diff --git a/CLAUDE.md b/CLAUDE.md
index 7d215be..2f68fde 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -93,10 +93,28 @@ everything else.
 
 ✅ **Required:** when a lookup that *must* succeed fails, emit a
 diagnostic via `self.diagnostics.addFmt(.err, span, "...", .{...})`
-and return the most clearly-broken sentinel the calling code can
-survive (e.g. `.void`, a `Ref.none`, or via a `?T` return that forces
-the caller to handle the null). Errors must surface to the user as
-text, not as a silently-corrupted size or alignment.
+and return a **dedicated, unmistakable sentinel** — one that can never
+be confused with a legitimate result — or a `?T` return that forces the
+caller to handle the null. Errors must surface to the user as text, not
+as a silently-corrupted size or alignment.
+
+❌ **`.void` is an UNACCEPTABLE sentinel for a failed *type* lookup.**
+`void` is a real, heavily-checked type (void returns, void params, "no
+value" markers), and pervasive `if (ty == .void) { skip / return-nothing }`
+checks would silently swallow the failure — trading one silent default
+(`.s64`) for another (`.void`) one layer down. The same objection rules
+out `noreturn` (diverging expressions) and any other load-bearing builtin.
+Instead, add a **distinct** `.unresolved`-style `TypeId` whose sole meaning
+is "resolution failed". A dedicated value (1) can't be mistaken for a real
+type by any downstream check, (2) makes the exhaustive `switch`es in the
+type table fail to compile until every site handles it (forcing coverage),
+and (3) can be a hard tripwire — `if (ty == .unresolved) @panic(...)` in
+codegen/emit guarantees it never silently ships. The one-time plumbing
+cost is exactly the trade this file mandates ("the field plumbing is a
+one-time cost; silent-clobber debugging is forever"). The same principle
+applies to non-type sentinels: prefer a `Ref.none`-style value that is
+distinct from every valid result, not a real one that "looks broken
+enough".
 
 If you find an existing default-return in the compiler that swallows
 a lookup failure, treat it as a discovered bug — file an issue per
diff --git a/src/ir/emit_llvm.zig b/src/ir/emit_llvm.zig
index 129a7e0..7ce5aae 100644
--- a/src/ir/emit_llvm.zig
+++ b/src/ir/emit_llvm.zig
@@ -4289,6 +4289,9 @@ pub const LLVMEmitter = struct {
             // Comptime-only: a pack is expanded to flat positional args before
             // codegen, so it must never reach LLVM type emission.
             .pack => @panic("pack type has no LLVM representation (comptime-only)"),
+            // Tripwire: a failed type resolution must have been diagnosed and
+            // aborted long before LLVM emission.
+            .unresolved => @panic("unresolved type reached LLVM emission — a type resolution failure was not diagnosed/aborted"),
         };
     }
 
diff --git a/src/ir/lower.zig b/src/ir/lower.zig
index 8b4e96b..671cd76 100644
--- a/src/ir/lower.zig
+++ b/src/ir/lower.zig
@@ -7101,13 +7101,22 @@ pub const Lowering = struct {
         // User params follow the ctx (optional) + env slots in `params`.
         const user_param_base: usize = (if (lambda_wants_ctx) @as(usize, 1) else 0) + 1;
         for (lam.params, 0..) |p, pi| {
-            var pty = self.resolveParamType(&p);
-            // Infer param type from target closure type if no annotation
-            if (p.type_expr.data == .inferred_type and target_closure_params != null) {
-                if (pi < target_closure_params.?.len) {
-                    pty = target_closure_params.?[pi];
+            const pty: TypeId = blk: {
+                // Unannotated lambda params take their type positionally from
+                // the target `Closure(T0, …)` signature. Resolve them here so
+                // `resolveParamType` (which would diagnose a missing annotation)
+                // is only called for params that carry one.
+                if (p.type_expr.data == .inferred_type) {
+                    if (target_closure_params != null and pi < target_closure_params.?.len) {
+                        break :blk target_closure_params.?[pi];
+                    }
+                    if (self.diagnostics) |d| {
+                        d.addFmt(.err, p.type_expr.span, "cannot infer type of lambda parameter '{s}'; annotate it or use the lambda where a closure type is expected", .{p.name});
+                    }
+                    break :blk .unresolved;
                 }
-            }
+                break :blk self.resolveParamType(&p);
+            };
             params.append(self.alloc, .{
                 .name = self.module.types.internString(p.name),
                 .ty = pty,
@@ -10743,6 +10752,18 @@ pub const Lowering = struct {
     }
 
     fn resolveParamType(self: *Lowering, p: *const ast.Param) TypeId {
+        // A plain value param with no annotation can only be typed from
+        // context (a lambda's target closure signature). When `resolveParamType`
+        // is reached for one, there is no such context — so it's a genuine
+        // "missing annotation" error, not an 8-byte-int guess. (Comptime/
+        // variadic pack params also carry `inferred_type` but get their types
+        // from per-call substitution, so they're exempt here.)
+        if (p.type_expr.data == .inferred_type and !p.is_comptime and !p.is_variadic and !p.is_pack) {
+            if (self.diagnostics) |d| {
+                d.addFmt(.err, p.type_expr.span, "parameter '{s}' has no type annotation", .{p.name});
+            }
+            return .unresolved;
+        }
         const declared_ty = self.resolveTypeWithBindings(p.type_expr);
         if (p.is_variadic) {
             // Two surface forms:
diff --git a/src/ir/type_bridge.zig b/src/ir/type_bridge.zig
index da13a03..8dba6b2 100644
--- a/src/ir/type_bridge.zig
+++ b/src/ir/type_bridge.zig
@@ -37,7 +37,14 @@ pub fn resolveAstType(node: ?*const Node, table: *TypeTable) TypeId {
         },
         .tuple_literal => |tl| resolveTupleLiteralAsType(&tl, table),
         .parameterized_type_expr => |pt| resolveParameterizedType(&pt, table),
-        .inferred_type => .s64, // inferred — default until we have type inference
+        // An unannotated param. Its type must be resolved from context
+        // (contextual closure typing, generic binding, or pack substitution)
+        // *before* reaching here; if it doesn't, returning a plausible `.s64`
+        // silently fabricates an 8-byte int (the classic silent-default trap).
+        // Return the dedicated `.unresolved` sentinel — never a legitimate
+        // type — so the omission surfaces; the lowering-side `resolveParamType`
+        // turns it into a real diagnostic.
+        .inferred_type => .unresolved,
         // Inline type declarations (used as field types)
         .enum_decl => |ed| resolveInlineEnum(&ed, table),
         .struct_decl => |sd| resolveInlineStruct(&sd, table),
diff --git a/src/ir/types.zig b/src/ir/types.zig
index f1c8e01..6a3d29b 100644
--- a/src/ir/types.zig
+++ b/src/ir/types.zig
@@ -5,8 +5,16 @@ const Allocator = std.mem.Allocator;
 // Opaque handle into the TypeTable. First 16 slots are reserved for builtins.
 
 pub const TypeId = enum(u32) {
-    // Builtin slots 0–15
-    void = 0,
+    // Builtin slots 0–17.
+    /// Resolution failed (e.g. an unannotated param whose type was never
+    /// inferred from context). A dedicated sentinel — never a legitimate
+    /// result — so downstream `== .void`/`== .s64` checks can't silently
+    /// swallow it. Must never reach codegen; sizeOf/toLLVMType panic on it.
+    ///
+    /// Deliberately slot 0: a zero-initialised or forgotten `TypeId` (the most
+    /// common accidental value) thus reads as `.unresolved` and trips the
+    /// tripwire, rather than silently masquerading as `.void`.
+    unresolved = 0,
     bool = 1,
     s8 = 2,
     s16 = 3,
@@ -23,9 +31,10 @@ pub const TypeId = enum(u32) {
     noreturn = 14,
     isize = 15,
     usize = 16,
-    _, // user-defined types start at 17
+    void = 17,
+    _, // user-defined types start at 18
 
-    pub const first_user: u32 = 17;
+    pub const first_user: u32 = 18;
 
     pub fn index(self: TypeId) u32 {
         return @intFromEnum(self);
@@ -73,6 +82,8 @@ pub const TypeInfo = union(enum) {
     noreturn,
     usize,
     isize,
+    /// Resolution-failure sentinel (see `TypeId.unresolved`).
+    unresolved,
 
     pub const StructInfo = struct {
         name: StringId,
@@ -280,9 +291,9 @@ pub const TypeTable = struct {
             .slice_arena = std.heap.ArenaAllocator.init(alloc),
         };
 
-        // Pre-populate builtin slots 0–15 (must match TypeId enum order)
+        // Pre-populate builtin slots 0–17 (must match TypeId enum order)
         const builtins = [_]TypeInfo{
-            .void, // 0
+            .unresolved, // 0: resolution-failure sentinel
             .bool, // 1
             .{ .signed = 8 }, // 2: s8
             .{ .signed = 16 }, // 3: s16
@@ -299,6 +310,7 @@ pub const TypeTable = struct {
             .noreturn, // 14
             .isize, // 15: isize (pointer-sized signed)
             .usize, // 16: usize (pointer-sized unsigned)
+            .void, // 17
         };
         for (&builtins) |info| {
             table.infos.append(alloc, info) catch unreachable;
@@ -477,6 +489,9 @@ pub const TypeTable = struct {
             // Comptime-only: a pack must be expanded to flat positional args
             // before codegen. Reaching runtime layout means a pack leaked.
             .pack => @panic("pack type has no runtime layout (comptime-only)"),
+            // Tripwire: a failed type resolution must have surfaced a
+            // diagnostic and aborted before any layout query.
+            .unresolved => @panic("unresolved type reached sizeOf — a type resolution failure was not diagnosed/aborted"),
         };
     }
 
@@ -674,6 +689,7 @@ pub const TypeTable = struct {
             .noreturn => "noreturn",
             .isize => "isize",
             .usize => "usize",
+            .unresolved => "<unresolved>",
             else => {
                 // User types — format from TypeInfo
                 const info = self.get(id);
@@ -813,7 +829,7 @@ fn hashTypeInfo(h: *std.hash.Wyhash, info: TypeInfo) void {
     switch (info) {
         .signed => |w| h.update(&.{w}),
         .unsigned => |w| h.update(&.{w}),
-        .f32, .f64, .void, .bool, .string, .any, .noreturn, .usize, .isize => {},
+        .f32, .f64, .void, .bool, .string, .any, .noreturn, .usize, .isize, .unresolved => {},
         .pointer => |p| h.update(std.mem.asBytes(&p.pointee)),
         .many_pointer => |p| h.update(std.mem.asBytes(&p.element)),
         .slice => |s| h.update(std.mem.asBytes(&s.element)),
@@ -866,7 +882,7 @@ fn typeInfoEql(a: TypeInfo, b: TypeInfo) bool {
     return switch (a) {
         .signed => |w| w == b.signed,
         .unsigned => |w| w == b.unsigned,
-        .f32, .f64, .void, .bool, .string, .any, .noreturn, .usize, .isize => true,
+        .f32, .f64, .void, .bool, .string, .any, .noreturn, .usize, .isize, .unresolved => true,
         .pointer => |p| p.pointee == b.pointer.pointee,
         .many_pointer => |p| p.element == b.many_pointer.element,
         .slice => |s| s.element == b.slice.element,
diff --git a/tests/expected/ffi-objc-call-06-sret-return.ir b/tests/expected/ffi-objc-call-06-sret-return.ir
index bccf047..261134f 100644
--- a/tests/expected/ffi-objc-call-06-sret-return.ir
+++ b/tests/expected/ffi-objc-call-06-sret-return.ir
@@ -10,7 +10,7 @@
 @str.3 = private unnamed_addr constant [2 x i8] c"0\00", align 1
 @str.4 = private unnamed_addr constant [4 x i8] c"<?>\00", align 1
 @str.5 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
-@tn.str = private constant [5 x i8] c"void\00"
+@tn.str = private constant [13 x i8] c"<unresolved>\00"
 @tn.str.6 = private constant [5 x i8] c"bool\00"
 @tn.str.7 = private constant [3 x i8] c"s8\00"
 @tn.str.8 = private constant [4 x i8] c"s16\00"
@@ -27,268 +27,269 @@
 @tn.str.19 = private constant [9 x i8] c"noreturn\00"
 @tn.str.20 = private constant [6 x i8] c"isize\00"
 @tn.str.21 = private constant [6 x i8] c"usize\00"
-@tn.str.22 = private constant [6 x i8] c"*void\00"
-@tn.str.23 = private constant [10 x i8] c"Allocator\00"
-@tn.str.24 = private constant [11 x i8] c"CAllocator\00"
-@tn.str.25 = private constant [12 x i8] c"*CAllocator\00"
-@tn.str.26 = private constant [4 x i8] c"GPA\00"
-@tn.str.27 = private constant [5 x i8] c"*GPA\00"
-@tn.str.28 = private constant [11 x i8] c"ArenaChunk\00"
-@tn.str.29 = private constant [12 x i8] c"*ArenaChunk\00"
-@tn.str.30 = private constant [6 x i8] c"Arena\00"
-@tn.str.31 = private constant [7 x i8] c"*Arena\00"
-@tn.str.32 = private constant [6 x i8] c"[*]u8\00"
-@tn.str.33 = private constant [9 x i8] c"BufAlloc\00"
-@tn.str.34 = private constant [10 x i8] c"*BufAlloc\00"
-@tn.str.35 = private constant [18 x i8] c"TrackingAllocator\00"
-@tn.str.36 = private constant [19 x i8] c"*TrackingAllocator\00"
-@tn.str.37 = private constant [8 x i8] c"Context\00"
-@tn.str.38 = private constant [9 x i8] c"[]string\00"
-@tn.str.39 = private constant [16 x i8] c"OperatingSystem\00"
-@tn.str.40 = private constant [13 x i8] c"Architecture\00"
-@tn.str.41 = private constant [13 x i8] c"BuildOptions\00"
-@tn.str.42 = private constant [11 x i8] c"() -> bool\00"
-@tn.str.43 = private constant [10 x i8] c"Closure()\00"
-@tn.str.44 = private constant [7 x i8] c"Triple\00"
-@tn.str.45 = private constant [13 x i8] c"**CAllocator\00"
-@tn.str.46 = private constant [5 x i8] c"*s64\00"
-@tn.str.47 = private constant [7 x i8] c"**void\00"
-@tn.str.48 = private constant [6 x i8] c"*bool\00"
-@tn.str.49 = private constant [8 x i8] c"*string\00"
-@tn.str.50 = private constant [6 x i8] c"[]Any\00"
-@tn.str.51 = private constant [5 x i8] c"*Any\00"
-@tn.str.52 = private constant [7 x i8] c"[1]Any\00"
-@tn.str.53 = private constant [8 x i8] c"*[1]Any\00"
-@tn.str.54 = private constant [7 x i8] c"*[]Any\00"
-@tn.str.55 = private constant [4 x i8] c"*u8\00"
-@tn.str.56 = private constant [8 x i8] c"*Triple\00"
-@tn.str.57 = private constant [7 x i8] c"[3]Any\00"
-@tn.str.58 = private constant [8 x i8] c"*[3]Any\00"
-@tn.str.59 = private constant [5 x i8] c"*f64\00"
-@tn.str.60 = private constant [11 x i8] c"*Allocator\00"
-@tn.str.61 = private constant [9 x i8] c"*Context\00"
-@tn.str.62 = private constant [14 x i8] c"*BuildOptions\00"
-@tn.str.63 = private constant [17 x i8] c"*OperatingSystem\00"
-@tn.str.64 = private constant [14 x i8] c"*Architecture\00"
-@tn.str.65 = private constant [10 x i8] c"*[]string\00"
-@tn.str.66 = private constant [6 x i8] c"**GPA\00"
-@tn.str.67 = private constant [13 x i8] c"**ArenaChunk\00"
-@tn.str.68 = private constant [8 x i8] c"**Arena\00"
-@tn.str.69 = private constant [7 x i8] c"*[*]u8\00"
-@tn.str.70 = private constant [11 x i8] c"**BufAlloc\00"
-@tn.str.71 = private constant [20 x i8] c"**TrackingAllocator\00"
-@tn.str.72 = private constant [14 x i8] c"***CAllocator\00"
-@tn.str.73 = private constant [6 x i8] c"**s64\00"
-@tn.str.74 = private constant [8 x i8] c"***void\00"
-@tn.str.75 = private constant [7 x i8] c"**bool\00"
-@tn.str.76 = private constant [9 x i8] c"**string\00"
-@tn.str.77 = private constant [6 x i8] c"**Any\00"
-@tn.str.78 = private constant [9 x i8] c"**[1]Any\00"
-@tn.str.79 = private constant [8 x i8] c"**[]Any\00"
-@tn.str.80 = private constant [5 x i8] c"**u8\00"
-@tn.str.81 = private constant [9 x i8] c"**Triple\00"
-@tn.str.82 = private constant [9 x i8] c"**[3]Any\00"
-@__sx_type_names = private constant [78 x { ptr, i64 }] [{ ptr, i64 } { ptr @tn.str, i64 4 }, { ptr, i64 } { ptr @tn.str.6, i64 4 }, { ptr, i64 } { ptr @tn.str.7, i64 2 }, { ptr, i64 } { ptr @tn.str.8, i64 3 }, { ptr, i64 } { ptr @tn.str.9, i64 3 }, { ptr, i64 } { ptr @tn.str.10, i64 3 }, { ptr, i64 } { ptr @tn.str.11, i64 2 }, { ptr, i64 } { ptr @tn.str.12, i64 3 }, { ptr, i64 } { ptr @tn.str.13, i64 3 }, { ptr, i64 } { ptr @tn.str.14, i64 3 }, { ptr, i64 } { ptr @tn.str.15, i64 3 }, { ptr, i64 } { ptr @tn.str.16, i64 3 }, { ptr, i64 } { ptr @tn.str.17, i64 6 }, { ptr, i64 } { ptr @tn.str.18, i64 3 }, { ptr, i64 } { ptr @tn.str.19, i64 8 }, { ptr, i64 } { ptr @tn.str.20, i64 5 }, { ptr, i64 } { ptr @tn.str.21, i64 5 }, { ptr, i64 } { ptr @tn.str.22, i64 5 }, { ptr, i64 } { ptr @tn.str.23, i64 9 }, { ptr, i64 } { ptr @tn.str.24, i64 10 }, { ptr, i64 } { ptr @tn.str.25, i64 11 }, { ptr, i64 } { ptr @tn.str.26, i64 3 }, { ptr, i64 } { ptr @tn.str.27, i64 4 }, { ptr, i64 } { ptr @tn.str.28, i64 10 }, { ptr, i64 } { ptr @tn.str.29, i64 11 }, { ptr, i64 } { ptr @tn.str.30, i64 5 }, { ptr, i64 } { ptr @tn.str.31, i64 6 }, { ptr, i64 } { ptr @tn.str.32, i64 5 }, { ptr, i64 } { ptr @tn.str.33, i64 8 }, { ptr, i64 } { ptr @tn.str.34, i64 9 }, { ptr, i64 } { ptr @tn.str.35, i64 17 }, { ptr, i64 } { ptr @tn.str.36, i64 18 }, { ptr, i64 } { ptr @tn.str.37, i64 7 }, { ptr, i64 } { ptr @tn.str.38, i64 8 }, { ptr, i64 } { ptr @tn.str.39, i64 15 }, { ptr, i64 } { ptr @tn.str.40, i64 12 }, { ptr, i64 } { ptr @tn.str.41, i64 12 }, { ptr, i64 } { ptr @tn.str.42, i64 10 }, { ptr, i64 } { ptr @tn.str.43, i64 9 }, { ptr, i64 } { ptr @tn.str.44, i64 6 }, { ptr, i64 } { ptr @tn.str.45, i64 12 }, { ptr, i64 } { ptr @tn.str.46, i64 4 }, { ptr, i64 } { ptr @tn.str.47, i64 6 }, { ptr, i64 } { ptr @tn.str.48, i64 5 }, { ptr, i64 } { ptr @tn.str.49, i64 7 }, { ptr, i64 } { ptr @tn.str.50, i64 5 }, { ptr, i64 } { ptr @tn.str.51, i64 4 }, { ptr, i64 } { ptr @tn.str.52, i64 6 }, { ptr, i64 } { ptr @tn.str.53, i64 7 }, { ptr, i64 } { ptr @tn.str.54, i64 6 }, { ptr, i64 } { ptr @tn.str.55, i64 3 }, { ptr, i64 } { ptr @tn.str.56, i64 7 }, { ptr, i64 } { ptr @tn.str.57, i64 6 }, { ptr, i64 } { ptr @tn.str.58, i64 7 }, { ptr, i64 } { ptr @tn.str.59, i64 4 }, { ptr, i64 } { ptr @tn.str.60, i64 10 }, { ptr, i64 } { ptr @tn.str.61, i64 8 }, { ptr, i64 } { ptr @tn.str.62, i64 13 }, { ptr, i64 } { ptr @tn.str.63, i64 16 }, { ptr, i64 } { ptr @tn.str.64, i64 13 }, { ptr, i64 } { ptr @tn.str.65, i64 9 }, { ptr, i64 } { ptr @tn.str.66, i64 5 }, { ptr, i64 } { ptr @tn.str.67, i64 12 }, { ptr, i64 } { ptr @tn.str.68, i64 7 }, { ptr, i64 } { ptr @tn.str.69, i64 6 }, { ptr, i64 } { ptr @tn.str.70, i64 10 }, { ptr, i64 } { ptr @tn.str.71, i64 19 }, { ptr, i64 } { ptr @tn.str.72, i64 13 }, { ptr, i64 } { ptr @tn.str.73, i64 5 }, { ptr, i64 } { ptr @tn.str.74, i64 7 }, { ptr, i64 } { ptr @tn.str.75, i64 6 }, { ptr, i64 } { ptr @tn.str.76, i64 8 }, { ptr, i64 } { ptr @tn.str.77, i64 5 }, { ptr, i64 } { ptr @tn.str.78, i64 8 }, { ptr, i64 } { ptr @tn.str.79, i64 7 }, { ptr, i64 } { ptr @tn.str.80, i64 4 }, { ptr, i64 } { ptr @tn.str.81, i64 8 }, { ptr, i64 } { ptr @tn.str.82, i64 8 }]
-@str.83 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
+@tn.str.22 = private constant [5 x i8] c"void\00"
+@tn.str.23 = private constant [6 x i8] c"*void\00"
+@tn.str.24 = private constant [10 x i8] c"Allocator\00"
+@tn.str.25 = private constant [11 x i8] c"CAllocator\00"
+@tn.str.26 = private constant [12 x i8] c"*CAllocator\00"
+@tn.str.27 = private constant [4 x i8] c"GPA\00"
+@tn.str.28 = private constant [5 x i8] c"*GPA\00"
+@tn.str.29 = private constant [11 x i8] c"ArenaChunk\00"
+@tn.str.30 = private constant [12 x i8] c"*ArenaChunk\00"
+@tn.str.31 = private constant [6 x i8] c"Arena\00"
+@tn.str.32 = private constant [7 x i8] c"*Arena\00"
+@tn.str.33 = private constant [6 x i8] c"[*]u8\00"
+@tn.str.34 = private constant [9 x i8] c"BufAlloc\00"
+@tn.str.35 = private constant [10 x i8] c"*BufAlloc\00"
+@tn.str.36 = private constant [18 x i8] c"TrackingAllocator\00"
+@tn.str.37 = private constant [19 x i8] c"*TrackingAllocator\00"
+@tn.str.38 = private constant [8 x i8] c"Context\00"
+@tn.str.39 = private constant [9 x i8] c"[]string\00"
+@tn.str.40 = private constant [16 x i8] c"OperatingSystem\00"
+@tn.str.41 = private constant [13 x i8] c"Architecture\00"
+@tn.str.42 = private constant [13 x i8] c"BuildOptions\00"
+@tn.str.43 = private constant [11 x i8] c"() -> bool\00"
+@tn.str.44 = private constant [10 x i8] c"Closure()\00"
+@tn.str.45 = private constant [7 x i8] c"Triple\00"
+@tn.str.46 = private constant [13 x i8] c"**CAllocator\00"
+@tn.str.47 = private constant [5 x i8] c"*s64\00"
+@tn.str.48 = private constant [7 x i8] c"**void\00"
+@tn.str.49 = private constant [6 x i8] c"*bool\00"
+@tn.str.50 = private constant [8 x i8] c"*string\00"
+@tn.str.51 = private constant [6 x i8] c"[]Any\00"
+@tn.str.52 = private constant [5 x i8] c"*Any\00"
+@tn.str.53 = private constant [7 x i8] c"[1]Any\00"
+@tn.str.54 = private constant [8 x i8] c"*[1]Any\00"
+@tn.str.55 = private constant [7 x i8] c"*[]Any\00"
+@tn.str.56 = private constant [4 x i8] c"*u8\00"
+@tn.str.57 = private constant [8 x i8] c"*Triple\00"
+@tn.str.58 = private constant [7 x i8] c"[3]Any\00"
+@tn.str.59 = private constant [8 x i8] c"*[3]Any\00"
+@tn.str.60 = private constant [5 x i8] c"*f64\00"
+@tn.str.61 = private constant [11 x i8] c"*Allocator\00"
+@tn.str.62 = private constant [9 x i8] c"*Context\00"
+@tn.str.63 = private constant [14 x i8] c"*BuildOptions\00"
+@tn.str.64 = private constant [17 x i8] c"*OperatingSystem\00"
+@tn.str.65 = private constant [14 x i8] c"*Architecture\00"
+@tn.str.66 = private constant [10 x i8] c"*[]string\00"
+@tn.str.67 = private constant [6 x i8] c"**GPA\00"
+@tn.str.68 = private constant [13 x i8] c"**ArenaChunk\00"
+@tn.str.69 = private constant [8 x i8] c"**Arena\00"
+@tn.str.70 = private constant [7 x i8] c"*[*]u8\00"
+@tn.str.71 = private constant [11 x i8] c"**BufAlloc\00"
+@tn.str.72 = private constant [20 x i8] c"**TrackingAllocator\00"
+@tn.str.73 = private constant [14 x i8] c"***CAllocator\00"
+@tn.str.74 = private constant [6 x i8] c"**s64\00"
+@tn.str.75 = private constant [8 x i8] c"***void\00"
+@tn.str.76 = private constant [7 x i8] c"**bool\00"
+@tn.str.77 = private constant [9 x i8] c"**string\00"
+@tn.str.78 = private constant [6 x i8] c"**Any\00"
+@tn.str.79 = private constant [9 x i8] c"**[1]Any\00"
+@tn.str.80 = private constant [8 x i8] c"**[]Any\00"
+@tn.str.81 = private constant [5 x i8] c"**u8\00"
+@tn.str.82 = private constant [9 x i8] c"**Triple\00"
+@tn.str.83 = private constant [9 x i8] c"**[3]Any\00"
+@__sx_type_names = private constant [79 x { ptr, i64 }] [{ ptr, i64 } { ptr @tn.str, i64 12 }, { ptr, i64 } { ptr @tn.str.6, i64 4 }, { ptr, i64 } { ptr @tn.str.7, i64 2 }, { ptr, i64 } { ptr @tn.str.8, i64 3 }, { ptr, i64 } { ptr @tn.str.9, i64 3 }, { ptr, i64 } { ptr @tn.str.10, i64 3 }, { ptr, i64 } { ptr @tn.str.11, i64 2 }, { ptr, i64 } { ptr @tn.str.12, i64 3 }, { ptr, i64 } { ptr @tn.str.13, i64 3 }, { ptr, i64 } { ptr @tn.str.14, i64 3 }, { ptr, i64 } { ptr @tn.str.15, i64 3 }, { ptr, i64 } { ptr @tn.str.16, i64 3 }, { ptr, i64 } { ptr @tn.str.17, i64 6 }, { ptr, i64 } { ptr @tn.str.18, i64 3 }, { ptr, i64 } { ptr @tn.str.19, i64 8 }, { ptr, i64 } { ptr @tn.str.20, i64 5 }, { ptr, i64 } { ptr @tn.str.21, i64 5 }, { ptr, i64 } { ptr @tn.str.22, i64 4 }, { ptr, i64 } { ptr @tn.str.23, i64 5 }, { ptr, i64 } { ptr @tn.str.24, i64 9 }, { ptr, i64 } { ptr @tn.str.25, i64 10 }, { ptr, i64 } { ptr @tn.str.26, i64 11 }, { ptr, i64 } { ptr @tn.str.27, i64 3 }, { ptr, i64 } { ptr @tn.str.28, i64 4 }, { ptr, i64 } { ptr @tn.str.29, i64 10 }, { ptr, i64 } { ptr @tn.str.30, i64 11 }, { ptr, i64 } { ptr @tn.str.31, i64 5 }, { ptr, i64 } { ptr @tn.str.32, i64 6 }, { ptr, i64 } { ptr @tn.str.33, i64 5 }, { ptr, i64 } { ptr @tn.str.34, i64 8 }, { ptr, i64 } { ptr @tn.str.35, i64 9 }, { ptr, i64 } { ptr @tn.str.36, i64 17 }, { ptr, i64 } { ptr @tn.str.37, i64 18 }, { ptr, i64 } { ptr @tn.str.38, i64 7 }, { ptr, i64 } { ptr @tn.str.39, i64 8 }, { ptr, i64 } { ptr @tn.str.40, i64 15 }, { ptr, i64 } { ptr @tn.str.41, i64 12 }, { ptr, i64 } { ptr @tn.str.42, i64 12 }, { ptr, i64 } { ptr @tn.str.43, i64 10 }, { ptr, i64 } { ptr @tn.str.44, i64 9 }, { ptr, i64 } { ptr @tn.str.45, i64 6 }, { ptr, i64 } { ptr @tn.str.46, i64 12 }, { ptr, i64 } { ptr @tn.str.47, i64 4 }, { ptr, i64 } { ptr @tn.str.48, i64 6 }, { ptr, i64 } { ptr @tn.str.49, i64 5 }, { ptr, i64 } { ptr @tn.str.50, i64 7 }, { ptr, i64 } { ptr @tn.str.51, i64 5 }, { ptr, i64 } { ptr @tn.str.52, i64 4 }, { ptr, i64 } { ptr @tn.str.53, i64 6 }, { ptr, i64 } { ptr @tn.str.54, i64 7 }, { ptr, i64 } { ptr @tn.str.55, i64 6 }, { ptr, i64 } { ptr @tn.str.56, i64 3 }, { ptr, i64 } { ptr @tn.str.57, i64 7 }, { ptr, i64 } { ptr @tn.str.58, i64 6 }, { ptr, i64 } { ptr @tn.str.59, i64 7 }, { ptr, i64 } { ptr @tn.str.60, i64 4 }, { ptr, i64 } { ptr @tn.str.61, i64 10 }, { ptr, i64 } { ptr @tn.str.62, i64 8 }, { ptr, i64 } { ptr @tn.str.63, i64 13 }, { ptr, i64 } { ptr @tn.str.64, i64 16 }, { ptr, i64 } { ptr @tn.str.65, i64 13 }, { ptr, i64 } { ptr @tn.str.66, i64 9 }, { ptr, i64 } { ptr @tn.str.67, i64 5 }, { ptr, i64 } { ptr @tn.str.68, i64 12 }, { ptr, i64 } { ptr @tn.str.69, i64 7 }, { ptr, i64 } { ptr @tn.str.70, i64 6 }, { ptr, i64 } { ptr @tn.str.71, i64 10 }, { ptr, i64 } { ptr @tn.str.72, i64 19 }, { ptr, i64 } { ptr @tn.str.73, i64 13 }, { ptr, i64 } { ptr @tn.str.74, i64 5 }, { ptr, i64 } { ptr @tn.str.75, i64 7 }, { ptr, i64 } { ptr @tn.str.76, i64 6 }, { ptr, i64 } { ptr @tn.str.77, i64 8 }, { ptr, i64 } { ptr @tn.str.78, i64 5 }, { ptr, i64 } { ptr @tn.str.79, i64 8 }, { ptr, i64 } { ptr @tn.str.80, i64 7 }, { ptr, i64 } { ptr @tn.str.81, i64 4 }, { ptr, i64 } { ptr @tn.str.82, i64 8 }, { ptr, i64 } { ptr @tn.str.83, i64 8 }]
 @str.84 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
 @str.85 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
 @str.86 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
 @str.87 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
-@str.88 = private unnamed_addr constant [15 x i8] c"result := \22\22; \00", align 1
-@str.89 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
-@str.90 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@str.91 = private unnamed_addr constant [5 x i8] c")); \00", align 1
-@str.92 = private unnamed_addr constant [44 x i8] c"result = concat(result, any_to_string(args[\00", align 1
-@str.93 = private unnamed_addr constant [6 x i8] c"])); \00", align 1
-@str.94 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
-@str.95 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@str.96 = private unnamed_addr constant [5 x i8] c")); \00", align 1
-@str.97 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
-@str.98 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@str.99 = private unnamed_addr constant [5 x i8] c")); \00", align 1
-@str.100 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
-@str.101 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@str.102 = private unnamed_addr constant [5 x i8] c")); \00", align 1
-@str.103 = private unnamed_addr constant [9 x i8] c"NSObject\00", align 1
-@str.104 = private unnamed_addr constant [14 x i8] c"SxTripleProbe\00", align 1
-@str.105 = private unnamed_addr constant [12 x i8] c"tripleValue\00", align 1
-@str.106 = private unnamed_addr constant [15 x i8] c"{Triple=qqq}@:\00", align 1
-@str.107 = private unnamed_addr constant [16 x i8] c"addMethod = {}\0A\00", align 1
-@str.108 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
-@str.109 = private unnamed_addr constant [16 x i8] c"addMethod = {}\0A\00", align 1
-@str.110 = private unnamed_addr constant [23 x i8] c"triple = ({}, {}, {})\0A\00", align 1
-@str.111 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
-@str.112 = private unnamed_addr constant [23 x i8] c"triple = ({}, {}, {})\0A\00", align 1
-@str.113 = private unnamed_addr constant [10 x i8] c"Allocator\00", align 1
-@str.114 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.115 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.116 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@str.88 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
+@str.89 = private unnamed_addr constant [15 x i8] c"result := \22\22; \00", align 1
+@str.90 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
+@str.91 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@str.92 = private unnamed_addr constant [5 x i8] c")); \00", align 1
+@str.93 = private unnamed_addr constant [44 x i8] c"result = concat(result, any_to_string(args[\00", align 1
+@str.94 = private unnamed_addr constant [6 x i8] c"])); \00", align 1
+@str.95 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
+@str.96 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@str.97 = private unnamed_addr constant [5 x i8] c")); \00", align 1
+@str.98 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
+@str.99 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@str.100 = private unnamed_addr constant [5 x i8] c")); \00", align 1
+@str.101 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
+@str.102 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@str.103 = private unnamed_addr constant [5 x i8] c")); \00", align 1
+@str.104 = private unnamed_addr constant [9 x i8] c"NSObject\00", align 1
+@str.105 = private unnamed_addr constant [14 x i8] c"SxTripleProbe\00", align 1
+@str.106 = private unnamed_addr constant [12 x i8] c"tripleValue\00", align 1
+@str.107 = private unnamed_addr constant [15 x i8] c"{Triple=qqq}@:\00", align 1
+@str.108 = private unnamed_addr constant [16 x i8] c"addMethod = {}\0A\00", align 1
+@str.109 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
+@str.110 = private unnamed_addr constant [16 x i8] c"addMethod = {}\0A\00", align 1
+@str.111 = private unnamed_addr constant [23 x i8] c"triple = ({}, {}, {})\0A\00", align 1
+@str.112 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
+@str.113 = private unnamed_addr constant [23 x i8] c"triple = ({}, {}, {})\0A\00", align 1
+@str.114 = private unnamed_addr constant [10 x i8] c"Allocator\00", align 1
+@str.115 = private unnamed_addr constant [2 x i8] c"{\00", align 1
+@str.116 = private unnamed_addr constant [2 x i8] c"}\00", align 1
+@str.117 = private unnamed_addr constant [3 x i8] c", \00", align 1
 @fld.str = private constant [4 x i8] c"ctx\00"
-@fld.str.117 = private constant [6 x i8] c"alloc\00"
-@fld.str.118 = private constant [8 x i8] c"dealloc\00"
-@field_names = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str, i64 3 }, { ptr, i64 } { ptr @fld.str.117, i64 5 }, { ptr, i64 } { ptr @fld.str.118, i64 7 }]
-@str.119 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.120 = private unnamed_addr constant [11 x i8] c"CAllocator\00", align 1
-@str.121 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.122 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.123 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@field_names.124 = private constant [0 x { ptr, i64 }] zeroinitializer
-@str.125 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.126 = private unnamed_addr constant [4 x i8] c"GPA\00", align 1
-@str.127 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.128 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.129 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@fld.str.130 = private constant [12 x i8] c"alloc_count\00"
-@field_names.131 = private constant [1 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.130, i64 11 }]
-@str.132 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.133 = private unnamed_addr constant [11 x i8] c"ArenaChunk\00", align 1
-@str.134 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.135 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.136 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@fld.str.137 = private constant [5 x i8] c"next\00"
-@fld.str.138 = private constant [4 x i8] c"cap\00"
-@field_names.139 = private constant [2 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.137, i64 4 }, { ptr, i64 } { ptr @fld.str.138, i64 3 }]
-@str.140 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.141 = private unnamed_addr constant [6 x i8] c"Arena\00", align 1
-@str.142 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.143 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.144 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@fld.str.145 = private constant [6 x i8] c"first\00"
-@fld.str.146 = private constant [10 x i8] c"end_index\00"
-@fld.str.147 = private constant [7 x i8] c"parent\00"
-@field_names.148 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.145, i64 5 }, { ptr, i64 } { ptr @fld.str.146, i64 9 }, { ptr, i64 } { ptr @fld.str.147, i64 6 }]
-@str.149 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.150 = private unnamed_addr constant [9 x i8] c"BufAlloc\00", align 1
-@str.151 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.152 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.153 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@fld.str.154 = private constant [4 x i8] c"buf\00"
-@fld.str.155 = private constant [4 x i8] c"len\00"
-@fld.str.156 = private constant [4 x i8] c"pos\00"
-@field_names.157 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.154, i64 3 }, { ptr, i64 } { ptr @fld.str.155, i64 3 }, { ptr, i64 } { ptr @fld.str.156, i64 3 }]
-@str.158 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.159 = private unnamed_addr constant [18 x i8] c"TrackingAllocator\00", align 1
-@str.160 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.161 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.162 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@fld.str.163 = private constant [7 x i8] c"parent\00"
-@fld.str.164 = private constant [12 x i8] c"alloc_count\00"
-@fld.str.165 = private constant [14 x i8] c"dealloc_count\00"
-@fld.str.166 = private constant [18 x i8] c"total_alloc_bytes\00"
-@field_names.167 = private constant [4 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.163, i64 6 }, { ptr, i64 } { ptr @fld.str.164, i64 11 }, { ptr, i64 } { ptr @fld.str.165, i64 13 }, { ptr, i64 } { ptr @fld.str.166, i64 17 }]
-@str.168 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.169 = private unnamed_addr constant [8 x i8] c"Context\00", align 1
-@str.170 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.171 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.172 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@fld.str.173 = private constant [10 x i8] c"allocator\00"
-@fld.str.174 = private constant [5 x i8] c"data\00"
-@field_names.175 = private constant [2 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.173, i64 9 }, { ptr, i64 } { ptr @fld.str.174, i64 4 }]
-@str.176 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.177 = private unnamed_addr constant [13 x i8] c"BuildOptions\00", align 1
-@str.178 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.179 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.180 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@field_names.181 = private constant [0 x { ptr, i64 }] zeroinitializer
-@str.182 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.183 = private unnamed_addr constant [7 x i8] c"Triple\00", align 1
-@str.184 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.185 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.186 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@fld.str.187 = private constant [2 x i8] c"a\00"
-@fld.str.188 = private constant [2 x i8] c"b\00"
-@fld.str.189 = private constant [2 x i8] c"c\00"
-@field_names.190 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.187, i64 1 }, { ptr, i64 } { ptr @fld.str.188, i64 1 }, { ptr, i64 } { ptr @fld.str.189, i64 1 }]
-@str.191 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.192 = private unnamed_addr constant [2 x i8] c".\00", align 1
-@fld.str.193 = private constant [6 x i8] c"macos\00"
-@fld.str.194 = private constant [6 x i8] c"linux\00"
-@fld.str.195 = private constant [8 x i8] c"windows\00"
-@fld.str.196 = private constant [5 x i8] c"wasm\00"
-@fld.str.197 = private constant [4 x i8] c"ios\00"
-@fld.str.198 = private constant [8 x i8] c"android\00"
-@fld.str.199 = private constant [8 x i8] c"unknown\00"
-@field_names.200 = private constant [7 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.193, i64 5 }, { ptr, i64 } { ptr @fld.str.194, i64 5 }, { ptr, i64 } { ptr @fld.str.195, i64 7 }, { ptr, i64 } { ptr @fld.str.196, i64 4 }, { ptr, i64 } { ptr @fld.str.197, i64 3 }, { ptr, i64 } { ptr @fld.str.198, i64 7 }, { ptr, i64 } { ptr @fld.str.199, i64 7 }]
-@str.201 = private unnamed_addr constant [2 x i8] c"(\00", align 1
-@str.202 = private unnamed_addr constant [2 x i8] c")\00", align 1
-@str.203 = private unnamed_addr constant [2 x i8] c".\00", align 1
-@fld.str.204 = private constant [8 x i8] c"aarch64\00"
-@fld.str.205 = private constant [7 x i8] c"x86_64\00"
-@fld.str.206 = private constant [7 x i8] c"wasm32\00"
-@fld.str.207 = private constant [7 x i8] c"wasm64\00"
-@fld.str.208 = private constant [8 x i8] c"unknown\00"
-@field_names.209 = private constant [5 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.204, i64 7 }, { ptr, i64 } { ptr @fld.str.205, i64 6 }, { ptr, i64 } { ptr @fld.str.206, i64 6 }, { ptr, i64 } { ptr @fld.str.207, i64 6 }, { ptr, i64 } { ptr @fld.str.208, i64 7 }]
-@str.210 = private unnamed_addr constant [2 x i8] c"(\00", align 1
-@str.211 = private unnamed_addr constant [2 x i8] c")\00", align 1
-@str.212 = private unnamed_addr constant [2 x i8] c"[\00", align 1
-@str.213 = private unnamed_addr constant [2 x i8] c"]\00", align 1
-@str.214 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@str.215 = private unnamed_addr constant [2 x i8] c"[\00", align 1
-@str.216 = private unnamed_addr constant [2 x i8] c"]\00", align 1
-@str.217 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@str.218 = private unnamed_addr constant [2 x i8] c"[\00", align 1
-@str.219 = private unnamed_addr constant [2 x i8] c"]\00", align 1
-@str.220 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@str.221 = private unnamed_addr constant [2 x i8] c"[\00", align 1
-@str.222 = private unnamed_addr constant [2 x i8] c"]\00", align 1
-@str.223 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@str.224 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.225 = private unnamed_addr constant [6 x i8] c"*void\00", align 1
-@str.226 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.227 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.228 = private unnamed_addr constant [12 x i8] c"*CAllocator\00", align 1
-@str.229 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.230 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.231 = private unnamed_addr constant [5 x i8] c"*GPA\00", align 1
-@str.232 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.233 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.234 = private unnamed_addr constant [12 x i8] c"*ArenaChunk\00", align 1
-@str.235 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.236 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.237 = private unnamed_addr constant [7 x i8] c"*Arena\00", align 1
-@str.238 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.239 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.240 = private unnamed_addr constant [6 x i8] c"[*]u8\00", align 1
-@str.241 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.242 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.243 = private unnamed_addr constant [10 x i8] c"*BufAlloc\00", align 1
-@str.244 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.245 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.246 = private unnamed_addr constant [19 x i8] c"*TrackingAllocator\00", align 1
-@str.247 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.248 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.249 = private unnamed_addr constant [13 x i8] c"**CAllocator\00", align 1
-@str.250 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.251 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.252 = private unnamed_addr constant [5 x i8] c"*s64\00", align 1
-@str.253 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.254 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.255 = private unnamed_addr constant [7 x i8] c"**void\00", align 1
-@str.256 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.257 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.258 = private unnamed_addr constant [6 x i8] c"*bool\00", align 1
-@str.259 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.260 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.261 = private unnamed_addr constant [8 x i8] c"*string\00", align 1
-@str.262 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.263 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.264 = private unnamed_addr constant [5 x i8] c"*Any\00", align 1
-@str.265 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.266 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.267 = private unnamed_addr constant [8 x i8] c"*[1]Any\00", align 1
-@str.268 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.269 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.270 = private unnamed_addr constant [7 x i8] c"*[]Any\00", align 1
-@str.271 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.272 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.273 = private unnamed_addr constant [4 x i8] c"*u8\00", align 1
-@str.274 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.275 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.276 = private unnamed_addr constant [8 x i8] c"*Triple\00", align 1
-@str.277 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.278 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.279 = private unnamed_addr constant [8 x i8] c"*[3]Any\00", align 1
-@str.280 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@fld.str.118 = private constant [6 x i8] c"alloc\00"
+@fld.str.119 = private constant [8 x i8] c"dealloc\00"
+@field_names = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str, i64 3 }, { ptr, i64 } { ptr @fld.str.118, i64 5 }, { ptr, i64 } { ptr @fld.str.119, i64 7 }]
+@str.120 = private unnamed_addr constant [3 x i8] c": \00", align 1
+@str.121 = private unnamed_addr constant [11 x i8] c"CAllocator\00", align 1
+@str.122 = private unnamed_addr constant [2 x i8] c"{\00", align 1
+@str.123 = private unnamed_addr constant [2 x i8] c"}\00", align 1
+@str.124 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@field_names.125 = private constant [0 x { ptr, i64 }] zeroinitializer
+@str.126 = private unnamed_addr constant [3 x i8] c": \00", align 1
+@str.127 = private unnamed_addr constant [4 x i8] c"GPA\00", align 1
+@str.128 = private unnamed_addr constant [2 x i8] c"{\00", align 1
+@str.129 = private unnamed_addr constant [2 x i8] c"}\00", align 1
+@str.130 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@fld.str.131 = private constant [12 x i8] c"alloc_count\00"
+@field_names.132 = private constant [1 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.131, i64 11 }]
+@str.133 = private unnamed_addr constant [3 x i8] c": \00", align 1
+@str.134 = private unnamed_addr constant [11 x i8] c"ArenaChunk\00", align 1
+@str.135 = private unnamed_addr constant [2 x i8] c"{\00", align 1
+@str.136 = private unnamed_addr constant [2 x i8] c"}\00", align 1
+@str.137 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@fld.str.138 = private constant [5 x i8] c"next\00"
+@fld.str.139 = private constant [4 x i8] c"cap\00"
+@field_names.140 = private constant [2 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.138, i64 4 }, { ptr, i64 } { ptr @fld.str.139, i64 3 }]
+@str.141 = private unnamed_addr constant [3 x i8] c": \00", align 1
+@str.142 = private unnamed_addr constant [6 x i8] c"Arena\00", align 1
+@str.143 = private unnamed_addr constant [2 x i8] c"{\00", align 1
+@str.144 = private unnamed_addr constant [2 x i8] c"}\00", align 1
+@str.145 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@fld.str.146 = private constant [6 x i8] c"first\00"
+@fld.str.147 = private constant [10 x i8] c"end_index\00"
+@fld.str.148 = private constant [7 x i8] c"parent\00"
+@field_names.149 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.146, i64 5 }, { ptr, i64 } { ptr @fld.str.147, i64 9 }, { ptr, i64 } { ptr @fld.str.148, i64 6 }]
+@str.150 = private unnamed_addr constant [3 x i8] c": \00", align 1
+@str.151 = private unnamed_addr constant [9 x i8] c"BufAlloc\00", align 1
+@str.152 = private unnamed_addr constant [2 x i8] c"{\00", align 1
+@str.153 = private unnamed_addr constant [2 x i8] c"}\00", align 1
+@str.154 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@fld.str.155 = private constant [4 x i8] c"buf\00"
+@fld.str.156 = private constant [4 x i8] c"len\00"
+@fld.str.157 = private constant [4 x i8] c"pos\00"
+@field_names.158 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.155, i64 3 }, { ptr, i64 } { ptr @fld.str.156, i64 3 }, { ptr, i64 } { ptr @fld.str.157, i64 3 }]
+@str.159 = private unnamed_addr constant [3 x i8] c": \00", align 1
+@str.160 = private unnamed_addr constant [18 x i8] c"TrackingAllocator\00", align 1
+@str.161 = private unnamed_addr constant [2 x i8] c"{\00", align 1
+@str.162 = private unnamed_addr constant [2 x i8] c"}\00", align 1
+@str.163 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@fld.str.164 = private constant [7 x i8] c"parent\00"
+@fld.str.165 = private constant [12 x i8] c"alloc_count\00"
+@fld.str.166 = private constant [14 x i8] c"dealloc_count\00"
+@fld.str.167 = private constant [18 x i8] c"total_alloc_bytes\00"
+@field_names.168 = private constant [4 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.164, i64 6 }, { ptr, i64 } { ptr @fld.str.165, i64 11 }, { ptr, i64 } { ptr @fld.str.166, i64 13 }, { ptr, i64 } { ptr @fld.str.167, i64 17 }]
+@str.169 = private unnamed_addr constant [3 x i8] c": \00", align 1
+@str.170 = private unnamed_addr constant [8 x i8] c"Context\00", align 1
+@str.171 = private unnamed_addr constant [2 x i8] c"{\00", align 1
+@str.172 = private unnamed_addr constant [2 x i8] c"}\00", align 1
+@str.173 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@fld.str.174 = private constant [10 x i8] c"allocator\00"
+@fld.str.175 = private constant [5 x i8] c"data\00"
+@field_names.176 = private constant [2 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.174, i64 9 }, { ptr, i64 } { ptr @fld.str.175, i64 4 }]
+@str.177 = private unnamed_addr constant [3 x i8] c": \00", align 1
+@str.178 = private unnamed_addr constant [13 x i8] c"BuildOptions\00", align 1
+@str.179 = private unnamed_addr constant [2 x i8] c"{\00", align 1
+@str.180 = private unnamed_addr constant [2 x i8] c"}\00", align 1
+@str.181 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@field_names.182 = private constant [0 x { ptr, i64 }] zeroinitializer
+@str.183 = private unnamed_addr constant [3 x i8] c": \00", align 1
+@str.184 = private unnamed_addr constant [7 x i8] c"Triple\00", align 1
+@str.185 = private unnamed_addr constant [2 x i8] c"{\00", align 1
+@str.186 = private unnamed_addr constant [2 x i8] c"}\00", align 1
+@str.187 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@fld.str.188 = private constant [2 x i8] c"a\00"
+@fld.str.189 = private constant [2 x i8] c"b\00"
+@fld.str.190 = private constant [2 x i8] c"c\00"
+@field_names.191 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.188, i64 1 }, { ptr, i64 } { ptr @fld.str.189, i64 1 }, { ptr, i64 } { ptr @fld.str.190, i64 1 }]
+@str.192 = private unnamed_addr constant [3 x i8] c": \00", align 1
+@str.193 = private unnamed_addr constant [2 x i8] c".\00", align 1
+@fld.str.194 = private constant [6 x i8] c"macos\00"
+@fld.str.195 = private constant [6 x i8] c"linux\00"
+@fld.str.196 = private constant [8 x i8] c"windows\00"
+@fld.str.197 = private constant [5 x i8] c"wasm\00"
+@fld.str.198 = private constant [4 x i8] c"ios\00"
+@fld.str.199 = private constant [8 x i8] c"android\00"
+@fld.str.200 = private constant [8 x i8] c"unknown\00"
+@field_names.201 = private constant [7 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.194, i64 5 }, { ptr, i64 } { ptr @fld.str.195, i64 5 }, { ptr, i64 } { ptr @fld.str.196, i64 7 }, { ptr, i64 } { ptr @fld.str.197, i64 4 }, { ptr, i64 } { ptr @fld.str.198, i64 3 }, { ptr, i64 } { ptr @fld.str.199, i64 7 }, { ptr, i64 } { ptr @fld.str.200, i64 7 }]
+@str.202 = private unnamed_addr constant [2 x i8] c"(\00", align 1
+@str.203 = private unnamed_addr constant [2 x i8] c")\00", align 1
+@str.204 = private unnamed_addr constant [2 x i8] c".\00", align 1
+@fld.str.205 = private constant [8 x i8] c"aarch64\00"
+@fld.str.206 = private constant [7 x i8] c"x86_64\00"
+@fld.str.207 = private constant [7 x i8] c"wasm32\00"
+@fld.str.208 = private constant [7 x i8] c"wasm64\00"
+@fld.str.209 = private constant [8 x i8] c"unknown\00"
+@field_names.210 = private constant [5 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.205, i64 7 }, { ptr, i64 } { ptr @fld.str.206, i64 6 }, { ptr, i64 } { ptr @fld.str.207, i64 6 }, { ptr, i64 } { ptr @fld.str.208, i64 6 }, { ptr, i64 } { ptr @fld.str.209, i64 7 }]
+@str.211 = private unnamed_addr constant [2 x i8] c"(\00", align 1
+@str.212 = private unnamed_addr constant [2 x i8] c")\00", align 1
+@str.213 = private unnamed_addr constant [2 x i8] c"[\00", align 1
+@str.214 = private unnamed_addr constant [2 x i8] c"]\00", align 1
+@str.215 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@str.216 = private unnamed_addr constant [2 x i8] c"[\00", align 1
+@str.217 = private unnamed_addr constant [2 x i8] c"]\00", align 1
+@str.218 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@str.219 = private unnamed_addr constant [2 x i8] c"[\00", align 1
+@str.220 = private unnamed_addr constant [2 x i8] c"]\00", align 1
+@str.221 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@str.222 = private unnamed_addr constant [2 x i8] c"[\00", align 1
+@str.223 = private unnamed_addr constant [2 x i8] c"]\00", align 1
+@str.224 = private unnamed_addr constant [3 x i8] c", \00", align 1
+@str.225 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.226 = private unnamed_addr constant [6 x i8] c"*void\00", align 1
+@str.227 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.228 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.229 = private unnamed_addr constant [12 x i8] c"*CAllocator\00", align 1
+@str.230 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.231 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.232 = private unnamed_addr constant [5 x i8] c"*GPA\00", align 1
+@str.233 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.234 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.235 = private unnamed_addr constant [12 x i8] c"*ArenaChunk\00", align 1
+@str.236 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.237 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.238 = private unnamed_addr constant [7 x i8] c"*Arena\00", align 1
+@str.239 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.240 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.241 = private unnamed_addr constant [6 x i8] c"[*]u8\00", align 1
+@str.242 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.243 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.244 = private unnamed_addr constant [10 x i8] c"*BufAlloc\00", align 1
+@str.245 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.246 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.247 = private unnamed_addr constant [19 x i8] c"*TrackingAllocator\00", align 1
+@str.248 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.249 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.250 = private unnamed_addr constant [13 x i8] c"**CAllocator\00", align 1
+@str.251 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.252 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.253 = private unnamed_addr constant [5 x i8] c"*s64\00", align 1
+@str.254 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.255 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.256 = private unnamed_addr constant [7 x i8] c"**void\00", align 1
+@str.257 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.258 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.259 = private unnamed_addr constant [6 x i8] c"*bool\00", align 1
+@str.260 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.261 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.262 = private unnamed_addr constant [8 x i8] c"*string\00", align 1
+@str.263 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.264 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.265 = private unnamed_addr constant [5 x i8] c"*Any\00", align 1
+@str.266 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.267 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.268 = private unnamed_addr constant [8 x i8] c"*[1]Any\00", align 1
+@str.269 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.270 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.271 = private unnamed_addr constant [7 x i8] c"*[]Any\00", align 1
+@str.272 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.273 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.274 = private unnamed_addr constant [4 x i8] c"*u8\00", align 1
+@str.275 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.276 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.277 = private unnamed_addr constant [8 x i8] c"*Triple\00", align 1
+@str.278 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
+@str.279 = private unnamed_addr constant [5 x i8] c"null\00", align 1
+@str.280 = private unnamed_addr constant [8 x i8] c"*[3]Any\00", align 1
+@str.281 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
 @OBJC_METH_VAR_NAME_ = private unnamed_addr constant [12 x i8] c"tripleValue\00"
 @llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @__sx_objc_selector_init, ptr null }]
 
