diff --git a/lib/std/core/dstring.c3 b/lib/std/core/dstring.c3
index 2537904ba..d21f4d9da 100644
--- a/lib/std/core/dstring.c3
+++ b/lib/std/core/dstring.c3
@@ -59,7 +59,7 @@ fn DString DString.new_tconcat(DString a, DString b) => a.new_concat(b, mem::tem
 fn ZString DString.zstr(DString str)
 {
 	StringData* data = str.data();
-	if (!data) return (ZString)"";
+	if (!data) return "";
 	if (data.capacity == data.len)
 	{
 		str.reserve(1);
diff --git a/src/compiler/compiler_internal.h b/src/compiler/compiler_internal.h
index 3a90f3203..5f0ea5275 100644
--- a/src/compiler/compiler_internal.h
+++ b/src/compiler/compiler_internal.h
@@ -1851,6 +1851,7 @@ extern Type *type_anyfail;
 extern Type *type_cint;
 extern Type *type_cuint;
 extern Type *type_chars;
+extern Type *type_string;
 
 
 extern const char *attribute_list[NUMBER_OF_ATTRIBUTES];
diff --git a/src/compiler/expr.c b/src/compiler/expr.c
index 51a30fc1d..b6376b8e4 100644
--- a/src/compiler/expr.c
+++ b/src/compiler/expr.c
@@ -933,7 +933,7 @@ void expr_rewrite_to_string(Expr *expr_to_rewrite, const char *string)
 	ArraySize len = (ArraySize)strlen(string);
 	expr_to_rewrite->const_expr.string.len = len;
 	expr_to_rewrite->resolve_status = RESOLVE_DONE;
-	expr_to_rewrite->type = type_get_ptr(type_get_array(type_char, len));
+	expr_to_rewrite->type = type_string;
 }
 
 void expr_rewrite_to_binary(Expr *expr_to_rewrite, Expr *left, Expr *right, BinaryOp op)
diff --git a/src/compiler/llvm_codegen_expr.c b/src/compiler/llvm_codegen_expr.c
index ed7cf1abe..3ea5ece1e 100644
--- a/src/compiler/llvm_codegen_expr.c
+++ b/src/compiler/llvm_codegen_expr.c
@@ -4471,59 +4471,68 @@ static void llvm_emit_const_expr(GenContext *c, BEValue *be_value, Expr *expr)
 		case CONST_STRING:
 		{
 			Type *str_type = type_lowering(expr->type);
-			bool is_array = type_flat_is_char_array(str_type);
-			if (llvm_is_local_eval(c) || !is_array)
+			bool is_array = str_type->type_kind == TYPE_ARRAY;
+			if (is_array && llvm_is_global_eval(c))
 			{
-				ArraySize strlen = expr->const_expr.string.len;
+				// In the global alloc case, create the byte array.
+				ArraySize array_len = str_type->array.len;
 				ArraySize size = expr->const_expr.string.len + 1;
-				if (type_flat_is_char_array(expr->type) && type->array.len > size) size = type->array.len;
-				LLVMValueRef global_name = llvm_add_global_raw(c,
-				                                               ".str",
-				                                               LLVMArrayType(llvm_get_type(c, type_char), size),
-				                                               1);
-				llvm_set_private_linkage(global_name);
-				LLVMSetUnnamedAddress(global_name, LLVMGlobalUnnamedAddr);
-				LLVMSetGlobalConstant(global_name, 1);
-				LLVMValueRef string = llvm_get_zstring(c, expr->const_expr.string.chars, expr->const_expr.string.len);
-				if (size > strlen + 1)
+				LLVMValueRef string;
+				if (array_len == size)
 				{
-					LLVMValueRef trailing_zeros = llvm_get_zero_raw(LLVMArrayType(c->byte_type, size - strlen - 1));
-					LLVMValueRef values[2] = { string, trailing_zeros };
-					string = llvm_get_packed_struct(c, values, 2);
+					string = llvm_get_zstring(c, expr->const_expr.string.chars, expr->const_expr.string.len);
 				}
-				LLVMSetInitializer(global_name, string);
-				if (is_array)
+				else if (array_len < size)
 				{
-					llvm_value_set_address(be_value, global_name, type, 1);
+					string = llvm_get_bytes(c, expr->const_expr.string.chars, array_len);
+				}
+				else
+				{
+					char *buffer = ccalloc(1, array_len);
+					memcpy(buffer, expr->const_expr.string.chars, expr->const_expr.string.len);
+					string = llvm_get_bytes(c, buffer, array_len);
+				}
+				llvm_value_set(be_value, string, type);
+				return;
+			}
+			// local case or creating a pointer / subarray.
+			// In this case we first create the constant.
+			ArraySize strlen = expr->const_expr.string.len;
+			if (strlen == 0 && str_type->type_kind == TYPE_SUBARRAY)
+			{
+				llvm_value_set(be_value, llvm_get_zero(c, expr->type), expr->type);
+				return;
+			}
+			ArraySize size = expr->const_expr.string.len + 1;
+			if (is_array && type->array.len > size) size = type->array.len;
+			LLVMValueRef global_name = llvm_add_global_raw(c, ".str", LLVMArrayType(llvm_get_type(c, type_char), size), 1);
+			llvm_set_private_linkage(global_name);
+			LLVMSetUnnamedAddress(global_name, LLVMGlobalUnnamedAddr);
+			LLVMSetGlobalConstant(global_name, 1);
+			LLVMValueRef string = llvm_get_zstring(c, expr->const_expr.string.chars, expr->const_expr.string.len);
+			if (size > strlen + 1)
+			{
+				LLVMValueRef trailing_zeros = llvm_get_zero_raw(LLVMArrayType(c->byte_type, size - strlen - 1));
+				LLVMValueRef values[2] = { string, trailing_zeros };
+				string = llvm_get_packed_struct(c, values, 2);
+			}
+			LLVMSetInitializer(global_name, string);
+			if (is_array)
+			{
+				llvm_value_set_address(be_value, global_name, type, 1);
+			}
+			else
+			{
+				if (str_type->type_kind == TYPE_SUBARRAY)
+				{
+					LLVMValueRef len = llvm_const_int(c, type_usz, strlen);
+					llvm_value_aggregate_two(c, be_value, str_type, global_name, len);
 				}
 				else
 				{
 					llvm_value_set(be_value, global_name, type);
 				}
-				return;
 			}
-			ArraySize array_len = type->array.len;
-			ArraySize size = expr->const_expr.string.len + 1;
-			bool zero_terminate = array_len == size;
-			LLVMValueRef string;
-			if (array_len <= size)
-			{
-				if (zero_terminate)
-				{
-					string = llvm_get_zstring(c, expr->const_expr.string.chars, expr->const_expr.string.len);
-				}
-				else
-				{
-					string = llvm_get_bytes(c, expr->const_expr.string.chars, array_len);
-				}
-			}
-			else
-			{
-				char *buffer = ccalloc(1, array_len);
-				memcpy(buffer, expr->const_expr.string.chars, expr->const_expr.string.len);
-				string = llvm_get_bytes(c, buffer, array_len);
-			}
-			llvm_value_set(be_value, string, type);
 			return;
 		}
 		case CONST_TYPEID:
diff --git a/src/compiler/parse_expr.c b/src/compiler/parse_expr.c
index c6e247786..6c61ee684 100644
--- a/src/compiler/parse_expr.c
+++ b/src/compiler/parse_expr.c
@@ -558,7 +558,7 @@ static Expr *parse_ct_stringify(ParseContext *c, Expr *left)
 	expr->const_expr.const_kind = CONST_STRING;
 	expr->const_expr.string.chars = content;
 	expr->const_expr.string.len = len;
-	expr->type = type_get_ptr(type_get_array(type_char, len));
+	expr->type = type_string;
 	return expr;
 }
 
@@ -1622,7 +1622,7 @@ static Expr *parse_string_literal(ParseContext *c, Expr *left)
 	assert(str);
 	expr_string->const_expr.string.chars = str;
 	expr_string->const_expr.string.len = (uint32_t)len;
-	expr_string->type = type_get_ptr(type_get_array(type_char, len));
+	expr_string->type = type_string;
 	expr_string->const_expr.const_kind = CONST_STRING;
 	return expr_string;
 }
diff --git a/src/compiler/sema_casts.c b/src/compiler/sema_casts.c
index fb122cd6d..68d0e302e 100644
--- a/src/compiler/sema_casts.c
+++ b/src/compiler/sema_casts.c
@@ -594,6 +594,7 @@ static bool vector_to_vector(Expr *expr, Type *to_type)
  * Perform vararg promotions typical for C style varargs:
  * 1. Widen int and bool to C int size
  * 2. Widen float and smaller to double
