diff --git a/src/compiler/llvm_codegen_stmt.c b/src/compiler/llvm_codegen_stmt.c
index ef6797b34..3a692f08f 100644
--- a/src/compiler/llvm_codegen_stmt.c
+++ b/src/compiler/llvm_codegen_stmt.c
@@ -1218,6 +1218,60 @@ static inline void llvm_emit_asm_block_stmt(GenContext *c, Ast *ast)
 	}
 }
 
+// Prune the common occurrence where the optional is not used.
+static void llvm_prune_optional(GenContext *c, LLVMBasicBlockRef discard_fail)
+{
+	// Replace discard with the current block,
+	// this removes the jump in the case:
+	// br i1 %not_err, label %after_check, label %voiderr
+	//after_check:
+	// br label %voiderr
+	//voiderr:
+	// <insert point>
+	LLVMValueRef block_value = LLVMBasicBlockAsValue(c->current_block);
+	LLVMReplaceAllUsesWith(LLVMBasicBlockAsValue(discard_fail), block_value);
+
+	// We now have:
+	// br i1 %not_err, label %after_check, label %after_check
+	//after_check:
+	// <insert point>
+
+	// Find the use of this block.
+	LLVMUseRef use = LLVMGetFirstUse(block_value);
+	if (!use) return;
+
+	LLVMValueRef maybe_br = LLVMGetUser(use);
+	// Expect a br instruction.
+	if (!LLVMIsAInstruction(maybe_br) || LLVMGetInstructionOpcode(maybe_br) != LLVMBr) return;
+	if (LLVMGetNumOperands(maybe_br) != 3) return;
+	// We expect a single user.
+	LLVMUseRef other_use = LLVMGetNextUse(use);
+	while (other_use)
+	{
+		if (LLVMGetUser(other_use) != maybe_br) return;
+		other_use = LLVMGetNextUse(other_use);
+	}
+	// Both operands same block value
+	if (LLVMGetOperand(maybe_br, 1) != block_value || LLVMGetOperand(maybe_br, 2) != block_value) return;
+
+	// Grab the compared value
+	LLVMValueRef compared = LLVMGetOperand(maybe_br, 0);
+
+	// Remove the block and the br
+	LLVMBasicBlockRef prev_block = LLVMGetInstructionParent(maybe_br);
+	LLVMRemoveBasicBlockFromParent(c->current_block);
+	LLVMInstructionEraseFromParent(maybe_br);
+
+	// Optionally remove the comparison
+	if (!LLVMGetFirstUse(compared))
+	{
+		LLVMInstructionEraseFromParent(compared);
+	}
+	// Update the context
+	c->current_block = prev_block;
+	c->current_block_is_target = LLVMGetFirstBasicBlock(c->function) == prev_block;
+	LLVMPositionBuilderAtEnd(c->builder, prev_block);
+}
 
 static void llvm_emit_expr_stmt(GenContext *c, Ast *ast)
 {
@@ -1234,11 +1288,19 @@ static void llvm_emit_expr_stmt(GenContext *c, Ast *ast)
 		LLVMBasicBlockRef discard_fail = llvm_basic_block_new(c, "voiderr");
 		c->catch_block = discard_fail;
 		c->opt_var = NULL;
-		llvm_emit_expr(c, &value, ast->expr_stmt);
+		llvm_emit_expr(c, &value, e);
 		llvm_value_fold_optional(c, &value);
 		EMIT_LOC(c, ast);
-		llvm_emit_br(c, discard_fail);
-		llvm_emit_block(c, discard_fail);
+		// We only optimize if there is no instruction the current block
+		if (!LLVMGetFirstInstruction(c->current_block))
+		{
+			llvm_prune_optional(c, discard_fail);
+		}
+		else
+		{
+			llvm_emit_br(c, discard_fail);
+			llvm_emit_block(c, discard_fail);
+		}
 		POP_OPT();
 		return;
 	}
diff --git a/src/version.h b/src/version.h
index 69a60ef28..942cd4fd2 100644
--- a/src/version.h
+++ b/src/version.h
@@ -1 +1 @@
-#define COMPILER_VERSION "0.4.43"
\ No newline at end of file
+#define COMPILER_VERSION "0.4.44"
\ No newline at end of file
diff --git a/test/test_suite/bitstruct/bitstruct_be.c3t b/test/test_suite/bitstruct/bitstruct_be.c3t
index a23ff0ca2..8224b9455 100644
--- a/test/test_suite/bitstruct/bitstruct_be.c3t
+++ b/test/test_suite/bitstruct/bitstruct_be.c3t
@@ -58,13 +58,6 @@ fn void main()
   %9 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %8, ptr %9, align 16
   %10 = call i64 @std_io_printf(ptr %retparam, ptr @.str, i64 18, ptr %varargslots, i64 2)
-  %not_err = icmp eq i64 %10, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   store i32 873625686, ptr %abc, align 4
   store [4 x i8] c"\124Vx", ptr %abc2, align 1
   store ptr %abc, ptr %z, align 8
@@ -74,7 +67,7 @@ voiderr:                                          ; preds = %after_check, %entry
   store i64 0, ptr %.anon1, align 8
   br label %loop.cond
 
-loop.cond:                                        ; preds = %voiderr6, %voiderr
+loop.cond:                                        ; preds = %loop.body, %entry
   %12 = load i64, ptr %.anon1, align 8
   %gt = icmp ugt i64 4, %12
   br i1 %gt, label %loop.body, label %loop.exit
@@ -90,108 +83,57 @@ loop.body:                                        ; preds = %loop.cond
   %19 = getelementptr inbounds [1 x %variant], ptr %varargslots3, i64 0, i64 0
   store %variant %18, ptr %19, align 16
   %20 = call i64 @std_io_printf(ptr %retparam2, ptr @.str.1, i64 3, ptr %varargslots3, i64 1)
-  %not_err4 = icmp eq i64 %20, 0
-  br i1 %not_err4, label %after_check5, label %voiderr6
-
-after_check5:                                     ; preds = %loop.body
-  br label %voiderr6
-
-voiderr6:                                         ; preds = %after_check5, %loop.body
   %21 = load i64, ptr %.anon1, align 8
   %add = add i64 %21, 1
   store i64 %add, ptr %.anon1, align 8
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
-  store ptr @.str.2, ptr %x7, align 8
-  store i64 0, ptr %error_var, align 8
+  store ptr @.str.2, ptr %x4, align 8
   %22 = call ptr @std_io_stdout()
   store ptr %22, ptr %result, align 8
-  %23 = call i64 @std_io_File_printn(ptr %retparam8, ptr %result, ptr null, i64 0)
-  %not_err9 = icmp eq i64 %23, 0
-  br i1 %not_err9, label %after_check10, label %assign_optional
-
-assign_optional:                                  ; preds = %loop.exit
-  store i64 %23, ptr %error_var, align 8
-  br label %noerr_block
-
-after_check10:                                    ; preds = %loop.exit
-  br label %noerr_block
-
-noerr_block:                                      ; preds = %after_check10, %assign_optional
-  br label %voiderr11
-
-voiderr11:                                        ; preds = %noerr_block
+  %23 = call i64 @std_io_File_printn(ptr %retparam5, ptr %result, ptr null, i64 0)
   %24 = load ptr, ptr %z, align 8
-  store ptr %24, ptr %.anon12, align 8
-  store i64 0, ptr %.anon13, align 8
-  br label %loop.cond14
+  store ptr %24, ptr %.anon6, align 8
+  store i64 0, ptr %.anon7, align 8
+  br label %loop.cond8
 
-loop.cond14:                                      ; preds = %voiderr22, %voiderr11
-  %25 = load i64, ptr %.anon13, align 8
-  %gt15 = icmp ugt i64 4, %25
-  br i1 %gt15, label %loop.body16, label %loop.exit24
+loop.cond8:                                       ; preds = %loop.body10, %loop.exit
+  %25 = load i64, ptr %.anon7, align 8
+  %gt9 = icmp ugt i64 4, %25
+  br i1 %gt9, label %loop.body10, label %loop.exit15
 
-loop.body16:                                      ; preds = %loop.cond14
-  %26 = load ptr, ptr %.anon12, align 8
-  %27 = load i64, ptr %.anon13, align 8
+loop.body10:                                      ; preds = %loop.cond8
+  %26 = load ptr, ptr %.anon6, align 8
+  %27 = load i64, ptr %.anon7, align 8
   %28 = getelementptr inbounds [4 x i8], ptr %26, i64 0, i64 %27
   %29 = load i8, ptr %28, align 1
-  store i8 %29, ptr %d17, align 1
-  %30 = insertvalue %variant undef, ptr %d17, 0
+  store i8 %29, ptr %d11, align 1
+  %30 = insertvalue %variant undef, ptr %d11, 0
   %31 = insertvalue %variant %30, i64 ptrtoint (ptr @"ct$char" to i64), 1
-  %32 = getelementptr inbounds [1 x %variant], ptr %varargslots19, i64 0, i64 0
+  %32 = getelementptr inbounds [1 x %variant], ptr %varargslots13, i64 0, i64 0
   store %variant %31, ptr %32, align 16
-  %33 = call i64 @std_io_printf(ptr %retparam18, ptr @.str.3, i64 3, ptr %varargslots19, i64 1)
-  %not_err20 = icmp eq i64 %33, 0
-  br i1 %not_err20, label %after_check21, label %voiderr22
+  %33 = call i64 @std_io_printf(ptr %retparam12, ptr @.str.3, i64 3, ptr %varargslots13, i64 1)
+  %34 = load i64, ptr %.anon7, align 8
+  %add14 = add i64 %34, 1
+  store i64 %add14, ptr %.anon7, align 8
+  br label %loop.cond8
 
-after_check21:                                    ; preds = %loop.body16
-  br label %voiderr22
-
-voiderr22:                                        ; preds = %after_check21, %loop.body16
-  %34 = load i64, ptr %.anon13, align 8
-  %add23 = add i64 %34, 1
-  store i64 %add23, ptr %.anon13, align 8
-  br label %loop.cond14
-
-loop.exit24:                                      ; preds = %loop.cond14
-  store ptr @.str.4, ptr %x25, align 8
-  store i64 0, ptr %error_var26, align 8
+loop.exit15:                                      ; preds = %loop.cond8
+  store ptr @.str.4, ptr %x16, align 8
   %35 = call ptr @std_io_stdout()
-  store ptr %35, ptr %result28, align 8
-  %36 = call i64 @std_io_File_printn(ptr %retparam27, ptr %result28, ptr null, i64 0)
-  %not_err29 = icmp eq i64 %36, 0
-  br i1 %not_err29, label %after_check31, label %assign_optional30
-
-assign_optional30:                                ; preds = %loop.exit24
-  store i64 %36, ptr %error_var26, align 8
-  br label %noerr_block32
-
-after_check31:                                    ; preds = %loop.exit24
-  br label %noerr_block32
-
-noerr_block32:                                    ; preds = %after_check31, %assign_optional30
-  br label %voiderr33
-
-voiderr33:                                        ; preds = %noerr_block32
+  store ptr %35, ptr %result18, align 8
+  %36 = call i64 @std_io_File_printn(ptr %retparam17, ptr %result18, ptr null, i64 0)
   %37 = load i32, ptr %abc, align 4
   %38 = call i32 @llvm.bswap.i32(i32 %37)
   %39 = and i32 65535, %38
   %ztrunc = trunc i32 %39 to i16
-  store i16 %ztrunc, ptr %taddr36, align 2
-  %40 = insertvalue %variant undef, ptr %taddr36, 0
+  store i16 %ztrunc, ptr %taddr21, align 2
+  %40 = insertvalue %variant undef, ptr %taddr21, 0
   %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
-  %42 = getelementptr inbounds [1 x %variant], ptr %varargslots35, i64 0, i64 0
+  %42 = getelementptr inbounds [1 x %variant], ptr %varargslots20, i64 0, i64 0
   store %variant %41, ptr %42, align 16
-  %43 = call i64 @std_io_printfn(ptr %retparam34, ptr @.str.5, i64 10, ptr %varargslots35, i64 1)
-  %not_err37 = icmp eq i64 %43, 0
-  br i1 %not_err37, label %after_check38, label %voiderr39
-
-after_check38:                                    ; preds = %voiderr33
-  br label %voiderr39
-
-voiderr39:                                        ; preds = %after_check38, %voiderr33
+  %43 = call i64 @std_io_printfn(ptr %retparam19, ptr @.str.5, i64 10, ptr %varargslots20, i64 1)
   %44 = load i32, ptr %abc, align 4
   %45 = call i32 @llvm.bswap.i32(i32 %44)
   %46 = and i32 %45, -65536
@@ -207,93 +149,57 @@ voiderr39:                                        ; preds = %after_check38, %voi
   %54 = load i32, ptr %abc, align 4
   %55 = call i32 @llvm.bswap.i32(i32 %54)
   %56 = and i32 65535, %55
-  %ztrunc42 = trunc i32 %56 to i16
-  store i16 %ztrunc42, ptr %taddr43, align 2
-  %57 = insertvalue %variant undef, ptr %taddr43, 0
+  %ztrunc24 = trunc i32 %56 to i16
+  store i16 %ztrunc24, ptr %taddr25, align 2
+  %57 = insertvalue %variant undef, ptr %taddr25, 0
   %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
-  %59 = getelementptr inbounds [1 x %variant], ptr %varargslots41, i64 0, i64 0
+  %59 = getelementptr inbounds [1 x %variant], ptr %varargslots23, i64 0, i64 0
   store %variant %58, ptr %59, align 16
-  %60 = call i64 @std_io_printfn(ptr %retparam40, ptr @.str.6, i64 12, ptr %varargslots41, i64 1)
-  %not_err44 = icmp eq i64 %60, 0
-  br i1 %not_err44, label %after_check45, label %voiderr46
-
-after_check45:                                    ; preds = %voiderr39
-  br label %voiderr46
-
-voiderr46:                                        ; preds = %after_check45, %voiderr39
+  %60 = call i64 @std_io_printfn(ptr %retparam22, ptr @.str.6, i64 12, ptr %varargslots23, i64 1)
   %61 = load ptr, ptr %z, align 8
-  store ptr %61, ptr %.anon47, align 8
-  store i64 0, ptr %.anon48, align 8
-  br label %loop.cond49
+  store ptr %61, ptr %.anon26, align 8
+  store i64 0, ptr %.anon27, align 8
+  br label %loop.cond28
 
-loop.cond49:                                      ; preds = %voiderr57, %voiderr46
-  %62 = load i64, ptr %.anon48, align 8
-  %gt50 = icmp ugt i64 4, %62
-  br i1 %gt50, label %loop.body51, label %loop.exit59
+loop.cond28:                                      ; preds = %loop.body30, %loop.exit15
+  %62 = load i64, ptr %.anon27, align 8
+  %gt29 = icmp ugt i64 4, %62
+  br i1 %gt29, label %loop.body30, label %loop.exit35
 
-loop.body51:                                      ; preds = %loop.cond49
-  %63 = load ptr, ptr %.anon47, align 8
-  %64 = load i64, ptr %.anon48, align 8
+loop.body30:                                      ; preds = %loop.cond28
+  %63 = load ptr, ptr %.anon26, align 8
+  %64 = load i64, ptr %.anon27, align 8
   %65 = getelementptr inbounds [4 x i8], ptr %63, i64 0, i64 %64
   %66 = load i8, ptr %65, align 1
-  store i8 %66, ptr %d52, align 1
-  %67 = insertvalue %variant undef, ptr %d52, 0
+  store i8 %66, ptr %d31, align 1
+  %67 = insertvalue %variant undef, ptr %d31, 0
   %68 = insertvalue %variant %67, i64 ptrtoint (ptr @"ct$char" to i64), 1
-  %69 = getelementptr inbounds [1 x %variant], ptr %varargslots54, i64 0, i64 0
+  %69 = getelementptr inbounds [1 x %variant], ptr %varargslots33, i64 0, i64 0
   store %variant %68, ptr %69, align 16
-  %70 = call i64 @std_io_printf(ptr %retparam53, ptr @.str.7, i64 3, ptr %varargslots54, i64 1)
-  %not_err55 = icmp eq i64 %70, 0
-  br i1 %not_err55, label %after_check56, label %voiderr57
+  %70 = call i64 @std_io_printf(ptr %retparam32, ptr @.str.7, i64 3, ptr %varargslots33, i64 1)
+  %71 = load i64, ptr %.anon27, align 8
+  %add34 = add i64 %71, 1
+  store i64 %add34, ptr %.anon27, align 8
+  br label %loop.cond28
 
-after_check56:                                    ; preds = %loop.body51
-  br label %voiderr57
-
-voiderr57:                                        ; preds = %after_check56, %loop.body51
-  %71 = load i64, ptr %.anon48, align 8
-  %add58 = add i64 %71, 1
-  store i64 %add58, ptr %.anon48, align 8
-  br label %loop.cond49
-
-loop.exit59:                                      ; preds = %loop.cond49
-  store ptr @.str.8, ptr %x60, align 8
-  store i64 0, ptr %error_var61, align 8
+loop.exit35:                                      ; preds = %loop.cond28
+  store ptr @.str.8, ptr %x36, align 8
   %72 = call ptr @std_io_stdout()
-  store ptr %72, ptr %result63, align 8
-  %73 = call i64 @std_io_File_printn(ptr %retparam62, ptr %result63, ptr null, i64 0)
-  %not_err64 = icmp eq i64 %73, 0
-  br i1 %not_err64, label %after_check66, label %assign_optional65
-
-assign_optional65:                                ; preds = %loop.exit59
-  store i64 %73, ptr %error_var61, align 8
-  br label %noerr_block67
-
-after_check66:                                    ; preds = %loop.exit59
-  br label %noerr_block67
-
-noerr_block67:                                    ; preds = %after_check66, %assign_optional65
-  br label %voiderr68
-
-voiderr68:                                        ; preds = %noerr_block67
+  store ptr %72, ptr %result38, align 8
+  %73 = call i64 @std_io_File_printn(ptr %retparam37, ptr %result38, ptr null, i64 0)
   store i32 0, ptr %y, align 4
   %74 = load i32, ptr %y, align 4
   store i32 123, ptr %y, align 4
   %75 = insertvalue %variant undef, ptr %y, 0
   %76 = insertvalue %variant %75, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %77 = getelementptr inbounds [2 x %variant], ptr %varargslots70, i64 0, i64 0
+  %77 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 0
   store %variant %76, ptr %77, align 16
   %78 = load i32, ptr %y, align 4
-  store i32 %78, ptr %taddr71, align 4
-  %79 = insertvalue %variant undef, ptr %taddr71, 0
+  store i32 %78, ptr %taddr41, align 4
+  %79 = insertvalue %variant undef, ptr %taddr41, 0
   %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %81 = getelementptr inbounds [2 x %variant], ptr %varargslots70, i64 0, i64 1
+  %81 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1
   store %variant %80, ptr %81, align 16
-  %82 = call i64 @std_io_printf(ptr %retparam69, ptr @.str.9, i64 18, ptr %varargslots70, i64 2)
-  %not_err72 = icmp eq i64 %82, 0
-  br i1 %not_err72, label %after_check73, label %voiderr74
-
-after_check73:                                    ; preds = %voiderr68
-  br label %voiderr74
-
-voiderr74:                                        ; preds = %after_check73, %voiderr68
+  %82 = call i64 @std_io_printf(ptr %retparam39, ptr @.str.9, i64 18, ptr %varargslots40, i64 2)
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/bitstruct/bitstruct_initializer.c3t b/test/test_suite/bitstruct/bitstruct_initializer.c3t
index 379a552ce..319600465 100644
--- a/test/test_suite/bitstruct/bitstruct_initializer.c3t
+++ b/test/test_suite/bitstruct/bitstruct_initializer.c3t
@@ -64,26 +64,26 @@ entry:
   %taddr20 = alloca i32, align 4
   %taddr23 = alloca i32, align 4
   %taddr26 = alloca i8, align 1
-  %retparam30 = alloca i64, align 8
-  %varargslots31 = alloca [3 x %variant], align 16
-  %taddr39 = alloca i32, align 4
-  %taddr47 = alloca i32, align 4
-  %taddr49 = alloca i8, align 1
-  %retparam67 = alloca i64, align 8
-  %varargslots68 = alloca [3 x %variant], align 16
-  %taddr70 = alloca i32, align 4
-  %taddr73 = alloca i32, align 4
-  %taddr76 = alloca i8, align 1
-  %retparam80 = alloca i64, align 8
-  %varargslots81 = alloca [3 x %variant], align 16
-  %taddr83 = alloca i32, align 4
-  %taddr86 = alloca i32, align 4
-  %taddr89 = alloca i8, align 1
-  %retparam93 = alloca i64, align 8
-  %varargslots94 = alloca [3 x %variant], align 16
-  %taddr102 = alloca i32, align 4
-  %taddr110 = alloca i32, align 4
-  %taddr112 = alloca i8, align 1
+  %retparam27 = alloca i64, align 8
+  %varargslots28 = alloca [3 x %variant], align 16
+  %taddr36 = alloca i32, align 4
+  %taddr44 = alloca i32, align 4
+  %taddr46 = alloca i8, align 1
+  %retparam61 = alloca i64, align 8
+  %varargslots62 = alloca [3 x %variant], align 16
+  %taddr64 = alloca i32, align 4
+  %taddr67 = alloca i32, align 4
+  %taddr70 = alloca i8, align 1
+  %retparam71 = alloca i64, align 8
+  %varargslots72 = alloca [3 x %variant], align 16
+  %taddr74 = alloca i32, align 4
+  %taddr77 = alloca i32, align 4
+  %taddr80 = alloca i8, align 1
+  %retparam81 = alloca i64, align 8
+  %varargslots82 = alloca [3 x %variant], align 16
+  %taddr90 = alloca i32, align 4
+  %taddr98 = alloca i32, align 4
+  %taddr100 = alloca i8, align 1
   store i64 0, ptr %x, align 8
   %zext = zext i32 %0 to i64
   %1 = and i64 %zext, 4294967295
@@ -180,13 +180,6 @@ entry:
   %45 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 2
   store %variant %44, ptr %45, align 16
   %46 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 3)
-  %not_err = icmp eq i64 %46, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   %47 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
   %48 = load i64, ptr %47, align 8
   %49 = and i64 4294967295, %48
@@ -217,88 +210,74 @@ voiderr:                                          ; preds = %after_check, %entry
   %64 = getelementptr inbounds [3 x %variant], ptr %varargslots18, i64 0, i64 2
   store %variant %63, ptr %64, align 16
   %65 = call i64 @std_io_printfn(ptr %retparam17, ptr @.str.2, i64 8, ptr %varargslots18, i64 3)
-  %not_err27 = icmp eq i64 %65, 0
-  br i1 %not_err27, label %after_check28, label %voiderr29
-
-after_check28:                                    ; preds = %voiderr
-  br label %voiderr29
-
-voiderr29:                                        ; preds = %after_check28, %voiderr
   %66 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
   %67 = load i8, ptr %66, align 1
-  %zext32 = zext i8 %67 to i32
+  %zext29 = zext i8 %67 to i32
   %68 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
   %69 = load i8, ptr %68, align 1
-  %zext33 = zext i8 %69 to i32
-  %shl34 = shl i32 %zext33, 8
-  %70 = or i32 %shl34, %zext32
+  %zext30 = zext i8 %69 to i32
+  %shl31 = shl i32 %zext30, 8
+  %70 = or i32 %shl31, %zext29
   %71 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
   %72 = load i8, ptr %71, align 1
-  %zext35 = zext i8 %72 to i32
-  %shl36 = shl i32 %zext35, 16
-  %73 = or i32 %shl36, %70
+  %zext32 = zext i8 %72 to i32
+  %shl33 = shl i32 %zext32, 16
+  %73 = or i32 %shl33, %70
   %74 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
   %75 = load i8, ptr %74, align 1
-  %zext37 = zext i8 %75 to i32
-  %shl38 = shl i32 %zext37, 24
-  %76 = or i32 %shl38, %73
-  store i32 %76, ptr %taddr39, align 4
-  %77 = insertvalue %variant undef, ptr %taddr39, 0
+  %zext34 = zext i8 %75 to i32
+  %shl35 = shl i32 %zext34, 24
+  %76 = or i32 %shl35, %73
+  store i32 %76, ptr %taddr36, align 4
+  %77 = insertvalue %variant undef, ptr %taddr36, 0
   %78 = insertvalue %variant %77, i64 ptrtoint (ptr @"ct$uint" to i64), 1
-  %79 = getelementptr inbounds [3 x %variant], ptr %varargslots31, i64 0, i64 0
+  %79 = getelementptr inbounds [3 x %variant], ptr %varargslots28, i64 0, i64 0
   store %variant %78, ptr %79, align 16
   %80 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
   %81 = load i8, ptr %80, align 1
-  %zext40 = zext i8 %81 to i32
+  %zext37 = zext i8 %81 to i32
   %82 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
   %83 = load i8, ptr %82, align 1
-  %zext41 = zext i8 %83 to i32
-  %shl42 = shl i32 %zext41, 8
-  %84 = or i32 %shl42, %zext40
+  %zext38 = zext i8 %83 to i32
+  %shl39 = shl i32 %zext38, 8
+  %84 = or i32 %shl39, %zext37
   %85 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6
   %86 = load i8, ptr %85, align 1
-  %zext43 = zext i8 %86 to i32
-  %shl44 = shl i32 %zext43, 16
-  %87 = or i32 %shl44, %84
+  %zext40 = zext i8 %86 to i32
+  %shl41 = shl i32 %zext40, 16
+  %87 = or i32 %shl41, %84
   %88 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
   %89 = load i8, ptr %88, align 1
-  %zext45 = zext i8 %89 to i32
-  %shl46 = shl i32 %zext45, 24
-  %90 = or i32 %shl46, %87
+  %zext42 = zext i8 %89 to i32
+  %shl43 = shl i32 %zext42, 24
+  %90 = or i32 %shl43, %87
   %91 = and i32 2147483647, %90
-  store i32 %91, ptr %taddr47, align 4
-  %92 = insertvalue %variant undef, ptr %taddr47, 0
+  store i32 %91, ptr %taddr44, align 4
+  %92 = insertvalue %variant undef, ptr %taddr44, 0
   %93 = insertvalue %variant %92, i64 ptrtoint (ptr @"ct$uint" to i64), 1
-  %94 = getelementptr inbounds [3 x %variant], ptr %varargslots31, i64 0, i64 1
+  %94 = getelementptr inbounds [3 x %variant], ptr %varargslots28, i64 0, i64 1
   store %variant %93, ptr %94, align 16
   %95 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
   %96 = load i8, ptr %95, align 1
-  %lshrl48 = lshr i8 %96, 7
-  %97 = trunc i8 %lshrl48 to i1
+  %lshrl45 = lshr i8 %96, 7
+  %97 = trunc i8 %lshrl45 to i1
   %98 = zext i1 %97 to i8
-  store i8 %98, ptr %taddr49, align 1
-  %99 = insertvalue %variant undef, ptr %taddr49, 0
+  store i8 %98, ptr %taddr46, align 1
+  %99 = insertvalue %variant undef, ptr %taddr46, 0
   %100 = insertvalue %variant %99, i64 ptrtoint (ptr @"ct$bool" to i64), 1
-  %101 = getelementptr inbounds [3 x %variant], ptr %varargslots31, i64 0, i64 2
+  %101 = getelementptr inbounds [3 x %variant], ptr %varargslots28, i64 0, i64 2
   store %variant %100, ptr %101, align 16
-  %102 = call i64 @std_io_printfn(ptr %retparam30, ptr @.str.3, i64 8, ptr %varargslots31, i64 3)
-  %not_err50 = icmp eq i64 %102, 0
-  br i1 %not_err50, label %after_check51, label %voiderr52
-
-after_check51:                                    ; preds = %voiderr29
-  br label %voiderr52
-
-voiderr52:                                        ; preds = %after_check51, %voiderr29
+  %102 = call i64 @std_io_printfn(ptr %retparam27, ptr @.str.3, i64 8, ptr %varargslots28, i64 3)
   %add = add i32 %0, 1
-  %zext53 = zext i32 %add to i64
-  %103 = and i64 %zext53, 4294967295
+  %zext47 = zext i32 %add to i64
+  %103 = and i64 %zext47, 4294967295
   %104 = and i64 %103, -9223372032559808513
   %105 = or i64 %104, 4294967296
   %gt = icmp sgt i32 %0, 100
   %106 = zext i1 %gt to i8
-  %zext54 = zext i8 %106 to i64
-  %shl55 = shl i64 %zext54, 63
-  %107 = and i64 %shl55, -9223372036854775808
+  %zext48 = zext i8 %106 to i64
+  %shl49 = shl i64 %zext48, 63
+  %107 = and i64 %shl49, -9223372036854775808
   %108 = and i64 %105, 9223372036854775807
   %109 = or i64 %108, %107
   store i64 %109, ptr %x, align 8
@@ -320,23 +299,23 @@ voiderr52:                                        ; preds = %after_check51, %voi
   store i8 0, ptr %117, align 1
   %118 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
   store i8 0, ptr %118, align 1
-  %add56 = add i32 %0, 1
+  %add50 = add i32 %0, 1
   %119 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
-  %ztrunc57 = trunc i32 %add56 to i8
-  store i8 %ztrunc57, ptr %119, align 1
-  %lshrl58 = lshr i32 %add56, 8
+  %ztrunc51 = trunc i32 %add50 to i8
+  store i8 %ztrunc51, ptr %119, align 1
+  %lshrl52 = lshr i32 %add50, 8
   %120 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
-  %ztrunc59 = trunc i32 %lshrl58 to i8
-  store i8 %ztrunc59, ptr %120, align 1
-  %lshrl60 = lshr i32 %lshrl58, 8
+  %ztrunc53 = trunc i32 %lshrl52 to i8
+  store i8 %ztrunc53, ptr %120, align 1
+  %lshrl54 = lshr i32 %lshrl52, 8
   %121 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
-  %ztrunc61 = trunc i32 %lshrl60 to i8
-  store i8 %ztrunc61, ptr %121, align 1
-  %lshrl62 = lshr i32 %lshrl60, 8
+  %ztrunc55 = trunc i32 %lshrl54 to i8
+  store i8 %ztrunc55, ptr %121, align 1
+  %lshrl56 = lshr i32 %lshrl54, 8
   %122 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
-  %ztrunc63 = trunc i32 %lshrl62 to i8
-  store i8 %ztrunc63, ptr %122, align 1
-  %lshrl64 = lshr i32 %lshrl62, 8
+  %ztrunc57 = trunc i32 %lshrl56 to i8
+  store i8 %ztrunc57, ptr %122, align 1
+  %lshrl58 = lshr i32 %lshrl56, 8
   %123 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
   store i8 1, ptr %123, align 1
   %124 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
@@ -347,150 +326,129 @@ voiderr52:                                        ; preds = %after_check51, %voi
   %127 = load i8, ptr %126, align 1
   %128 = and i8 %127, -128
   store i8 %128, ptr %126, align 1
-  %gt65 = icmp sgt i32 %0, 100
-  %129 = zext i1 %gt65 to i8
-  %shl66 = shl i8 %129, 7
+  %gt59 = icmp sgt i32 %0, 100
+  %129 = zext i1 %gt59 to i8
+  %shl60 = shl i8 %129, 7
   %130 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
   %131 = load i8, ptr %130, align 1
   %132 = and i8 %131, 127
-  %133 = or i8 %132, %shl66
+  %133 = or i8 %132, %shl60
   store i8 %133, ptr %130, align 1
   %134 = load i64, ptr %x, align 8
   %135 = and i64 4294967295, %134
-  %ztrunc69 = trunc i64 %135 to i32
-  store i32 %ztrunc69, ptr %taddr70, align 4
-  %136 = insertvalue %variant undef, ptr %taddr70, 0
+  %ztrunc63 = trunc i64 %135 to i32
+  store i32 %ztrunc63, ptr %taddr64, align 4
+  %136 = insertvalue %variant undef, ptr %taddr64, 0
   %137 = insertvalue %variant %136, i64 ptrtoint (ptr @"ct$uint" to i64), 1
-  %138 = getelementptr inbounds [3 x %variant], ptr %varargslots68, i64 0, i64 0
+  %138 = getelementptr inbounds [3 x %variant], ptr %varargslots62, i64 0, i64 0
   store %variant %137, ptr %138, align 16
   %139 = load i64, ptr %x, align 8
-  %lshrl71 = lshr i64 %139, 32
-  %140 = and i64 2147483647, %lshrl71
-  %ztrunc72 = trunc i64 %140 to i32
-  store i32 %ztrunc72, ptr %taddr73, align 4
-  %141 = insertvalue %variant undef, ptr %taddr73, 0
+  %lshrl65 = lshr i64 %139, 32
+  %140 = and i64 2147483647, %lshrl65
+  %ztrunc66 = trunc i64 %140 to i32
+  store i32 %ztrunc66, ptr %taddr67, align 4
+  %141 = insertvalue %variant undef, ptr %taddr67, 0
   %142 = insertvalue %variant %141, i64 ptrtoint (ptr @"ct$uint" to i64), 1
-  %143 = getelementptr inbounds [3 x %variant], ptr %varargslots68, i64 0, i64 1
+  %143 = getelementptr inbounds [3 x %variant], ptr %varargslots62, i64 0, i64 1
   store %variant %142, ptr %143, align 16
   %144 = load i64, ptr %x, align 8
-  %lshrl74 = lshr i64 %144, 63
-  %145 = and i64 1, %lshrl74
-  %ztrunc75 = trunc i64 %145 to i8
-  store i8 %ztrunc75, ptr %taddr76, align 1
-  %146 = insertvalue %variant undef, ptr %taddr76, 0
+  %lshrl68 = lshr i64 %144, 63
+  %145 = and i64 1, %lshrl68
+  %ztrunc69 = trunc i64 %145 to i8
+  store i8 %ztrunc69, ptr %taddr70, align 1
+  %146 = insertvalue %variant undef, ptr %taddr70, 0
   %147 = insertvalue %variant %146, i64 ptrtoint (ptr @"ct$bool" to i64), 1
-  %148 = getelementptr inbounds [3 x %variant], ptr %varargslots68, i64 0, i64 2
+  %148 = getelementptr inbounds [3 x %variant], ptr %varargslots62, i64 0, i64 2
   store %variant %147, ptr %148, align 16
-  %149 = call i64 @std_io_printfn(ptr %retparam67, ptr @.str.4, i64 8, ptr %varargslots68, i64 3)
-  %not_err77 = icmp eq i64 %149, 0
-  br i1 %not_err77, label %after_check78, label %voiderr79
-
-after_check78:                                    ; preds = %voiderr52
-  br label %voiderr79
-
-voiderr79:                                        ; preds = %after_check78, %voiderr52
+  %149 = call i64 @std_io_printfn(ptr %retparam61, ptr @.str.4, i64 8, ptr %varargslots62, i64 3)
   %150 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
   %151 = load i64, ptr %150, align 8
   %152 = and i64 4294967295, %151
-  %ztrunc82 = trunc i64 %152 to i32
-  store i32 %ztrunc82, ptr %taddr83, align 4
-  %153 = insertvalue %variant undef, ptr %taddr83, 0
+  %ztrunc73 = trunc i64 %152 to i32
+  store i32 %ztrunc73, ptr %taddr74, align 4
+  %153 = insertvalue %variant undef, ptr %taddr74, 0
   %154 = insertvalue %variant %153, i64 ptrtoint (ptr @"ct$uint" to i64), 1
-  %155 = getelementptr inbounds [3 x %variant], ptr %varargslots81, i64 0, i64 0
+  %155 = getelementptr inbounds [3 x %variant], ptr %varargslots72, i64 0, i64 0
   store %variant %154, ptr %155, align 16
   %156 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
   %157 = load i64, ptr %156, align 8
-  %lshrl84 = lshr i64 %157, 32
-  %158 = and i64 2147483647, %lshrl84
-  %ztrunc85 = trunc i64 %158 to i32
-  store i32 %ztrunc85, ptr %taddr86, align 4
-  %159 = insertvalue %variant undef, ptr %taddr86, 0
+  %lshrl75 = lshr i64 %157, 32
+  %158 = and i64 2147483647, %lshrl75
+  %ztrunc76 = trunc i64 %158 to i32
+  store i32 %ztrunc76, ptr %taddr77, align 4
+  %159 = insertvalue %variant undef, ptr %taddr77, 0
   %160 = insertvalue %variant %159, i64 ptrtoint (ptr @"ct$uint" to i64), 1
-  %161 = getelementptr inbounds [3 x %variant], ptr %varargslots81, i64 0, i64 1
+  %161 = getelementptr inbounds [3 x %variant], ptr %varargslots72, i64 0, i64 1
   store %variant %160, ptr %161, align 16
   %162 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
   %163 = load i64, ptr %162, align 8
-  %lshrl87 = lshr i64 %163, 63
-  %164 = and i64 1, %lshrl87
-  %ztrunc88 = trunc i64 %164 to i8
-  store i8 %ztrunc88, ptr %taddr89, align 1
-  %165 = insertvalue %variant undef, ptr %taddr89, 0
+  %lshrl78 = lshr i64 %163, 63
+  %164 = and i64 1, %lshrl78
+  %ztrunc79 = trunc i64 %164 to i8
+  store i8 %ztrunc79, ptr %taddr80, align 1
+  %165 = insertvalue %variant undef, ptr %taddr80, 0
   %166 = insertvalue %variant %165, i64 ptrtoint (ptr @"ct$bool" to i64), 1
-  %167 = getelementptr inbounds [3 x %variant], ptr %varargslots81, i64 0, i64 2
+  %167 = getelementptr inbounds [3 x %variant], ptr %varargslots72, i64 0, i64 2
   store %variant %166, ptr %167, align 16
-  %168 = call i64 @std_io_printfn(ptr %retparam80, ptr @.str.5, i64 8, ptr %varargslots81, i64 3)
-  %not_err90 = icmp eq i64 %168, 0
-  br i1 %not_err90, label %after_check91, label %voiderr92
-
-after_check91:                                    ; preds = %voiderr79
-  br label %voiderr92
-
-voiderr92:                                        ; preds = %after_check91, %voiderr79
+  %168 = call i64 @std_io_printfn(ptr %retparam71, ptr @.str.5, i64 8, ptr %varargslots72, i64 3)
   %169 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
   %170 = load i8, ptr %169, align 1
-  %zext95 = zext i8 %170 to i32
+  %zext83 = zext i8 %170 to i32
   %171 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
   %172 = load i8, ptr %171, align 1
-  %zext96 = zext i8 %172 to i32
-  %shl97 = shl i32 %zext96, 8
-  %173 = or i32 %shl97, %zext95
+  %zext84 = zext i8 %172 to i32
+  %shl85 = shl i32 %zext84, 8
+  %173 = or i32 %shl85, %zext83
   %174 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
   %175 = load i8, ptr %174, align 1
-  %zext98 = zext i8 %175 to i32
-  %shl99 = shl i32 %zext98, 16
-  %176 = or i32 %shl99, %173
+  %zext86 = zext i8 %175 to i32
+  %shl87 = shl i32 %zext86, 16
+  %176 = or i32 %shl87, %173
   %177 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
   %178 = load i8, ptr %177, align 1
-  %zext100 = zext i8 %178 to i32
-  %shl101 = shl i32 %zext100, 24
-  %179 = or i32 %shl101, %176
-  store i32 %179, ptr %taddr102, align 4
-  %180 = insertvalue %variant undef, ptr %taddr102, 0
+  %zext88 = zext i8 %178 to i32
+  %shl89 = shl i32 %zext88, 24
+  %179 = or i32 %shl89, %176
+  store i32 %179, ptr %taddr90, align 4
+  %180 = insertvalue %variant undef, ptr %taddr90, 0
   %181 = insertvalue %variant %180, i64 ptrtoint (ptr @"ct$uint" to i64), 1
-  %182 = getelementptr inbounds [3 x %variant], ptr %varargslots94, i64 0, i64 0
+  %182 = getelementptr inbounds [3 x %variant], ptr %varargslots82, i64 0, i64 0
   store %variant %181, ptr %182, align 16
   %183 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
   %184 = load i8, ptr %183, align 1
-  %zext103 = zext i8 %184 to i32
+  %zext91 = zext i8 %184 to i32
   %185 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
   %186 = load i8, ptr %185, align 1
-  %zext104 = zext i8 %186 to i32
-  %shl105 = shl i32 %zext104, 8
-  %187 = or i32 %shl105, %zext103
+  %zext92 = zext i8 %186 to i32
+  %shl93 = shl i32 %zext92, 8
+  %187 = or i32 %shl93, %zext91
   %188 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6
   %189 = load i8, ptr %188, align 1
-  %zext106 = zext i8 %189 to i32
-  %shl107 = shl i32 %zext106, 16
-  %190 = or i32 %shl107, %187
+  %zext94 = zext i8 %189 to i32
+  %shl95 = shl i32 %zext94, 16
+  %190 = or i32 %shl95, %187
   %191 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
   %192 = load i8, ptr %191, align 1
-  %zext108 = zext i8 %192 to i32
-  %shl109 = shl i32 %zext108, 24
-  %193 = or i32 %shl109, %190
+  %zext96 = zext i8 %192 to i32
+  %shl97 = shl i32 %zext96, 24
+  %193 = or i32 %shl97, %190
   %194 = and i32 2147483647, %193
-  store i32 %194, ptr %taddr110, align 4
-  %195 = insertvalue %variant undef, ptr %taddr110, 0
+  store i32 %194, ptr %taddr98, align 4
+  %195 = insertvalue %variant undef, ptr %taddr98, 0
   %196 = insertvalue %variant %195, i64 ptrtoint (ptr @"ct$uint" to i64), 1
-  %197 = getelementptr inbounds [3 x %variant], ptr %varargslots94, i64 0, i64 1
+  %197 = getelementptr inbounds [3 x %variant], ptr %varargslots82, i64 0, i64 1
   store %variant %196, ptr %197, align 16
   %198 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
   %199 = load i8, ptr %198, align 1
-  %lshrl111 = lshr i8 %199, 7
-  %200 = trunc i8 %lshrl111 to i1
+  %lshrl99 = lshr i8 %199, 7
+  %200 = trunc i8 %lshrl99 to i1
   %201 = zext i1 %200 to i8
-  store i8 %201, ptr %taddr112, align 1
-  %202 = insertvalue %variant undef, ptr %taddr112, 0
+  store i8 %201, ptr %taddr100, align 1
+  %202 = insertvalue %variant undef, ptr %taddr100, 0
   %203 = insertvalue %variant %202, i64 ptrtoint (ptr @"ct$bool" to i64), 1
-  %204 = getelementptr inbounds [3 x %variant], ptr %varargslots94, i64 0, i64 2
+  %204 = getelementptr inbounds [3 x %variant], ptr %varargslots82, i64 0, i64 2
   store %variant %203, ptr %204, align 16
-  %205 = call i64 @std_io_printfn(ptr %retparam93, ptr @.str.6, i64 8, ptr %varargslots94, i64 3)
-  %not_err113 = icmp eq i64 %205, 0
-  br i1 %not_err113, label %after_check114, label %voiderr115
-
-after_check114:                                   ; preds = %voiderr92
-  br label %voiderr115
-
-voiderr115:                                       ; preds = %after_check114, %voiderr92
+  %205 = call i64 @std_io_printfn(ptr %retparam81, ptr @.str.6, i64 8, ptr %varargslots82, i64 3)
   ret void
 }
 
diff --git a/test/test_suite/compile_time/compile_time_access_subscript.c3t b/test/test_suite/compile_time/compile_time_access_subscript.c3t
index e9438a947..a88a0eb44 100644
--- a/test/test_suite/compile_time/compile_time_access_subscript.c3t
+++ b/test/test_suite/compile_time/compile_time_access_subscript.c3t
@@ -44,67 +44,60 @@ fn void main()
 
 /* #expect: test.ll
 
-    %z = alloca i32, align 4
-    %z1 = alloca %Abc, align 4
-    %z2 = alloca i64, align 8
-    %z3 = alloca i32, align 4
-    %z4 = alloca ptr, align 8
-    %z5 = alloca i8, align 1
-    %z6 = alloca i64, align 8
-    %z7 = alloca <3 x i32>, align 16
-    %z8 = alloca %Abc, align 4
-    %z9 = alloca [2 x i32], align 4
-    %z10 = alloca %"int[]", align 8
-    %retparam = alloca i64, align 8
-    %varargslots = alloca [1 x %variant], align 16
-    %literal = alloca %Abc, align 4
-    store i32 0, ptr %z, align 4
-    %0 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 0
-    store float 0.000000e+00, ptr %0, align 4
-    %1 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 1
-    store float 0.000000e+00, ptr %1, align 4
-    %2 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 2
-    store float 0.000000e+00, ptr %2, align 4
-    %3 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 3
-    store float 0.000000e+00, ptr %3, align 4
-    store i64 0, ptr %z2, align 8
-    store i32 0, ptr %z3, align 4
-    store ptr null, ptr %z4, align 8
-    store i8 0, ptr %z5, align 1
-    store i64 0, ptr %z6, align 8
-    store <3 x i32> zeroinitializer, ptr %z7, align 16
-    %4 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 0
-    store float 0.000000e+00, ptr %4, align 4
-    %5 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 1
-    store float 0.000000e+00, ptr %5, align 4
-    %6 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 2
-    store float 0.000000e+00, ptr %6, align 4
-    %7 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 3
-    store float 0.000000e+00, ptr %7, align 4
-    %8 = getelementptr inbounds [2 x i32], ptr %z9, i64 0, i64 0
-    store i32 0, ptr %8, align 4
-    %9 = getelementptr inbounds [2 x i32], ptr %z9, i64 0, i64 1
-    store i32 0, ptr %9, align 4
-    call void @llvm.memset.p0.i64(ptr align 8 %z10, i8 0, i64 16, i1 false)
-    %10 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 0
-    store float 0.000000e+00, ptr %10, align 4
-    %11 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 1
-    store float 0.000000e+00, ptr %11, align 4
-    %12 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 2
-    store float 0.000000e+00, ptr %12, align 4
-    %13 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 3
-    store float 0.000000e+00, ptr %13, align 4
-    %14 = insertvalue %variant undef, ptr %literal, 0
-    %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$test_Abc" to i64), 1
-    %16 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
-    store %variant %15, ptr %16, align 16
-    %17 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
-    %not_err = icmp eq i64 %17, 0
-    br i1 %not_err, label %after_check, label %voiderr
-
-  after_check:                                      ; preds = %entry
-    br label %voiderr
-
-  voiderr:                                          ; preds = %after_check, %entry
-    ret void
-  }
+  %z = alloca i32, align 4
+  %z1 = alloca %Abc, align 4
+  %z2 = alloca i64, align 8
+  %z3 = alloca i32, align 4
+  %z4 = alloca ptr, align 8
+  %z5 = alloca i8, align 1
+  %z6 = alloca i64, align 8
+  %z7 = alloca <3 x i32>, align 16
+  %z8 = alloca %Abc, align 4
+  %z9 = alloca [2 x i32], align 4
+  %z10 = alloca %"int[]", align 8
+  %retparam = alloca i64, align 8
+  %varargslots = alloca [1 x %variant], align 16
+  %literal = alloca %Abc, align 4
+  store i32 0, ptr %z, align 4
+  %0 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 0
+  store float 0.000000e+00, ptr %0, align 4
+  %1 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 1
+  store float 0.000000e+00, ptr %1, align 4
+  %2 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 2
+  store float 0.000000e+00, ptr %2, align 4
+  %3 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 3
+  store float 0.000000e+00, ptr %3, align 4
+  store i64 0, ptr %z2, align 8
+  store i32 0, ptr %z3, align 4
+  store ptr null, ptr %z4, align 8
+  store i8 0, ptr %z5, align 1
+  store i64 0, ptr %z6, align 8
+  store <3 x i32> zeroinitializer, ptr %z7, align 16
+  %4 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 0
+  store float 0.000000e+00, ptr %4, align 4
+  %5 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 1
+  store float 0.000000e+00, ptr %5, align 4
+  %6 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 2
+  store float 0.000000e+00, ptr %6, align 4
+  %7 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 3
+  store float 0.000000e+00, ptr %7, align 4
+  %8 = getelementptr inbounds [2 x i32], ptr %z9, i64 0, i64 0
+  store i32 0, ptr %8, align 4
+  %9 = getelementptr inbounds [2 x i32], ptr %z9, i64 0, i64 1
+  store i32 0, ptr %9, align 4
+  call void @llvm.memset.p0.i64(ptr align 8 %z10, i8 0, i64 16, i1 false)
+  %10 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 0
+  store float 0.000000e+00, ptr %10, align 4
+  %11 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 1
+  store float 0.000000e+00, ptr %11, align 4
+  %12 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 2
+  store float 0.000000e+00, ptr %12, align 4
+  %13 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 3
+  store float 0.000000e+00, ptr %13, align 4
+  %14 = insertvalue %variant undef, ptr %literal, 0
+  %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$test_Abc" to i64), 1
+  %16 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
+  store %variant %15, ptr %16, align 16
+  %17 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
+  ret void
+}
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 3205c634b..f7e10a8a5 100644
--- a/test/test_suite/compile_time/ct_builtin_time_date.c3t
+++ b/test/test_suite/compile_time/ct_builtin_time_date.c3t
@@ -33,154 +33,69 @@ entry:
   %varargslots = alloca [1 x %variant], align 16
   %taddr = alloca i32, align 4
   %x = alloca ptr, align 8
-  %error_var = alloca i64, align 8
   %retparam1 = alloca i64, align 8
   %result = alloca %File, align 8
-  %x5 = alloca ptr, align 8
-  %error_var6 = alloca i64, align 8
-  %retparam7 = alloca i64, align 8
-  %result8 = alloca %File, align 8
-  %retparam14 = alloca i64, align 8
-  %varargslots15 = alloca [1 x %variant], align 16
-  %taddr16 = alloca i64, align 8
-  %retparam20 = alloca i64, align 8
-  %varargslots21 = alloca [1 x %variant], align 16
-  %taddr22 = alloca i64, align 8
-  %x26 = alloca ptr, align 8
-  %error_var27 = alloca i64, align 8
-  %retparam28 = alloca i64, align 8
-  %result29 = alloca %File, align 8
-  %x35 = alloca ptr, align 8
-  %error_var36 = alloca i64, align 8
-  %retparam37 = alloca i64, align 8
-  %result38 = alloca %File, align 8
+  %x2 = alloca ptr, 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
   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
   %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %2, ptr %3, align 16
   %4 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
-  %not_err = icmp eq i64 %4, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   %gt = icmp sgt i32 %0, 0
   br i1 %gt, label %if.then, label %if.exit
 
-if.then:                                          ; preds = %voiderr
+if.then:                                          ; preds = %entry
   %sub = sub i32 %0, 1
   call void @test_test(i32 %sub)
   br label %if.exit
 
-if.exit:                                          ; preds = %if.then, %voiderr
+if.exit:                                          ; preds = %if.then, %entry
   store ptr @.str.1, ptr %x, align 8
-  store i64 0, ptr %error_var, align 8
   %5 = call ptr @std_io_stdout()
   store ptr %5, ptr %result, align 8
   %6 = load ptr, ptr %x, align 8
   %7 = call i64 @std_io_File_printn(ptr %retparam1, ptr %result, ptr %6, i64 8)
-  %not_err2 = icmp eq i64 %7, 0
-  br i1 %not_err2, label %after_check3, label %assign_optional
-
-assign_optional:                                  ; preds = %if.exit
-  store i64 %7, ptr %error_var, align 8
-  br label %noerr_block
-
-after_check3:                                     ; preds = %if.exit
-  br label %noerr_block
-
-noerr_block:                                      ; preds = %after_check3, %assign_optional
-  br label %voiderr4
-
-voiderr4:                                         ; preds = %noerr_block
-  store ptr @.str.2, ptr %x5, align 8
-  store i64 0, ptr %error_var6, align 8
+  store ptr @.str.2, ptr %x2, align 8
   %8 = call ptr @std_io_stdout()
-  store ptr %8, ptr %result8, align 8
-  %9 = load ptr, ptr %x5, align 8
-  %10 = call i64 @std_io_File_printn(ptr %retparam7, ptr %result8, ptr %9, i64 10)
-  %not_err9 = icmp eq i64 %10, 0
-  br i1 %not_err9, label %after_check11, label %assign_optional10
-
-assign_optional10:                                ; preds = %voiderr4
-  store i64 %10, ptr %error_var6, align 8
-  br label %noerr_block12
-
-after_check11:                                    ; preds = %voiderr4
-  br label %noerr_block12
-
-noerr_block12:                                    ; preds = %after_check11, %assign_optional10
-  br label %voiderr13
-
-voiderr13:                                        ; preds = %noerr_block12
-  store i64 14, ptr %taddr16, align 8
-  %11 = insertvalue %variant undef, ptr %taddr16, 0
+  store ptr %8, ptr %result4, align 8
+  %9 = load ptr, ptr %x2, align 8
+  %10 = call i64 @std_io_File_printn(ptr %retparam3, ptr %result4, ptr %9, i64 10)
+  store i64 14, ptr %taddr7, align 8
+  %11 = insertvalue %variant undef, ptr %taddr7, 0
   %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$long" to i64), 1
-  %13 = getelementptr inbounds [1 x %variant], ptr %varargslots15, i64 0, i64 0
+  %13 = getelementptr inbounds [1 x %variant], ptr %varargslots6, i64 0, i64 0
   store %variant %12, ptr %13, align 16
-  %14 = call i64 @std_io_printfn(ptr %retparam14, ptr @.str.3, i64 2, ptr %varargslots15, i64 1)
-  %not_err17 = icmp eq i64 %14, 0
-  br i1 %not_err17, label %after_check18, label %voiderr19
-
-after_check18:                                    ; preds = %voiderr13
-  br label %voiderr19
-
-voiderr19:                                        ; preds = %after_check18, %voiderr13
-  store i64 6, ptr %taddr22, align 8
-  %15 = insertvalue %variant undef, ptr %taddr22, 0
+  %14 = call i64 @std_io_printfn(ptr %retparam5, ptr @.str.3, i64 2, ptr %varargslots6, i64 1)
+  store i64 6, ptr %taddr10, align 8
+  %15 = insertvalue %variant undef, ptr %taddr10, 0
   %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$long" to i64), 1
-  %17 = getelementptr inbounds [1 x %variant], ptr %varargslots21, i64 0, i64 0
+  %17 = getelementptr inbounds [1 x %variant], ptr %varargslots9, i64 0, i64 0
   store %variant %16, ptr %17, align 16
-  %18 = call i64 @std_io_printfn(ptr %retparam20, ptr @.str.4, i64 2, ptr %varargslots21, i64 1)
-  %not_err23 = icmp eq i64 %18, 0
-  br i1 %not_err23, label %after_check24, label %voiderr25
-
-after_check24:                                    ; preds = %voiderr19
-  br label %voiderr25
-
-voiderr25:                                        ; preds = %after_check24, %voiderr19
-  store ptr @.str.5, ptr %x26, align 8
-  store i64 0, ptr %error_var27, align 8
+  %18 = call i64 @std_io_printfn(ptr %retparam8, ptr @.str.4, i64 2, ptr %varargslots9, i64 1)
+  store ptr @.str.5, ptr %x11, align 8
   %19 = call ptr @std_io_stdout()
-  store ptr %19, ptr %result29, align 8
-  %20 = load ptr, ptr %x26, align 8
-  %21 = call i64 @std_io_File_printn(ptr %retparam28, ptr %result29, ptr %20, i64 23)
-  %not_err30 = icmp eq i64 %21, 0
-  br i1 %not_err30, label %after_check32, label %assign_optional31
-
-assign_optional31:                                ; preds = %voiderr25
-  store i64 %21, ptr %error_var27, align 8
-  br label %noerr_block33
-
-after_check32:                                    ; preds = %voiderr25
-  br label %noerr_block33
-
-noerr_block33:                                    ; preds = %after_check32, %assign_optional31
-  br label %voiderr34
-
-voiderr34:                                        ; preds = %noerr_block33
-  store ptr @.str.6, ptr %x35, align 8
-  store i64 0, ptr %error_var36, align 8
+  store ptr %19, ptr %result13, align 8
+  %20 = load ptr, ptr %x11, align 8
+  %21 = call i64 @std_io_File_printn(ptr %retparam12, ptr %result13, ptr %20, i64 23)
+  store ptr @.str.6, ptr %x14, align 8
   %22 = call ptr @std_io_stdout()
-  store ptr %22, ptr %result38, align 8
-  %23 = load ptr, ptr %x35, align 8
-  %24 = call i64 @std_io_File_printn(ptr %retparam37, ptr %result38, ptr %23, i64 4)
-  %not_err39 = icmp eq i64 %24, 0
-  br i1 %not_err39, label %after_check41, label %assign_optional40
-
-assign_optional40:                                ; preds = %voiderr34
-  store i64 %24, ptr %error_var36, align 8
-  br label %noerr_block42
-
-after_check41:                                    ; preds = %voiderr34
-  br label %noerr_block42
-
-noerr_block42:                                    ; preds = %after_check41, %assign_optional40
-  br label %voiderr43
-
-voiderr43:                                        ; preds = %noerr_block42
+  store ptr %22, ptr %result16, align 8
+  %23 = load ptr, ptr %x14, align 8
+  %24 = call i64 @std_io_File_printn(ptr %retparam15, ptr %result16, ptr %23, i64 4)
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/compile_time/ct_funcptr.c3t b/test/test_suite/compile_time/ct_funcptr.c3t
index ffbb21d1e..13e82add8 100644
--- a/test/test_suite/compile_time/ct_funcptr.c3t
+++ b/test/test_suite/compile_time/ct_funcptr.c3t
@@ -29,22 +29,15 @@ entry:
   %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %2, ptr %3, align 16
   %4 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
-  %not_err = icmp eq i64 %4, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   %gt = icmp sgt i32 %0, 0
   br i1 %gt, label %if.then, label %if.exit
 
-if.then:                                          ; preds = %voiderr
+if.then:                                          ; preds = %entry
   %5 = load ptr, ptr %ptr, align 8
   %sub = sub i32 %0, 1
   call void %5(i32 %sub)
   br label %if.exit
 
-if.exit:                                          ; preds = %if.then, %voiderr
+if.exit:                                          ; preds = %if.then, %entry
   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 4309c1843..770ad51dc 100644
--- a/test/test_suite/compile_time/ct_memberof.c3t
+++ b/test/test_suite/compile_time/ct_memberof.c3t
@@ -118,441 +118,238 @@ entry:
 define void @test_test(i32 %0) #0 {
 entry:
   %x = alloca ptr, align 8
-  %error_var = alloca i64, align 8
   %retparam = alloca i64, align 8
   %result = alloca %File, align 8
   %x1 = alloca ptr, align 8
-  %error_var2 = alloca i64, align 8
-  %retparam3 = alloca i64, align 8
-  %result4 = alloca %File, 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
-  %error_var11 = alloca i64, align 8
-  %retparam12 = alloca i64, align 8
-  %result13 = alloca %File, align 8
-  %x19 = alloca ptr, align 8
-  %error_var20 = alloca i64, align 8
-  %retparam21 = alloca i64, align 8
-  %result22 = alloca %File, align 8
-  %x28 = alloca ptr, align 8
-  %error_var29 = alloca i64, align 8
-  %retparam30 = alloca i64, align 8
-  %result31 = alloca %File, align 8
-  %x37 = alloca ptr, align 8
-  %error_var38 = alloca i64, align 8
-  %retparam39 = alloca i64, align 8
-  %result40 = alloca %File, align 8
-  %x46 = alloca ptr, align 8
-  %error_var47 = alloca i64, align 8
-  %retparam48 = alloca i64, align 8
-  %result49 = alloca %File, align 8
-  %retparam55 = alloca i64, 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
+  %retparam17 = alloca i64, align 8
+  %result18 = alloca %File, align 8
+  %retparam19 = alloca i64, align 8
   %varargslots = alloca [1 x %variant], align 16
   %taddr = alloca ptr, align 8
-  %retparam59 = alloca i64, align 8
-  %varargslots60 = alloca [2 x %variant], align 16
+  %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
+  %retparam32 = alloca i64, align 8
+  %varargslots33 = alloca [2 x %variant], align 16
+  %taddr34 = alloca ptr, align 8
+  %taddr35 = alloca ptr, 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
+  %retparam51 = alloca i64, align 8
+  %varargslots52 = alloca [2 x %variant], align 16
+  %taddr53 = alloca ptr, align 8
+  %taddr54 = alloca ptr, 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
-  %taddr62 = alloca ptr, align 8
-  %retparam66 = alloca i64, align 8
-  %varargslots67 = alloca [2 x %variant], align 16
-  %taddr68 = alloca ptr, align 8
-  %taddr69 = alloca ptr, align 8
-  %retparam73 = alloca i64, align 8
-  %varargslots74 = alloca [2 x %variant], align 16
-  %taddr75 = alloca ptr, align 8
-  %taddr76 = alloca ptr, align 8
-  %retparam80 = alloca i64, align 8
-  %varargslots81 = alloca [2 x %variant], align 16
-  %taddr82 = alloca ptr, align 8
-  %taddr83 = alloca ptr, align 8
-  %retparam87 = alloca i64, align 8
-  %varargslots88 = alloca [1 x %variant], align 16
-  %taddr89 = alloca ptr, align 8
-  %retparam93 = alloca i64, align 8
-  %varargslots94 = alloca [2 x %variant], align 16
-  %taddr95 = alloca ptr, align 8
-  %taddr96 = alloca ptr, align 8
-  %retparam100 = alloca i64, align 8
-  %varargslots101 = alloca [2 x %variant], align 16
-  %taddr102 = alloca ptr, align 8
-  %taddr103 = alloca ptr, align 8
-  %retparam107 = alloca i64, align 8
-  %varargslots108 = alloca [2 x %variant], align 16
-  %taddr109 = alloca ptr, align 8
-  %taddr110 = alloca ptr, align 8
-  %retparam114 = alloca i64, align 8
-  %varargslots115 = alloca [2 x %variant], align 16
-  %taddr116 = alloca ptr, align 8
-  %taddr117 = alloca ptr, align 8
-  %retparam121 = alloca i64, align 8
-  %varargslots122 = alloca [1 x %variant], align 16
-  %taddr123 = alloca ptr, align 8
-  %retparam127 = alloca i64, align 8
-  %varargslots128 = alloca [2 x %variant], align 16
-  %taddr129 = alloca ptr, align 8
-  %taddr130 = alloca ptr, align 8
-  %retparam134 = alloca i64, align 8
-  %varargslots135 = alloca [2 x %variant], align 16
-  %taddr136 = alloca ptr, align 8
-  %taddr137 = 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
-  store i64 0, ptr %error_var, align 8
   %1 = call ptr @std_io_stdout()
   store ptr %1, ptr %result, align 8
   %2 = load ptr, ptr %x, align 8
   %3 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %2, i64 3)
-  %not_err = icmp eq i64 %3, 0
-  br i1 %not_err, label %after_check, label %assign_optional
-
-assign_optional:                                  ; preds = %entry
-  store i64 %3, ptr %error_var, align 8
-  br label %noerr_block
-
-after_check:                                      ; preds = %entry
-  br label %noerr_block
-
-noerr_block:                                      ; preds = %after_check, %assign_optional
-  br label %voiderr
-
-voiderr:                                          ; preds = %noerr_block
   store ptr @.str.10, ptr %x1, align 8
-  store i64 0, ptr %error_var2, align 8
   %4 = call ptr @std_io_stdout()
-  store ptr %4, ptr %result4, align 8
+  store ptr %4, ptr %result3, align 8
   %5 = load ptr, ptr %x1, align 8
-  %6 = call i64 @std_io_File_printn(ptr %retparam3, ptr %result4, ptr %5, i64 3)
-  %not_err5 = icmp eq i64 %6, 0
-  br i1 %not_err5, label %after_check7, label %assign_optional6
-
-assign_optional6:                                 ; preds = %voiderr
-  store i64 %6, ptr %error_var2, align 8
-  br label %noerr_block8
-
-after_check7:                                     ; preds = %voiderr
-  br label %noerr_block8
-
-noerr_block8:                                     ; preds = %after_check7, %assign_optional6
-  br label %voiderr9
-
-voiderr9:                                         ; preds = %noerr_block8
-  store ptr @.str.11, ptr %x10, align 8
-  store i64 0, ptr %error_var11, align 8
+  %6 = call i64 @std_io_File_printn(ptr %retparam2, ptr %result3, ptr %5, i64 3)
+  store ptr @.str.11, ptr %x4, align 8
   %7 = call ptr @std_io_stdout()
-  store ptr %7, ptr %result13, align 8
-  %8 = load ptr, ptr %x10, align 8
-  %9 = call i64 @std_io_File_printn(ptr %retparam12, ptr %result13, ptr %8, i64 6)
-  %not_err14 = icmp eq i64 %9, 0
-  br i1 %not_err14, label %after_check16, label %assign_optional15
-
-assign_optional15:                                ; preds = %voiderr9
-  store i64 %9, ptr %error_var11, align 8
-  br label %noerr_block17
-
-after_check16:                                    ; preds = %voiderr9
-  br label %noerr_block17
-
-noerr_block17:                                    ; preds = %after_check16, %assign_optional15
-  br label %voiderr18
-
-voiderr18:                                        ; preds = %noerr_block17
-  store ptr @.str.12, ptr %x19, align 8
-  store i64 0, ptr %error_var20, align 8
+  store ptr %7, ptr %result6, align 8
+  %8 = load ptr, ptr %x4, align 8
+  %9 = call i64 @std_io_File_printn(ptr %retparam5, ptr %result6, ptr %8, i64 6)
+  store ptr @.str.12, ptr %x7, align 8
   %10 = call ptr @std_io_stdout()
-  store ptr %10, ptr %result22, align 8
-  %11 = load ptr, ptr %x19, align 8
-  %12 = call i64 @std_io_File_printn(ptr %retparam21, ptr %result22, ptr %11, i64 6)
-  %not_err23 = icmp eq i64 %12, 0
-  br i1 %not_err23, label %after_check25, label %assign_optional24
-
-assign_optional24:                                ; preds = %voiderr18
-  store i64 %12, ptr %error_var20, align 8
-  br label %noerr_block26
-
-after_check25:                                    ; preds = %voiderr18
-  br label %noerr_block26
-
-noerr_block26:                                    ; preds = %after_check25, %assign_optional24
-  br label %voiderr27
-
-voiderr27:                                        ; preds = %noerr_block26
-  store ptr @.str.13, ptr %x28, align 8
-  store i64 0, ptr %error_var29, align 8
+  store ptr %10, ptr %result9, align 8
+  %11 = load ptr, ptr %x7, align 8
+  %12 = call i64 @std_io_File_printn(ptr %retparam8, ptr %result9, ptr %11, i64 6)
+  store ptr @.str.13, ptr %x10, align 8
   %13 = call ptr @std_io_stdout()
-  store ptr %13, ptr %result31, align 8
-  %14 = load ptr, ptr %x28, align 8
-  %15 = call i64 @std_io_File_printn(ptr %retparam30, ptr %result31, ptr %14, i64 9)
-  %not_err32 = icmp eq i64 %15, 0
-  br i1 %not_err32, label %after_check34, label %assign_optional33
-
-assign_optional33:                                ; preds = %voiderr27
-  store i64 %15, ptr %error_var29, align 8
-  br label %noerr_block35
-
-after_check34:                                    ; preds = %voiderr27
-  br label %noerr_block35
-
-noerr_block35:                                    ; preds = %after_check34, %assign_optional33
-  br label %voiderr36
-
-voiderr36:                                        ; preds = %noerr_block35
-  store ptr @.str.14, ptr %x37, align 8
-  store i64 0, ptr %error_var38, align 8
+  store ptr %13, ptr %result12, align 8
+  %14 = load ptr, ptr %x10, align 8
+  %15 = call i64 @std_io_File_printn(ptr %retparam11, ptr %result12, ptr %14, i64 9)
+  store ptr @.str.14, ptr %x13, align 8
   %16 = call ptr @std_io_stdout()
-  store ptr %16, ptr %result40, align 8
-  %17 = load ptr, ptr %x37, align 8
-  %18 = call i64 @std_io_File_printn(ptr %retparam39, ptr %result40, ptr %17, i64 4)
-  %not_err41 = icmp eq i64 %18, 0
-  br i1 %not_err41, label %after_check43, label %assign_optional42
-
-assign_optional42:                                ; preds = %voiderr36
-  store i64 %18, ptr %error_var38, align 8
-  br label %noerr_block44
-
-after_check43:                                    ; preds = %voiderr36
-  br label %noerr_block44
-
-noerr_block44:                                    ; preds = %after_check43, %assign_optional42
-  br label %voiderr45
-
-voiderr45:                                        ; preds = %noerr_block44
-  store ptr @.str.15, ptr %x46, align 8
-  store i64 0, ptr %error_var47, align 8
+  store ptr %16, ptr %result15, align 8
+  %17 = load ptr, ptr %x13, align 8
+  %18 = call i64 @std_io_File_printn(ptr %retparam14, ptr %result15, ptr %17, i64 4)
+  store ptr @.str.15, ptr %x16, align 8
   %19 = call ptr @std_io_stdout()
-  store ptr %19, ptr %result49, align 8
-  %20 = load ptr, ptr %x46, align 8
-  %21 = call i64 @std_io_File_printn(ptr %retparam48, ptr %result49, ptr %20, i64 3)
-  %not_err50 = icmp eq i64 %21, 0
-  br i1 %not_err50, label %after_check52, label %assign_optional51
-
-assign_optional51:                                ; preds = %voiderr45
-  store i64 %21, ptr %error_var47, align 8
-  br label %noerr_block53
-
-after_check52:                                    ; preds = %voiderr45
-  br label %noerr_block53
-
-noerr_block53:                                    ; preds = %after_check52, %assign_optional51
-  br label %voiderr54
-
-voiderr54:                                        ; preds = %noerr_block53
+  store ptr %19, ptr %result18, align 8
+  %20 = load ptr, ptr %x16, align 8
+  %21 = call i64 @std_io_File_printn(ptr %retparam17, ptr %result18, ptr %20, i64 3)
   store ptr @.str.17, ptr %taddr, align 8
   %22 = insertvalue %variant undef, ptr %taddr, 0
   %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
   %24 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %23, ptr %24, align 16
-  %25 = call i64 @std_io_printfn(ptr %retparam55, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
-  %not_err56 = icmp eq i64 %25, 0
-  br i1 %not_err56, label %after_check57, label %voiderr58
-
-after_check57:                                    ; preds = %voiderr54
-  br label %voiderr58
-
-voiderr58:                                        ; preds = %after_check57, %voiderr54
-  store ptr @.str.19, ptr %taddr61, align 8
-  %26 = insertvalue %variant undef, ptr %taddr61, 0
+  %25 = call i64 @std_io_printfn(ptr %retparam19, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
+  store ptr @.str.19, ptr %taddr22, align 8
+  %26 = insertvalue %variant undef, ptr %taddr22, 0
   %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
-  %28 = getelementptr inbounds [2 x %variant], ptr %varargslots60, i64 0, i64 0
+  %28 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 0
   store %variant %27, ptr %28, align 16
-  store ptr @.str.20, ptr %taddr62, align 8
-  %29 = insertvalue %variant undef, ptr %taddr62, 0
+  store ptr @.str.20, ptr %taddr23, align 8
+  %29 = insertvalue %variant undef, ptr %taddr23, 0
   %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
-  %31 = getelementptr inbounds [2 x %variant], ptr %varargslots60, i64 0, i64 1
+  %31 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 1
   store %variant %30, ptr %31, align 16
-  %32 = call i64 @std_io_printfn(ptr %retparam59, ptr @.str.18, i64 6, ptr %varargslots60, i64 2)
-  %not_err63 = icmp eq i64 %32, 0
-  br i1 %not_err63, label %after_check64, label %voiderr65
-
-after_check64:                                    ; preds = %voiderr58
-  br label %voiderr65
-
-voiderr65:                                        ; preds = %after_check64, %voiderr58
-  store ptr @.str.22, ptr %taddr68, align 8
-  %33 = insertvalue %variant undef, ptr %taddr68, 0
+  %32 = call i64 @std_io_printfn(ptr %retparam20, ptr @.str.18, i64 6, ptr %varargslots21, i64 2)
+  store ptr @.str.22, ptr %taddr26, align 8
+  %33 = insertvalue %variant undef, ptr %taddr26, 0
   %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
-  %35 = getelementptr inbounds [2 x %variant], ptr %varargslots67, i64 0, i64 0
+  %35 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 0
   store %variant %34, ptr %35, align 16
-  store ptr @.str.23, ptr %taddr69, align 8
-  %36 = insertvalue %variant undef, ptr %taddr69, 0
+  store ptr @.str.23, ptr %taddr27, align 8
+  %36 = insertvalue %variant undef, ptr %taddr27, 0
   %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
-  %38 = getelementptr inbounds [2 x %variant], ptr %varargslots67, i64 0, i64 1
+  %38 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 1
   store %variant %37, ptr %38, align 16
-  %39 = call i64 @std_io_printfn(ptr %retparam66, ptr @.str.21, i64 6, ptr %varargslots67, i64 2)
-  %not_err70 = icmp eq i64 %39, 0
-  br i1 %not_err70, label %after_check71, label %voiderr72
-
-after_check71:                                    ; preds = %voiderr65
-  br label %voiderr72
-
-voiderr72:                                        ; preds = %after_check71, %voiderr65
-  store ptr @.str.25, ptr %taddr75, align 8
-  %40 = insertvalue %variant undef, ptr %taddr75, 0
+  %39 = call i64 @std_io_printfn(ptr %retparam24, ptr @.str.21, i64 6, ptr %varargslots25, i64 2)
+  store ptr @.str.25, ptr %taddr30, align 8
+  %40 = insertvalue %variant undef, ptr %taddr30, 0
   %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1
-  %42 = getelementptr inbounds [2 x %variant], ptr %varargslots74, i64 0, i64 0
+  %42 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 0
   store %variant %41, ptr %42, align 16
-  store ptr @.str.26, ptr %taddr76, align 8
-  %43 = insertvalue %variant undef, ptr %taddr76, 0
+  store ptr @.str.26, ptr %taddr31, align 8
+  %43 = insertvalue %variant undef, ptr %taddr31, 0
   %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
-  %45 = getelementptr inbounds [2 x %variant], ptr %varargslots74, i64 0, i64 1
+  %45 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 1
   store %variant %44, ptr %45, align 16
-  %46 = call i64 @std_io_printfn(ptr %retparam73, ptr @.str.24, i64 6, ptr %varargslots74, i64 2)
-  %not_err77 = icmp eq i64 %46, 0
-  br i1 %not_err77, label %after_check78, label %voiderr79
-
-after_check78:                                    ; preds = %voiderr72
-  br label %voiderr79
-
-voiderr79:                                        ; preds = %after_check78, %voiderr72
-  store ptr @.str.28, ptr %taddr82, align 8
-  %47 = insertvalue %variant undef, ptr %taddr82, 0
+  %46 = call i64 @std_io_printfn(ptr %retparam28, ptr @.str.24, i64 6, ptr %varargslots29, i64 2)
+  store ptr @.str.28, ptr %taddr34, align 8
+  %47 = insertvalue %variant undef, ptr %taddr34, 0
   %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
-  %49 = getelementptr inbounds [2 x %variant], ptr %varargslots81, i64 0, i64 0
+  %49 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 0
   store %variant %48, ptr %49, align 16
-  store ptr @.str.29, ptr %taddr83, align 8
-  %50 = insertvalue %variant undef, ptr %taddr83, 0
+  store ptr @.str.29, ptr %taddr35, align 8
+  %50 = insertvalue %variant undef, ptr %taddr35, 0
   %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1
-  %52 = getelementptr inbounds [2 x %variant], ptr %varargslots81, i64 0, i64 1
+  %52 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 1
   store %variant %51, ptr %52, align 16
-  %53 = call i64 @std_io_printfn(ptr %retparam80, ptr @.str.27, i64 6, ptr %varargslots81, i64 2)
-  %not_err84 = icmp eq i64 %53, 0
-  br i1 %not_err84, label %after_check85, label %voiderr86
-
-after_check85:                                    ; preds = %voiderr79
-  br label %voiderr86
-
-voiderr86:                                        ; preds = %after_check85, %voiderr79
-  store ptr @.str.31, ptr %taddr89, align 8
-  %54 = insertvalue %variant undef, ptr %taddr89, 0
+  %53 = call i64 @std_io_printfn(ptr %retparam32, ptr @.str.27, i64 6, ptr %varargslots33, i64 2)
+  store ptr @.str.31, ptr %taddr38, align 8
+  %54 = insertvalue %variant undef, ptr %taddr38, 0
   %55 = insertvalue %variant %54, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
-  %56 = getelementptr inbounds [1 x %variant], ptr %varargslots88, i64 0, i64 0
+  %56 = getelementptr inbounds [1 x %variant], ptr %varargslots37, i64 0, i64 0
   store %variant %55, ptr %56, align 16
-  %57 = call i64 @std_io_printfn(ptr %retparam87, ptr @.str.30, i64 8, ptr %varargslots88, i64 1)
-  %not_err90 = icmp eq i64 %57, 0
-  br i1 %not_err90, label %after_check91, label %voiderr92
-
-after_check91:                                    ; preds = %voiderr86
-  br label %voiderr92
-
-voiderr92:                                        ; preds = %after_check91, %voiderr86
-  store ptr @.str.33, ptr %taddr95, align 8
-  %58 = insertvalue %variant undef, ptr %taddr95, 0
+  %57 = call i64 @std_io_printfn(ptr %retparam36, ptr @.str.30, i64 8, ptr %varargslots37, i64 1)
+  store ptr @.str.33, ptr %taddr41, align 8
+  %58 = insertvalue %variant undef, ptr %taddr41, 0
   %59 = insertvalue %variant %58, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
-  %60 = getelementptr inbounds [2 x %variant], ptr %varargslots94, i64 0, i64 0
+  %60 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 0
   store %variant %59, ptr %60, align 16
-  store ptr @.str.34, ptr %taddr96, align 8
-  %61 = insertvalue %variant undef, ptr %taddr96, 0
+  store ptr @.str.34, ptr %taddr42, align 8
+  %61 = insertvalue %variant undef, ptr %taddr42, 0
   %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
-  %63 = getelementptr inbounds [2 x %variant], ptr %varargslots94, i64 0, i64 1
+  %63 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1
   store %variant %62, ptr %63, align 16
-  %64 = call i64 @std_io_printfn(ptr %retparam93, ptr @.str.32, i64 6, ptr %varargslots94, i64 2)
-  %not_err97 = icmp eq i64 %64, 0
-  br i1 %not_err97, label %after_check98, label %voiderr99
-
-after_check98:                                    ; preds = %voiderr92
-  br label %voiderr99
-
-voiderr99:                                        ; preds = %after_check98, %voiderr92
-  store ptr @.str.36, ptr %taddr102, align 8
-  %65 = insertvalue %variant undef, ptr %taddr102, 0
+  %64 = call i64 @std_io_printfn(ptr %retparam39, ptr @.str.32, i64 6, ptr %varargslots40, i64 2)
+  store ptr @.str.36, ptr %taddr45, align 8
+  %65 = insertvalue %variant undef, ptr %taddr45, 0
   %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
-  %67 = getelementptr inbounds [2 x %variant], ptr %varargslots101, i64 0, i64 0
+  %67 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 0
   store %variant %66, ptr %67, align 16
-  store ptr @.str.37, ptr %taddr103, align 8
-  %68 = insertvalue %variant undef, ptr %taddr103, 0
+  store ptr @.str.37, ptr %taddr46, align 8
+  %68 = insertvalue %variant undef, ptr %taddr46, 0
   %69 = insertvalue %variant %68, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
-  %70 = getelementptr inbounds [2 x %variant], ptr %varargslots101, i64 0, i64 1
+  %70 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 1
   store %variant %69, ptr %70, align 16
-  %71 = call i64 @std_io_printfn(ptr %retparam100, ptr @.str.35, i64 6, ptr %varargslots101, i64 2)
-  %not_err104 = icmp eq i64 %71, 0
-  br i1 %not_err104, label %after_check105, label %voiderr106
-
-after_check105:                                   ; preds = %voiderr99
-  br label %voiderr106
-
-voiderr106:                                       ; preds = %after_check105, %voiderr99
-  store ptr @.str.39, ptr %taddr109, align 8
-  %72 = insertvalue %variant undef, ptr %taddr109, 0
+  %71 = call i64 @std_io_printfn(ptr %retparam43, ptr @.str.35, i64 6, ptr %varargslots44, i64 2)
+  store ptr @.str.39, ptr %taddr49, align 8
+  %72 = insertvalue %variant undef, ptr %taddr49, 0
   %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1
-  %74 = getelementptr inbounds [2 x %variant], ptr %varargslots108, i64 0, i64 0
+  %74 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 0
   store %variant %73, ptr %74, align 16
-  store ptr @.str.40, ptr %taddr110, align 8
-  %75 = insertvalue %variant undef, ptr %taddr110, 0
+  store ptr @.str.40, ptr %taddr50, align 8
+  %75 = insertvalue %variant undef, ptr %taddr50, 0
   %76 = insertvalue %variant %75, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
-  %77 = getelementptr inbounds [2 x %variant], ptr %varargslots108, i64 0, i64 1
+  %77 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 1
   store %variant %76, ptr %77, align 16
-  %78 = call i64 @std_io_printfn(ptr %retparam107, ptr @.str.38, i64 6, ptr %varargslots108, i64 2)
-  %not_err111 = icmp eq i64 %78, 0
-  br i1 %not_err111, label %after_check112, label %voiderr113
-
-after_check112:                                   ; preds = %voiderr106
-  br label %voiderr113
-
-voiderr113:                                       ; preds = %after_check112, %voiderr106
-  store ptr @.str.42, ptr %taddr116, align 8
-  %79 = insertvalue %variant undef, ptr %taddr116, 0
+  %78 = call i64 @std_io_printfn(ptr %retparam47, ptr @.str.38, i64 6, ptr %varargslots48, i64 2)
+  store ptr @.str.42, ptr %taddr53, align 8
+  %79 = insertvalue %variant undef, ptr %taddr53, 0
   %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
-  %81 = getelementptr inbounds [2 x %variant], ptr %varargslots115, i64 0, i64 0
+  %81 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 0
   store %variant %80, ptr %81, align 16
-  store ptr @.str.43, ptr %taddr117, align 8
-  %82 = insertvalue %variant undef, ptr %taddr117, 0
+  store ptr @.str.43, ptr %taddr54, align 8
+  %82 = insertvalue %variant undef, ptr %taddr54, 0
   %83 = insertvalue %variant %82, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
-  %84 = getelementptr inbounds [2 x %variant], ptr %varargslots115, i64 0, i64 1
+  %84 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 1
   store %variant %83, ptr %84, align 16
-  %85 = call i64 @std_io_printfn(ptr %retparam114, ptr @.str.41, i64 6, ptr %varargslots115, i64 2)
-  %not_err118 = icmp eq i64 %85, 0
-  br i1 %not_err118, label %after_check119, label %voiderr120
-
-after_check119:                                   ; preds = %voiderr113
-  br label %voiderr120
-
-voiderr120:                                       ; preds = %after_check119, %voiderr113
-  store ptr @.str.45, ptr %taddr123, align 8
-  %86 = insertvalue %variant undef, ptr %taddr123, 0
+  %85 = call i64 @std_io_printfn(ptr %retparam51, ptr @.str.41, i64 6, ptr %varargslots52, i64 2)
+  store ptr @.str.45, ptr %taddr57, align 8
+  %86 = insertvalue %variant undef, ptr %taddr57, 0
   %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
-  %88 = getelementptr inbounds [1 x %variant], ptr %varargslots122, i64 0, i64 0
+  %88 = getelementptr inbounds [1 x %variant], ptr %varargslots56, i64 0, i64 0
   store %variant %87, ptr %88, align 16
-  %89 = call i64 @std_io_printfn(ptr %retparam121, ptr @.str.44, i64 8, ptr %varargslots122, i64 1)
-  %not_err124 = icmp eq i64 %89, 0
-  br i1 %not_err124, label %after_check125, label %voiderr126
-
-after_check125:                                   ; preds = %voiderr120
-  br label %voiderr126
-
-voiderr126:                                       ; preds = %after_check125, %voiderr120
-  store ptr @.str.47, ptr %taddr129, align 8
-  %90 = insertvalue %variant undef, ptr %taddr129, 0
+  %89 = call i64 @std_io_printfn(ptr %retparam55, ptr @.str.44, i64 8, ptr %varargslots56, i64 1)
+  store ptr @.str.47, ptr %taddr60, align 8
+  %90 = insertvalue %variant undef, ptr %taddr60, 0
   %91 = insertvalue %variant %90, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
-  %92 = getelementptr inbounds [2 x %variant], ptr %varargslots128, i64 0, i64 0
+  %92 = getelementptr inbounds [2 x %variant], ptr %varargslots59, i64 0, i64 0
   store %variant %91, ptr %92, align 16
-  store ptr @.str.48, ptr %taddr130, align 8
-  %93 = insertvalue %variant undef, ptr %taddr130, 0
+  store ptr @.str.48, ptr %taddr61, align 8
+  %93 = insertvalue %variant undef, ptr %taddr61, 0
   %94 = insertvalue %variant %93, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
-  %95 = getelementptr inbounds [2 x %variant], ptr %varargslots128, i64 0, i64 1
+  %95 = getelementptr inbounds [2 x %variant], ptr %varargslots59, i64 0, i64 1
   store %variant %94, ptr %95, align 16
-  %96 = call i64 @std_io_printfn(ptr %retparam127, ptr @.str.46, i64 6, ptr %varargslots128, i64 2)
-  %not_err131 = icmp eq i64 %96, 0
-  br i1 %not_err131, label %after_check132, label %voiderr133
-
-after_check132:                                   ; preds = %voiderr126
-  br label %voiderr133
-
-voiderr133:                                       ; preds = %after_check132, %voiderr126
-  store ptr @.str.50, ptr %taddr136, align 8
-  %97 = insertvalue %variant undef, ptr %taddr136, 0
+  %96 = call i64 @std_io_printfn(ptr %retparam58, ptr @.str.46, i64 6, ptr %varargslots59, i64 2)
+  store ptr @.str.50, ptr %taddr64, align 8
+  %97 = insertvalue %variant undef, ptr %taddr64, 0
   %98 = insertvalue %variant %97, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
-  %99 = getelementptr inbounds [2 x %variant], ptr %varargslots135, i64 0, i64 0
+  %99 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 0
   store %variant %98, ptr %99, align 16
-  store ptr @.str.51, ptr %taddr137, align 8
-  %100 = insertvalue %variant undef, ptr %taddr137, 0
+  store ptr @.str.51, ptr %taddr65, align 8
+  %100 = insertvalue %variant undef, ptr %taddr65, 0
   %101 = insertvalue %variant %100, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
-  %102 = getelementptr inbounds [2 x %variant], ptr %varargslots135, i64 0, i64 1
+  %102 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 1
   store %variant %101, ptr %102, align 16
-  %103 = call i64 @std_io_printfn(ptr %retparam134, ptr @.str.49, i64 6, ptr %varargslots135, i64 2)
-  %not_err138 = icmp eq i64 %103, 0
-  br i1 %not_err138, label %after_check139, label %voiderr140
-
-after_check139:                                   ; preds = %voiderr133
-  br label %voiderr140
-
-voiderr140:                                       ; preds = %after_check139, %voiderr133
+  %103 = call i64 @std_io_printfn(ptr %retparam62, ptr @.str.49, i64 6, ptr %varargslots63, i64 2)
   ret void
 }
 
@@ -565,224 +362,147 @@ entry:
   %retparam1 = alloca i64, align 8
   %varargslots2 = alloca [1 x %variant], align 16
   %taddr3 = alloca i64, align 8
-  %retparam7 = alloca i64, align 8
-  %varargslots8 = alloca [2 x %variant], align 16
-  %taddr9 = alloca i64, align 8
+  %retparam4 = alloca i64, align 8
+  %varargslots5 = alloca [2 x %variant], align 16
+  %taddr6 = alloca i64, align 8
+  %taddr7 = alloca i64, align 8
+  %retparam8 = alloca i64, align 8
+  %varargslots9 = alloca [2 x %variant], align 16
   %taddr10 = alloca i64, align 8
-  %retparam14 = alloca i64, align 8
-  %varargslots15 = alloca [2 x %variant], align 16
-  %taddr16 = alloca i64, align 8
-  %taddr17 = alloca i64, align 8
-  %retparam21 = alloca i64, align 8
-  %varargslots22 = alloca [2 x %variant], align 16
+  %taddr11 = alloca i64, align 8
+  %retparam12 = alloca i64, align 8
+  %varargslots13 = alloca [2 x %variant], align 16
+  %taddr14 = alloca i64, align 8
+  %taddr15 = alloca i64, align 8
+  %retparam16 = alloca i64, align 8
+  %varargslots17 = alloca [2 x %variant], align 16
+  %taddr18 = alloca i64, align 8
+  %taddr19 = alloca i64, align 8
+  %retparam20 = alloca i64, align 8
+  %varargslots21 = alloca [2 x %variant], align 16
+  %taddr22 = alloca i64, align 8
   %taddr23 = alloca i64, align 8
-  %taddr24 = alloca i64, align 8
+  %retparam24 = alloca i64, align 8
+  %varargslots25 = alloca [2 x %variant], align 16
+  %taddr26 = alloca i64, align 8
+  %taddr27 = alloca i64, align 8
   %retparam28 = alloca i64, align 8
   %varargslots29 = alloca [2 x %variant], align 16
   %taddr30 = alloca i64, align 8
   %taddr31 = alloca i64, align 8
+  %retparam32 = alloca i64, align 8
+  %varargslots33 = alloca [1 x %variant], align 16
+  %taddr34 = alloca i64, align 8
   %retparam35 = alloca i64, align 8
   %varargslots36 = alloca [2 x %variant], align 16
   %taddr37 = alloca i64, align 8
   %taddr38 = alloca i64, align 8
-  %retparam42 = alloca i64, align 8
-  %varargslots43 = alloca [2 x %variant], align 16
-  %taddr44 = alloca i64, align 8
-  %taddr45 = alloca i64, align 8
-  %retparam49 = alloca i64, align 8
-  %varargslots50 = alloca [2 x %variant], align 16
-  %taddr51 = alloca i64, align 8
-  %taddr52 = alloca i64, align 8
-  %retparam56 = alloca i64, align 8
-  %varargslots57 = alloca [1 x %variant], align 16
-  %taddr58 = alloca i64, align 8
-  %retparam62 = alloca i64, align 8
-  %varargslots63 = alloca [2 x %variant], align 16
-  %taddr64 = alloca i64, align 8
-  %taddr65 = alloca i64, align 8
   store i64 4, ptr %taddr, align 8
   %0 = insertvalue %variant undef, ptr %taddr, 0
   %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)
-  %not_err = icmp eq i64 %3, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   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)
-  %not_err4 = icmp eq i64 %7, 0
-  br i1 %not_err4, label %after_check5, label %voiderr6
-
-after_check5:                                     ; preds = %voiderr
-  br label %voiderr6
-
-voiderr6:                                         ; preds = %after_check5, %voiderr
-  store i64 0, ptr %taddr9, align 8
-  %8 = insertvalue %variant undef, ptr %taddr9, 0
+  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
-  %10 = getelementptr inbounds [2 x %variant], ptr %varargslots8, i64 0, i64 0
+  %10 = getelementptr inbounds [2 x %variant], ptr %varargslots5, i64 0, i64 0
   store %variant %9, ptr %10, align 16
-  store i64 4, ptr %taddr10, align 8
-  %11 = insertvalue %variant undef, ptr %taddr10, 0
+  store i64 4, ptr %taddr7, align 8
+  %11 = insertvalue %variant undef, ptr %taddr7, 0
   %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %13 = getelementptr inbounds [2 x %variant], ptr %varargslots8, i64 0, 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 %retparam7, ptr @.str.54, i64 8, ptr %varargslots8, i64 2)
-  %not_err11 = icmp eq i64 %14, 0
-  br i1 %not_err11, label %after_check12, label %voiderr13
-
-after_check12:                                    ; preds = %voiderr6
-  br label %voiderr13
-
-voiderr13:                                        ; preds = %after_check12, %voiderr6
-  store i64 2, ptr %taddr16, align 8
-  %15 = insertvalue %variant undef, ptr %taddr16, 0
+  %14 = call i64 @std_io_printfn(ptr %retparam4, ptr @.str.54, 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
-  %17 = getelementptr inbounds [2 x %variant], ptr %varargslots15, i64 0, i64 0
+  %17 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 0
   store %variant %16, ptr %17, align 16
-  store i64 2, ptr %taddr17, align 8
-  %18 = insertvalue %variant undef, ptr %taddr17, 0
+  store i64 2, ptr %taddr11, align 8
+  %18 = insertvalue %variant undef, ptr %taddr11, 0
   %19 = insertvalue %variant %18, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %20 = getelementptr inbounds [2 x %variant], ptr %varargslots15, i64 0, 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 %retparam14, ptr @.str.55, i64 8, ptr %varargslots15, i64 2)
-  %not_err18 = icmp eq i64 %21, 0
-  br i1 %not_err18, label %after_check19, label %voiderr20
-
-after_check19:                                    ; preds = %voiderr13
-  br label %voiderr20
-
-voiderr20:                                        ; preds = %after_check19, %voiderr13
-  store i64 4, ptr %taddr23, align 8
-  %22 = insertvalue %variant undef, ptr %taddr23, 0
+  %21 = call i64 @std_io_printfn(ptr %retparam8, ptr @.str.55, 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
-  %24 = getelementptr inbounds [2 x %variant], ptr %varargslots22, i64 0, i64 0
+  %24 = getelementptr inbounds [2 x %variant], ptr %varargslots13, i64 0, i64 0
   store %variant %23, ptr %24, align 16
-  store i64 4, ptr %taddr24, align 8
-  %25 = insertvalue %variant undef, ptr %taddr24, 0
+  store i64 4, ptr %taddr15, align 8
+  %25 = insertvalue %variant undef, ptr %taddr15, 0
   %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %27 = getelementptr inbounds [2 x %variant], ptr %varargslots22, i64 0, 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 %retparam21, ptr @.str.56, i64 8, ptr %varargslots22, i64 2)
-  %not_err25 = icmp eq i64 %28, 0
-  br i1 %not_err25, label %after_check26, label %voiderr27
-
-after_check26:                                    ; preds = %voiderr20
-  br label %voiderr27
-
-voiderr27:                                        ; preds = %after_check26, %voiderr20
-  store i64 4, ptr %taddr30, align 8
-  %29 = insertvalue %variant undef, ptr %taddr30, 0
+  %28 = call i64 @std_io_printfn(ptr %retparam12, ptr @.str.56, 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
-  %31 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 0
+  %31 = getelementptr inbounds [2 x %variant], ptr %varargslots17, i64 0, i64 0
   store %variant %30, ptr %31, align 16
-  store i64 4, ptr %taddr31, align 8
-  %32 = insertvalue %variant undef, ptr %taddr31, 0
+  store i64 4, ptr %taddr19, align 8
+  %32 = insertvalue %variant undef, ptr %taddr19, 0
   %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %34 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, 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 %retparam28, ptr @.str.57, i64 8, ptr %varargslots29, i64 2)
-  %not_err32 = icmp eq i64 %35, 0
-  br i1 %not_err32, label %after_check33, label %voiderr34
-
-after_check33:                                    ; preds = %voiderr27
-  br label %voiderr34
-
-voiderr34:                                        ; preds = %after_check33, %voiderr27
-  store i64 4, ptr %taddr37, align 8
-  %36 = insertvalue %variant undef, ptr %taddr37, 0
+  %35 = call i64 @std_io_printfn(ptr %retparam16, ptr @.str.57, 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
-  %38 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 0
+  %38 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 0
   store %variant %37, ptr %38, align 16
-  store i64 4, ptr %taddr38, align 8
-  %39 = insertvalue %variant undef, ptr %taddr38, 0
+  store i64 4, ptr %taddr23, align 8
+  %39 = insertvalue %variant undef, ptr %taddr23, 0
   %40 = insertvalue %variant %39, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %41 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, 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 %retparam35, ptr @.str.58, i64 9, ptr %varargslots36, i64 2)
-  %not_err39 = icmp eq i64 %42, 0
-  br i1 %not_err39, label %after_check40, label %voiderr41
-
-after_check40:                                    ; preds = %voiderr34
-  br label %voiderr41
-
-voiderr41:                                        ; preds = %after_check40, %voiderr34
-  store i64 5, ptr %taddr44, align 8
-  %43 = insertvalue %variant undef, ptr %taddr44, 0
+  %42 = call i64 @std_io_printfn(ptr %retparam20, ptr @.str.58, 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
-  %45 = getelementptr inbounds [2 x %variant], ptr %varargslots43, i64 0, i64 0
+  %45 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 0
   store %variant %44, ptr %45, align 16
-  store i64 1, ptr %taddr45, align 8
-  %46 = insertvalue %variant undef, ptr %taddr45, 0
+  store i64 1, ptr %taddr27, align 8
+  %46 = insertvalue %variant undef, ptr %taddr27, 0
   %47 = insertvalue %variant %46, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %48 = getelementptr inbounds [2 x %variant], ptr %varargslots43, i64 0, 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 %retparam42, ptr @.str.59, i64 9, ptr %varargslots43, i64 2)
-  %not_err46 = icmp eq i64 %49, 0
-  br i1 %not_err46, label %after_check47, label %voiderr48
-
-after_check47:                                    ; preds = %voiderr41
-  br label %voiderr48
-
-voiderr48:                                        ; preds = %after_check47, %voiderr41
-  store i64 8, ptr %taddr51, align 8
-  %50 = insertvalue %variant undef, ptr %taddr51, 0
+  %49 = call i64 @std_io_printfn(ptr %retparam24, ptr @.str.59, 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
-  %52 = getelementptr inbounds [2 x %variant], ptr %varargslots50, i64 0, i64 0
+  %52 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 0
   store %variant %51, ptr %52, align 16
-  store i64 4, ptr %taddr52, align 8
-  %53 = insertvalue %variant undef, ptr %taddr52, 0
+  store i64 4, ptr %taddr31, align 8
+  %53 = insertvalue %variant undef, ptr %taddr31, 0
   %54 = insertvalue %variant %53, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %55 = getelementptr inbounds [2 x %variant], ptr %varargslots50, i64 0, 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 %retparam49, ptr @.str.60, i64 10, ptr %varargslots50, i64 2)
-  %not_err53 = icmp eq i64 %56, 0
-  br i1 %not_err53, label %after_check54, label %voiderr55
-
-after_check54:                                    ; preds = %voiderr48
-  br label %voiderr55
-
-voiderr55:                                        ; preds = %after_check54, %voiderr48
-  store i64 4, ptr %taddr58, align 8
-  %57 = insertvalue %variant undef, ptr %taddr58, 0
+  %56 = call i64 @std_io_printfn(ptr %retparam28, ptr @.str.60, 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 %varargslots57, i64 0, i64 0
+  %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 %retparam56, ptr @.str.61, i64 7, ptr %varargslots57, i64 1)
-  %not_err59 = icmp eq i64 %60, 0
-  br i1 %not_err59, label %after_check60, label %voiderr61
-
-after_check60:                                    ; preds = %voiderr55
-  br label %voiderr61
-
-voiderr61:                                        ; preds = %after_check60, %voiderr55
-  store i64 8, ptr %taddr64, align 8
-  %61 = insertvalue %variant undef, ptr %taddr64, 0
+  %60 = call i64 @std_io_printfn(ptr %retparam32, ptr @.str.61, 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
-  %63 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 0
+  %63 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 0
   store %variant %62, ptr %63, align 16
-  store i64 4, ptr %taddr65, align 8
-  %64 = insertvalue %variant undef, ptr %taddr65, 0
+  store i64 4, ptr %taddr38, align 8
+  %64 = insertvalue %variant undef, ptr %taddr38, 0
   %65 = insertvalue %variant %64, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %66 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, 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 %retparam62, ptr @.str.62, i64 10, ptr %varargslots63, i64 2)
-  %not_err66 = icmp eq i64 %67, 0
-  br i1 %not_err66, label %after_check67, label %voiderr68
-
-after_check67:                                    ; preds = %voiderr61
-  br label %voiderr68
-
-voiderr68:                                        ; preds = %after_check67, %voiderr61
+  %67 = call i64 @std_io_printfn(ptr %retparam35, ptr @.str.62, 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/compile_time/untyped_conversions.c3t b/test/test_suite/compile_time/untyped_conversions.c3t
index b90c8daae..fd2d4858a 100644
--- a/test/test_suite/compile_time/untyped_conversions.c3t
+++ b/test/test_suite/compile_time/untyped_conversions.c3t
@@ -71,13 +71,6 @@ entry:
   %12 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 2
   store %variant %11, ptr %12, align 16
   %13 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 3)
-  %not_err = icmp eq i64 %13, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   ret void
 }
 
@@ -119,13 +112,6 @@ entry:
   %13 = getelementptr inbounds [4 x %variant], ptr %varargslots, i64 0, i64 3
   store %variant %12, ptr %13, align 16
   %14 = call i64 @std_io_printfn(ptr %retparam, ptr @.str.4, i64 14, ptr %varargslots, i64 4)
-  %not_err = icmp eq i64 %14, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   %15 = getelementptr inbounds [2 x i32], ptr %literal, i64 0, i64 0
   store i32 1, ptr %15, align 4
   %16 = getelementptr inbounds [2 x i32], ptr %literal, i64 0, i64 1
diff --git a/test/test_suite/enumerations/enum_associated_values_other.c3t b/test/test_suite/enumerations/enum_associated_values_other.c3t
index 4f0b08d9e..38b0b69af 100644
--- a/test/test_suite/enumerations/enum_associated_values_other.c3t
+++ b/test/test_suite/enumerations/enum_associated_values_other.c3t
@@ -9,7 +9,7 @@ fn void main(String[] args)
 	int* x = &abc::dabc;
 	Foo a = Foo.DEF;
 	String z = a.val;
-	io::printfln("%s", z);
+	io::printfn("%s", z);
 }
 
 module abc;
@@ -73,12 +73,5 @@ entry:
   %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %5, ptr %6, align 16
   %7 = call i64 @std_io_printfn(ptr %retparam, ptr @.str.2, i64 2, ptr %varargslots, i64 1)
-  %not_err = icmp eq i64 %7, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/enumerations/enum_cast.c3t b/test/test_suite/enumerations/enum_cast.c3t
index 15ad4b8ee..3691246ab 100644
--- a/test/test_suite/enumerations/enum_cast.c3t
+++ b/test/test_suite/enumerations/enum_cast.c3t
@@ -79,21 +79,15 @@ entry:
   %optval = load i64, ptr %xf.f, align 8
   %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
-
 assign_optional:                                  ; preds = %entry
   store i64 %optval, ptr %e.f, align 8
   br label %after_assign
-
 after_check:                                      ; preds = %entry
   %3 = load i8, ptr %xf, align 1
   %uifp1 = uitofp i8 %3 to float
   store float %uifp1, ptr %e, align 4
   store i64 0, ptr %e.f, align 8
   br label %after_assign
-
 after_assign:                                     ; preds = %after_check, %assign_optional
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_assign
   ret void
 }
diff --git a/test/test_suite/errors/error_introspect.c3t b/test/test_suite/errors/error_introspect.c3t
index 56f69b0c5..e574770ef 100644
--- a/test/test_suite/errors/error_introspect.c3t
+++ b/test/test_suite/errors/error_introspect.c3t
@@ -42,8 +42,8 @@ entry:
   %retparam1 = alloca i64, align 8
   %varargslots2 = alloca [1 x %variant], align 16
   %literal3 = alloca [2 x i64], align 16
-  %retparam7 = alloca i64, align 8
-  %varargslots8 = alloca [1 x %variant], align 16
+  %retparam4 = alloca i64, align 8
+  %varargslots5 = alloca [1 x %variant], align 16
   %taddr = alloca i64, align 8
   %0 = getelementptr inbounds [2 x %"char[]"], ptr %literal, i64 0, i64 0
   store %"char[]" { ptr @.str, i64 3 }, ptr %0, align 8
@@ -57,13 +57,6 @@ entry:
   %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %5, ptr %6, align 16
   %7 = call i64 @std_io_printfn(ptr %retparam, ptr @.str.3, i64 13, ptr %varargslots, i64 1)
-  %not_err = icmp eq i64 %7, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   %8 = getelementptr inbounds [2 x i64], ptr %literal3, i64 0, i64 0
   store i64 ptrtoint (ptr @"foo_Foo$BAR" to i64), ptr %8, align 8
   %9 = getelementptr inbounds [2 x i64], ptr %literal3, i64 0, i64 1
@@ -73,25 +66,11 @@ voiderr:                                          ; preds = %after_check, %entry
   %12 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0
   store %variant %11, ptr %12, align 16
   %13 = call i64 @std_io_printfn(ptr %retparam1, ptr @.str.4, i64 14, ptr %varargslots2, i64 1)
-  %not_err4 = icmp eq i64 %13, 0
-  br i1 %not_err4, label %after_check5, label %voiderr6
-
-after_check5:                                     ; preds = %voiderr
-  br label %voiderr6
-
-voiderr6:                                         ; preds = %after_check5, %voiderr
   store i64 2, ptr %taddr, align 8
   %14 = insertvalue %variant undef, ptr %taddr, 0
   %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$long" to i64), 1
-  %16 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
+  %16 = getelementptr inbounds [1 x %variant], ptr %varargslots5, i64 0, i64 0
   store %variant %15, ptr %16, align 16
-  %17 = call i64 @std_io_printfn(ptr %retparam7, ptr @.str.5, i64 16, ptr %varargslots8, i64 1)
-  %not_err9 = icmp eq i64 %17, 0
-  br i1 %not_err9, label %after_check10, label %voiderr11
-
-after_check10:                                    ; preds = %voiderr6
-  br label %voiderr11
-
-voiderr11:                                        ; preds = %after_check10, %voiderr6
+  %17 = call i64 @std_io_printfn(ptr %retparam4, ptr @.str.5, i64 16, ptr %varargslots5, i64 1)
   ret void
 }
diff --git a/test/test_suite/errors/general_error_regression.c3t b/test/test_suite/errors/general_error_regression.c3t
index 92fc03a23..28cd8ee10 100644
--- a/test/test_suite/errors/general_error_regression.c3t
+++ b/test/test_suite/errors/general_error_regression.c3t
@@ -75,87 +75,39 @@ fn void main()
 define void @foo_Foo_hello(ptr %0) #0 {
 entry:
   %x = alloca ptr, align 8
-  %error_var = alloca i64, align 8
   %retparam = alloca i64, align 8
   %result = alloca %File, align 8
   store ptr @.str.12, ptr %x, align 8
-  store i64 0, ptr %error_var, align 8
   %1 = call ptr @std_io_stdout()
   store ptr %1, ptr %result, align 8
   %2 = load ptr, ptr %x, align 8
   %3 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %2, i64 14)
-  %not_err = icmp eq i64 %3, 0
-  br i1 %not_err, label %after_check, label %assign_optional
-
-assign_optional:                                  ; preds = %entry
-  store i64 %3, ptr %error_var, align 8
-  br label %noerr_block
-
-after_check:                                      ; preds = %entry
-  br label %noerr_block
-
-noerr_block:                                      ; preds = %after_check, %assign_optional
-  br label %voiderr
-
-voiderr:                                          ; preds = %noerr_block
   ret void
 }
 
 define void @foo_Bar_hello(ptr %0) #0 {
 entry:
   %x = alloca ptr, align 8
-  %error_var = alloca i64, align 8
   %retparam = alloca i64, align 8
   %result = alloca %File, align 8
   store ptr @.str.13, ptr %x, align 8
-  store i64 0, ptr %error_var, align 8
   %1 = call ptr @std_io_stdout()
   store ptr %1, ptr %result, align 8
   %2 = load ptr, ptr %x, align 8
   %3 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %2, i64 14)
-  %not_err = icmp eq i64 %3, 0
-  br i1 %not_err, label %after_check, label %assign_optional
-
-assign_optional:                                  ; preds = %entry
-  store i64 %3, ptr %error_var, align 8
-  br label %noerr_block
-
-after_check:                                      ; preds = %entry
-  br label %noerr_block
-
-noerr_block:                                      ; preds = %after_check, %assign_optional
-  br label %voiderr
-
-voiderr:                                          ; preds = %noerr_block
   ret void
 }
 
 define void @foo_MyEnum_hello(ptr %0) #0 {
 entry:
   %x = alloca ptr, align 8
-  %error_var = alloca i64, align 8
   %retparam = alloca i64, align 8
   %result = alloca %File, align 8
   store ptr @.str.14, ptr %x, align 8
-  store i64 0, ptr %error_var, align 8
   %1 = call ptr @std_io_stdout()
   store ptr %1, ptr %result, align 8
   %2 = load ptr, ptr %x, align 8
   %3 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %2, i64 17)
-  %not_err = icmp eq i64 %3, 0
-  br i1 %not_err, label %after_check, label %assign_optional
-
-assign_optional:                                  ; preds = %entry
-  store i64 %3, ptr %error_var, align 8
-  br label %noerr_block
-
-after_check:                                      ; preds = %entry
-  br label %noerr_block
-
-noerr_block:                                      ; preds = %after_check, %assign_optional
-  br label %voiderr
-
-voiderr:                                          ; preds = %noerr_block
   ret void
 }
 
diff --git a/test/test_suite/errors/optional_chained_init.c3t b/test/test_suite/errors/optional_chained_init.c3t
index d04e0be32..eb9b5ce48 100644
--- a/test/test_suite/errors/optional_chained_init.c3t
+++ b/test/test_suite/errors/optional_chained_init.c3t
@@ -58,10 +58,10 @@ entry:
   %err3 = alloca i64, align 8
   %retparam12 = alloca i64, align 8
   %varargslots13 = alloca [1 x %variant], align 16
-  %retparam18 = alloca i64, align 8
-  %varargslots19 = alloca [1 x %variant], align 16
-  %retparam26 = alloca i64, align 8
-  %varargslots27 = alloca [1 x %variant], align 16
+  %retparam17 = alloca i64, align 8
+  %varargslots18 = alloca [1 x %variant], align 16
+  %retparam24 = alloca i64, align 8
+  %varargslots25 = alloca [1 x %variant], align 16
   store i32 1, ptr %a, align 4
   store i64 0, ptr %a.f, align 8
   store i64 ptrtoint (ptr @"test_Test$FOO" to i64), ptr %a.f, align 8
@@ -95,16 +95,9 @@ if.then:                                          ; preds = %end_block
   %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %2, ptr %3, align 16
   %4 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 13, ptr %varargslots, i64 1)
-  %not_err1 = icmp eq i64 %4, 0
-  br i1 %not_err1, label %after_check2, label %voiderr
-
-after_check2:                                     ; preds = %if.then
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check2, %if.then
   br label %if.exit
 
-if.exit:                                          ; preds = %voiderr, %end_block
+if.exit:                                          ; preds = %if.then, %end_block
   br label %testblock4
 
 testblock4:                                       ; preds = %if.exit
@@ -123,7 +116,7 @@ after_check8:                                     ; preds = %testblock4
 end_block9:                                       ; preds = %after_check8, %assign_optional7
   %5 = load i64, ptr %err3, align 8
   %neq10 = icmp ne i64 %5, 0
-  br i1 %neq10, label %if.then11, label %if.exit17
+  br i1 %neq10, label %if.then11, label %if.exit16
 
 if.then11:                                        ; preds = %end_block9
   %6 = insertvalue %variant undef, ptr %err3, 0
@@ -131,50 +124,37 @@ if.then11:                                        ; preds = %end_block9
   %8 = getelementptr inbounds [1 x %variant], ptr %varargslots13, i64 0, i64 0
   store %variant %7, ptr %8, align 16
   %9 = call i64 @std_io_printfn(ptr %retparam12, ptr @.str.1, i64 13, ptr %varargslots13, i64 1)
-  %not_err14 = icmp eq i64 %9, 0
-  br i1 %not_err14, label %after_check15, label %voiderr16
+  br label %if.exit16
 
-after_check15:                                    ; preds = %if.then11
-  br label %voiderr16
+if.exit16:                                        ; preds = %if.then11, %end_block9
+  %optval19 = load i64, ptr %a.f, align 8
+  %not_err20 = icmp eq i64 %optval19, 0
+  br i1 %not_err20, label %after_check21, label %after_check23
 
-voiderr16:                                        ; preds = %after_check15, %if.then11
-  br label %if.exit17
-
-if.exit17:                                        ; preds = %voiderr16, %end_block9
-  %optval20 = load i64, ptr %a.f, align 8
-  %not_err21 = icmp eq i64 %optval20, 0
-  br i1 %not_err21, label %after_check22, label %voiderr25
-
-after_check22:                                    ; preds = %if.exit17
+after_check21:                                    ; preds = %if.exit16
   %10 = insertvalue %variant undef, ptr %a, 0
   %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %12 = getelementptr inbounds [1 x %variant], ptr %varargslots19, i64 0, i64 0
+  %12 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0
   store %variant %11, ptr %12, align 16
-  %13 = call i64 @std_io_printfn(ptr %retparam18, ptr @.str.2, i64 9, ptr %varargslots19, i64 1)
-  %not_err23 = icmp eq i64 %13, 0
-  br i1 %not_err23, label %after_check24, label %voiderr25
+  %13 = call i64 @std_io_printfn(ptr %retparam17, ptr @.str.2, i64 9, ptr %varargslots18, i64 1)
+  %not_err22 = icmp eq i64 %13, 0
+  br i1 %not_err22, label %after_check23, label %after_check23
 
-after_check24:                                    ; preds = %after_check22
-  br label %voiderr25
+after_check23:                                    ; preds = %if.exit16, %after_check21, %after_check21
+  %optval26 = load i64, ptr %b.f, align 8
+  %not_err27 = icmp eq i64 %optval26, 0
+  br i1 %not_err27, label %after_check28, label %after_check30
 
-voiderr25:                                        ; preds = %after_check24, %after_check22, %if.exit17
-  %optval28 = load i64, ptr %b.f, align 8
-  %not_err29 = icmp eq i64 %optval28, 0
-  br i1 %not_err29, label %after_check30, label %voiderr33
-
-after_check30:                                    ; preds = %voiderr25
+after_check28:                                    ; preds = %after_check23
   %14 = insertvalue %variant undef, ptr %b, 0
   %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %16 = getelementptr inbounds [1 x %variant], ptr %varargslots27, i64 0, i64 0
+  %16 = getelementptr inbounds [1 x %variant], ptr %varargslots25, i64 0, i64 0
   store %variant %15, ptr %16, align 16
-  %17 = call i64 @std_io_printfn(ptr %retparam26, ptr @.str.3, i64 9, ptr %varargslots27, i64 1)
-  %not_err31 = icmp eq i64 %17, 0
-  br i1 %not_err31, label %after_check32, label %voiderr33
+  %17 = call i64 @std_io_printfn(ptr %retparam24, ptr @.str.3, i64 9, ptr %varargslots25, i64 1)
+  %not_err29 = icmp eq i64 %17, 0
+  br i1 %not_err29, label %after_check30, label %after_check30
 
-after_check32:                                    ; preds = %after_check30
-  br label %voiderr33
-
-voiderr33:                                        ; preds = %after_check32, %after_check30, %voiderr25
+after_check30:                                    ; preds = %after_check23, %after_check28, %after_check28
   ret void
 }
 
@@ -193,10 +173,10 @@ entry:
   %err8 = alloca i64, align 8
   %retparam17 = alloca i64, align 8
   %varargslots18 = alloca [1 x %variant], align 16
-  %retparam23 = alloca i64, align 8
-  %varargslots24 = alloca [1 x %variant], align 16
-  %retparam31 = alloca i64, align 8
-  %varargslots32 = alloca [1 x %variant], align 16
+  %retparam22 = alloca i64, align 8
+  %varargslots23 = alloca [1 x %variant], align 16
+  %retparam29 = alloca i64, align 8
+  %varargslots30 = alloca [1 x %variant], align 16
   store i64 ptrtoint (ptr @"test_Test$FOO" to i64), ptr %x.f, align 8
   store i32 1, ptr %a, align 4
   store i64 0, ptr %a.f, align 8
@@ -251,16 +231,9 @@ if.then:                                          ; preds = %end_block
   %4 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %3, ptr %4, align 16
   %5 = call i64 @std_io_printfn(ptr %retparam, ptr @.str.4, i64 13, ptr %varargslots, i64 1)
-  %not_err6 = icmp eq i64 %5, 0
-  br i1 %not_err6, label %after_check7, label %voiderr
-
-after_check7:                                     ; preds = %if.then
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check7, %if.then
   br label %if.exit
 
-if.exit:                                          ; preds = %voiderr, %end_block
+if.exit:                                          ; preds = %if.then, %end_block
   br label %testblock9
 
 testblock9:                                       ; preds = %if.exit
@@ -279,7 +252,7 @@ after_check13:                                    ; preds = %testblock9
 end_block14:                                      ; preds = %after_check13, %assign_optional12
   %6 = load i64, ptr %err8, align 8
   %neq15 = icmp ne i64 %6, 0
-  br i1 %neq15, label %if.then16, label %if.exit22
+  br i1 %neq15, label %if.then16, label %if.exit21
 
 if.then16:                                        ; preds = %end_block14
   %7 = insertvalue %variant undef, ptr %err8, 0
@@ -287,50 +260,37 @@ if.then16:                                        ; preds = %end_block14
   %9 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0
   store %variant %8, ptr %9, align 16
   %10 = call i64 @std_io_printfn(ptr %retparam17, ptr @.str.5, i64 13, ptr %varargslots18, i64 1)
-  %not_err19 = icmp eq i64 %10, 0
-  br i1 %not_err19, label %after_check20, label %voiderr21
+  br label %if.exit21
 
-after_check20:                                    ; preds = %if.then16
-  br label %voiderr21
+if.exit21:                                        ; preds = %if.then16, %end_block14
+  %optval24 = load i64, ptr %a.f, align 8
+  %not_err25 = icmp eq i64 %optval24, 0
+  br i1 %not_err25, label %after_check26, label %after_check28
 
-voiderr21:                                        ; preds = %after_check20, %if.then16
-  br label %if.exit22
-
-if.exit22:                                        ; preds = %voiderr21, %end_block14
-  %optval25 = load i64, ptr %a.f, align 8
-  %not_err26 = icmp eq i64 %optval25, 0
-  br i1 %not_err26, label %after_check27, label %voiderr30
-
-after_check27:                                    ; preds = %if.exit22
+after_check26:                                    ; preds = %if.exit21
   %11 = insertvalue %variant undef, ptr %a, 0
   %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %13 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0
+  %13 = getelementptr inbounds [1 x %variant], ptr %varargslots23, i64 0, i64 0
   store %variant %12, ptr %13, align 16
-  %14 = call i64 @std_io_printfn(ptr %retparam23, ptr @.str.6, i64 9, ptr %varargslots24, i64 1)
-  %not_err28 = icmp eq i64 %14, 0
-  br i1 %not_err28, label %after_check29, label %voiderr30
+  %14 = call i64 @std_io_printfn(ptr %retparam22, ptr @.str.6, i64 9, ptr %varargslots23, i64 1)
+  %not_err27 = icmp eq i64 %14, 0
+  br i1 %not_err27, label %after_check28, label %after_check28
 
-after_check29:                                    ; preds = %after_check27
-  br label %voiderr30
+after_check28:                                    ; preds = %if.exit21, %after_check26, %after_check26
+  %optval31 = load i64, ptr %b.f, align 8
+  %not_err32 = icmp eq i64 %optval31, 0
+  br i1 %not_err32, label %after_check33, label %after_check35
 
-voiderr30:                                        ; preds = %after_check29, %after_check27, %if.exit22
-  %optval33 = load i64, ptr %b.f, align 8
-  %not_err34 = icmp eq i64 %optval33, 0
-  br i1 %not_err34, label %after_check35, label %voiderr38
-
-after_check35:                                    ; preds = %voiderr30
+after_check33:                                    ; preds = %after_check28
   %15 = insertvalue %variant undef, ptr %b, 0
   %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %17 = getelementptr inbounds [1 x %variant], ptr %varargslots32, i64 0, i64 0
+  %17 = getelementptr inbounds [1 x %variant], ptr %varargslots30, i64 0, i64 0
   store %variant %16, ptr %17, align 16
-  %18 = call i64 @std_io_printfn(ptr %retparam31, ptr @.str.7, i64 9, ptr %varargslots32, i64 1)
-  %not_err36 = icmp eq i64 %18, 0
-  br i1 %not_err36, label %after_check37, label %voiderr38
+  %18 = call i64 @std_io_printfn(ptr %retparam29, ptr @.str.7, i64 9, ptr %varargslots30, i64 1)
+  %not_err34 = icmp eq i64 %18, 0
+  br i1 %not_err34, label %after_check35, label %after_check35
 
-after_check37:                                    ; preds = %after_check35
-  br label %voiderr38
-
-voiderr38:                                        ; preds = %after_check37, %after_check35, %voiderr30
+after_check35:                                    ; preds = %after_check28, %after_check33, %after_check33
   ret void
 }
 
@@ -349,10 +309,10 @@ entry:
   %err8 = alloca i64, align 8
   %retparam17 = alloca i64, align 8
   %varargslots18 = alloca [1 x %variant], align 16
-  %retparam23 = alloca i64, align 8
-  %varargslots24 = alloca [1 x %variant], align 16
-  %retparam31 = alloca i64, align 8
-  %varargslots32 = alloca [1 x %variant], align 16
+  %retparam22 = alloca i64, align 8
+  %varargslots23 = alloca [1 x %variant], align 16
+  %retparam29 = alloca i64, align 8
+  %varargslots30 = alloca [1 x %variant], align 16
   store i32 23, ptr %x, align 4
   store i64 0, ptr %x.f, align 8
   store i32 1, ptr %a, align 4
@@ -408,16 +368,9 @@ if.then:                                          ; preds = %end_block
   %4 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %3, ptr %4, align 16
   %5 = call i64 @std_io_printfn(ptr %retparam, ptr @.str.8, i64 13, ptr %varargslots, i64 1)
-  %not_err6 = icmp eq i64 %5, 0
-  br i1 %not_err6, label %after_check7, label %voiderr
-
-after_check7:                                     ; preds = %if.then
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check7, %if.then
   br label %if.exit
 
-if.exit:                                          ; preds = %voiderr, %end_block
+if.exit:                                          ; preds = %if.then, %end_block
   br label %testblock9
 
 testblock9:                                       ; preds = %if.exit
@@ -436,7 +389,7 @@ after_check13:                                    ; preds = %testblock9
 end_block14:                                      ; preds = %after_check13, %assign_optional12
   %6 = load i64, ptr %err8, align 8
   %neq15 = icmp ne i64 %6, 0
-  br i1 %neq15, label %if.then16, label %if.exit22
+  br i1 %neq15, label %if.then16, label %if.exit21
 
 if.then16:                                        ; preds = %end_block14
   %7 = insertvalue %variant undef, ptr %err8, 0
@@ -444,49 +397,36 @@ if.then16:                                        ; preds = %end_block14
   %9 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0
   store %variant %8, ptr %9, align 16
   %10 = call i64 @std_io_printfn(ptr %retparam17, ptr @.str.9, i64 13, ptr %varargslots18, i64 1)
-  %not_err19 = icmp eq i64 %10, 0
-  br i1 %not_err19, label %after_check20, label %voiderr21
+  br label %if.exit21
 
-after_check20:                                    ; preds = %if.then16
-  br label %voiderr21
+if.exit21:                                        ; preds = %if.then16, %end_block14
+  %optval24 = load i64, ptr %a.f, align 8
+  %not_err25 = icmp eq i64 %optval24, 0
+  br i1 %not_err25, label %after_check26, label %after_check28
 
-voiderr21:                                        ; preds = %after_check20, %if.then16
-  br label %if.exit22
-
-if.exit22:                                        ; preds = %voiderr21, %end_block14
-  %optval25 = load i64, ptr %a.f, align 8
-  %not_err26 = icmp eq i64 %optval25, 0
-  br i1 %not_err26, label %after_check27, label %voiderr30
-
-after_check27:                                    ; preds = %if.exit22
+after_check26:                                    ; preds = %if.exit21
   %11 = insertvalue %variant undef, ptr %a, 0
   %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %13 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0
+  %13 = getelementptr inbounds [1 x %variant], ptr %varargslots23, i64 0, i64 0
   store %variant %12, ptr %13, align 16
-  %14 = call i64 @std_io_printfn(ptr %retparam23, ptr @.str.10, i64 9, ptr %varargslots24, i64 1)
-  %not_err28 = icmp eq i64 %14, 0
-  br i1 %not_err28, label %after_check29, label %voiderr30
+  %14 = call i64 @std_io_printfn(ptr %retparam22, ptr @.str.10, i64 9, ptr %varargslots23, i64 1)
+  %not_err27 = icmp eq i64 %14, 0
+  br i1 %not_err27, label %after_check28, label %after_check28
 
-after_check29:                                    ; preds = %after_check27
-  br label %voiderr30
+after_check28:                                    ; preds = %if.exit21, %after_check26, %after_check26
+  %optval31 = load i64, ptr %b.f, align 8
+  %not_err32 = icmp eq i64 %optval31, 0
+  br i1 %not_err32, label %after_check33, label %after_check35
 
-voiderr30:                                        ; preds = %after_check29, %after_check27, %if.exit22
-  %optval33 = load i64, ptr %b.f, align 8
-  %not_err34 = icmp eq i64 %optval33, 0
-  br i1 %not_err34, label %after_check35, label %voiderr38
-
-after_check35:                                    ; preds = %voiderr30
+after_check33:                                    ; preds = %after_check28
   %15 = insertvalue %variant undef, ptr %b, 0
   %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %17 = getelementptr inbounds [1 x %variant], ptr %varargslots32, i64 0, i64 0
+  %17 = getelementptr inbounds [1 x %variant], ptr %varargslots30, i64 0, i64 0
   store %variant %16, ptr %17, align 16
-  %18 = call i64 @std_io_printfn(ptr %retparam31, ptr @.str.11, i64 9, ptr %varargslots32, i64 1)
-  %not_err36 = icmp eq i64 %18, 0
-  br i1 %not_err36, label %after_check37, label %voiderr38
+  %18 = call i64 @std_io_printfn(ptr %retparam29, ptr @.str.11, i64 9, ptr %varargslots30, i64 1)
+  %not_err34 = icmp eq i64 %18, 0
+  br i1 %not_err34, label %after_check35, label %after_check35
 
-after_check37:                                    ; preds = %after_check35
-  br label %voiderr38
-
-voiderr38:                                        ; preds = %after_check37, %after_check35, %voiderr30
+after_check35:                                    ; preds = %after_check28, %after_check33, %after_check33
   ret void
 }
diff --git a/test/test_suite/errors/optional_inits.c3t b/test/test_suite/errors/optional_inits.c3t
index e21850667..ff044530c 100644
--- a/test/test_suite/errors/optional_inits.c3t
+++ b/test/test_suite/errors/optional_inits.c3t
@@ -94,20 +94,6 @@ noerr_block:                                      ; preds = %after_check
 define void @test_main() #0 {
 entry:
   %0 = call i64 @test_test1()
-  %not_err = icmp eq i64 %0, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   %1 = call i64 @test_test2()
-  %not_err1 = icmp eq i64 %1, 0
-  br i1 %not_err1, label %after_check2, label %voiderr3
-
-after_check2:                                     ; preds = %voiderr
-  br label %voiderr3
-
-voiderr3:                                         ; preds = %after_check2, %voiderr
   ret void
 }
diff --git a/test/test_suite/errors/optional_taddr_and_access.c3t b/test/test_suite/errors/optional_taddr_and_access.c3t
index 1a52cdb0a..922ffcd7e 100644
--- a/test/test_suite/errors/optional_taddr_and_access.c3t
+++ b/test/test_suite/errors/optional_taddr_and_access.c3t
@@ -44,7 +44,7 @@ entry:
   %w = alloca ptr, align 8
   %w.f = alloca i64, align 8
   %literal = alloca %Foo, align 4
-  %literal6 = alloca %Foo, align 4
+  %literal5 = alloca %Foo, align 4
   store i32 2, ptr %z, align 4
   store i64 0, ptr %z.f, align 8
   %0 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 0
@@ -79,42 +79,39 @@ after_check3:                                     ; preds = %after_assign
 
 voiderr:                                          ; preds = %after_check3, %after_assign
   store i64 ptrtoint (ptr @"test_MyErr$FOO" to i64), ptr %z.f, align 8
-  br label %voiderr5
+  br label %after_check4
 
-voiderr5:                                         ; preds = %voiderr
-  %7 = getelementptr inbounds %Foo, ptr %literal6, i32 0, i32 0
-  %optval7 = load i64, ptr %z.f, align 8
-  %not_err8 = icmp eq i64 %optval7, 0
-  br i1 %not_err8, label %after_check10, label %assign_optional9
+after_check4:                                     ; preds = %voiderr
+  %7 = getelementptr inbounds %Foo, ptr %literal5, i32 0, i32 0
+  %optval6 = load i64, ptr %z.f, align 8
+  %not_err7 = icmp eq i64 %optval6, 0
+  br i1 %not_err7, label %after_check9, label %assign_optional8
 
-assign_optional9:                                 ; preds = %voiderr5
-  store i64 %optval7, ptr %w.f, align 8
-  br label %after_assign11
+assign_optional8:                                 ; preds = %after_check4
+  store i64 %optval6, ptr %w.f, align 8
+  br label %after_assign10
 
-after_check10:                                    ; preds = %voiderr5
+after_check9:                                     ; preds = %after_check4
   %8 = load i32, ptr %z, align 4
   store i32 %8, ptr %7, align 4
-  %9 = getelementptr inbounds %Foo, ptr %literal6, i32 0, i32 1
+  %9 = getelementptr inbounds %Foo, ptr %literal5, i32 0, i32 1
   store i32 0, ptr %9, align 4
-  store ptr %literal6, ptr %w, align 8
+  store ptr %literal5, ptr %w, align 8
   store i64 0, ptr %w.f, align 8
-  br label %after_assign11
+  br label %after_assign10
 
-after_assign11:                                   ; preds = %after_check10, %assign_optional9
-  br label %voiderr12
+after_assign10:                                   ; preds = %after_check9, %assign_optional8
+  %optval11 = load i64, ptr %w.f, align 8
+  %not_err12 = icmp eq i64 %optval11, 0
+  br i1 %not_err12, label %after_check13, label %voiderr14
 
-voiderr12:                                        ; preds = %after_assign11
-  %optval13 = load i64, ptr %w.f, align 8
-  %not_err14 = icmp eq i64 %optval13, 0
-  br i1 %not_err14, label %after_check15, label %voiderr16
-
-after_check15:                                    ; preds = %voiderr12
+after_check13:                                    ; preds = %after_assign10
   %10 = load ptr, ptr %w, align 8
   %11 = getelementptr inbounds %Foo, ptr %10, i32 0, i32 0
   %12 = load i32, ptr %11, align 4
   %13 = call i32 (ptr, ...) @printf(ptr @.str.1, i32 %12)
-  br label %voiderr16
+  br label %voiderr14
 
-voiderr16:                                        ; preds = %after_check15, %voiderr12
+voiderr14:                                        ; preds = %after_check13, %after_assign10
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/errors/optional_with_optional.c3t b/test/test_suite/errors/optional_with_optional.c3t
index dcde87ce0..4cf3f44b1 100644
--- a/test/test_suite/errors/optional_with_optional.c3t
+++ b/test/test_suite/errors/optional_with_optional.c3t
@@ -44,26 +44,26 @@ entry:
   %retparam12 = alloca i32, align 4
   %retparam16 = alloca i32, align 4
   %taddr24 = alloca i32, align 4
-  %retparam28 = alloca i64, align 8
-  %varargslots29 = alloca [1 x %variant], align 16
-  %retparam30 = alloca i32, align 4
-  %retparam34 = alloca i32, align 4
-  %taddr42 = alloca i32, align 4
-  %retparam46 = alloca i64, align 8
-  %varargslots47 = alloca [1 x %variant], align 16
-  %taddr48 = alloca i64, align 8
-  %retparam52 = alloca i64, align 8
-  %varargslots53 = alloca [1 x %variant], align 16
-  %taddr54 = alloca i32, align 4
-  %retparam58 = alloca i64, align 8
-  %varargslots59 = alloca [1 x %variant], align 16
-  %taddr60 = alloca i64, align 8
-  %retparam64 = alloca i64, align 8
-  %varargslots65 = alloca [1 x %variant], align 16
+  %retparam27 = alloca i64, align 8
+  %varargslots28 = alloca [1 x %variant], align 16
+  %retparam29 = alloca i32, align 4
+  %retparam33 = alloca i32, align 4
+  %taddr41 = alloca i32, align 4
+  %retparam44 = alloca i64, align 8
+  %varargslots45 = alloca [1 x %variant], align 16
+  %taddr46 = alloca i64, align 8
+  %retparam49 = alloca i64, align 8
+  %varargslots50 = alloca [1 x %variant], align 16
+  %taddr51 = alloca i32, align 4
+  %retparam54 = alloca i64, align 8
+  %varargslots55 = alloca [1 x %variant], align 16
+  %taddr56 = alloca i64, align 8
+  %retparam59 = alloca i64, align 8
+  %varargslots60 = alloca [1 x %variant], align 16
   %error_var = alloca i64, align 8
   %x = alloca i64, align 8
-  %retparam71 = alloca i64, align 8
-  %varargslots72 = alloca [1 x %variant], align 16
+  %retparam65 = alloca i64, align 8
+  %varargslots66 = alloca [1 x %variant], align 16
   %xy = alloca i32, align 4
   %xy.f = alloca i64, align 8
   %0 = call i64 @test_get_a(ptr %retparam1, i32 1)
@@ -98,22 +98,15 @@ phi_block6:                                       ; preds = %else_block5, %phi_b
   %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %5, ptr %6, align 16
   %7 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 4, ptr %varargslots, i64 1)
-  %not_err8 = icmp eq i64 %7, 0
-  br i1 %not_err8, label %after_check9, label %voiderr
-
-after_check9:                                     ; preds = %phi_block6
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check9, %phi_block6
   %8 = call i64 @test_get_a(ptr %retparam12, i32 2)
   %not_err13 = icmp eq i64 %8, 0
   br i1 %not_err13, label %after_check14, label %else_block15
 
-after_check14:                                    ; preds = %voiderr
+after_check14:                                    ; preds = %phi_block6
   %9 = load i32, ptr %retparam12, align 4
   br label %phi_block19
 
-else_block15:                                     ; preds = %voiderr
+else_block15:                                     ; preds = %phi_block6
   %10 = call i64 @test_get_b(ptr %retparam16, i32 4)
   %not_err17 = icmp eq i64 %10, 0
   br i1 %not_err17, label %after_check18, label %else_block21
@@ -137,123 +130,74 @@ phi_block22:                                      ; preds = %else_block21, %phi_
   %14 = getelementptr inbounds [1 x %variant], ptr %varargslots11, i64 0, i64 0
   store %variant %13, ptr %14, align 16
   %15 = call i64 @std_io_printfn(ptr %retparam10, ptr @.str.2, i64 4, ptr %varargslots11, i64 1)
-  %not_err25 = icmp eq i64 %15, 0
-  br i1 %not_err25, label %after_check26, label %voiderr27
+  %16 = call i64 @test_get_a(ptr %retparam29, i32 1)
+  %not_err30 = icmp eq i64 %16, 0
+  br i1 %not_err30, label %after_check31, label %else_block32
 
-after_check26:                                    ; preds = %phi_block22
-  br label %voiderr27
+after_check31:                                    ; preds = %phi_block22
+  %17 = load i32, ptr %retparam29, align 4
+  br label %phi_block36
 
-voiderr27:                                        ; preds = %after_check26, %phi_block22
-  %16 = call i64 @test_get_a(ptr %retparam30, i32 1)
-  %not_err31 = icmp eq i64 %16, 0
-  br i1 %not_err31, label %after_check32, label %else_block33
+else_block32:                                     ; preds = %phi_block22
+  %18 = call i64 @test_get_b(ptr %retparam33, i32 5)
+  %not_err34 = icmp eq i64 %18, 0
+  br i1 %not_err34, label %after_check35, label %else_block38
 
-after_check32:                                    ; preds = %voiderr27
-  %17 = load i32, ptr %retparam30, align 4
-  br label %phi_block37
+after_check35:                                    ; preds = %else_block32
+  %19 = load i32, ptr %retparam33, align 4
+  br label %phi_block36
 
-else_block33:                                     ; preds = %voiderr27
-  %18 = call i64 @test_get_b(ptr %retparam34, i32 5)
-  %not_err35 = icmp eq i64 %18, 0
-  br i1 %not_err35, label %after_check36, label %else_block39
+phi_block36:                                      ; preds = %after_check35, %after_check31
+  %val37 = phi i32 [ %17, %after_check31 ], [ %19, %after_check35 ]
+  br label %phi_block39
 
-after_check36:                                    ; preds = %else_block33
-  %19 = load i32, ptr %retparam34, align 4
-  br label %phi_block37
+else_block38:                                     ; preds = %else_block32
+  br label %phi_block39
 
-phi_block37:                                      ; preds = %after_check36, %after_check32
-  %val38 = phi i32 [ %17, %after_check32 ], [ %19, %after_check36 ]
-  br label %phi_block40
-
-else_block39:                                     ; preds = %else_block33
-  br label %phi_block40
-
-phi_block40:                                      ; preds = %else_block39, %phi_block37
-  %val41 = phi i32 [ %val38, %phi_block37 ], [ -1, %else_block39 ]
-  store i32 %val41, ptr %taddr42, align 4
-  %20 = insertvalue %variant undef, ptr %taddr42, 0
+phi_block39:                                      ; preds = %else_block38, %phi_block36
+  %val40 = phi i32 [ %val37, %phi_block36 ], [ -1, %else_block38 ]
+  store i32 %val40, ptr %taddr41, align 4
+  %20 = insertvalue %variant undef, ptr %taddr41, 0
   %21 = insertvalue %variant %20, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %22 = getelementptr inbounds [1 x %variant], ptr %varargslots29, i64 0, i64 0
+  %22 = getelementptr inbounds [1 x %variant], ptr %varargslots28, i64 0, i64 0
   store %variant %21, ptr %22, align 16
-  %23 = call i64 @std_io_printfn(ptr %retparam28, ptr @.str.3, i64 4, ptr %varargslots29, i64 1)
-  %not_err43 = icmp eq i64 %23, 0
-  br i1 %not_err43, label %after_check44, label %voiderr45
-
-after_check44:                                    ; preds = %phi_block40
-  br label %voiderr45
-
-voiderr45:                                        ; preds = %after_check44, %phi_block40
-  store i64 ptrtoint (ptr @"test_Foo$DEF" to i64), ptr %taddr48, align 8
-  %24 = insertvalue %variant undef, ptr %taddr48, 0
+  %23 = call i64 @std_io_printfn(ptr %retparam27, ptr @.str.3, i64 4, ptr %varargslots28, i64 1)
+  store i64 ptrtoint (ptr @"test_Foo$DEF" to i64), ptr %taddr46, align 8
+  %24 = insertvalue %variant undef, ptr %taddr46, 0
   %25 = insertvalue %variant %24, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
-  %26 = getelementptr inbounds [1 x %variant], ptr %varargslots47, i64 0, i64 0
+  %26 = getelementptr inbounds [1 x %variant], ptr %varargslots45, i64 0, i64 0
   store %variant %25, ptr %26, align 16
-  %27 = call i64 @std_io_printfn(ptr %retparam46, ptr @.str.4, i64 4, ptr %varargslots47, i64 1)
-  %not_err49 = icmp eq i64 %27, 0
-  br i1 %not_err49, label %after_check50, label %voiderr51
-
-after_check50:                                    ; preds = %voiderr45
-  br label %voiderr51
-
-voiderr51:                                        ; preds = %after_check50, %voiderr45
-  store i32 3, ptr %taddr54, align 4
-  %28 = insertvalue %variant undef, ptr %taddr54, 0
+  %27 = call i64 @std_io_printfn(ptr %retparam44, ptr @.str.4, i64 4, ptr %varargslots45, i64 1)
+  store i32 3, ptr %taddr51, align 4
+  %28 = insertvalue %variant undef, ptr %taddr51, 0
   %29 = insertvalue %variant %28, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %30 = getelementptr inbounds [1 x %variant], ptr %varargslots53, i64 0, i64 0
+  %30 = getelementptr inbounds [1 x %variant], ptr %varargslots50, i64 0, i64 0
   store %variant %29, ptr %30, align 16
-  %31 = call i64 @std_io_printfn(ptr %retparam52, ptr @.str.5, i64 4, ptr %varargslots53, i64 1)
-  %not_err55 = icmp eq i64 %31, 0
-  br i1 %not_err55, label %after_check56, label %voiderr57
-
-after_check56:                                    ; preds = %voiderr51
-  br label %voiderr57
-
-voiderr57:                                        ; preds = %after_check56, %voiderr51
-  store i64 ptrtoint (ptr @"test_Foo$DEF" to i64), ptr %taddr60, align 8
-  %32 = insertvalue %variant undef, ptr %taddr60, 0
+  %31 = call i64 @std_io_printfn(ptr %retparam49, ptr @.str.5, i64 4, ptr %varargslots50, i64 1)
+  store i64 ptrtoint (ptr @"test_Foo$DEF" to i64), ptr %taddr56, align 8
+  %32 = insertvalue %variant undef, ptr %taddr56, 0
   %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
-  %34 = getelementptr inbounds [1 x %variant], ptr %varargslots59, i64 0, i64 0
+  %34 = getelementptr inbounds [1 x %variant], ptr %varargslots55, i64 0, i64 0
   store %variant %33, ptr %34, align 16
-  %35 = call i64 @std_io_printfn(ptr %retparam58, ptr @.str.6, i64 4, ptr %varargslots59, i64 1)
-  %not_err61 = icmp eq i64 %35, 0
-  br i1 %not_err61, label %after_check62, label %voiderr63
-
-after_check62:                                    ; preds = %voiderr57
-  br label %voiderr63
-
-voiderr63:                                        ; preds = %after_check62, %voiderr57
+  %35 = call i64 @std_io_printfn(ptr %retparam54, ptr @.str.6, i64 4, ptr %varargslots55, i64 1)
   store i64 0, ptr %error_var, align 8
-  br label %phi_block67
+  br label %phi_block62
 
-phi_block67:                                      ; preds = %voiderr63
+phi_block62:                                      ; preds = %phi_block39
   br label %noerr_block
 
-noerr_block:                                      ; preds = %phi_block67
+noerr_block:                                      ; preds = %phi_block62
   %36 = insertvalue %variant undef, ptr %error_var, 0
   %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
-  %38 = getelementptr inbounds [1 x %variant], ptr %varargslots65, i64 0, i64 0
+  %38 = getelementptr inbounds [1 x %variant], ptr %varargslots60, i64 0, i64 0
   store %variant %37, ptr %38, align 16
-  %39 = call i64 @std_io_printfn(ptr %retparam64, ptr @.str.7, i64 4, ptr %varargslots65, i64 1)
-  %not_err68 = icmp eq i64 %39, 0
-  br i1 %not_err68, label %after_check69, label %voiderr70
-
-after_check69:                                    ; preds = %noerr_block
-  br label %voiderr70
-
-voiderr70:                                        ; preds = %after_check69, %noerr_block
+  %39 = call i64 @std_io_printfn(ptr %retparam59, ptr @.str.7, i64 4, ptr %varargslots60, i64 1)
   store i64 3, ptr %x, align 8
   %40 = insertvalue %variant undef, ptr %x, 0
   %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$long" to i64), 1
-  %42 = getelementptr inbounds [1 x %variant], ptr %varargslots72, i64 0, i64 0
+  %42 = getelementptr inbounds [1 x %variant], ptr %varargslots66, i64 0, i64 0
   store %variant %41, ptr %42, align 16
-  %43 = call i64 @std_io_printfn(ptr %retparam71, ptr @.str.8, i64 4, ptr %varargslots72, i64 1)
-  %not_err73 = icmp eq i64 %43, 0
-  br i1 %not_err73, label %after_check74, label %voiderr75
-
-after_check74:                                    ; preds = %voiderr70
-  br label %voiderr75
-
-voiderr75:                                        ; preds = %after_check74, %voiderr70
+  %43 = call i64 @std_io_printfn(ptr %retparam65, ptr @.str.8, i64 4, ptr %varargslots66, i64 1)
   store i64 ptrtoint (ptr @"test_Foo$DEF" to i64), ptr %xy.f, align 8
   ret void
 }
diff --git a/test/test_suite/errors/or_and_rethrow.c3t b/test/test_suite/errors/or_and_rethrow.c3t
index 645c3607e..21fe318bf 100644
--- a/test/test_suite/errors/or_and_rethrow.c3t
+++ b/test/test_suite/errors/or_and_rethrow.c3t
@@ -47,23 +47,19 @@ entry:
   %error_var = alloca i64, align 8
   %blockret = alloca i32, align 4
   %x = alloca ptr, align 8
-  %error_var1 = alloca i64, align 8
-  %retparam2 = alloca i64, align 8
+  %retparam1 = alloca i64, align 8
   %result = alloca %File, align 8
-  %x6 = alloca ptr, align 8
-  %error_var7 = alloca i64, align 8
-  %retparam8 = alloca i64, align 8
-  %result9 = alloca %File, align 8
-  %error_var15 = alloca i64, align 8
-  %blockret16 = alloca i32, align 4
-  %x21 = alloca ptr, align 8
-  %error_var22 = alloca i64, align 8
-  %retparam23 = alloca i64, align 8
-  %result24 = alloca %File, align 8
-  %x31 = alloca ptr, align 8
-  %error_var32 = alloca i64, align 8
-  %retparam33 = alloca i64, align 8
-  %result34 = alloca %File, align 8
+  %x2 = alloca ptr, 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
   %reterr = alloca i64, align 8
   store i32 %0, ptr %taddr, align 4
   %1 = insertvalue %variant undef, ptr %taddr, 0
@@ -71,17 +67,10 @@ entry:
   %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %2, ptr %3, align 16
   %4 = call i64 @std_io_printfn(ptr %retparam, ptr @.str.1, i64 8, ptr %varargslots, i64 1)
-  %not_err = icmp eq i64 %4, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   %intbool = icmp ne i32 %0, 0
   br i1 %intbool, label %or.phi, label %or.rhs
 
-or.rhs:                                           ; preds = %voiderr
+or.rhs:                                           ; preds = %entry
   store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var, align 8
   br label %opt_block_cleanup
 
@@ -93,108 +82,40 @@ guard_block:                                      ; preds = %opt_block_cleanup
   %5 = load i64, ptr %error_var, align 8
   ret i64 %5
 
-or.phi:                                           ; preds = %voiderr
+or.phi:                                           ; preds = %entry
   br label %if.then
 
 if.then:                                          ; preds = %or.phi
   store ptr @.str.2, ptr %x, align 8
-  store i64 0, ptr %error_var1, align 8
   %6 = call ptr @std_io_stdout()
   store ptr %6, ptr %result, align 8
   %7 = load ptr, ptr %x, align 8
-  %8 = call i64 @std_io_File_printn(ptr %retparam2, ptr %result, ptr %7, i64 3)
-  %not_err3 = icmp eq i64 %8, 0
-  br i1 %not_err3, label %after_check4, label %assign_optional
-
-assign_optional:                                  ; preds = %if.then
-  store i64 %8, ptr %error_var1, align 8
-  br label %noerr_block
-
-after_check4:                                     ; preds = %if.then
-  br label %noerr_block
-
-noerr_block:                                      ; preds = %after_check4, %assign_optional
-  br label %voiderr5
-
-voiderr5:                                         ; preds = %noerr_block
+  %8 = call i64 @std_io_File_printn(ptr %retparam1, ptr %result, ptr %7, i64 3)
   br label %if.exit
 
-if.exit:                                          ; preds = %voiderr5
-  store ptr @.str.3, ptr %x6, align 8
-  store i64 0, ptr %error_var7, align 8
+if.exit:                                          ; preds = %if.then
+  store ptr @.str.3, ptr %x2, align 8
   %9 = call ptr @std_io_stdout()
-  store ptr %9, ptr %result9, align 8
-  %10 = load ptr, ptr %x6, align 8
-  %11 = call i64 @std_io_File_printn(ptr %retparam8, ptr %result9, ptr %10, i64 9)
-  %not_err10 = icmp eq i64 %11, 0
-  br i1 %not_err10, label %after_check12, label %assign_optional11
+  store ptr %9, ptr %result4, align 8
+  %10 = load ptr, ptr %x2, align 8
+  %11 = call i64 @std_io_File_printn(ptr %retparam3, ptr %result4, ptr %10, i64 9)
+  store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var5, align 8
+  br label %opt_block_cleanup7
 
-assign_optional11:                                ; preds = %if.exit
-  store i64 %11, ptr %error_var7, align 8
-  br label %noerr_block13
-
-after_check12:                                    ; preds = %if.exit
-  br label %noerr_block13
-
-noerr_block13:                                    ; preds = %after_check12, %assign_optional11
-  br label %voiderr14
-
-voiderr14:                                        ; preds = %noerr_block13
-  store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var15, align 8
-  br label %opt_block_cleanup17
-
-opt_block_cleanup17:                              ; preds = %voiderr14
+opt_block_cleanup7:                               ; preds = %if.exit
   call void @foo_blurb()
-  br label %guard_block18
+  br label %guard_block8
 
-guard_block18:                                    ; preds = %opt_block_cleanup17
-  %12 = load i64, ptr %error_var15, align 8
+guard_block8:                                     ; preds = %opt_block_cleanup7
+  %12 = load i64, ptr %error_var5, align 8
   ret i64 %12
 
-if.then20:                                        ; No predecessors!
-  store ptr @.str.4, ptr %x21, align 8
-  store i64 0, ptr %error_var22, align 8
+if.exit13:                                        ; No predecessors!
+  store ptr @.str.5, ptr %x14, align 8
   %13 = call ptr @std_io_stdout()
-  store ptr %13, ptr %result24, align 8
-  %14 = load ptr, ptr %x21, align 8
-  %15 = call i64 @std_io_File_printn(ptr %retparam23, ptr %result24, ptr %14, i64 3)
-  %not_err25 = icmp eq i64 %15, 0
-  br i1 %not_err25, label %after_check27, label %assign_optional26
-
-assign_optional26:                                ; preds = %if.then20
-  store i64 %15, ptr %error_var22, align 8
-  br label %noerr_block28
-
-after_check27:                                    ; preds = %if.then20
-  br label %noerr_block28
-
-noerr_block28:                                    ; preds = %after_check27, %assign_optional26
-  br label %voiderr29
-
-voiderr29:                                        ; preds = %noerr_block28
-  br label %if.exit30
-
-if.exit30:                                        ; preds = %voiderr29
-  store ptr @.str.5, ptr %x31, align 8
-  store i64 0, ptr %error_var32, align 8
-  %16 = call ptr @std_io_stdout()
-  store ptr %16, ptr %result34, align 8
-  %17 = load ptr, ptr %x31, align 8
-  %18 = call i64 @std_io_File_printn(ptr %retparam33, ptr %result34, ptr %17, i64 7)
-  %not_err35 = icmp eq i64 %18, 0
-  br i1 %not_err35, label %after_check37, label %assign_optional36
-
-assign_optional36:                                ; preds = %if.exit30
-  store i64 %18, ptr %error_var32, align 8
-  br label %noerr_block38
-
-after_check37:                                    ; preds = %if.exit30
-  br label %noerr_block38
-
-noerr_block38:                                    ; preds = %after_check37, %assign_optional36
-  br label %voiderr39
-
-voiderr39:                                        ; preds = %noerr_block38
+  store ptr %13, ptr %result16, align 8
+  %14 = load ptr, ptr %x14, align 8
+  %15 = call i64 @std_io_File_printn(ptr %retparam15, ptr %result16, ptr %14, i64 7)
   ret i64 0
 }
 
@@ -207,15 +128,13 @@ entry:
   %error_var = alloca i64, align 8
   %blockret = alloca i32, align 4
   %x = alloca ptr, align 8
-  %error_var1 = alloca i64, align 8
-  %retparam2 = alloca i64, align 8
+  %retparam1 = alloca i64, align 8
   %result = alloca %File, align 8
-  %error_var6 = alloca i64, align 8
-  %blockret7 = alloca i32, align 4
-  %x12 = alloca ptr, align 8
-  %error_var13 = alloca i64, align 8
-  %retparam14 = alloca i64, align 8
-  %result15 = alloca %File, align 8
+  %error_var2 = alloca i64, align 8
+  %blockret3 = alloca i32, align 4
+  %x7 = alloca ptr, align 8
+  %retparam8 = alloca i64, align 8
+  %result9 = alloca %File, align 8
   %reterr = alloca i64, align 8
   store i32 %0, ptr %taddr, align 4
   %1 = insertvalue %variant undef, ptr %taddr, 0
@@ -223,17 +142,10 @@ entry:
   %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %2, ptr %3, align 16
   %4 = call i64 @std_io_printfn(ptr %retparam, ptr @.str.6, i64 9, ptr %varargslots, i64 1)
-  %not_err = icmp eq i64 %4, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   %intbool = icmp ne i32 %0, 0
   br i1 %intbool, label %and.rhs, label %and.phi
 
-and.rhs:                                          ; preds = %voiderr
+and.rhs:                                          ; preds = %entry
   store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var, align 8
   br label %opt_block_cleanup
 
@@ -245,61 +157,127 @@ guard_block:                                      ; preds = %opt_block_cleanup
   %5 = load i64, ptr %error_var, align 8
   ret i64 %5
 
-and.phi:                                          ; preds = %voiderr
+and.phi:                                          ; preds = %entry
   br label %if.exit
 
 if.exit:                                          ; preds = %and.phi
   store ptr @.str.7, ptr %x, align 8
-  store i64 0, ptr %error_var1, align 8
   %6 = call ptr @std_io_stdout()
   store ptr %6, ptr %result, align 8
   %7 = load ptr, ptr %x, align 8
-  %8 = call i64 @std_io_File_printn(ptr %retparam2, ptr %result, ptr %7, i64 9)
-  %not_err3 = icmp eq i64 %8, 0
-  br i1 %not_err3, label %after_check4, label %assign_optional
+  %8 = call i64 @std_io_File_printn(ptr %retparam1, ptr %result, ptr %7, i64 9)
+  store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var2, align 8
+  br label %opt_block_cleanup4
 
-assign_optional:                                  ; preds = %if.exit
-  store i64 %8, ptr %error_var1, align 8
-  br label %noerr_block
-
-after_check4:                                     ; preds = %if.exit
-  br label %noerr_block
-
-noerr_block:                                      ; preds = %after_check4, %assign_optional
-  br label %voiderr5
-
-voiderr5:                                         ; preds = %noerr_block
-  store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var6, align 8
-  br label %opt_block_cleanup8
-
-opt_block_cleanup8:                               ; preds = %voiderr5
+opt_block_cleanup4:                               ; preds = %if.exit
   call void @foo_blurb()
-  br label %guard_block9
+  br label %guard_block5
 
-guard_block9:                                     ; preds = %opt_block_cleanup8
-  %9 = load i64, ptr %error_var6, align 8
+guard_block5:                                     ; preds = %opt_block_cleanup4
+  %9 = load i64, ptr %error_var2, align 8
   ret i64 %9
 
-if.exit11:                                        ; No predecessors!
-  store ptr @.str.8, ptr %x12, align 8
-  store i64 0, ptr %error_var13, align 8
+if.exit6:                                         ; No predecessors!
+  store ptr @.str.8, ptr %x7, align 8
   %10 = call ptr @std_io_stdout()
-  store ptr %10, ptr %result15, align 8
-  %11 = load ptr, ptr %x12, align 8
-  %12 = call i64 @std_io_File_printn(ptr %retparam14, ptr %result15, ptr %11, i64 7)
-  %not_err16 = icmp eq i64 %12, 0
-  br i1 %not_err16, label %after_check18, label %assign_optional17
-
-assign_optional17:                                ; preds = %if.exit11
-  store i64 %12, ptr %error_var13, align 8
-  br label %noerr_block19
-
-after_check18:                                    ; preds = %if.exit11
-  br label %noerr_block19
-
-noerr_block19:                                    ; preds = %after_check18, %assign_optional17
-  br label %voiderr20
-
-voiderr20:                                        ; preds = %noerr_block19
+  store ptr %10, ptr %result9, align 8
+  %11 = load ptr, ptr %x7, align 8
+  %12 = call i64 @std_io_File_printn(ptr %retparam8, ptr %result9, ptr %11, i64 7)
   ret i64 0
 }
+
+; Function Attrs: nounwind
+define void @foo_main() #0 {
+entry:
+  %a = alloca i64, align 8
+  %error_var = alloca i64, align 8
+  %b = alloca i64, align 8
+  %error_var1 = alloca i64, align 8
+  %c = alloca i64, align 8
+  %error_var6 = alloca i64, align 8
+  %d = alloca i64, align 8
+  %error_var11 = alloca i64, align 8
+  store i64 0, ptr %error_var, align 8
+  %0 = call i64 @foo_test(i32 0)
+  %not_err = icmp eq i64 %0, 0
+  br i1 %not_err, label %after_check, label %assign_optional
+
+assign_optional:                                  ; preds = %entry
+  store i64 %0, ptr %error_var, align 8
+  br label %noerr_block
+
+after_check:                                      ; preds = %entry
+  br label %noerr_block
+
+noerr_block:                                      ; preds = %after_check, %assign_optional
+  %1 = load i64, ptr %error_var, align 8
+  store i64 %1, ptr %a, align 8
+  store i64 0, ptr %error_var1, align 8
+  %2 = call i64 @foo_test(i32 1)
+  %not_err2 = icmp eq i64 %2, 0
+  br i1 %not_err2, label %after_check4, label %assign_optional3
+
+assign_optional3:                                 ; preds = %noerr_block
+  store i64 %2, ptr %error_var1, align 8
+  br label %noerr_block5
+
+after_check4:                                     ; preds = %noerr_block
+  br label %noerr_block5
+
+noerr_block5:                                     ; preds = %after_check4, %assign_optional3
+  %3 = load i64, ptr %error_var1, align 8
+  store i64 %3, ptr %b, align 8
+  store i64 0, ptr %error_var6, align 8
+  %4 = call i64 @foo_test2(i32 0)
+  %not_err7 = icmp eq i64 %4, 0
+  br i1 %not_err7, label %after_check9, label %assign_optional8
+
+assign_optional8:                                 ; preds = %noerr_block5
+  store i64 %4, ptr %error_var6, align 8
+  br label %noerr_block10
+
+after_check9:                                     ; preds = %noerr_block5
+  br label %noerr_block10
+
+noerr_block10:                                    ; preds = %after_check9, %assign_optional8
+  %5 = load i64, ptr %error_var6, align 8
+  store i64 %5, ptr %c, align 8
+  store i64 0, ptr %error_var11, align 8
+  %6 = call i64 @foo_test2(i32 1)
+  %not_err12 = icmp eq i64 %6, 0
+  br i1 %not_err12, label %after_check14, label %assign_optional13
+
+assign_optional13:                                ; preds = %noerr_block10
+  store i64 %6, ptr %error_var11, align 8
+  br label %noerr_block15
+
+after_check14:                                    ; preds = %noerr_block10
+  br label %noerr_block15
+
+noerr_block15:                                    ; preds = %after_check14, %assign_optional13
+  %7 = load i64, ptr %error_var11, align 8
+  store i64 %7, ptr %d, align 8
+  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 @foo_main()
+  ret i32 0
+}
+
+; Function Attrs: nounwind
+declare i64 @std_io_File_printn(ptr, ptr, ptr, i64) #0
+
+; Function Attrs: nounwind
+declare ptr @std_io_stdout() #0
+
+; Function Attrs: nounwind
+declare i64 @std_io_printfn(ptr, ptr, i64, ptr, i64) #0
+
+attributes #0 = { nounwind }
diff --git a/test/test_suite/errors/printing_errors.c3t b/test/test_suite/errors/printing_errors.c3t
index 35623daea..a2145a885 100644
--- a/test/test_suite/errors/printing_errors.c3t
+++ b/test/test_suite/errors/printing_errors.c3t
@@ -48,12 +48,5 @@ faultname_exit:                                   ; preds = %faultname_ok, %faul
   %8 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %7, ptr %8, align 16
   %9 = call i64 @std_io_printf(ptr %retparam, ptr @.str, i64 6, ptr %varargslots, i64 2)
-  %not_err = icmp eq i64 %9, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %faultname_exit
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %faultname_exit
   ret void
 }
diff --git a/test/test_suite/expressions/chained_ternary.c3t b/test/test_suite/expressions/chained_ternary.c3t
index 2e0bf0daf..594b06c94 100644
--- a/test/test_suite/expressions/chained_ternary.c3t
+++ b/test/test_suite/expressions/chained_ternary.c3t
@@ -106,14 +106,11 @@ cond.phi18:                                       ; preds = %after_check17, %con
   br label %after_assign20
 
 after_assign20:                                   ; preds = %cond.phi18, %assign_optional16
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_assign20
   %11 = load ptr, ptr %a, align 8
   %not21 = icmp eq ptr %11, null
   br i1 %not21, label %cond.lhs22, label %cond.rhs27
 
-cond.lhs22:                                       ; preds = %voiderr
+cond.lhs22:                                       ; preds = %after_assign20
   %optval23 = load i64, ptr %x.f, align 8
   %not_err24 = icmp eq i64 %optval23, 0
   br i1 %not_err24, label %after_check26, label %assign_optional25
@@ -126,7 +123,7 @@ after_check26:                                    ; preds = %cond.lhs22
   %12 = load ptr, ptr %x, align 8
   br label %cond.phi32
 
-cond.rhs27:                                       ; preds = %voiderr
+cond.rhs27:                                       ; preds = %after_assign20
   %optval28 = load i64, ptr %x.f, align 8
   %not_err29 = icmp eq i64 %optval28, 0
   br i1 %not_err29, label %after_check31, label %assign_optional30
@@ -146,84 +143,72 @@ cond.phi32:                                       ; preds = %after_check31, %aft
   br label %after_assign34
 
 after_assign34:                                   ; preds = %cond.phi32, %assign_optional30, %assign_optional25
-  br label %voiderr35
-
-voiderr35:                                        ; preds = %after_assign34
   %14 = load ptr, ptr %a, align 8
-  %not36 = icmp eq ptr %14, null
-  br i1 %not36, label %cond.lhs37, label %cond.rhs42
+  %not35 = icmp eq ptr %14, null
+  br i1 %not35, label %cond.lhs36, label %cond.rhs41
 
-cond.lhs37:                                       ; preds = %voiderr35
-  %optval38 = load i64, ptr %x.f, align 8
-  %not_err39 = icmp eq i64 %optval38, 0
-  br i1 %not_err39, label %after_check41, label %assign_optional40
+cond.lhs36:                                       ; preds = %after_assign34
+  %optval37 = load i64, ptr %x.f, align 8
+  %not_err38 = icmp eq i64 %optval37, 0
+  br i1 %not_err38, label %after_check40, label %assign_optional39
 
-assign_optional40:                                ; preds = %cond.lhs37
-  store i64 %optval38, ptr %y.f, align 8
-  br label %after_assign44
+assign_optional39:                                ; preds = %cond.lhs36
+  store i64 %optval37, ptr %y.f, align 8
+  br label %after_assign43
 
-after_check41:                                    ; preds = %cond.lhs37
+after_check40:                                    ; preds = %cond.lhs36
   %15 = load ptr, ptr %x, align 8
-  br label %cond.phi43
+  br label %cond.phi42
 
-cond.rhs42:                                       ; preds = %voiderr35
+cond.rhs41:                                       ; preds = %after_assign34
   store i64 ptrtoint (ptr @"test_Test$FOO" to i64), ptr %y.f, align 8
-  br label %after_assign44
+  br label %after_assign43
 
-cond.phi43:                                       ; preds = %after_check41
+cond.phi42:                                       ; preds = %after_check40
   store ptr %15, ptr %y, align 8
   store i64 0, ptr %y.f, align 8
-  br label %after_assign44
+  br label %after_assign43
 
-after_assign44:                                   ; preds = %cond.phi43, %cond.rhs42, %assign_optional40
-  br label %voiderr45
-
-voiderr45:                                        ; preds = %after_assign44
+after_assign43:                                   ; preds = %cond.phi42, %cond.rhs41, %assign_optional39
   %16 = load ptr, ptr %a, align 8
-  %not46 = icmp eq ptr %16, null
-  br i1 %not46, label %cond.lhs47, label %cond.rhs48
+  %not44 = icmp eq ptr %16, null
+  br i1 %not44, label %cond.lhs45, label %cond.rhs46
 
-cond.lhs47:                                       ; preds = %voiderr45
+cond.lhs45:                                       ; preds = %after_assign43
   store i64 ptrtoint (ptr @"test_Test$FOO" to i64), ptr %y.f, align 8
-  br label %after_assign54
+  br label %after_assign52
 
-cond.rhs48:                                       ; preds = %voiderr45
-  %optval49 = load i64, ptr %x.f, align 8
-  %not_err50 = icmp eq i64 %optval49, 0
-  br i1 %not_err50, label %after_check52, label %assign_optional51
+cond.rhs46:                                       ; preds = %after_assign43
+  %optval47 = load i64, ptr %x.f, align 8
+  %not_err48 = icmp eq i64 %optval47, 0
+  br i1 %not_err48, label %after_check50, label %assign_optional49
 
-assign_optional51:                                ; preds = %cond.rhs48
-  store i64 %optval49, ptr %y.f, align 8
-  br label %after_assign54
+assign_optional49:                                ; preds = %cond.rhs46
+  store i64 %optval47, ptr %y.f, align 8
+  br label %after_assign52
 
-after_check52:                                    ; preds = %cond.rhs48
+after_check50:                                    ; preds = %cond.rhs46
   %17 = load ptr, ptr %x, align 8
-  br label %cond.phi53
+  br label %cond.phi51
 
-cond.phi53:                                       ; preds = %after_check52
+cond.phi51:                                       ; preds = %after_check50
   store ptr %17, ptr %y, align 8
   store i64 0, ptr %y.f, align 8
-  br label %after_assign54
+  br label %after_assign52
 
-after_assign54:                                   ; preds = %cond.phi53, %assign_optional51, %cond.lhs47
-  br label %voiderr55
-
-voiderr55:                                        ; preds = %after_assign54
+after_assign52:                                   ; preds = %cond.phi51, %assign_optional49, %cond.lhs45
   %18 = load ptr, ptr %a, align 8
-  %not56 = icmp eq ptr %18, null
-  br i1 %not56, label %cond.lhs57, label %cond.rhs58
+  %not53 = icmp eq ptr %18, null
+  br i1 %not53, label %cond.lhs54, label %cond.rhs55
 
-cond.lhs57:                                       ; preds = %voiderr55
+cond.lhs54:                                       ; preds = %after_assign52
   store i64 ptrtoint (ptr @"test_Test$FOO" to i64), ptr %y.f, align 8
-  br label %after_assign60
+  br label %after_assign57
 
-cond.rhs58:                                       ; preds = %voiderr55
+cond.rhs55:                                       ; preds = %after_assign52
   store i64 ptrtoint (ptr @"test_Test$BAR" to i64), ptr %y.f, align 8
-  br label %after_assign60
+  br label %after_assign57
 
-after_assign60:                                   ; preds = %cond.rhs58, %cond.lhs57
-  br label %voiderr61
-
-voiderr61:                                        ; preds = %after_assign60
+after_assign57:                                   ; preds = %cond.rhs55, %cond.lhs54
   ret void
 }
\ 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 bd35d768b..7084adcfc 100644
--- a/test/test_suite/from_docs/examples_defer.c3t
+++ b/test/test_suite/from_docs/examples_defer.c3t
@@ -30,192 +30,57 @@ entry:
 
 if.then:                                          ; preds = %entry
   store ptr @.str, ptr %x, align 8
-  store i64 0, ptr %error_var, align 8
   %1 = call ptr @std_io_stdout()
   store ptr %1, ptr %result, align 8
   %2 = load ptr, ptr %x, align 8
   %3 = call i64 @std_io_File_print(ptr %retparam, ptr %result, ptr %2, i64 1)
-  %not_err = icmp eq i64 %3, 0
-  br i1 %not_err, label %after_check, label %assign_optional
-
-assign_optional:                                  ; preds = %if.then
-  store i64 %3, ptr %error_var, align 8
-  br label %noerr_block
-
-after_check:                                      ; preds = %if.then
-  br label %noerr_block
-
-noerr_block:                                      ; preds = %after_check, %assign_optional
-  br label %voiderr
-
-voiderr:                                          ; preds = %noerr_block
   store ptr @.str.1, ptr %x1, align 8
-  store i64 0, ptr %error_var2, align 8
   %4 = call ptr @std_io_stdout()
-  store ptr %4, ptr %result4, align 8
-  %5 = call i64 @std_io_File_printn(ptr %retparam3, ptr %result4, ptr null, i64 0)
-  %not_err5 = icmp eq i64 %5, 0
-  br i1 %not_err5, label %after_check7, label %assign_optional6
-
-assign_optional6:                                 ; preds = %voiderr
-  store i64 %5, ptr %error_var2, align 8
-  br label %noerr_block8
-
-after_check7:                                     ; preds = %voiderr
-  br label %noerr_block8
-
-noerr_block8:                                     ; preds = %after_check7, %assign_optional6
-  br label %voiderr9
-
-voiderr9:                                         ; preds = %noerr_block8
+  store ptr %4, ptr %result3, align 8
+  %5 = call i64 @std_io_File_printn(ptr %retparam2, ptr %result3, ptr null, i64 0)
   ret void
 
 if.exit:                                          ; preds = %entry
-  %eq10 = icmp eq i32 %0, 0
-  br i1 %eq10, label %if.then11, label %if.exit39
+  %eq4 = icmp eq i32 %0, 0
+  br i1 %eq4, label %if.then5, label %if.exit15
 
-if.then11:                                        ; preds = %if.exit
-  store ptr @.str.2, ptr %x12, align 8
-  store i64 0, ptr %error_var13, align 8
+if.then5:                                         ; preds = %if.exit
+  store ptr @.str.2, ptr %x6, align 8
   %6 = call ptr @std_io_stdout()
-  store ptr %6, ptr %result15, align 8
-  %7 = load ptr, ptr %x12, align 8
-  %8 = call i64 @std_io_File_print(ptr %retparam14, ptr %result15, ptr %7, i64 1)
-  %not_err16 = icmp eq i64 %8, 0
-  br i1 %not_err16, label %after_check18, label %assign_optional17
-
-assign_optional17:                                ; preds = %if.then11
-  store i64 %8, ptr %error_var13, align 8
-  br label %noerr_block19
-
-after_check18:                                    ; preds = %if.then11
-  br label %noerr_block19
-
-noerr_block19:                                    ; preds = %after_check18, %assign_optional17
-  br label %voiderr20
-
-voiderr20:                                        ; preds = %noerr_block19
-  store ptr @.str.3, ptr %x21, align 8
-  store i64 0, ptr %error_var22, align 8
+  store ptr %6, ptr %result8, align 8
+  %7 = load ptr, ptr %x6, align 8
+  %8 = call i64 @std_io_File_print(ptr %retparam7, ptr %result8, ptr %7, i64 1)
+  store ptr @.str.3, ptr %x9, align 8
   %9 = call ptr @std_io_stdout()
-  store ptr %9, ptr %result24, align 8
-  %10 = load ptr, ptr %x21, align 8
-  %11 = call i64 @std_io_File_print(ptr %retparam23, ptr %result24, ptr %10, i64 1)
-  %not_err25 = icmp eq i64 %11, 0
-  br i1 %not_err25, label %after_check27, label %assign_optional26
-
-assign_optional26:                                ; preds = %voiderr20
-  store i64 %11, ptr %error_var22, align 8
-  br label %noerr_block28
-
-after_check27:                                    ; preds = %voiderr20
-  br label %noerr_block28
-
-noerr_block28:                                    ; preds = %after_check27, %assign_optional26
-  br label %voiderr29
-
-voiderr29:                                        ; preds = %noerr_block28
-  store ptr @.str.4, ptr %x30, align 8
-  store i64 0, ptr %error_var31, align 8
+  store ptr %9, ptr %result11, align 8
+  %10 = load ptr, ptr %x9, align 8
+  %11 = call i64 @std_io_File_print(ptr %retparam10, ptr %result11, ptr %10, i64 1)
+  store ptr @.str.4, ptr %x12, align 8
   %12 = call ptr @std_io_stdout()
-  store ptr %12, ptr %result33, align 8
-  %13 = call i64 @std_io_File_printn(ptr %retparam32, ptr %result33, ptr null, i64 0)
-  %not_err34 = icmp eq i64 %13, 0
-  br i1 %not_err34, label %after_check36, label %assign_optional35
-
-assign_optional35:                                ; preds = %voiderr29
-  store i64 %13, ptr %error_var31, align 8
-  br label %noerr_block37
-
-after_check36:                                    ; preds = %voiderr29
-  br label %noerr_block37
-
-noerr_block37:                                    ; preds = %after_check36, %assign_optional35
-  br label %voiderr38
-
-voiderr38:                                        ; preds = %noerr_block37
+  store ptr %12, ptr %result14, align 8
+  %13 = call i64 @std_io_File_printn(ptr %retparam13, ptr %result14, ptr null, i64 0)
   ret void
 
-if.exit39:                                        ; preds = %if.exit
-  store ptr @.str.5, ptr %x40, align 8
-  store i64 0, ptr %error_var41, align 8
+if.exit15:                                        ; preds = %if.exit
+  store ptr @.str.5, ptr %x16, align 8
   %14 = call ptr @std_io_stdout()
-  store ptr %14, ptr %result43, align 8
-  %15 = load ptr, ptr %x40, align 8
-  %16 = call i64 @std_io_File_print(ptr %retparam42, ptr %result43, ptr %15, i64 1)
-  %not_err44 = icmp eq i64 %16, 0
-  br i1 %not_err44, label %after_check46, label %assign_optional45
-
-assign_optional45:                                ; preds = %if.exit39
-  store i64 %16, ptr %error_var41, align 8
-  br label %noerr_block47
-
-after_check46:                                    ; preds = %if.exit39
-  br label %noerr_block47
-
-noerr_block47:                                    ; preds = %after_check46, %assign_optional45
-  br label %voiderr48
-
-voiderr48:                                        ; preds = %noerr_block47
-  store ptr @.str.6, ptr %x49, align 8
-  store i64 0, ptr %error_var50, align 8
+  store ptr %14, ptr %result18, align 8
+  %15 = load ptr, ptr %x16, align 8
+  %16 = call i64 @std_io_File_print(ptr %retparam17, ptr %result18, ptr %15, i64 1)
+  store ptr @.str.6, ptr %x19, align 8
   %17 = call ptr @std_io_stdout()
-  store ptr %17, ptr %result52, align 8
-  %18 = load ptr, ptr %x49, align 8
-  %19 = call i64 @std_io_File_print(ptr %retparam51, ptr %result52, ptr %18, i64 1)
-  %not_err53 = icmp eq i64 %19, 0
-  br i1 %not_err53, label %after_check55, label %assign_optional54
-
-assign_optional54:                                ; preds = %voiderr48
-  store i64 %19, ptr %error_var50, align 8
-  br label %noerr_block56
-
-after_check55:                                    ; preds = %voiderr48
-  br label %noerr_block56
-
-noerr_block56:                                    ; preds = %after_check55, %assign_optional54
-  br label %voiderr57
-
-voiderr57:                                        ; preds = %noerr_block56
-  store ptr @.str.7, ptr %x58, align 8
-  store i64 0, ptr %error_var59, align 8
+  store ptr %17, ptr %result21, align 8
+  %18 = load ptr, ptr %x19, align 8
+  %19 = call i64 @std_io_File_print(ptr %retparam20, ptr %result21, ptr %18, i64 1)
+  store ptr @.str.7, ptr %x22, align 8
   %20 = call ptr @std_io_stdout()
-  store ptr %20, ptr %result61, align 8
-  %21 = load ptr, ptr %x58, align 8
-  %22 = call i64 @std_io_File_print(ptr %retparam60, ptr %result61, ptr %21, i64 1)
-  %not_err62 = icmp eq i64 %22, 0
-  br i1 %not_err62, label %after_check64, label %assign_optional63
-
-assign_optional63:                                ; preds = %voiderr57
-  store i64 %22, ptr %error_var59, align 8
-  br label %noerr_block65
-
-after_check64:                                    ; preds = %voiderr57
-  br label %noerr_block65
-
-noerr_block65:                                    ; preds = %after_check64, %assign_optional63
-  br label %voiderr66
-
-voiderr66:                                        ; preds = %noerr_block65
-  store ptr @.str.8, ptr %x67, align 8
-  store i64 0, ptr %error_var68, align 8
+  store ptr %20, ptr %result24, align 8
+  %21 = load ptr, ptr %x22, align 8
+  %22 = call i64 @std_io_File_print(ptr %retparam23, ptr %result24, ptr %21, i64 1)
+  store ptr @.str.8, ptr %x25, align 8
   %23 = call ptr @std_io_stdout()
-  store ptr %23, ptr %result70, align 8
-  %24 = call i64 @std_io_File_printn(ptr %retparam69, ptr %result70, ptr null, i64 0)
-  %not_err71 = icmp eq i64 %24, 0
-  br i1 %not_err71, label %after_check73, label %assign_optional72
-
-assign_optional72:                                ; preds = %voiderr66
-  store i64 %24, ptr %error_var68, align 8
-  br label %noerr_block74
-
-after_check73:                                    ; preds = %voiderr66
-  br label %noerr_block74
-
-noerr_block74:                                    ; preds = %after_check73, %assign_optional72
-  br label %voiderr75
-
-voiderr75:                                        ; preds = %noerr_block74
+  store ptr %23, ptr %result27, align 8
+  %24 = call i64 @std_io_File_printn(ptr %retparam26, ptr %result27, ptr null, i64 0)
   ret void
 }
 
diff --git a/test/test_suite/from_docs/examples_forswitch.c3t b/test/test_suite/from_docs/examples_forswitch.c3t
index 7afaa5bd5..54c5236e7 100644
--- a/test/test_suite/from_docs/examples_forswitch.c3t
+++ b/test/test_suite/from_docs/examples_forswitch.c3t
@@ -122,43 +122,35 @@ define void @examples_demo_enum(i32 %0) #0 {
 entry:
   %switch = alloca i32, align 4
   %x = alloca ptr, align 8
-  %error_var = alloca i64, align 8
   %retparam = alloca i64, align 8
   %result = alloca %File, align 8
   %x2 = alloca ptr, align 8
-  %error_var3 = alloca i64, align 8
-  %retparam4 = alloca i64, align 8
-  %result5 = alloca %File, align 8
-  %switch11 = alloca i32, align 4
-  %x14 = alloca ptr, align 8
-  %error_var15 = alloca i64, align 8
-  %retparam16 = alloca i64, align 8
-  %result17 = alloca %File, align 8
-  %x24 = alloca ptr, align 8
-  %error_var25 = alloca i64, align 8
-  %retparam26 = alloca i64, align 8
-  %result27 = alloca %File, align 8
-  %switch34 = alloca i32, align 4
-  %x38 = alloca ptr, align 8
-  %error_var39 = alloca i64, align 8
-  %retparam40 = alloca i64, align 8
-  %result41 = alloca %File, align 8
-  %switch49 = alloca i32, align 4
-  %switch53 = alloca i32, align 4
+  %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
   %a = alloca i32, align 4
-  %x56 = alloca ptr, align 8
-  %error_var57 = alloca i64, align 8
-  %retparam58 = alloca i64, align 8
-  %result59 = alloca %File, align 8
-  %a66 = alloca i32, align 4
-  %x67 = alloca ptr, align 8
-  %error_var68 = alloca i64, align 8
-  %retparam69 = alloca i64, align 8
-  %result70 = alloca %File, align 8
-  %x77 = alloca ptr, align 8
-  %error_var78 = alloca i64, align 8
-  %retparam79 = alloca i64, align 8
-  %result80 = alloca %File, align 8
+  %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
   store i32 %0, ptr %switch, align 4
   br label %switch.entry
 
@@ -172,250 +164,130 @@ switch.entry:                                     ; preds = %entry
 
 switch.case:                                      ; preds = %switch.entry, %switch.entry
   store ptr @.str.1, ptr %x, align 8
-  store i64 0, ptr %error_var, align 8
   %2 = call ptr @std_io_stdout()
   store ptr %2, ptr %result, align 8
   %3 = load ptr, ptr %x, align 8
   %4 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %3, i64 8)
-  %not_err = icmp eq i64 %4, 0
-  br i1 %not_err, label %after_check, label %assign_optional
-
-assign_optional:                                  ; preds = %switch.case
-  store i64 %4, ptr %error_var, align 8
-  br label %noerr_block
-
-after_check:                                      ; preds = %switch.case
-  br label %noerr_block
-
-noerr_block:                                      ; preds = %after_check, %assign_optional
-  br label %voiderr
-
-voiderr:                                          ; preds = %noerr_block
   br label %switch.exit
 
 switch.case1:                                     ; preds = %switch.entry
   store ptr @.str.2, ptr %x2, align 8
-  store i64 0, ptr %error_var3, align 8
   %5 = call ptr @std_io_stdout()
-  store ptr %5, ptr %result5, align 8
+  store ptr %5, ptr %result4, align 8
   %6 = load ptr, ptr %x2, align 8
-  %7 = call i64 @std_io_File_printn(ptr %retparam4, ptr %result5, ptr %6, i64 4)
-  %not_err6 = icmp eq i64 %7, 0
-  br i1 %not_err6, label %after_check8, label %assign_optional7
-
-assign_optional7:                                 ; preds = %switch.case1
-  store i64 %7, ptr %error_var3, align 8
-  br label %noerr_block9
-
-after_check8:                                     ; preds = %switch.case1
-  br label %noerr_block9
-
-noerr_block9:                                     ; preds = %after_check8, %assign_optional7
-  br label %voiderr10
-
-voiderr10:                                        ; preds = %noerr_block9
+  %7 = call i64 @std_io_File_printn(ptr %retparam3, ptr %result4, ptr %6, i64 4)
   br label %switch.exit
 
-switch.exit:                                      ; preds = %voiderr10, %voiderr, %switch.entry
-  store i32 %0, ptr %switch11, align 4
-  br label %switch.entry12
+switch.exit:                                      ; preds = %switch.case1, %switch.case, %switch.entry
+  store i32 %0, ptr %switch5, align 4
+  br label %switch.entry6
 
-switch.entry12:                                   ; preds = %switch.exit
-  %8 = load i32, ptr %switch11, align 4
-  switch i32 %8, label %switch.exit33 [
-    i32 0, label %switch.case13
-    i32 1, label %switch.case13
+switch.entry6:                                    ; preds = %switch.exit
+  %8 = load i32, ptr %switch5, align 4
+  switch i32 %8, label %switch.exit15 [
+    i32 0, label %switch.case7
+    i32 1, label %switch.case7
+    i32 2, label %switch.case11
+  ]
+
+switch.case7:                                     ; preds = %switch.entry6, %switch.entry6
+  store ptr @.str.3, ptr %x8, align 8
+  %9 = call ptr @std_io_stdout()
+  store ptr %9, ptr %result10, align 8
+  %10 = load ptr, ptr %x8, align 8
+  %11 = call i64 @std_io_File_printn(ptr %retparam9, ptr %result10, ptr %10, i64 8)
+  br label %switch.exit15
+
+switch.case11:                                    ; preds = %switch.entry6
+  store ptr @.str.4, ptr %x12, align 8
+  %12 = call ptr @std_io_stdout()
+  store ptr %12, ptr %result14, align 8
+  %13 = load ptr, ptr %x12, align 8
+  %14 = call i64 @std_io_File_printn(ptr %retparam13, ptr %result14, ptr %13, i64 4)
+  br label %switch.exit15
+
+switch.exit15:                                    ; preds = %switch.case11, %switch.case7, %switch.entry6
+  store i32 %0, ptr %switch16, align 4
+  br label %switch.entry17
+
+switch.entry17:                                   ; preds = %switch.exit15
+  %15 = load i32, ptr %switch16, align 4
+  switch i32 %15, label %switch.exit24 [
+    i32 0, label %switch.case18
+    i32 1, label %switch.case19
     i32 2, label %switch.case23
   ]
 
-switch.case13:                                    ; preds = %switch.entry12, %switch.entry12
-  store ptr @.str.3, ptr %x14, align 8
-  store i64 0, ptr %error_var15, align 8
-  %9 = call ptr @std_io_stdout()
-  store ptr %9, ptr %result17, align 8
-  %10 = load ptr, ptr %x14, align 8
-  %11 = call i64 @std_io_File_printn(ptr %retparam16, ptr %result17, ptr %10, i64 8)
-  %not_err18 = icmp eq i64 %11, 0
-  br i1 %not_err18, label %after_check20, label %assign_optional19
+switch.case18:                                    ; preds = %switch.entry17
+  br label %switch.exit24
 
-assign_optional19:                                ; preds = %switch.case13
-  store i64 %11, ptr %error_var15, align 8
-  br label %noerr_block21
-
-after_check20:                                    ; preds = %switch.case13
-  br label %noerr_block21
-
-noerr_block21:                                    ; preds = %after_check20, %assign_optional19
-  br label %voiderr22
-
-voiderr22:                                        ; preds = %noerr_block21
-  br label %switch.exit33
-
-switch.case23:                                    ; preds = %switch.entry12
-  store ptr @.str.4, ptr %x24, align 8
-  store i64 0, ptr %error_var25, align 8
-  %12 = call ptr @std_io_stdout()
-  store ptr %12, ptr %result27, align 8
-  %13 = load ptr, ptr %x24, align 8
-  %14 = call i64 @std_io_File_printn(ptr %retparam26, ptr %result27, ptr %13, i64 4)
-  %not_err28 = icmp eq i64 %14, 0
-  br i1 %not_err28, label %after_check30, label %assign_optional29
-
-assign_optional29:                                ; preds = %switch.case23
-  store i64 %14, ptr %error_var25, align 8
-  br label %noerr_block31
-
-after_check30:                                    ; preds = %switch.case23
-  br label %noerr_block31
-
-noerr_block31:                                    ; preds = %after_check30, %assign_optional29
-  br label %voiderr32
-
-voiderr32:                                        ; preds = %noerr_block31
-  br label %switch.exit33
-
-switch.exit33:                                    ; preds = %voiderr32, %voiderr22, %switch.entry12
-  store i32 %0, ptr %switch34, align 4
-  br label %switch.entry35
-
-switch.entry35:                                   ; preds = %switch.exit33
-  %15 = load i32, ptr %switch34, align 4
-  switch i32 %15, label %switch.exit48 [
-    i32 0, label %switch.case36
-    i32 1, label %switch.case37
-    i32 2, label %switch.case47
-  ]
-
-switch.case36:                                    ; preds = %switch.entry35
-  br label %switch.exit48
-
-switch.case37:                                    ; preds = %switch.entry35
-  store ptr @.str.5, ptr %x38, align 8
-  store i64 0, ptr %error_var39, align 8
+switch.case19:                                    ; preds = %switch.entry17
+  store ptr @.str.5, ptr %x20, align 8
   %16 = call ptr @std_io_stdout()
-  store ptr %16, ptr %result41, align 8
-  %17 = load ptr, ptr %x38, align 8
-  %18 = call i64 @std_io_File_printn(ptr %retparam40, ptr %result41, ptr %17, i64 6)
-  %not_err42 = icmp eq i64 %18, 0
-  br i1 %not_err42, label %after_check44, label %assign_optional43
+  store ptr %16, ptr %result22, align 8
+  %17 = load ptr, ptr %x20, align 8
+  %18 = call i64 @std_io_File_printn(ptr %retparam21, ptr %result22, ptr %17, i64 6)
+  br label %switch.exit24
 
-assign_optional43:                                ; preds = %switch.case37
-  store i64 %18, ptr %error_var39, align 8
-  br label %noerr_block45
+switch.case23:                                    ; preds = %switch.entry17
+  br label %switch.exit24
 
-after_check44:                                    ; preds = %switch.case37
-  br label %noerr_block45
+switch.exit24:                                    ; preds = %switch.case23, %switch.case19, %switch.case18, %switch.entry17
+  store i32 %0, ptr %switch25, align 4
+  br label %switch.entry26
 
-noerr_block45:                                    ; preds = %after_check44, %assign_optional43
-  br label %voiderr46
-
-voiderr46:                                        ; preds = %noerr_block45
-  br label %switch.exit48
-
-switch.case47:                                    ; preds = %switch.entry35
-  br label %switch.exit48
-
-switch.exit48:                                    ; preds = %switch.case47, %voiderr46, %switch.case36, %switch.entry35
-  store i32 %0, ptr %switch49, align 4
-  br label %switch.entry50
-
-switch.entry50:                                   ; preds = %switch.exit48
-  %19 = load i32, ptr %switch49, align 4
+switch.entry26:                                   ; preds = %switch.exit24
+  %19 = load i32, ptr %switch25, align 4
   switch i32 %19, label %switch.default [
-    i32 0, label %switch.case51
-    i32 1, label %switch.case51
-    i32 2, label %switch.case51
+    i32 0, label %switch.case27
+    i32 1, label %switch.case27
+    i32 2, label %switch.case27
   ]
 
-switch.case51:                                    ; preds = %switch.entry50, %switch.entry50, %switch.entry50
-  br label %switch.exit52
+switch.case27:                                    ; preds = %switch.entry26, %switch.entry26, %switch.entry26
+  br label %switch.exit28
 
-switch.default:                                   ; preds = %switch.entry50
-  br label %switch.exit52
+switch.default:                                   ; preds = %switch.entry26
+  br label %switch.exit28
 
-switch.exit52:                                    ; preds = %switch.default, %switch.case51
-  store i32 %0, ptr %switch53, align 4
-  br label %switch.entry54
+switch.exit28:                                    ; preds = %switch.default, %switch.case27
+  store i32 %0, ptr %switch29, align 4
+  br label %switch.entry30
 
-switch.entry54:                                   ; preds = %switch.exit52
-  %20 = load i32, ptr %switch53, align 4
-  switch i32 %20, label %switch.exit86 [
-    i32 0, label %switch.case55
-    i32 1, label %switch.case65
-    i32 2, label %switch.case76
+switch.entry30:                                   ; preds = %switch.exit28
+  %20 = load i32, ptr %switch29, align 4
+  switch i32 %20, label %switch.exit44 [
+    i32 0, label %switch.case31
+    i32 1, label %switch.case35
+    i32 2, label %switch.case40
   ]
 
-switch.case55:                                    ; preds = %switch.entry54
+switch.case31:                                    ; preds = %switch.entry30
   store i32 1, ptr %a, align 4
-  store ptr @.str.6, ptr %x56, align 8
-  store i64 0, ptr %error_var57, align 8
+  store ptr @.str.6, ptr %x32, align 8
   %21 = call ptr @std_io_stdout()
-  store ptr %21, ptr %result59, align 8
-  %22 = load ptr, ptr %x56, align 8
-  %23 = call i64 @std_io_File_printn(ptr %retparam58, ptr %result59, ptr %22, i64 1)
-  %not_err60 = icmp eq i64 %23, 0
-  br i1 %not_err60, label %after_check62, label %assign_optional61
+  store ptr %21, ptr %result34, align 8
+  %22 = load ptr, ptr %x32, align 8
+  %23 = call i64 @std_io_File_printn(ptr %retparam33, ptr %result34, ptr %22, i64 1)
+  br label %switch.case35
 
-assign_optional61:                                ; preds = %switch.case55
-  store i64 %23, ptr %error_var57, align 8
-  br label %noerr_block63
-
-after_check62:                                    ; preds = %switch.case55
-  br label %noerr_block63
-
-noerr_block63:                                    ; preds = %after_check62, %assign_optional61
-  br label %voiderr64
-
-voiderr64:                                        ; preds = %noerr_block63
-  br label %switch.case65
-
-switch.case65:                                    ; preds = %switch.entry54, %voiderr64
-  store i32 2, ptr %a66, align 4
-  store ptr @.str.7, ptr %x67, align 8
-  store i64 0, ptr %error_var68, align 8
+switch.case35:                                    ; preds = %switch.entry30, %switch.case31
+  store i32 2, ptr %a36, align 4
+  store ptr @.str.7, ptr %x37, align 8
   %24 = call ptr @std_io_stdout()
-  store ptr %24, ptr %result70, align 8
-  %25 = load ptr, ptr %x67, align 8
-  %26 = call i64 @std_io_File_printn(ptr %retparam69, ptr %result70, ptr %25, i64 1)
-  %not_err71 = icmp eq i64 %26, 0
-  br i1 %not_err71, label %after_check73, label %assign_optional72
+  store ptr %24, ptr %result39, align 8
+  %25 = load ptr, ptr %x37, align 8
+  %26 = call i64 @std_io_File_printn(ptr %retparam38, ptr %result39, ptr %25, i64 1)
+  br label %switch.case40
 
-assign_optional72:                                ; preds = %switch.case65
-  store i64 %26, ptr %error_var68, align 8
-  br label %noerr_block74
-
-after_check73:                                    ; preds = %switch.case65
-  br label %noerr_block74
-
-noerr_block74:                                    ; preds = %after_check73, %assign_optional72
-  br label %voiderr75
-
-voiderr75:                                        ; preds = %noerr_block74
-  br label %switch.case76
-
-switch.case76:                                    ; preds = %switch.entry54, %voiderr75
-  store ptr @.str.8, ptr %x77, align 8
-  store i64 0, ptr %error_var78, align 8
+switch.case40:                                    ; preds = %switch.entry30, %switch.case35
+  store ptr @.str.8, ptr %x41, align 8
   %27 = call ptr @std_io_stdout()
-  store ptr %27, ptr %result80, align 8
-  %28 = load ptr, ptr %x77, align 8
-  %29 = call i64 @std_io_File_printn(ptr %retparam79, ptr %result80, ptr %28, i64 1)
-  %not_err81 = icmp eq i64 %29, 0
-  br i1 %not_err81, label %after_check83, label %assign_optional82
+  store ptr %27, ptr %result43, align 8
+  %28 = load ptr, ptr %x41, align 8
+  %29 = call i64 @std_io_File_printn(ptr %retparam42, ptr %result43, ptr %28, i64 1)
+  br label %switch.exit44
 
-assign_optional82:                                ; preds = %switch.case76
-  store i64 %29, ptr %error_var78, align 8
-  br label %noerr_block84
-
-after_check83:                                    ; preds = %switch.case76
-  br label %noerr_block84
-
-noerr_block84:                                    ; preds = %after_check83, %assign_optional82
-  br label %voiderr85
-
-voiderr85:                                        ; preds = %noerr_block84
-  br label %switch.exit86
-
-switch.exit86:                                    ; preds = %voiderr85, %switch.entry54
+switch.exit44:                                    ; preds = %switch.case40, %switch.entry30
   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 684b556df..63558b76a 100644
--- a/test/test_suite/functions/func_ptr_conversions_and_names.c3t
+++ b/test/test_suite/functions/func_ptr_conversions_and_names.c3t
@@ -66,24 +66,24 @@ entry:
   %varargslots2 = alloca [1 x %variant], align 16
   %taddr3 = alloca i32, align 4
   %z = alloca ptr, align 8
+  %retparam4 = alloca i64, align 8
+  %varargslots5 = alloca [1 x %variant], align 16
+  %taddr6 = alloca i32, align 4
   %retparam7 = alloca i64, align 8
   %varargslots8 = alloca [1 x %variant], align 16
-  %taddr9 = alloca i32, align 4
+  %taddr9 = alloca ptr, align 8
+  %retparam10 = alloca i64, align 8
+  %varargslots11 = alloca [1 x %variant], align 16
+  %taddr12 = alloca ptr, align 8
   %retparam13 = alloca i64, align 8
   %varargslots14 = alloca [1 x %variant], align 16
   %taddr15 = alloca ptr, align 8
+  %retparam16 = alloca i64, align 8
+  %varargslots17 = alloca [1 x %variant], align 16
+  %taddr18 = alloca ptr, align 8
   %retparam19 = alloca i64, align 8
   %varargslots20 = alloca [1 x %variant], align 16
   %taddr21 = alloca ptr, align 8
-  %retparam25 = alloca i64, align 8
-  %varargslots26 = alloca [1 x %variant], align 16
-  %taddr27 = alloca ptr, align 8
-  %retparam31 = alloca i64, align 8
-  %varargslots32 = alloca [1 x %variant], align 16
-  %taddr33 = alloca ptr, align 8
-  %retparam37 = alloca i64, align 8
-  %varargslots38 = alloca [1 x %variant], align 16
-  %taddr39 = alloca ptr, align 8
   %y = alloca ptr, align 8
   %zfoke = alloca i64, align 8
   store ptr @test_test, ptr %a, align 8
@@ -96,13 +96,6 @@ entry:
   %4 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %3, ptr %4, align 16
   %5 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
-  %not_err = icmp eq i64 %5, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   %6 = call i32 @test_test2(i32 3)
   store i32 %6, ptr %taddr3, align 4
   %7 = insertvalue %variant undef, ptr %taddr3, 0
@@ -110,94 +103,45 @@ voiderr:                                          ; preds = %after_check, %entry
   %9 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0
   store %variant %8, ptr %9, align 16
   %10 = call i64 @std_io_printfn(ptr %retparam1, ptr @.str.1, i64 2, ptr %varargslots2, i64 1)
-  %not_err4 = icmp eq i64 %10, 0
-  br i1 %not_err4, label %after_check5, label %voiderr6
-
-after_check5:                                     ; preds = %voiderr
-  br label %voiderr6
-
-voiderr6:                                         ; preds = %after_check5, %voiderr
   store ptr @test_test2, ptr %z, align 8
   %11 = load ptr, ptr %z, align 8
   %12 = call i32 %11(i32 444)
-  store i32 %12, ptr %taddr9, align 4
-  %13 = insertvalue %variant undef, ptr %taddr9, 0
+  store i32 %12, ptr %taddr6, align 4
+  %13 = insertvalue %variant undef, ptr %taddr6, 0
   %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %15 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
+  %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 %retparam7, ptr @.str.2, i64 2, ptr %varargslots8, i64 1)
-  %not_err10 = icmp eq i64 %16, 0
-  br i1 %not_err10, label %after_check11, label %voiderr12
-
-after_check11:                                    ; preds = %voiderr6
-  br label %voiderr12
-
-voiderr12:                                        ; preds = %after_check11, %voiderr6
-  store ptr @.str.4, ptr %taddr15, align 8
-  %17 = insertvalue %variant undef, ptr %taddr15, 0
+  %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
+  %17 = insertvalue %variant undef, ptr %taddr9, 0
   %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"ct$p$a12$char" to i64), 1
-  %19 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0
+  %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 %retparam13, ptr @.str.3, i64 2, ptr %varargslots14, i64 1)
-  %not_err16 = icmp eq i64 %20, 0
-  br i1 %not_err16, label %after_check17, label %voiderr18
-
-after_check17:                                    ; preds = %voiderr12
-  br label %voiderr18
-
-voiderr18:                                        ; preds = %after_check17, %voiderr12
-  store ptr @.str.6, ptr %taddr21, align 8
-  %21 = insertvalue %variant undef, ptr %taddr21, 0
+  %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
+  %21 = insertvalue %variant undef, ptr %taddr12, 0
   %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"ct$p$a12$char" to i64), 1
-  %23 = getelementptr inbounds [1 x %variant], ptr %varargslots20, i64 0, i64 0
+  %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 %retparam19, ptr @.str.5, i64 2, ptr %varargslots20, i64 1)
-  %not_err22 = icmp eq i64 %24, 0
-  br i1 %not_err22, label %after_check23, label %voiderr24
-
-after_check23:                                    ; preds = %voiderr18
-  br label %voiderr24
-
-voiderr24:                                        ; preds = %after_check23, %voiderr18
-  store ptr @.str.8, ptr %taddr27, align 8
-  %25 = insertvalue %variant undef, ptr %taddr27, 0
+  %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
+  %25 = insertvalue %variant undef, ptr %taddr15, 0
   %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$p$a12$char" to i64), 1
-  %27 = getelementptr inbounds [1 x %variant], ptr %varargslots26, i64 0, i64 0
+  %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 %retparam25, ptr @.str.7, i64 2, ptr %varargslots26, i64 1)
-  %not_err28 = icmp eq i64 %28, 0
-  br i1 %not_err28, label %after_check29, label %voiderr30
-
-after_check29:                                    ; preds = %voiderr24
-  br label %voiderr30
-
-voiderr30:                                        ; preds = %after_check29, %voiderr24
-  store ptr @.str.10, ptr %taddr33, align 8
-  %29 = insertvalue %variant undef, ptr %taddr33, 0
+  %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
+  %29 = insertvalue %variant undef, ptr %taddr18, 0
   %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1
-  %31 = getelementptr inbounds [1 x %variant], ptr %varargslots32, i64 0, i64 0
+  %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 %retparam31, ptr @.str.9, i64 2, ptr %varargslots32, i64 1)
-  %not_err34 = icmp eq i64 %32, 0
-  br i1 %not_err34, label %after_check35, label %voiderr36
-
-after_check35:                                    ; preds = %voiderr30
-  br label %voiderr36
-
-voiderr36:                                        ; preds = %after_check35, %voiderr30
-  store ptr @.str.12, ptr %taddr39, align 8
-  %33 = insertvalue %variant undef, ptr %taddr39, 0
+  %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
+  %33 = insertvalue %variant undef, ptr %taddr21, 0
   %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$p$a13$char" to i64), 1
-  %35 = getelementptr inbounds [1 x %variant], ptr %varargslots38, i64 0, i64 0
+  %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 %retparam37, ptr @.str.11, i64 2, ptr %varargslots38, i64 1)
-  %not_err40 = icmp eq i64 %36, 0
-  br i1 %not_err40, label %after_check41, label %voiderr42
-
-after_check41:                                    ; preds = %voiderr36
-  br label %voiderr42
-
-voiderr42:                                        ; preds = %after_check41, %voiderr36
+  %36 = call i64 @std_io_printfn(ptr %retparam19, ptr @.str.11, i64 2, ptr %varargslots20, i64 1)
   store ptr @test_test2, ptr %y, align 8
   store i64 ptrtoint (ptr @"ct$p$fn$int$int$" to i64), ptr %zfoke, align 8
   ret void
diff --git a/test/test_suite/generic/enum_set_test.c3t b/test/test_suite/generic/enum_set_test.c3t
index 88ba51c23..32abf1f57 100644
--- a/test/test_suite/generic/enum_set_test.c3t
+++ b/test/test_suite/generic/enum_set_test.c3t
@@ -36,16 +36,16 @@ entry:
   %retparam1 = alloca i64, align 8
   %varargslots2 = alloca [1 x %variant], align 16
   %taddr3 = alloca i8, align 1
+  %retparam4 = alloca i64, align 8
+  %varargslots5 = alloca [1 x %variant], align 16
+  %taddr6 = alloca i8, align 1
+  %set2 = alloca i32, align 4
   %retparam7 = alloca i64, align 8
   %varargslots8 = alloca [1 x %variant], align 16
   %taddr9 = alloca i8, align 1
-  %set2 = alloca i32, align 4
-  %retparam13 = alloca i64, align 8
-  %varargslots14 = alloca [1 x %variant], align 16
-  %taddr15 = alloca i8, align 1
-  %retparam19 = alloca i64, align 8
-  %varargslots20 = alloca [1 x %variant], align 16
-  %taddr21 = alloca i8, align 1
+  %retparam10 = alloca i64, align 8
+  %varargslots11 = alloca [1 x %variant], align 16
+  %taddr12 = alloca i8, align 1
   store i32 0, ptr %set, align 4
   %0 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(ptr %set, i32 1)
   store i8 %0, ptr %taddr, align 1
@@ -54,13 +54,6 @@ entry:
   %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %2, ptr %3, align 16
   %4 = call i64 @std_io_printf(ptr %retparam, ptr @.str, i64 14, ptr %varargslots, i64 1)
-  %not_err = icmp eq i64 %4, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   call void @"std_enumset$$test_Abc_EnumSet_add"(ptr %set, i32 0)
   %5 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(ptr %set, i32 1)
   store i8 %5, ptr %taddr3, align 1
@@ -69,60 +62,32 @@ voiderr:                                          ; preds = %after_check, %entry
   %8 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0
   store %variant %7, ptr %8, align 16
   %9 = call i64 @std_io_printf(ptr %retparam1, ptr @.str.1, i64 14, ptr %varargslots2, i64 1)
-  %not_err4 = icmp eq i64 %9, 0
-  br i1 %not_err4, label %after_check5, label %voiderr6
-
-after_check5:                                     ; preds = %voiderr
-  br label %voiderr6
-
-voiderr6:                                         ; preds = %after_check5, %voiderr
   call void @"std_enumset$$test_Abc_EnumSet_add"(ptr %set, i32 1)
   %10 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(ptr %set, i32 1)
-  store i8 %10, ptr %taddr9, align 1
-  %11 = insertvalue %variant undef, ptr %taddr9, 0
+  store i8 %10, ptr %taddr6, align 1
+  %11 = insertvalue %variant undef, ptr %taddr6, 0
   %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$bool" to i64), 1
-  %13 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
+  %13 = getelementptr inbounds [1 x %variant], ptr %varargslots5, i64 0, i64 0
   store %variant %12, ptr %13, align 16
-  %14 = call i64 @std_io_printf(ptr %retparam7, ptr @.str.2, i64 14, ptr %varargslots8, i64 1)
-  %not_err10 = icmp eq i64 %14, 0
-  br i1 %not_err10, label %after_check11, label %voiderr12
-
-after_check11:                                    ; preds = %voiderr6
-  br label %voiderr12
-
-voiderr12:                                        ; preds = %after_check11, %voiderr6
+  %14 = call i64 @std_io_printf(ptr %retparam4, ptr @.str.2, i64 14, ptr %varargslots5, i64 1)
   store i32 0, ptr %set2, align 4
   %15 = load i32, ptr %set, align 4
   call void @"std_enumset$$test_Abc_EnumSet_add_all"(ptr %set2, i32 %15)
   %16 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(ptr %set2, i32 1)
-  store i8 %16, ptr %taddr15, align 1
-  %17 = insertvalue %variant undef, ptr %taddr15, 0
+  store i8 %16, ptr %taddr9, align 1
+  %17 = insertvalue %variant undef, ptr %taddr9, 0
   %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"ct$bool" to i64), 1
-  %19 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0
+  %19 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
   store %variant %18, ptr %19, align 16
-  %20 = call i64 @std_io_printf(ptr %retparam13, ptr @.str.3, i64 14, ptr %varargslots14, i64 1)
-  %not_err16 = icmp eq i64 %20, 0
-  br i1 %not_err16, label %after_check17, label %voiderr18
-
-after_check17:                                    ; preds = %voiderr12
-  br label %voiderr18
-
-voiderr18:                                        ; preds = %after_check17, %voiderr12
+  %20 = call i64 @std_io_printf(ptr %retparam7, ptr @.str.3, i64 14, ptr %varargslots8, i64 1)
   %21 = load i32, ptr %set2, align 4
   call void @"std_enumset$$test_Abc_EnumSet_remove_all"(ptr %set, i32 %21)
   %22 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(ptr %set, i32 1)
-  store i8 %22, ptr %taddr21, align 1
-  %23 = insertvalue %variant undef, ptr %taddr21, 0
+  store i8 %22, ptr %taddr12, align 1
+  %23 = insertvalue %variant undef, ptr %taddr12, 0
   %24 = insertvalue %variant %23, i64 ptrtoint (ptr @"ct$bool" to i64), 1
-  %25 = getelementptr inbounds [1 x %variant], ptr %varargslots20, i64 0, i64 0
+  %25 = getelementptr inbounds [1 x %variant], ptr %varargslots11, i64 0, i64 0
   store %variant %24, ptr %25, align 16
-  %26 = call i64 @std_io_printf(ptr %retparam19, ptr @.str.4, i64 14, ptr %varargslots20, i64 1)
-  %not_err22 = icmp eq i64 %26, 0
-  br i1 %not_err22, label %after_check23, label %voiderr24
-
-after_check23:                                    ; preds = %voiderr18
-  br label %voiderr24
-
-voiderr24:                                        ; preds = %after_check23, %voiderr18
+  %26 = call i64 @std_io_printf(ptr %retparam10, ptr @.str.4, i64 14, ptr %varargslots11, i64 1)
   ret void
 }
diff --git a/test/test_suite/generic/generic_num.c3t b/test/test_suite/generic/generic_num.c3t
index 5f2526db0..1524c088c 100644
--- a/test/test_suite/generic/generic_num.c3t
+++ b/test/test_suite/generic/generic_num.c3t
@@ -31,13 +31,6 @@ entry:
   %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %2, ptr %3, align 16
   %4 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
-  %not_err = icmp eq i64 %4, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   ret void
 }
 
diff --git a/test/test_suite/initializer_lists/subarrays.c3t b/test/test_suite/initializer_lists/subarrays.c3t
index fc0d9a3d4..f183ee0db 100644
--- a/test/test_suite/initializer_lists/subarrays.c3t
+++ b/test/test_suite/initializer_lists/subarrays.c3t
@@ -73,7 +73,6 @@ entry:
   %y = alloca ptr, align 8
   %literal2 = alloca [3 x i32], align 4
   %x3 = alloca ptr, align 8
-  %error_var = alloca i64, align 8
   %retparam = alloca i64, align 8
   %result = alloca %File, align 8
   %ffe = alloca %Baz, align 8
@@ -81,9 +80,8 @@ entry:
   %xy = alloca i8, align 1
   %literal7 = alloca [3 x i32], align 4
   %x9 = alloca ptr, align 8
-  %error_var10 = alloca i64, align 8
-  %retparam11 = alloca i64, align 8
-  %result12 = alloca %File, align 8
+  %retparam10 = alloca i64, align 8
+  %result11 = alloca %File, align 8
   %b = alloca %Bar, align 4
   %z = alloca %Baz, align 8
   %sub = alloca %"int[]", align 8
@@ -114,21 +112,10 @@ entry:
   store i32 567, ptr %12, align 4
   store ptr %literal2, ptr %y, align 8
   store ptr @.str.5, ptr %x3, align 8
-  store i64 0, ptr %error_var, align 8
   %13 = call ptr @std_io_stdout()
   store ptr %13, ptr %result, align 8
   %14 = load ptr, ptr %x3, align 8
   %15 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %14, i64 6)
-  %not_err = icmp eq i64 %15, 0
-  br i1 %not_err, label %after_check, label %assign_optional
-assign_optional:                                  ; preds = %entry
-  store i64 %15, ptr %error_var, align 8
-  br label %noerr_block
-after_check:                                      ; preds = %entry
-  br label %noerr_block
-noerr_block:                                      ; preds = %after_check, %assign_optional
-  br label %voiderr
-voiderr:                                          ; preds = %noerr_block
   %16 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1
   %17 = load i64, ptr %16, align 8
   %uisitrunc = trunc i64 %17 to i32
@@ -164,25 +151,16 @@ voiderr:                                          ; preds = %noerr_block
   %37 = trunc i8 %36 to i1
   %not8 = xor i1 %37, true
   br i1 %not8, label %if.then, label %if.exit
-if.then:                                          ; preds = %voiderr
+
+if.then:                                          ; preds = %entry
   store ptr @.str.9, ptr %x9, align 8
-  store i64 0, ptr %error_var10, align 8
   %38 = call ptr @std_io_stdout()
-  store ptr %38, ptr %result12, align 8
+  store ptr %38, ptr %result11, align 8
   %39 = load ptr, ptr %x9, align 8
-  %40 = call i64 @std_io_File_printn(ptr %retparam11, ptr %result12, ptr %39, i64 2)
-  %not_err13 = icmp eq i64 %40, 0
-  br i1 %not_err13, label %after_check15, label %assign_optional14
-assign_optional14:                                ; preds = %if.then
-  store i64 %40, ptr %error_var10, align 8
-  br label %noerr_block16
-after_check15:                                    ; preds = %if.then
-  br label %noerr_block16
-noerr_block16:                                    ; preds = %after_check15, %assign_optional14
-  br label %voiderr17
-voiderr17:                                        ; preds = %noerr_block16
+  %40 = call i64 @std_io_File_printn(ptr %retparam10, ptr %result11, ptr %39, i64 2)
   br label %if.exit
-if.exit:                                          ; preds = %voiderr17, %voiderr
+
+if.exit:                                          ; preds = %if.then, %entry
   %41 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 0
   store i32 0, ptr %41, align 4
   %42 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1
diff --git a/test/test_suite/lambda/lambda_in_macro.c3t b/test/test_suite/lambda/lambda_in_macro.c3t
index 849774ee7..222759749 100644
--- a/test/test_suite/lambda/lambda_in_macro.c3t
+++ b/test/test_suite/lambda/lambda_in_macro.c3t
@@ -33,7 +33,7 @@ fn void main()
   %1 = call i32 %0(i32 3)
   store ptr @"test_test$lambda2", ptr %z3, align 8
   %7 = call double %6(double 3.300000e+00)
-  store ptr @"test_test$lambda2", ptr %z10, align 8
+  store ptr @"test_test$lambda2", ptr %z7, align 8
   %13 = call double %12(double 3.300000e+00)
   %18 = call i32 @"test_test2$lambda3"(i32 3)
   %23 = call i32 @"test_test2$lambda3"(i32 3)
diff --git a/test/test_suite/literals/bin_literal.c3t b/test/test_suite/literals/bin_literal.c3t
index 3dd034aad..80f3aaed4 100644
--- a/test/test_suite/literals/bin_literal.c3t
+++ b/test/test_suite/literals/bin_literal.c3t
@@ -51,13 +51,6 @@ entry:
   %11 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %10, ptr %11, align 16
   %12 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2)
-  %not_err = icmp eq i64 %12, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   store i8 -35, ptr %z, align 1
   %13 = insertvalue %variant undef, ptr %z, 0
   %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"ct$char" to i64), 1
@@ -88,12 +81,5 @@ voiderr:                                          ; preds = %after_check, %entry
   %31 = getelementptr inbounds [3 x %variant], ptr %varargslots2, i64 0, i64 2
   store %variant %30, ptr %31, align 16
   %32 = call i64 @std_io_printfn(ptr %retparam1, ptr @.str.1, i64 8, ptr %varargslots2, i64 3)
-  %not_err6 = icmp eq i64 %32, 0
-  br i1 %not_err6, label %after_check7, label %voiderr8
-
-after_check7:                                     ; preds = %voiderr
-  br label %voiderr8
-
-voiderr8:                                         ; preds = %after_check7, %voiderr
   ret void
 }
diff --git a/test/test_suite/macros/macro_typed_varargs.c3t b/test/test_suite/macros/macro_typed_varargs.c3t
index 35edde6bc..443b7f898 100644
--- a/test/test_suite/macros/macro_typed_varargs.c3t
+++ b/test/test_suite/macros/macro_typed_varargs.c3t
@@ -64,13 +64,11 @@ entry:
   store i64 %7, ptr %.anon, align 8
   store i64 0, ptr %.anon1, align 8
   br label %loop.cond
-
-loop.cond:                                        ; preds = %voiderr, %entry
+loop.cond:                                        ; preds = %loop.body, %entry
   %8 = load i64, ptr %.anon1, align 8
   %9 = load i64, ptr %.anon, align 8
   %lt = icmp ult i64 %8, %9
   br i1 %lt, label %loop.body, label %loop.exit
-
 loop.body:                                        ; preds = %loop.cond
   %10 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0
   %11 = load ptr, ptr %10, align 8
@@ -83,18 +81,10 @@ loop.body:                                        ; preds = %loop.cond
   %16 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %15, ptr %16, align 16
   %17 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
-  %not_err = icmp eq i64 %17, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %loop.body
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %loop.body
   %18 = load i64, ptr %.anon1, align 8
   %add = add i64 %18, 1
   store i64 %add, ptr %.anon1, align 8
   br label %loop.cond
-
 loop.exit:                                        ; preds = %loop.cond
   %19 = getelementptr inbounds [4 x %variant], ptr %literal3, i64 0, i64 0
   store i32 1, ptr %taddr, align 4
@@ -124,13 +114,11 @@ loop.exit:                                        ; preds = %loop.cond
   store i64 %34, ptr %.anon7, align 8
   store i64 0, ptr %.anon8, align 8
   br label %loop.cond9
-
-loop.cond9:                                       ; preds = %voiderr18, %loop.exit
+loop.cond9:                                       ; preds = %loop.body11, %loop.exit
   %35 = load i64, ptr %.anon8, align 8
   %36 = load i64, ptr %.anon7, align 8
   %lt10 = icmp ult i64 %35, %36
-  br i1 %lt10, label %loop.body11, label %loop.exit20
-
+  br i1 %lt10, label %loop.body11, label %loop.exit17
 loop.body11:                                      ; preds = %loop.cond9
   %37 = getelementptr inbounds %"variant[]", ptr %x2, i32 0, i32 0
   %38 = load ptr, ptr %37, align 8
@@ -144,18 +132,10 @@ loop.body11:                                      ; preds = %loop.cond9
   %44 = getelementptr inbounds [1 x %variant], ptr %varargslots15, i64 0, i64 0
   store %variant %43, ptr %44, align 16
   %45 = call i64 @std_io_printfn(ptr %retparam14, ptr @.str.1, i64 2, ptr %varargslots15, i64 1)
-  %not_err16 = icmp eq i64 %45, 0
-  br i1 %not_err16, label %after_check17, label %voiderr18
-
-after_check17:                                    ; preds = %loop.body11
-  br label %voiderr18
-
-voiderr18:                                        ; preds = %after_check17, %loop.body11
   %46 = load i64, ptr %.anon8, align 8
-  %add19 = add i64 %46, 1
-  store i64 %add19, ptr %.anon8, align 8
+  %add16 = add i64 %46, 1
+  store i64 %add16, ptr %.anon8, align 8
   br label %loop.cond9
-
-loop.exit20:                                      ; preds = %loop.cond9
+loop.exit17:                                      ; preds = %loop.cond9
   ret void
 }
diff --git a/test/test_suite/macros/macro_untyped_varargs_2.c3t b/test/test_suite/macros/macro_untyped_varargs_2.c3t
index e779fc55c..67d8e7668 100644
--- a/test/test_suite/macros/macro_untyped_varargs_2.c3t
+++ b/test/test_suite/macros/macro_untyped_varargs_2.c3t
@@ -71,13 +71,6 @@ entry:
   %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %2, ptr %3, align 16
   %4 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 1)
-  %not_err = icmp eq i64 %4, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   ret i32 %0
 }
 
@@ -93,29 +86,29 @@ entry:
   %varargslots = alloca [1 x %variant], align 16
   %retparam5 = alloca i64, align 8
   %varargslots6 = alloca [1 x %variant], align 16
-  %retparam10 = alloca i64, align 8
-  %varargslots11 = alloca [1 x %variant], align 16
-  %retparam15 = alloca i64, align 8
-  %varargslots16 = alloca [1 x %variant], align 16
+  %retparam7 = alloca i64, align 8
+  %varargslots8 = alloca [1 x %variant], align 16
+  %retparam9 = alloca i64, align 8
+  %varargslots10 = alloca [1 x %variant], align 16
   %x = alloca i32, align 4
-  %retparam20 = alloca i64, align 8
-  %varargslots21 = alloca [1 x %variant], align 16
+  %retparam11 = alloca i64, align 8
+  %varargslots12 = alloca [1 x %variant], align 16
   %taddr = alloca ptr, align 8
-  %x25 = alloca double, align 8
-  %retparam26 = alloca i64, align 8
-  %varargslots27 = alloca [1 x %variant], align 16
-  %taddr28 = alloca ptr, align 8
-  %retparam32 = alloca i64, align 8
-  %varargslots33 = alloca [1 x %variant], align 16
-  %taddr34 = alloca i32, align 4
-  %x38 = alloca i32, align 4
+  %x13 = alloca double, align 8
+  %retparam14 = alloca i64, align 8
+  %varargslots15 = alloca [1 x %variant], align 16
+  %taddr16 = alloca ptr, align 8
+  %retparam17 = alloca i64, align 8
+  %varargslots18 = alloca [1 x %variant], align 16
+  %taddr19 = alloca i32, align 4
+  %x20 = alloca i32, align 4
   %y = alloca i32, align 4
   %a = alloca i32, align 4
-  %retparam39 = alloca i64, align 8
-  %varargslots40 = alloca [2 x %variant], align 16
-  %a44 = alloca i32, align 4
-  %retparam45 = alloca i64, align 8
-  %varargslots46 = alloca [2 x %variant], align 16
+  %retparam21 = alloca i64, align 8
+  %varargslots22 = alloca [2 x %variant], align 16
+  %a23 = alloca i32, align 4
+  %retparam24 = alloca i64, align 8
+  %varargslots25 = alloca [2 x %variant], align 16
   %0 = call i32 @test_ping(i32 -1)
   store i32 %0, ptr %.anon, align 4
   %1 = call i32 @test_ping(i32 1)
@@ -137,135 +130,72 @@ entry:
   %10 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %9, ptr %10, align 16
   %11 = call i64 @std_io_printfn(ptr %retparam, ptr @.str.1, i64 2, ptr %varargslots, i64 1)
-  %not_err = icmp eq i64 %11, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   %12 = insertvalue %variant undef, ptr %.anon, 0
   %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$int" to i64), 1
   %14 = getelementptr inbounds [1 x %variant], ptr %varargslots6, i64 0, i64 0
   store %variant %13, ptr %14, align 16
   %15 = call i64 @std_io_printfn(ptr %retparam5, ptr @.str.2, i64 2, ptr %varargslots6, i64 1)
-  %not_err7 = icmp eq i64 %15, 0
-  br i1 %not_err7, label %after_check8, label %voiderr9
-
-after_check8:                                     ; preds = %voiderr
-  br label %voiderr9
-
-voiderr9:                                         ; preds = %after_check8, %voiderr
   %16 = insertvalue %variant undef, ptr %.anon2, 0
   %17 = insertvalue %variant %16, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %18 = getelementptr inbounds [1 x %variant], ptr %varargslots11, i64 0, i64 0
+  %18 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
   store %variant %17, ptr %18, align 16
-  %19 = call i64 @std_io_printfn(ptr %retparam10, ptr @.str.3, i64 2, ptr %varargslots11, i64 1)
-  %not_err12 = icmp eq i64 %19, 0
-  br i1 %not_err12, label %after_check13, label %voiderr14
-
-after_check13:                                    ; preds = %voiderr9
-  br label %voiderr14
-
-voiderr14:                                        ; preds = %after_check13, %voiderr9
+  %19 = call i64 @std_io_printfn(ptr %retparam7, ptr @.str.3, i64 2, ptr %varargslots8, i64 1)
   %20 = insertvalue %variant undef, ptr %.anon3, 0
   %21 = insertvalue %variant %20, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %22 = getelementptr inbounds [1 x %variant], ptr %varargslots16, i64 0, i64 0
+  %22 = getelementptr inbounds [1 x %variant], ptr %varargslots10, i64 0, i64 0
   store %variant %21, ptr %22, align 16
-  %23 = call i64 @std_io_printfn(ptr %retparam15, ptr @.str.4, i64 2, ptr %varargslots16, i64 1)
-  %not_err17 = icmp eq i64 %23, 0
-  br i1 %not_err17, label %after_check18, label %voiderr19
-
-after_check18:                                    ; preds = %voiderr14
-  br label %voiderr19
-
-voiderr19:                                        ; preds = %after_check18, %voiderr14
+  %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
   %24 = insertvalue %variant undef, ptr %taddr, 0
   %25 = insertvalue %variant %24, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
-  %26 = getelementptr inbounds [1 x %variant], ptr %varargslots21, i64 0, i64 0
+  %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 %retparam20, ptr @.str.5, i64 2, ptr %varargslots21, i64 1)
-  %not_err22 = icmp eq i64 %27, 0
-  br i1 %not_err22, label %after_check23, label %voiderr24
-
-after_check23:                                    ; preds = %voiderr19
-  br label %voiderr24
-
-voiderr24:                                        ; preds = %after_check23, %voiderr19
-  store double 0.000000e+00, ptr %x25, align 8
-  store ptr @.str.8, ptr %taddr28, align 8
-  %28 = insertvalue %variant undef, ptr %taddr28, 0
+  %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
+  %28 = insertvalue %variant undef, ptr %taddr16, 0
   %29 = insertvalue %variant %28, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1
-  %30 = getelementptr inbounds [1 x %variant], ptr %varargslots27, i64 0, i64 0
+  %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 %retparam26, ptr @.str.7, i64 2, ptr %varargslots27, i64 1)
-  %not_err29 = icmp eq i64 %31, 0
-  br i1 %not_err29, label %after_check30, label %voiderr31
-
-after_check30:                                    ; preds = %voiderr24
-  br label %voiderr31
-
-voiderr31:                                        ; preds = %after_check30, %voiderr24
-  store i32 105, ptr %taddr34, align 4
-  %32 = insertvalue %variant undef, ptr %taddr34, 0
+  %31 = call i64 @std_io_printfn(ptr %retparam14, ptr @.str.7, i64 2, ptr %varargslots15, i64 1)
+  store i32 105, ptr %taddr19, align 4
+  %32 = insertvalue %variant undef, ptr %taddr19, 0
   %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %34 = getelementptr inbounds [1 x %variant], ptr %varargslots33, i64 0, i64 0
+  %34 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0
   store %variant %33, ptr %34, align 16
-  %35 = call i64 @std_io_printfn(ptr %retparam32, ptr @.str.9, i64 2, ptr %varargslots33, i64 1)
-  %not_err35 = icmp eq i64 %35, 0
-  br i1 %not_err35, label %after_check36, label %voiderr37
-
-after_check36:                                    ; preds = %voiderr31
-  br label %voiderr37
-
-voiderr37:                                        ; preds = %after_check36, %voiderr31
-  store i32 123, ptr %x38, align 4
+  %35 = call i64 @std_io_printfn(ptr %retparam17, ptr @.str.9, i64 2, ptr %varargslots18, i64 1)
+  store i32 123, ptr %x20, align 4
   store i32 33, ptr %y, align 4
-  %36 = load i32, ptr %x38, align 4
+  %36 = load i32, ptr %x20, align 4
   store i32 %36, ptr %a, align 4
   %37 = load i32, ptr %y, align 4
-  store i32 %37, ptr %x38, align 4
+  store i32 %37, ptr %x20, align 4
   %38 = load i32, ptr %a, align 4
   store i32 %38, ptr %y, align 4
-  %39 = insertvalue %variant undef, ptr %x38, 0
+  %39 = insertvalue %variant undef, ptr %x20, 0
   %40 = insertvalue %variant %39, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %41 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 0
+  %41 = getelementptr inbounds [2 x %variant], ptr %varargslots22, i64 0, i64 0
   store %variant %40, ptr %41, align 16
   %42 = insertvalue %variant undef, ptr %y, 0
   %43 = insertvalue %variant %42, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %44 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1
+  %44 = getelementptr inbounds [2 x %variant], ptr %varargslots22, i64 0, i64 1
   store %variant %43, ptr %44, align 16
-  %45 = call i64 @std_io_printfn(ptr %retparam39, ptr @.str.10, i64 6, ptr %varargslots40, i64 2)
-  %not_err41 = icmp eq i64 %45, 0
-  br i1 %not_err41, label %after_check42, label %voiderr43
-
-after_check42:                                    ; preds = %voiderr37
-  br label %voiderr43
-
-voiderr43:                                        ; preds = %after_check42, %voiderr37
-  %46 = load i32, ptr %x38, align 4
-  store i32 %46, ptr %a44, align 4
+  %45 = call i64 @std_io_printfn(ptr %retparam21, ptr @.str.10, i64 6, ptr %varargslots22, i64 2)
+  %46 = load i32, ptr %x20, align 4
+  store i32 %46, ptr %a23, align 4
   %47 = load i32, ptr %y, align 4
-  store i32 %47, ptr %x38, align 4
-  %48 = load i32, ptr %a44, align 4
+  store i32 %47, ptr %x20, align 4
+  %48 = load i32, ptr %a23, align 4
   store i32 %48, ptr %y, align 4
-  %49 = insertvalue %variant undef, ptr %x38, 0
+  %49 = insertvalue %variant undef, ptr %x20, 0
   %50 = insertvalue %variant %49, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %51 = getelementptr inbounds [2 x %variant], ptr %varargslots46, i64 0, i64 0
+  %51 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 0
   store %variant %50, ptr %51, align 16
   %52 = insertvalue %variant undef, ptr %y, 0
   %53 = insertvalue %variant %52, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %54 = getelementptr inbounds [2 x %variant], ptr %varargslots46, i64 0, i64 1
+  %54 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 1
   store %variant %53, ptr %54, align 16
-  %55 = call i64 @std_io_printfn(ptr %retparam45, ptr @.str.11, i64 6, ptr %varargslots46, i64 2)
-  %not_err47 = icmp eq i64 %55, 0
-  br i1 %not_err47, label %after_check48, label %voiderr49
-
-after_check48:                                    ; preds = %voiderr43
-  br label %voiderr49
-
-voiderr49:                                        ; preds = %after_check48, %voiderr43
+  %55 = call i64 @std_io_printfn(ptr %retparam24, ptr @.str.11, i64 6, ptr %varargslots25, i64 2)
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/macros/macro_vasplat.c3t b/test/test_suite/macros/macro_vasplat.c3t
index 1b35114b2..cef800109 100644
--- a/test/test_suite/macros/macro_vasplat.c3t
+++ b/test/test_suite/macros/macro_vasplat.c3t
@@ -76,71 +76,71 @@ entry:
   %x7 = alloca i32, align 4
   %retparam8 = alloca i64, align 8
   %varargslots9 = alloca [2 x %variant], align 16
-  %a15 = alloca [4 x i32], align 16
-  %.anon16 = alloca i64, align 8
-  %i20 = alloca i64, align 8
-  %x21 = alloca i32, align 4
-  %retparam22 = alloca i64, align 8
-  %varargslots23 = alloca [2 x %variant], align 16
-  %a29 = alloca [2 x i32], align 4
-  %.anon30 = alloca i64, align 8
-  %i34 = alloca i64, align 8
-  %x35 = alloca i32, align 4
-  %retparam36 = alloca i64, align 8
-  %varargslots37 = alloca [2 x %variant], align 16
-  %a43 = alloca [3 x i32], align 4
-  %.anon44 = alloca i64, align 8
-  %i48 = alloca i64, align 8
-  %x49 = alloca i32, align 4
-  %retparam50 = alloca i64, align 8
-  %varargslots51 = alloca [2 x %variant], align 16
-  %a57 = alloca [1 x i32], align 4
-  %.anon58 = alloca i64, align 8
-  %i62 = alloca i64, align 8
-  %x63 = alloca i32, align 4
-  %retparam64 = alloca i64, align 8
-  %varargslots65 = alloca [2 x %variant], align 16
-  %a71 = alloca [2 x i32], align 4
-  %.anon72 = alloca i64, align 8
-  %i76 = alloca i64, align 8
-  %x77 = alloca i32, align 4
-  %retparam78 = alloca i64, align 8
-  %varargslots79 = alloca [2 x %variant], align 16
-  %a85 = alloca [5 x i32], align 16
-  %.anon86 = alloca i64, align 8
-  %i90 = alloca i64, align 8
-  %x91 = alloca i32, align 4
-  %retparam92 = alloca i64, align 8
-  %varargslots93 = alloca [2 x %variant], align 16
-  %a99 = alloca [8 x i32], align 16
-  %.anon100 = alloca i64, align 8
-  %i104 = alloca i64, align 8
-  %x105 = alloca i32, align 4
-  %retparam106 = alloca i64, align 8
-  %varargslots107 = alloca [2 x %variant], align 16
+  %a12 = alloca [4 x i32], align 16
+  %.anon13 = alloca i64, align 8
+  %i17 = alloca i64, align 8
+  %x18 = alloca i32, align 4
+  %retparam19 = alloca i64, align 8
+  %varargslots20 = alloca [2 x %variant], align 16
+  %a23 = alloca [2 x i32], align 4
+  %.anon24 = alloca i64, align 8
+  %i28 = alloca i64, align 8
+  %x29 = alloca i32, align 4
+  %retparam30 = alloca i64, align 8
+  %varargslots31 = alloca [2 x %variant], align 16
+  %a34 = alloca [3 x i32], align 4
+  %.anon35 = alloca i64, align 8
+  %i39 = alloca i64, align 8
+  %x40 = alloca i32, align 4
+  %retparam41 = alloca i64, align 8
+  %varargslots42 = alloca [2 x %variant], align 16
+  %a45 = alloca [1 x i32], align 4
+  %.anon46 = alloca i64, align 8
+  %i50 = alloca i64, align 8
+  %x51 = alloca i32, align 4
+  %retparam52 = alloca i64, align 8
+  %varargslots53 = alloca [2 x %variant], align 16
+  %a56 = alloca [2 x i32], align 4
+  %.anon57 = alloca i64, align 8
+  %i61 = alloca i64, align 8
+  %x62 = alloca i32, align 4
+  %retparam63 = alloca i64, align 8
+  %varargslots64 = alloca [2 x %variant], align 16
+  %a67 = alloca [5 x i32], align 16
+  %.anon68 = alloca i64, align 8
+  %i72 = alloca i64, align 8
+  %x73 = alloca i32, align 4
+  %retparam74 = alloca i64, align 8
+  %varargslots75 = alloca [2 x %variant], align 16
+  %a78 = alloca [8 x i32], align 16
+  %.anon79 = alloca i64, align 8
+  %i83 = alloca i64, align 8
+  %x84 = alloca i32, align 4
+  %retparam85 = alloca i64, align 8
+  %varargslots86 = alloca [2 x %variant], align 16
   %b = alloca [7 x i32], align 16
-  %.anon113 = alloca i64, align 8
-  %i117 = alloca i64, align 8
-  %x118 = alloca i32, align 4
-  %retparam119 = alloca i64, align 8
-  %varargslots120 = alloca [2 x %variant], align 16
+  %.anon89 = alloca i64, align 8
+  %i93 = alloca i64, align 8
+  %x94 = alloca i32, align 4
+  %retparam95 = alloca i64, align 8
+  %varargslots96 = alloca [2 x %variant], align 16
   %c = alloca [8 x i32], align 16
-  %.anon126 = alloca i64, align 8
-  %i130 = alloca i64, align 8
-  %x131 = alloca i32, align 4
-  %retparam132 = alloca i64, align 8
-  %varargslots133 = alloca [2 x %variant], align 16
-  %a139 = alloca [6 x i32], align 16
-  %.anon140 = alloca i64, align 8
-  %i144 = alloca i64, align 8
-  %x145 = alloca i32, align 4
-  %retparam146 = alloca i64, align 8
-  %varargslots147 = alloca [2 x %variant], align 16
+  %.anon99 = alloca i64, align 8
+  %i103 = alloca i64, align 8
+  %x104 = alloca i32, align 4
+  %retparam105 = alloca i64, align 8
+  %varargslots106 = alloca [2 x %variant], align 16
+  %a109 = alloca [6 x i32], align 16
+  %.anon110 = alloca i64, align 8
+  %i114 = alloca i64, align 8
+  %x115 = alloca i32, align 4
+  %retparam116 = alloca i64, align 8
+  %varargslots117 = alloca [2 x %variant], align 16
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a, ptr align 4 @.__const, i32 12, i1 false)
   store i64 0, ptr %.anon, align 8
   br label %loop.cond
 
-loop.cond:                                        ; preds = %voiderr, %entry
+loop.cond:                                        ; preds = %loop.body, %entry
   %0 = load i64, ptr %.anon, align 8
   %gt = icmp ugt i64 3, %0
   br i1 %gt, label %loop.body, label %loop.exit
@@ -161,13 +161,6 @@ loop.body:                                        ; preds = %loop.cond
   %10 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %9, ptr %10, align 16
   %11 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 2)
-  %not_err = icmp eq i64 %11, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %loop.body
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %loop.body
   %12 = load i64, ptr %.anon, align 8
   %add = add i64 %12, 1
   store i64 %add, ptr %.anon, align 8
@@ -178,10 +171,10 @@ loop.exit:                                        ; preds = %loop.cond
   store i64 0, ptr %.anon2, align 8
   br label %loop.cond3
 
-loop.cond3:                                       ; preds = %voiderr12, %loop.exit
+loop.cond3:                                       ; preds = %loop.body5, %loop.exit
   %13 = load i64, ptr %.anon2, align 8
   %gt4 = icmp ugt i64 1, %13
-  br i1 %gt4, label %loop.body5, label %loop.exit14
+  br i1 %gt4, label %loop.body5, label %loop.exit11
 
 loop.body5:                                       ; preds = %loop.cond3
   %14 = load i64, ptr %.anon2, align 8
@@ -199,398 +192,321 @@ loop.body5:                                       ; preds = %loop.cond3
   %23 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 1
   store %variant %22, ptr %23, align 16
   %24 = call i64 @std_io_printfn(ptr %retparam8, ptr @.str.2, i64 8, ptr %varargslots9, i64 2)
-  %not_err10 = icmp eq i64 %24, 0
-  br i1 %not_err10, label %after_check11, label %voiderr12
-
-after_check11:                                    ; preds = %loop.body5
-  br label %voiderr12
-
-voiderr12:                                        ; preds = %after_check11, %loop.body5
   %25 = load i64, ptr %.anon2, align 8
-  %add13 = add i64 %25, 1
-  store i64 %add13, ptr %.anon2, align 8
+  %add10 = add i64 %25, 1
+  store i64 %add10, ptr %.anon2, align 8
   br label %loop.cond3
 
-loop.exit14:                                      ; preds = %loop.cond3
-  call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a15, ptr align 16 @.__const.3, i32 16, i1 false)
-  store i64 0, ptr %.anon16, align 8
-  br label %loop.cond17
+loop.exit11:                                      ; preds = %loop.cond3
+  call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a12, ptr align 16 @.__const.3, i32 16, i1 false)
+  store i64 0, ptr %.anon13, align 8
+  br label %loop.cond14
 
-loop.cond17:                                      ; preds = %voiderr26, %loop.exit14
-  %26 = load i64, ptr %.anon16, align 8
-  %gt18 = icmp ugt i64 4, %26
-  br i1 %gt18, label %loop.body19, label %loop.exit28
+loop.cond14:                                      ; preds = %loop.body16, %loop.exit11
+  %26 = load i64, ptr %.anon13, align 8
+  %gt15 = icmp ugt i64 4, %26
+  br i1 %gt15, label %loop.body16, label %loop.exit22
 
-loop.body19:                                      ; preds = %loop.cond17
-  %27 = load i64, ptr %.anon16, align 8
-  store i64 %27, ptr %i20, align 8
-  %28 = load i64, ptr %.anon16, align 8
-  %29 = getelementptr inbounds [4 x i32], ptr %a15, i64 0, i64 %28
+loop.body16:                                      ; preds = %loop.cond14
+  %27 = load i64, ptr %.anon13, align 8
+  store i64 %27, ptr %i17, align 8
+  %28 = load i64, ptr %.anon13, align 8
+  %29 = getelementptr inbounds [4 x i32], ptr %a12, i64 0, i64 %28
   %30 = load i32, ptr %29, align 4
-  store i32 %30, ptr %x21, align 4
-  %31 = insertvalue %variant undef, ptr %i20, 0
+  store i32 %30, ptr %x18, align 4
+  %31 = insertvalue %variant undef, ptr %i17, 0
   %32 = insertvalue %variant %31, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %33 = getelementptr inbounds [2 x %variant], ptr %varargslots23, i64 0, i64 0
+  %33 = getelementptr inbounds [2 x %variant], ptr %varargslots20, i64 0, i64 0
   store %variant %32, ptr %33, align 16
-  %34 = insertvalue %variant undef, ptr %x21, 0
+  %34 = insertvalue %variant undef, ptr %x18, 0
   %35 = insertvalue %variant %34, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %36 = getelementptr inbounds [2 x %variant], ptr %varargslots23, i64 0, i64 1
+  %36 = getelementptr inbounds [2 x %variant], ptr %varargslots20, i64 0, i64 1
   store %variant %35, ptr %36, align 16
-  %37 = call i64 @std_io_printfn(ptr %retparam22, ptr @.str.4, i64 6, ptr %varargslots23, i64 2)
-  %not_err24 = icmp eq i64 %37, 0
-  br i1 %not_err24, label %after_check25, label %voiderr26
+  %37 = call i64 @std_io_printfn(ptr %retparam19, ptr @.str.4, i64 6, ptr %varargslots20, i64 2)
+  %38 = load i64, ptr %.anon13, align 8
+  %add21 = add i64 %38, 1
+  store i64 %add21, ptr %.anon13, align 8
+  br label %loop.cond14
 
-after_check25:                                    ; preds = %loop.body19
-  br label %voiderr26
+loop.exit22:                                      ; preds = %loop.cond14
+  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a23, ptr align 4 @.__const.5, i32 8, i1 false)
+  store i64 0, ptr %.anon24, align 8
+  br label %loop.cond25
 
-voiderr26:                                        ; preds = %after_check25, %loop.body19
-  %38 = load i64, ptr %.anon16, align 8
-  %add27 = add i64 %38, 1
-  store i64 %add27, ptr %.anon16, align 8
-  br label %loop.cond17
+loop.cond25:                                      ; preds = %loop.body27, %loop.exit22
+  %39 = load i64, ptr %.anon24, align 8
+  %gt26 = icmp ugt i64 2, %39
+  br i1 %gt26, label %loop.body27, label %loop.exit33
 
-loop.exit28:                                      ; preds = %loop.cond17
-  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a29, ptr align 4 @.__const.5, i32 8, i1 false)
-  store i64 0, ptr %.anon30, align 8
-  br label %loop.cond31
-
-loop.cond31:                                      ; preds = %voiderr40, %loop.exit28
-  %39 = load i64, ptr %.anon30, align 8
-  %gt32 = icmp ugt i64 2, %39
-  br i1 %gt32, label %loop.body33, label %loop.exit42
-
-loop.body33:                                      ; preds = %loop.cond31
-  %40 = load i64, ptr %.anon30, align 8
-  store i64 %40, ptr %i34, align 8
-  %41 = load i64, ptr %.anon30, align 8
-  %42 = getelementptr inbounds [2 x i32], ptr %a29, i64 0, i64 %41
+loop.body27:                                      ; preds = %loop.cond25
+  %40 = load i64, ptr %.anon24, align 8
+  store i64 %40, ptr %i28, align 8
+  %41 = load i64, ptr %.anon24, align 8
+  %42 = getelementptr inbounds [2 x i32], ptr %a23, i64 0, i64 %41
   %43 = load i32, ptr %42, align 4
-  store i32 %43, ptr %x35, align 4
-  %44 = insertvalue %variant undef, ptr %i34, 0
+  store i32 %43, ptr %x29, align 4
+  %44 = insertvalue %variant undef, ptr %i28, 0
   %45 = insertvalue %variant %44, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %46 = getelementptr inbounds [2 x %variant], ptr %varargslots37, i64 0, i64 0
+  %46 = getelementptr inbounds [2 x %variant], ptr %varargslots31, i64 0, i64 0
   store %variant %45, ptr %46, align 16
-  %47 = insertvalue %variant undef, ptr %x35, 0
+  %47 = insertvalue %variant undef, ptr %x29, 0
   %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %49 = getelementptr inbounds [2 x %variant], ptr %varargslots37, i64 0, i64 1
+  %49 = getelementptr inbounds [2 x %variant], ptr %varargslots31, i64 0, i64 1
   store %variant %48, ptr %49, align 16
-  %50 = call i64 @std_io_printfn(ptr %retparam36, ptr @.str.6, i64 6, ptr %varargslots37, i64 2)
-  %not_err38 = icmp eq i64 %50, 0
-  br i1 %not_err38, label %after_check39, label %voiderr40
+  %50 = call i64 @std_io_printfn(ptr %retparam30, ptr @.str.6, i64 6, ptr %varargslots31, i64 2)
+  %51 = load i64, ptr %.anon24, align 8
+  %add32 = add i64 %51, 1
+  store i64 %add32, ptr %.anon24, align 8
+  br label %loop.cond25
 
-after_check39:                                    ; preds = %loop.body33
-  br label %voiderr40
+loop.exit33:                                      ; preds = %loop.cond25
+  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a34, ptr align 4 @.__const.7, i32 12, i1 false)
+  store i64 0, ptr %.anon35, align 8
+  br label %loop.cond36
 
-voiderr40:                                        ; preds = %after_check39, %loop.body33
-  %51 = load i64, ptr %.anon30, align 8
-  %add41 = add i64 %51, 1
-  store i64 %add41, ptr %.anon30, align 8
-  br label %loop.cond31
+loop.cond36:                                      ; preds = %loop.body38, %loop.exit33
+  %52 = load i64, ptr %.anon35, align 8
+  %gt37 = icmp ugt i64 3, %52
+  br i1 %gt37, label %loop.body38, label %loop.exit44
 
-loop.exit42:                                      ; preds = %loop.cond31
-  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a43, ptr align 4 @.__const.7, i32 12, i1 false)
-  store i64 0, ptr %.anon44, align 8
-  br label %loop.cond45
-
-loop.cond45:                                      ; preds = %voiderr54, %loop.exit42
-  %52 = load i64, ptr %.anon44, align 8
-  %gt46 = icmp ugt i64 3, %52
-  br i1 %gt46, label %loop.body47, label %loop.exit56
-
-loop.body47:                                      ; preds = %loop.cond45
-  %53 = load i64, ptr %.anon44, align 8
-  store i64 %53, ptr %i48, align 8
-  %54 = load i64, ptr %.anon44, align 8
-  %55 = getelementptr inbounds [3 x i32], ptr %a43, i64 0, i64 %54
+loop.body38:                                      ; preds = %loop.cond36
+  %53 = load i64, ptr %.anon35, align 8
+  store i64 %53, ptr %i39, align 8
+  %54 = load i64, ptr %.anon35, align 8
+  %55 = getelementptr inbounds [3 x i32], ptr %a34, i64 0, i64 %54
   %56 = load i32, ptr %55, align 4
-  store i32 %56, ptr %x49, align 4
-  %57 = insertvalue %variant undef, ptr %i48, 0
+  store i32 %56, ptr %x40, align 4
+  %57 = insertvalue %variant undef, ptr %i39, 0
   %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %59 = getelementptr inbounds [2 x %variant], ptr %varargslots51, i64 0, i64 0
+  %59 = getelementptr inbounds [2 x %variant], ptr %varargslots42, i64 0, i64 0
   store %variant %58, ptr %59, align 16
-  %60 = insertvalue %variant undef, ptr %x49, 0
+  %60 = insertvalue %variant undef, ptr %x40, 0
   %61 = insertvalue %variant %60, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %62 = getelementptr inbounds [2 x %variant], ptr %varargslots51, i64 0, i64 1
+  %62 = getelementptr inbounds [2 x %variant], ptr %varargslots42, i64 0, i64 1
   store %variant %61, ptr %62, align 16
-  %63 = call i64 @std_io_printfn(ptr %retparam50, ptr @.str.8, i64 8, ptr %varargslots51, i64 2)
-  %not_err52 = icmp eq i64 %63, 0
-  br i1 %not_err52, label %after_check53, label %voiderr54
+  %63 = call i64 @std_io_printfn(ptr %retparam41, ptr @.str.8, i64 8, ptr %varargslots42, i64 2)
+  %64 = load i64, ptr %.anon35, align 8
+  %add43 = add i64 %64, 1
+  store i64 %add43, ptr %.anon35, align 8
+  br label %loop.cond36
 
-after_check53:                                    ; preds = %loop.body47
-  br label %voiderr54
+loop.exit44:                                      ; preds = %loop.cond36
+  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a45, ptr align 4 @.__const.9, i32 4, i1 false)
+  store i64 0, ptr %.anon46, align 8
+  br label %loop.cond47
 
-voiderr54:                                        ; preds = %after_check53, %loop.body47
-  %64 = load i64, ptr %.anon44, align 8
-  %add55 = add i64 %64, 1
-  store i64 %add55, ptr %.anon44, align 8
-  br label %loop.cond45
+loop.cond47:                                      ; preds = %loop.body49, %loop.exit44
+  %65 = load i64, ptr %.anon46, align 8
+  %gt48 = icmp ugt i64 1, %65
+  br i1 %gt48, label %loop.body49, label %loop.exit55
 
-loop.exit56:                                      ; preds = %loop.cond45
-  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a57, ptr align 4 @.__const.9, i32 4, i1 false)
-  store i64 0, ptr %.anon58, align 8
-  br label %loop.cond59
-
-loop.cond59:                                      ; preds = %voiderr68, %loop.exit56
-  %65 = load i64, ptr %.anon58, align 8
-  %gt60 = icmp ugt i64 1, %65
-  br i1 %gt60, label %loop.body61, label %loop.exit70
-
-loop.body61:                                      ; preds = %loop.cond59
-  %66 = load i64, ptr %.anon58, align 8
-  store i64 %66, ptr %i62, align 8
-  %67 = load i64, ptr %.anon58, align 8
-  %68 = getelementptr inbounds [1 x i32], ptr %a57, i64 0, i64 %67
+loop.body49:                                      ; preds = %loop.cond47
+  %66 = load i64, ptr %.anon46, align 8
+  store i64 %66, ptr %i50, align 8
+  %67 = load i64, ptr %.anon46, align 8
+  %68 = getelementptr inbounds [1 x i32], ptr %a45, i64 0, i64 %67
   %69 = load i32, ptr %68, align 4
-  store i32 %69, ptr %x63, align 4
-  %70 = insertvalue %variant undef, ptr %i62, 0
+  store i32 %69, ptr %x51, align 4
+  %70 = insertvalue %variant undef, ptr %i50, 0
   %71 = insertvalue %variant %70, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %72 = getelementptr inbounds [2 x %variant], ptr %varargslots65, i64 0, i64 0
+  %72 = getelementptr inbounds [2 x %variant], ptr %varargslots53, i64 0, i64 0
   store %variant %71, ptr %72, align 16
-  %73 = insertvalue %variant undef, ptr %x63, 0
+  %73 = insertvalue %variant undef, ptr %x51, 0
   %74 = insertvalue %variant %73, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %75 = getelementptr inbounds [2 x %variant], ptr %varargslots65, i64 0, i64 1
+  %75 = getelementptr inbounds [2 x %variant], ptr %varargslots53, i64 0, i64 1
   store %variant %74, ptr %75, align 16
-  %76 = call i64 @std_io_printfn(ptr %retparam64, ptr @.str.10, i64 8, ptr %varargslots65, i64 2)
-  %not_err66 = icmp eq i64 %76, 0
-  br i1 %not_err66, label %after_check67, label %voiderr68
+  %76 = call i64 @std_io_printfn(ptr %retparam52, ptr @.str.10, i64 8, ptr %varargslots53, i64 2)
+  %77 = load i64, ptr %.anon46, align 8
+  %add54 = add i64 %77, 1
+  store i64 %add54, ptr %.anon46, align 8
+  br label %loop.cond47
 
-after_check67:                                    ; preds = %loop.body61
-  br label %voiderr68
+loop.exit55:                                      ; preds = %loop.cond47
+  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a56, ptr align 4 @.__const.11, i32 8, i1 false)
+  store i64 0, ptr %.anon57, align 8
+  br label %loop.cond58
 
-voiderr68:                                        ; preds = %after_check67, %loop.body61
-  %77 = load i64, ptr %.anon58, align 8
-  %add69 = add i64 %77, 1
-  store i64 %add69, ptr %.anon58, align 8
-  br label %loop.cond59
+loop.cond58:                                      ; preds = %loop.body60, %loop.exit55
+  %78 = load i64, ptr %.anon57, align 8
+  %gt59 = icmp ugt i64 2, %78
+  br i1 %gt59, label %loop.body60, label %loop.exit66
 
-loop.exit70:                                      ; preds = %loop.cond59
-  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a71, ptr align 4 @.__const.11, i32 8, i1 false)
-  store i64 0, ptr %.anon72, align 8
-  br label %loop.cond73
-
-loop.cond73:                                      ; preds = %voiderr82, %loop.exit70
-  %78 = load i64, ptr %.anon72, align 8
-  %gt74 = icmp ugt i64 2, %78
-  br i1 %gt74, label %loop.body75, label %loop.exit84
-
-loop.body75:                                      ; preds = %loop.cond73
-  %79 = load i64, ptr %.anon72, align 8
-  store i64 %79, ptr %i76, align 8
-  %80 = load i64, ptr %.anon72, align 8
-  %81 = getelementptr inbounds [2 x i32], ptr %a71, i64 0, i64 %80
+loop.body60:                                      ; preds = %loop.cond58
+  %79 = load i64, ptr %.anon57, align 8
+  store i64 %79, ptr %i61, align 8
+  %80 = load i64, ptr %.anon57, align 8
+  %81 = getelementptr inbounds [2 x i32], ptr %a56, i64 0, i64 %80
   %82 = load i32, ptr %81, align 4
-  store i32 %82, ptr %x77, align 4
-  %83 = insertvalue %variant undef, ptr %i76, 0
+  store i32 %82, ptr %x62, align 4
+  %83 = insertvalue %variant undef, ptr %i61, 0
   %84 = insertvalue %variant %83, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %85 = getelementptr inbounds [2 x %variant], ptr %varargslots79, i64 0, i64 0
+  %85 = getelementptr inbounds [2 x %variant], ptr %varargslots64, i64 0, i64 0
   store %variant %84, ptr %85, align 16
-  %86 = insertvalue %variant undef, ptr %x77, 0
+  %86 = insertvalue %variant undef, ptr %x62, 0
   %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %88 = getelementptr inbounds [2 x %variant], ptr %varargslots79, i64 0, i64 1
+  %88 = getelementptr inbounds [2 x %variant], ptr %varargslots64, i64 0, i64 1
   store %variant %87, ptr %88, align 16
-  %89 = call i64 @std_io_printfn(ptr %retparam78, ptr @.str.12, i64 8, ptr %varargslots79, i64 2)
-  %not_err80 = icmp eq i64 %89, 0
-  br i1 %not_err80, label %after_check81, label %voiderr82
+  %89 = call i64 @std_io_printfn(ptr %retparam63, ptr @.str.12, i64 8, ptr %varargslots64, i64 2)
+  %90 = load i64, ptr %.anon57, align 8
+  %add65 = add i64 %90, 1
+  store i64 %add65, ptr %.anon57, align 8
+  br label %loop.cond58
 
-after_check81:                                    ; preds = %loop.body75
-  br label %voiderr82
+loop.exit66:                                      ; preds = %loop.cond58
+  call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a67, ptr align 16 @.__const.13, i32 20, i1 false)
+  store i64 0, ptr %.anon68, align 8
+  br label %loop.cond69
 
-voiderr82:                                        ; preds = %after_check81, %loop.body75
-  %90 = load i64, ptr %.anon72, align 8
-  %add83 = add i64 %90, 1
-  store i64 %add83, ptr %.anon72, align 8
-  br label %loop.cond73
+loop.cond69:                                      ; preds = %loop.body71, %loop.exit66
+  %91 = load i64, ptr %.anon68, align 8
+  %gt70 = icmp ugt i64 5, %91
+  br i1 %gt70, label %loop.body71, label %loop.exit77
 
-loop.exit84:                                      ; preds = %loop.cond73
-  call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a85, ptr align 16 @.__const.13, i32 20, i1 false)
-  store i64 0, ptr %.anon86, align 8
-  br label %loop.cond87
-
-loop.cond87:                                      ; preds = %voiderr96, %loop.exit84
-  %91 = load i64, ptr %.anon86, align 8
-  %gt88 = icmp ugt i64 5, %91
-  br i1 %gt88, label %loop.body89, label %loop.exit98
-
-loop.body89:                                      ; preds = %loop.cond87
-  %92 = load i64, ptr %.anon86, align 8
-  store i64 %92, ptr %i90, align 8
-  %93 = load i64, ptr %.anon86, align 8
-  %94 = getelementptr inbounds [5 x i32], ptr %a85, i64 0, i64 %93
+loop.body71:                                      ; preds = %loop.cond69
+  %92 = load i64, ptr %.anon68, align 8
+  store i64 %92, ptr %i72, align 8
+  %93 = load i64, ptr %.anon68, align 8
+  %94 = getelementptr inbounds [5 x i32], ptr %a67, i64 0, i64 %93
   %95 = load i32, ptr %94, align 4
-  store i32 %95, ptr %x91, align 4
-  %96 = insertvalue %variant undef, ptr %i90, 0
+  store i32 %95, ptr %x73, align 4
+  %96 = insertvalue %variant undef, ptr %i72, 0
   %97 = insertvalue %variant %96, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %98 = getelementptr inbounds [2 x %variant], ptr %varargslots93, i64 0, i64 0
+  %98 = getelementptr inbounds [2 x %variant], ptr %varargslots75, i64 0, i64 0
   store %variant %97, ptr %98, align 16
-  %99 = insertvalue %variant undef, ptr %x91, 0
+  %99 = insertvalue %variant undef, ptr %x73, 0
   %100 = insertvalue %variant %99, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %101 = getelementptr inbounds [2 x %variant], ptr %varargslots93, i64 0, i64 1
+  %101 = getelementptr inbounds [2 x %variant], ptr %varargslots75, i64 0, i64 1
   store %variant %100, ptr %101, align 16
-  %102 = call i64 @std_io_printfn(ptr %retparam92, ptr @.str.14, i64 8, ptr %varargslots93, i64 2)
-  %not_err94 = icmp eq i64 %102, 0
-  br i1 %not_err94, label %after_check95, label %voiderr96
+  %102 = call i64 @std_io_printfn(ptr %retparam74, ptr @.str.14, i64 8, ptr %varargslots75, i64 2)
+  %103 = load i64, ptr %.anon68, align 8
+  %add76 = add i64 %103, 1
+  store i64 %add76, ptr %.anon68, align 8
+  br label %loop.cond69
 
-after_check95:                                    ; preds = %loop.body89
-  br label %voiderr96
+loop.exit77:                                      ; preds = %loop.cond69
+  call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a78, ptr align 16 @.__const.15, i32 32, i1 false)
+  store i64 0, ptr %.anon79, align 8
+  br label %loop.cond80
 
-voiderr96:                                        ; preds = %after_check95, %loop.body89
-  %103 = load i64, ptr %.anon86, align 8
-  %add97 = add i64 %103, 1
-  store i64 %add97, ptr %.anon86, align 8
-  br label %loop.cond87
+loop.cond80:                                      ; preds = %loop.body82, %loop.exit77
+  %104 = load i64, ptr %.anon79, align 8
+  %gt81 = icmp ugt i64 8, %104
+  br i1 %gt81, label %loop.body82, label %loop.exit88
 
-loop.exit98:                                      ; preds = %loop.cond87
-  call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a99, ptr align 16 @.__const.15, i32 32, i1 false)
-  store i64 0, ptr %.anon100, align 8
-  br label %loop.cond101
-
-loop.cond101:                                     ; preds = %voiderr110, %loop.exit98
-  %104 = load i64, ptr %.anon100, align 8
-  %gt102 = icmp ugt i64 8, %104
-  br i1 %gt102, label %loop.body103, label %loop.exit112
-
-loop.body103:                                     ; preds = %loop.cond101
-  %105 = load i64, ptr %.anon100, align 8
-  store i64 %105, ptr %i104, align 8
-  %106 = load i64, ptr %.anon100, align 8
-  %107 = getelementptr inbounds [8 x i32], ptr %a99, i64 0, i64 %106
+loop.body82:                                      ; preds = %loop.cond80
+  %105 = load i64, ptr %.anon79, align 8
+  store i64 %105, ptr %i83, align 8
+  %106 = load i64, ptr %.anon79, align 8
+  %107 = getelementptr inbounds [8 x i32], ptr %a78, i64 0, i64 %106
   %108 = load i32, ptr %107, align 4
-  store i32 %108, ptr %x105, align 4
-  %109 = insertvalue %variant undef, ptr %i104, 0
+  store i32 %108, ptr %x84, align 4
+  %109 = insertvalue %variant undef, ptr %i83, 0
   %110 = insertvalue %variant %109, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %111 = getelementptr inbounds [2 x %variant], ptr %varargslots107, i64 0, i64 0
+  %111 = getelementptr inbounds [2 x %variant], ptr %varargslots86, i64 0, i64 0
   store %variant %110, ptr %111, align 16
-  %112 = insertvalue %variant undef, ptr %x105, 0
+  %112 = insertvalue %variant undef, ptr %x84, 0
   %113 = insertvalue %variant %112, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %114 = getelementptr inbounds [2 x %variant], ptr %varargslots107, i64 0, i64 1
+  %114 = getelementptr inbounds [2 x %variant], ptr %varargslots86, i64 0, i64 1
   store %variant %113, ptr %114, align 16
-  %115 = call i64 @std_io_printfn(ptr %retparam106, ptr @.str.16, i64 8, ptr %varargslots107, i64 2)
-  %not_err108 = icmp eq i64 %115, 0
-  br i1 %not_err108, label %after_check109, label %voiderr110
+  %115 = call i64 @std_io_printfn(ptr %retparam85, ptr @.str.16, i64 8, ptr %varargslots86, i64 2)
+  %116 = load i64, ptr %.anon79, align 8
+  %add87 = add i64 %116, 1
+  store i64 %add87, ptr %.anon79, align 8
+  br label %loop.cond80
 
-after_check109:                                   ; preds = %loop.body103
-  br label %voiderr110
-
-voiderr110:                                       ; preds = %after_check109, %loop.body103
-  %116 = load i64, ptr %.anon100, align 8
-  %add111 = add i64 %116, 1
-  store i64 %add111, ptr %.anon100, align 8
-  br label %loop.cond101
-
-loop.exit112:                                     ; preds = %loop.cond101
+loop.exit88:                                      ; preds = %loop.cond80
   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %b, ptr align 16 @.__const.17, i32 28, i1 false)
-  store i64 0, ptr %.anon113, align 8
-  br label %loop.cond114
+  store i64 0, ptr %.anon89, align 8
+  br label %loop.cond90
 
-loop.cond114:                                     ; preds = %voiderr123, %loop.exit112
-  %117 = load i64, ptr %.anon113, align 8
-  %gt115 = icmp ugt i64 7, %117
-  br i1 %gt115, label %loop.body116, label %loop.exit125
+loop.cond90:                                      ; preds = %loop.body92, %loop.exit88
+  %117 = load i64, ptr %.anon89, align 8
+  %gt91 = icmp ugt i64 7, %117
+  br i1 %gt91, label %loop.body92, label %loop.exit98
 
-loop.body116:                                     ; preds = %loop.cond114
-  %118 = load i64, ptr %.anon113, align 8
-  store i64 %118, ptr %i117, align 8
-  %119 = load i64, ptr %.anon113, align 8
+loop.body92:                                      ; preds = %loop.cond90
+  %118 = load i64, ptr %.anon89, align 8
+  store i64 %118, ptr %i93, align 8
+  %119 = load i64, ptr %.anon89, align 8
   %120 = getelementptr inbounds [7 x i32], ptr %b, i64 0, i64 %119
   %121 = load i32, ptr %120, align 4
-  store i32 %121, ptr %x118, align 4
-  %122 = insertvalue %variant undef, ptr %i117, 0
+  store i32 %121, ptr %x94, align 4
+  %122 = insertvalue %variant undef, ptr %i93, 0
   %123 = insertvalue %variant %122, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %124 = getelementptr inbounds [2 x %variant], ptr %varargslots120, i64 0, i64 0
+  %124 = getelementptr inbounds [2 x %variant], ptr %varargslots96, i64 0, i64 0
   store %variant %123, ptr %124, align 16
-  %125 = insertvalue %variant undef, ptr %x118, 0
+  %125 = insertvalue %variant undef, ptr %x94, 0
   %126 = insertvalue %variant %125, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %127 = getelementptr inbounds [2 x %variant], ptr %varargslots120, i64 0, i64 1
+  %127 = getelementptr inbounds [2 x %variant], ptr %varargslots96, i64 0, i64 1
   store %variant %126, ptr %127, align 16
-  %128 = call i64 @std_io_printfn(ptr %retparam119, ptr @.str.18, i64 8, ptr %varargslots120, i64 2)
-  %not_err121 = icmp eq i64 %128, 0
-  br i1 %not_err121, label %after_check122, label %voiderr123
+  %128 = call i64 @std_io_printfn(ptr %retparam95, ptr @.str.18, i64 8, ptr %varargslots96, i64 2)
+  %129 = load i64, ptr %.anon89, align 8
+  %add97 = add i64 %129, 1
+  store i64 %add97, ptr %.anon89, align 8
+  br label %loop.cond90
 
-after_check122:                                   ; preds = %loop.body116
-  br label %voiderr123
-
-voiderr123:                                       ; preds = %after_check122, %loop.body116
-  %129 = load i64, ptr %.anon113, align 8
-  %add124 = add i64 %129, 1
-  store i64 %add124, ptr %.anon113, align 8
-  br label %loop.cond114
-
-loop.exit125:                                     ; preds = %loop.cond114
+loop.exit98:                                      ; preds = %loop.cond90
   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %c, ptr align 16 @.__const.19, i32 32, i1 false)
-  store i64 0, ptr %.anon126, align 8
-  br label %loop.cond127
+  store i64 0, ptr %.anon99, align 8
+  br label %loop.cond100
 
-loop.cond127:                                     ; preds = %voiderr136, %loop.exit125
-  %130 = load i64, ptr %.anon126, align 8
-  %gt128 = icmp ugt i64 8, %130
-  br i1 %gt128, label %loop.body129, label %loop.exit138
+loop.cond100:                                     ; preds = %loop.body102, %loop.exit98
+  %130 = load i64, ptr %.anon99, align 8
+  %gt101 = icmp ugt i64 8, %130
+  br i1 %gt101, label %loop.body102, label %loop.exit108
 
-loop.body129:                                     ; preds = %loop.cond127
-  %131 = load i64, ptr %.anon126, align 8
-  store i64 %131, ptr %i130, align 8
-  %132 = load i64, ptr %.anon126, align 8
+loop.body102:                                     ; preds = %loop.cond100
+  %131 = load i64, ptr %.anon99, align 8
+  store i64 %131, ptr %i103, align 8
+  %132 = load i64, ptr %.anon99, align 8
   %133 = getelementptr inbounds [8 x i32], ptr %c, i64 0, i64 %132
   %134 = load i32, ptr %133, align 4
-  store i32 %134, ptr %x131, align 4
-  %135 = insertvalue %variant undef, ptr %i130, 0
+  store i32 %134, ptr %x104, align 4
+  %135 = insertvalue %variant undef, ptr %i103, 0
   %136 = insertvalue %variant %135, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %137 = getelementptr inbounds [2 x %variant], ptr %varargslots133, i64 0, i64 0
+  %137 = getelementptr inbounds [2 x %variant], ptr %varargslots106, i64 0, i64 0
   store %variant %136, ptr %137, align 16
-  %138 = insertvalue %variant undef, ptr %x131, 0
+  %138 = insertvalue %variant undef, ptr %x104, 0
   %139 = insertvalue %variant %138, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %140 = getelementptr inbounds [2 x %variant], ptr %varargslots133, i64 0, i64 1
+  %140 = getelementptr inbounds [2 x %variant], ptr %varargslots106, i64 0, i64 1
   store %variant %139, ptr %140, align 16
-  %141 = call i64 @std_io_printfn(ptr %retparam132, ptr @.str.20, i64 9, ptr %varargslots133, i64 2)
-  %not_err134 = icmp eq i64 %141, 0
-  br i1 %not_err134, label %after_check135, label %voiderr136
+  %141 = call i64 @std_io_printfn(ptr %retparam105, ptr @.str.20, i64 9, ptr %varargslots106, i64 2)
+  %142 = load i64, ptr %.anon99, align 8
+  %add107 = add i64 %142, 1
+  store i64 %add107, ptr %.anon99, align 8
+  br label %loop.cond100
 
-after_check135:                                   ; preds = %loop.body129
-  br label %voiderr136
+loop.exit108:                                     ; preds = %loop.cond100
+  call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a109, ptr align 16 @.__const.21, i32 24, i1 false)
+  store i64 0, ptr %.anon110, align 8
+  br label %loop.cond111
 
-voiderr136:                                       ; preds = %after_check135, %loop.body129
-  %142 = load i64, ptr %.anon126, align 8
-  %add137 = add i64 %142, 1
-  store i64 %add137, ptr %.anon126, align 8
-  br label %loop.cond127
+loop.cond111:                                     ; preds = %loop.body113, %loop.exit108
+  %143 = load i64, ptr %.anon110, align 8
+  %gt112 = icmp ugt i64 6, %143
+  br i1 %gt112, label %loop.body113, label %loop.exit119
 
-loop.exit138:                                     ; preds = %loop.cond127
-  call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a139, ptr align 16 @.__const.21, i32 24, i1 false)
-  store i64 0, ptr %.anon140, align 8
-  br label %loop.cond141
-
-loop.cond141:                                     ; preds = %voiderr150, %loop.exit138
-  %143 = load i64, ptr %.anon140, align 8
-  %gt142 = icmp ugt i64 6, %143
-  br i1 %gt142, label %loop.body143, label %loop.exit152
-
-loop.body143:                                     ; preds = %loop.cond141
-  %144 = load i64, ptr %.anon140, align 8
-  store i64 %144, ptr %i144, align 8
-  %145 = load i64, ptr %.anon140, align 8
-  %146 = getelementptr inbounds [6 x i32], ptr %a139, i64 0, i64 %145
+loop.body113:                                     ; preds = %loop.cond111
+  %144 = load i64, ptr %.anon110, align 8
+  store i64 %144, ptr %i114, align 8
+  %145 = load i64, ptr %.anon110, align 8
+  %146 = getelementptr inbounds [6 x i32], ptr %a109, i64 0, i64 %145
   %147 = load i32, ptr %146, align 4
-  store i32 %147, ptr %x145, align 4
-  %148 = insertvalue %variant undef, ptr %i144, 0
+  store i32 %147, ptr %x115, align 4
+  %148 = insertvalue %variant undef, ptr %i114, 0
   %149 = insertvalue %variant %148, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
-  %150 = getelementptr inbounds [2 x %variant], ptr %varargslots147, i64 0, i64 0
+  %150 = getelementptr inbounds [2 x %variant], ptr %varargslots117, i64 0, i64 0
   store %variant %149, ptr %150, align 16
-  %151 = insertvalue %variant undef, ptr %x145, 0
+  %151 = insertvalue %variant undef, ptr %x115, 0
   %152 = insertvalue %variant %151, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %153 = getelementptr inbounds [2 x %variant], ptr %varargslots147, i64 0, i64 1
+  %153 = getelementptr inbounds [2 x %variant], ptr %varargslots117, i64 0, i64 1
   store %variant %152, ptr %153, align 16
-  %154 = call i64 @std_io_printfn(ptr %retparam146, ptr @.str.22, i64 6, ptr %varargslots147, i64 2)
-  %not_err148 = icmp eq i64 %154, 0
-  br i1 %not_err148, label %after_check149, label %voiderr150
+  %154 = call i64 @std_io_printfn(ptr %retparam116, ptr @.str.22, i64 6, ptr %varargslots117, i64 2)
+  %155 = load i64, ptr %.anon110, align 8
+  %add118 = add i64 %155, 1
+  store i64 %add118, ptr %.anon110, align 8
+  br label %loop.cond111
 
-after_check149:                                   ; preds = %loop.body143
-  br label %voiderr150
-
-voiderr150:                                       ; preds = %after_check149, %loop.body143
-  %155 = load i64, ptr %.anon140, align 8
-  %add151 = add i64 %155, 1
-  store i64 %add151, ptr %.anon140, align 8
-  br label %loop.cond141
-
-loop.exit152:                                     ; preds = %loop.cond141
+loop.exit119:                                     ; preds = %loop.cond111
   ret void
 }
diff --git a/test/test_suite/slices/slice_to_slice_assign.c3t b/test/test_suite/slices/slice_to_slice_assign.c3t
index a6329087d..8917819c7 100644
--- a/test/test_suite/slices/slice_to_slice_assign.c3t
+++ b/test/test_suite/slices/slice_to_slice_assign.c3t
@@ -32,17 +32,17 @@ entry:
   %varargslots3 = alloca [2 x %variant], align 16
   %a = alloca %"int[][]", align 8
   %literal = alloca [1 x %"int[]"], align 16
-  %literal7 = alloca [1 x i32], align 4
+  %literal4 = alloca [1 x i32], align 4
   %b = alloca %"int[][]", align 8
-  %literal8 = alloca [1 x %"int[]"], align 16
-  %literal9 = alloca [1 x i32], align 4
-  %retparam10 = alloca i64, align 8
-  %varargslots11 = alloca [1 x %variant], align 16
-  %taddr16 = alloca %"int[][]", align 8
-  %retparam17 = alloca i64, align 8
-  %varargslots18 = alloca [1 x %variant], align 16
-  %retparam23 = alloca i64, align 8
-  %varargslots24 = alloca [1 x %variant], align 16
+  %literal5 = alloca [1 x %"int[]"], align 16
+  %literal6 = alloca [1 x i32], align 4
+  %retparam7 = alloca i64, align 8
+  %varargslots8 = alloca [1 x %variant], align 16
+  %taddr10 = alloca %"int[][]", align 8
+  %retparam11 = alloca i64, align 8
+  %varargslots12 = alloca [1 x %variant], align 16
+  %retparam14 = alloca i64, align 8
+  %varargslots15 = alloca [1 x %variant], align 16
   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %z, ptr align 16 @.__const, i32 28, i1 false)
   call void @llvm.memset.p0.i64(ptr align 16 %y, i8 0, i64 24, i1 false)
   %0 = getelementptr inbounds [7 x i32], ptr %z, i64 0, i64 3
@@ -67,13 +67,6 @@ entry:
   %16 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %15, ptr %16, align 16
   %17 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2)
-  %not_err = icmp eq i64 %17, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   %18 = getelementptr inbounds [7 x i32], ptr %z, i64 0, i64 5
   %19 = insertvalue %"int[]" undef, ptr %18, 0
   %20 = insertvalue %"int[]" %19, i64 2, 1
@@ -96,43 +89,29 @@ voiderr:                                          ; preds = %after_check, %entry
   %34 = getelementptr inbounds [2 x %variant], ptr %varargslots3, i64 0, i64 1
   store %variant %33, ptr %34, align 16
   %35 = call i64 @std_io_printfn(ptr %retparam2, ptr @.str.1, i64 5, ptr %varargslots3, i64 2)
-  %not_err4 = icmp eq i64 %35, 0
-  br i1 %not_err4, label %after_check5, label %voiderr6
-
-after_check5:                                     ; preds = %voiderr
-  br label %voiderr6
-
-voiderr6:                                         ; preds = %after_check5, %voiderr
   %36 = getelementptr inbounds [1 x %"int[]"], ptr %literal, i64 0, i64 0
-  %37 = getelementptr inbounds [1 x i32], ptr %literal7, i64 0, i64 0
+  %37 = getelementptr inbounds [1 x i32], ptr %literal4, i64 0, i64 0
   store i32 1, ptr %37, align 4
-  %38 = insertvalue %"int[]" undef, ptr %literal7, 0
+  %38 = insertvalue %"int[]" undef, ptr %literal4, 0
   %39 = insertvalue %"int[]" %38, i64 1, 1
   store %"int[]" %39, ptr %36, align 8
   %40 = insertvalue %"int[][]" undef, ptr %literal, 0
   %41 = insertvalue %"int[][]" %40, i64 1, 1
   store %"int[][]" %41, ptr %a, align 8
-  %42 = getelementptr inbounds [1 x %"int[]"], ptr %literal8, i64 0, i64 0
-  %43 = getelementptr inbounds [1 x i32], ptr %literal9, i64 0, i64 0
+  %42 = getelementptr inbounds [1 x %"int[]"], ptr %literal5, i64 0, i64 0
+  %43 = getelementptr inbounds [1 x i32], ptr %literal6, i64 0, i64 0
   store i32 2, ptr %43, align 4
-  %44 = insertvalue %"int[]" undef, ptr %literal9, 0
+  %44 = insertvalue %"int[]" undef, ptr %literal6, 0
   %45 = insertvalue %"int[]" %44, i64 1, 1
   store %"int[]" %45, ptr %42, align 8
-  %46 = insertvalue %"int[][]" undef, ptr %literal8, 0
+  %46 = insertvalue %"int[][]" undef, ptr %literal5, 0
   %47 = insertvalue %"int[][]" %46, i64 1, 1
   store %"int[][]" %47, ptr %b, align 8
   %48 = insertvalue %variant undef, ptr %a, 0
   %49 = insertvalue %variant %48, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1
-  %50 = getelementptr inbounds [1 x %variant], ptr %varargslots11, i64 0, i64 0
+  %50 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
   store %variant %49, ptr %50, align 16
-  %51 = call i64 @std_io_printfn(ptr %retparam10, ptr @.str.2, i64 2, ptr %varargslots11, i64 1)
-  %not_err12 = icmp eq i64 %51, 0
-  br i1 %not_err12, label %after_check13, label %voiderr14
-
-after_check13:                                    ; preds = %voiderr6
-  br label %voiderr14
-
-voiderr14:                                        ; preds = %after_check13, %voiderr6
+  %51 = call i64 @std_io_printfn(ptr %retparam7, ptr @.str.2, i64 2, ptr %varargslots8, i64 1)
   %52 = load %"int[][]", ptr %b, align 8
   %53 = extractvalue %"int[][]" %52, 0
   %ptroffset = getelementptr inbounds %"int[]", ptr %53, i64 0
@@ -140,46 +119,32 @@ voiderr14:                                        ; preds = %after_check13, %voi
   %55 = insertvalue %"int[][]" %54, i64 1, 1
   %56 = load %"int[][]", ptr %a, align 8
   %57 = extractvalue %"int[][]" %56, 0
-  %ptroffset15 = getelementptr inbounds %"int[]", ptr %57, i64 0
-  %58 = insertvalue %"int[][]" undef, ptr %ptroffset15, 0
+  %ptroffset9 = getelementptr inbounds %"int[]", ptr %57, i64 0
+  %58 = insertvalue %"int[][]" undef, ptr %ptroffset9, 0
   %59 = insertvalue %"int[][]" %58, i64 1, 1
   %60 = extractvalue %"int[][]" %59, 0
   %61 = extractvalue %"int[][]" %55, 0
-  store %"int[][]" %55, ptr %taddr16, align 8
-  %62 = getelementptr inbounds %"int[][]", ptr %taddr16, i32 0, i32 1
+  store %"int[][]" %55, ptr %taddr10, align 8
+  %62 = getelementptr inbounds %"int[][]", ptr %taddr10, i32 0, i32 1
   %63 = load i64, ptr %62, align 8
   %64 = mul i64 %63, 16
   call void @llvm.memcpy.p0.p0.i64(ptr align 8 %60, ptr align 8 %61, i64 %64, i1 false)
   %65 = insertvalue %variant undef, ptr %a, 0
   %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1
-  %67 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0
+  %67 = getelementptr inbounds [1 x %variant], ptr %varargslots12, i64 0, i64 0
   store %variant %66, ptr %67, align 16
-  %68 = call i64 @std_io_printfn(ptr %retparam17, ptr @.str.3, i64 2, ptr %varargslots18, i64 1)
-  %not_err19 = icmp eq i64 %68, 0
-  br i1 %not_err19, label %after_check20, label %voiderr21
-
-after_check20:                                    ; preds = %voiderr14
-  br label %voiderr21
-
-voiderr21:                                        ; preds = %after_check20, %voiderr14
+  %68 = call i64 @std_io_printfn(ptr %retparam11, ptr @.str.3, i64 2, ptr %varargslots12, i64 1)
   %69 = getelementptr inbounds [6 x i32], ptr %y, i64 0, i64 2
   %70 = insertvalue %"int[]" undef, ptr %69, 0
   %71 = insertvalue %"int[]" %70, i64 3, 1
   %72 = load %"int[][]", ptr %a, align 8
   %73 = extractvalue %"int[][]" %72, 0
-  %ptroffset22 = getelementptr inbounds %"int[]", ptr %73, i64 0
-  store %"int[]" %71, ptr %ptroffset22, align 8
+  %ptroffset13 = getelementptr inbounds %"int[]", ptr %73, i64 0
+  store %"int[]" %71, ptr %ptroffset13, align 8
   %74 = insertvalue %variant undef, ptr %a, 0
   %75 = insertvalue %variant %74, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1
-  %76 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0
+  %76 = getelementptr inbounds [1 x %variant], ptr %varargslots15, i64 0, i64 0
   store %variant %75, ptr %76, align 16
-  %77 = call i64 @std_io_printfn(ptr %retparam23, ptr @.str.4, i64 2, ptr %varargslots24, i64 1)
-  %not_err25 = icmp eq i64 %77, 0
-  br i1 %not_err25, label %after_check26, label %voiderr27
-
-after_check26:                                    ; preds = %voiderr21
-  br label %voiderr27
-
-voiderr27:                                        ; preds = %after_check26, %voiderr21
+  %77 = call i64 @std_io_printfn(ptr %retparam14, ptr @.str.4, i64 2, ptr %varargslots15, i64 1)
   ret void
 }
diff --git a/test/test_suite/slices/slice_to_slice_vector_assign.c3t b/test/test_suite/slices/slice_to_slice_vector_assign.c3t
index c00ca9c89..4cd62f017 100644
--- a/test/test_suite/slices/slice_to_slice_vector_assign.c3t
+++ b/test/test_suite/slices/slice_to_slice_vector_assign.c3t
@@ -33,17 +33,17 @@ entry:
   %varargslots3 = alloca [2 x %variant], align 16
   %a = alloca %"int[][]", align 8
   %literal = alloca [1 x %"int[]"], align 16
-  %literal7 = alloca [1 x i32], align 4
+  %literal4 = alloca [1 x i32], align 4
   %b = alloca %"int[][]", align 8
-  %literal8 = alloca [1 x %"int[]"], align 16
-  %literal9 = alloca [1 x i32], align 4
-  %retparam10 = alloca i64, align 8
-  %varargslots11 = alloca [1 x %variant], align 16
-  %taddr16 = alloca %"int[][]", align 8
-  %retparam17 = alloca i64, align 8
-  %varargslots18 = alloca [1 x %variant], align 16
-  %retparam23 = alloca i64, align 8
-  %varargslots24 = alloca [1 x %variant], align 16
+  %literal5 = alloca [1 x %"int[]"], align 16
+  %literal6 = alloca [1 x i32], align 4
+  %retparam7 = alloca i64, align 8
+  %varargslots8 = alloca [1 x %variant], align 16
+  %taddr10 = alloca %"int[][]", align 8
+  %retparam11 = alloca i64, align 8
+  %varargslots12 = alloca [1 x %variant], align 16
+  %retparam14 = alloca i64, align 8
+  %varargslots15 = alloca [1 x %variant], align 16
   store <7 x i32> <i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>, ptr %z, align 32
   store <6 x i32> zeroinitializer, ptr %y, align 32
   %0 = getelementptr inbounds <7 x i32>, ptr %z, i64 0, i64 3
@@ -68,13 +68,6 @@ entry:
   %16 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %15, ptr %16, align 16
   %17 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2)
-  %not_err = icmp eq i64 %17, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   %18 = getelementptr inbounds <7 x i32>, ptr %z, i64 0, i64 5
   %19 = insertvalue %"int[]" undef, ptr %18, 0
   %20 = insertvalue %"int[]" %19, i64 2, 1
@@ -97,43 +90,29 @@ voiderr:                                          ; preds = %after_check, %entry
   %34 = getelementptr inbounds [2 x %variant], ptr %varargslots3, i64 0, i64 1
   store %variant %33, ptr %34, align 16
   %35 = call i64 @std_io_printfn(ptr %retparam2, ptr @.str.1, i64 5, ptr %varargslots3, i64 2)
-  %not_err4 = icmp eq i64 %35, 0
-  br i1 %not_err4, label %after_check5, label %voiderr6
-
-after_check5:                                     ; preds = %voiderr
-  br label %voiderr6
-
-voiderr6:                                         ; preds = %after_check5, %voiderr
   %36 = getelementptr inbounds [1 x %"int[]"], ptr %literal, i64 0, i64 0
-  %37 = getelementptr inbounds [1 x i32], ptr %literal7, i64 0, i64 0
+  %37 = getelementptr inbounds [1 x i32], ptr %literal4, i64 0, i64 0
   store i32 1, ptr %37, align 4
-  %38 = insertvalue %"int[]" undef, ptr %literal7, 0
+  %38 = insertvalue %"int[]" undef, ptr %literal4, 0
   %39 = insertvalue %"int[]" %38, i64 1, 1
   store %"int[]" %39, ptr %36, align 8
   %40 = insertvalue %"int[][]" undef, ptr %literal, 0
   %41 = insertvalue %"int[][]" %40, i64 1, 1
   store %"int[][]" %41, ptr %a, align 8
-  %42 = getelementptr inbounds [1 x %"int[]"], ptr %literal8, i64 0, i64 0
-  %43 = getelementptr inbounds [1 x i32], ptr %literal9, i64 0, i64 0
+  %42 = getelementptr inbounds [1 x %"int[]"], ptr %literal5, i64 0, i64 0
+  %43 = getelementptr inbounds [1 x i32], ptr %literal6, i64 0, i64 0
   store i32 2, ptr %43, align 4
-  %44 = insertvalue %"int[]" undef, ptr %literal9, 0
+  %44 = insertvalue %"int[]" undef, ptr %literal6, 0
   %45 = insertvalue %"int[]" %44, i64 1, 1
   store %"int[]" %45, ptr %42, align 8
-  %46 = insertvalue %"int[][]" undef, ptr %literal8, 0
+  %46 = insertvalue %"int[][]" undef, ptr %literal5, 0
   %47 = insertvalue %"int[][]" %46, i64 1, 1
   store %"int[][]" %47, ptr %b, align 8
   %48 = insertvalue %variant undef, ptr %a, 0
   %49 = insertvalue %variant %48, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1
-  %50 = getelementptr inbounds [1 x %variant], ptr %varargslots11, i64 0, i64 0
+  %50 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
   store %variant %49, ptr %50, align 16
-  %51 = call i64 @std_io_printfn(ptr %retparam10, ptr @.str.2, i64 2, ptr %varargslots11, i64 1)
-  %not_err12 = icmp eq i64 %51, 0
-  br i1 %not_err12, label %after_check13, label %voiderr14
-
-after_check13:                                    ; preds = %voiderr6
-  br label %voiderr14
-
-voiderr14:                                        ; preds = %after_check13, %voiderr6
+  %51 = call i64 @std_io_printfn(ptr %retparam7, ptr @.str.2, i64 2, ptr %varargslots8, i64 1)
   %52 = load %"int[][]", ptr %b, align 8
   %53 = extractvalue %"int[][]" %52, 0
   %ptroffset = getelementptr inbounds %"int[]", ptr %53, i64 0
@@ -141,46 +120,32 @@ voiderr14:                                        ; preds = %after_check13, %voi
   %55 = insertvalue %"int[][]" %54, i64 1, 1
   %56 = load %"int[][]", ptr %a, align 8
   %57 = extractvalue %"int[][]" %56, 0
-  %ptroffset15 = getelementptr inbounds %"int[]", ptr %57, i64 0
-  %58 = insertvalue %"int[][]" undef, ptr %ptroffset15, 0
+  %ptroffset9 = getelementptr inbounds %"int[]", ptr %57, i64 0
+  %58 = insertvalue %"int[][]" undef, ptr %ptroffset9, 0
   %59 = insertvalue %"int[][]" %58, i64 1, 1
   %60 = extractvalue %"int[][]" %59, 0
   %61 = extractvalue %"int[][]" %55, 0
-  store %"int[][]" %55, ptr %taddr16, align 8
-  %62 = getelementptr inbounds %"int[][]", ptr %taddr16, i32 0, i32 1
+  store %"int[][]" %55, ptr %taddr10, align 8
+  %62 = getelementptr inbounds %"int[][]", ptr %taddr10, i32 0, i32 1
   %63 = load i64, ptr %62, align 8
   %64 = mul i64 %63, 16
   call void @llvm.memcpy.p0.p0.i64(ptr align 8 %60, ptr align 8 %61, i64 %64, i1 false)
   %65 = insertvalue %variant undef, ptr %a, 0
   %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1
-  %67 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0
+  %67 = getelementptr inbounds [1 x %variant], ptr %varargslots12, i64 0, i64 0
   store %variant %66, ptr %67, align 16
-  %68 = call i64 @std_io_printfn(ptr %retparam17, ptr @.str.3, i64 2, ptr %varargslots18, i64 1)
-  %not_err19 = icmp eq i64 %68, 0
-  br i1 %not_err19, label %after_check20, label %voiderr21
-
-after_check20:                                    ; preds = %voiderr14
-  br label %voiderr21
-
-voiderr21:                                        ; preds = %after_check20, %voiderr14
+  %68 = call i64 @std_io_printfn(ptr %retparam11, ptr @.str.3, i64 2, ptr %varargslots12, i64 1)
   %69 = getelementptr inbounds <6 x i32>, ptr %y, i64 0, i64 2
   %70 = insertvalue %"int[]" undef, ptr %69, 0
   %71 = insertvalue %"int[]" %70, i64 3, 1
   %72 = load %"int[][]", ptr %a, align 8
   %73 = extractvalue %"int[][]" %72, 0
-  %ptroffset22 = getelementptr inbounds %"int[]", ptr %73, i64 0
-  store %"int[]" %71, ptr %ptroffset22, align 8
+  %ptroffset13 = getelementptr inbounds %"int[]", ptr %73, i64 0
+  store %"int[]" %71, ptr %ptroffset13, align 8
   %74 = insertvalue %variant undef, ptr %a, 0
   %75 = insertvalue %variant %74, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1
-  %76 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0
+  %76 = getelementptr inbounds [1 x %variant], ptr %varargslots15, i64 0, i64 0
   store %variant %75, ptr %76, align 16
-  %77 = call i64 @std_io_printfn(ptr %retparam23, ptr @.str.4, i64 2, ptr %varargslots24, i64 1)
-  %not_err25 = icmp eq i64 %77, 0
-  br i1 %not_err25, label %after_check26, label %voiderr27
-
-after_check26:                                    ; preds = %voiderr21
-  br label %voiderr27
-
-voiderr27:                                        ; preds = %after_check26, %voiderr21
+  %77 = call i64 @std_io_printfn(ptr %retparam14, ptr @.str.4, i64 2, ptr %varargslots15, i64 1)
   ret void
 }
diff --git a/test/test_suite/statements/foreach_more_implementations.c3t b/test/test_suite/statements/foreach_more_implementations.c3t
index 5aab4a99a..619b52be9 100644
--- a/test/test_suite/statements/foreach_more_implementations.c3t
+++ b/test/test_suite/statements/foreach_more_implementations.c3t
@@ -72,7 +72,7 @@ entry:
   store i64 0, ptr %.anon1, align 8
   br label %loop.cond
 
-loop.cond:                                        ; preds = %voiderr, %entry
+loop.cond:                                        ; preds = %loop.body, %entry
   %4 = load i64, ptr %.anon1, align 8
   %5 = load i64, ptr %.anon, align 8
   %lt = icmp ult i64 %4, %5
@@ -94,13 +94,6 @@ loop.body:                                        ; preds = %loop.cond
   %14 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %13, ptr %14, align 16
   %15 = call i64 @std_io_printf(ptr %retparam, ptr @.str, i64 3, ptr %varargslots, i64 1)
-  %not_err = icmp eq i64 %15, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %loop.body
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %loop.body
   %16 = load ptr, ptr %ref, align 8
   %17 = load i32, ptr %16, align 4
   %add = add i32 %17, 2
@@ -118,11 +111,11 @@ loop.exit:                                        ; preds = %loop.cond
   store i64 0, ptr %.anon6, align 8
   br label %loop.cond7
 
-loop.cond7:                                       ; preds = %voiderr17, %loop.exit
+loop.cond7:                                       ; preds = %loop.body9, %loop.exit
   %21 = load i64, ptr %.anon6, align 8
   %22 = load i64, ptr %.anon4, align 8
   %lt8 = icmp ult i64 %21, %22
-  br i1 %lt8, label %loop.body9, label %loop.exit19
+  br i1 %lt8, label %loop.body9, label %loop.exit16
 
 loop.body9:                                       ; preds = %loop.cond7
   store ptr %v, ptr %vector10, align 8
@@ -140,18 +133,11 @@ loop.body9:                                       ; preds = %loop.cond7
   %31 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0
   store %variant %30, ptr %31, align 16
   %32 = call i64 @std_io_printf(ptr %retparam13, ptr @.str.1, i64 3, ptr %varargslots14, i64 1)
-  %not_err15 = icmp eq i64 %32, 0
-  br i1 %not_err15, label %after_check16, label %voiderr17
-
-after_check16:                                    ; preds = %loop.body9
-  br label %voiderr17
-
-voiderr17:                                        ; preds = %after_check16, %loop.body9
   %33 = load i64, ptr %.anon6, align 8
-  %add18 = add i64 %33, 1
-  store i64 %add18, ptr %.anon6, align 8
+  %add15 = add i64 %33, 1
+  store i64 %add15, ptr %.anon6, align 8
   br label %loop.cond7
 
-loop.exit19:                                      ; preds = %loop.cond7
+loop.exit16:                                      ; preds = %loop.cond7
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/stdlib/map.c3t b/test/test_suite/stdlib/map.c3t
index f5cfd3795..90b68f90f 100644
--- a/test/test_suite/stdlib/map.c3t
+++ b/test/test_suite/stdlib/map.c3t
@@ -92,13 +92,6 @@ entry:
   %10 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %9, ptr %10, align 16
   %11 = call i64 @std_core_string_VarString_printf(ptr %retparam, ptr %s, ptr @.str.12, i64 8, ptr %varargslots, i64 2)
-  %not_err = icmp eq i64 %11, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   %12 = load ptr, ptr %s, align 8
   %13 = call { ptr, i64 } @std_core_string_VarString_str(ptr %12)
   store { ptr, i64 } %13, ptr %result, align 8
@@ -115,43 +108,43 @@ entry:
   %literal = alloca %Foo, align 8
   %retparam1 = alloca i64, align 8
   %varargslots2 = alloca [1 x %variant], align 16
-  %literal6 = alloca %Foo, align 8
-  %retparam9 = alloca i64, align 8
-  %varargslots10 = alloca [1 x %variant], align 16
-  %retparam14 = alloca i64, align 8
-  %varargslots15 = alloca [1 x %variant], align 16
-  %retparam16 = alloca %Foo, align 8
-  %retparam22 = alloca i64, align 8
-  %varargslots23 = alloca [1 x %variant], align 16
+  %literal3 = alloca %Foo, align 8
+  %retparam6 = alloca i64, align 8
+  %varargslots7 = alloca [1 x %variant], align 16
+  %retparam8 = alloca i64, align 8
+  %varargslots9 = alloca [1 x %variant], align 16
+  %retparam10 = alloca %Foo, align 8
+  %retparam13 = alloca i64, align 8
+  %varargslots14 = alloca [1 x %variant], align 16
   %taddr = alloca i8, align 1
-  %retparam27 = alloca i64, align 8
-  %varargslots28 = alloca [1 x %variant], align 16
-  %taddr29 = alloca i8, align 1
-  %literal33 = alloca %Foo, align 8
-  %retparam36 = alloca i64, align 8
-  %varargslots37 = alloca [1 x %variant], align 16
+  %retparam17 = alloca i64, align 8
+  %varargslots18 = alloca [1 x %variant], align 16
+  %taddr19 = alloca i8, align 1
+  %literal22 = alloca %Foo, align 8
+  %retparam25 = alloca i64, align 8
+  %varargslots26 = alloca [1 x %variant], align 16
   %result = alloca %"Foo[]", align 8
   %map2 = alloca %HashMap.2, align 8
-  %retparam41 = alloca i64, align 8
-  %varargslots42 = alloca [1 x %variant], align 16
-  %taddr43 = alloca i8, align 1
-  %retparam47 = alloca i64, align 8
-  %varargslots48 = alloca [1 x %variant], align 16
-  %taddr49 = alloca i8, align 1
-  %retparam53 = alloca i64, align 8
-  %varargslots54 = alloca [1 x %variant], align 16
-  %result55 = alloca %"int[]", align 8
-  %retparam59 = alloca i64, align 8
-  %varargslots60 = alloca [1 x %variant], align 16
-  %result61 = alloca %"double[]", align 8
+  %retparam29 = alloca i64, align 8
+  %varargslots30 = alloca [1 x %variant], align 16
+  %taddr31 = alloca i8, align 1
+  %retparam34 = alloca i64, align 8
+  %varargslots35 = alloca [1 x %variant], align 16
+  %taddr36 = alloca i8, align 1
+  %retparam39 = alloca i64, align 8
+  %varargslots40 = alloca [1 x %variant], align 16
+  %result41 = alloca %"int[]", align 8
+  %retparam44 = alloca i64, align 8
+  %varargslots45 = alloca [1 x %variant], align 16
+  %result46 = alloca %"double[]", align 8
   %temp = alloca ptr, align 8
   %error_var = alloca i64, align 8
-  %retparam65 = alloca ptr, align 8
+  %retparam49 = alloca ptr, align 8
   %mark = alloca i64, align 8
   %map3 = alloca %HashMap.2, align 8
-  %retparam68 = alloca i64, align 8
-  %varargslots69 = alloca [1 x %variant], align 16
-  %result70 = alloca %"int[]", align 8
+  %retparam52 = alloca i64, align 8
+  %varargslots53 = alloca [1 x %variant], align 16
+  %result54 = alloca %"int[]", align 8
   call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 40, i1 false)
   %0 = load ptr, ptr @std_core_mem_thread_allocator, align 8
   call void @"std_map$$int.test_Foo_HashMap_init"(ptr %map, i32 16, float 7.500000e-01, ptr %0)
@@ -161,13 +154,6 @@ entry:
   %4 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %3, ptr %4, align 16
   %5 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 12, ptr %varargslots, i64 1)
-  %not_err = icmp eq i64 %5, 0
-  br i1 %not_err, label %after_check, label %voiderr
-
-after_check:                                      ; preds = %entry
-  br label %voiderr
-
-voiderr:                                          ; preds = %after_check, %entry
   %6 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 0
   store i32 1, ptr %6, align 8
   %7 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 1
@@ -183,184 +169,118 @@ voiderr:                                          ; preds = %after_check, %entry
   %14 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0
   store %variant %13, ptr %14, align 16
   %15 = call i64 @std_io_printfn(ptr %retparam1, ptr @.str.1, i64 12, ptr %varargslots2, i64 1)
-  %not_err3 = icmp eq i64 %15, 0
-  br i1 %not_err3, label %after_check4, label %voiderr5
-
-after_check4:                                     ; preds = %voiderr
-  br label %voiderr5
-
-voiderr5:                                         ; preds = %after_check4, %voiderr
-  %16 = getelementptr inbounds %Foo, ptr %literal6, i32 0, i32 0
+  %16 = getelementptr inbounds %Foo, ptr %literal3, i32 0, i32 0
   store i32 2, ptr %16, align 8
-  %17 = getelementptr inbounds %Foo, ptr %literal6, i32 0, i32 1
+  %17 = getelementptr inbounds %Foo, ptr %literal3, i32 0, i32 1
   store ptr null, ptr %17, align 8
-  %18 = getelementptr inbounds { i64, ptr }, ptr %literal6, i32 0, i32 0
-  %lo7 = load i64, ptr %18, align 8
-  %19 = getelementptr inbounds { i64, ptr }, ptr %literal6, i32 0, i32 1
-  %hi8 = load ptr, ptr %19, align 8
-  %20 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 1, i64 %lo7, ptr %hi8)
+  %18 = getelementptr inbounds { i64, ptr }, ptr %literal3, i32 0, i32 0
+  %lo4 = load i64, ptr %18, align 8
+  %19 = getelementptr inbounds { i64, ptr }, ptr %literal3, i32 0, i32 1
+  %hi5 = load ptr, ptr %19, align 8
+  %20 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 1, i64 %lo4, ptr %hi5)
   %21 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2
   %22 = insertvalue %variant undef, ptr %21, 0
   %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$uint" to i64), 1
-  %24 = getelementptr inbounds [1 x %variant], ptr %varargslots10, i64 0, i64 0
+  %24 = getelementptr inbounds [1 x %variant], ptr %varargslots7, i64 0, i64 0
   store %variant %23, ptr %24, align 16
-  %25 = call i64 @std_io_printfn(ptr %retparam9, ptr @.str.2, i64 12, ptr %varargslots10, i64 1)
-  %not_err11 = icmp eq i64 %25, 0
-  br i1 %not_err11, label %after_check12, label %voiderr13
+  %25 = call i64 @std_io_printfn(ptr %retparam6, ptr @.str.2, i64 12, ptr %varargslots7, i64 1)
+  %26 = call i64 @"std_map$$int.test_Foo_HashMap_get"(ptr %retparam10, ptr %map, i32 1)
+  %not_err = icmp eq i64 %26, 0
+  br i1 %not_err, label %after_check, label %after_check12
 
-after_check12:                                    ; preds = %voiderr5
-  br label %voiderr13
-
-voiderr13:                                        ; preds = %after_check12, %voiderr5
-  %26 = call i64 @"std_map$$int.test_Foo_HashMap_get"(ptr %retparam16, ptr %map, i32 1)
-  %not_err17 = icmp eq i64 %26, 0
-  br i1 %not_err17, label %after_check18, label %voiderr21
-
-after_check18:                                    ; preds = %voiderr13
-  %27 = getelementptr inbounds %Foo, ptr %retparam16, i32 0, i32 0
+after_check:                                      ; preds = %entry
+  %27 = getelementptr inbounds %Foo, ptr %retparam10, i32 0, i32 0
   %28 = insertvalue %variant undef, ptr %27, 0
   %29 = insertvalue %variant %28, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %30 = getelementptr inbounds [1 x %variant], ptr %varargslots15, i64 0, i64 0
+  %30 = getelementptr inbounds [1 x %variant], ptr %varargslots9, i64 0, i64 0
   store %variant %29, ptr %30, align 16
-  %31 = call i64 @std_io_printfn(ptr %retparam14, ptr @.str.3, i64 7, ptr %varargslots15, i64 1)
-  %not_err19 = icmp eq i64 %31, 0
-  br i1 %not_err19, label %after_check20, label %voiderr21
+  %31 = call i64 @std_io_printfn(ptr %retparam8, ptr @.str.3, i64 7, ptr %varargslots9, i64 1)
+  %not_err11 = icmp eq i64 %31, 0
+  br i1 %not_err11, label %after_check12, label %after_check12
 
-after_check20:                                    ; preds = %after_check18
-  br label %voiderr21
-
-voiderr21:                                        ; preds = %after_check20, %after_check18, %voiderr13
+after_check12:                                    ; preds = %entry, %after_check, %after_check
   %32 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(ptr %map, i32 1)
   store i8 %32, ptr %taddr, align 1
   %33 = insertvalue %variant undef, ptr %taddr, 0
   %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$bool" to i64), 1
-  %35 = getelementptr inbounds [1 x %variant], ptr %varargslots23, i64 0, i64 0
+  %35 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0
   store %variant %34, ptr %35, align 16
-  %36 = call i64 @std_io_printfn(ptr %retparam22, ptr @.str.4, i64 9, ptr %varargslots23, i64 1)
-  %not_err24 = icmp eq i64 %36, 0
-  br i1 %not_err24, label %after_check25, label %voiderr26
-
-after_check25:                                    ; preds = %voiderr21
-  br label %voiderr26
-
-voiderr26:                                        ; preds = %after_check25, %voiderr21
+  %36 = call i64 @std_io_printfn(ptr %retparam13, ptr @.str.4, i64 9, ptr %varargslots14, i64 1)
   %37 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(ptr %map, i32 2)
-  store i8 %37, ptr %taddr29, align 1
-  %38 = insertvalue %variant undef, ptr %taddr29, 0
+  store i8 %37, ptr %taddr19, align 1
+  %38 = insertvalue %variant undef, ptr %taddr19, 0
   %39 = insertvalue %variant %38, i64 ptrtoint (ptr @"ct$bool" to i64), 1
-  %40 = getelementptr inbounds [1 x %variant], ptr %varargslots28, i64 0, i64 0
+  %40 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0
   store %variant %39, ptr %40, align 16
-  %41 = call i64 @std_io_printfn(ptr %retparam27, ptr @.str.5, i64 9, ptr %varargslots28, i64 1)
-  %not_err30 = icmp eq i64 %41, 0
-  br i1 %not_err30, label %after_check31, label %voiderr32
-
-after_check31:                                    ; preds = %voiderr26
-  br label %voiderr32
-
-voiderr32:                                        ; preds = %after_check31, %voiderr26
-  %42 = getelementptr inbounds %Foo, ptr %literal33, i32 0, i32 0
+  %41 = call i64 @std_io_printfn(ptr %retparam17, ptr @.str.5, i64 9, ptr %varargslots18, i64 1)
+  %42 = getelementptr inbounds %Foo, ptr %literal22, i32 0, i32 0
   store i32 4, ptr %42, align 8
-  %43 = getelementptr inbounds %Foo, ptr %literal33, i32 0, i32 1
+  %43 = getelementptr inbounds %Foo, ptr %literal22, i32 0, i32 1
   store ptr null, ptr %43, align 8
-  %44 = getelementptr inbounds { i64, ptr }, ptr %literal33, i32 0, i32 0
-  %lo34 = load i64, ptr %44, align 8
-  %45 = getelementptr inbounds { i64, ptr }, ptr %literal33, i32 0, i32 1
-  %hi35 = load ptr, ptr %45, align 8
-  %46 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 7, i64 %lo34, ptr %hi35)
+  %44 = getelementptr inbounds { i64, ptr }, ptr %literal22, i32 0, i32 0
+  %lo23 = load i64, ptr %44, align 8
+  %45 = getelementptr inbounds { i64, ptr }, ptr %literal22, i32 0, i32 1
+  %hi24 = load ptr, ptr %45, align 8
+  %46 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 7, i64 %lo23, ptr %hi24)
   %47 = load ptr, ptr @std_core_mem_thread_allocator, align 8
   %48 = call { ptr, i64 } @"std_map$$int.test_Foo_HashMap_value_list"(ptr %map, ptr %47)
   store { ptr, i64 } %48, ptr %result, align 8
   %49 = insertvalue %variant undef, ptr %result, 0
   %50 = insertvalue %variant %49, i64 ptrtoint (ptr @"ct$sa$test_Foo" to i64), 1
-  %51 = getelementptr inbounds [1 x %variant], ptr %varargslots37, i64 0, i64 0
+  %51 = getelementptr inbounds [1 x %variant], ptr %varargslots26, i64 0, i64 0
   store %variant %50, ptr %51, align 16
-  %52 = call i64 @std_io_printfn(ptr %retparam36, ptr @.str.6, i64 10, ptr %varargslots37, i64 1)
-  %not_err38 = icmp eq i64 %52, 0
-  br i1 %not_err38, label %after_check39, label %voiderr40
-
-after_check39:                                    ; preds = %voiderr32
-  br label %voiderr40
-
-voiderr40:                                        ; preds = %after_check39, %voiderr32
+  %52 = call i64 @std_io_printfn(ptr %retparam25, ptr @.str.6, i64 10, ptr %varargslots26, i64 1)
   call void @llvm.memset.p0.i64(ptr align 8 %map2, i8 0, i64 40, i1 false)
   %53 = load ptr, ptr @std_core_mem_thread_allocator, align 8
   call void @"std_map$$int.double_HashMap_init"(ptr %map2, i32 16, float 7.500000e-01, ptr %53)
   %54 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map2, i32 4, double 1.300000e+00)
   %55 = call i8 @"std_map$$int.double_HashMap_has_value"(ptr %map2, double 1.300000e+00)
-  store i8 %55, ptr %taddr43, align 1
-  %56 = insertvalue %variant undef, ptr %taddr43, 0
+  store i8 %55, ptr %taddr31, align 1
+  %56 = insertvalue %variant undef, ptr %taddr31, 0
   %57 = insertvalue %variant %56, i64 ptrtoint (ptr @"ct$bool" to i64), 1
-  %58 = getelementptr inbounds [1 x %variant], ptr %varargslots42, i64 0, i64 0
+  %58 = getelementptr inbounds [1 x %variant], ptr %varargslots30, i64 0, i64 0
   store %variant %57, ptr %58, align 16
-  %59 = call i64 @std_io_printfn(ptr %retparam41, ptr @.str.7, i64 12, ptr %varargslots42, i64 1)
-  %not_err44 = icmp eq i64 %59, 0
-  br i1 %not_err44, label %after_check45, label %voiderr46
-
-after_check45:                                    ; preds = %voiderr40
-  br label %voiderr46
-
-voiderr46:                                        ; preds = %after_check45, %voiderr40
+  %59 = call i64 @std_io_printfn(ptr %retparam29, ptr @.str.7, i64 12, ptr %varargslots30, i64 1)
   %60 = call i8 @"std_map$$int.double_HashMap_has_value"(ptr %map2, double 1.200000e+00)
-  store i8 %60, ptr %taddr49, align 1
-  %61 = insertvalue %variant undef, ptr %taddr49, 0
+  store i8 %60, ptr %taddr36, align 1
+  %61 = insertvalue %variant undef, ptr %taddr36, 0
   %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"ct$bool" to i64), 1
-  %63 = getelementptr inbounds [1 x %variant], ptr %varargslots48, i64 0, i64 0
+  %63 = getelementptr inbounds [1 x %variant], ptr %varargslots35, i64 0, i64 0
   store %variant %62, ptr %63, align 16
-  %64 = call i64 @std_io_printfn(ptr %retparam47, ptr @.str.8, i64 12, ptr %varargslots48, i64 1)
-  %not_err50 = icmp eq i64 %64, 0
-  br i1 %not_err50, label %after_check51, label %voiderr52
-
-after_check51:                                    ; preds = %voiderr46
-  br label %voiderr52
-
-voiderr52:                                        ; preds = %after_check51, %voiderr46
+  %64 = call i64 @std_io_printfn(ptr %retparam34, ptr @.str.8, i64 12, ptr %varargslots35, i64 1)
   %65 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map2, i32 100, double 3.400000e+00)
   %66 = load ptr, ptr @std_core_mem_thread_allocator, align 8
   %67 = call { ptr, i64 } @"std_map$$int.double_HashMap_key_list"(ptr %map2, ptr %66)
-  store { ptr, i64 } %67, ptr %result55, align 8
-  %68 = insertvalue %variant undef, ptr %result55, 0
+  store { ptr, i64 } %67, ptr %result41, align 8
+  %68 = insertvalue %variant undef, ptr %result41, 0
   %69 = insertvalue %variant %68, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1
-  %70 = getelementptr inbounds [1 x %variant], ptr %varargslots54, i64 0, i64 0
+  %70 = getelementptr inbounds [1 x %variant], ptr %varargslots40, i64 0, i64 0
   store %variant %69, ptr %70, align 16
-  %71 = call i64 @std_io_printfn(ptr %retparam53, ptr @.str.9, i64 2, ptr %varargslots54, i64 1)
-  %not_err56 = icmp eq i64 %71, 0
-  br i1 %not_err56, label %after_check57, label %voiderr58
-
-after_check57:                                    ; preds = %voiderr52
-  br label %voiderr58
-
-voiderr58:                                        ; preds = %after_check57, %voiderr52
+  %71 = call i64 @std_io_printfn(ptr %retparam39, ptr @.str.9, i64 2, ptr %varargslots40, i64 1)
   %72 = load ptr, ptr @std_core_mem_thread_allocator, align 8
   %73 = call { ptr, i64 } @"std_map$$int.double_HashMap_value_list"(ptr %map2, ptr %72)
-  store { ptr, i64 } %73, ptr %result61, align 8
-  %74 = insertvalue %variant undef, ptr %result61, 0
+  store { ptr, i64 } %73, ptr %result46, align 8
+  %74 = insertvalue %variant undef, ptr %result46, 0
   %75 = insertvalue %variant %74, i64 ptrtoint (ptr @"ct$sa$double" to i64), 1
-  %76 = getelementptr inbounds [1 x %variant], ptr %varargslots60, i64 0, i64 0
+  %76 = getelementptr inbounds [1 x %variant], ptr %varargslots45, i64 0, i64 0
   store %variant %75, ptr %76, align 16
-  %77 = call i64 @std_io_printfn(ptr %retparam59, ptr @.str.10, i64 2, ptr %varargslots60, i64 1)
-  %not_err62 = icmp eq i64 %77, 0
-  br i1 %not_err62, label %after_check63, label %voiderr64
-
-after_check63:                                    ; preds = %voiderr58
-  br label %voiderr64
-
-voiderr64:                                        ; preds = %after_check63, %voiderr58
+  %77 = call i64 @std_io_printfn(ptr %retparam44, ptr @.str.10, i64 2, ptr %varargslots45, i64 1)
   %78 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
   %not = icmp eq ptr %78, null
   br i1 %not, label %if.then, label %if.exit
 
-if.then:                                          ; preds = %voiderr64
+if.then:                                          ; preds = %after_check12
   %79 = load ptr, ptr @std_core_mem_thread_allocator, align 8
-  %80 = call i64 @std_core_mem_allocator_new_temp(ptr %retparam65, i64 262144, ptr %79)
-  %not_err66 = icmp eq i64 %80, 0
-  br i1 %not_err66, label %after_check67, label %assign_optional
+  %80 = call i64 @std_core_mem_allocator_new_temp(ptr %retparam49, i64 262144, ptr %79)
+  %not_err50 = icmp eq i64 %80, 0
+  br i1 %not_err50, label %after_check51, label %assign_optional
 
 assign_optional:                                  ; preds = %if.then
   store i64 %80, ptr %error_var, align 8
   br label %panic_block
 
-after_check67:                                    ; preds = %if.then
-  %81 = load ptr, ptr %retparam65, align 8
+after_check51:                                    ; preds = %if.then
+  %81 = load ptr, ptr %retparam49, align 8
   br label %noerr_block
 
 panic_block:                                      ; preds = %assign_optional
@@ -368,11 +288,11 @@ panic_block:                                      ; preds = %assign_optional
   call void %82(ptr @.panic_msg, i64 27, ptr @.file, i64 6, ptr @.func, i64 4, i32 280)
   unreachable
 
-noerr_block:                                      ; preds = %after_check67
+noerr_block:                                      ; preds = %after_check51
   store ptr %81, ptr @std_core_mem_thread_temp_allocator, align 8
   br label %if.exit
 
-if.exit:                                          ; preds = %noerr_block, %voiderr64
+if.exit:                                          ; preds = %noerr_block, %after_check12
   %83 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
   store ptr %83, ptr %temp, align 8
   %84 = load ptr, ptr %temp, align 8
@@ -386,19 +306,12 @@ if.exit:                                          ; preds = %noerr_block, %voide
   %89 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map3, i32 7, double 5.200000e+00)
   %90 = load ptr, ptr @std_core_mem_thread_allocator, align 8
   %91 = call { ptr, i64 } @"std_map$$int.double_HashMap_key_list"(ptr %map3, ptr %90)
-  store { ptr, i64 } %91, ptr %result70, align 8
-  %92 = insertvalue %variant undef, ptr %result70, 0
+  store { ptr, i64 } %91, ptr %result54, align 8
+  %92 = insertvalue %variant undef, ptr %result54, 0
   %93 = insertvalue %variant %92, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1
-  %94 = getelementptr inbounds [1 x %variant], ptr %varargslots69, i64 0, i64 0
+  %94 = getelementptr inbounds [1 x %variant], ptr %varargslots53, i64 0, i64 0
   store %variant %93, ptr %94, align 16
-  %95 = call i64 @std_io_printfn(ptr %retparam68, ptr @.str.11, i64 2, ptr %varargslots69, i64 1)
-  %not_err71 = icmp eq i64 %95, 0
-  br i1 %not_err71, label %after_check72, label %voiderr73
-
-after_check72:                                    ; preds = %if.exit
-  br label %voiderr73
-
-voiderr73:                                        ; preds = %after_check72, %if.exit
+  %95 = call i64 @std_io_printfn(ptr %retparam52, ptr @.str.11, i64 2, ptr %varargslots53, i64 1)
   %96 = load ptr, ptr %temp, align 8
   %97 = getelementptr inbounds %TempAllocator, ptr %96, i32 0, i32 0
   %98 = load i64, ptr %mark, align 8