@@ -960,7 +961,7 @@ entry:
   %loadN = load { i64, i64 }, ptr %allocaN, align 8
   %ua.raw = extractvalue { i64, i64 } %loadN, 1
   switch i64 %ua.raw, label %match.unr.52 [
-    i64 0, label %match.arm.39
+    i64 17, label %match.arm.39
     i64 2, label %match.arm.40
     i64 3, label %match.arm.40
     i64 4, label %match.arm.40
@@ -975,41 +976,41 @@ entry:
     i64 1, label %match.arm.42
     i64 10, label %match.arm.43
     i64 11, label %match.arm.43
-    i64 18, label %match.arm.44
     i64 19, label %match.arm.44
-    i64 21, label %match.arm.44
-    i64 23, label %match.arm.44
-    i64 25, label %match.arm.44
-    i64 28, label %match.arm.44
-    i64 30, label %match.arm.44
-    i64 32, label %match.arm.44
-    i64 36, label %match.arm.44
-    i64 39, label %match.arm.44
-    i64 34, label %match.arm.45
+    i64 20, label %match.arm.44
+    i64 22, label %match.arm.44
+    i64 24, label %match.arm.44
+    i64 26, label %match.arm.44
+    i64 29, label %match.arm.44
+    i64 31, label %match.arm.44
+    i64 33, label %match.arm.44
+    i64 37, label %match.arm.44
+    i64 40, label %match.arm.44
     i64 35, label %match.arm.45
-    i64 47, label %match.arm.47
-    i64 52, label %match.arm.47
-    i64 33, label %match.arm.48
-    i64 45, label %match.arm.48
-    i64 17, label %match.arm.49
-    i64 20, label %match.arm.49
-    i64 22, label %match.arm.49
-    i64 24, label %match.arm.49
-    i64 26, label %match.arm.49
+    i64 36, label %match.arm.45
+    i64 48, label %match.arm.47
+    i64 53, label %match.arm.47
+    i64 34, label %match.arm.48
+    i64 46, label %match.arm.48
+    i64 18, label %match.arm.49
+    i64 21, label %match.arm.49
+    i64 23, label %match.arm.49
+    i64 25, label %match.arm.49
     i64 27, label %match.arm.49
-    i64 29, label %match.arm.49
-    i64 31, label %match.arm.49
-    i64 40, label %match.arm.49
+    i64 28, label %match.arm.49
+    i64 30, label %match.arm.49
+    i64 32, label %match.arm.49
     i64 41, label %match.arm.49
     i64 42, label %match.arm.49
     i64 43, label %match.arm.49
     i64 44, label %match.arm.49
-    i64 46, label %match.arm.49
-    i64 48, label %match.arm.49
+    i64 45, label %match.arm.49
+    i64 47, label %match.arm.49
     i64 49, label %match.arm.49
     i64 50, label %match.arm.49
     i64 51, label %match.arm.49
-    i64 53, label %match.arm.49
+    i64 52, label %match.arm.49
+    i64 54, label %match.arm.49
     i64 13, label %match.arm.51
   ]
 