+ * 3. Turn subarrays into pointers
  */
 bool cast_promote_vararg(Expr *arg)
 {
@@ -606,6 +607,9 @@ bool cast_promote_vararg(Expr *arg)
 	// 2. Promote any float to at least double
 	if (type_is_promotable_float(arg_type)) return cast(arg, type_double);
 
+	// 3. Turn subarrays into pointers
+	if (arg_type->type_kind == TYPE_SUBARRAY) return cast(arg, type_get_ptr(arg_type->array.base));
+
 	return true;
 }
 /**
@@ -1029,23 +1033,36 @@ static void sema_error_const_int_out_of_range(Expr *expr, Expr *problem, Type *t
 }
 
 
-static inline bool cast_maybe_string_lit_to_char_array(Expr *expr, Type *expr_canonical, Type *to_canonical, Type *to_original)
+static inline bool cast_maybe_string_lit(Expr *expr, Type *to_canonical, Type *to_original)
 {
-	if (expr->expr_kind != EXPR_CONST || expr->const_expr.const_kind != CONST_STRING) return false;
-	if (expr_canonical->type_kind != TYPE_POINTER) return false;
-	if (to_canonical->type_kind != TYPE_ARRAY && to_canonical->type_kind != TYPE_INFERRED_ARRAY) return false;
-	if (to_canonical->array.base != type_char) return false;
-	Type *pointer = expr_canonical->pointer;
-	if (pointer->type_kind != TYPE_ARRAY) return false;
-	if (pointer->array.base != type_char) return false;
-	assert(!type_is_optional(expr->type));
-	if (to_canonical->type_kind == TYPE_INFERRED_ARRAY)
+	if (expr->expr_kind != EXPR_CONST || expr->const_expr.const_kind != CONST_STRING || expr->type != type_string) return false;
+	Type *flat = type_flatten(to_canonical);
+	Type *indexed_type = type_get_indexed_type(flat);
+	if (indexed_type) indexed_type = type_flatten(indexed_type);
+	switch (flat->type_kind)
 	{
-		assert(to_original->type_kind == TYPE_INFERRED_ARRAY);
-		to_original = type_get_array(to_original->array.base, pointer->array.len);
+		case TYPE_SUBARRAY:
+		case TYPE_POINTER:
+			if (indexed_type != type_char && indexed_type != type_ichar) return false;
+			expr->type = to_original;
+		case TYPE_INFERRED_ARRAY:
+			if (indexed_type != type_char && indexed_type != type_ichar) return false;
+			expr->type = type_infer_len_from_actual_type(to_original, type_get_array(indexed_type, expr->const_expr.string.len));
+			return true;
+			break;
+		case TYPE_ARRAY:
+			if (indexed_type != type_char && indexed_type != type_ichar) return false;
+			{
+				ArraySize len = expr->const_expr.string.len;
+				ArraySize to_len = flat->array.len;
+				if (len > to_len) return false;
+				expr->type = to_original;
+				return true;
+			}
+			break;
+		default:
+			return false;
 	}
-	expr->type = to_original;
-	return true;
 }
 
 
@@ -1568,7 +1585,7 @@ static bool cast_expr_inner(SemaContext *context, Expr *expr, Type *to_type, boo
 
 	// Handle strings, these don't actually mess with the underlying data,
 	// just the type.
-	if (cast_maybe_string_lit_to_char_array(expr, from, to, to_type)) return true;
+	if (cast_maybe_string_lit(expr, to, to_type)) return true;
 
 	// For constant pointers cast into anything pointer-like:
 	if (expr_is_const_pointer(expr) && from == type_voidptr && type_flatten(to)->type_kind == TYPE_POINTER)
diff --git a/src/compiler/sema_expr.c b/src/compiler/sema_expr.c
index c1b70b95b..12aca6e1d 100644
--- a/src/compiler/sema_expr.c
+++ b/src/compiler/sema_expr.c
@@ -3572,6 +3572,12 @@ CHECK_DEEPER:
 	{
 		if (flat_type->type_kind == TYPE_SUBARRAY)
 		{
+			// Handle literal "foo".len which is now a subarray.
+			if (expr_is_const_string(parent))
+			{
+				expr_rewrite_const_int(expr, type_isz, parent->const_expr.string.len);
+				return true;
+			}
 			expr_rewrite_to_builtin_access(expr, current_parent, ACCESS_LEN, type_usz);
 			return true;
 		}
diff --git a/src/compiler/sema_stmts.c b/src/compiler/sema_stmts.c
index 9855aca1b..601eda381 100644
--- a/src/compiler/sema_stmts.c
+++ b/src/compiler/sema_stmts.c
@@ -2198,7 +2198,7 @@ static inline bool sema_analyse_ct_switch_stmt(SemaContext *context, Ast *statem
 		case ALL_FLOATS:
 		case TYPE_BOOL:
 			break;
-		case TYPE_POINTER:
+		case TYPE_SUBARRAY:
 			if (expr_is_const_string(cond)) break;
 			FALLTHROUGH;
 		default:
diff --git a/src/compiler/types.c b/src/compiler/types.c
index 6e45222b7..18f4fec1f 100644
--- a/src/compiler/types.c
+++ b/src/compiler/types.c
@@ -45,6 +45,7 @@ Type *type_untypedlist = &t.untyped_list;
 Type *type_anyfail = &t.anyfail;
 Type *type_member = &t.member;
 Type *type_chars = NULL;
+Type *type_string = NULL;
 
 static unsigned size_subarray;
 static AlignSize alignment_subarray;
@@ -1505,6 +1506,7 @@ void type_setup(PlatformTarget *target)
 	size_subarray = (unsigned)(alignment_subarray * 2);
 	type_init("anyerr", &t.anyerr, TYPE_ANYERR, target->width_pointer, target->align_pointer);
 	type_chars = type_get_subarray(type_char);
+	type_string = type_chars;
 }
 
 int type_kind_bitsize(TypeKind kind)
diff --git a/src/version.h b/src/version.h
index 1fa1befee..bf1988933 100644
--- a/src/version.h
+++ b/src/version.h
@@ -1 +1 @@
-#define COMPILER_VERSION "0.4.102"
\ No newline at end of file
+#define COMPILER_VERSION "0.4.103"
\ No newline at end of file
diff --git a/test/test_suite/arrays/global_init.c3t b/test/test_suite/arrays/global_init.c3t
index 6e345d562..5d4c26713 100644
--- a/test/test_suite/arrays/global_init.c3t
+++ b/test/test_suite/arrays/global_init.c3t
@@ -32,8 +32,8 @@ fn void main() {
 @test.bf3 = local_unnamed_addr global ptr getelementptr ([3 x i32], ptr @test.abc, i64 1, i64 1), align 8
 @.taddr.9 = private global i32 42, align 4
 @.taddr.10 = private global i8 99, align 1
-@.taddr.11 = private global ptr @.str, align 8
-@"main$x" = internal unnamed_addr global [3 x %variant] [%variant { ptr @.taddr.9, i64 ptrtoint (ptr @"$ct.int" to i64) }, %variant { ptr @.taddr.10, i64 ptrtoint (ptr @"$ct.char" to i64) }, %variant { ptr @.taddr.11, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64) }], align 16
+@.taddr.11 = private global %"char[]" { ptr @.str, i64 3 }, align 8
+@"main$x" = internal unnamed_addr global [3 x %variant] [%variant { ptr @.taddr.9, i64 ptrtoint (ptr @"$ct.int" to i64) }, %variant { ptr @.taddr.10, i64 ptrtoint (ptr @"$ct.char" to i64) }, %variant { ptr @.taddr.11, i64 ptrtoint (ptr @"$ct.sa$char" to i64) }], align 16
 
 define void @test.main() #0 {
 entry:
@@ -41,7 +41,7 @@ entry:
   %y = alloca [3 x %variant], align 16
   %taddr = alloca i32, align 4
   %taddr1 = alloca i8, align 1
-  %taddr2 = alloca ptr, align 8
+  %taddr2 = alloca %"char[]", align 8
   store ptr getelementptr ([3 x i32], ptr @test.abc, i64 2, i64 1), ptr %bf34, align 8
   %0 = getelementptr inbounds [3 x %variant], ptr %y, i64 0, i64 0
   store i32 42, ptr %taddr, align 4
@@ -54,9 +54,9 @@ entry:
   %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"$ct.char" to i64), 1
   store %variant %5, ptr %3, align 16
   %6 = getelementptr inbounds [3 x %variant], ptr %y, i64 0, i64 2
-  store ptr @.str.12, ptr %taddr2, align 8
+  store %"char[]" { ptr @.str.12, i64 3 }, ptr %taddr2, align 8
   %7 = insertvalue %variant undef, ptr %taddr2, 0
-  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
+  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
   store %variant %8, ptr %6, align 16
   ret void
 }
diff --git a/test/test_suite/bitstruct/bitstruct_be.c3t b/test/test_suite/bitstruct/bitstruct_be.c3t
index 2c4a71c35..7c7739927 100644
--- a/test/test_suite/bitstruct/bitstruct_be.c3t
+++ b/test/test_suite/bitstruct/bitstruct_be.c3t
@@ -89,120 +89,132 @@ loop.body:                                        ; preds = %loop.cond
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
-  store ptr @.str.2, ptr %x4, align 8
+  store %"char[]" zeroinitializer, ptr %x4, align 8
   %22 = call ptr @std.io.stdout()
   store ptr %22, ptr %result, align 8
   %23 = load ptr, ptr %result, align 8
-  %24 = call i64 @std.io.File.printn(ptr %retparam5, ptr %23, ptr null, i64 0)
-  %25 = load ptr, ptr %z, align 8
-  store ptr %25, ptr %.anon6, align 8
+  %24 = getelementptr inbounds %"char[]", ptr %x4, i32 0, i32 0
+  %lo = load ptr, ptr %24, align 8
+  %25 = getelementptr inbounds %"char[]", ptr %x4, i32 0, i32 1
+  %hi = load i64, ptr %25, align 8
+  %26 = call i64 @std.io.File.printn(ptr %retparam5, ptr %23, ptr %lo, i64 %hi)
+  %27 = load ptr, ptr %z, align 8
+  store ptr %27, ptr %.anon6, align 8
   store i64 0, ptr %.anon7, align 8
   br label %loop.cond8
 
 loop.cond8:                                       ; preds = %loop.body10, %loop.exit
-  %26 = load i64, ptr %.anon7, align 8
-  %gt9 = icmp ugt i64 4, %26
+  %28 = load i64, ptr %.anon7, align 8
+  %gt9 = icmp ugt i64 4, %28
   br i1 %gt9, label %loop.body10, label %loop.exit15
 
 loop.body10:                                      ; preds = %loop.cond8
-  %27 = load ptr, ptr %.anon6, align 8
-  %28 = load i64, ptr %.anon7, align 8
-  %29 = getelementptr inbounds [4 x i8], ptr %27, i64 0, i64 %28
-  %30 = load i8, ptr %29, align 1
-  store i8 %30, ptr %d11, align 1
-  %31 = insertvalue %variant undef, ptr %d11, 0
-  %32 = insertvalue %variant %31, i64 ptrtoint (ptr @"$ct.char" to i64), 1
-  %33 = getelementptr inbounds [1 x %variant], ptr %varargslots13, i64 0, i64 0
-  store %variant %32, ptr %33, align 16
-  %34 = call i64 @std.io.printf(ptr %retparam12, ptr @.str.3, i64 3, ptr %varargslots13, i64 1)
-  %35 = load i64, ptr %.anon7, align 8
-  %add14 = add i64 %35, 1
+  %29 = load ptr, ptr %.anon6, align 8
+  %30 = load i64, ptr %.anon7, align 8
+  %31 = getelementptr inbounds [4 x i8], ptr %29, i64 0, i64 %30
+  %32 = load i8, ptr %31, align 1
+  store i8 %32, ptr %d11, align 1
+  %33 = insertvalue %variant undef, ptr %d11, 0
+  %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.char" to i64), 1
+  %35 = getelementptr inbounds [1 x %variant], ptr %varargslots13, i64 0, i64 0
+  store %variant %34, ptr %35, align 16
+  %36 = call i64 @std.io.printf(ptr %retparam12, ptr @.str.2, i64 3, ptr %varargslots13, i64 1)
+  %37 = load i64, ptr %.anon7, align 8
+  %add14 = add i64 %37, 1
   store i64 %add14, ptr %.anon7, align 8
   br label %loop.cond8
 
 loop.exit15:                                      ; preds = %loop.cond8
-  store ptr @.str.4, ptr %x16, align 8
-  %36 = call ptr @std.io.stdout()
-  store ptr %36, ptr %result18, align 8
-  %37 = load ptr, ptr %result18, align 8
-  %38 = call i64 @std.io.File.printn(ptr %retparam17, ptr %37, ptr null, i64 0)
-  %39 = load i32, ptr %abc, align 4
-  %40 = call i32 @llvm.bswap.i32(i32 %39)
-  %41 = and i32 65535, %40
-  %trunc = trunc i32 %41 to i16
-  store i16 %trunc, ptr %taddr21, align 2
-  %42 = insertvalue %variant undef, ptr %taddr21, 0
-  %43 = insertvalue %variant %42, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
-  %44 = getelementptr inbounds [1 x %variant], ptr %varargslots20, i64 0, i64 0
-  store %variant %43, ptr %44, align 16
-  %45 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.5, i64 10, ptr %varargslots20, i64 1)
-  %46 = load i32, ptr %abc, align 4
-  %47 = call i32 @llvm.bswap.i32(i32 %46)
-  %48 = and i32 %47, -65536
-  %49 = or i32 %48, 4660
-  %50 = call i32 @llvm.bswap.i32(i32 %49)
-  store i32 %50, ptr %abc, align 4
-  %51 = load i32, ptr %abc, align 4
-  %52 = call i32 @llvm.bswap.i32(i32 %51)
-  %53 = and i32 %52, 65535
-  %54 = or i32 %53, 1450704896
-  %55 = call i32 @llvm.bswap.i32(i32 %54)
-  store i32 %55, ptr %abc, align 4
-  %56 = load i32, ptr %abc, align 4
-  %57 = call i32 @llvm.bswap.i32(i32 %56)
-  %58 = and i32 65535, %57
-  %trunc24 = trunc i32 %58 to i16
-  store i16 %trunc24, ptr %taddr25, align 2
-  %59 = insertvalue %variant undef, ptr %taddr25, 0
-  %60 = insertvalue %variant %59, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
-  %61 = getelementptr inbounds [1 x %variant], ptr %varargslots23, i64 0, i64 0
-  store %variant %60, ptr %61, align 16
-  %62 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.6, i64 12, ptr %varargslots23, i64 1)
-  %63 = load ptr, ptr %z, align 8
-  store ptr %63, ptr %.anon26, align 8
-  store i64 0, ptr %.anon27, align 8
-  br label %loop.cond28
+  store %"char[]" zeroinitializer, ptr %x16, align 8
+  %38 = call ptr @std.io.stdout()
+  store ptr %38, ptr %result18, align 8
+  %39 = load ptr, ptr %result18, align 8
+  %40 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 0
+  %lo19 = load ptr, ptr %40, align 8
+  %41 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 1
+  %hi20 = load i64, ptr %41, align 8
+  %42 = call i64 @std.io.File.printn(ptr %retparam17, ptr %39, ptr %lo19, i64 %hi20)
+  %43 = load i32, ptr %abc, align 4
+  %44 = call i32 @llvm.bswap.i32(i32 %43)
+  %45 = and i32 65535, %44
+  %trunc = trunc i32 %45 to i16
+  store i16 %trunc, ptr %taddr23, align 2
+  %46 = insertvalue %variant undef, ptr %taddr23, 0
+  %47 = insertvalue %variant %46, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
+  %48 = getelementptr inbounds [1 x %variant], ptr %varargslots22, i64 0, i64 0
+  store %variant %47, ptr %48, align 16
+  %49 = call i64 @std.io.printfn(ptr %retparam21, ptr @.str.3, i64 10, ptr %varargslots22, i64 1)
+  %50 = load i32, ptr %abc, align 4
+  %51 = call i32 @llvm.bswap.i32(i32 %50)
+  %52 = and i32 %51, -65536
+  %53 = or i32 %52, 4660
+  %54 = call i32 @llvm.bswap.i32(i32 %53)
+  store i32 %54, ptr %abc, align 4
+  %55 = load i32, ptr %abc, align 4
+  %56 = call i32 @llvm.bswap.i32(i32 %55)
+  %57 = and i32 %56, 65535
+  %58 = or i32 %57, 1450704896
+  %59 = call i32 @llvm.bswap.i32(i32 %58)
+  store i32 %59, ptr %abc, align 4
+  %60 = load i32, ptr %abc, align 4
+  %61 = call i32 @llvm.bswap.i32(i32 %60)
+  %62 = and i32 65535, %61
+  %trunc26 = trunc i32 %62 to i16
+  store i16 %trunc26, ptr %taddr27, align 2
+  %63 = insertvalue %variant undef, ptr %taddr27, 0
+  %64 = insertvalue %variant %63, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
+  %65 = getelementptr inbounds [1 x %variant], ptr %varargslots25, i64 0, i64 0
+  store %variant %64, ptr %65, align 16
+  %66 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.4, i64 12, ptr %varargslots25, i64 1)
+  %67 = load ptr, ptr %z, align 8
+  store ptr %67, ptr %.anon28, align 8
+  store i64 0, ptr %.anon29, align 8
+  br label %loop.cond30
 
-loop.cond28:                                      ; preds = %loop.body30, %loop.exit15
-  %64 = load i64, ptr %.anon27, align 8
-  %gt29 = icmp ugt i64 4, %64
-  br i1 %gt29, label %loop.body30, label %loop.exit35
+loop.cond30:                                      ; preds = %loop.body32, %loop.exit15
+  %68 = load i64, ptr %.anon29, align 8
+  %gt31 = icmp ugt i64 4, %68
+  br i1 %gt31, label %loop.body32, label %loop.exit37
 
-loop.body30:                                      ; preds = %loop.cond28
-  %65 = load ptr, ptr %.anon26, align 8
-  %66 = load i64, ptr %.anon27, align 8
-  %67 = getelementptr inbounds [4 x i8], ptr %65, i64 0, i64 %66
-  %68 = load i8, ptr %67, align 1
-  store i8 %68, ptr %d31, align 1
-  %69 = insertvalue %variant undef, ptr %d31, 0
-  %70 = insertvalue %variant %69, i64 ptrtoint (ptr @"$ct.char" to i64), 1
-  %71 = getelementptr inbounds [1 x %variant], ptr %varargslots33, i64 0, i64 0
-  store %variant %70, ptr %71, align 16
-  %72 = call i64 @std.io.printf(ptr %retparam32, ptr @.str.7, i64 3, ptr %varargslots33, i64 1)
-  %73 = load i64, ptr %.anon27, align 8
-  %add34 = add i64 %73, 1
-  store i64 %add34, ptr %.anon27, align 8
-  br label %loop.cond28
+loop.body32:                                      ; preds = %loop.cond30
+  %69 = load ptr, ptr %.anon28, align 8
+  %70 = load i64, ptr %.anon29, align 8
+  %71 = getelementptr inbounds [4 x i8], ptr %69, i64 0, i64 %70
+  %72 = load i8, ptr %71, align 1
+  store i8 %72, ptr %d33, align 1
+  %73 = insertvalue %variant undef, ptr %d33, 0
+  %74 = insertvalue %variant %73, i64 ptrtoint (ptr @"$ct.char" to i64), 1
+  %75 = getelementptr inbounds [1 x %variant], ptr %varargslots35, i64 0, i64 0
+  store %variant %74, ptr %75, align 16
+  %76 = call i64 @std.io.printf(ptr %retparam34, ptr @.str.5, i64 3, ptr %varargslots35, i64 1)
+  %77 = load i64, ptr %.anon29, align 8
+  %add36 = add i64 %77, 1
+  store i64 %add36, ptr %.anon29, align 8
+  br label %loop.cond30
 
-loop.exit35:                                      ; preds = %loop.cond28
-  store ptr @.str.8, ptr %x36, align 8
-  %74 = call ptr @std.io.stdout()
-  store ptr %74, ptr %result38, align 8
-  %75 = load ptr, ptr %result38, align 8
-  %76 = call i64 @std.io.File.printn(ptr %retparam37, ptr %75, ptr null, i64 0)
+loop.exit37:                                      ; preds = %loop.cond30
+  store %"char[]" zeroinitializer, ptr %x38, align 8
+  %78 = call ptr @std.io.stdout()
+  store ptr %78, ptr %result40, align 8
+  %79 = load ptr, ptr %result40, align 8
+  %80 = getelementptr inbounds %"char[]", ptr %x38, i32 0, i32 0
+  %lo41 = load ptr, ptr %80, align 8
+  %81 = getelementptr inbounds %"char[]", ptr %x38, i32 0, i32 1
+  %hi42 = load i64, ptr %81, align 8
+  %82 = call i64 @std.io.File.printn(ptr %retparam39, ptr %79, ptr %lo41, i64 %hi42)
   store i32 0, ptr %y, align 4
-  %77 = load i32, ptr %y, align 4
+  %83 = load i32, ptr %y, align 4
   store i32 123, ptr %y, align 4
-  %78 = insertvalue %variant undef, ptr %y, 0
-  %79 = insertvalue %variant %78, i64 ptrtoint (ptr @"$ct.int" to i64), 1
-  %80 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 0
-  store %variant %79, ptr %80, align 16
-  %81 = load i32, ptr %y, align 4
-  store i32 %81, ptr %taddr41, align 4
-  %82 = insertvalue %variant undef, ptr %taddr41, 0
-  %83 = insertvalue %variant %82, i64 ptrtoint (ptr @"$ct.int" to i64), 1
-  %84 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1
-  store %variant %83, ptr %84, align 16
-  %85 = call i64 @std.io.printf(ptr %retparam39, ptr @.str.9, i64 18, ptr %varargslots40, i64 2)
+  %84 = insertvalue %variant undef, ptr %y, 0
+  %85 = insertvalue %variant %84, i64 ptrtoint (ptr @"$ct.int" to i64), 1
+  %86 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 0
+  store %variant %85, ptr %86, align 16
+  %87 = load i32, ptr %y, align 4
+  store i32 %87, ptr %taddr45, align 4
+  %88 = insertvalue %variant undef, ptr %taddr45, 0
+  %89 = insertvalue %variant %88, i64 ptrtoint (ptr @"$ct.int" to i64), 1
+  %90 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 1
+  store %variant %89, ptr %90, align 16
+  %91 = call i64 @std.io.printf(ptr %retparam43, ptr @.str.6, i64 18, ptr %varargslots44, i64 2)
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/compile_time/ct_builtin_time_date.c3t b/test/test_suite/compile_time/ct_builtin_time_date.c3t
index 3b9d49b5d..24f81660d 100644
--- a/test/test_suite/compile_time/ct_builtin_time_date.c3t
+++ b/test/test_suite/compile_time/ct_builtin_time_date.c3t
@@ -26,30 +26,29 @@ fn void main()
 
 /* #expect: test.ll
 
-
 define void @test.test(i32 %0) #0 {
 entry:
   %retparam = alloca i64, align 8
   %varargslots = alloca [1 x %variant], align 16
   %taddr = alloca i32, align 4
-  %x = alloca ptr, align 8
+  %x = alloca %"char[]", align 8
   %retparam1 = alloca i64, align 8
   %result = alloca %File, align 8
-  %x2 = alloca ptr, align 8
+  %x2 = alloca %"char[]", align 8
   %retparam3 = alloca i64, align 8
   %result4 = alloca %File, align 8
-  %retparam5 = alloca i64, align 8
-  %varargslots6 = alloca [1 x %variant], align 16
-  %taddr7 = alloca i64, align 8
-  %retparam8 = alloca i64, align 8
-  %varargslots9 = alloca [1 x %variant], align 16
-  %taddr10 = alloca i64, align 8
-  %x11 = alloca ptr, align 8
-  %retparam12 = alloca i64, align 8
-  %result13 = alloca %File, align 8
-  %x14 = alloca ptr, align 8
-  %retparam15 = alloca i64, align 8
-  %result16 = alloca %File, align 8
+  %retparam7 = alloca i64, align 8
+  %varargslots8 = alloca [1 x %variant], align 16
+  %taddr9 = alloca i64, align 8
+  %retparam10 = alloca i64, align 8
+  %varargslots11 = alloca [1 x %variant], align 16
+  %taddr12 = alloca i64, align 8
+  %x13 = alloca %"char[]", align 8
+  %retparam14 = alloca i64, align 8
+  %result15 = alloca %File, align 8
+  %x18 = alloca %"char[]", align 8
+  %retparam19 = alloca i64, align 8
+  %result20 = alloca %File, align 8
   store i32 %0, ptr %taddr, align 4
   %1 = insertvalue %variant undef, ptr %taddr, 0
   %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"$ct.int" to i64), 1
@@ -63,41 +62,61 @@ if.then:                                          ; preds = %entry
   call void @test.test(i32 %sub)
   br label %if.exit
 if.exit:                                          ; preds = %if.then, %entry
-  store ptr @.str.1, ptr %x, align 8
+  store %"char[]" { ptr @.str.1, i64 8 }, ptr %x, align 8
   %5 = call ptr @std.io.stdout()
   store ptr %5, ptr %result, align 8
   %6 = load ptr, ptr %result, align 8
-  %7 = load ptr, ptr %x, align 8
-  %8 = call i64 @std.io.File.printn(ptr %retparam1, ptr %6, ptr %7, i64 8)
-  store ptr @.str.2, ptr %x2, align 8
-  %9 = call ptr @std.io.stdout()
-  store ptr %9, ptr %result4, align 8
-  %10 = load ptr, ptr %result4, align 8
-  %11 = load ptr, ptr %x2, align 8
-  %12 = call i64 @std.io.File.printn(ptr %retparam3, ptr %10, ptr %11, i64 10)
-  store i64 14, ptr %taddr7, align 8
-  %13 = insertvalue %variant undef, ptr %taddr7, 0
-  %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"$ct.long" to i64), 1
-  %15 = getelementptr inbounds [1 x %variant], ptr %varargslots6, i64 0, i64 0
-  store %variant %14, ptr %15, align 16
-  %16 = call i64 @std.io.printfn(ptr %retparam5, ptr @.str.3, i64 2, ptr %varargslots6, i64 1)
-  store i64 6, ptr %taddr10, align 8
-  %17 = insertvalue %variant undef, ptr %taddr10, 0
-  %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"$ct.long" to i64), 1
-  %19 = getelementptr inbounds [1 x %variant], ptr %varargslots9, i64 0, i64 0
-  store %variant %18, ptr %19, align 16
-  %20 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.4, i64 2, ptr %varargslots9, i64 1)
-  store ptr @.str.5, ptr %x11, align 8
-  %21 = call ptr @std.io.stdout()
-  store ptr %21, ptr %result13, align 8
-  %22 = load ptr, ptr %result13, align 8
-  %23 = load ptr, ptr %x11, align 8
-  %24 = call i64 @std.io.File.printn(ptr %retparam12, ptr %22, ptr %23, i64 23)
-  store ptr @.str.6, ptr %x14, align 8
-  %25 = call ptr @std.io.stdout()
-  store ptr %25, ptr %result16, align 8
-  %26 = load ptr, ptr %result16, align 8
-  %27 = load ptr, ptr %x14, align 8
-  %28 = call i64 @std.io.File.printn(ptr %retparam15, ptr %26, ptr %27, i64 4)
+  %7 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
+  %lo = load ptr, ptr %7, align 8
+  %8 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
+  %hi = load i64, ptr %8, align 8
+  %9 = call i64 @std.io.File.printn(ptr %retparam1, ptr %6, ptr %lo, i64 %hi)
+  store %"char[]" { ptr @.str.2, i64 10 }, ptr %x2, align 8
+  %10 = call ptr @std.io.stdout()
+  store ptr %10, ptr %result4, align 8
+  %11 = load ptr, ptr %result4, align 8
+  %12 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 0
+  %lo5 = load ptr, ptr %12, align 8
+  %13 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 1
+  %hi6 = load i64, ptr %13, align 8
+  %14 = call i64 @std.io.File.printn(ptr %retparam3, ptr %11, ptr %lo5, i64 %hi6)
+  store i64 14, ptr %taddr9, align 8
+  %15 = insertvalue %variant undef, ptr %taddr9, 0
+  %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"$ct.long" to i64), 1
+  %17 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
+  store %variant %16, ptr %17, align 16
+  %18 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.3, i64 2, ptr %varargslots8, i64 1)
+  store i64 6, ptr %taddr12, align 8
+  %19 = insertvalue %variant undef, ptr %taddr12, 0
+  %20 = insertvalue %variant %19, i64 ptrtoint (ptr @"$ct.long" to i64), 1
+  %21 = getelementptr inbounds [1 x %variant], ptr %varargslots11, i64 0, i64 0
+  store %variant %20, ptr %21, align 16
+  %22 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.4, i64 2, ptr %varargslots11, i64 1)
+  store %"char[]" { ptr @.str.5, i64 23 }, ptr %x13, align 8
+  %23 = call ptr @std.io.stdout()
+  store ptr %23, ptr %result15, align 8
+  %24 = load ptr, ptr %result15, align 8
+  %25 = getelementptr inbounds %"char[]", ptr %x13, i32 0, i32 0
+  %lo16 = load ptr, ptr %25, align 8
+  %26 = getelementptr inbounds %"char[]", ptr %x13, i32 0, i32 1
+  %hi17 = load i64, ptr %26, align 8
+  %27 = call i64 @std.io.File.printn(ptr %retparam14, ptr %24, ptr %lo16, i64 %hi17)
+  store %"char[]" { ptr @.str.6, i64 4 }, ptr %x18, align 8
+  %28 = call ptr @std.io.stdout()
+  store ptr %28, ptr %result20, align 8
+  %29 = load ptr, ptr %result20, align 8
+  %30 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 0
+  %lo21 = load ptr, ptr %30, align 8
+  %31 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 1
+  %hi22 = load i64, ptr %31, align 8
+  %32 = call i64 @std.io.File.printn(ptr %retparam19, ptr %29, ptr %lo21, i64 %hi22)
+  ret void
+}
+; Function Attrs: nounwind
+define void @test.main() #0 {
+entry:
+  %is_def2 = alloca i8, align 1
+  store i8 1, ptr %is_def2, align 1
+  call void @test.test(i32 10)
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/compile_time/ct_foreach.c3t b/test/test_suite/compile_time/ct_foreach.c3t
index 71649bb19..684a75999 100644
--- a/test/test_suite/compile_time/ct_foreach.c3t
+++ b/test/test_suite/compile_time/ct_foreach.c3t
@@ -28,12 +28,13 @@ fn void main()
 }
 
 /* #expect: test.ll
+
 define void @test.main() #0 {
 entry:
   %z = alloca i32, align 4
-  %z1 = alloca ptr, align 8
+  %z1 = alloca %"char[]", align 8
   %z2 = alloca i32, align 4
-  %z3 = alloca ptr, align 8
+  %z3 = alloca %"char[]", align 8
   call void (ptr, ...) @printf(ptr @.str, i32 1)
   call void (ptr, ...) @printf(ptr @.str.1, i32 10)
   call void (ptr, ...) @printf(ptr @.str.2, i32 34)
@@ -42,11 +43,11 @@ entry:
   call void (ptr, ...) @printf(ptr @.str.5, i32 2, i32 34)
   store i32 123, ptr %z, align 4
   call void (ptr, ...) @printf(ptr @.str.6, i32 123)
-  store ptr @.str.7, ptr %z1, align 8
+  store %"char[]" { ptr @.str.7, i64 3 }, ptr %z1, align 8
   call void (ptr, ...) @printf(ptr @.str.8, ptr @.str.9)
   store i32 1177, ptr %z2, align 4
   call void (ptr, ...) @printf(ptr @.str.10, i32 1177)
-  store ptr @.str.11, ptr %z3, align 8
+  store %"char[]" { ptr @.str.11, i64 5 }, ptr %z3, align 8
   call void (ptr, ...) @printf(ptr @.str.12, ptr @.str.13)
   ret void
-}
+}
\ No newline at end of file
diff --git a/test/test_suite/compile_time/ct_memberof.c3t b/test/test_suite/compile_time/ct_memberof.c3t
index a06e136e8..93eb03d87 100644
--- a/test/test_suite/compile_time/ct_memberof.c3t
+++ b/test/test_suite/compile_time/ct_memberof.c3t
@@ -117,249 +117,269 @@ entry:
 ; Function Attrs: nounwind
 define void @test.test(i32 %0) #0 {
 entry:
-  %x = alloca ptr, align 8
+  %x = alloca %"char[]", align 8
   %retparam = alloca i64, align 8
   %result = alloca %File, align 8
-  %x1 = alloca ptr, align 8
+  %x1 = alloca %"char[]", align 8
   %retparam2 = alloca i64, align 8
   %result3 = alloca %File, align 8
-  %x4 = alloca ptr, align 8
-  %retparam5 = alloca i64, align 8
-  %result6 = alloca %File, align 8
-  %x7 = alloca ptr, align 8
-  %retparam8 = alloca i64, align 8
-  %result9 = alloca %File, align 8
-  %x10 = alloca ptr, align 8
-  %retparam11 = alloca i64, align 8
-  %result12 = alloca %File, align 8
-  %x13 = alloca ptr, align 8
-  %retparam14 = alloca i64, align 8
-  %result15 = alloca %File, align 8
-  %x16 = alloca ptr, align 8
+  %x6 = alloca %"char[]", align 8
+  %retparam7 = alloca i64, align 8
+  %result8 = alloca %File, align 8
+  %x11 = alloca %"char[]", align 8
+  %retparam12 = alloca i64, align 8
+  %result13 = alloca %File, align 8
+  %x16 = alloca %"char[]", align 8
   %retparam17 = alloca i64, align 8
   %result18 = alloca %File, align 8
-  %retparam19 = alloca i64, align 8
+  %x21 = alloca %"char[]", align 8
+  %retparam22 = alloca i64, align 8
+  %result23 = alloca %File, align 8
+  %x26 = alloca %"char[]", align 8
+  %retparam27 = alloca i64, align 8
+  %result28 = alloca %File, align 8
+  %retparam31 = alloca i64, align 8
   %varargslots = alloca [1 x %variant], align 16
-  %taddr = alloca ptr, align 8
-  %retparam20 = alloca i64, align 8
-  %varargslots21 = alloca [2 x %variant], align 16
-  %taddr22 = alloca ptr, align 8
-  %taddr23 = alloca ptr, align 8
-  %retparam24 = alloca i64, align 8
-  %varargslots25 = alloca [2 x %variant], align 16
-  %taddr26 = alloca ptr, align 8
-  %taddr27 = alloca ptr, align 8
-  %retparam28 = alloca i64, align 8
-  %varargslots29 = alloca [2 x %variant], align 16
-  %taddr30 = alloca ptr, align 8
-  %taddr31 = alloca ptr, align 8
+  %taddr = alloca %"char[]", align 8
   %retparam32 = alloca i64, align 8
   %varargslots33 = alloca [2 x %variant], align 16
-  %taddr34 = alloca ptr, align 8
-  %taddr35 = alloca ptr, align 8
+  %taddr34 = alloca %"char[]", align 8
+  %taddr35 = alloca %"char[]", align 8
   %retparam36 = alloca i64, align 8
-  %varargslots37 = alloca [1 x %variant], align 16
-  %taddr38 = alloca ptr, align 8
-  %retparam39 = alloca i64, align 8
-  %varargslots40 = alloca [2 x %variant], align 16
-  %taddr41 = alloca ptr, align 8
-  %taddr42 = alloca ptr, align 8
-  %retparam43 = alloca i64, align 8
-  %varargslots44 = alloca [2 x %variant], align 16
-  %taddr45 = alloca ptr, align 8
-  %taddr46 = alloca ptr, align 8
-  %retparam47 = alloca i64, align 8
-  %varargslots48 = alloca [2 x %variant], align 16
-  %taddr49 = alloca ptr, align 8
-  %taddr50 = alloca ptr, align 8
+  %varargslots37 = alloca [2 x %variant], align 16
+  %taddr38 = alloca %"char[]", align 8
+  %taddr39 = alloca %"char[]", align 8
+  %retparam40 = alloca i64, align 8
+  %varargslots41 = alloca [2 x %variant], align 16
+  %taddr42 = alloca %"char[]", align 8
+  %taddr43 = alloca %"char[]", align 8
+  %retparam44 = alloca i64, align 8
+  %varargslots45 = alloca [2 x %variant], align 16
+  %taddr46 = alloca %"char[]", align 8
+  %taddr47 = alloca %"char[]", align 8
+  %retparam48 = alloca i64, align 8
+  %varargslots49 = alloca [1 x %variant], align 16
+  %taddr50 = alloca %"char[]", align 8
   %retparam51 = alloca i64, align 8
   %varargslots52 = alloca [2 x %variant], align 16
-  %taddr53 = alloca ptr, align 8
-  %taddr54 = alloca ptr, align 8
+  %taddr53 = alloca %"char[]", align 8
+  %taddr54 = alloca %"char[]", align 8
   %retparam55 = alloca i64, align 8
-  %varargslots56 = alloca [1 x %variant], align 16
-  %taddr57 = alloca ptr, align 8
-  %retparam58 = alloca i64, align 8
-  %varargslots59 = alloca [2 x %variant], align 16
-  %taddr60 = alloca ptr, align 8
-  %taddr61 = alloca ptr, align 8
-  %retparam62 = alloca i64, align 8
-  %varargslots63 = alloca [2 x %variant], align 16
-  %taddr64 = alloca ptr, align 8
-  %taddr65 = alloca ptr, align 8
-  store ptr @.str, ptr %x, align 8
+  %varargslots56 = alloca [2 x %variant], align 16
+  %taddr57 = alloca %"char[]", align 8
+  %taddr58 = alloca %"char[]", align 8
+  %retparam59 = alloca i64, align 8
+  %varargslots60 = alloca [2 x %variant], align 16
+  %taddr61 = alloca %"char[]", align 8
+  %taddr62 = alloca %"char[]", align 8
+  %retparam63 = alloca i64, align 8
+  %varargslots64 = alloca [2 x %variant], align 16
+  %taddr65 = alloca %"char[]", align 8
+  %taddr66 = alloca %"char[]", align 8
+  %retparam67 = alloca i64, align 8
+  %varargslots68 = alloca [1 x %variant], align 16
+  %taddr69 = alloca %"char[]", align 8
+  %retparam70 = alloca i64, align 8
+  %varargslots71 = alloca [2 x %variant], align 16
+  %taddr72 = alloca %"char[]", align 8
+  %taddr73 = alloca %"char[]", align 8
+  %retparam74 = alloca i64, align 8
+  %varargslots75 = alloca [2 x %variant], align 16
+  %taddr76 = alloca %"char[]", align 8
+  %taddr77 = alloca %"char[]", align 8
+  store %"char[]" { ptr @.str, i64 3 }, ptr %x, align 8
   %1 = call ptr @std.io.stdout()
   store ptr %1, ptr %result, align 8
   %2 = load ptr, ptr %result, align 8
-  %3 = load ptr, ptr %x, align 8
-  %4 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %3, i64 3)
-  store ptr @.str.10, ptr %x1, align 8
-  %5 = call ptr @std.io.stdout()
-  store ptr %5, ptr %result3, align 8
-  %6 = load ptr, ptr %result3, align 8
-  %7 = load ptr, ptr %x1, align 8
-  %8 = call i64 @std.io.File.printn(ptr %retparam2, ptr %6, ptr %7, i64 3)
-  store ptr @.str.11, ptr %x4, align 8
-  %9 = call ptr @std.io.stdout()
-  store ptr %9, ptr %result6, align 8
-  %10 = load ptr, ptr %result6, align 8
-  %11 = load ptr, ptr %x4, align 8
-  %12 = call i64 @std.io.File.printn(ptr %retparam5, ptr %10, ptr %11, i64 6)
-  store ptr @.str.12, ptr %x7, align 8
-  %13 = call ptr @std.io.stdout()
-  store ptr %13, ptr %result9, align 8
-  %14 = load ptr, ptr %result9, align 8
-  %15 = load ptr, ptr %x7, align 8
-  %16 = call i64 @std.io.File.printn(ptr %retparam8, ptr %14, ptr %15, i64 6)
-  store ptr @.str.13, ptr %x10, align 8
-  %17 = call ptr @std.io.stdout()
-  store ptr %17, ptr %result12, align 8
-  %18 = load ptr, ptr %result12, align 8
-  %19 = load ptr, ptr %x10, align 8
-  %20 = call i64 @std.io.File.printn(ptr %retparam11, ptr %18, ptr %19, i64 9)
-  store ptr @.str.14, ptr %x13, align 8
+  %3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
+  %lo = load ptr, ptr %3, align 8
+  %4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
+  %hi = load i64, ptr %4, align 8
+  %5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi)
+  store %"char[]" { ptr @.str.10, i64 3 }, ptr %x1, align 8
+  %6 = call ptr @std.io.stdout()
+  store ptr %6, ptr %result3, align 8
+  %7 = load ptr, ptr %result3, align 8
+  %8 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 0
+  %lo4 = load ptr, ptr %8, align 8
+  %9 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 1
+  %hi5 = load i64, ptr %9, align 8
+  %10 = call i64 @std.io.File.printn(ptr %retparam2, ptr %7, ptr %lo4, i64 %hi5)
+  store %"char[]" { ptr @.str.11, i64 6 }, ptr %x6, align 8
+  %11 = call ptr @std.io.stdout()
+  store ptr %11, ptr %result8, align 8
+  %12 = load ptr, ptr %result8, align 8
+  %13 = getelementptr inbounds %"char[]", ptr %x6, i32 0, i32 0
+  %lo9 = load ptr, ptr %13, align 8
+  %14 = getelementptr inbounds %"char[]", ptr %x6, i32 0, i32 1
+  %hi10 = load i64, ptr %14, align 8
+  %15 = call i64 @std.io.File.printn(ptr %retparam7, ptr %12, ptr %lo9, i64 %hi10)
+  store %"char[]" { ptr @.str.12, i64 6 }, ptr %x11, align 8
+  %16 = call ptr @std.io.stdout()
+  store ptr %16, ptr %result13, align 8
+  %17 = load ptr, ptr %result13, align 8
+  %18 = getelementptr inbounds %"char[]", ptr %x11, i32 0, i32 0
+  %lo14 = load ptr, ptr %18, align 8
+  %19 = getelementptr inbounds %"char[]", ptr %x11, i32 0, i32 1
+  %hi15 = load i64, ptr %19, align 8
+  %20 = call i64 @std.io.File.printn(ptr %retparam12, ptr %17, ptr %lo14, i64 %hi15)
+  store %"char[]" { ptr @.str.13, i64 9 }, ptr %x16, align 8
   %21 = call ptr @std.io.stdout()
-  store ptr %21, ptr %result15, align 8
-  %22 = load ptr, ptr %result15, align 8
-  %23 = load ptr, ptr %x13, align 8
-  %24 = call i64 @std.io.File.printn(ptr %retparam14, ptr %22, ptr %23, i64 4)
-  store ptr @.str.15, ptr %x16, align 8
-  %25 = call ptr @std.io.stdout()
-  store ptr %25, ptr %result18, align 8
-  %26 = load ptr, ptr %result18, align 8
-  %27 = load ptr, ptr %x16, align 8
-  %28 = call i64 @std.io.File.printn(ptr %retparam17, ptr %26, ptr %27, i64 3)
-  store ptr @.str.17, ptr %taddr, align 8
-  %29 = insertvalue %variant undef, ptr %taddr, 0
-  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
-  %31 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
-  store %variant %30, ptr %31, align 16
-  %32 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
-  store ptr @.str.19, ptr %taddr22, align 8
-  %33 = insertvalue %variant undef, ptr %taddr22, 0
-  %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
-  %35 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 0
-  store %variant %34, ptr %35, align 16
-  store ptr @.str.20, ptr %taddr23, align 8
-  %36 = insertvalue %variant undef, ptr %taddr23, 0
-  %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
-  %38 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 1
+  store ptr %21, ptr %result18, align 8
+  %22 = load ptr, ptr %result18, align 8
+  %23 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 0
+  %lo19 = load ptr, ptr %23, align 8
+  %24 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 1
+  %hi20 = load i64, ptr %24, align 8
+  %25 = call i64 @std.io.File.printn(ptr %retparam17, ptr %22, ptr %lo19, i64 %hi20)
+  store %"char[]" { ptr @.str.14, i64 4 }, ptr %x21, align 8
+  %26 = call ptr @std.io.stdout()
+  store ptr %26, ptr %result23, align 8
+  %27 = load ptr, ptr %result23, align 8
+  %28 = getelementptr inbounds %"char[]", ptr %x21, i32 0, i32 0
+  %lo24 = load ptr, ptr %28, align 8
+  %29 = getelementptr inbounds %"char[]", ptr %x21, i32 0, i32 1
+  %hi25 = load i64, ptr %29, align 8
+  %30 = call i64 @std.io.File.printn(ptr %retparam22, ptr %27, ptr %lo24, i64 %hi25)
+  store %"char[]" { ptr @.str.15, i64 3 }, ptr %x26, align 8
+  %31 = call ptr @std.io.stdout()
+  store ptr %31, ptr %result28, align 8
+  %32 = load ptr, ptr %result28, align 8
+  %33 = getelementptr inbounds %"char[]", ptr %x26, i32 0, i32 0
+  %lo29 = load ptr, ptr %33, align 8
+  %34 = getelementptr inbounds %"char[]", ptr %x26, i32 0, i32 1
+  %hi30 = load i64, ptr %34, align 8
+  %35 = call i64 @std.io.File.printn(ptr %retparam27, ptr %32, ptr %lo29, i64 %hi30)
+  store %"char[]" { ptr @.str.17, i64 3 }, ptr %taddr, align 8
+  %36 = insertvalue %variant undef, ptr %taddr, 0
+  %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %38 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %37, ptr %38, align 16
-  %39 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.18, i64 6, ptr %varargslots21, i64 2)
-  store ptr @.str.22, ptr %taddr26, align 8
-  %40 = insertvalue %variant undef, ptr %taddr26, 0
-  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
-  %42 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 0
+  %39 = call i64 @std.io.printfn(ptr %retparam31, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
+  store %"char[]" { ptr @.str.19, i64 1 }, ptr %taddr34, align 8
+  %40 = insertvalue %variant undef, ptr %taddr34, 0
+  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %42 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 0
   store %variant %41, ptr %42, align 16
-  store ptr @.str.23, ptr %taddr27, align 8
-  %43 = insertvalue %variant undef, ptr %taddr27, 0
-  %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
-  %45 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 1
+  store %"char[]" { ptr @.str.20, i64 3 }, ptr %taddr35, align 8
+  %43 = insertvalue %variant undef, ptr %taddr35, 0
+  %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %45 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 1
   store %variant %44, ptr %45, align 16
-  %46 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.21, i64 6, ptr %varargslots25, i64 2)
-  store ptr @.str.25, ptr %taddr30, align 8
-  %47 = insertvalue %variant undef, ptr %taddr30, 0
-  %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"$ct.p$a0$char" to i64), 1
-  %49 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 0
+  %46 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.18, i64 6, ptr %varargslots33, i64 2)
+  store %"char[]" { ptr @.str.22, i64 4 }, ptr %taddr38, align 8
+  %47 = insertvalue %variant undef, ptr %taddr38, 0
+  %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %49 = getelementptr inbounds [2 x %variant], ptr %varargslots37, i64 0, i64 0
   store %variant %48, ptr %49, align 16
-  store ptr @.str.26, ptr %taddr31, align 8
-  %50 = insertvalue %variant undef, ptr %taddr31, 0
-  %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
-  %52 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 1
+  store %"char[]" { ptr @.str.23, i64 4 }, ptr %taddr39, align 8
+  %50 = insertvalue %variant undef, ptr %taddr39, 0
+  %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %52 = getelementptr inbounds [2 x %variant], ptr %varargslots37, i64 0, i64 1
   store %variant %51, ptr %52, align 16
-  %53 = call i64 @std.io.printfn(ptr %retparam28, ptr @.str.24, i64 6, ptr %varargslots29, i64 2)
-  store ptr @.str.28, ptr %taddr34, align 8
-  %54 = insertvalue %variant undef, ptr %taddr34, 0
-  %55 = insertvalue %variant %54, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
-  %56 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 0
+  %53 = call i64 @std.io.printfn(ptr %retparam36, ptr @.str.21, i64 6, ptr %varargslots37, i64 2)
+  store %"char[]" zeroinitializer, ptr %taddr42, align 8
+  %54 = insertvalue %variant undef, ptr %taddr42, 0
+  %55 = insertvalue %variant %54, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %56 = getelementptr inbounds [2 x %variant], ptr %varargslots41, i64 0, i64 0
   store %variant %55, ptr %56, align 16
-  store ptr @.str.29, ptr %taddr35, align 8
-  %57 = insertvalue %variant undef, ptr %taddr35, 0
-  %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"$ct.p$a6$char" to i64), 1
-  %59 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 1
+  store %"char[]" { ptr @.str.25, i64 5 }, ptr %taddr43, align 8
+  %57 = insertvalue %variant undef, ptr %taddr43, 0
+  %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %59 = getelementptr inbounds [2 x %variant], ptr %varargslots41, i64 0, i64 1
   store %variant %58, ptr %59, align 16
-  %60 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.27, i64 6, ptr %varargslots33, i64 2)
-  store ptr @.str.31, ptr %taddr38, align 8
-  %61 = insertvalue %variant undef, ptr %taddr38, 0
-  %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
-  %63 = getelementptr inbounds [1 x %variant], ptr %varargslots37, i64 0, i64 0
+  %60 = call i64 @std.io.printfn(ptr %retparam40, ptr @.str.24, i64 6, ptr %varargslots41, i64 2)
+  store %"char[]" { ptr @.str.27, i64 1 }, ptr %taddr46, align 8
+  %61 = insertvalue %variant undef, ptr %taddr46, 0
+  %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %63 = getelementptr inbounds [2 x %variant], ptr %varargslots45, i64 0, i64 0
   store %variant %62, ptr %63, align 16
-  %64 = call i64 @std.io.printfn(ptr %retparam36, ptr @.str.30, i64 8, ptr %varargslots37, i64 1)
-  store ptr @.str.33, ptr %taddr41, align 8
-  %65 = insertvalue %variant undef, ptr %taddr41, 0
-  %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
-  %67 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 0
-  store %variant %66, ptr %67, align 16
-  store ptr @.str.34, ptr %taddr42, align 8
-  %68 = insertvalue %variant undef, ptr %taddr42, 0
-  %69 = insertvalue %variant %68, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
-  %70 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1
+  store %"char[]" { ptr @.str.28, i64 6 }, ptr %taddr47, align 8
+  %64 = insertvalue %variant undef, ptr %taddr47, 0
+  %65 = insertvalue %variant %64, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %66 = getelementptr inbounds [2 x %variant], ptr %varargslots45, i64 0, i64 1
+  store %variant %65, ptr %66, align 16
+  %67 = call i64 @std.io.printfn(ptr %retparam44, ptr @.str.26, i64 6, ptr %varargslots45, i64 2)
+  store %"char[]" { ptr @.str.30, i64 3 }, ptr %taddr50, align 8
+  %68 = insertvalue %variant undef, ptr %taddr50, 0
+  %69 = insertvalue %variant %68, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %70 = getelementptr inbounds [1 x %variant], ptr %varargslots49, i64 0, i64 0
   store %variant %69, ptr %70, align 16
-  %71 = call i64 @std.io.printfn(ptr %retparam39, ptr @.str.32, i64 6, ptr %varargslots40, i64 2)
-  store ptr @.str.36, ptr %taddr45, align 8
-  %72 = insertvalue %variant undef, ptr %taddr45, 0
-  %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
-  %74 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 0
+  %71 = call i64 @std.io.printfn(ptr %retparam48, ptr @.str.29, i64 8, ptr %varargslots49, i64 1)
+  store %"char[]" { ptr @.str.32, i64 1 }, ptr %taddr53, align 8
+  %72 = insertvalue %variant undef, ptr %taddr53, 0
+  %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %74 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 0
   store %variant %73, ptr %74, align 16
-  store ptr @.str.37, ptr %taddr46, align 8
-  %75 = insertvalue %variant undef, ptr %taddr46, 0
-  %76 = insertvalue %variant %75, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
-  %77 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 1
+  store %"char[]" { ptr @.str.33, i64 4 }, ptr %taddr54, align 8
+  %75 = insertvalue %variant undef, ptr %taddr54, 0
+  %76 = insertvalue %variant %75, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %77 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 1
   store %variant %76, ptr %77, align 16
-  %78 = call i64 @std.io.printfn(ptr %retparam43, ptr @.str.35, i64 6, ptr %varargslots44, i64 2)
-  store ptr @.str.39, ptr %taddr49, align 8
-  %79 = insertvalue %variant undef, ptr %taddr49, 0
-  %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"$ct.p$a0$char" to i64), 1
-  %81 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 0
+  %78 = call i64 @std.io.printfn(ptr %retparam51, ptr @.str.31, i64 6, ptr %varargslots52, i64 2)
+  store %"char[]" { ptr @.str.35, i64 1 }, ptr %taddr57, align 8
+  %79 = insertvalue %variant undef, ptr %taddr57, 0
+  %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %81 = getelementptr inbounds [2 x %variant], ptr %varargslots56, i64 0, i64 0
   store %variant %80, ptr %81, align 16
-  store ptr @.str.40, ptr %taddr50, align 8
-  %82 = insertvalue %variant undef, ptr %taddr50, 0
-  %83 = insertvalue %variant %82, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
-  %84 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 1
+  store %"char[]" { ptr @.str.36, i64 5 }, ptr %taddr58, align 8
+  %82 = insertvalue %variant undef, ptr %taddr58, 0
+  %83 = insertvalue %variant %82, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %84 = getelementptr inbounds [2 x %variant], ptr %varargslots56, i64 0, i64 1
   store %variant %83, ptr %84, align 16
-  %85 = call i64 @std.io.printfn(ptr %retparam47, ptr @.str.38, i64 6, ptr %varargslots48, i64 2)
-  store ptr @.str.42, ptr %taddr53, align 8
-  %86 = insertvalue %variant undef, ptr %taddr53, 0
-  %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
-  %88 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 0
+  %85 = call i64 @std.io.printfn(ptr %retparam55, ptr @.str.34, i64 6, ptr %varargslots56, i64 2)
+  store %"char[]" zeroinitializer, ptr %taddr61, align 8
+  %86 = insertvalue %variant undef, ptr %taddr61, 0
+  %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %88 = getelementptr inbounds [2 x %variant], ptr %varargslots60, i64 0, i64 0
   store %variant %87, ptr %88, align 16
-  store ptr @.str.43, ptr %taddr54, align 8
-  %89 = insertvalue %variant undef, ptr %taddr54, 0
-  %90 = insertvalue %variant %89, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
-  %91 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 1
+  store %"char[]" { ptr @.str.38, i64 5 }, ptr %taddr62, align 8
+  %89 = insertvalue %variant undef, ptr %taddr62, 0
+  %90 = insertvalue %variant %89, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %91 = getelementptr inbounds [2 x %variant], ptr %varargslots60, i64 0, i64 1
   store %variant %90, ptr %91, align 16
-  %92 = call i64 @std.io.printfn(ptr %retparam51, ptr @.str.41, i64 6, ptr %varargslots52, i64 2)
-  store ptr @.str.45, ptr %taddr57, align 8
-  %93 = insertvalue %variant undef, ptr %taddr57, 0
-  %94 = insertvalue %variant %93, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
-  %95 = getelementptr inbounds [1 x %variant], ptr %varargslots56, i64 0, i64 0
+  %92 = call i64 @std.io.printfn(ptr %retparam59, ptr @.str.37, i64 6, ptr %varargslots60, i64 2)
+  store %"char[]" { ptr @.str.40, i64 3 }, ptr %taddr65, align 8
+  %93 = insertvalue %variant undef, ptr %taddr65, 0
+  %94 = insertvalue %variant %93, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %95 = getelementptr inbounds [2 x %variant], ptr %varargslots64, i64 0, i64 0
   store %variant %94, ptr %95, align 16
-  %96 = call i64 @std.io.printfn(ptr %retparam55, ptr @.str.44, i64 8, ptr %varargslots56, i64 1)
-  store ptr @.str.47, ptr %taddr60, align 8
-  %97 = insertvalue %variant undef, ptr %taddr60, 0
-  %98 = insertvalue %variant %97, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
-  %99 = getelementptr inbounds [2 x %variant], ptr %varargslots59, i64 0, i64 0
-  store %variant %98, ptr %99, align 16
-  store ptr @.str.48, ptr %taddr61, align 8
-  %100 = insertvalue %variant undef, ptr %taddr61, 0
-  %101 = insertvalue %variant %100, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
-  %102 = getelementptr inbounds [2 x %variant], ptr %varargslots59, i64 0, i64 1
+  store %"char[]" { ptr @.str.41, i64 3 }, ptr %taddr66, align 8
+  %96 = insertvalue %variant undef, ptr %taddr66, 0
+  %97 = insertvalue %variant %96, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %98 = getelementptr inbounds [2 x %variant], ptr %varargslots64, i64 0, i64 1
+  store %variant %97, ptr %98, align 16
+  %99 = call i64 @std.io.printfn(ptr %retparam63, ptr @.str.39, i64 6, ptr %varargslots64, i64 2)
+  store %"char[]" { ptr @.str.43, i64 4 }, ptr %taddr69, align 8
+  %100 = insertvalue %variant undef, ptr %taddr69, 0
+  %101 = insertvalue %variant %100, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %102 = getelementptr inbounds [1 x %variant], ptr %varargslots68, i64 0, i64 0
   store %variant %101, ptr %102, align 16
-  %103 = call i64 @std.io.printfn(ptr %retparam58, ptr @.str.46, i64 6, ptr %varargslots59, i64 2)
-  store ptr @.str.50, ptr %taddr64, align 8
-  %104 = insertvalue %variant undef, ptr %taddr64, 0
-  %105 = insertvalue %variant %104, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
-  %106 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 0
+  %103 = call i64 @std.io.printfn(ptr %retparam67, ptr @.str.42, i64 8, ptr %varargslots68, i64 1)
+  store %"char[]" { ptr @.str.45, i64 1 }, ptr %taddr72, align 8
+  %104 = insertvalue %variant undef, ptr %taddr72, 0
+  %105 = insertvalue %variant %104, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %106 = getelementptr inbounds [2 x %variant], ptr %varargslots71, i64 0, i64 0
   store %variant %105, ptr %106, align 16
-  store ptr @.str.51, ptr %taddr65, align 8
-  %107 = insertvalue %variant undef, ptr %taddr65, 0
-  %108 = insertvalue %variant %107, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
-  %109 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 1
+  store %"char[]" { ptr @.str.46, i64 3 }, ptr %taddr73, align 8
+  %107 = insertvalue %variant undef, ptr %taddr73, 0
+  %108 = insertvalue %variant %107, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %109 = getelementptr inbounds [2 x %variant], ptr %varargslots71, i64 0, i64 1
   store %variant %108, ptr %109, align 16
-  %110 = call i64 @std.io.printfn(ptr %retparam62, ptr @.str.49, i64 6, ptr %varargslots63, i64 2)
+  %110 = call i64 @std.io.printfn(ptr %retparam70, ptr @.str.44, i64 6, ptr %varargslots71, i64 2)
+  store %"char[]" { ptr @.str.48, i64 1 }, ptr %taddr76, align 8
+  %111 = insertvalue %variant undef, ptr %taddr76, 0
+  %112 = insertvalue %variant %111, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %113 = getelementptr inbounds [2 x %variant], ptr %varargslots75, i64 0, i64 0
+  store %variant %112, ptr %113, align 16
+  store %"char[]" { ptr @.str.49, i64 5 }, ptr %taddr77, align 8
+  %114 = insertvalue %variant undef, ptr %taddr77, 0
+  %115 = insertvalue %variant %114, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %116 = getelementptr inbounds [2 x %variant], ptr %varargslots75, i64 0, i64 1
+  store %variant %115, ptr %116, align 16
+  %117 = call i64 @std.io.printfn(ptr %retparam74, ptr @.str.47, i64 6, ptr %varargslots75, i64 2)
   ret void
 }
-
 ; Function Attrs: nounwind
 define void @test.main() #0 {
 entry:
@@ -409,13 +429,13 @@ entry:
   %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"$ct.long" to i64), 1
   %2 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %1, ptr %2, align 16
-  %3 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.52, i64 7, ptr %varargslots, i64 1)
+  %3 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.50, i64 7, ptr %varargslots, i64 1)
   store i64 1, ptr %taddr3, align 8
   %4 = insertvalue %variant undef, ptr %taddr3, 0
   %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"$ct.long" to i64), 1
   %6 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0
   store %variant %5, ptr %6, align 16
-  %7 = call i64 @std.io.printfn(ptr %retparam1, ptr @.str.53, i64 7, ptr %varargslots2, i64 1)
+  %7 = call i64 @std.io.printfn(ptr %retparam1, ptr @.str.51, i64 7, ptr %varargslots2, i64 1)
   store i64 0, ptr %taddr6, align 8
   %8 = insertvalue %variant undef, ptr %taddr6, 0
   %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
@@ -426,7 +446,7 @@ entry:
   %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %13 = getelementptr inbounds [2 x %variant], ptr %varargslots5, i64 0, i64 1
   store %variant %12, ptr %13, align 16
-  %14 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.54, i64 8, ptr %varargslots5, i64 2)
+  %14 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.52, i64 8, ptr %varargslots5, i64 2)
   store i64 2, ptr %taddr10, align 8
   %15 = insertvalue %variant undef, ptr %taddr10, 0
   %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
@@ -437,7 +457,7 @@ entry:
   %19 = insertvalue %variant %18, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %20 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 1
   store %variant %19, ptr %20, align 16
-  %21 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.55, i64 8, ptr %varargslots9, i64 2)
+  %21 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.53, i64 8, ptr %varargslots9, i64 2)
   store i64 4, ptr %taddr14, align 8
   %22 = insertvalue %variant undef, ptr %taddr14, 0
   %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
@@ -448,7 +468,7 @@ entry:
   %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %27 = getelementptr inbounds [2 x %variant], ptr %varargslots13, i64 0, i64 1
   store %variant %26, ptr %27, align 16
-  %28 = call i64 @std.io.printfn(ptr %retparam12, ptr @.str.56, i64 8, ptr %varargslots13, i64 2)
+  %28 = call i64 @std.io.printfn(ptr %retparam12, ptr @.str.54, i64 8, ptr %varargslots13, i64 2)
   store i64 4, ptr %taddr18, align 8
   %29 = insertvalue %variant undef, ptr %taddr18, 0
   %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
@@ -459,7 +479,7 @@ entry:
   %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %34 = getelementptr inbounds [2 x %variant], ptr %varargslots17, i64 0, i64 1
   store %variant %33, ptr %34, align 16
-  %35 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.57, i64 8, ptr %varargslots17, i64 2)
+  %35 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.55, i64 8, ptr %varargslots17, i64 2)
   store i64 4, ptr %taddr22, align 8
   %36 = insertvalue %variant undef, ptr %taddr22, 0
   %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
@@ -470,7 +490,7 @@ entry:
   %40 = insertvalue %variant %39, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %41 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 1
   store %variant %40, ptr %41, align 16
-  %42 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.58, i64 9, ptr %varargslots21, i64 2)
+  %42 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.56, i64 9, ptr %varargslots21, i64 2)
   store i64 5, ptr %taddr26, align 8
   %43 = insertvalue %variant undef, ptr %taddr26, 0
   %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
@@ -481,7 +501,7 @@ entry:
   %47 = insertvalue %variant %46, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %48 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 1
   store %variant %47, ptr %48, align 16
-  %49 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.59, i64 9, ptr %varargslots25, i64 2)
+  %49 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.57, i64 9, ptr %varargslots25, i64 2)
   store i64 8, ptr %taddr30, align 8
   %50 = insertvalue %variant undef, ptr %taddr30, 0
   %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
@@ -492,13 +512,13 @@ entry:
   %54 = insertvalue %variant %53, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %55 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 1
   store %variant %54, ptr %55, align 16
-  %56 = call i64 @std.io.printfn(ptr %retparam28, ptr @.str.60, i64 10, ptr %varargslots29, i64 2)
+  %56 = call i64 @std.io.printfn(ptr %retparam28, ptr @.str.58, i64 10, ptr %varargslots29, i64 2)
   store i64 4, ptr %taddr34, align 8
   %57 = insertvalue %variant undef, ptr %taddr34, 0
   %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %59 = getelementptr inbounds [1 x %variant], ptr %varargslots33, i64 0, i64 0
   store %variant %58, ptr %59, align 16
-  %60 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.61, i64 7, ptr %varargslots33, i64 1)
+  %60 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.59, i64 7, ptr %varargslots33, i64 1)
   store i64 8, ptr %taddr37, align 8
   %61 = insertvalue %variant undef, ptr %taddr37, 0
   %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
@@ -509,7 +529,7 @@ entry:
   %65 = insertvalue %variant %64, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %66 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 1
   store %variant %65, ptr %66, align 16
-  %67 = call i64 @std.io.printfn(ptr %retparam35, ptr @.str.62, i64 10, ptr %varargslots36, i64 2)
+  %67 = call i64 @std.io.printfn(ptr %retparam35, ptr @.str.60, i64 10, ptr %varargslots36, i64 2)
   call void @test.test(i32 10)
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/errors/error_regression_2.c3t b/test/test_suite/errors/error_regression_2.c3t
index 5ec61fb1a..96d18ee3b 100644
--- a/test/test_suite/errors/error_regression_2.c3t
+++ b/test/test_suite/errors/error_regression_2.c3t
@@ -168,7 +168,7 @@ cond.rhs:                                         ; preds = %entry
   br label %cond.phi
 
 cond.phi:                                         ; preds = %cond.rhs, %cond.lhs
-  %val = phi %"char[]" [ %6, %cond.lhs ], [ { ptr @.str.43, i64 7 }, %cond.rhs ]
+  %val = phi %"char[]" [ %6, %cond.lhs ], [ { ptr @.str.41, i64 7 }, %cond.rhs ]
   store %"char[]" %val, ptr %title, align 8
   %7 = getelementptr inbounds %"char[]", ptr %title, i32 0, i32 1
   %8 = load i64, ptr %7, align 8
@@ -178,8 +178,8 @@ cond.phi:                                         ; preds = %cond.rhs, %cond.lhs
   %11 = getelementptr inbounds %Summary, ptr %0, i32 0, i32 1
   %12 = load i8, ptr %11, align 8
   %13 = trunc i8 %12 to i1
-  %ternary = select i1 %13, ptr @.str.45, ptr @.str.46
-  %14 = call i32 (ptr, ptr, ...) @fprintf(ptr %1, ptr @.str.44, i32 %trunc, ptr %10, ptr %ternary)
+  %ternary = select i1 %13, ptr @.str.43, ptr @.str.44
+  %14 = call i32 (ptr, ptr, ...) @fprintf(ptr %1, ptr @.str.42, i32 %trunc, ptr %10, ptr %ternary)
   ret void
 }
 
@@ -488,7 +488,7 @@ expr_block.exit46:                                ; preds = %after_check45
 
 panic_block47:                                    ; preds = %assign_optional44
   %49 = load ptr, ptr @std.core.builtin.panic, align 8
-  call void %49(ptr @.panic_msg.7, i64 27, ptr @.file.8, i64 6, ptr @.func.9, i64 7
+  call void %49(ptr @.panic_msg.6, i64 27, ptr @.file.7, i64 6, ptr @.func.8, i64 7
   unreachable
 
 noerr_block48:                                    ; preds = %expr_block.exit46
@@ -546,7 +546,7 @@ expr_block.exit69:                                ; preds = %after_check68
 
 panic_block70:                                    ; preds = %assign_optional67
   %64 = load ptr, ptr @std.core.builtin.panic, align 8
-  call void %64(ptr @.panic_msg.10, i64 27, ptr @.file.11, i64 6, ptr @.func.12, i64 7
+  call void %64(ptr @.panic_msg.9, i64 27, ptr @.file.10, i64 6, ptr @.func.11, i64 7
   unreachable
 
 noerr_block71:                                    ; preds = %expr_block.exit69
@@ -580,7 +580,7 @@ if.exit77:                                        ; preds = %if.exit20
   %trunc = trunc i64 %70 to i32
   %71 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0
   %72 = load ptr, ptr %71, align 8
-  %73 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr null, i64 0, ptr @.str.13, i32 %trunc, ptr %72)
+  %73 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr null, i64 0, ptr @.str.12, i32 %trunc, ptr %72)
   store i32 %73, ptr %len, align 4
   %74 = load ptr, ptr @std.core.mem.thread_allocator, align 8
   store ptr %74, ptr %using78, align 8
@@ -617,7 +617,7 @@ expr_block.exit91:                                ; preds = %after_check90
 
 panic_block92:                                    ; preds = %assign_optional89
   %85 = load ptr, ptr @std.core.builtin.panic, align 8
-  call void %85(ptr @.panic_msg.14, i64 27, ptr @.file.15, i64 6, ptr @.func.16
+  call void %85(ptr @.panic_msg.13, i64 27, ptr @.file.14, i64 6, ptr @.func.15
   unreachable
 
 noerr_block93:                                    ; preds = %expr_block.exit91
@@ -639,7 +639,7 @@ if.exit96:                                        ; preds = %noerr_block93
   %trunc99 = trunc i64 %90 to i32
   %91 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0
   %92 = load ptr, ptr %91, align 8
-  %93 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %87, i64 %add98, ptr @.str.17, i32 %trunc99, ptr %92)
+  %93 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %87, i64 %add98, ptr @.str.16, i32 %trunc99, ptr %92)
   %94 = getelementptr inbounds %Doc, ptr %literal101, i32 0, i32 0
   store ptr null, ptr %literal104, align 8
   %95 = getelementptr inbounds %Head, ptr %literal104, i32 0, i32 0
@@ -685,7 +685,7 @@ expr_block.exit124:                               ; preds = %after_check123
 
 panic_block125:                                   ; preds = %assign_optional122
   %111 = load ptr, ptr @std.core.builtin.panic, align 8
-  call void %111(ptr @.panic_msg.18, i64 27, ptr @.file.19, i64 6, ptr @.func.20
+  call void %111(ptr @.panic_msg.17, i64 27, ptr @.file.18, i64 6, ptr @.func.19
   unreachable
 
 noerr_block126:                                   ; preds = %expr_block.exit124
@@ -743,7 +743,7 @@ expr_block.exit147:                               ; preds = %after_check146
 
 panic_block148:                                   ; preds = %assign_optional145
   %126 = load ptr, ptr @std.core.builtin.panic, align 8
-  call void %126(ptr @.panic_msg.21, i64 27, ptr @.file.22, i64 6, ptr @.func.23
+  call void %126(ptr @.panic_msg.20, i64 27, ptr @.file.21, i64 6, ptr @.func.22
   unreachable
 
 noerr_block149:                                   ; preds = %expr_block.exit147
@@ -935,7 +935,7 @@ err_retblock:                                     ; preds = %assign_optional3, %
 define ptr @test.bool_to_string(i8 zeroext %0) #0 {
 entry:
   %1 = trunc i8 %0 to i1
-  %ternary = select i1 %1, %"char[]" { ptr @.str.24, i64 4 }, %"char[]" { ptr @.str.25, i64 5 }
+  %ternary = select i1 %1, %"char[]" { ptr @.str.23, i64 4 }, %"char[]" { ptr @.str.24, i64 5 }
   %2 = extractvalue %"char[]" %ternary, 0
   ret ptr %2
 }
@@ -953,27 +953,27 @@ switch.entry:                                     ; preds = %entry
   br i1 %eq, label %switch.case, label %next_if
 
 switch.case:                                      ; preds = %switch.entry
-  ret ptr @.str.26
+  ret ptr @.str.25
 
 next_if:                                          ; preds = %switch.entry
   %eq1 = icmp eq i64 ptrtoint (ptr @"test.ReadError$BAD_READ" to i64), %1
   br i1 %eq1, label %switch.case2, label %next_if3
 
 switch.case2:                                     ; preds = %next_if
-  ret ptr @.str.27
+  ret ptr @.str.26
 
 next_if3:                                         ; preds = %next_if
   %eq4 = icmp eq i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64), %1
   br i1 %eq4, label %switch.case5, label %next_if6
 
 switch.case5:                                     ; preds = %next_if3
-  ret ptr @.str.28
+  ret ptr @.str.27
 
 next_if6:                                         ; preds = %next_if3
   br label %switch.default
 
 switch.default:                                   ; preds = %next_if6
-  ret ptr @.str.29
+  ret ptr @.str.28
 }
 
 ; Function Attrs: nounwind
@@ -991,15 +991,15 @@ entry:
   %has_title.f = alloca i64, align 8
   %retparam = alloca i8, align 1
   %0 = getelementptr inbounds [5 x %"char[]"], ptr %literal, i64 0, i64 0
-  store %"char[]" { ptr @.str.30, i64 4 }, ptr %0, align 8
+  store %"char[]" { ptr @.str.29, i64 4 }, ptr %0, align 8
   %1 = getelementptr inbounds [5 x %"char[]"], ptr %literal, i64 0, i64 1
-  store %"char[]" { ptr @.str.31, i64 11 }, ptr %1, align 8
+  store %"char[]" { ptr @.str.30, i64 11 }, ptr %1, align 8
   %2 = getelementptr inbounds [5 x %"char[]"], ptr %literal, i64 0, i64 2
-  store %"char[]" { ptr @.str.32, i64 13 }, ptr %2, align 8
+  store %"char[]" { ptr @.str.31, i64 13 }, ptr %2, align 8
   %3 = getelementptr inbounds [5 x %"char[]"], ptr %literal, i64 0, i64 3
-  store %"char[]" { ptr @.str.33, i64 12 }, ptr %3, align 8
+  store %"char[]" { ptr @.str.32, i64 12 }, ptr %3, align 8
   %4 = getelementptr inbounds [5 x %"char[]"], ptr %literal, i64 0, i64 4
-  store %"char[]" { ptr @.str.34, i64 4 }, ptr %4, align 8
+  store %"char[]" { ptr @.str.33, i64 4 }, ptr %4, align 8
   %5 = insertvalue %"char[][]" undef, ptr %literal, 0
   %6 = insertvalue %"char[][]" %5, i64 5, 1
   store %"char[][]" %6, ptr %URLS, align 8
@@ -1026,7 +1026,7 @@ loop.body:                                        ; preds = %loop.cond
   %trunc = trunc i64 %15 to i32
   %16 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0
   %17 = load ptr, ptr %16, align 8
-  %18 = call i32 (ptr, ...) @printf(ptr @.str.35, i32 %trunc, ptr %17)
+  %18 = call i32 (ptr, ...) @printf(ptr @.str.34, i32 %trunc, ptr %17)
   %19 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0
   %lo = load ptr, ptr %19, align 8
   %20 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1
@@ -1034,10 +1034,10 @@ loop.body:                                        ; preds = %loop.cond
   %21 = call { ptr, i8 } @test.readAndBuildSummary(ptr %lo, i64 %hi)
   store { ptr, i8 } %21, ptr %result, align 8
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %summary, ptr align 8 %result, i32 16, i1 false)
-  %22 = call i32 (ptr, ...) @printf(ptr @.str.36)
+  %22 = call i32 (ptr, ...) @printf(ptr @.str.35)
   %23 = load ptr, ptr @__stdoutp, align 8
   call void @test.Summary.print(ptr %summary, ptr %23)
-  %24 = call i32 (ptr, ...) @printf(ptr @.str.37)
+  %24 = call i32 (ptr, ...) @printf(ptr @.str.36)
   %25 = getelementptr inbounds %Summary, ptr %summary, i32 0, i32 0
   %26 = load ptr, ptr %25, align 8
   %ptrbool = icmp ne ptr %26, null
@@ -1060,7 +1060,7 @@ cond.phi:                                         ; preds = %cond.rhs, %cond.lhs
   %trunc2 = trunc i64 %31 to i32
   %32 = getelementptr inbounds %"char[]", ptr %title_sure, i32 0, i32 0
   %33 = load ptr, ptr %32, align 8
-  %34 = call i32 (ptr, ...) @printf(ptr @.str.39, i32 %trunc2, ptr %33)
+  %34 = call i32 (ptr, ...) @printf(ptr @.str.37, i32 %trunc2, ptr %33)
   %35 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0
   %lo3 = load ptr, ptr %35, align 8
   %36 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1
@@ -1113,8 +1113,8 @@ else_block11:                                     ; preds = %phi_block
 
 phi_block12:                                      ; preds = %else_block11, %after_check10
   %val13 = phi i1 [ %47, %after_check10 ], [ false, %else_block11 ]
-  %ternary = select i1 %val13, ptr @.str.41, ptr @.str.42
-  %48 = call i32 (ptr, ...) @printf(ptr @.str.40, ptr %val7, ptr %ternary)
+  %ternary = select i1 %val13, ptr @.str.39, ptr @.str.40
+  %48 = call i32 (ptr, ...) @printf(ptr @.str.38, ptr %val7, ptr %ternary)
   %49 = load i64, ptr %.anon1, align 8
   %add = add i64 %49, 1
   store i64 %add, ptr %.anon1, align 8
diff --git a/test/test_suite/errors/general_error_regression.c3t b/test/test_suite/errors/general_error_regression.c3t
index cdaa4fb54..082f33a30 100644
--- a/test/test_suite/errors/general_error_regression.c3t
+++ b/test/test_suite/errors/general_error_regression.c3t
@@ -74,45 +74,54 @@ fn void main()
 
 define void @foo.Foo.hello(ptr %0) #0 {
 entry:
-  %x = alloca ptr, align 8
+  %x = alloca %"char[]", align 8
   %retparam = alloca i64, align 8
   %result = alloca %File, align 8
-  store ptr @.str.12, ptr %x, align 8
+  store %"char[]" { ptr @.str.12, i64 14 }, ptr %x, align 8
   %1 = call ptr @std.io.stdout()
   store ptr %1, ptr %result, align 8
   %2 = load ptr, ptr %result, align 8
-  %3 = load ptr, ptr %x, align 8
-  %4 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %3, i64 14)
+  %3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
+  %lo = load ptr, ptr %3, align 8
+  %4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
+  %hi = load i64, ptr %4, align 8
+  %5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi)
   ret void
 }
 
 ; Function Attrs: nounwind
 define void @foo.Bar.hello(ptr %0) #0 {
 entry:
-  %x = alloca ptr, align 8
+  %x = alloca %"char[]", align 8
   %retparam = alloca i64, align 8
   %result = alloca %File, align 8
-  store ptr @.str.13, ptr %x, align 8
+  store %"char[]" { ptr @.str.13, i64 14 }, ptr %x, align 8
   %1 = call ptr @std.io.stdout()
   store ptr %1, ptr %result, align 8
   %2 = load ptr, ptr %result, align 8
-  %3 = load ptr, ptr %x, align 8
-  %4 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %3, i64 14)
+  %3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
+  %lo = load ptr, ptr %3, align 8
+  %4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
+  %hi = load i64, ptr %4, align 8
+  %5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi)
   ret void
 }
 
 ; Function Attrs: nounwind
 define void @foo.MyEnum.hello(ptr %0) #0 {
 entry:
-  %x = alloca ptr, align 8
+  %x = alloca %"char[]", align 8
   %retparam = alloca i64, align 8
   %result = alloca %File, align 8
-  store ptr @.str.14, ptr %x, align 8
+  store %"char[]" { ptr @.str.14, i64 17 }, ptr %x, align 8
   %1 = call ptr @std.io.stdout()
   store ptr %1, ptr %result, align 8
   %2 = load ptr, ptr %result, align 8
-  %3 = load ptr, ptr %x, align 8
-  %4 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %3, i64 17)
+  %3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
+  %lo = load ptr, ptr %3, align 8
+  %4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
+  %hi = load i64, ptr %4, align 8
+  %5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi)
   ret void
 }
 
diff --git a/test/test_suite/errors/or_and_rethrow.c3t b/test/test_suite/errors/or_and_rethrow.c3t
index 8b018ef46..0e88a192f 100644
--- a/test/test_suite/errors/or_and_rethrow.c3t
+++ b/test/test_suite/errors/or_and_rethrow.c3t
@@ -46,20 +46,20 @@ entry:
   %taddr = alloca i32, align 4
   %error_var = alloca i64, align 8
   %blockret = alloca i32, align 4
-  %x = alloca ptr, align 8
+  %x = alloca %"char[]", align 8
   %retparam1 = alloca i64, align 8
   %result = alloca %File, align 8
-  %x2 = alloca ptr, align 8
+  %x2 = alloca %"char[]", align 8
   %retparam3 = alloca i64, align 8
   %result4 = alloca %File, align 8
-  %error_var5 = alloca i64, align 8
-  %blockret6 = alloca i32, align 4
-  %x10 = alloca ptr, align 8
-  %retparam11 = alloca i64, align 8
-  %result12 = alloca %File, align 8
-  %x14 = alloca ptr, align 8
-  %retparam15 = alloca i64, align 8
-  %result16 = alloca %File, align 8
+  %error_var7 = alloca i64, align 8
+  %blockret8 = alloca i32, align 4
+  %x12 = alloca %"char[]", align 8
+  %retparam13 = alloca i64, align 8
+  %result14 = alloca %File, align 8
+  %x18 = alloca %"char[]", align 8
+  %retparam19 = alloca i64, align 8
+  %result20 = alloca %File, align 8
   %reterr = alloca i64, align 8
   store i32 %0, ptr %taddr, align 4
   %1 = insertvalue %variant undef, ptr %taddr, 0
@@ -86,39 +86,48 @@ or.phi:                                           ; preds = %entry
   br label %if.then
 
 if.then:                                          ; preds = %or.phi
-  store ptr @.str.2, ptr %x, align 8
+  store %"char[]" { ptr @.str.2, i64 3 }, ptr %x, align 8
   %6 = call ptr @std.io.stdout()
   store ptr %6, ptr %result, align 8
   %7 = load ptr, ptr %result, align 8
-  %8 = load ptr, ptr %x, align 8
-  %9 = call i64 @std.io.File.printn(ptr %retparam1, ptr %7, ptr %8, i64 3)
+  %8 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
+  %lo = load ptr, ptr %8, align 8
+  %9 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
+  %hi = load i64, ptr %9, align 8
+  %10 = call i64 @std.io.File.printn(ptr %retparam1, ptr %7, ptr %lo, i64 %hi)
   br label %if.exit
 
 if.exit:                                          ; preds = %if.then
-  store ptr @.str.3, ptr %x2, align 8
-  %10 = call ptr @std.io.stdout()
-  store ptr %10, ptr %result4, align 8
-  %11 = load ptr, ptr %result4, align 8
-  %12 = load ptr, ptr %x2, align 8
-  %13 = call i64 @std.io.File.printn(ptr %retparam3, ptr %11, ptr %12, i64 9)
-  store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var5, align 8
-  br label %opt_block_cleanup7
+  store %"char[]" { ptr @.str.3, i64 9 }, ptr %x2, align 8
+  %11 = call ptr @std.io.stdout()
+  store ptr %11, ptr %result4, align 8
+  %12 = load ptr, ptr %result4, align 8
+  %13 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 0
+  %lo5 = load ptr, ptr %13, align 8
+  %14 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 1
+  %hi6 = load i64, ptr %14, align 8
+  %15 = call i64 @std.io.File.printn(ptr %retparam3, ptr %12, ptr %lo5, i64 %hi6)
+  store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var7, align 8
+  br label %opt_block_cleanup9
 
-opt_block_cleanup7:                               ; preds = %if.exit
+opt_block_cleanup9:                               ; preds = %if.exit
   call void @foo.blurb()
-  br label %guard_block8
+  br label %guard_block10
 
-guard_block8:                                     ; preds = %opt_block_cleanup7
-  %14 = load i64, ptr %error_var5, align 8
-  ret i64 %14
+guard_block10:                                    ; preds = %opt_block_cleanup9
+  %16 = load i64, ptr %error_var7, align 8
+  ret i64 %16
 
-if.exit13:                                        ; No predecessors!
-  store ptr @.str.5, ptr %x14, align 8
-  %15 = call ptr @std.io.stdout()
-  store ptr %15, ptr %result16, align 8
-  %16 = load ptr, ptr %result16, align 8
-  %17 = load ptr, ptr %x14, align 8
-  %18 = call i64 @std.io.File.printn(ptr %retparam15, ptr %16, ptr %17, i64 7)
+if.exit17:                                        ; No predecessors!
+  store %"char[]" { ptr @.str.5, i64 7 }, ptr %x18, align 8
+  %17 = call ptr @std.io.stdout()
+  store ptr %17, ptr %result20, align 8
+  %18 = load ptr, ptr %result20, align 8
+  %19 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 0
+  %lo21 = load ptr, ptr %19, align 8
+  %20 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 1
+  %hi22 = load i64, ptr %20, align 8
+  %21 = call i64 @std.io.File.printn(ptr %retparam19, ptr %18, ptr %lo21, i64 %hi22)
   ret i64 0
 }
 
@@ -130,12 +139,12 @@ entry:
   %taddr = alloca i32, align 4
   %error_var = alloca i64, align 8
   %blockret = alloca i32, align 4
-  %x = alloca ptr, align 8
+  %x = alloca %"char[]", align 8
   %retparam1 = alloca i64, align 8
   %result = alloca %File, align 8
   %error_var2 = alloca i64, align 8
   %blockret3 = alloca i32, align 4
-  %x7 = alloca ptr, align 8
+  %x7 = alloca %"char[]", align 8
   %retparam8 = alloca i64, align 8
   %result9 = alloca %File, align 8
   %reterr = alloca i64, align 8
@@ -164,12 +173,15 @@ and.phi:                                          ; preds = %entry
   br label %if.exit
 
 if.exit:                                          ; preds = %and.phi
-  store ptr @.str.7, ptr %x, align 8
+  store %"char[]" { ptr @.str.7, i64 9 }, ptr %x, align 8
   %6 = call ptr @std.io.stdout()
   store ptr %6, ptr %result, align 8
   %7 = load ptr, ptr %result, align 8
-  %8 = load ptr, ptr %x, align 8
-  %9 = call i64 @std.io.File.printn(ptr %retparam1, ptr %7, ptr %8, i64 9)
+  %8 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
+  %lo = load ptr, ptr %8, align 8
+  %9 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
+  %hi = load i64, ptr %9, align 8
+  %10 = call i64 @std.io.File.printn(ptr %retparam1, ptr %7, ptr %lo, i64 %hi)
   store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var2, align 8
   br label %opt_block_cleanup4
 
@@ -178,16 +190,19 @@ opt_block_cleanup4:                               ; preds = %if.exit
   br label %guard_block5
 
 guard_block5:                                     ; preds = %opt_block_cleanup4
-  %10 = load i64, ptr %error_var2, align 8
-  ret i64 %10
+  %11 = load i64, ptr %error_var2, align 8
+  ret i64 %11
 
 if.exit6:                                         ; No predecessors!
-  store ptr @.str.8, ptr %x7, align 8
-  %11 = call ptr @std.io.stdout()
-  store ptr %11, ptr %result9, align 8
-  %12 = load ptr, ptr %result9, align 8
-  %13 = load ptr, ptr %x7, align 8
-  %14 = call i64 @std.io.File.printn(ptr %retparam8, ptr %12, ptr %13, i64 7)
+  store %"char[]" { ptr @.str.8, i64 7 }, ptr %x7, align 8
+  %12 = call ptr @std.io.stdout()
+  store ptr %12, ptr %result9, align 8
+  %13 = load ptr, ptr %result9, align 8
+  %14 = getelementptr inbounds %"char[]", ptr %x7, i32 0, i32 0
+  %lo10 = load ptr, ptr %14, align 8
+  %15 = getelementptr inbounds %"char[]", ptr %x7, i32 0, i32 1
+  %hi11 = load i64, ptr %15, align 8
+  %16 = call i64 @std.io.File.printn(ptr %retparam8, ptr %13, ptr %lo10, i64 %hi11)
   ret i64 0
 }
 
diff --git a/test/test_suite/errors/printing_errors.c3t b/test/test_suite/errors/printing_errors.c3t
index aa3b4cdc9..86da78b8a 100644
--- a/test/test_suite/errors/printing_errors.c3t
+++ b/test/test_suite/errors/printing_errors.c3t
@@ -20,12 +20,12 @@ entry:
   %x = alloca i64, align 8
   %retparam = alloca i64, align 8
   %varargslots = alloca [2 x %variant], align 16
-  %taddr = alloca ptr, align 8
+  %taddr = alloca %"char[]", align 8
   %faultname_zero = alloca %"char[]", align 8
   store i64 ptrtoint (ptr @"test.Cde$WORLD" to i64), ptr %x, align 8
-  store ptr @.str.2, ptr %taddr, align 8
+  store %"char[]" { ptr @.str.2, i64 5 }, ptr %taddr, align 8
   %0 = insertvalue %variant undef, ptr %taddr, 0
-  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
+  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
   %2 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %1, ptr %2, align 16
   %3 = load i64, ptr %x, align 8
@@ -50,3 +50,27 @@ faultname_exit:                                   ; preds = %faultname_ok, %faul
   %9 = call i64 @std.io.printf(ptr %retparam, ptr @.str, i64 6, ptr %varargslots, i64 2)
   ret void
 }
+
+; Function Attrs: nounwind
+define i32 @main(i32 %0, ptr %1) #0 {
+entry:
+  %.anon = alloca i32, align 4
+  %.anon1 = alloca ptr, align 8
+  store i32 %0, ptr %.anon, align 4
+  store ptr %1, ptr %.anon1, align 8
+  call void @test.main()
+  ret i32 0
+}
+
+; Function Attrs: nounwind
+declare i64 @std.io.printf(ptr, ptr, i64, ptr, i64) #0
+
+; Function Attrs: argmemonly nocallback nofree nounwind willreturn writeonly
+declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #1
+
+; Function Attrs: nocallback nofree nosync nounwind readnone willreturn
+declare i1 @llvm.expect.i1(i1, i1) #2
+
+attributes #0 = { nounwind }
+attributes #1 = { argmemonly nocallback nofree nounwind willreturn writeonly }
+attributes #2 = { nocallback nofree nosync nounwind readnone willreturn }
\ No newline at end of file
diff --git a/test/test_suite/from_docs/examples_defer.c3t b/test/test_suite/from_docs/examples_defer.c3t
index fc7845a37..9e737b0b2 100644
--- a/test/test_suite/from_docs/examples_defer.c3t
+++ b/test/test_suite/from_docs/examples_defer.c3t
@@ -29,67 +29,97 @@ entry:
   br i1 %eq, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %entry
-  store ptr @.str, ptr %x, align 8
+  store %"char[]" { ptr @.str, i64 1 }, ptr %x, align 8
   %1 = call ptr @std.io.stdout()
   store ptr %1, ptr %result, align 8
   %2 = load ptr, ptr %result, align 8
-  %3 = load ptr, ptr %x, align 8
-  %4 = call i64 @std.io.File.print(ptr %retparam, ptr %2, ptr %3, i64 1)
-  store ptr @.str.1, ptr %x1, align 8
-  %5 = call ptr @std.io.stdout()
-  store ptr %5, ptr %result3, align 8
-  %6 = load ptr, ptr %result3, align 8
-  %7 = call i64 @std.io.File.printn(ptr %retparam2, ptr %6, ptr null, i64 0)
+  %3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
+  %lo = load ptr, ptr %3, align 8
+  %4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
+  %hi = load i64, ptr %4, align 8
+  %5 = call i64 @std.io.File.print(ptr %retparam, ptr %2, ptr %lo, i64 %hi)
+  store %"char[]" zeroinitializer, ptr %x1, align 8
+  %6 = call ptr @std.io.stdout()
+  store ptr %6, ptr %result3, align 8
+  %7 = load ptr, ptr %result3, align 8
+  %8 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 0
+  %lo4 = load ptr, ptr %8, align 8
+  %9 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 1
+  %hi5 = load i64, ptr %9, align 8
+  %10 = call i64 @std.io.File.printn(ptr %retparam2, ptr %7, ptr %lo4, i64 %hi5)
   ret void
 
 if.exit:                                          ; preds = %entry
-  %eq4 = icmp eq i32 %0, 0
-  br i1 %eq4, label %if.then5, label %if.exit15
+  %eq6 = icmp eq i32 %0, 0
+  br i1 %eq6, label %if.then7, label %if.exit23
 
-if.then5:                                         ; preds = %if.exit
-  store ptr @.str.2, ptr %x6, align 8
-  %8 = call ptr @std.io.stdout()
-  store ptr %8, ptr %result8, align 8
-  %9 = load ptr, ptr %result8, align 8
-  %10 = load ptr, ptr %x6, align 8
-  %11 = call i64 @std.io.File.print(ptr %retparam7, ptr %9, ptr %10, i64 1)
-  store ptr @.str.3, ptr %x9, align 8
-  %12 = call ptr @std.io.stdout()
-  store ptr %12, ptr %result11, align 8
-  %13 = load ptr, ptr %result11, align 8
-  %14 = load ptr, ptr %x9, align 8
-  %15 = call i64 @std.io.File.print(ptr %retparam10, ptr %13, ptr %14, i64 1)
-  store ptr @.str.4, ptr %x12, align 8
+if.then7:                                         ; preds = %if.exit
+  store %"char[]" { ptr @.str.1, i64 1 }, ptr %x8, align 8
+  %11 = call ptr @std.io.stdout()
+  store ptr %11, ptr %result10, align 8
+  %12 = load ptr, ptr %result10, align 8
+  %13 = getelementptr inbounds %"char[]", ptr %x8, i32 0, i32 0
+  %lo11 = load ptr, ptr %13, align 8
+  %14 = getelementptr inbounds %"char[]", ptr %x8, i32 0, i32 1
+  %hi12 = load i64, ptr %14, align 8
+  %15 = call i64 @std.io.File.print(ptr %retparam9, ptr %12, ptr %lo11, i64 %hi12)
+  store %"char[]" { ptr @.str.2, i64 1 }, ptr %x13, align 8
   %16 = call ptr @std.io.stdout()
-  store ptr %16, ptr %result14, align 8
-  %17 = load ptr, ptr %result14, align 8
-  %18 = call i64 @std.io.File.printn(ptr %retparam13, ptr %17, ptr null, i64 0)
+  store ptr %16, ptr %result15, align 8
+  %17 = load ptr, ptr %result15, align 8
+  %18 = getelementptr inbounds %"char[]", ptr %x13, i32 0, i32 0
+  %lo16 = load ptr, ptr %18, align 8
+  %19 = getelementptr inbounds %"char[]", ptr %x13, i32 0, i32 1
+  %hi17 = load i64, ptr %19, align 8
+  %20 = call i64 @std.io.File.print(ptr %retparam14, ptr %17, ptr %lo16, i64 %hi17)
+  store %"char[]" zeroinitializer, ptr %x18, align 8
+  %21 = call ptr @std.io.stdout()
+  store ptr %21, ptr %result20, align 8
+  %22 = load ptr, ptr %result20, align 8
+  %23 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 0
+  %lo21 = load ptr, ptr %23, align 8
+  %24 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 1
+  %hi22 = load i64, ptr %24, align 8
+  %25 = call i64 @std.io.File.printn(ptr %retparam19, ptr %22, ptr %lo21, i64 %hi22)
   ret void
 
-if.exit15:                                        ; preds = %if.exit
-  store ptr @.str.5, ptr %x16, align 8
-  %19 = call ptr @std.io.stdout()
-  store ptr %19, ptr %result18, align 8
-  %20 = load ptr, ptr %result18, align 8
-  %21 = load ptr, ptr %x16, align 8
-  %22 = call i64 @std.io.File.print(ptr %retparam17, ptr %20, ptr %21, i64 1)
-  store ptr @.str.6, ptr %x19, align 8
-  %23 = call ptr @std.io.stdout()
-  store ptr %23, ptr %result21, align 8
-  %24 = load ptr, ptr %result21, align 8
-  %25 = load ptr, ptr %x19, align 8
-  %26 = call i64 @std.io.File.print(ptr %retparam20, ptr %24, ptr %25, i64 1)
-  store ptr @.str.7, ptr %x22, align 8
-  %27 = call ptr @std.io.stdout()
-  store ptr %27, ptr %result24, align 8
-  %28 = load ptr, ptr %result24, align 8
-  %29 = load ptr, ptr %x22, align 8
-  %30 = call i64 @std.io.File.print(ptr %retparam23, ptr %28, ptr %29, i64 1)
-  store ptr @.str.8, ptr %x25, align 8
+if.exit23:                                        ; preds = %if.exit
+  store %"char[]" { ptr @.str.3, i64 1 }, ptr %x24, align 8
+  %26 = call ptr @std.io.stdout()
+  store ptr %26, ptr %result26, align 8
+  %27 = load ptr, ptr %result26, align 8
+  %28 = getelementptr inbounds %"char[]", ptr %x24, i32 0, i32 0
+  %lo27 = load ptr, ptr %28, align 8
+  %29 = getelementptr inbounds %"char[]", ptr %x24, i32 0, i32 1
+  %hi28 = load i64, ptr %29, align 8
+  %30 = call i64 @std.io.File.print(ptr %retparam25, ptr %27, ptr %lo27, i64 %hi28)
+  store %"char[]" { ptr @.str.4, i64 1 }, ptr %x29, align 8
   %31 = call ptr @std.io.stdout()
-  store ptr %31, ptr %result27, align 8
-  %32 = load ptr, ptr %result27, align 8
-  %33 = call i64 @std.io.File.printn(ptr %retparam26, ptr %32, ptr null, i64 0)
+  store ptr %31, ptr %result31, align 8
+  %32 = load ptr, ptr %result31, align 8
+  %33 = getelementptr inbounds %"char[]", ptr %x29, i32 0, i32 0
+  %lo32 = load ptr, ptr %33, align 8
+  %34 = getelementptr inbounds %"char[]", ptr %x29, i32 0, i32 1
+  %hi33 = load i64, ptr %34, align 8
+  %35 = call i64 @std.io.File.print(ptr %retparam30, ptr %32, ptr %lo32, i64 %hi33)
+  store %"char[]" { ptr @.str.5, i64 1 }, ptr %x34, align 8
+  %36 = call ptr @std.io.stdout()
+  store ptr %36, ptr %result36, align 8
+  %37 = load ptr, ptr %result36, align 8
+  %38 = getelementptr inbounds %"char[]", ptr %x34, i32 0, i32 0
+  %lo37 = load ptr, ptr %38, align 8
+  %39 = getelementptr inbounds %"char[]", ptr %x34, i32 0, i32 1
+  %hi38 = load i64, ptr %39, align 8
+  %40 = call i64 @std.io.File.print(ptr %retparam35, ptr %37, ptr %lo37, i64 %hi38)
+  store %"char[]" zeroinitializer, ptr %x39, align 8
+  %41 = call ptr @std.io.stdout()
+  store ptr %41, ptr %result41, align 8
+  %42 = load ptr, ptr %result41, align 8
+  %43 = getelementptr inbounds %"char[]", ptr %x39, i32 0, i32 0
+  %lo42 = load ptr, ptr %43, align 8
+  %44 = getelementptr inbounds %"char[]", ptr %x39, i32 0, i32 1
+  %hi43 = load i64, ptr %44, align 8
+  %45 = call i64 @std.io.File.printn(ptr %retparam40, ptr %42, ptr %lo42, i64 %hi43)
   ret void
 }
 
diff --git a/test/test_suite/from_docs/examples_forswitch.c3t b/test/test_suite/from_docs/examples_forswitch.c3t
index 7c13c1a83..8f2c60731 100644
--- a/test/test_suite/from_docs/examples_forswitch.c3t
+++ b/test/test_suite/from_docs/examples_forswitch.c3t
@@ -121,36 +121,36 @@ unreachable_block:                                ; No predecessors!
 define void @examples.demo_enum(i32 %0) #0 {
 entry:
   %switch = alloca i32, align 4
-  %x = alloca ptr, align 8
+  %x = alloca %"char[]", align 8
   %retparam = alloca i64, align 8
   %result = alloca %File, align 8
-  %x2 = alloca ptr, align 8
+  %x2 = alloca %"char[]", align 8
   %retparam3 = alloca i64, align 8
   %result4 = alloca %File, align 8
-  %switch5 = alloca i32, align 4
-  %x8 = alloca ptr, align 8
-  %retparam9 = alloca i64, align 8
-  %result10 = alloca %File, align 8
-  %x12 = alloca ptr, align 8
-  %retparam13 = alloca i64, align 8
-  %result14 = alloca %File, align 8
-  %switch16 = alloca i32, align 4
-  %x20 = alloca ptr, align 8
-  %retparam21 = alloca i64, align 8
-  %result22 = alloca %File, align 8
-  %switch25 = alloca i32, align 4
-  %switch29 = alloca i32, align 4
+  %switch7 = alloca i32, align 4
+  %x10 = alloca %"char[]", align 8
+  %retparam11 = alloca i64, align 8
+  %result12 = alloca %File, align 8
+  %x16 = alloca %"char[]", align 8
+  %retparam17 = alloca i64, align 8
+  %result18 = alloca %File, align 8
+  %switch22 = alloca i32, align 4
+  %x26 = alloca %"char[]", align 8
+  %retparam27 = alloca i64, align 8
+  %result28 = alloca %File, align 8
+  %switch33 = alloca i32, align 4
+  %switch37 = alloca i32, align 4
   %a = alloca i32, align 4
-  %x32 = alloca ptr, align 8
-  %retparam33 = alloca i64, align 8
-  %result34 = alloca %File, align 8
-  %a36 = alloca i32, align 4
-  %x37 = alloca ptr, align 8
-  %retparam38 = alloca i64, align 8
-  %result39 = alloca %File, align 8
-  %x41 = alloca ptr, align 8
-  %retparam42 = alloca i64, align 8
-  %result43 = alloca %File, align 8
+  %x40 = alloca %"char[]", align 8
+  %retparam41 = alloca i64, align 8
+  %result42 = alloca %File, align 8
+  %a46 = alloca i32, align 4
+  %x47 = alloca %"char[]", align 8
+  %retparam48 = alloca i64, align 8
+  %result49 = alloca %File, align 8
+  %x53 = alloca %"char[]", align 8
+  %retparam54 = alloca i64, align 8
+  %result55 = alloca %File, align 8
   store i32 %0, ptr %switch, align 4
   br label %switch.entry
 
@@ -163,139 +163,163 @@ switch.entry:                                     ; preds = %entry
   ]
 
 switch.case:                                      ; preds = %switch.entry, %switch.entry
-  store ptr @.str.1, ptr %x, align 8
+  store %"char[]" { ptr @.str.1, i64 8 }, ptr %x, align 8
   %2 = call ptr @std.io.stdout()
   store ptr %2, ptr %result, align 8
   %3 = load ptr, ptr %result, align 8
-  %4 = load ptr, ptr %x, align 8
-  %5 = call i64 @std.io.File.printn(ptr %retparam, ptr %3, ptr %4, i64 8)
+  %4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
+  %lo = load ptr, ptr %4, align 8
+  %5 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
+  %hi = load i64, ptr %5, align 8
+  %6 = call i64 @std.io.File.printn(ptr %retparam, ptr %3, ptr %lo, i64 %hi)
   br label %switch.exit
 
 switch.case1:                                     ; preds = %switch.entry
-  store ptr @.str.2, ptr %x2, align 8
-  %6 = call ptr @std.io.stdout()
-  store ptr %6, ptr %result4, align 8
-  %7 = load ptr, ptr %result4, align 8
-  %8 = load ptr, ptr %x2, align 8
-  %9 = call i64 @std.io.File.printn(ptr %retparam3, ptr %7, ptr %8, i64 4)
+  store %"char[]" { ptr @.str.2, i64 4 }, ptr %x2, align 8
+  %7 = call ptr @std.io.stdout()
+  store ptr %7, ptr %result4, align 8
+  %8 = load ptr, ptr %result4, align 8
+  %9 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 0
+  %lo5 = load ptr, ptr %9, align 8
+  %10 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 1
+  %hi6 = load i64, ptr %10, align 8
+  %11 = call i64 @std.io.File.printn(ptr %retparam3, ptr %8, ptr %lo5, i64 %hi6)
   br label %switch.exit
 
 switch.exit:                                      ; preds = %switch.case1, %switch.case, %switch.entry
-  store i32 %0, ptr %switch5, align 4
-  br label %switch.entry6
+  store i32 %0, ptr %switch7, align 4
+  br label %switch.entry8
 
-switch.entry6:                                    ; preds = %switch.exit
-  %10 = load i32, ptr %switch5, align 4
-  switch i32 %10, label %switch.exit15 [
-    i32 0, label %switch.case7
-    i32 1, label %switch.case7
-    i32 2, label %switch.case11
+switch.entry8:                                    ; preds = %switch.exit
+  %12 = load i32, ptr %switch7, align 4
+  switch i32 %12, label %switch.exit21 [
+    i32 0, label %switch.case9
+    i32 1, label %switch.case9
+    i32 2, label %switch.case15
   ]
 
-switch.case7:                                     ; preds = %switch.entry6, %switch.entry6
-  store ptr @.str.3, ptr %x8, align 8
-  %11 = call ptr @std.io.stdout()
-  store ptr %11, ptr %result10, align 8
-  %12 = load ptr, ptr %result10, align 8
-  %13 = load ptr, ptr %x8, align 8
-  %14 = call i64 @std.io.File.printn(ptr %retparam9, ptr %12, ptr %13, i64 8)
-  br label %switch.exit15
+switch.case9:                                     ; preds = %switch.entry8, %switch.entry8
+  store %"char[]" { ptr @.str.3, i64 8 }, ptr %x10, align 8
+  %13 = call ptr @std.io.stdout()
+  store ptr %13, ptr %result12, align 8
+  %14 = load ptr, ptr %result12, align 8
+  %15 = getelementptr inbounds %"char[]", ptr %x10, i32 0, i32 0
+  %lo13 = load ptr, ptr %15, align 8
+  %16 = getelementptr inbounds %"char[]", ptr %x10, i32 0, i32 1
+  %hi14 = load i64, ptr %16, align 8
+  %17 = call i64 @std.io.File.printn(ptr %retparam11, ptr %14, ptr %lo13, i64 %hi14)
+  br label %switch.exit21
 
-switch.case11:                                    ; preds = %switch.entry6
-  store ptr @.str.4, ptr %x12, align 8
-  %15 = call ptr @std.io.stdout()
-  store ptr %15, ptr %result14, align 8
-  %16 = load ptr, ptr %result14, align 8
-  %17 = load ptr, ptr %x12, align 8
-  %18 = call i64 @std.io.File.printn(ptr %retparam13, ptr %16, ptr %17, i64 4)
-  br label %switch.exit15
+switch.case15:                                    ; preds = %switch.entry8
+  store %"char[]" { ptr @.str.4, i64 4 }, ptr %x16, align 8
+  %18 = call ptr @std.io.stdout()
+  store ptr %18, ptr %result18, align 8
+  %19 = load ptr, ptr %result18, align 8
+  %20 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 0
+  %lo19 = load ptr, ptr %20, align 8
+  %21 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 1
+  %hi20 = load i64, ptr %21, align 8
+  %22 = call i64 @std.io.File.printn(ptr %retparam17, ptr %19, ptr %lo19, i64 %hi20)
+  br label %switch.exit21
 
-switch.exit15:                                    ; preds = %switch.case11, %switch.case7, %switch.entry6
-  store i32 %0, ptr %switch16, align 4
-  br label %switch.entry17
+switch.exit21:                                    ; preds = %switch.case15, %switch.case9, %switch.entry8
+  store i32 %0, ptr %switch22, align 4
+  br label %switch.entry23
 
-switch.entry17:                                   ; preds = %switch.exit15
-  %19 = load i32, ptr %switch16, align 4
-  switch i32 %19, label %switch.exit24 [
-    i32 0, label %switch.case18
-    i32 1, label %switch.case19
-    i32 2, label %switch.case23
+switch.entry23:                                   ; preds = %switch.exit21
+  %23 = load i32, ptr %switch22, align 4
+  switch i32 %23, label %switch.exit32 [
+    i32 0, label %switch.case24
+    i32 1, label %switch.case25
+    i32 2, label %switch.case31
   ]
 
-switch.case18:                                    ; preds = %switch.entry17
-  br label %switch.exit24
+switch.case24:                                    ; preds = %switch.entry23
+  br label %switch.exit32
 
-switch.case19:                                    ; preds = %switch.entry17
-  store ptr @.str.5, ptr %x20, align 8
-  %20 = call ptr @std.io.stdout()
-  store ptr %20, ptr %result22, align 8
-  %21 = load ptr, ptr %result22, align 8
-  %22 = load ptr, ptr %x20, align 8
-  %23 = call i64 @std.io.File.printn(ptr %retparam21, ptr %21, ptr %22, i64 6)
-  br label %switch.exit24
+switch.case25:                                    ; preds = %switch.entry23
+  store %"char[]" { ptr @.str.5, i64 6 }, ptr %x26, align 8
+  %24 = call ptr @std.io.stdout()
+  store ptr %24, ptr %result28, align 8
+  %25 = load ptr, ptr %result28, align 8
+  %26 = getelementptr inbounds %"char[]", ptr %x26, i32 0, i32 0
+  %lo29 = load ptr, ptr %26, align 8
+  %27 = getelementptr inbounds %"char[]", ptr %x26, i32 0, i32 1
+  %hi30 = load i64, ptr %27, align 8
+  %28 = call i64 @std.io.File.printn(ptr %retparam27, ptr %25, ptr %lo29, i64 %hi30)
+  br label %switch.exit32
 
-switch.case23:                                    ; preds = %switch.entry17
-  br label %switch.exit24
+switch.case31:                                    ; preds = %switch.entry23
+  br label %switch.exit32
 
-switch.exit24:                                    ; preds = %switch.case23, %switch.case19, %switch.case18, %switch.entry17
-  store i32 %0, ptr %switch25, align 4
-  br label %switch.entry26
+switch.exit32:                                    ; preds = %switch.case31, %switch.case25, %switch.case24, %switch.entry23
+  store i32 %0, ptr %switch33, align 4
+  br label %switch.entry34
 
-switch.entry26:                                   ; preds = %switch.exit24
-  %24 = load i32, ptr %switch25, align 4
-  switch i32 %24, label %switch.default [
-    i32 0, label %switch.case27
-    i32 1, label %switch.case27
-    i32 2, label %switch.case27
-  ]
-
-switch.case27:                                    ; preds = %switch.entry26, %switch.entry26, %switch.entry26
-  br label %switch.exit28
-
-switch.default:                                   ; preds = %switch.entry26
-  br label %switch.exit28
-
-switch.exit28:                                    ; preds = %switch.default, %switch.case27
-  store i32 %0, ptr %switch29, align 4
-  br label %switch.entry30
-
-switch.entry30:                                   ; preds = %switch.exit28
-  %25 = load i32, ptr %switch29, align 4
-  switch i32 %25, label %switch.exit44 [
-    i32 0, label %switch.case31
+switch.entry34:                                   ; preds = %switch.exit32
+  %29 = load i32, ptr %switch33, align 4
+  switch i32 %29, label %switch.default [
+    i32 0, label %switch.case35
     i32 1, label %switch.case35
-    i32 2, label %switch.case40
+    i32 2, label %switch.case35
   ]
 
-switch.case31:                                    ; preds = %switch.entry30
+switch.case35:                                    ; preds = %switch.entry34, %switch.entry34, %switch.entry34
+  br label %switch.exit36
+
+switch.default:                                   ; preds = %switch.entry34
+  br label %switch.exit36
+
+switch.exit36:                                    ; preds = %switch.default, %switch.case35
+  store i32 %0, ptr %switch37, align 4
+  br label %switch.entry38
+
+switch.entry38:                                   ; preds = %switch.exit36
+  %30 = load i32, ptr %switch37, align 4
+  switch i32 %30, label %switch.exit58 [
+    i32 0, label %switch.case39
+    i32 1, label %switch.case45
+    i32 2, label %switch.case52
+  ]
+
+switch.case39:                                    ; preds = %switch.entry38
   store i32 1, ptr %a, align 4
-  store ptr @.str.6, ptr %x32, align 8
-  %26 = call ptr @std.io.stdout()
-  store ptr %26, ptr %result34, align 8
-  %27 = load ptr, ptr %result34, align 8
-  %28 = load ptr, ptr %x32, align 8
-  %29 = call i64 @std.io.File.printn(ptr %retparam33, ptr %27, ptr %28, i64 1)
-  br label %switch.case35
+  store %"char[]" { ptr @.str.6, i64 1 }, ptr %x40, align 8
+  %31 = call ptr @std.io.stdout()
+  store ptr %31, ptr %result42, align 8
+  %32 = load ptr, ptr %result42, align 8
+  %33 = getelementptr inbounds %"char[]", ptr %x40, i32 0, i32 0
+  %lo43 = load ptr, ptr %33, align 8
+  %34 = getelementptr inbounds %"char[]", ptr %x40, i32 0, i32 1
+  %hi44 = load i64, ptr %34, align 8
+  %35 = call i64 @std.io.File.printn(ptr %retparam41, ptr %32, ptr %lo43, i64 %hi44)
+  br label %switch.case45
 
-switch.case35:                                    ; preds = %switch.entry30, %switch.case31
-  store i32 2, ptr %a36, align 4
-  store ptr @.str.7, ptr %x37, align 8
-  %30 = call ptr @std.io.stdout()
-  store ptr %30, ptr %result39, align 8
-  %31 = load ptr, ptr %result39, align 8
-  %32 = load ptr, ptr %x37, align 8
-  %33 = call i64 @std.io.File.printn(ptr %retparam38, ptr %31, ptr %32, i64 1)
-  br label %switch.case40
+switch.case45:                                    ; preds = %switch.entry38, %switch.case39
+  store i32 2, ptr %a46, align 4
+  store %"char[]" { ptr @.str.7, i64 1 }, ptr %x47, align 8
+  %36 = call ptr @std.io.stdout()
+  store ptr %36, ptr %result49, align 8
+  %37 = load ptr, ptr %result49, align 8
+  %38 = getelementptr inbounds %"char[]", ptr %x47, i32 0, i32 0
+  %lo50 = load ptr, ptr %38, align 8
+  %39 = getelementptr inbounds %"char[]", ptr %x47, i32 0, i32 1
+  %hi51 = load i64, ptr %39, align 8
+  %40 = call i64 @std.io.File.printn(ptr %retparam48, ptr %37, ptr %lo50, i64 %hi51)
+  br label %switch.case52
 
-switch.case40:                                    ; preds = %switch.entry30, %switch.case35
-  store ptr @.str.8, ptr %x41, align 8
-  %34 = call ptr @std.io.stdout()
-  store ptr %34, ptr %result43, align 8
-  %35 = load ptr, ptr %result43, align 8
-  %36 = load ptr, ptr %x41, align 8
-  %37 = call i64 @std.io.File.printn(ptr %retparam42, ptr %35, ptr %36, i64 1)
-  br label %switch.exit44
+switch.case52:                                    ; preds = %switch.entry38, %switch.case45
+  store %"char[]" { ptr @.str.8, i64 1 }, ptr %x53, align 8
+  %41 = call ptr @std.io.stdout()
+  store ptr %41, ptr %result55, align 8
+  %42 = load ptr, ptr %result55, align 8
+  %43 = getelementptr inbounds %"char[]", ptr %x53, i32 0, i32 0
+  %lo56 = load ptr, ptr %43, align 8
+  %44 = getelementptr inbounds %"char[]", ptr %x53, i32 0, i32 1
+  %hi57 = load i64, ptr %44, align 8
+  %45 = call i64 @std.io.File.printn(ptr %retparam54, ptr %42, ptr %lo56, i64 %hi57)
+  br label %switch.exit58
 
-switch.exit44:                                    ; preds = %switch.case40, %switch.entry30
+switch.exit58:                                    ; preds = %switch.case52, %switch.entry38
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/functions/func_ptr_conversions_and_names.c3t b/test/test_suite/functions/func_ptr_conversions_and_names.c3t
index 29851c094..7f6b0d33d 100644
--- a/test/test_suite/functions/func_ptr_conversions_and_names.c3t
+++ b/test/test_suite/functions/func_ptr_conversions_and_names.c3t
@@ -38,20 +38,15 @@ fn void main()
 @.str.3 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
 @.str.4 = private unnamed_addr constant [13 x i8] c"fn int(int)*\00", align 1
 @"$ct.char" = linkonce constant %.introspect { i8 3, i64 1, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"$ct.a12$char" = linkonce constant %.introspect { i8 15, i64 12, i64 ptrtoint (ptr @"$ct.char" to i64), i64 12, [0 x i64] zeroinitializer }, align 8
-@"$ct.p$a12$char" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"$ct.a12$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.sa$char" = linkonce constant %.introspect { i8 16, i64 16, i64 ptrtoint (ptr @"$ct.char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
 @.str.5 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
 @.str.6 = private unnamed_addr constant [13 x i8] c"fn int(int)*\00", align 1
 @.str.7 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
 @.str.8 = private unnamed_addr constant [13 x i8] c"test::test2*\00", align 1
 @.str.9 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
 @.str.10 = private unnamed_addr constant [7 x i8] c"test2*\00", align 1
-@"$ct.a6$char" = linkonce constant %.introspect { i8 15, i64 6, i64 ptrtoint (ptr @"$ct.char" to i64), i64 6, [0 x i64] zeroinitializer }, align 8
-@"$ct.p$a6$char" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"$ct.a6$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
 @.str.11 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
 @.str.12 = private unnamed_addr constant [14 x i8] c"fn int!(int)*\00", align 1
-@"$ct.a13$char" = linkonce constant %.introspect { i8 15, i64 13, i64 ptrtoint (ptr @"$ct.char" to i64), i64 13, [0 x i64] zeroinitializer }, align 8
-@"$ct.p$a13$char" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"$ct.a13$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
 @"$ct.fn$int$int$" = linkonce constant %.introspect { i8 13, i64 8, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
 @"$ct.p$fn$int$int$" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"$ct.fn$int$int$" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
 
@@ -71,19 +66,19 @@ entry:
   %taddr6 = alloca i32, align 4
   %retparam7 = alloca i64, align 8
   %varargslots8 = alloca [1 x %variant], align 16
-  %taddr9 = alloca ptr, align 8
+  %taddr9 = alloca %"char[]", align 8
   %retparam10 = alloca i64, align 8
   %varargslots11 = alloca [1 x %variant], align 16
-  %taddr12 = alloca ptr, align 8
+  %taddr12 = alloca %"char[]", align 8
   %retparam13 = alloca i64, align 8
   %varargslots14 = alloca [1 x %variant], align 16
-  %taddr15 = alloca ptr, align 8
+  %taddr15 = alloca %"char[]", align 8
   %retparam16 = alloca i64, align 8
   %varargslots17 = alloca [1 x %variant], align 16
-  %taddr18 = alloca ptr, align 8
+  %taddr18 = alloca %"char[]", align 8
   %retparam19 = alloca i64, align 8
   %varargslots20 = alloca [1 x %variant], align 16
-  %taddr21 = alloca ptr, align 8
+  %taddr21 = alloca %"char[]", align 8
   %y = alloca ptr, align 8
   %zfoke = alloca i64, align 8
   store ptr @test.test, ptr %a, align 8
@@ -112,33 +107,33 @@ entry:
   %15 = getelementptr inbounds [1 x %variant], ptr %varargslots5, i64 0, i64 0
   store %variant %14, ptr %15, align 16
   %16 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.2, i64 2, ptr %varargslots5, i64 1)
-  store ptr @.str.4, ptr %taddr9, align 8
+  store %"char[]" { ptr @.str.4, i64 12 }, ptr %taddr9, align 8
   %17 = insertvalue %variant undef, ptr %taddr9, 0
-  %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"$ct.p$a12$char" to i64), 1
+  %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
   %19 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
   store %variant %18, ptr %19, align 16
   %20 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.3, i64 2, ptr %varargslots8, i64 1)
-  store ptr @.str.6, ptr %taddr12, align 8
+  store %"char[]" { ptr @.str.6, i64 12 }, ptr %taddr12, align 8
   %21 = insertvalue %variant undef, ptr %taddr12, 0
-  %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"$ct.p$a12$char" to i64), 1
+  %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
   %23 = getelementptr inbounds [1 x %variant], ptr %varargslots11, i64 0, i64 0
   store %variant %22, ptr %23, align 16
   %24 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.5, i64 2, ptr %varargslots11, i64 1)
-  store ptr @.str.8, ptr %taddr15, align 8
+  store %"char[]" { ptr @.str.8, i64 12 }, ptr %taddr15, align 8
   %25 = insertvalue %variant undef, ptr %taddr15, 0
-  %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"$ct.p$a12$char" to i64), 1
+  %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
   %27 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0
   store %variant %26, ptr %27, align 16
   %28 = call i64 @std.io.printfn(ptr %retparam13, ptr @.str.7, i64 2, ptr %varargslots14, i64 1)
-  store ptr @.str.10, ptr %taddr18, align 8
+  store %"char[]" { ptr @.str.10, i64 6 }, ptr %taddr18, align 8
   %29 = insertvalue %variant undef, ptr %taddr18, 0
-  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.p$a6$char" to i64), 1
+  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
   %31 = getelementptr inbounds [1 x %variant], ptr %varargslots17, i64 0, i64 0
   store %variant %30, ptr %31, align 16
   %32 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.9, i64 2, ptr %varargslots17, i64 1)
-  store ptr @.str.12, ptr %taddr21, align 8
+  store %"char[]" { ptr @.str.12, i64 13 }, ptr %taddr21, align 8
   %33 = insertvalue %variant undef, ptr %taddr21, 0
-  %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.p$a13$char" to i64), 1
+  %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
   %35 = getelementptr inbounds [1 x %variant], ptr %varargslots20, i64 0, i64 0
   store %variant %34, ptr %35, align 16
   %36 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.11, i64 2, ptr %varargslots20, i64 1)
diff --git a/test/test_suite/initializer_lists/subarrays.c3t b/test/test_suite/initializer_lists/subarrays.c3t
index 6c54c6de0..b3bc1869b 100644
--- a/test/test_suite/initializer_lists/subarrays.c3t
+++ b/test/test_suite/initializer_lists/subarrays.c3t
@@ -48,7 +48,10 @@ fn int main()
 %Bar = type { i32, i32 }
 %"Bar[]" = type { ptr, i64 }
 %"int[]" = type { ptr, i64 }
+%"char[]" = type { ptr, i64 }
+%File = type { ptr }
 %Baz = type { double }
+
 @"$ct.subarrays.Baz" = linkonce constant %.introspect { i8 11, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
 @"$ct.subarrays.Bar" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
 @.taddr = private global [2 x %Bar] [%Bar { i32 3, i32 4 }, %Bar { i32 8, i32 9 }], align 8
@@ -72,14 +75,14 @@ entry:
   %literal = alloca [3 x i32], align 4
   %y = alloca ptr, align 8
   %literal2 = alloca [3 x i32], align 4
-  %x3 = alloca ptr, align 8
+  %x3 = alloca %"char[]", align 8
   %retparam = alloca i64, align 8
   %result = alloca %File, align 8
   %ffe = alloca %Baz, align 8
   %azz = alloca [1 x i32], align 4
   %xy = alloca i8, align 1
   %literal7 = alloca [3 x i32], align 4
-  %x9 = alloca ptr, align 8
+  %x9 = alloca %"char[]", align 8
   %retparam10 = alloca i64, align 8
   %result11 = alloca %File, align 8
   %b = alloca %Bar, align 4
@@ -111,62 +114,68 @@ entry:
   %12 = getelementptr inbounds [3 x i32], ptr %literal2, i64 0, i64 2
   store i32 567, ptr %12, align 4
   store ptr %literal2, ptr %y, align 8
-  store ptr @.str.5, ptr %x3, align 8
+  store %"char[]" { ptr @.str.5, i64 6 }, ptr %x3, align 8
   %13 = call ptr @std.io.stdout()
   store ptr %13, ptr %result, align 8
   %14 = load ptr, ptr %result, align 8
-  %15 = load ptr, ptr %x3, align 8
-  %16 = call i64 @std.io.File.printn(ptr %retparam, ptr %14, ptr %15, i64 6)
-  %17 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1
-  %18 = load i64, ptr %17, align 8
-  %trunc = trunc i64 %18 to i32
-  %19 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0
-  %20 = load ptr, ptr %19, align 8
-  %ptroffset4 = getelementptr inbounds i32, ptr %20, i64 1
-  %21 = load i32, ptr %ptroffset4, align 4
-  %22 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %trunc, i32 %21)
-  %23 = load ptr, ptr %y, align 8
-  %ptroffset5 = getelementptr inbounds i32, ptr %23, i64 1
-  %24 = load i32, ptr %ptroffset5, align 4
-  %25 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %24)
-  %26 = load ptr, ptr @subarrays.fofeo, align 8
-  %ptroffset6 = getelementptr inbounds i32, ptr %26, i64 1
-  %27 = load i32, ptr %ptroffset6, align 4
-  %28 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %27)
+  %15 = getelementptr inbounds %"char[]", ptr %x3, i32 0, i32 0
+  %lo = load ptr, ptr %15, align 8
+  %16 = getelementptr inbounds %"char[]", ptr %x3, i32 0, i32 1
+  %hi = load i64, ptr %16, align 8
+  %17 = call i64 @std.io.File.printn(ptr %retparam, ptr %14, ptr %lo, i64 %hi)
+  %18 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1
+  %19 = load i64, ptr %18, align 8
+  %trunc = trunc i64 %19 to i32
+  %20 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0
+  %21 = load ptr, ptr %20, align 8
+  %ptroffset4 = getelementptr inbounds i32, ptr %21, i64 1
+  %22 = load i32, ptr %ptroffset4, align 4
+  %23 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %trunc, i32 %22)
+  %24 = load ptr, ptr %y, align 8
+  %ptroffset5 = getelementptr inbounds i32, ptr %24, i64 1
+  %25 = load i32, ptr %ptroffset5, align 4
+  %26 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %25)
+  %27 = load ptr, ptr @subarrays.fofeo, align 8
+  %ptroffset6 = getelementptr inbounds i32, ptr %27, i64 1
+  %28 = load i32, ptr %ptroffset6, align 4
+  %29 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %28)
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %ffe, ptr align 8 @.__const, i32 8, i1 false)
-  %29 = getelementptr inbounds [1 x i32], ptr %azz, i64 0, i64 0
-  store i32 0, ptr %29, align 4
-  %30 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 0
-  store i32 1, ptr %30, align 4
-  %31 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 1
-  store i32 2, ptr %31, align 4
-  %32 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 2
-  store i32 3, ptr %32, align 4
-  %33 = insertvalue %"int[]" undef, ptr %literal7, 0
-  %34 = insertvalue %"int[]" %33, i64 3, 1
-  %35 = extractvalue %"int[]" %34, 1
-  %not = icmp eq i64 %35, 0
-  %36 = zext i1 %not to i8
-  store i8 %36, ptr %xy, align 1
-  %37 = load i8, ptr %xy, align 1
-  %38 = trunc i8 %37 to i1
-  %not8 = xor i1 %38, true
+  %30 = getelementptr inbounds [1 x i32], ptr %azz, i64 0, i64 0
+  store i32 0, ptr %30, align 4
+  %31 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 0
+  store i32 1, ptr %31, align 4
+  %32 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 1
+  store i32 2, ptr %32, align 4
+  %33 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 2
+  store i32 3, ptr %33, align 4
+  %34 = insertvalue %"int[]" undef, ptr %literal7, 0
+  %35 = insertvalue %"int[]" %34, i64 3, 1
+  %36 = extractvalue %"int[]" %35, 1
+  %not = icmp eq i64 %36, 0
+  %37 = zext i1 %not to i8
+  store i8 %37, ptr %xy, align 1
+  %38 = load i8, ptr %xy, align 1
+  %39 = trunc i8 %38 to i1
+  %not8 = xor i1 %39, true
   br i1 %not8, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %entry
-  store ptr @.str.9, ptr %x9, align 8
-  %39 = call ptr @std.io.stdout()
-  store ptr %39, ptr %result11, align 8
-  %40 = load ptr, ptr %result11, align 8
-  %41 = load ptr, ptr %x9, align 8
-  %42 = call i64 @std.io.File.printn(ptr %retparam10, ptr %40, ptr %41, i64 2)
+  store %"char[]" { ptr @.str.9, i64 2 }, ptr %x9, align 8
+  %40 = call ptr @std.io.stdout()
+  store ptr %40, ptr %result11, align 8
+  %41 = load ptr, ptr %result11, align 8
+  %42 = getelementptr inbounds %"char[]", ptr %x9, i32 0, i32 0
+  %lo12 = load ptr, ptr %42, align 8
+  %43 = getelementptr inbounds %"char[]", ptr %x9, i32 0, i32 1
+  %hi13 = load i64, ptr %43, align 8
+  %44 = call i64 @std.io.File.printn(ptr %retparam10, ptr %41, ptr %lo12, i64 %hi13)
   br label %if.exit
 
 if.exit:                                          ; preds = %if.then, %entry
-  %43 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 0
-  store i32 0, ptr %43, align 4
-  %44 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1
-  store i32 0, ptr %44, align 4
+  %45 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 0
+  store i32 0, ptr %45, align 4
+  %46 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1
+  store i32 0, ptr %46, align 4
   call void @llvm.memset.p0.i64(ptr align 8 %z, i8 0, i64 8, i1 false)
   store %"int[]" zeroinitializer, ptr %sub, align 8
   store %"Bar[]" zeroinitializer, ptr %foo, align 8
diff --git a/test/test_suite/macros/macro_untyped_varargs_2.c3t b/test/test_suite/macros/macro_untyped_varargs_2.c3t
index f2de6215c..613bf5476 100644
--- a/test/test_suite/macros/macro_untyped_varargs_2.c3t
+++ b/test/test_suite/macros/macro_untyped_varargs_2.c3t
@@ -93,11 +93,11 @@ entry:
   %x = alloca i32, align 4
   %retparam11 = alloca i64, align 8
   %varargslots12 = alloca [1 x %variant], align 16
-  %taddr = alloca ptr, align 8
+  %taddr = alloca %"char[]", align 8
   %x13 = alloca double, align 8
   %retparam14 = alloca i64, align 8
   %varargslots15 = alloca [1 x %variant], align 16
-  %taddr16 = alloca ptr, align 8
+  %taddr16 = alloca %"char[]", align 8
   %retparam17 = alloca i64, align 8
   %varargslots18 = alloca [1 x %variant], align 16
   %taddr19 = alloca i32, align 4
@@ -146,16 +146,16 @@ entry:
   store %variant %21, ptr %22, align 16
   %23 = call i64 @std.io.printfn(ptr %retparam9, ptr @.str.4, i64 2, ptr %varargslots10, i64 1)
   store i32 0, ptr %x, align 4
-  store ptr @.str.6, ptr %taddr, align 8
+  store %"char[]" { ptr @.str.6, i64 3 }, ptr %taddr, align 8
   %24 = insertvalue %variant undef, ptr %taddr, 0
-  %25 = insertvalue %variant %24, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
+  %25 = insertvalue %variant %24, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
   %26 = getelementptr inbounds [1 x %variant], ptr %varargslots12, i64 0, i64 0
   store %variant %25, ptr %26, align 16
   %27 = call i64 @std.io.printfn(ptr %retparam11, ptr @.str.5, i64 2, ptr %varargslots12, i64 1)
   store double 0.000000e+00, ptr %x13, align 8
-  store ptr @.str.8, ptr %taddr16, align 8
+  store %"char[]" { ptr @.str.8, i64 6 }, ptr %taddr16, align 8
   %28 = insertvalue %variant undef, ptr %taddr16, 0
-  %29 = insertvalue %variant %28, i64 ptrtoint (ptr @"$ct.p$a6$char" to i64), 1
+  %29 = insertvalue %variant %28, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
   %30 = getelementptr inbounds [1 x %variant], ptr %varargslots15, i64 0, i64 0
   store %variant %29, ptr %30, align 16
   %31 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.7, i64 2, ptr %varargslots15, i64 1)
diff --git a/test/test_suite/methods/enum_distinct_err_methods.c3t b/test/test_suite/methods/enum_distinct_err_methods.c3t
index 81b5db541..c8d1022c4 100644
--- a/test/test_suite/methods/enum_distinct_err_methods.c3t
+++ b/test/test_suite/methods/enum_distinct_err_methods.c3t
@@ -43,20 +43,62 @@ fn int main()
 
 /* #expect: foo.ll
 
+
 define void @foo.Foo.hello(ptr %0) #0 {
 entry:
-  store ptr @.str, ptr %x, align 8
+  %x = alloca %"char[]", align 8
+  %x1 = alloca %"char[]", align 8
+  %retparam = alloca i64, align 8
+  %result = alloca %File, align 8
+  store %"char[]" { ptr @.str, i64 14 }, ptr %x, align 8
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %x1, ptr align 8 %x, i32 16, i1 false)
+  %1 = call ptr @std.io.stdout()
+  store ptr %1, ptr %result, align 8
+  %2 = load ptr, ptr %result, align 8
+  %3 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 0
+  %lo = load ptr, ptr %3, align 8
+  %4 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 1
+  %hi = load i64, ptr %4, align 8
+  %5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi)
   ret void
 }
 
 define void @foo.Bar.hello(ptr %0) #0 {
 entry:
-  store ptr @.str.1, ptr %x, align 8
+  %x = alloca %"char[]", align 8
+  %x1 = alloca %"char[]", align 8
+  %retparam = alloca i64, align 8
+  %result = alloca %File, align 8
+  store %"char[]" { ptr @.str.1, i64 14 }, ptr %x, align 8
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %x1, ptr align 8 %x, i32 16, i1 false)
+  %1 = call ptr @std.io.stdout()
+  store ptr %1, ptr %result, align 8
+  %2 = load ptr, ptr %result, align 8
+  %3 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 0
+  %lo = load ptr, ptr %3, align 8
+  %4 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 1
+  %hi = load i64, ptr %4, align 8
+  %5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi)
+  ret void
 }
 
 define void @foo.MyEnum.hello(ptr %0) #0 {
 entry:
-  store ptr @.str.2, ptr %x, align 8
+  %x = alloca %"char[]", align 8
+  %x1 = alloca %"char[]", align 8
+  %retparam = alloca i64, align 8
+  %result = alloca %File, align 8
+  store %"char[]" { ptr @.str.2, i64 17 }, ptr %x, align 8
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %x1, ptr align 8 %x, i32 16, i1 false)
+  %1 = call ptr @std.io.stdout()
+  store ptr %1, ptr %result, align 8
+  %2 = load ptr, ptr %result, align 8
+  %3 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 0
+  %lo = load ptr, ptr %3, align 8
+  %4 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 1
+  %hi = load i64, ptr %4, align 8
+  %5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi)
+  ret void
 }
 
 define i32 @main() #0 {
diff --git a/test/test_suite/symbols/various.c3 b/test/test_suite/symbols/various.c3
index ec81a4e8a..0432a215a 100644
--- a/test/test_suite/symbols/various.c3
+++ b/test/test_suite/symbols/various.c3
@@ -125,7 +125,7 @@ fn void test16()
 
 fn void test17()
 {
-    int a = "test";             // #error: 'char[4]*' to 'int'
+    int a = "test";             // #error: 'char[]' to 'int'
 }
 
 fn void test18()