diff --git a/examples/12-meta.sx b/examples/12-meta.sx
index b0be483..165e4fe 100644
--- a/examples/12-meta.sx
+++ b/examples/12-meta.sx
@@ -25,5 +25,5 @@ main :: () {
 // ** stdout **
 // f64
 // 3.200000
-// Vec4
+// Vector(4,f32)
 // () -> s32
\ No newline at end of file
diff --git a/examples/189-type-all-interactions.sx b/examples/189-type-all-interactions.sx
new file mode 100644
index 0000000..64a2dca
--- /dev/null
+++ b/examples/189-type-all-interactions.sx
@@ -0,0 +1,206 @@
+// Type as a first-class value — comprehensive interaction smoke.
+//
+// Every way a user can plausibly touch a `Type` value, in one
+// place. Pre-fix: some sections fail (`<?>`, false, garbage, or
+// compile errors). Post-fix: every section's output matches the
+// header line.
+//
+// Sections labelled `--- N. <thing> ---` so the diff localises
+// which interaction regressed.
+
+#import "modules/std.sx";
+
+// ── Test fixtures ─────────────────────────────────────────────
+
+Point :: struct { x: s32; y: s32; }
+
+Color :: enum { red; green; blue; }
+
+Wrap :: struct ($T: Type) { v: T; }
+
+identity :: ($T: Type, val: T) -> T => val;
+
+// Generic comptime fn that dispatches on type identity (compile-
+// time fold via type_eq → const_bool → inline-if folds the
+// branch away).
+describe :: ($T: Type) -> string {
+    inline if type_eq(T, s64) { return "int64"; }
+    inline if type_eq(T, string) { return "text"; }
+    inline if type_eq(T, bool) { return "boolean"; }
+    return "other";
+}
+
+// Pack-fn collecting per-position types (step 4A.bare path).
+type_list :: (..$args) -> string {
+    list := $args;
+    s := "[";
+    i : s64 = 0;
+    while i < list.len {
+        if i > 0 { s = concat(s, ", "); }
+        s = concat(s, type_name(list[i]));
+        i = i + 1;
+    }
+    return concat(s, "]");
+}
+
+// Type stored in a struct field.
+TypeHolder :: struct { t: Type; }
+
+main :: () -> s32 {
+    // ── 1. Type literal equality ────────────────────────────
+    print("=== 1. literal == ===\n");
+    print("s64 == s64:    {}\n", s64 == s64);
+    print("s64 == string: {}\n", s64 == string);
+    print("*u8 == *u8:    {}\n", *u8 == *u8);
+    print("?s64 == ?s64:  {}\n", ?s64 == ?s64);
+    print("?s64 == ?s32:  {}\n", ?s64 == ?s32);
+
+    // ── 2. type_of(value) ───────────────────────────────────
+    print("=== 2. type_of(value) == T ===\n");
+    a : s64 = 42;
+    b : f64 = 3.14;
+    s : string = "hi";
+    print("type_of(a) == s64:    {}\n", type_of(a) == s64);
+    print("type_of(b) == f64:    {}\n", type_of(b) == f64);
+    print("type_of(s) == string: {}\n", type_of(s) == string);
+    print("type_of(a) == f64:    {}\n", type_of(a) == f64);
+
+    // ── 3. Type variable storage + readback ─────────────────
+    print("=== 3. Type variable storage ===\n");
+    t : Type = f64;
+    print("t == f64:    {}\n", t == f64);
+    print("t == string: {}\n", t == string);
+    t = string;
+    print("after reassign t == string: {}\n", t == string);
+    t = bool;
+    print("t == bool:   {}\n", t == bool);
+
+    // ── 4. type_name on literals + variables ────────────────
+    print("=== 4. type_name ===\n");
+    print("type_name(s64):    {}\n", type_name(s64));
+    print("type_name(*u8):    {}\n", type_name(*u8));
+    print("type_name(Point):  {}\n", type_name(Point));
+    print("type_name(Color):  {}\n", type_name(Color));
+    t = f64;
+    print("type_name(t):      {}\n", type_name(t));
+
+    // ── 5. Print Type values directly ───────────────────────
+    print("=== 5. print Type values ===\n");
+    print("literal: {}\n", s64);
+    t = string;
+    print("var:     {}\n", t);
+    print("type_of(b): {}\n", type_of(b));
+
+    // ── 6. Generic dispatch via $T: Type ────────────────────
+    print("=== 6. generic dispatch ===\n");
+    print("describe(s64):    {}\n", describe(s64));
+    print("describe(string): {}\n", describe(string));
+    print("describe(bool):   {}\n", describe(bool));
+    print("describe(f64):    {}\n", describe(f64));
+
+    // ── 7. identity(T, val) ─────────────────────────────────
+    print("=== 7. identity($T, val) ===\n");
+    print("identity(s64, 7):     {}\n", identity(s64, 7));
+    print("identity(string, hi): {}\n", identity(string, "hi"));
+    print("identity(bool, true): {}\n", identity(bool, true));
+
+    // ── 8. Comptime-generated struct (Wrap($T)) ─────────────
+    print("=== 8. Wrap($T) ===\n");
+    w_int := Wrap(s64).{ v = 42 };
+    w_str := Wrap(string).{ v = "wrapped" };
+    print("Wrap(s64).v:    {}\n", w_int.v);
+    print("Wrap(string).v: {}\n", w_str.v);
+
+    // ── 9. Reflection builtins on Types ─────────────────────
+    print("=== 9. reflection on Type ===\n");
+    print("size_of(s64):      {}\n", size_of(s64));
+    print("size_of(*u8):      {}\n", size_of(*u8));
+    print("align_of(f64):     {}\n", align_of(f64));
+    print("field_count(Point): {}\n", field_count(Point));
+    print("type_eq(s64, s64):    {}\n", type_eq(s64, s64));
+    print("type_eq(s64, string): {}\n", type_eq(s64, string));
+
+    // ── 10. Type pack (..$args) walking ─────────────────────
+    print("=== 10. ..$args walking ===\n");
+    print("type_list():            {}\n", type_list());
+    print("type_list(1):           {}\n", type_list(42));
+    print("type_list(1, \"x\"):    {}\n", type_list(42, "x"));
+    print("type_list(true, 3.14):  {}\n", type_list(true, 3.14));
+
+    // ── 11. Type in struct field ────────────────────────────
+    print("=== 11. Type in struct field ===\n");
+    h := TypeHolder.{ t = s64 };
+    print("h.t == s64:    {}\n", h.t == s64);
+    print("h.t == string: {}\n", h.t == string);
+    print("type_name(h.t): {}\n", type_name(h.t));
+
+    // ── 12. Compound type literals ──────────────────────────
+    print("=== 12. compound literals ===\n");
+    print("type_name(*Point):    {}\n", type_name(*Point));
+    print("type_name([4]s32):    {}\n", type_name([4]s32));
+    print("type_name([]bool):    {}\n", type_name([]bool));
+    print("type_name(?f64):      {}\n", type_name(?f64));
+
+    return 0;
+}
+
+// ** stdout **
+// === 1. literal == ===
+// s64 == s64:    true
+// s64 == string: false
+// *u8 == *u8:    true
+// ?s64 == ?s64:  true
+// ?s64 == ?s32:  false
+// === 2. type_of(value) == T ===
+// type_of(a) == s64:    true
+// type_of(b) == f64:    true
+// type_of(s) == string: true
+// type_of(a) == f64:    false
+// === 3. Type variable storage ===
+// t == f64:    true
+// t == string: false
+// after reassign t == string: true
+// t == bool:   true
+// === 4. type_name ===
+// type_name(s64):    s64
+// type_name(*u8):    *u8
+// type_name(Point):  Point
+// type_name(Color):  Color
+// type_name(t):      f64
+// === 5. print Type values ===
+// literal: s64
+// var:     string
+// type_of(b): f64
+// === 6. generic dispatch ===
+// describe(s64):    int64
+// describe(string): text
+// describe(bool):   boolean
+// describe(f64):    other
+// === 7. identity($T, val) ===
+// identity(s64, 7):     7
+// identity(string, hi): hi
+// identity(bool, true): true
+// === 8. Wrap($T) ===
+// Wrap(s64).v:    42
+// Wrap(string).v: wrapped
+// === 9. reflection on Type ===
+// size_of(s64):      8
+// size_of(*u8):      8
+// align_of(f64):     8
+// field_count(Point): 2
+// type_eq(s64, s64):    true
+// type_eq(s64, string): false
+// === 10. ..$args walking ===
+// type_list():            []
+// type_list(1):           [s64]
+// type_list(1, "x"):      [s64, string]
+// type_list(true, 3.14):  [bool, f64]
+// === 11. Type in struct field ===
+// h.t == s64:    true
+// h.t == string: false
+// type_name(h.t): s64
+// === 12. compound literals ===
+// type_name(*Point):    *Point
+// type_name([4]s32):    [4]s32
+// type_name([]bool):    []bool
+// type_name(?f64):      ?f64
diff --git a/library/modules/std.sx b/library/modules/std.sx
index bff43dc..6d53c89 100644
--- a/library/modules/std.sx
+++ b/library/modules/std.sx
@@ -319,7 +319,7 @@ any_to_string :: (val: Any) -> string {
         case slice: result = slice_to_string(cast(type) val);
         case pointer: result = pointer_to_string(cast(type) val);
         case optional: result = optional_to_string(cast(type) val);
-        case type: { s : string = xx val; result = s; }
+        case type: result = type_name(val);
     }
     result;
 }
diff --git a/src/ir/emit_llvm.zig b/src/ir/emit_llvm.zig
index f177916..dea0126 100644
--- a/src/ir/emit_llvm.zig
+++ b/src/ir/emit_llvm.zig
@@ -144,6 +144,12 @@ pub const LLVMEmitter = struct {
     // Cached field name arrays for reflection (TypeId → LLVM global)
     field_name_arrays: std.AutoHashMap(u32, c.LLVMValueRef),
 
+    // Lazy global `[N x string]` indexed by TypeId.index(), holding
+    // each type's display name. Built on the first dynamic
+    // `type_name(t)` call site; reused thereafter.
+    type_name_array: ?c.LLVMValueRef = null,
+    type_name_array_len: u32 = 0,
+
     // Target configuration (stored for ABI decisions during emission)
     target_config: TargetConfig,
 
@@ -1670,20 +1676,24 @@ pub const LLVMEmitter = struct {
                     self.mapRef(llvm_val);
                 }
             },