@@ -1060,16 +1061,16 @@ match.arm.44:                                     ; preds = %entry, %entry, %ent
   %loadN = load { i64, i64 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   switch i64 %ua.raw18, label %dispatch.default.70 [
-    i64 18, label %dispatch.case.71
-    i64 19, label %dispatch.case.72
-    i64 21, label %dispatch.case.73
-    i64 23, label %dispatch.case.74
-    i64 25, label %dispatch.case.75
-    i64 28, label %dispatch.case.76
-    i64 30, label %dispatch.case.77
-    i64 32, label %dispatch.case.78
-    i64 36, label %dispatch.case.79
-    i64 39, label %dispatch.case.80
+    i64 19, label %dispatch.case.71
+    i64 20, label %dispatch.case.72
+    i64 22, label %dispatch.case.73
+    i64 24, label %dispatch.case.74
+    i64 26, label %dispatch.case.75
+    i64 29, label %dispatch.case.76
+    i64 31, label %dispatch.case.77
+    i64 33, label %dispatch.case.78
+    i64 37, label %dispatch.case.79
+    i64 40, label %dispatch.case.80
   ]
 
 match.arm.45:                                     ; preds = %entry, %entry
@@ -1078,8 +1079,8 @@ match.arm.45:                                     ; preds = %entry, %entry
   %loadN = load { i64, i64 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   switch i64 %ua.raw22, label %dispatch.default.132 [
-    i64 34, label %dispatch.case.133
-    i64 35, label %dispatch.case.134
+    i64 35, label %dispatch.case.133
+    i64 36, label %dispatch.case.134
   ]
 
 match.arm.46:                                     ; No predecessors!
@@ -1091,8 +1092,8 @@ match.arm.47:                                     ; preds = %entry, %entry
   %loadN = load { i64, i64 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   switch i64 %ua.raw26, label %dispatch.default.140 [
-    i64 47, label %dispatch.case.141
-    i64 52, label %dispatch.case.142
+    i64 48, label %dispatch.case.141
+    i64 53, label %dispatch.case.142
   ]
 
 match.arm.48:                                     ; preds = %entry, %entry
@@ -1101,8 +1102,8 @@ match.arm.48:                                     ; preds = %entry, %entry
   %loadN = load { i64, i64 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   switch i64 %ua.raw30, label %dispatch.default.154 [
-    i64 33, label %dispatch.case.155
-    i64 45, label %dispatch.case.156
+    i64 34, label %dispatch.case.155
+    i64 46, label %dispatch.case.156
   ]
 
 match.arm.49:                                     ; preds = %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry
@@ -1111,25 +1112,25 @@ match.arm.49:                                     ; preds = %entry, %entry, %ent
   %loadN = load { i64, i64 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   switch i64 %ua.raw34, label %dispatch.default.168 [
-    i64 17, label %dispatch.case.169
-    i64 20, label %dispatch.case.170
-    i64 22, label %dispatch.case.171
-    i64 24, label %dispatch.case.172
-    i64 26, label %dispatch.case.173
-    i64 27, label %dispatch.case.174
-    i64 29, label %dispatch.case.175
-    i64 31, label %dispatch.case.176
-    i64 40, label %dispatch.case.177
-    i64 41, label %dispatch.case.178
-    i64 42, label %dispatch.case.179
-    i64 43, label %dispatch.case.180
-    i64 44, label %dispatch.case.181
-    i64 46, label %dispatch.case.182
-    i64 48, label %dispatch.case.183
-    i64 49, label %dispatch.case.184
-    i64 50, label %dispatch.case.185
-    i64 51, label %dispatch.case.186
-    i64 53, label %dispatch.case.187
+    i64 18, label %dispatch.case.169
+    i64 21, label %dispatch.case.170
+    i64 23, label %dispatch.case.171
+    i64 25, label %dispatch.case.172
+    i64 27, label %dispatch.case.173
+    i64 28, label %dispatch.case.174
+    i64 30, label %dispatch.case.175
+    i64 32, label %dispatch.case.176
+    i64 41, label %dispatch.case.177
+    i64 42, label %dispatch.case.178
+    i64 43, label %dispatch.case.179
+    i64 44, label %dispatch.case.180
+    i64 45, label %dispatch.case.181
+    i64 47, label %dispatch.case.182
+    i64 49, label %dispatch.case.183
+    i64 50, label %dispatch.case.184
+    i64 51, label %dispatch.case.185
+    i64 52, label %dispatch.case.186
+    i64 54, label %dispatch.case.187
   ]
 
 match.arm.50:                                     ; No predecessors!
@@ -1138,7 +1139,7 @@ match.arm.50:                                     ; No predecessors!
 match.arm.51:                                     ; preds = %entry
   %loadN = load { i64, i64 }, ptr %alloca, align 8
   %tn.tid = extractvalue { i64, i64 } %loadN, 1
-  %tn.gep = getelementptr inbounds [78 x { ptr, i64 }], ptr @__sx_type_names, i64 0, i64 %tn.tid
+  %tn.gep = getelementptr inbounds [79 x { ptr, i64 }], ptr @__sx_type_names, i64 0, i64 %tn.tid
   %tn.load = load { ptr, i64 }, ptr %tn.gep, align 8
   store { ptr, i64 } %tn.load, ptr %allocaN, align 8
   br label %match.merge.38
@@ -1172,7 +1173,7 @@ dispatch.merge.69:                                ; preds = %dispatch.case.80, %
   br label %match.merge.38
 
 dispatch.default.70:                              ; preds = %match.arm.44
-  store { ptr, i64 } { ptr @str.83, i64 0 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.84, i64 0 }, ptr %allocaN, align 8
   br label %dispatch.merge.69
 
 dispatch.case.71:                                 ; preds = %match.arm.44
@@ -1261,7 +1262,7 @@ dispatch.merge.131:                               ; preds = %dispatch.case.134,
   br label %match.merge.38
 
 dispatch.default.132:                             ; preds = %match.arm.45
-  store { ptr, i64 } { ptr @str.84, i64 0 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.85, i64 0 }, ptr %allocaN, align 8
   br label %dispatch.merge.131
 
 dispatch.case.133:                                ; preds = %match.arm.45
@@ -1282,7 +1283,7 @@ dispatch.merge.139:                               ; preds = %dispatch.case.142,
   br label %match.merge.38
 
 dispatch.default.140:                             ; preds = %match.arm.47
-  store { ptr, i64 } { ptr @str.85, i64 0 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.86, i64 0 }, ptr %allocaN, align 8
   br label %dispatch.merge.139
 
 dispatch.case.141:                                ; preds = %match.arm.47
@@ -1307,7 +1308,7 @@ dispatch.merge.153:                               ; preds = %dispatch.case.156,
   br label %match.merge.38
 
 dispatch.default.154:                             ; preds = %match.arm.48
-  store { ptr, i64 } { ptr @str.86, i64 0 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.87, i64 0 }, ptr %allocaN, align 8
   br label %dispatch.merge.153
 
 dispatch.case.155:                                ; preds = %match.arm.48
@@ -1332,7 +1333,7 @@ dispatch.merge.167:                               ; preds = %dispatch.case.187,
   br label %match.merge.38
 
 dispatch.default.168:                             ; preds = %match.arm.49
-  store { ptr, i64 } { ptr @str.87, i64 0 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.88, i64 0 }, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.169:                                ; preds = %match.arm.49
@@ -1475,7 +1476,7 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %1, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  store { ptr, i64 } { ptr @str.88, i64 14 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.89, i64 14 }, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
   store i64 0, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -1571,7 +1572,7 @@ if.merge.11:                                      ; preds = %if.merge.26, %if.me
 
 if.then.12:                                       ; preds = %if.then.9
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.89, i64 36 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.90, i64 36 })
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
@@ -1579,7 +1580,7 @@ if.then.12:                                       ; preds = %if.then.9
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.90, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.91, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
@@ -1589,13 +1590,13 @@ if.then.12:                                       ; preds = %if.then.9
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.91, i64 4 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.92, i64 4 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.13
 
 if.merge.13:                                      ; preds = %if.then.12, %if.then.9
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.92, i64 43 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.93, i64 43 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
@@ -1603,7 +1604,7 @@ if.merge.13:                                      ; preds = %if.then.12, %if.the
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.93, i64 5 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.94, i64 5 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
   %addN = add i64 %loadN, 1
@@ -1617,7 +1618,7 @@ if.merge.13:                                      ; preds = %if.then.12, %if.the
 
 if.then.24:                                       ; preds = %if.else.10
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.94, i64 36 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.95, i64 36 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
@@ -1625,7 +1626,7 @@ if.then.24:                                       ; preds = %if.else.10
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.95, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.96, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
@@ -1636,7 +1637,7 @@ if.then.24:                                       ; preds = %if.else.10
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.96, i64 4 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.97, i64 4 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
   %addN = add i64 %loadN, 2
@@ -1693,7 +1694,7 @@ if.merge.32:                                      ; preds = %if.merge.35, %if.el
 
 if.then.33:                                       ; preds = %if.then.30
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.97, i64 36 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.98, i64 36 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
@@ -1701,7 +1702,7 @@ if.then.33:                                       ; preds = %if.then.30
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.98, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.99, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
@@ -1712,7 +1713,7 @@ if.then.33:                                       ; preds = %if.then.30
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.99, i64 4 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.100, i64 4 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
   %addN = add i64 %loadN, 2
@@ -1732,7 +1733,7 @@ if.merge.35:                                      ; preds = %if.else.34, %if.the
 
 if.then.36:                                       ; preds = %while.exit.2
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.100, i64 36 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.101, i64 36 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
@@ -1740,7 +1741,7 @@ if.then.36:                                       ; preds = %while.exit.2
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.101, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.102, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %alloca, align 8
@@ -1751,7 +1752,7 @@ if.then.36:                                       ; preds = %while.exit.2
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.102, i64 4 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.103, i64 4 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.37
 
@@ -1943,19 +1944,19 @@ entry:
 define i32 @main() #0 {
 entry:
   call void @__sx_objc_selector_init()
-  %call = call ptr @objc_getClass(ptr @str.103)
+  %call = call ptr @objc_getClass(ptr @str.104)
   %alloca = alloca ptr, align 8
   store ptr %call, ptr %alloca, align 8
   %load = load ptr, ptr %alloca, align 8
-  %callN = call ptr @objc_allocateClassPair(ptr %load, ptr @str.104, i64 0)
+  %callN = call ptr @objc_allocateClassPair(ptr %load, ptr @str.105, i64 0)
   %allocaN = alloca ptr, align 8
   store ptr %callN, ptr %allocaN, align 8
-  %callN = call ptr @sel_registerName(ptr @str.105)
+  %callN = call ptr @sel_registerName(ptr @str.106)
   %allocaN = alloca ptr, align 8
   store ptr %callN, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %callN = call i1 @class_addMethod(ptr %loadN, ptr %loadN, ptr @triple_imp, ptr @str.106)
+  %callN = call i1 @class_addMethod(ptr %loadN, ptr %loadN, ptr @triple_imp, ptr @str.107)
   %allocaN = alloca i1, align 1
   store i1 %callN, ptr %allocaN, align 1
   %loadN = load i1, ptr %allocaN, align 1
@@ -2001,7 +2002,7 @@ entry:
 define internal void @print__ct_s7f3aff1506f207ab__pack_bool(ptr %0, i1 %1) #0 {
 entry:
   %alloca = alloca { ptr, i64 }, align 8
-  store { ptr, i64 } { ptr @str.107, i64 15 }, ptr %alloca, align 8
+  store { ptr, i64 } { ptr @str.108, i64 15 }, ptr %alloca, align 8
   %allocaN = alloca i1, align 1
   store i1 %1, ptr %allocaN, align 1
   %allocaN = alloca [1 x { i64, i64 }], align 8
@@ -2017,7 +2018,7 @@ entry:
   %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  store { ptr, i64 } { ptr @str.108, i64 0 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.109, i64 0 }, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %alloca, align 8
   %call = call { ptr, i64 } @substr(ptr %0, { ptr, i64 } %loadN, i64 0, i64 12)
@@ -2045,7 +2046,7 @@ entry:
 ; Function Attrs: nounwind
 define internal { ptr, i64 } @__insert_0(ptr %0) #0 {
 entry:
-  %call = call { ptr, i64 } @build_format(ptr %0, { ptr, i64 } { ptr @str.109, i64 15 })
+  %call = call { ptr, i64 } @build_format(ptr %0, { ptr, i64 } { ptr @str.110, i64 15 })
   ret { ptr, i64 } %call
 }
 
@@ -2053,7 +2054,7 @@ entry:
 define internal void @print__ct_s337be2777a405332__pack_s64_s64_s64(ptr %0, i64 %1, i64 %2, i64 %3) #0 {
 entry:
   %alloca = alloca { ptr, i64 }, align 8
-  store { ptr, i64 } { ptr @str.110, i64 22 }, ptr %alloca, align 8
+  store { ptr, i64 } { ptr @str.111, i64 22 }, ptr %alloca, align 8
   %allocaN = alloca i64, align 8
   store i64 %1, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2080,7 +2081,7 @@ entry:
   %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 3, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  store { ptr, i64 } { ptr @str.111, i64 0 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.112, i64 0 }, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %alloca, align 8
   %call = call { ptr, i64 } @substr(ptr %0, { ptr, i64 } %loadN, i64 0, i64 10)
@@ -2129,7 +2130,7 @@ entry:
 ; Function Attrs: nounwind
 define internal { ptr, i64 } @__insert_1(ptr %0) #0 {
 entry:
-  %call = call { ptr, i64 } @build_format(ptr %0, { ptr, i64 } { ptr @str.112, i64 22 })
+  %call = call { ptr, i64 } @build_format(ptr %0, { ptr, i64 } { ptr @str.113, i64 22 })
   ret { ptr, i64 } %call
 }
 
@@ -2138,7 +2139,7 @@ define internal { ptr, i64 } @struct_to_string__Allocator(ptr %0, { ptr, ptr, pt
 entry:
   %alloca = alloca { ptr, ptr, ptr }, align 8
   store { ptr, ptr, ptr } %1, ptr %alloca, align 8
-  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.113, i64 9 }, { ptr, i64 } { ptr @str.114, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.114, i64 9 }, { ptr, i64 } { ptr @str.115, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2157,12 +2158,12 @@ while.body.82:                                    ; preds = %while.hdr.81
 
 while.exit.83:                                    ; preds = %while.hdr.81
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.115, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.116, i64 1 })
   ret { ptr, i64 } %callN
 
 if.then.84:                                       ; preds = %while.body.82
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.116, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.117, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.85
 
@@ -2174,7 +2175,7 @@ if.merge.85:                                      ; preds = %if.then.84, %while.
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.119, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.120, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load { ptr, ptr, ptr }, ptr %alloca, align 8
@@ -2201,19 +2202,19 @@ fv.default:                                       ; preds = %if.merge.85
 fv.case:                                          ; preds = %if.merge.85
   %fv.field = extractvalue { ptr, ptr, ptr } %loadN, 0
   %pNi = ptrtoint ptr %fv.field to i64
-  %fv.val = insertvalue { i64, i64 } { i64 17, i64 undef }, i64 %pNi, 1
+  %fv.val = insertvalue { i64, i64 } { i64 18, i64 undef }, i64 %pNi, 1
   br label %fv.merge
 
 fv.case17:                                        ; preds = %if.merge.85
   %fv.field18 = extractvalue { ptr, ptr, ptr } %loadN, 1
   %pNi19 = ptrtoint ptr %fv.field18 to i64
-  %fv.val20 = insertvalue { i64, i64 } { i64 17, i64 undef }, i64 %pNi19, 1
+  %fv.val20 = insertvalue { i64, i64 } { i64 18, i64 undef }, i64 %pNi19, 1
   br label %fv.merge
 
 fv.case21:                                        ; preds = %if.merge.85
   %fv.field22 = extractvalue { ptr, ptr, ptr } %loadN, 2
   %pNi23 = ptrtoint ptr %fv.field22 to i64
-  %fv.val24 = insertvalue { i64, i64 } { i64 17, i64 undef }, i64 %pNi23, 1
+  %fv.val24 = insertvalue { i64, i64 } { i64 18, i64 undef }, i64 %pNi23, 1
   br label %fv.merge
 }
 
@@ -2222,7 +2223,7 @@ define internal { ptr, i64 } @struct_to_string__CAllocator(ptr %0, {} %1) #0 {
 entry:
   %alloca = alloca {}, align 8
   store {} %1, ptr %alloca, align 1
-  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.120, i64 10 }, { ptr, i64 } { ptr @str.121, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.121, i64 10 }, { ptr, i64 } { ptr @str.122, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2241,29 +2242,29 @@ while.body.87:                                    ; preds = %while.hdr.86
 
 while.exit.88:                                    ; preds = %while.hdr.86
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.122, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.123, i64 1 })
   ret { ptr, i64 } %callN
 
 if.then.89:                                       ; preds = %while.body.87
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.123, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.124, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.90
 
 if.merge.90:                                      ; preds = %if.then.89, %while.body.87
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %fn.gep = getelementptr inbounds [0 x { ptr, i64 }], ptr @field_names.124, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [0 x { ptr, i64 }], ptr @field_names.125, i64 0, i64 %loadN
   %fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.125, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.126, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load {}, ptr %alloca, align 1
   %loadN = load i64, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } zeroinitializer)
+  %callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } { i64 17, i64 0 })
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
@@ -2277,7 +2278,7 @@ define internal { ptr, i64 } @struct_to_string__GPA(ptr %0, { i64 } %1) #0 {
 entry:
   %alloca = alloca { i64 }, align 8
   store { i64 } %1, ptr %alloca, align 8