-            .const_type => {
-                // Type values are comptime-only. At LLVM emit they
-                // become undef-i64 placeholders — Type-aware ops are
-                // routed through the interp; if one slips through to
-                // a runtime use site (`type_name` / `type_eq` /
-                // `has_impl` / `bitcast`), the corresponding emit_llvm
-                // bail or runtime use-site error fires loudly. Pure
-                // STORAGE of Type values in runtime aggregates (e.g.
-                // `$args` lowering builds an `[]Any` slice whose
-                // elements happen to be Type values that the user's
-                // code may or may not actually read) is safe — undef
-                // just gets stored, undef just gets read; no use-site
-                // misbehaviour follows.
-                self.mapRef(c.LLVMGetUndef(self.cached_i64));
+            .const_type => |tid| {
+                // Type values are Any-shaped pairs:
+                //   { tag = .any.index() (the meta-marker),
+                //     value = tid.index() }
+                // Lets storage in Any slots, struct fields,
+                // `Type`-typed vars, and slice elements all round-
+                // trip through the standard Any infrastructure.
+                // `case type:` in `any_to_string` matches on
+                // tag == `.any.index()`. Runtime `type_name(t)`
+                // extracts the value field and indexes into the
+                // type-name lookup table.
+                const any_ty = self.getAnyStructType();
+                const tag = c.LLVMConstInt(self.cached_i64, TypeId.any.index(), 0);
+                const val = c.LLVMConstInt(self.cached_i64, tid.index(), 0);
+                var result = c.LLVMGetUndef(any_ty);
+                result = c.LLVMBuildInsertValue(self.builder, result, tag, 0, "ct.tag");
+                result = c.LLVMBuildInsertValue(self.builder, result, val, 1, "ct.val");
+                self.mapRef(result);
             },
 
             // ── Arithmetic ─────────────────────────────────────────
@@ -2969,19 +2979,66 @@ pub const LLVMEmitter = struct {
                         _ = c.LLVMBuildCall2(self.builder, self.getWriteType(), write_fn, &write_args, 3, "");
                         self.advanceRefCounter();
                     },
-                    .type_name, .type_eq, .has_impl => {
-                        // Comptime-only reflection builtins. When the
-                        // lowering split between static-fold and
-                        // dynamic-builtin-call routes a call to one of
-                        // these, the call site is intended for the
-                        // interp's arm. LLVM still compiles the
-                        // containing fn (the JIT module-wide) even if
-                        // main never calls it — so this op DOES reach
-                        // emit, just in dead-from-main's-perspective
-                        // code. Silent undef-i64 placeholder is the
-                        // right answer; the interp's arm catches real
-                        // misuse via `asTypeId orelse bailDetail`.
-                        self.mapRef(c.LLVMGetUndef(self.toLLVMType(instruction.ty)));
+                    .type_name => {
+                        // Dynamic `type_name(t)` at runtime: extract
+                        // the TypeId from the arg (an Any-boxed Type
+                        // value: tag=`.s64.index()`, value=tid), GEP
+                        // into the compiler-emitted `__sx_type_names`
+                        // global, load the string. The arg's LLVM
+                        // shape is the `{i64, i64}` Any aggregate
+                        // (because the IR-side arg type is `.any`
+                        // when boxed); for unboxed direct call sites
+                        // (the arg IR type is `.s64` from
+                        // `const_type`), the value IS the TypeId
+                        // index directly.
+                        const arg_ref = bi.args[0];
+                        const arg_val = self.resolveRef(arg_ref);
+                        const arg_ir_ty = self.getRefIRType(arg_ref) orelse @import("types.zig").TypeId.s64;
+                        const tid_idx = blk: {
+                            if (arg_ir_ty == .any) {
+                                // Boxed: extract value field.
+                                break :blk c.LLVMBuildExtractValue(self.builder, arg_val, 1, "tn.tid");
+                            }
+                            // Bare i64 (TypeId index).
+                            break :blk arg_val;
+                        };
+                        const arr_global = self.getOrBuildTypeNameArray();
+                        const arr_len = self.type_name_array_len;
+                        const string_ty = self.getStringStructType();
+                        const arr_ty = c.LLVMArrayType(string_ty, arr_len);
+                        const zero = c.LLVMConstInt(self.cached_i64, 0, 0);
+                        var indices = [2]c.LLVMValueRef{ zero, tid_idx };
+                        const gep = c.LLVMBuildInBoundsGEP2(self.builder, arr_ty, arr_global, &indices, 2, "tn.gep");
+                        const result = c.LLVMBuildLoad2(self.builder, string_ty, gep, "tn.load");
+                        self.mapRef(result);
+                    },
+                    .type_eq => {
+                        // Dynamic `type_eq(a, b)` — both args are
+                        // Type values. Extract TypeId from each Any
+                        // box (or use directly if `.s64`-typed),
+                        // icmp eq.
+                        const a = blk: {
+                            const v = self.resolveRef(bi.args[0]);
+                            const ty = self.getRefIRType(bi.args[0]) orelse @import("types.zig").TypeId.s64;
+                            if (ty == .any) break :blk c.LLVMBuildExtractValue(self.builder, v, 1, "te.a");
+                            break :blk v;
+                        };
+                        const b = blk: {
+                            const v = self.resolveRef(bi.args[1]);
+                            const ty = self.getRefIRType(bi.args[1]) orelse @import("types.zig").TypeId.s64;
+                            if (ty == .any) break :blk c.LLVMBuildExtractValue(self.builder, v, 1, "te.b");
+                            break :blk v;
+                        };
+                        const eq_res = c.LLVMBuildICmp(self.builder, c.LLVMIntEQ, a, b, "te.eq");
+                        self.mapRef(eq_res);
+                    },
+                    .has_impl => {
+                        // Runtime has_impl needs a protocol-map
+                        // snapshot — not wired yet. Silent false for
+                        // now; the lower-time fold via
+                        // `tryConstBoolCondition` covers every
+                        // statically-resolvable call.
+                        self.mapRef(c.LLVMConstInt(self.cached_i1, 0, 0));
                     },
                     else => {
                         // size_of, cast — handled by lowering or codegen glue
@@ -4496,6 +4553,49 @@ pub const LLVMEmitter = struct {
 
     // ── Reflection emission helpers ────────────────────────────────
 
+    /// Build (or return cached) a global constant array of {ptr, i64}
+    /// string values indexed by `TypeId.index()`. Lets the dynamic
+    /// `type_name(t)` builtin look up the type's display name at
+    /// runtime — `gep arr[tid]; load string`. The array's length is
+    /// the current `infos.items.len`; new types interned after this
+    /// is built fall outside the array (the gep would OOB), so
+    /// callers must build LAZILY after all types are registered.
+    fn getOrBuildTypeNameArray(self: *LLVMEmitter) c.LLVMValueRef {
+        if (self.type_name_array) |g| return g;
+
+        const n: u32 = @intCast(self.ir_mod.types.infos.items.len);
+        const string_ty = self.getStringStructType();
+
+        var field_vals = std.ArrayList(c.LLVMValueRef).empty;
+        defer field_vals.deinit(self.alloc);
+        var i: u32 = 0;
+        while (i < n) : (i += 1) {
+            const tid = @import("types.zig").TypeId.fromIndex(i);
+            const name_str = self.ir_mod.types.formatTypeName(self.alloc, tid);
+            const str_z = self.alloc.dupeZ(u8, name_str) catch unreachable;
+            defer self.alloc.free(str_z);
+            const global_str = c.LLVMAddGlobal(self.llvm_module, c.LLVMArrayType(self.cached_i8, @intCast(name_str.len + 1)), "tn.str");
+            c.LLVMSetInitializer(global_str, c.LLVMConstStringInContext(self.context, str_z.ptr, @intCast(name_str.len + 1), 1));
+            c.LLVMSetGlobalConstant(global_str, 1);
+            c.LLVMSetLinkage(global_str, c.LLVMPrivateLinkage);
+            const len_val = c.LLVMConstInt(self.cached_i64, name_str.len, 0);
+            var struct_fields = [2]c.LLVMValueRef{ global_str, len_val };
+            const const_struct = c.LLVMConstStructInContext(self.context, &struct_fields, 2, 0);
+            field_vals.append(self.alloc, const_struct) catch unreachable;
+        }
+
+        const arr_ty = c.LLVMArrayType(string_ty, n);
+        const arr_init = c.LLVMConstArray(string_ty, field_vals.items.ptr, n);
+        const global = c.LLVMAddGlobal(self.llvm_module, arr_ty, "__sx_type_names");
+        c.LLVMSetInitializer(global, arr_init);
+        c.LLVMSetGlobalConstant(global, 1);
+        c.LLVMSetLinkage(global, c.LLVMPrivateLinkage);
+
+        self.type_name_array = global;
+        self.type_name_array_len = n;
+        return global;
+    }
+
     /// Build (or return cached) a global constant array of {ptr, i64} string values
     /// for the field names of a struct type.
     fn getOrBuildFieldNameArray(self: *LLVMEmitter, struct_type: TypeId) c.LLVMValueRef {
diff --git a/src/ir/interp.zig b/src/ir/interp.zig
index c89b6ca..a73882a 100644
--- a/src/ir/interp.zig
+++ b/src/ir/interp.zig
@@ -1767,7 +1767,22 @@ pub const Interpreter = struct {
             .type_name => {
                 if (bi.args.len < 1) return bailDetail("comptime type_name: missing argument");
                 const arg = frame.getRef(bi.args[0]);
-                const tid = arg.asTypeId() orelse return bailDetail("comptime type_name: argument is not a Type value (expected `.type_tag`, got a different Value kind)");
+                // Accept either a bare `.type_tag` Value (the
+                // comptime-native form) or an Any-boxed Type
+                // (`.aggregate { tag: int, value: .type_tag }`)
+                // — the latter shape is what `box_any` produces
+                // when const_type values flow through a `.any`-typed
+                // slice or struct field.
+                const tid = blk: {
+                    if (arg.asTypeId()) |t| break :blk t;
+                    if (arg == .aggregate) {
+                        const fields = arg.aggregate;
+                        if (fields.len >= 2) {
+                            if (fields[1].asTypeId()) |t| break :blk t;
+                        }
+                    }
+                    return bailDetail("comptime type_name: argument is not a Type value (expected `.type_tag` or Any-boxed Type)");
+                };
                 const name = self.module.types.typeName(tid);
                 // Copy the slice into the interp's allocator so it
                 // outlives any TypeTable churn during the rest of the
diff --git a/src/ir/lower.zig b/src/ir/lower.zig
index 589bcef..4f64499 100644
--- a/src/ir/lower.zig
+++ b/src/ir/lower.zig
@@ -610,6 +610,18 @@ pub const Lowering = struct {
                                     const alias_id = if (self.module.types.findByName(alias_name_id)) |existing| existing else self.module.types.intern(alias_info);
                                     self.module.types.update(alias_id, alias_info);
                                 }
+                            } else if (std.mem.eql(u8, callee_name, "Vector")) {
+                                // Builtin type constructor — checked BEFORE
+                                // the generic `fn_ast_map` branch because
+                                // `Vector` IS in `fn_ast_map` (declared as a
+                                // `#builtin` fn) but `instantiateTypeFunction`
+                                // can't resolve it (no body). Use
+                                // `resolveTypeCallWithBindings` which
+                                // hard-codes the vector layout.
+                                const result_ty = self.resolveTypeCallWithBindings(call_data);
+                                if (result_ty != .void) {
+                                    self.type_alias_map.put(cd.name, result_ty) catch {};
+                                }
                             } else if (self.fn_ast_map.get(callee_name)) |fd| {
                                 // Type-returning function: Foo :: Complex(u32)
                                 if (fd.type_params.len > 0) {
@@ -635,6 +647,15 @@ pub const Lowering = struct {
                                 const alias_id = if (self.module.types.findByName(alias_name_id)) |existing| existing else self.module.types.intern(alias_info);
                                 self.module.types.update(alias_id, alias_info);
                             }
+                        } else {
+                            // Builtin parameterised type (Vector(N, T) etc) —
+                            // resolve via type_bridge and register the result
+                            // under the alias name so `Vec4` in expression
+                            // position can `const_type(<vector tid>)`.
+                            const result_ty = type_bridge.resolveAstType(cd.value, &self.module.types);
+                            if (result_ty != .void and result_ty != .s64) {
+                                self.type_alias_map.put(cd.name, result_ty) catch {};
+                            }
                         }
                     }
                     // comptime_expr handled in Pass 2
@@ -2258,16 +2279,26 @@ pub const Lowering = struct {
                         break :blk self.builder.emit(.{ .func_ref = fid }, .s64);
                     }
                 }
-                // Type-as-value: if target is Any (Type context), produce a type name string
-                if (self.target_type == .any) {
-                    const sid = self.module.types.internString(id.name);
-                    const str = self.builder.constString(sid);
-                    break :blk self.builder.boxAny(str, .string);
-                }
-                // Type-as-value: known type name used where a value is expected (e.g. cast(s64, val))
-                // The type arg is lowered but unused — the caller resolves from AST.
-                if (self.isKnownTypeName(id.name)) {
-                    break :blk self.emitPlaceholder(id.name);
+                // Type-as-value: a name that resolves to a TypeId
+                // (primitive, alias, registered struct/enum/union,
+                // generic-struct instantiation) evaluates to a
+                // `const_type` in expression position. Works for
+                // direct assignment to a `Type`-typed slot
+                // (`x: Type = Vec4`), comparison (`x == Vec4`), and
+                // pack-arg / Any context (boxing happens at the
+                // consumer).
+                const ty = blk_ty: {
+                    if (self.type_bindings) |tb| {
+                        if (tb.get(id.name)) |t| break :blk_ty t;
+                    }
+                    if (self.type_alias_map.get(id.name)) |t| break :blk_ty t;
+                    if (type_bridge.resolveTypePrimitive(id.name)) |t| break :blk_ty t;
+                    const name_id = self.module.types.internString(id.name);
+                    if (self.module.types.findByName(name_id)) |t| break :blk_ty t;
+                    break :blk_ty TypeId.void;
+                };
+                if (ty != .void) {
+                    break :blk self.builder.constType(ty);
                 }
                 // Unknown identifier
                 break :blk self.emitError(id.name, node.span);
@@ -2410,16 +2441,13 @@ pub const Lowering = struct {
                 if (self.global_names.get(te.name)) |gi| {
                     break :blk self.builder.emit(.{ .global_get = gi.id }, gi.ty);
                 }
-                // Type-as-value: if target is Any (Type variable), produce a boxed string
-                if (self.target_type == .any) {
-                    const sid = self.module.types.internString(te.name);
-                    const str = self.builder.constString(sid);
-                    break :blk self.builder.boxAny(str, .string);
-                }
-                // Type expressions are always type names from the parser — they appear
-                // in value position when used as args to cast() etc. Silent placeholder.
+                // Type literal in expression position → first-class
+                // `const_type` Value (i64 = TypeId.index()). Makes
+                // `t : Type = f64;` store a real TypeId; lets
+                // `t == f64` icmp at runtime against the same TypeId.
                 if (self.isKnownTypeName(te.name)) {
-                    break :blk self.emitPlaceholder(te.name);
+                    const ty = type_bridge.resolveAstType(node, &self.module.types);
+                    break :blk self.builder.constType(ty);
                 }
                 break :blk self.emitError(te.name, node.span);
             },
@@ -2456,6 +2484,46 @@ pub const Lowering = struct {
             return self.builder.blockParam(merge_bb, 0, .bool);
         }
 
+        // Type-literal comparison fold: when both sides are type-shaped
+        // AST nodes (`s64`, `*u8`, `?T`, `[3]f64`, etc.) OR resolve to
+        // a static TypeId at lower time (`type_of(x)` for any
+        // statically-typed `x`), resolve each and emit a `const_bool`.
+        // Same semantic as `type_eq(A, B)` but using the standard `==`
+        // operator — the user's intuition. Without the fold, both
+        // sides lower as `const_type` undef-i64 and the runtime icmp
+        // returns garbage.
+        if (bop.op == .eq or bop.op == .neq) {
+            if (self.isStaticTypeRef(bop.lhs) and self.isStaticTypeRef(bop.rhs)) {
+                const lhs_ty = self.resolveTypeArg(bop.lhs);
+                const rhs_ty = self.resolveTypeArg(bop.rhs);
+                const eq_result = lhs_ty == rhs_ty;
+                return self.builder.constBool(if (bop.op == .eq) eq_result else !eq_result);
+            }
+        }
+
+        // Any-shaped `==` (e.g. `t == s64` where `t: Type`): both
+        // operands are 16-byte `{tag, value}` aggregates. LLVM
+        // doesn't accept `icmp` on aggregates directly. Decompose
+        // via `unbox_any` (which extracts the value field at
+        // `.s64`) and compare the i64s. Tag fields are stable
+        // across compilations of the same source so value-only
+        // identity is enough.
+        if (bop.op == .eq or bop.op == .neq) {
+            const lhs_ty = self.inferExprType(bop.lhs);
+            const rhs_ty = self.inferExprType(bop.rhs);
+            if (lhs_ty == .any and rhs_ty == .any) {
+                const lhs = self.lowerExpr(bop.lhs);
+                const rhs = self.lowerExpr(bop.rhs);
+                const lhs_val = self.builder.emit(.{ .unbox_any = .{ .operand = lhs } }, .s64);
+                const rhs_val = self.builder.emit(.{ .unbox_any = .{ .operand = rhs } }, .s64);
+                if (bop.op == .eq) {
+                    return self.builder.emit(.{ .cmp_eq = .{ .lhs = lhs_val, .rhs = rhs_val } }, .bool);
+                } else {
+                    return self.builder.emit(.{ .cmp_ne = .{ .lhs = lhs_val, .rhs = rhs_val } }, .bool);
+                }
+            }
+        }
+
         // Special case: optional == null / optional != null
         if (bop.op == .eq or bop.op == .neq) {
             const lhs_is_null = bop.lhs.data == .null_literal;
@@ -3295,8 +3363,15 @@ pub const Lowering = struct {
             default_bb = self.freshBlock("match.unr");
         }
 
-        // Switch on the subject (for type match, subject IS the tag; for enum match, extract tag)
-        const tag = if (is_type_match) subject else if (is_optional_match) self.builder.emit(.{ .optional_has_value = .{ .operand = subject } }, .bool) else blk: {
+        // Switch on the subject (for type match, subject is either a
+        // bare TypeId (s64) or an Any-shaped Type value — unbox in the
+        // latter case so the switch sees the i64 type id).
+        const tag = if (is_type_match) tag_blk: {
+            if (subject_ty == .any) {
+                break :tag_blk self.builder.emit(.{ .unbox_any = .{ .operand = subject } }, .s64);
+            }
+            break :tag_blk subject;
+        } else if (is_optional_match) self.builder.emit(.{ .optional_has_value = .{ .operand = subject } }, .bool) else blk: {
             // Determine actual tag type from union info (e.g. u32 for SDL_Event)
             const tag_ty: TypeId = tt: {
                 if (!subject_ty.isBuiltin()) {
@@ -8018,7 +8093,12 @@ pub const Lowering = struct {
         }
 
         // Lower the type tag (runtime value) and Any value BEFORE the switch
-        const type_tag = self.lowerExpr(type_tag_node orelse return self.emitError("dispatch", call_node.callee.span));
+        const type_tag_raw = self.lowerExpr(type_tag_node orelse return self.emitError("dispatch", call_node.callee.span));
+        const type_tag_node_ty = self.inferExprType(type_tag_node.?);
+        const type_tag = if (type_tag_node_ty == .any)
+            self.builder.emit(.{ .unbox_any = .{ .operand = type_tag_raw } }, .s64)
+        else
+            type_tag_raw;
         const any_val = self.lowerExpr(any_val_node orelse return self.emitError("dispatch", call_node.callee.span));
 
         // Lower non-cast arguments once (before the switch)
@@ -8290,6 +8370,9 @@ pub const Lowering = struct {
         const array_slot = self.builder.alloca(array_ty);
 
         for (arg_types, 0..) |ty, i| {
+            // `const_type` produces an `.any`-typed Type value
+            // (`{tag=.any, value=tid}`) — already the canonical Any
+            // shape, so no re-box needed.
             const type_val = self.builder.constType(ty);
             const idx_ref = self.builder.constInt(@intCast(i), .s64);
             const elem_ptr = self.builder.emit(.{ .index_gep = .{ .lhs = array_slot, .rhs = idx_ref } }, any_ptr_ty);
@@ -8923,7 +9006,7 @@ pub const Lowering = struct {
             //     `resolveTypeArg` silently returns "s64" for every
             //     dynamic call — exactly the silent-arm pattern the
             //     project's REJECTED PATTERNS forbid.
-            if (isStaticTypeArg(c.args[0])) {
+            if (self.isStaticTypeArg(c.args[0])) {
                 const ty = self.resolveTypeArg(c.args[0]);
                 const tn_str = self.formatTypeName(ty);
                 const sid = self.module.types.internString(tn_str);
@@ -9024,16 +9107,18 @@ pub const Lowering = struct {
             } }, .any);
         }
         if (std.mem.eql(u8, name, "type_of")) {
-            // type_of(val) — extract Any tag or produce compile-time constant
-            if (c.args.len < 1) return self.builder.constInt(0, .s64);
+            // type_of(val) — produce a Type value (.any-typed aggregate).
+            if (c.args.len < 1) return self.builder.constType(.void);
             const arg_ty = self.inferExprType(c.args[0]);
             if (arg_ty == .any) {
-                // Runtime: extract tag field (field 0 of Any {tag: s64, value: s64})
+                // Runtime: extract tag, rebuild Any with `{.any, tag}` so
+                // the returned value carries Type semantics (tag field
+                // says ".any" → the value field holds the type id).
                 const val = self.lowerExpr(c.args[0]);
-                return self.builder.structGet(val, 0, .s64);
+                const tag_val = self.builder.structGet(val, 0, .s64);
+                return self.builder.boxAny(tag_val, .any);
             } else {
-                // Static: emit type tag as constant
-                return self.builder.constInt(@intCast(@intFromEnum(arg_ty)), .s64);
+                return self.builder.constType(arg_ty);
             }
         }
         if (std.mem.eql(u8, name, "field_index")) {
@@ -9091,10 +9176,25 @@ pub const Lowering = struct {
     ///
     /// Dynamic shapes (index_expr, field_access, runtime locals,
     /// etc.) fall to the alternative path that emits a builtin_call.
-    fn isStaticTypeArg(node: *const Node) bool {
-        return switch (node.data) {
-            .type_expr,
-            .identifier,
+    fn isStaticTypeArg(self: *Lowering, node: *const Node) bool {
+        switch (node.data) {
+            .type_expr => |te| {
+                // A type-keyword name (e.g. `s64`) is always static.
+                // A user-defined name that happens to be in scope as
+                // a runtime variable (`x: Type = s64; type_name(x)`)
+                // is NOT static — route through the dynamic builtin
+                // call so the runtime lookup table fires.
+                if (self.scope) |scope| {
+                    if (scope.lookup(te.name) != null) return false;
+                }
+                return true;
+            },
+            .identifier => |id| {
+                if (self.scope) |scope| {
+                    if (scope.lookup(id.name) != null) return false;
+                }
+                return true;
+            },
             .pack_index_type_expr,
             .pointer_type_expr,
             .many_pointer_type_expr,
@@ -9104,9 +9204,59 @@ pub const Lowering = struct {
             .function_type_expr,
             .tuple_literal,
             .call,
-            => true,
-            else => false,
-        };
+            => return true,
+            else => return false,
+        }
+    }
+
+    /// True iff `node` is a Type-shaped expression that resolves to a
+    /// concrete TypeId at lower time WITHOUT being a runtime variable
+    /// reference. Differs from `isStaticTypeArg` in that we exclude
+    /// identifiers that are in scope as runtime locals/globals — those
+    /// are runtime Type values (e.g. `t: Type = f64`) and the
+    /// comparison fold can't statically resolve them.
+    fn isStaticTypeRef(self: *Lowering, node: *const Node) bool {
+        switch (node.data) {
+            .type_expr => |te| {
+                // Compound type names (`s64`, `Point`, `Vec4`) resolve
+                // statically. If the name is also a runtime var in
+                // scope, it's a value reference, not a type ref.
+                if (self.scope) |scope| {
+                    if (scope.lookup(te.name) != null) return false;
+                }
+                return self.isKnownTypeName(te.name) or
+                    self.module.types.findByName(self.module.types.internString(te.name)) != null or
+                    self.type_alias_map.get(te.name) != null;
+            },
+            .identifier => |id| {
+                if (self.scope) |scope| {
+                    if (scope.lookup(id.name) != null) return false;
+                }
+                return self.isKnownTypeName(id.name) or
+                    self.module.types.findByName(self.module.types.internString(id.name)) != null or
+                    self.type_alias_map.get(id.name) != null;
+            },
+            .pointer_type_expr,
+            .many_pointer_type_expr,
+            .array_type_expr,
+            .slice_type_expr,
+            .optional_type_expr,
+            .function_type_expr,
+            .pack_index_type_expr,
+            => return true,
+            .call => |cl| {
+                // `type_of(x)` resolves statically when `x`'s type is
+                // known — which it always is for a typed expression.
+                if (cl.callee.data == .identifier and
+                    std.mem.eql(u8, cl.callee.data.identifier.name, "type_of") and
+                    cl.args.len == 1)
+                {
+                    return true;
+                }
+                return false;
+            },
+            else => return false,
+        }
     }
 
     fn resolveTypeArg(self: *Lowering, node: *const Node) TypeId {
@@ -9170,6 +9320,18 @@ pub const Lowering = struct {
                 return type_bridge.resolveAstType(node, &self.module.types);
             },
             .call => |cl| {
+                // `type_of(x)` resolves to `inferExprType(x)` at lower
+                // time when `x`'s type is statically known (which it
+                // is for any expression — type inference always
+                // produces a concrete TypeId). Lets
+                // `type_of(a) == s64` fold the same as
+                // `inferExprType(a) == s64`.
+                if (cl.callee.data == .identifier and
+                    std.mem.eql(u8, cl.callee.data.identifier.name, "type_of") and
+                    cl.args.len == 1)
+                {
+                    return self.inferExprType(cl.args[0]);
+                }
                 // Handle type constructor calls: size_of(Sx(f32)), size_of(Complex(u32))
                 return self.resolveTypeCallWithBindings(&cl);
             },
@@ -12148,6 +12310,10 @@ pub const Lowering = struct {
                 if (self.module_const_map.get(id.name)) |ci| {
                     return ci.ty;
                 }
+                // A bare type name (alias like `Vec4`, struct name, or
+                // builtin primitive) referenced in expression position
+                // is a Type value — IR type `.any`.
+                if (self.isKnownTypeName(id.name)) return .any;
                 return .s64;
             },
             .type_expr => |te| {
@@ -12157,6 +12323,9 @@ pub const Lowering = struct {
                         return binding.ty;
                     }
                 }
+                // A bare type name in expression position (e.g. `s64`,
+                // `Point`, `*u8`) is a Type value — IR type `.any`.
+                if (self.isKnownTypeName(te.name)) return .any;
                 return .s64;
             },
             .enum_literal => {
@@ -12927,6 +13096,7 @@ pub const Lowering = struct {
         if (self.type_bindings) |bindings| {
             if (bindings.get(name) != null) return true;
         }
+        if (self.type_alias_map.get(name) != null) return true;
         const name_id = self.module.types.internString(name);
         return self.module.types.findByName(name_id) != null;
     }
diff --git a/src/ir/module.zig b/src/ir/module.zig
index 208324f..9affb95 100644
--- a/src/ir/module.zig
+++ b/src/ir/module.zig
@@ -385,6 +385,10 @@ pub const Builder = struct {
     /// fail loudly rather than silently materialise the TypeId as an
     /// int.
     pub fn constType(self: *Builder, tid: TypeId) Ref {
+        // Type values are Any-shaped at runtime —
+        // `{ tag = .any.index() (the meta-marker), value = tid }`.
+        // Matches `Type → .any` in `type_bridge`. The interp keeps
+        // the high-fidelity `.type_tag` Value for comptime ops.
         return self.emit(.{ .const_type = tid }, .any);
     }
 
diff --git a/src/ir/type_bridge.zig b/src/ir/type_bridge.zig
index bc4141f..f943db4 100644
--- a/src/ir/type_bridge.zig
+++ b/src/ir/type_bridge.zig
@@ -232,7 +232,15 @@ pub fn resolveTypePrimitive(name: []const u8) ?TypeId {
     if (std.mem.eql(u8, name, "string")) return .string;
     if (std.mem.eql(u8, name, "void")) return .void;
     if (std.mem.eql(u8, name, "Any")) return .any;
-    if (std.mem.eql(u8, name, "Type")) return .any; // Type-as-value: boxed string
+    // Type values are runtime-representable as Any-shaped pairs:
+    // `{ tag = .any.index() (the meta-marker), value = TypeId.index() }`.
+    // Lets `t : Type = f64; t == s64; print(t)` all route through the
+    // existing Any infrastructure — boxing/unboxing, `case type:`
+    // dispatch, runtime `type_name(t)` via the type-name lookup
+    // table. Comparison decomposes via the eq fold path
+    // (`isStaticTypeRef`) for static literals; runtime-var vs
+    // literal compares decompose at `lowerBinaryOp`.
+    if (std.mem.eql(u8, name, "Type")) return .any;
     if (std.mem.eql(u8, name, "noreturn")) return .noreturn;
     if (std.mem.eql(u8, name, "usize")) return .usize;
     if (std.mem.eql(u8, name, "isize")) return .isize;
diff --git a/src/ir/types.zig b/src/ir/types.zig
index 258d453..f8d2bec 100644
--- a/src/ir/types.zig
+++ b/src/ir/types.zig
@@ -466,6 +466,7 @@ pub const TypeTable = struct {
         if (ty == .s64 or ty == .u64 or ty == .f64) return 8;
         if (ty == .usize or ty == .isize) return ptr_size;
         if (ty == .string) return 16; // {ptr, i64} — always 16 (i64 alignment pads on wasm32)
+        if (ty == .any) return 16; // {i64 tag, i64 value} — Any boxed layout
         if (ty.isBuiltin()) return ptr_size; // default for unknown builtins
         const info = self.get(ty);
         return switch (info) {
@@ -564,6 +565,7 @@ pub const TypeTable = struct {
         if (ty == .s64 or ty == .u64 or ty == .f64) return 8;
         if (ty == .usize or ty == .isize) return ptr_align;
         if (ty == .string) return 8; // i64 drives alignment
+        if (ty == .any) return 8; // {i64, i64} aligns to 8
         if (ty.isBuiltin()) return ptr_align;
         const info = self.get(ty);
         return switch (info) {
@@ -650,6 +652,91 @@ pub const TypeTable = struct {
             },
         };
     }
+
+    /// Like `typeName` but produces structural names for compound
+    /// types (`*T`, `[]T`, `[N]T`, `?T`, `Vector(N,T)`, function and
+    /// tuple types) instead of returning `"?"`. Compound names are
+    /// freshly allocated via `alloc`; builtin and named user types
+    /// return borrowed slices.
+    pub fn formatTypeName(self: *const TypeTable, alloc: std.mem.Allocator, id: TypeId) []const u8 {
+        if (id.isBuiltin()) return self.typeName(id);
+        const info = self.get(id);
+        return switch (info) {
+            .@"struct" => |s| self.getString(s.name),
+            .@"enum" => |e| self.getString(e.name),
+            .@"union" => |u| self.getString(u.name),
+            .tagged_union => |u| self.getString(u.name),
+            .protocol => |p| self.getString(p.name),
+            .pointer => |p| blk: {
+                const inner = self.formatTypeName(alloc, p.pointee);
+                break :blk std.fmt.allocPrint(alloc, "*{s}", .{inner}) catch "*?";
+            },
+            .many_pointer => |p| blk: {
+                const inner = self.formatTypeName(alloc, p.element);
+                break :blk std.fmt.allocPrint(alloc, "[*]{s}", .{inner}) catch "[*]?";
+            },
+            .slice => |s| blk: {
+                const inner = self.formatTypeName(alloc, s.element);
+                break :blk std.fmt.allocPrint(alloc, "[]{s}", .{inner}) catch "[]?";
+            },
+            .array => |a| blk: {
+                const inner = self.formatTypeName(alloc, a.element);
+                break :blk std.fmt.allocPrint(alloc, "[{d}]{s}", .{ a.length, inner }) catch "[N]?";
+            },
+            .vector => |v| blk: {
+                const inner = self.formatTypeName(alloc, v.element);
+                break :blk std.fmt.allocPrint(alloc, "Vector({d},{s})", .{ v.length, inner }) catch "Vector(?)";
+            },
+            .optional => |o| blk: {
+                const inner = self.formatTypeName(alloc, o.child);
+                break :blk std.fmt.allocPrint(alloc, "?{s}", .{inner}) catch "?_";
+            },
+            .function => |f| blk: {
+                var buf = std.ArrayList(u8).empty;
+                defer buf.deinit(alloc);
+                buf.append(alloc, '(') catch break :blk "(?)";
+                for (f.params, 0..) |p, i| {
+                    if (i > 0) buf.appendSlice(alloc, ", ") catch break :blk "(?)";
+                    buf.appendSlice(alloc, self.formatTypeName(alloc, p)) catch break :blk "(?)";
+                }
+                buf.append(alloc, ')') catch break :blk "(?)";
+                if (f.ret != .void) {
+                    buf.appendSlice(alloc, " -> ") catch break :blk "(?)";
+                    buf.appendSlice(alloc, self.formatTypeName(alloc, f.ret)) catch break :blk "(?)";
+                }
+                break :blk buf.toOwnedSlice(alloc) catch "(?)";
+            },
+            .closure => |co| blk: {
+                var buf = std.ArrayList(u8).empty;
+                defer buf.deinit(alloc);
+                buf.appendSlice(alloc, "Closure(") catch break :blk "Closure(?)";
+                for (co.params, 0..) |p, i| {
+                    if (i > 0) buf.appendSlice(alloc, ", ") catch break :blk "Closure(?)";
+                    buf.appendSlice(alloc, self.formatTypeName(alloc, p)) catch break :blk "Closure(?)";
+                }
+                buf.append(alloc, ')') catch break :blk "Closure(?)";
+                if (co.ret != .void) {
+                    buf.appendSlice(alloc, " -> ") catch break :blk "Closure(?)";
+                    buf.appendSlice(alloc, self.formatTypeName(alloc, co.ret)) catch break :blk "Closure(?)";
+                }
+                break :blk buf.toOwnedSlice(alloc) catch "Closure(?)";
+            },
+            .tuple => |tu| blk: {
+                var buf = std.ArrayList(u8).empty;
+                defer buf.deinit(alloc);
+                buf.append(alloc, '(') catch break :blk "(?)";
+                for (tu.fields, 0..) |f, i| {
+                    if (i > 0) buf.appendSlice(alloc, ", ") catch break :blk "(?)";
+                    buf.appendSlice(alloc, self.formatTypeName(alloc, f)) catch break :blk "(?)";
+                }
+                buf.append(alloc, ')') catch break :blk "(?)";
+                break :blk buf.toOwnedSlice(alloc) catch "(?)";
+            },
+            .signed => |w| std.fmt.allocPrint(alloc, "s{d}", .{w}) catch "s?",
+            .unsigned => |w| std.fmt.allocPrint(alloc, "u{d}", .{w}) catch "u?",
+            else => self.typeName(id),
+        };
+    }
 };
 
 // ── Intern map support ──────────────────────────────────────────────────
diff --git a/tests/expected/12-meta.txt b/tests/expected/12-meta.txt
index 84b8809..aea7668 100644
--- a/tests/expected/12-meta.txt
+++ b/tests/expected/12-meta.txt
@@ -1,4 +1,4 @@
 f64
 3.200000
-Vec4
+Vector(4,f32)
 () -> s32
diff --git a/tests/expected/189-type-all-interactions.exit b/tests/expected/189-type-all-interactions.exit
new file mode 100644
index 0000000..573541a
--- /dev/null
+++ b/tests/expected/189-type-all-interactions.exit
@@ -0,0 +1 @@
+0
diff --git a/tests/expected/189-type-all-interactions.txt b/tests/expected/189-type-all-interactions.txt
new file mode 100644
index 0000000..6f4d0e5
--- /dev/null
+++ b/tests/expected/189-type-all-interactions.txt
@@ -0,0 +1,59 @@
+=== 1. literal == ===
+s64 == s64:    true
+s64 == string: false
+*u8 == *u8:    true
+?s64 == ?s64:  true
+?s64 == ?s32:  false
+=== 2. type_of(value) == T ===
+type_of(a) == s64:    true
+type_of(b) == f64:    true
+type_of(s) == string: true
+type_of(a) == f64:    false
+=== 3. Type variable storage ===
+t == f64:    true
+t == string: false
+after reassign t == string: true
+t == bool:   true
+=== 4. type_name ===
+type_name(s64):    s64
+type_name(*u8):    *u8
+type_name(Point):  Point
+type_name(Color):  Color
+type_name(t):      f64
+=== 5. print Type values ===
+literal: s64
+var:     string
+type_of(b): f64
+=== 6. generic dispatch ===
+describe(s64):    int64
+describe(string): text
+describe(bool):   boolean
+describe(f64):    other
+=== 7. identity($T, val) ===
+identity(s64, 7):     7
+identity(string, hi): hi
+identity(bool, true): true
+=== 8. Wrap($T) ===
+Wrap(s64).v:    42
+Wrap(string).v: wrapped
+=== 9. reflection on Type ===
+size_of(s64):      8
+size_of(*u8):      8
+align_of(f64):     8
+field_count(Point): 2
+type_eq(s64, s64):    true
+type_eq(s64, string): false
+=== 10. ..$args walking ===
+type_list():            []
+type_list(1):           [s64]
+type_list(1, "x"):    [s64, string]
+type_list(true, 3.14):  [bool, f64]
+=== 11. Type in struct field ===
+h.t == s64:    true
+h.t == string: false
+type_name(h.t): s64
+=== 12. compound literals ===
+type_name(*Point):    *Point
+type_name([4]s32):    [4]s32
+type_name([]bool):    []bool
+type_name(?f64):      ?f64
diff --git a/tests/expected/ffi-objc-call-06-sret-return.ir b/tests/expected/ffi-objc-call-06-sret-return.ir
index 42b66a9..bccf047 100644
--- a/tests/expected/ffi-objc-call-06-sret-return.ir
+++ b/tests/expected/ffi-objc-call-06-sret-return.ir
@@ -10,206 +10,285 @@
 @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
-@str.6 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
-@str.7 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
-@str.8 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
-@str.9 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
-@str.10 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
-@str.11 = private unnamed_addr constant [15 x i8] c"result := \22\22; \00", align 1
-@str.12 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
-@str.13 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@str.14 = private unnamed_addr constant [5 x i8] c")); \00", align 1
-@str.15 = private unnamed_addr constant [44 x i8] c"result = concat(result, any_to_string(args[\00", align 1
-@str.16 = private unnamed_addr constant [6 x i8] c"])); \00", align 1
-@str.17 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
-@str.18 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@str.19 = private unnamed_addr constant [5 x i8] c")); \00", align 1
-@str.20 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
-@str.21 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@str.22 = private unnamed_addr constant [5 x i8] c")); \00", align 1
-@str.23 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
-@str.24 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@str.25 = private unnamed_addr constant [5 x i8] c")); \00", align 1
-@str.26 = private unnamed_addr constant [9 x i8] c"NSObject\00", align 1
-@str.27 = private unnamed_addr constant [14 x i8] c"SxTripleProbe\00", align 1
-@str.28 = private unnamed_addr constant [12 x i8] c"tripleValue\00", align 1
-@str.29 = private unnamed_addr constant [15 x i8] c"{Triple=qqq}@:\00", align 1
-@str.30 = private unnamed_addr constant [16 x i8] c"addMethod = {}\0A\00", align 1
-@str.31 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
-@str.32 = private unnamed_addr constant [16 x i8] c"addMethod = {}\0A\00", align 1
-@str.33 = private unnamed_addr constant [23 x i8] c"triple = ({}, {}, {})\0A\00", align 1
-@str.34 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
-@str.35 = private unnamed_addr constant [23 x i8] c"triple = ({}, {}, {})\0A\00", align 1
-@str.36 = private unnamed_addr constant [10 x i8] c"Allocator\00", align 1
-@str.37 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.38 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.39 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@fld.str = private constant [4 x i8] c"ctx\00"
-@fld.str.40 = private constant [6 x i8] c"alloc\00"
-@fld.str.41 = 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.40, i64 5 }, { ptr, i64 } { ptr @fld.str.41, i64 7 }]
-@str.42 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.43 = private unnamed_addr constant [11 x i8] c"CAllocator\00", align 1
-@str.44 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.45 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.46 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@field_names.47 = private constant [0 x { ptr, i64 }] zeroinitializer
-@str.48 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.49 = private unnamed_addr constant [4 x i8] c"GPA\00", align 1
-@str.50 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.51 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.52 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@fld.str.53 = private constant [12 x i8] c"alloc_count\00"
-@field_names.54 = private constant [1 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.53, i64 11 }]
-@str.55 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.56 = private unnamed_addr constant [11 x i8] c"ArenaChunk\00", align 1
-@str.57 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.58 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.59 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@fld.str.60 = private constant [5 x i8] c"next\00"
-@fld.str.61 = private constant [4 x i8] c"cap\00"
-@field_names.62 = private constant [2 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.60, i64 4 }, { ptr, i64 } { ptr @fld.str.61, i64 3 }]
-@str.63 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.64 = private unnamed_addr constant [6 x i8] c"Arena\00", align 1
-@str.65 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.66 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.67 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@fld.str.68 = private constant [6 x i8] c"first\00"
-@fld.str.69 = private constant [10 x i8] c"end_index\00"
-@fld.str.70 = private constant [7 x i8] c"parent\00"
-@field_names.71 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.68, i64 5 }, { ptr, i64 } { ptr @fld.str.69, i64 9 }, { ptr, i64 } { ptr @fld.str.70, i64 6 }]
-@str.72 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.73 = private unnamed_addr constant [9 x i8] c"BufAlloc\00", align 1
-@str.74 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.75 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.76 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@fld.str.77 = private constant [4 x i8] c"buf\00"
-@fld.str.78 = private constant [4 x i8] c"len\00"
-@fld.str.79 = private constant [4 x i8] c"pos\00"
-@field_names.80 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.77, i64 3 }, { ptr, i64 } { ptr @fld.str.78, i64 3 }, { ptr, i64 } { ptr @fld.str.79, i64 3 }]
-@str.81 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.82 = private unnamed_addr constant [18 x i8] c"TrackingAllocator\00", align 1
-@str.83 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.84 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.85 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@fld.str.86 = private constant [7 x i8] c"parent\00"
-@fld.str.87 = private constant [12 x i8] c"alloc_count\00"
-@fld.str.88 = private constant [14 x i8] c"dealloc_count\00"
-@fld.str.89 = private constant [18 x i8] c"total_alloc_bytes\00"
-@field_names.90 = private constant [4 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.86, i64 6 }, { ptr, i64 } { ptr @fld.str.87, i64 11 }, { ptr, i64 } { ptr @fld.str.88, i64 13 }, { ptr, i64 } { ptr @fld.str.89, i64 17 }]
-@str.91 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.92 = private unnamed_addr constant [8 x i8] c"Context\00", align 1
-@str.93 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.94 = private unnamed_addr constant [2 x i8] c"}\00", align 1
+@tn.str = private constant [5 x i8] c"void\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"
+@tn.str.9 = private constant [4 x i8] c"s32\00"
+@tn.str.10 = private constant [4 x i8] c"s64\00"
+@tn.str.11 = private constant [3 x i8] c"u8\00"
+@tn.str.12 = private constant [4 x i8] c"u16\00"
+@tn.str.13 = private constant [4 x i8] c"u32\00"
+@tn.str.14 = private constant [4 x i8] c"u64\00"
+@tn.str.15 = private constant [4 x i8] c"f32\00"
+@tn.str.16 = private constant [4 x i8] c"f64\00"
+@tn.str.17 = private constant [7 x i8] c"string\00"
+@tn.str.18 = private constant [4 x i8] c"Any\00"
+@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
+@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
-@fld.str.96 = private constant [10 x i8] c"allocator\00"
-@fld.str.97 = private constant [5 x i8] c"data\00"
-@field_names.98 = private constant [2 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.96, i64 9 }, { ptr, i64 } { ptr @fld.str.97, i64 4 }]
-@str.99 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.100 = private unnamed_addr constant [13 x i8] c"BuildOptions\00", align 1
-@str.101 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.102 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.103 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@field_names.104 = private constant [0 x { ptr, i64 }] zeroinitializer
-@str.105 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.106 = private unnamed_addr constant [7 x i8] c"Triple\00", align 1
-@str.107 = private unnamed_addr constant [2 x i8] c"{\00", align 1
-@str.108 = private unnamed_addr constant [2 x i8] c"}\00", align 1
-@str.109 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@fld.str.110 = private constant [2 x i8] c"a\00"
-@fld.str.111 = private constant [2 x i8] c"b\00"
-@fld.str.112 = private constant [2 x i8] c"c\00"
-@field_names.113 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.110, i64 1 }, { ptr, i64 } { ptr @fld.str.111, i64 1 }, { ptr, i64 } { ptr @fld.str.112, i64 1 }]
-@str.114 = private unnamed_addr constant [3 x i8] c": \00", align 1
-@str.115 = private unnamed_addr constant [2 x i8] c".\00", align 1
-@fld.str.116 = private constant [6 x i8] c"macos\00"
-@fld.str.117 = private constant [6 x i8] c"linux\00"
-@fld.str.118 = private constant [8 x i8] c"windows\00"
-@fld.str.119 = private constant [5 x i8] c"wasm\00"
-@fld.str.120 = private constant [4 x i8] c"ios\00"
-@fld.str.121 = private constant [8 x i8] c"android\00"
-@fld.str.122 = private constant [8 x i8] c"unknown\00"
-@field_names.123 = private constant [7 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.116, i64 5 }, { ptr, i64 } { ptr @fld.str.117, i64 5 }, { ptr, i64 } { ptr @fld.str.118, i64 7 }, { ptr, i64 } { ptr @fld.str.119, i64 4 }, { ptr, i64 } { ptr @fld.str.120, i64 3 }, { ptr, i64 } { ptr @fld.str.121, i64 7 }, { ptr, i64 } { ptr @fld.str.122, i64 7 }]
-@str.124 = private unnamed_addr constant [2 x i8] c"(\00", align 1
-@str.125 = private unnamed_addr constant [2 x i8] c")\00", align 1
-@str.126 = private unnamed_addr constant [2 x i8] c".\00", align 1
-@fld.str.127 = private constant [8 x i8] c"aarch64\00"
-@fld.str.128 = private constant [7 x i8] c"x86_64\00"
-@fld.str.129 = private constant [7 x i8] c"wasm32\00"
-@fld.str.130 = private constant [7 x i8] c"wasm64\00"
-@fld.str.131 = private constant [8 x i8] c"unknown\00"
-@field_names.132 = private constant [5 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.127, i64 7 }, { ptr, i64 } { ptr @fld.str.128, i64 6 }, { ptr, i64 } { ptr @fld.str.129, i64 6 }, { ptr, i64 } { ptr @fld.str.130, i64 6 }, { ptr, i64 } { ptr @fld.str.131, i64 7 }]
-@str.133 = private unnamed_addr constant [2 x i8] c"(\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 [2 x i8] c"]\00", align 1
-@str.137 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@str.138 = private unnamed_addr constant [2 x i8] c"[\00", align 1
-@str.139 = private unnamed_addr constant [2 x i8] c"]\00", align 1
-@str.140 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@str.141 = private unnamed_addr constant [2 x i8] c"[\00", align 1
-@str.142 = private unnamed_addr constant [2 x i8] c"]\00", align 1
-@str.143 = private unnamed_addr constant [3 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 [2 x i8] c"]\00", align 1
-@str.146 = private unnamed_addr constant [3 x i8] c", \00", align 1
-@str.147 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.148 = private unnamed_addr constant [6 x i8] c"*void\00", align 1
-@str.149 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.150 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.151 = private unnamed_addr constant [12 x i8] c"*CAllocator\00", align 1
-@str.152 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.153 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.154 = private unnamed_addr constant [5 x i8] c"*GPA\00", align 1
-@str.155 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.156 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.157 = private unnamed_addr constant [12 x i8] c"*ArenaChunk\00", align 1
-@str.158 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.159 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.160 = private unnamed_addr constant [7 x i8] c"*Arena\00", align 1
-@str.161 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.162 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.163 = private unnamed_addr constant [6 x i8] c"[*]u8\00", align 1
-@str.164 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.165 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.166 = private unnamed_addr constant [10 x i8] c"*BufAlloc\00", align 1
-@str.167 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.168 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.169 = private unnamed_addr constant [19 x i8] c"*TrackingAllocator\00", align 1
-@str.170 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.171 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.172 = private unnamed_addr constant [13 x i8] c"**CAllocator\00", align 1
-@str.173 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.174 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.175 = private unnamed_addr constant [5 x i8] c"*s64\00", align 1
-@str.176 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.177 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.178 = private unnamed_addr constant [7 x i8] c"**void\00", align 1
-@str.179 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.180 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.181 = private unnamed_addr constant [6 x i8] c"*bool\00", align 1
-@str.182 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.183 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.184 = private unnamed_addr constant [8 x i8] c"*string\00", align 1
-@str.185 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.186 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.187 = private unnamed_addr constant [5 x i8] c"*Any\00", align 1
-@str.188 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.189 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.190 = private unnamed_addr constant [8 x i8] c"*[1]Any\00", align 1
-@str.191 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.192 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.193 = private unnamed_addr constant [7 x i8] c"*[]Any\00", align 1
-@str.194 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.195 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.196 = private unnamed_addr constant [4 x i8] c"*u8\00", align 1
-@str.197 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.198 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.199 = private unnamed_addr constant [8 x i8] c"*Triple\00", align 1
-@str.200 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
-@str.201 = private unnamed_addr constant [5 x i8] c"null\00", align 1
-@str.202 = private unnamed_addr constant [8 x i8] c"*[3]Any\00", align 1
-@str.203 = private unnamed_addr constant [4 x i8] c"@0x\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
+@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
 @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 }]
 
@@ -875,10 +954,12 @@ entry:
   store { ptr, i64 } { ptr @str.4, i64 3 }, ptr %allocaN, align 8
   %load = load { i64, i64 }, ptr %alloca, align 8
   %sg = extractvalue { i64, i64 } %load, 0
-  %allocaN = alloca i64, align 8
-  store i64 %sg, ptr %allocaN, align 8
-  %loadN = load i64, ptr %allocaN, align 8
-  switch i64 %loadN, label %match.unr.52 [
+  %ba.val = insertvalue { i64, i64 } { i64 13, i64 undef }, i64 %sg, 1
+  %allocaN = alloca { i64, i64 }, align 8
+  store { i64, i64 } %ba.val, ptr %allocaN, align 8
+  %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 2, label %match.arm.40
     i64 3, label %match.arm.40
@@ -942,16 +1023,16 @@ match.arm.39:                                     ; preds = %entry
 
 match.arm.40:                                     ; preds = %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry
   %loadN = load { i64, i64 }, ptr %alloca, align 8
-  %ua.raw = extractvalue { i64, i64 } %loadN, 1
-  %call = call { ptr, i64 } @int_to_string(ptr %0, i64 %ua.raw)
+  %ua.raw6 = extractvalue { i64, i64 } %loadN, 1
+  %call = call { ptr, i64 } @int_to_string(ptr %0, i64 %ua.raw6)
   store { ptr, i64 } %call, ptr %allocaN, align 8
   br label %match.merge.38
 
 match.arm.41:                                     ; preds = %entry
   %allocaN = alloca { ptr, i64 }, align 8
   %loadN = load { i64, i64 }, ptr %alloca, align 8
-  %ua.raw8 = extractvalue { i64, i64 } %loadN, 1
-  %ua.ptr = inttoptr i64 %ua.raw8 to ptr
+  %ua.raw9 = extractvalue { i64, i64 } %loadN, 1
+  %ua.ptr = inttoptr i64 %ua.raw9 to ptr
   %ua.load = load { ptr, i64 }, ptr %ua.ptr, align 8
   store { ptr, i64 } %ua.load, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
@@ -960,8 +1041,8 @@ match.arm.41:                                     ; preds = %entry
 
 match.arm.42:                                     ; preds = %entry
   %loadN = load { i64, i64 }, ptr %alloca, align 8
-  %ua.raw11 = extractvalue { i64, i64 } %loadN, 1
-  %tr = trunc i64 %ua.raw11 to i1
+  %ua.raw12 = extractvalue { i64, i64 } %loadN, 1
+  %tr = trunc i64 %ua.raw12 to i1
   %callN = call { ptr, i64 } @bool_to_string(ptr %0, i1 %tr)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %match.merge.38
@@ -974,10 +1055,11 @@ match.arm.43:                                     ; preds = %entry, %entry
   br i1 %icmp, label %fN.unbox.56, label %fN.unbox.57
 
 match.arm.44:                                     ; preds = %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry
-  %loadN = load i64, ptr %allocaN, align 8
+  %loadN = load { i64, i64 }, ptr %allocaN, align 8
+  %ua.raw18 = extractvalue { i64, i64 } %loadN, 1
   %loadN = load { i64, i64 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  switch i64 %loadN, label %dispatch.default.70 [
+  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
@@ -991,10 +1073,11 @@ match.arm.44:                                     ; preds = %entry, %entry, %ent
   ]
 
 match.arm.45:                                     ; preds = %entry, %entry
-  %loadN = load i64, ptr %allocaN, align 8
+  %loadN = load { i64, i64 }, ptr %allocaN, align 8
+  %ua.raw22 = extractvalue { i64, i64 } %loadN, 1
   %loadN = load { i64, i64 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  switch i64 %loadN, label %dispatch.default.132 [
+  switch i64 %ua.raw22, label %dispatch.default.132 [
     i64 34, label %dispatch.case.133
     i64 35, label %dispatch.case.134
   ]
@@ -1003,28 +1086,31 @@ match.arm.46:                                     ; No predecessors!
   unreachable
 
 match.arm.47:                                     ; preds = %entry, %entry
-  %loadN = load i64, ptr %allocaN, align 8
+  %loadN = load { i64, i64 }, ptr %allocaN, align 8
+  %ua.raw26 = extractvalue { i64, i64 } %loadN, 1
   %loadN = load { i64, i64 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  switch i64 %loadN, label %dispatch.default.140 [
+  switch i64 %ua.raw26, label %dispatch.default.140 [
     i64 47, label %dispatch.case.141
     i64 52, label %dispatch.case.142
   ]
 
 match.arm.48:                                     ; preds = %entry, %entry
-  %loadN = load i64, ptr %allocaN, align 8
+  %loadN = load { i64, i64 }, ptr %allocaN, align 8
+  %ua.raw30 = extractvalue { i64, i64 } %loadN, 1
   %loadN = load { i64, i64 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  switch i64 %loadN, label %dispatch.default.154 [
+  switch i64 %ua.raw30, label %dispatch.default.154 [
     i64 33, label %dispatch.case.155
     i64 45, 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
-  %loadN = load i64, ptr %allocaN, align 8
+  %loadN = load { i64, i64 }, ptr %allocaN, align 8
+  %ua.raw34 = extractvalue { i64, i64 } %loadN, 1
   %loadN = load { i64, i64 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  switch i64 %loadN, label %dispatch.default.168 [
+  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
@@ -1050,30 +1136,27 @@ match.arm.50:                                     ; No predecessors!
   unreachable
 
 match.arm.51:                                     ; preds = %entry
-  %allocaN = alloca { ptr, i64 }, align 8
   %loadN = load { i64, i64 }, ptr %alloca, align 8
-  %ua.raw33 = extractvalue { i64, i64 } %loadN, 1
-  %ua.ptr34 = inttoptr i64 %ua.raw33 to ptr
-  %ua.load35 = load { ptr, i64 }, ptr %ua.ptr34, align 8
-  store { ptr, i64 } %ua.load35, ptr %allocaN, align 8
-  %loadN = load { ptr, i64 }, ptr %allocaN, align 8
-  store { ptr, i64 } %loadN, ptr %allocaN, 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.load = load { ptr, i64 }, ptr %tn.gep, align 8
+  store { ptr, i64 } %tn.load, ptr %allocaN, align 8
   br label %match.merge.38
 
 match.unr.52:                                     ; preds = %entry
   br label %match.merge.38
 
 f32.unbox.56:                                     ; preds = %match.arm.43
-  %ua.raw37 = extractvalue { i64, i64 } %loadN, 1
-  %trN = trunc i64 %ua.raw37 to i32
+  %ua.raw38 = extractvalue { i64, i64 } %loadN, 1
+  %trN = trunc i64 %ua.raw38 to i32
   %iNf = bitcast i32 %trN to float
   %fpext = fpext float %iNf to double
   store double %fpext, ptr %allocaN, align 8
   br label %float.merge.58
 
 f64.unbox.57:                                     ; preds = %match.arm.43
-  %ua.raw38 = extractvalue { i64, i64 } %loadN, 1
-  %iNd = bitcast i64 %ua.raw38 to double
+  %ua.raw39 = extractvalue { i64, i64 } %loadN, 1
+  %iNd = bitcast i64 %ua.raw39 to double
   store double %iNd, ptr %allocaN, align 8
   br label %float.merge.58
 
@@ -1089,86 +1172,86 @@ dispatch.merge.69:                                ; preds = %dispatch.case.80, %
   br label %match.merge.38
 
 dispatch.default.70:                              ; preds = %match.arm.44
-  store { ptr, i64 } { ptr @str.6, i64 0 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.83, i64 0 }, ptr %allocaN, align 8
   br label %dispatch.merge.69
 
 dispatch.case.71:                                 ; preds = %match.arm.44
-  %ua.raw42 = extractvalue { i64, i64 } %loadN, 1
-  %ua.ptr43 = inttoptr i64 %ua.raw42 to ptr
-  %ua.load44 = load { ptr, ptr, ptr }, ptr %ua.ptr43, align 8
-  %callN = call { ptr, i64 } @struct_to_string__Allocator(ptr %0, { ptr, ptr, ptr } %ua.load44)
+  %ua.raw43 = extractvalue { i64, i64 } %loadN, 1
+  %ua.ptr44 = inttoptr i64 %ua.raw43 to ptr
+  %ua.load45 = load { ptr, ptr, ptr }, ptr %ua.ptr44, align 8
+  %callN = call { ptr, i64 } @struct_to_string__Allocator(ptr %0, { ptr, ptr, ptr } %ua.load45)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.69
 
 dispatch.case.72:                                 ; preds = %match.arm.44
-  %ua.raw46 = extractvalue { i64, i64 } %loadN, 1
-  %ua.ptr47 = inttoptr i64 %ua.raw46 to ptr
-  %ua.load48 = load {}, ptr %ua.ptr47, align 1
-  %callN = call { ptr, i64 } @struct_to_string__CAllocator(ptr %0, {} %ua.load48)
+  %ua.raw47 = extractvalue { i64, i64 } %loadN, 1
+  %ua.ptr48 = inttoptr i64 %ua.raw47 to ptr
+  %ua.load49 = load {}, ptr %ua.ptr48, align 1
+  %callN = call { ptr, i64 } @struct_to_string__CAllocator(ptr %0, {} %ua.load49)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.69
 
 dispatch.case.73:                                 ; preds = %match.arm.44
-  %ua.raw50 = extractvalue { i64, i64 } %loadN, 1
-  %ua.ptr51 = inttoptr i64 %ua.raw50 to ptr
-  %ua.load52 = load { i64 }, ptr %ua.ptr51, align 8
-  %callN = call { ptr, i64 } @struct_to_string__GPA(ptr %0, { i64 } %ua.load52)
+  %ua.raw51 = extractvalue { i64, i64 } %loadN, 1
+  %ua.ptr52 = inttoptr i64 %ua.raw51 to ptr
+  %ua.load53 = load { i64 }, ptr %ua.ptr52, align 8
+  %callN = call { ptr, i64 } @struct_to_string__GPA(ptr %0, { i64 } %ua.load53)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.69
 
 dispatch.case.74:                                 ; preds = %match.arm.44
-  %ua.raw54 = extractvalue { i64, i64 } %loadN, 1
-  %ua.ptr55 = inttoptr i64 %ua.raw54 to ptr
-  %ua.load56 = load { ptr, i64 }, ptr %ua.ptr55, align 8
-  %callN = call { ptr, i64 } @struct_to_string__ArenaChunk(ptr %0, { ptr, i64 } %ua.load56)
+  %ua.raw55 = extractvalue { i64, i64 } %loadN, 1
+  %ua.ptr56 = inttoptr i64 %ua.raw55 to ptr
+  %ua.load57 = load { ptr, i64 }, ptr %ua.ptr56, align 8
+  %callN = call { ptr, i64 } @struct_to_string__ArenaChunk(ptr %0, { ptr, i64 } %ua.load57)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.69
 
 dispatch.case.75:                                 ; preds = %match.arm.44
-  %ua.raw58 = extractvalue { i64, i64 } %loadN, 1
-  %ua.ptr59 = inttoptr i64 %ua.raw58 to ptr
-  %ua.load60 = load { ptr, i64, { ptr, ptr, ptr } }, ptr %ua.ptr59, align 8
-  %callN = call { ptr, i64 } @struct_to_string__Arena(ptr %0, { ptr, i64, { ptr, ptr, ptr } } %ua.load60)
+  %ua.raw59 = extractvalue { i64, i64 } %loadN, 1
+  %ua.ptr60 = inttoptr i64 %ua.raw59 to ptr
+  %ua.load61 = load { ptr, i64, { ptr, ptr, ptr } }, ptr %ua.ptr60, align 8
+  %callN = call { ptr, i64 } @struct_to_string__Arena(ptr %0, { ptr, i64, { ptr, ptr, ptr } } %ua.load61)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.69
 
 dispatch.case.76:                                 ; preds = %match.arm.44
-  %ua.raw62 = extractvalue { i64, i64 } %loadN, 1
-  %ua.ptr63 = inttoptr i64 %ua.raw62 to ptr
-  %ua.load64 = load { ptr, i64, i64 }, ptr %ua.ptr63, align 8
-  %callN = call { ptr, i64 } @struct_to_string__BufAlloc(ptr %0, { ptr, i64, i64 } %ua.load64)
+  %ua.raw63 = extractvalue { i64, i64 } %loadN, 1
+  %ua.ptr64 = inttoptr i64 %ua.raw63 to ptr
+  %ua.load65 = load { ptr, i64, i64 }, ptr %ua.ptr64, align 8
+  %callN = call { ptr, i64 } @struct_to_string__BufAlloc(ptr %0, { ptr, i64, i64 } %ua.load65)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.69
 
 dispatch.case.77:                                 ; preds = %match.arm.44
-  %ua.raw66 = extractvalue { i64, i64 } %loadN, 1
-  %ua.ptr67 = inttoptr i64 %ua.raw66 to ptr
-  %ua.load68 = load { { ptr, ptr, ptr }, i64, i64, i64 }, ptr %ua.ptr67, align 8
-  %callN = call { ptr, i64 } @struct_to_string__TrackingAllocator(ptr %0, { { ptr, ptr, ptr }, i64, i64, i64 } %ua.load68)
+  %ua.raw67 = extractvalue { i64, i64 } %loadN, 1
+  %ua.ptr68 = inttoptr i64 %ua.raw67 to ptr
+  %ua.load69 = load { { ptr, ptr, ptr }, i64, i64, i64 }, ptr %ua.ptr68, align 8
+  %callN = call { ptr, i64 } @struct_to_string__TrackingAllocator(ptr %0, { { ptr, ptr, ptr }, i64, i64, i64 } %ua.load69)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.69
 
 dispatch.case.78:                                 ; preds = %match.arm.44
-  %ua.raw70 = extractvalue { i64, i64 } %loadN, 1
-  %ua.ptr71 = inttoptr i64 %ua.raw70 to ptr
-  %ua.load72 = load { { ptr, ptr, ptr }, ptr }, ptr %ua.ptr71, align 8
-  %callN = call { ptr, i64 } @struct_to_string__Context(ptr %0, { { ptr, ptr, ptr }, ptr } %ua.load72)
+  %ua.raw71 = extractvalue { i64, i64 } %loadN, 1
+  %ua.ptr72 = inttoptr i64 %ua.raw71 to ptr
+  %ua.load73 = load { { ptr, ptr, ptr }, ptr }, ptr %ua.ptr72, align 8
+  %callN = call { ptr, i64 } @struct_to_string__Context(ptr %0, { { ptr, ptr, ptr }, ptr } %ua.load73)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.69
 
 dispatch.case.79:                                 ; preds = %match.arm.44
-  %ua.raw74 = extractvalue { i64, i64 } %loadN, 1
-  %ua.ptr75 = inttoptr i64 %ua.raw74 to ptr
-  %ua.load76 = load {}, ptr %ua.ptr75, align 1
-  %callN = call { ptr, i64 } @struct_to_string__BuildOptions(ptr %0, {} %ua.load76)
+  %ua.raw75 = extractvalue { i64, i64 } %loadN, 1
+  %ua.ptr76 = inttoptr i64 %ua.raw75 to ptr
+  %ua.load77 = load {}, ptr %ua.ptr76, align 1
+  %callN = call { ptr, i64 } @struct_to_string__BuildOptions(ptr %0, {} %ua.load77)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.69
 
 dispatch.case.80:                                 ; preds = %match.arm.44
-  %ua.raw78 = extractvalue { i64, i64 } %loadN, 1
-  %ua.ptr79 = inttoptr i64 %ua.raw78 to ptr
-  %ua.load80 = load { i64, i64, i64 }, ptr %ua.ptr79, align 8
-  %callN = call { ptr, i64 } @struct_to_string__Triple(ptr %0, { i64, i64, i64 } %ua.load80)
+  %ua.raw79 = extractvalue { i64, i64 } %loadN, 1
+  %ua.ptr80 = inttoptr i64 %ua.raw79 to ptr
+  %ua.load81 = load { i64, i64, i64 }, ptr %ua.ptr80, align 8
+  %callN = call { ptr, i64 } @struct_to_string__Triple(ptr %0, { i64, i64, i64 } %ua.load81)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.69
 
@@ -1178,18 +1261,18 @@ dispatch.merge.131:                               ; preds = %dispatch.case.134,
   br label %match.merge.38
 
 dispatch.default.132:                             ; preds = %match.arm.45
-  store { ptr, i64 } { ptr @str.7, i64 0 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.84, i64 0 }, ptr %allocaN, align 8
   br label %dispatch.merge.131
 
 dispatch.case.133:                                ; preds = %match.arm.45
-  %ua.raw83 = extractvalue { i64, i64 } %loadN, 1
-  %callN = call { ptr, i64 } @enum_to_string__OperatingSystem(ptr %0, i64 %ua.raw83)
+  %ua.raw84 = extractvalue { i64, i64 } %loadN, 1
+  %callN = call { ptr, i64 } @enum_to_string__OperatingSystem(ptr %0, i64 %ua.raw84)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.131
 
 dispatch.case.134:                                ; preds = %match.arm.45
-  %ua.raw85 = extractvalue { i64, i64 } %loadN, 1
-  %callN = call { ptr, i64 } @enum_to_string__Architecture(ptr %0, i64 %ua.raw85)
+  %ua.raw86 = extractvalue { i64, i64 } %loadN, 1
+  %callN = call { ptr, i64 } @enum_to_string__Architecture(ptr %0, i64 %ua.raw86)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.131
 
@@ -1199,22 +1282,22 @@ dispatch.merge.139:                               ; preds = %dispatch.case.142,
   br label %match.merge.38
 
 dispatch.default.140:                             ; preds = %match.arm.47
-  store { ptr, i64 } { ptr @str.8, i64 0 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.85, i64 0 }, ptr %allocaN, align 8
   br label %dispatch.merge.139
 
 dispatch.case.141:                                ; preds = %match.arm.47
-  %ua.raw88 = extractvalue { i64, i64 } %loadN, 1
-  %ua.ptr89 = inttoptr i64 %ua.raw88 to ptr
-  %ua.load90 = load [1 x { i64, i64 }], ptr %ua.ptr89, align 8
-  %callN = call { ptr, i64 } @array_to_string__AR_1_Any(ptr %0, [1 x { i64, i64 }] %ua.load90)
+  %ua.raw89 = extractvalue { i64, i64 } %loadN, 1
+  %ua.ptr90 = inttoptr i64 %ua.raw89 to ptr
+  %ua.load91 = load [1 x { i64, i64 }], ptr %ua.ptr90, align 8
+  %callN = call { ptr, i64 } @array_to_string__AR_1_Any(ptr %0, [1 x { i64, i64 }] %ua.load91)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.139
 
 dispatch.case.142:                                ; preds = %match.arm.47
-  %ua.raw92 = extractvalue { i64, i64 } %loadN, 1
-  %ua.ptr93 = inttoptr i64 %ua.raw92 to ptr
-  %ua.load94 = load [3 x { i64, i64 }], ptr %ua.ptr93, align 8
-  %callN = call { ptr, i64 } @array_to_string__AR_3_Any(ptr %0, [3 x { i64, i64 }] %ua.load94)
+  %ua.raw93 = extractvalue { i64, i64 } %loadN, 1
+  %ua.ptr94 = inttoptr i64 %ua.raw93 to ptr
+  %ua.load95 = load [3 x { i64, i64 }], ptr %ua.ptr94, align 8
+  %callN = call { ptr, i64 } @array_to_string__AR_3_Any(ptr %0, [3 x { i64, i64 }] %ua.load95)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.139
 
@@ -1224,22 +1307,22 @@ dispatch.merge.153:                               ; preds = %dispatch.case.156,
   br label %match.merge.38
 
 dispatch.default.154:                             ; preds = %match.arm.48
-  store { ptr, i64 } { ptr @str.9, i64 0 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.86, i64 0 }, ptr %allocaN, align 8
   br label %dispatch.merge.153
 
 dispatch.case.155:                                ; preds = %match.arm.48
-  %ua.raw97 = extractvalue { i64, i64 } %loadN, 1
-  %ua.ptr98 = inttoptr i64 %ua.raw97 to ptr
-  %ua.load99 = load { ptr, i64 }, ptr %ua.ptr98, align 8
-  %callN = call { ptr, i64 } @slice_to_string__string(ptr %0, { ptr, i64 } %ua.load99)
+  %ua.raw98 = extractvalue { i64, i64 } %loadN, 1
+  %ua.ptr99 = inttoptr i64 %ua.raw98 to ptr
+  %ua.load100 = load { ptr, i64 }, ptr %ua.ptr99, align 8
+  %callN = call { ptr, i64 } @slice_to_string__string(ptr %0, { ptr, i64 } %ua.load100)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.153
 
 dispatch.case.156:                                ; preds = %match.arm.48
-  %ua.raw101 = extractvalue { i64, i64 } %loadN, 1
-  %ua.ptr102 = inttoptr i64 %ua.raw101 to ptr
-  %ua.load103 = load { ptr, i64 }, ptr %ua.ptr102, align 8
-  %callN = call { ptr, i64 } @slice_to_string__Any(ptr %0, { ptr, i64 } %ua.load103)
+  %ua.raw102 = extractvalue { i64, i64 } %loadN, 1
+  %ua.ptr103 = inttoptr i64 %ua.raw102 to ptr
+  %ua.load104 = load { ptr, i64 }, ptr %ua.ptr103, align 8
+  %callN = call { ptr, i64 } @slice_to_string__Any(ptr %0, { ptr, i64 } %ua.load104)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.153
 
@@ -1249,139 +1332,139 @@ dispatch.merge.167:                               ; preds = %dispatch.case.187,
   br label %match.merge.38
 
 dispatch.default.168:                             ; preds = %match.arm.49
-  store { ptr, i64 } { ptr @str.10, i64 0 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.87, i64 0 }, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.169:                                ; preds = %match.arm.49
-  %ua.raw106 = extractvalue { i64, i64 } %loadN, 1
-  %iNp = inttoptr i64 %ua.raw106 to ptr
+  %ua.raw107 = extractvalue { i64, i64 } %loadN, 1
+  %iNp = inttoptr i64 %ua.raw107 to ptr
   %callN = call { ptr, i64 } @pointer_to_string__ptr_void(ptr %0, ptr %iNp)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.170:                                ; preds = %match.arm.49
-  %ua.raw108 = extractvalue { i64, i64 } %loadN, 1
-  %iNp109 = inttoptr i64 %ua.raw108 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__ptr_CAllocator(ptr %0, ptr %iNp109)
+  %ua.raw109 = extractvalue { i64, i64 } %loadN, 1
+  %iNp110 = inttoptr i64 %ua.raw109 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__ptr_CAllocator(ptr %0, ptr %iNp110)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.171:                                ; preds = %match.arm.49
-  %ua.raw111 = extractvalue { i64, i64 } %loadN, 1
-  %iNp112 = inttoptr i64 %ua.raw111 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__ptr_GPA(ptr %0, ptr %iNp112)
+  %ua.raw112 = extractvalue { i64, i64 } %loadN, 1
+  %iNp113 = inttoptr i64 %ua.raw112 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__ptr_GPA(ptr %0, ptr %iNp113)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.172:                                ; preds = %match.arm.49
-  %ua.raw114 = extractvalue { i64, i64 } %loadN, 1
-  %iNp115 = inttoptr i64 %ua.raw114 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__ptr_ArenaChunk(ptr %0, ptr %iNp115)
+  %ua.raw115 = extractvalue { i64, i64 } %loadN, 1
+  %iNp116 = inttoptr i64 %ua.raw115 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__ptr_ArenaChunk(ptr %0, ptr %iNp116)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.173:                                ; preds = %match.arm.49
-  %ua.raw117 = extractvalue { i64, i64 } %loadN, 1
-  %iNp118 = inttoptr i64 %ua.raw117 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__ptr_Arena(ptr %0, ptr %iNp118)
+  %ua.raw118 = extractvalue { i64, i64 } %loadN, 1
+  %iNp119 = inttoptr i64 %ua.raw118 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__ptr_Arena(ptr %0, ptr %iNp119)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.174:                                ; preds = %match.arm.49
-  %ua.raw120 = extractvalue { i64, i64 } %loadN, 1
-  %iNp121 = inttoptr i64 %ua.raw120 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__mptr_u8(ptr %0, ptr %iNp121)
+  %ua.raw121 = extractvalue { i64, i64 } %loadN, 1
+  %iNp122 = inttoptr i64 %ua.raw121 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__mptr_u8(ptr %0, ptr %iNp122)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.175:                                ; preds = %match.arm.49
-  %ua.raw123 = extractvalue { i64, i64 } %loadN, 1
-  %iNp124 = inttoptr i64 %ua.raw123 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__ptr_BufAlloc(ptr %0, ptr %iNp124)
+  %ua.raw124 = extractvalue { i64, i64 } %loadN, 1
+  %iNp125 = inttoptr i64 %ua.raw124 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__ptr_BufAlloc(ptr %0, ptr %iNp125)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.176:                                ; preds = %match.arm.49
-  %ua.raw126 = extractvalue { i64, i64 } %loadN, 1
-  %iNp127 = inttoptr i64 %ua.raw126 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__ptr_TrackingAllocator(ptr %0, ptr %iNp127)
+  %ua.raw127 = extractvalue { i64, i64 } %loadN, 1
+  %iNp128 = inttoptr i64 %ua.raw127 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__ptr_TrackingAllocator(ptr %0, ptr %iNp128)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.177:                                ; preds = %match.arm.49
-  %ua.raw129 = extractvalue { i64, i64 } %loadN, 1
-  %iNp130 = inttoptr i64 %ua.raw129 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__ptr_ptr_CAllocator(ptr %0, ptr %iNp130)
+  %ua.raw130 = extractvalue { i64, i64 } %loadN, 1
+  %iNp131 = inttoptr i64 %ua.raw130 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__ptr_ptr_CAllocator(ptr %0, ptr %iNp131)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.178:                                ; preds = %match.arm.49
-  %ua.raw132 = extractvalue { i64, i64 } %loadN, 1
-  %iNp133 = inttoptr i64 %ua.raw132 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__ptr_s64(ptr %0, ptr %iNp133)
+  %ua.raw133 = extractvalue { i64, i64 } %loadN, 1
+  %iNp134 = inttoptr i64 %ua.raw133 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__ptr_s64(ptr %0, ptr %iNp134)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.179:                                ; preds = %match.arm.49
-  %ua.raw135 = extractvalue { i64, i64 } %loadN, 1
-  %iNp136 = inttoptr i64 %ua.raw135 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__ptr_ptr_void(ptr %0, ptr %iNp136)
+  %ua.raw136 = extractvalue { i64, i64 } %loadN, 1
+  %iNp137 = inttoptr i64 %ua.raw136 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__ptr_ptr_void(ptr %0, ptr %iNp137)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.180:                                ; preds = %match.arm.49
-  %ua.raw138 = extractvalue { i64, i64 } %loadN, 1
-  %iNp139 = inttoptr i64 %ua.raw138 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__ptr_bool(ptr %0, ptr %iNp139)
+  %ua.raw139 = extractvalue { i64, i64 } %loadN, 1
+  %iNp140 = inttoptr i64 %ua.raw139 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__ptr_bool(ptr %0, ptr %iNp140)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.181:                                ; preds = %match.arm.49
-  %ua.raw141 = extractvalue { i64, i64 } %loadN, 1
-  %iNp142 = inttoptr i64 %ua.raw141 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__ptr_string(ptr %0, ptr %iNp142)
+  %ua.raw142 = extractvalue { i64, i64 } %loadN, 1
+  %iNp143 = inttoptr i64 %ua.raw142 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__ptr_string(ptr %0, ptr %iNp143)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.182:                                ; preds = %match.arm.49
-  %ua.raw144 = extractvalue { i64, i64 } %loadN, 1
-  %iNp145 = inttoptr i64 %ua.raw144 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__ptr_Any(ptr %0, ptr %iNp145)
+  %ua.raw145 = extractvalue { i64, i64 } %loadN, 1
+  %iNp146 = inttoptr i64 %ua.raw145 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__ptr_Any(ptr %0, ptr %iNp146)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.183:                                ; preds = %match.arm.49
-  %ua.raw147 = extractvalue { i64, i64 } %loadN, 1
-  %iNp148 = inttoptr i64 %ua.raw147 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__ptr_AR_1_Any(ptr %0, ptr %iNp148)
+  %ua.raw148 = extractvalue { i64, i64 } %loadN, 1
+  %iNp149 = inttoptr i64 %ua.raw148 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__ptr_AR_1_Any(ptr %0, ptr %iNp149)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.184:                                ; preds = %match.arm.49
-  %ua.raw150 = extractvalue { i64, i64 } %loadN, 1
-  %iNp151 = inttoptr i64 %ua.raw150 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__ptr_SL_Any(ptr %0, ptr %iNp151)
+  %ua.raw151 = extractvalue { i64, i64 } %loadN, 1
+  %iNp152 = inttoptr i64 %ua.raw151 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__ptr_SL_Any(ptr %0, ptr %iNp152)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.185:                                ; preds = %match.arm.49
-  %ua.raw153 = extractvalue { i64, i64 } %loadN, 1
-  %iNp154 = inttoptr i64 %ua.raw153 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__ptr_u8(ptr %0, ptr %iNp154)
+  %ua.raw154 = extractvalue { i64, i64 } %loadN, 1
+  %iNp155 = inttoptr i64 %ua.raw154 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__ptr_u8(ptr %0, ptr %iNp155)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.186:                                ; preds = %match.arm.49
-  %ua.raw156 = extractvalue { i64, i64 } %loadN, 1
-  %iNp157 = inttoptr i64 %ua.raw156 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__ptr_Triple(ptr %0, ptr %iNp157)
+  %ua.raw157 = extractvalue { i64, i64 } %loadN, 1
+  %iNp158 = inttoptr i64 %ua.raw157 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__ptr_Triple(ptr %0, ptr %iNp158)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 
 dispatch.case.187:                                ; preds = %match.arm.49
-  %ua.raw159 = extractvalue { i64, i64 } %loadN, 1
-  %iNp160 = inttoptr i64 %ua.raw159 to ptr
-  %callN = call { ptr, i64 } @pointer_to_string__ptr_AR_3_Any(ptr %0, ptr %iNp160)
+  %ua.raw160 = extractvalue { i64, i64 } %loadN, 1
+  %iNp161 = inttoptr i64 %ua.raw160 to ptr
+  %callN = call { ptr, i64 } @pointer_to_string__ptr_AR_3_Any(ptr %0, ptr %iNp161)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %dispatch.merge.167
 }
@@ -1392,7 +1475,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.11, i64 14 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.88, i64 14 }, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
   store i64 0, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -1488,7 +1571,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.12, i64 36 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.89, 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
@@ -1496,7 +1579,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.13, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.90, 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
@@ -1506,13 +1589,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.14, i64 4 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.91, 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.15, i64 43 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.92, 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
@@ -1520,7 +1603,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.16, i64 5 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.93, i64 5 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
   %addN = add i64 %loadN, 1
@@ -1534,7 +1617,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.17, i64 36 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.94, 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
@@ -1542,7 +1625,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.18, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.95, 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
@@ -1553,7 +1636,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.19, i64 4 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.96, i64 4 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
   %addN = add i64 %loadN, 2
@@ -1610,7 +1693,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.20, i64 36 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.97, 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
@@ -1618,7 +1701,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.21, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.98, 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
@@ -1629,7 +1712,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.22, i64 4 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.99, i64 4 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load i64, ptr %allocaN, align 8
   %addN = add i64 %loadN, 2
@@ -1649,7 +1732,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.23, i64 36 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.100, 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
@@ -1657,7 +1740,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.24, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.101, 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
@@ -1668,7 +1751,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.25, i64 4 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.102, i64 4 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.37
 
@@ -1860,19 +1943,19 @@ entry:
 define i32 @main() #0 {
 entry:
   call void @__sx_objc_selector_init()
-  %call = call ptr @objc_getClass(ptr @str.26)
+  %call = call ptr @objc_getClass(ptr @str.103)
   %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.27, i64 0)
+  %callN = call ptr @objc_allocateClassPair(ptr %load, ptr @str.104, i64 0)
   %allocaN = alloca ptr, align 8
   store ptr %callN, ptr %allocaN, align 8
-  %callN = call ptr @sel_registerName(ptr @str.28)
+  %callN = call ptr @sel_registerName(ptr @str.105)
   %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.29)
+  %callN = call i1 @class_addMethod(ptr %loadN, ptr %loadN, ptr @triple_imp, ptr @str.106)
   %allocaN = alloca i1, align 1
   store i1 %callN, ptr %allocaN, align 1
   %loadN = load i1, ptr %allocaN, align 1
@@ -1918,7 +2001,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.30, i64 15 }, ptr %alloca, align 8
+  store { ptr, i64 } { ptr @str.107, 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
@@ -1934,7 +2017,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.31, i64 0 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.108, 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)
@@ -1962,7 +2045,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.32, i64 15 })
+  %call = call { ptr, i64 } @build_format(ptr %0, { ptr, i64 } { ptr @str.109, i64 15 })
   ret { ptr, i64 } %call
 }
 
@@ -1970,7 +2053,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.33, i64 22 }, ptr %alloca, align 8
+  store { ptr, i64 } { ptr @str.110, i64 22 }, ptr %alloca, align 8
   %allocaN = alloca i64, align 8
   store i64 %1, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -1997,7 +2080,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.34, i64 0 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.111, 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)
@@ -2046,7 +2129,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.35, i64 22 })
+  %call = call { ptr, i64 } @build_format(ptr %0, { ptr, i64 } { ptr @str.112, i64 22 })
   ret { ptr, i64 } %call
 }
 
@@ -2055,7 +2138,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.36, i64 9 }, { ptr, i64 } { ptr @str.37, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.113, i64 9 }, { ptr, i64 } { ptr @str.114, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2074,12 +2157,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.38, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.115, 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.39, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.116, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.85
 
@@ -2091,7 +2174,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.42, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.119, 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
@@ -2139,7 +2222,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.43, i64 10 }, { ptr, i64 } { ptr @str.44, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.120, i64 10 }, { ptr, i64 } { ptr @str.121, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2158,24 +2241,24 @@ 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.45, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.122, 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.46, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.123, 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.47, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [0 x { ptr, i64 }], ptr @field_names.124, 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.48, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.125, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load {}, ptr %alloca, align 1
@@ -2194,7 +2277,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.49, i64 3 }, { ptr, i64 } { ptr @str.50, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.126, i64 3 }, { ptr, i64 } { ptr @str.127, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2213,24 +2296,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.51, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.128, 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.52, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.129, 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.54, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [1 x { ptr, i64 }], ptr @field_names.131, 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.55, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.132, 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
@@ -2263,7 +2346,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.56, i64 10 }, { ptr, i64 } { ptr @str.57, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.133, i64 10 }, { ptr, i64 } { ptr @str.134, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2282,24 +2365,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.58, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.135, 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.59, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.136, 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.62, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [2 x { ptr, i64 }], ptr @field_names.139, 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.63, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.140, 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
@@ -2339,7 +2422,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.64, i64 5 }, { ptr, i64 } { ptr @str.65, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.141, i64 5 }, { ptr, i64 } { ptr @str.142, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2358,24 +2441,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.66, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.143, 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.67, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.144, 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.71, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [3 x { ptr, i64 }], ptr @field_names.148, 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.72, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.149, 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
@@ -2424,7 +2507,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.73, i64 8 }, { ptr, i64 } { ptr @str.74, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.150, i64 8 }, { ptr, i64 } { ptr @str.151, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2443,24 +2526,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.75, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.152, 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.76, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.153, 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.80, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [3 x { ptr, i64 }], ptr @field_names.157, 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.81, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.158, 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
@@ -2506,7 +2589,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.82, i64 17 }, { ptr, i64 } { ptr @str.83, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.159, i64 17 }, { ptr, i64 } { ptr @str.160, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2525,24 +2608,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.84, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.161, 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.85, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.162, 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.90, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [4 x { ptr, i64 }], ptr @field_names.167, 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.91, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.168, 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
@@ -2596,7 +2679,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.92, i64 7 }, { ptr, i64 } { ptr @str.93, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.169, i64 7 }, { ptr, i64 } { ptr @str.170, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2615,24 +2698,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.94, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.171, 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.95, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.172, 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.98, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [2 x { ptr, i64 }], ptr @field_names.175, 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.99, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.176, 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
@@ -2675,7 +2758,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.100, i64 12 }, { ptr, i64 } { ptr @str.101, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.177, i64 12 }, { ptr, i64 } { ptr @str.178, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2694,24 +2777,24 @@ 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.102, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.179, 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.103, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.180, 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.104, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [0 x { ptr, i64 }], ptr @field_names.181, 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.105, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.182, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %loadN = load {}, ptr %alloca, align 1
@@ -2730,7 +2813,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.106, i64 6 }, { ptr, i64 } { ptr @str.107, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.183, i64 6 }, { ptr, i64 } { ptr @str.184, i64 1 })
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } %call, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
@@ -2749,24 +2832,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.108, i64 1 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.185, 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.109, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.186, 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.113, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [3 x { ptr, i64 }], ptr @field_names.190, 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.114, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.191, 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
@@ -2815,9 +2898,9 @@ 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.123, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [7 x { ptr, i64 }], ptr @field_names.200, 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.115, i64 1 }, { ptr, i64 } %fn.load)
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.192, 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
@@ -2836,8 +2919,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.125, i64 1 })
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.124, i64 1 }, { ptr, i64 } %callN)
+  %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 } %callN)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.136
@@ -2856,9 +2939,9 @@ 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.132, i64 0, i64 %loadN
+  %fn.gep = getelementptr inbounds [5 x { ptr, i64 }], ptr @field_names.209, 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.126, i64 1 }, { ptr, i64 } %fn.load)
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.203, 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
@@ -2877,8 +2960,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.134, i64 1 })
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.133, i64 1 }, { ptr, i64 } %callN)
+  %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 } %callN)
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.138
@@ -2894,7 +2977,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.135, i64 1 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.212, i64 1 }, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
   store i64 0, ptr %allocaN, align 8
   br label %while.hdr.143