-  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.126, i64 3 }, { ptr, i64 } { ptr @str.127, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.127, i64 3 }, { ptr, i64 } { ptr @str.128, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2296,24 +2297,24 @@ while.body.92:                                    ; preds = %while.hdr.91
 
 while.exit.93:                                    ; preds = %while.hdr.91
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.128, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.129, i64 1 })
   ret { ptr, i64 } %callN
 
 if.then.94:                                       ; preds = %while.body.92
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.129, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.130, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.95
 
 if.merge.95:                                      ; preds = %if.then.94, %while.body.92
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %fn.gep = getelementptr inbounds [1 x { ptr, i64 }], ptr @field_names.131, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [1 x { ptr, i64 }], ptr @field_names.132, i64 0, i64 %loadN
   %fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.132, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.133, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load { i64 }, ptr %alloca, align 8
@@ -2346,7 +2347,7 @@ define internal { ptr, i64 } @struct_to_string__ArenaChunk(ptr %0, { ptr, i64 }
 entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %1, ptr %alloca, align 8
-  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.133, i64 10 }, { ptr, i64 } { ptr @str.134, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.134, i64 10 }, { ptr, i64 } { ptr @str.135, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2365,24 +2366,24 @@ while.body.97:                                    ; preds = %while.hdr.96
 
 while.exit.98:                                    ; preds = %while.hdr.96
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.135, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.136, i64 1 })
   ret { ptr, i64 } %callN
 
 if.then.99:                                       ; preds = %while.body.97
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.136, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.137, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.100
 
 if.merge.100:                                     ; preds = %if.then.99, %while.body.97
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %fn.gep = getelementptr inbounds [2 x { ptr, i64 }], ptr @field_names.139, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [2 x { ptr, i64 }], ptr @field_names.140, i64 0, i64 %loadN
   %fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.140, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.141, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %alloca, align 8
@@ -2408,7 +2409,7 @@ fv.default:                                       ; preds = %if.merge.100
 fv.case:                                          ; preds = %if.merge.100
   %fv.field = extractvalue { ptr, i64 } %loadN, 0
   %pNi = ptrtoint ptr %fv.field to i64
-  %fv.val = insertvalue { i64, i64 } { i64 24, i64 undef }, i64 %pNi, 1
+  %fv.val = insertvalue { i64, i64 } { i64 25, i64 undef }, i64 %pNi, 1
   br label %fv.merge
 
 fv.case17:                                        ; preds = %if.merge.100
@@ -2422,7 +2423,7 @@ define internal { ptr, i64 } @struct_to_string__Arena(ptr %0, { ptr, i64, { ptr,
 entry:
   %alloca = alloca { ptr, i64, { ptr, ptr, ptr } }, align 8
   store { ptr, i64, { ptr, ptr, ptr } } %1, ptr %alloca, align 8
-  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.141, i64 5 }, { ptr, i64 } { ptr @str.142, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.142, i64 5 }, { ptr, i64 } { ptr @str.143, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2441,24 +2442,24 @@ while.body.102:                                   ; preds = %while.hdr.101
 
 while.exit.103:                                   ; preds = %while.hdr.101
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.143, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.144, i64 1 })
   ret { ptr, i64 } %callN
 
 if.then.104:                                      ; preds = %while.body.102
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.144, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.145, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.105
 
 if.merge.105:                                     ; preds = %if.then.104, %while.body.102
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %fn.gep = getelementptr inbounds [3 x { ptr, i64 }], ptr @field_names.148, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [3 x { ptr, i64 }], ptr @field_names.149, i64 0, i64 %loadN
   %fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.149, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.150, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load { ptr, i64, { ptr, ptr, ptr } }, ptr %alloca, align 8
@@ -2485,7 +2486,7 @@ fv.default:                                       ; preds = %if.merge.105
 fv.case:                                          ; preds = %if.merge.105
   %fv.field = extractvalue { ptr, i64, { ptr, ptr, ptr } } %loadN, 0
   %pNi = ptrtoint ptr %fv.field to i64
-  %fv.val = insertvalue { i64, i64 } { i64 24, i64 undef }, i64 %pNi, 1
+  %fv.val = insertvalue { i64, i64 } { i64 25, i64 undef }, i64 %pNi, 1
   br label %fv.merge
 
 fv.case17:                                        ; preds = %if.merge.105
@@ -2498,7 +2499,7 @@ fv.case20:                                        ; preds = %if.merge.105
   %ba.tmp = alloca { ptr, ptr, ptr }, align 8
   store { ptr, ptr, ptr } %fv.field21, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
-  %fv.val22 = insertvalue { i64, i64 } { i64 18, i64 undef }, i64 %ba.p2i, 1
+  %fv.val22 = insertvalue { i64, i64 } { i64 19, i64 undef }, i64 %ba.p2i, 1
   br label %fv.merge
 }
 