@@ -2911,12 +2994,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.136, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.213, 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.137, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.214, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.147
 
@@ -2947,7 +3030,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.138, i64 1 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.215, i64 1 }, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
   store i64 0, ptr %allocaN, align 8
   br label %while.hdr.148
@@ -2964,12 +3047,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.139, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.216, 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.140, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.217, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.152
 
@@ -3000,7 +3083,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.141, i64 1 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.218, i64 1 }, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
   store i64 0, ptr %allocaN, align 8
   br label %while.hdr.157
@@ -3019,12 +3102,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.142, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.219, 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.143, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.220, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.161
 
@@ -3054,7 +3137,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.144, i64 1 }, ptr %allocaN, align 8
+  store { ptr, i64 } { ptr @str.221, i64 1 }, ptr %allocaN, align 8
   %allocaN = alloca i64, align 8
   store i64 0, ptr %allocaN, align 8
   br label %while.hdr.162
@@ -3073,12 +3156,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.145, i64 1 })
+  %call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.222, 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.146, i64 2 })
+  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.223, i64 2 })
   store { ptr, i64 } %callN, ptr %allocaN, align 8
   br label %if.merge.166
 
@@ -3121,12 +3204,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.149, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.148, i64 5 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.190
 
 if.merge.190:                                     ; preds = %if.else.189, %if.then.188