@@ -2507,7 +2508,7 @@ define internal { ptr, i64 } @struct_to_string__BufAlloc(ptr %0, { ptr, i64, i64
 entry:
   %alloca = alloca { ptr, i64, i64 }, align 8
   store { ptr, i64, i64 } %1, ptr %alloca, align 8
-  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.150, i64 8 }, { ptr, i64 } { ptr @str.151, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.151, i64 8 }, { ptr, i64 } { ptr @str.152, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2526,24 +2527,24 @@ while.body.107:                                   ; preds = %while.hdr.106
 
 while.exit.108:                                   ; preds = %while.hdr.106
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.152, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.153, i64 1 })
   ret { ptr, i64 } %callN
 
 if.then.109:                                      ; preds = %while.body.107
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.153, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.154, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.110
 
 if.merge.110:                                     ; preds = %if.then.109, %while.body.107
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %fn.gep = getelementptr inbounds [3 x { ptr, i64 }], ptr @field_names.157, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [3 x { ptr, i64 }], ptr @field_names.158, i64 0, i64 %loadN
   %fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.158, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.159, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load { ptr, i64, i64 }, ptr %alloca, align 8
@@ -2570,7 +2571,7 @@ fv.default:                                       ; preds = %if.merge.110
 fv.case:                                          ; preds = %if.merge.110
   %fv.field = extractvalue { ptr, i64, i64 } %loadN, 0
   %pNi = ptrtoint ptr %fv.field to i64
-  %fv.val = insertvalue { i64, i64 } { i64 27, i64 undef }, i64 %pNi, 1
+  %fv.val = insertvalue { i64, i64 } { i64 28, i64 undef }, i64 %pNi, 1
   br label %fv.merge
 
 fv.case17:                                        ; preds = %if.merge.110
@@ -2589,7 +2590,7 @@ define internal { ptr, i64 } @struct_to_string__TrackingAllocator(ptr %0, { { pt
 entry:
   %alloca = alloca { { ptr, ptr, ptr }, i64, i64, i64 }, align 8
   store { { ptr, ptr, ptr }, i64, i64, i64 } %1, ptr %alloca, align 8
-  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.159, i64 17 }, { ptr, i64 } { ptr @str.160, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.160, i64 17 }, { ptr, i64 } { ptr @str.161, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2608,24 +2609,24 @@ while.body.112:                                   ; preds = %while.hdr.111
 
 while.exit.113:                                   ; preds = %while.hdr.111
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.161, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.162, i64 1 })
   ret { ptr, i64 } %callN
 
 if.then.114:                                      ; preds = %while.body.112
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.162, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.163, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.115
 
 if.merge.115:                                     ; preds = %if.then.114, %while.body.112
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %fn.gep = getelementptr inbounds [4 x { ptr, i64 }], ptr @field_names.167, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [4 x { ptr, i64 }], ptr @field_names.168, i64 0, i64 %loadN
   %fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.168, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.169, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load { { ptr, ptr, ptr }, i64, i64, i64 }, ptr %alloca, align 8
@@ -2655,7 +2656,7 @@ fv.case:                                          ; preds = %if.merge.115
   %ba.tmp = alloca { ptr, ptr, ptr }, align 8
   store { ptr, ptr, ptr } %fv.field, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
-  %fv.val = insertvalue { i64, i64 } { i64 18, i64 undef }, i64 %ba.p2i, 1
+  %fv.val = insertvalue { i64, i64 } { i64 19, i64 undef }, i64 %ba.p2i, 1
   br label %fv.merge
 
 fv.case17:                                        ; preds = %if.merge.115
@@ -2679,7 +2680,7 @@ define internal { ptr, i64 } @struct_to_string__Context(ptr %0, { { ptr, ptr, pt
 entry:
   %alloca = alloca { { ptr, ptr, ptr }, ptr }, align 8
   store { { ptr, ptr, ptr }, ptr } %1, ptr %alloca, align 8
-  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.169, i64 7 }, { ptr, i64 } { ptr @str.170, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.170, i64 7 }, { ptr, i64 } { ptr @str.171, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2698,24 +2699,24 @@ while.body.117:                                   ; preds = %while.hdr.116
 
 while.exit.118:                                   ; preds = %while.hdr.116
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.171, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.172, i64 1 })
   ret { ptr, i64 } %callN
 
 if.then.119:                                      ; preds = %while.body.117
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.172, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.173, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.120
 
 if.merge.120:                                     ; preds = %if.then.119, %while.body.117
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %fn.gep = getelementptr inbounds [2 x { ptr, i64 }], ptr @field_names.175, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [2 x { ptr, i64 }], ptr @field_names.176, i64 0, i64 %loadN
   %fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.176, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.177, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load { { ptr, ptr, ptr }, ptr }, ptr %alloca, align 8
@@ -2743,13 +2744,13 @@ fv.case:                                          ; preds = %if.merge.120
   %ba.tmp = alloca { ptr, ptr, ptr }, align 8
   store { ptr, ptr, ptr } %fv.field, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
-  %fv.val = insertvalue { i64, i64 } { i64 18, i64 undef }, i64 %ba.p2i, 1
+  %fv.val = insertvalue { i64, i64 } { i64 19, i64 undef }, i64 %ba.p2i, 1
   br label %fv.merge
 
 fv.case17:                                        ; preds = %if.merge.120
   %fv.field18 = extractvalue { { ptr, ptr, ptr }, ptr } %loadN, 1
   %pNi = ptrtoint ptr %fv.field18 to i64
-  %fv.val19 = insertvalue { i64, i64 } { i64 17, i64 undef }, i64 %pNi, 1
+  %fv.val19 = insertvalue { i64, i64 } { i64 18, i64 undef }, i64 %pNi, 1
   br label %fv.merge
 }
 
@@ -2758,7 +2759,7 @@ define internal { ptr, i64 } @struct_to_string__BuildOptions(ptr %0, {} %1) #0 {
 entry:
   %alloca = alloca {}, align 8
   store {} %1, ptr %alloca, align 1
-  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.177, i64 12 }, { ptr, i64 } { ptr @str.178, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.178, i64 12 }, { ptr, i64 } { ptr @str.179, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2777,29 +2778,29 @@ while.body.122:                                   ; preds = %while.hdr.121
 
 while.exit.123:                                   ; preds = %while.hdr.121
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.179, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.180, i64 1 })
   ret { ptr, i64 } %callN
 
 if.then.124:                                      ; preds = %while.body.122
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.180, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.181, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.125
 
 if.merge.125:                                     ; preds = %if.then.124, %while.body.122
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %fn.gep = getelementptr inbounds [0 x { ptr, i64 }], ptr @field_names.181, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [0 x { ptr, i64 }], ptr @field_names.182, i64 0, i64 %loadN
   %fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.182, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.183, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load {}, ptr %alloca, align 1
   %loadN = load i64, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } zeroinitializer)
+  %callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } { i64 17, i64 0 })
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
@@ -2813,7 +2814,7 @@ define internal { ptr, i64 } @struct_to_string__Triple(ptr %0, { i64, i64, i64 }
 entry:
   %alloca = alloca { i64, i64, i64 }, align 8
   store { i64, i64, i64 } %1, ptr %alloca, align 8
-  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.183, i64 6 }, { ptr, i64 } { ptr @str.184, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.184, i64 6 }, { ptr, i64 } { ptr @str.185, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2832,24 +2833,24 @@ while.body.127:                                   ; preds = %while.hdr.126
 
 while.exit.128:                                   ; preds = %while.hdr.126
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.185, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.186, i64 1 })
   ret { ptr, i64 } %callN
 
 if.then.129:                                      ; preds = %while.body.127
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.186, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.187, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.130
 
 if.merge.130:                                     ; preds = %if.then.129, %while.body.127
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %fn.gep = getelementptr inbounds [3 x { ptr, i64 }], ptr @field_names.190, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [3 x { ptr, i64 }], ptr @field_names.191, i64 0, i64 %loadN
   %fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.191, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.192, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load { i64, i64, i64 }, ptr %alloca, align 8
@@ -2898,15 +2899,15 @@ entry:
   %allocaN = alloca i64, align 8
   store i64 %load, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %fn.gep = getelementptr inbounds [7 x { ptr, i64 }], ptr @field_names.200, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [7 x { ptr, i64 }], ptr @field_names.201, i64 0, i64 %loadN
   %fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
-  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.192, i64 1 }, { ptr, i64 } %fn.load)
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.193, i64 1 }, { ptr, i64 } %fn.load)
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %loadN = load i64, ptr %alloca, align 8
   %loadN = load i64, ptr %allocaN, align 8
   %allocaN = alloca { i64, i64 }, align 8
-  store { i64, i64 } zeroinitializer, ptr %allocaN, align 8
+  store { i64, i64 } { i64 17, i64 0 }, ptr %allocaN, align 8
   %loadN = load { i64, i64 }, ptr %allocaN, align 8
   %callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %loadN)
   %allocaN = alloca { ptr, i64 }, align 8
@@ -2919,8 +2920,8 @@ entry:
 if.then.135:                                      ; preds = %entry
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.202, i64 1 })
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.201, i64 1 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.203, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.202, i64 1 }, { ptr, i64 } %callN)
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.136
@@ -2939,15 +2940,15 @@ entry:
   %allocaN = alloca i64, align 8
   store i64 %load, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %fn.gep = getelementptr inbounds [5 x { ptr, i64 }], ptr @field_names.209, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [5 x { ptr, i64 }], ptr @field_names.210, i64 0, i64 %loadN
   %fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
-  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.203, i64 1 }, { ptr, i64 } %fn.load)
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.204, i64 1 }, { ptr, i64 } %fn.load)
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %loadN = load i64, ptr %alloca, align 8
   %loadN = load i64, ptr %allocaN, align 8
   %allocaN = alloca { i64, i64 }, align 8