-  %bp = phi { ptr, i64 } [ { ptr @str.147, i64 4 }, %if.then.188 ], [ %callN, %if.else.189 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.224, i64 4 }, %if.then.188 ], [ %callN, %if.else.189 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3149,12 +3232,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.152, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.151, i64 11 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.214
 
 if.merge.214:                                     ; preds = %if.else.213, %if.then.212
-  %bp = phi { ptr, i64 } [ { ptr @str.150, i64 4 }, %if.then.212 ], [ %callN, %if.else.213 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.227, i64 4 }, %if.then.212 ], [ %callN, %if.else.213 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3177,12 +3260,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.155, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.154, i64 4 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.217
 
 if.merge.217:                                     ; preds = %if.else.216, %if.then.215
-  %bp = phi { ptr, i64 } [ { ptr @str.153, i64 4 }, %if.then.215 ], [ %callN, %if.else.216 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.230, i64 4 }, %if.then.215 ], [ %callN, %if.else.216 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3205,12 +3288,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.158, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.157, i64 11 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.220
 
 if.merge.220:                                     ; preds = %if.else.219, %if.then.218
-  %bp = phi { ptr, i64 } [ { ptr @str.156, i64 4 }, %if.then.218 ], [ %callN, %if.else.219 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.233, i64 4 }, %if.then.218 ], [ %callN, %if.else.219 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3233,12 +3316,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.161, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.160, i64 6 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.223
 
 if.merge.223:                                     ; preds = %if.else.222, %if.then.221
-  %bp = phi { ptr, i64 } [ { ptr @str.159, i64 4 }, %if.then.221 ], [ %callN, %if.else.222 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.236, i64 4 }, %if.then.221 ], [ %callN, %if.else.222 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3260,12 +3343,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.164, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.163, i64 5 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.226
 
 if.merge.226:                                     ; preds = %if.else.225, %if.then.224
-  %bp = phi { ptr, i64 } [ { ptr @str.162, i64 4 }, %if.then.224 ], [ %callN, %if.else.225 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.239, i64 4 }, %if.then.224 ], [ %callN, %if.else.225 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3288,12 +3371,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.167, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.166, i64 9 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.229
 
 if.merge.229:                                     ; preds = %if.else.228, %if.then.227
-  %bp = phi { ptr, i64 } [ { ptr @str.165, i64 4 }, %if.then.227 ], [ %callN, %if.else.228 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.242, i64 4 }, %if.then.227 ], [ %callN, %if.else.228 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3316,12 +3399,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.170, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.169, i64 18 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.232
 
 if.merge.232:                                     ; preds = %if.else.231, %if.then.230
-  %bp = phi { ptr, i64 } [ { ptr @str.168, i64 4 }, %if.then.230 ], [ %callN, %if.else.231 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.245, i64 4 }, %if.then.230 ], [ %callN, %if.else.231 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3344,12 +3427,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.173, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.172, i64 12 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.235
 
 if.merge.235:                                     ; preds = %if.else.234, %if.then.233
-  %bp = phi { ptr, i64 } [ { ptr @str.171, i64 4 }, %if.then.233 ], [ %callN, %if.else.234 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.248, i64 4 }, %if.then.233 ], [ %callN, %if.else.234 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3372,12 +3455,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.176, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.175, i64 4 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.238
 
 if.merge.238:                                     ; preds = %if.else.237, %if.then.236
-  %bp = phi { ptr, i64 } [ { ptr @str.174, i64 4 }, %if.then.236 ], [ %callN, %if.else.237 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.251, i64 4 }, %if.then.236 ], [ %callN, %if.else.237 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3400,12 +3483,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.179, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.178, i64 6 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.241
 
 if.merge.241:                                     ; preds = %if.else.240, %if.then.239
-  %bp = phi { ptr, i64 } [ { ptr @str.177, i64 4 }, %if.then.239 ], [ %callN, %if.else.240 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.254, i64 4 }, %if.then.239 ], [ %callN, %if.else.240 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3428,12 +3511,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.182, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.181, i64 5 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.244
 
 if.merge.244:                                     ; preds = %if.else.243, %if.then.242
-  %bp = phi { ptr, i64 } [ { ptr @str.180, i64 4 }, %if.then.242 ], [ %callN, %if.else.243 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.257, i64 4 }, %if.then.242 ], [ %callN, %if.else.243 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3456,12 +3539,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.185, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.184, i64 7 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.247
 
 if.merge.247:                                     ; preds = %if.else.246, %if.then.245
-  %bp = phi { ptr, i64 } [ { ptr @str.183, i64 4 }, %if.then.245 ], [ %callN, %if.else.246 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.260, i64 4 }, %if.then.245 ], [ %callN, %if.else.246 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3484,12 +3567,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.188, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.187, i64 4 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.250
 
 if.merge.250:                                     ; preds = %if.else.249, %if.then.248
-  %bp = phi { ptr, i64 } [ { ptr @str.186, i64 4 }, %if.then.248 ], [ %callN, %if.else.249 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.263, i64 4 }, %if.then.248 ], [ %callN, %if.else.249 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3512,12 +3595,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.191, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.190, i64 7 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.253
 
 if.merge.253:                                     ; preds = %if.else.252, %if.then.251
-  %bp = phi { ptr, i64 } [ { ptr @str.189, i64 4 }, %if.then.251 ], [ %callN, %if.else.252 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.266, i64 4 }, %if.then.251 ], [ %callN, %if.else.252 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3540,12 +3623,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.194, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.193, i64 6 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.256
 
 if.merge.256:                                     ; preds = %if.else.255, %if.then.254
-  %bp = phi { ptr, i64 } [ { ptr @str.192, i64 4 }, %if.then.254 ], [ %callN, %if.else.255 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.269, i64 4 }, %if.then.254 ], [ %callN, %if.else.255 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3568,12 +3651,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.197, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.196, i64 3 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.259
 
 if.merge.259:                                     ; preds = %if.else.258, %if.then.257
-  %bp = phi { ptr, i64 } [ { ptr @str.195, i64 4 }, %if.then.257 ], [ %callN, %if.else.258 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.272, i64 4 }, %if.then.257 ], [ %callN, %if.else.258 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3596,12 +3679,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.200, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.199, i64 7 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.262
 
 if.merge.262:                                     ; preds = %if.else.261, %if.then.260
-  %bp = phi { ptr, i64 } [ { ptr @str.198, i64 4 }, %if.then.260 ], [ %callN, %if.else.261 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.275, i64 4 }, %if.then.260 ], [ %callN, %if.else.261 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3624,12 +3707,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.203, i64 3 }, { ptr, i64 } %call)
-  %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.202, i64 7 }, { ptr, i64 } %callN)
+  %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)
   br label %if.merge.265
 
 if.merge.265:                                     ; preds = %if.else.264, %if.then.263
-  %bp = phi { ptr, i64 } [ { ptr @str.201, i64 4 }, %if.then.263 ], [ %callN, %if.else.264 ]
+  %bp = phi { ptr, i64 } [ { ptr @str.278, i64 4 }, %if.then.263 ], [ %callN, %if.else.264 ]
   ret { ptr, i64 } %bp
 }
 
@@ -3641,3 +3724,5 @@ entry:
   store ptr %sel, ptr @OBJC_SELECTOR_REFERENCES_tripleValue, align 8
   ret void
 }
+
+