-  store { i64, i64 } zeroinitializer, ptr %allocaN, align 8
+  store { i64, i64 } { i64 17, i64 0 }, ptr %allocaN, align 8
   %loadN = load { i64, i64 }, ptr %allocaN, align 8
   %callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %loadN)
   %allocaN = alloca { ptr, i64 }, align 8
@@ -2960,8 +2961,8 @@ entry:
 if.then.137:                                      ; preds = %entry
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.211, i64 1 })
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.210, i64 1 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.212, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.211, i64 1 }, { ptr, i64 } %callN)
   %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.138
@@ -2977,7 +2978,7 @@ entry:
   %alloca = alloca [1 x { i64, i64 }], align 8
   store [1 x { i64, i64 }] %1, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  store { ptr, i64 } { ptr @str.212, i64 1 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.213, i64 1 }, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
   store i64 0, ptr %allocaN, align 8
   br label %while.hdr.143
@@ -2994,12 +2995,12 @@ while.body.144:                                   ; preds = %while.hdr.143
 
 while.exit.145:                                   ; preds = %while.hdr.143
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.213, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.214, i64 1 })
   ret { ptr, i64 } %call
 
 if.then.146:                                      ; preds = %while.body.144
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.214, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.215, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.147
 
@@ -3030,7 +3031,7 @@ entry:
   %alloca = alloca [3 x { i64, i64 }], align 8
   store [3 x { i64, i64 }] %1, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  store { ptr, i64 } { ptr @str.215, i64 1 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.216, i64 1 }, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
   store i64 0, ptr %allocaN, align 8
   br label %while.hdr.148
@@ -3047,12 +3048,12 @@ while.body.149:                                   ; preds = %while.hdr.148
 
 while.exit.150:                                   ; preds = %while.hdr.148
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.216, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.217, i64 1 })
   ret { ptr, i64 } %call
 
 if.then.151:                                      ; preds = %while.body.149
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.217, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.218, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.152
 
@@ -3083,7 +3084,7 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %1, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  store { ptr, i64 } { ptr @str.218, i64 1 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.219, i64 1 }, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
   store i64 0, ptr %allocaN, align 8
   br label %while.hdr.157
@@ -3102,12 +3103,12 @@ while.body.158:                                   ; preds = %while.hdr.157
 
 while.exit.159:                                   ; preds = %while.hdr.157
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.219, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.220, i64 1 })
   ret { ptr, i64 } %call
 
 if.then.160:                                      ; preds = %while.body.158
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.220, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.221, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.161
 
@@ -3137,7 +3138,7 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %1, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  store { ptr, i64 } { ptr @str.221, i64 1 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.222, i64 1 }, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
   store i64 0, ptr %allocaN, align 8
   br label %while.hdr.162
@@ -3156,12 +3157,12 @@ while.body.163:                                   ; preds = %while.hdr.162
 
 while.exit.164:                                   ; preds = %while.hdr.162
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.222, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.223, i64 1 })
   ret { ptr, i64 } %call
 
 if.then.165:                                      ; preds = %while.body.163
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.223, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.224, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.166
 
@@ -3204,12 +3205,12 @@ if.then.188:                                      ; preds = %entry
 if.else.189:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.226, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.225, i64 5 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.227, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.226, i64 5 }, { ptr, i64 } %callN)
   br label %if.merge.190
 
 if.merge.190:                                     ; preds = %if.else.189, %if.then.188
-  %bp = phi { ptr, i64 } [ { ptr @str.224, i64 4 }, %if.then.188 ], [ %callN, %if.else.189 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.225, i64 4 }, %if.then.188 ], [ %callN, %if.else.189 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3232,12 +3233,12 @@ if.then.212:                                      ; preds = %entry
 if.else.213:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.229, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.228, i64 11 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.230, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.229, i64 11 }, { ptr, i64 } %callN)
   br label %if.merge.214
 
 if.merge.214:                                     ; preds = %if.else.213, %if.then.212
-  %bp = phi { ptr, i64 } [ { ptr @str.227, i64 4 }, %if.then.212 ], [ %callN, %if.else.213 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.228, i64 4 }, %if.then.212 ], [ %callN, %if.else.213 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3260,12 +3261,12 @@ if.then.215:                                      ; preds = %entry
 if.else.216:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.232, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.231, i64 4 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.233, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.232, i64 4 }, { ptr, i64 } %callN)
   br label %if.merge.217
 
 if.merge.217:                                     ; preds = %if.else.216, %if.then.215
-  %bp = phi { ptr, i64 } [ { ptr @str.230, i64 4 }, %if.then.215 ], [ %callN, %if.else.216 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.231, i64 4 }, %if.then.215 ], [ %callN, %if.else.216 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3288,12 +3289,12 @@ if.then.218:                                      ; preds = %entry
 if.else.219:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.235, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.234, i64 11 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.236, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.235, i64 11 }, { ptr, i64 } %callN)
   br label %if.merge.220
 
 if.merge.220:                                     ; preds = %if.else.219, %if.then.218
-  %bp = phi { ptr, i64 } [ { ptr @str.233, i64 4 }, %if.then.218 ], [ %callN, %if.else.219 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.234, i64 4 }, %if.then.218 ], [ %callN, %if.else.219 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3316,12 +3317,12 @@ if.then.221:                                      ; preds = %entry
 if.else.222:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.238, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.237, i64 6 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.239, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.238, i64 6 }, { ptr, i64 } %callN)
   br label %if.merge.223
 
 if.merge.223:                                     ; preds = %if.else.222, %if.then.221
-  %bp = phi { ptr, i64 } [ { ptr @str.236, i64 4 }, %if.then.221 ], [ %callN, %if.else.222 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.237, i64 4 }, %if.then.221 ], [ %callN, %if.else.222 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3343,12 +3344,12 @@ if.then.224:                                      ; preds = %entry
 if.else.225:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.241, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.240, i64 5 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.242, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.241, i64 5 }, { ptr, i64 } %callN)
   br label %if.merge.226
 
 if.merge.226:                                     ; preds = %if.else.225, %if.then.224
-  %bp = phi { ptr, i64 } [ { ptr @str.239, i64 4 }, %if.then.224 ], [ %callN, %if.else.225 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.240, i64 4 }, %if.then.224 ], [ %callN, %if.else.225 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3371,12 +3372,12 @@ if.then.227:                                      ; preds = %entry
 if.else.228:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.244, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.243, i64 9 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.245, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.244, i64 9 }, { ptr, i64 } %callN)
   br label %if.merge.229
 
 if.merge.229:                                     ; preds = %if.else.228, %if.then.227
-  %bp = phi { ptr, i64 } [ { ptr @str.242, i64 4 }, %if.then.227 ], [ %callN, %if.else.228 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.243, i64 4 }, %if.then.227 ], [ %callN, %if.else.228 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3399,12 +3400,12 @@ if.then.230:                                      ; preds = %entry
 if.else.231:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.247, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.246, i64 18 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.248, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.247, i64 18 }, { ptr, i64 } %callN)
   br label %if.merge.232
 
 if.merge.232:                                     ; preds = %if.else.231, %if.then.230
-  %bp = phi { ptr, i64 } [ { ptr @str.245, i64 4 }, %if.then.230 ], [ %callN, %if.else.231 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.246, i64 4 }, %if.then.230 ], [ %callN, %if.else.231 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3427,12 +3428,12 @@ if.then.233:                                      ; preds = %entry
 if.else.234:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.250, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.249, i64 12 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.251, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.250, i64 12 }, { ptr, i64 } %callN)
   br label %if.merge.235
 
 if.merge.235:                                     ; preds = %if.else.234, %if.then.233
-  %bp = phi { ptr, i64 } [ { ptr @str.248, i64 4 }, %if.then.233 ], [ %callN, %if.else.234 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.249, i64 4 }, %if.then.233 ], [ %callN, %if.else.234 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3455,12 +3456,12 @@ if.then.236:                                      ; preds = %entry
 if.else.237:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.253, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.252, i64 4 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.254, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.253, i64 4 }, { ptr, i64 } %callN)
   br label %if.merge.238
 
 if.merge.238:                                     ; preds = %if.else.237, %if.then.236
-  %bp = phi { ptr, i64 } [ { ptr @str.251, i64 4 }, %if.then.236 ], [ %callN, %if.else.237 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.252, i64 4 }, %if.then.236 ], [ %callN, %if.else.237 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3483,12 +3484,12 @@ if.then.239:                                      ; preds = %entry
 if.else.240:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.256, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.255, i64 6 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.257, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.256, i64 6 }, { ptr, i64 } %callN)
   br label %if.merge.241
 
 if.merge.241:                                     ; preds = %if.else.240, %if.then.239
-  %bp = phi { ptr, i64 } [ { ptr @str.254, i64 4 }, %if.then.239 ], [ %callN, %if.else.240 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.255, i64 4 }, %if.then.239 ], [ %callN, %if.else.240 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3511,12 +3512,12 @@ if.then.242:                                      ; preds = %entry
 if.else.243:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.259, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.258, i64 5 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.260, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.259, i64 5 }, { ptr, i64 } %callN)
   br label %if.merge.244
 
 if.merge.244:                                     ; preds = %if.else.243, %if.then.242
-  %bp = phi { ptr, i64 } [ { ptr @str.257, i64 4 }, %if.then.242 ], [ %callN, %if.else.243 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.258, i64 4 }, %if.then.242 ], [ %callN, %if.else.243 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3539,12 +3540,12 @@ if.then.245:                                      ; preds = %entry
 if.else.246:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.262, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.261, i64 7 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.263, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.262, i64 7 }, { ptr, i64 } %callN)
   br label %if.merge.247
 
 if.merge.247:                                     ; preds = %if.else.246, %if.then.245
-  %bp = phi { ptr, i64 } [ { ptr @str.260, i64 4 }, %if.then.245 ], [ %callN, %if.else.246 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.261, i64 4 }, %if.then.245 ], [ %callN, %if.else.246 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3567,12 +3568,12 @@ if.then.248:                                      ; preds = %entry
 if.else.249:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.265, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.264, i64 4 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.266, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.265, i64 4 }, { ptr, i64 } %callN)
   br label %if.merge.250
 
 if.merge.250:                                     ; preds = %if.else.249, %if.then.248
-  %bp = phi { ptr, i64 } [ { ptr @str.263, i64 4 }, %if.then.248 ], [ %callN, %if.else.249 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.264, i64 4 }, %if.then.248 ], [ %callN, %if.else.249 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3595,12 +3596,12 @@ if.then.251:                                      ; preds = %entry
 if.else.252:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.268, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.267, i64 7 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.269, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.268, i64 7 }, { ptr, i64 } %callN)
   br label %if.merge.253
 
 if.merge.253:                                     ; preds = %if.else.252, %if.then.251
-  %bp = phi { ptr, i64 } [ { ptr @str.266, i64 4 }, %if.then.251 ], [ %callN, %if.else.252 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.267, i64 4 }, %if.then.251 ], [ %callN, %if.else.252 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3623,12 +3624,12 @@ if.then.254:                                      ; preds = %entry
 if.else.255:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.271, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.270, i64 6 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.272, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.271, i64 6 }, { ptr, i64 } %callN)
   br label %if.merge.256
 
 if.merge.256:                                     ; preds = %if.else.255, %if.then.254
-  %bp = phi { ptr, i64 } [ { ptr @str.269, i64 4 }, %if.then.254 ], [ %callN, %if.else.255 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.270, i64 4 }, %if.then.254 ], [ %callN, %if.else.255 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3651,12 +3652,12 @@ if.then.257:                                      ; preds = %entry
 if.else.258:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.274, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.273, i64 3 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.275, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.274, i64 3 }, { ptr, i64 } %callN)
   br label %if.merge.259
 
 if.merge.259:                                     ; preds = %if.else.258, %if.then.257
-  %bp = phi { ptr, i64 } [ { ptr @str.272, i64 4 }, %if.then.257 ], [ %callN, %if.else.258 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.273, i64 4 }, %if.then.257 ], [ %callN, %if.else.258 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3679,12 +3680,12 @@ if.then.260:                                      ; preds = %entry
 if.else.261:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.277, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.276, i64 7 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.278, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.277, i64 7 }, { ptr, i64 } %callN)
   br label %if.merge.262
 
 if.merge.262:                                     ; preds = %if.else.261, %if.then.260
-  %bp = phi { ptr, i64 } [ { ptr @str.275, i64 4 }, %if.then.260 ], [ %callN, %if.else.261 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.276, i64 4 }, %if.then.260 ], [ %callN, %if.else.261 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3707,12 +3708,12 @@ if.then.263:                                      ; preds = %entry
 if.else.264:                                      ; preds = %entry
   %loadN = load i64, ptr %allocaN, align 8
   %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.280, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.279, i64 7 }, { ptr, i64 } %callN)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.281, i64 3 }, { ptr, i64 } %call)
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.280, i64 7 }, { ptr, i64 } %callN)
   br label %if.merge.265
 
 if.merge.265:                                     ; preds = %if.else.264, %if.then.263
-  %bp = phi { ptr, i64 } [ { ptr @str.278, i64 4 }, %if.then.263 ], [ %callN, %if.else.264 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.279, i64 4 }, %if.then.263 ], [ %callN, %if.else.264 ]
   ret { ptr, i64 } %bp
 }