diff --git a/lib/std/core/dstring.c3 b/lib/std/core/dstring.c3
index b9c14a83b..a6e51e365 100644
--- a/lib/std/core/dstring.c3
+++ b/lib/std/core/dstring.c3
@@ -349,7 +349,7 @@ fn DString new_join(String[] s, String joiner, Allocator* using = mem::heap())
 	return res;
 }
 
-fn void! out_string_append_fn(char c, void* data) @private
+fn void! out_string_append_fn(void* data, char c) @private
 {
 	DString* s = data;
 	s.append_char(c);
diff --git a/lib/std/io/io_file.c3 b/lib/std/io/file.c3
similarity index 85%
rename from lib/std/io/io_file.c3
rename to lib/std/io/file.c3
index 4d04e6cc9..9bca8fbfd 100644
--- a/lib/std/io/io_file.c3
+++ b/lib/std/io/file.c3
@@ -1,3 +1,12 @@
+module std::io;
+import libc;
+
+struct File
+{
+	inline Stream stream;
+	CFile file;
+}
+
 module std::io::file;
 import libc;
 
@@ -16,6 +25,16 @@ fn File from_handle(CFile file)
 	return { .stream.fns = &FILESTREAM_INTERFACE, .file = file };
 }
 
+fn bool is_file(String path)
+{
+	return os::native_is_file(path);
+}
+
+fn usz! get_size(String path)
+{
+	return os::native_file_size(path);
+}
+
 fn void! delete(String filename) => os::native_remove(filename) @inline;
 
 
@@ -112,25 +131,6 @@ fn usz! File.write(&self, char[] buffer)
 	return os::native_fwrite(self.file, buffer);
 }
 
-/**
- * @require self.file `File must be initialized`
- */
-fn usz! File.printn(&self, String string = "")
-{
-	usz len = self.print(string)!;
-	if (!libc::putc('\n', self.file)) return IoError.UNKNOWN_ERROR?;
-	return len + 1;
-}
-
-/**
- * @require self.file `File must be initialized`
- */
-fn usz! File.print(&self, String string)
-{
-	usz len = string.len;
-	if (len != self.write((char[])string)!) return IoError.UNKNOWN_ERROR?;
-	return len;
-}
 
 fn char! File.read_byte(&self)
 {
@@ -142,7 +142,7 @@ fn char! File.read_byte(&self)
 /**
  * @require self.file `File must be initialized`
  */
-fn void File.flush(&self)
+fn void! File.flush(&self)
 {
 	libc::fflush(self.file);
 }
diff --git a/lib/std/io/io_printf.c3 b/lib/std/io/formatter.c3
similarity index 84%
rename from lib/std/io/io_printf.c3
rename to lib/std/io/formatter.c3
index dd6accdea..ec4175101 100644
--- a/lib/std/io/io_printf.c3
+++ b/lib/std/io/formatter.c3
@@ -4,6 +4,9 @@ import libc;
 
 const int PRINTF_NTOA_BUFFER_SIZE = 256;
 
+fn String any.to_string(void* value, Allocator *using) @interface;
+fn usz! any.to_format(void* value, Formatter* formatter) @interface;
+
 fault PrintFault
 {
 	BUFFER_EXCEEDED,
@@ -21,53 +24,10 @@ fault FormattingFault
 	INVALID_FORMAT_TYPE,
 }
 
-def OutputFn = fn void!(char c, void* buffer);
+def OutputFn = fn void!(void* buffer, char c);
 def FloatType = double;
 
-fn String any.to_string(void* value, Allocator *using) @interface;
-fn usz! any.to_format(void* value, Formatter* formatter) @interface;
 
-fn usz! printf(String format, args...) @maydiscard
-{
-	Formatter formatter;
-	formatter.init(&out_putchar_fn);
-	return formatter.vprintf(format, args);
-}
-
-fn usz! printfn(String format, args...) @maydiscard
-{
-	Formatter formatter;
-	formatter.init(&out_putchar_fn);
-	usz len = formatter.vprintf(format, args)!;
-	putchar('\n');
-	return len + 1;
-}
-
-fn char[]! bprintf(char[] buffer, String format, args...) @maydiscard
-{
-	Formatter formatter;
-	BufferData data = { .buffer = buffer };
-	formatter.init(&out_buffer_fn, &data);
-	usz size = formatter.vprintf(format, args)!;
-	return buffer[:data.written];
-}
-
-fn usz! File.printf(self, String format, args...) @maydiscard
-{
-	Formatter formatter;
-	formatter.init(&out_fputchar_fn, &self);
-	return formatter.vprintf(format, args)!;
-}
-
-fn usz! File.printfn(self, String format, args...) @maydiscard
-{
-	Formatter formatter;
-	formatter.init(&out_fputchar_fn, &self);
-	usz len = formatter.vprintf(format, args)!;
-	self.write_byte('\n')!;
-	self.flush();
-	return len + 1;
-}
 
 fn usz! Formatter.printf(&self, String format, args...)
 {
@@ -105,7 +65,7 @@ fn void Formatter.init(&self, OutputFn out_fn, void* data = null)
 
 fn usz! Formatter.out(&self, char c) @private
 {
-	self.out_fn(c, self.data)!;
+	self.out_fn(self.data, c)!;
 	return 1;
 }
 
@@ -261,33 +221,11 @@ fn usz! Formatter.out_str(&self, any arg) @private
 
 
 
-fn void! out_buffer_fn(char c, void *data) @private
-{
-	BufferData *buffer_data = data;
-	if (buffer_data.written >= buffer_data.buffer.len) return PrintFault.BUFFER_EXCEEDED?;
-	buffer_data.buffer[buffer_data.written++] = c;
-}
 
-fn void! out_null_fn(char c @unused, void* data @unused) @private
+fn void! out_null_fn(void* data @unused, char c @unused) @private
 {
 }
 
-fn void! out_putchar_fn(char c, void* data @unused) @private
-{
-	libc::putchar(c);
-}
-
-fn void! out_fputchar_fn(char c, void* data) @private
-{
-	File* f = data;
-	f.write_byte(c)!;
-}
-
-struct BufferData @private
-{
-	char[] buffer;
-	usz written;
-}
 
 
 fn usz! Formatter.vprintf(&self, String format, any[] anys)
diff --git a/lib/std/io/io_formatter_private.c3 b/lib/std/io/formatter_private.c3
similarity index 100%
rename from lib/std/io/io_formatter_private.c3
rename to lib/std/io/formatter_private.c3
diff --git a/lib/std/io/io.c3 b/lib/std/io/io.c3
index b93338f9c..247455e5b 100644
--- a/lib/std/io/io.c3
+++ b/lib/std/io/io.c3
@@ -4,12 +4,6 @@
 module std::io;
 import libc;
 
-struct File
-{
-	inline Stream stream;
-	CFile file;
-}
-
 enum Seek
 {
 	SET,
@@ -52,42 +46,60 @@ fault IoError
 
 macro void print(x)
 {
-	var $Type = $typeof(x);
-	$switch ($Type)
-	$case String:
-		(void)stdout().print(x);
-	$case ZString:
-		(void)stdout().print(x.as_str());
-	$case DString:
-		(void)stdout().print(x.as_str());
-	$default:
-		$if @convertible(x, String):
-			(void)stdout().print((String)x);
-		$else
-			(void)stdout().printf("%s", x);
-		$endif
-	$endswitch
+	(void)print_gen(stdout(), x);
 }
 
 macro void printn(x = "")
 {
-	var $Type = $typeof(x);
-	$switch ($Type)
-	$case String:
-		(void)stdout().printn(x);
-	$case ZString:
-		(void)stdout().printn(x.as_str());
-	$case DString:
-		(void)stdout().printn(x.as_str());
-	$default:
-		$if @convertible(x, String):
-			(void)stdout().printn((String)x);
-		$else
-			(void)stdout().printfn("%s", x);
-		$endif
-	$endswitch
+	(void)printn_gen(stdout(), x);
 }
 
+fn void! out_putchar_fn(void* data @unused, char c) @private
+{
+	libc::putchar(c);
+}
+
+
+fn usz! printf(String format, args...) @maydiscard
+{
+	Formatter formatter;
+	formatter.init(&out_putchar_fn);
+	return formatter.vprintf(format, args);
+}
+
+fn usz! printfn(String format, args...) @maydiscard
+{
+	Formatter formatter;
+	formatter.init(&out_putchar_fn);
+	usz len = formatter.vprintf(format, args)!;
+	putchar('\n');
+	return len + 1;
+}
+
+fn char[]! bprintf(char[] buffer, String format, args...) @maydiscard
+{
+	Formatter formatter;
+	BufferData data = { .buffer = buffer };
+	formatter.init(&out_buffer_fn, &data);
+	usz size = formatter.vprintf(format, args)!;
+	return buffer[:data.written];
+}
+
+fn void! out_buffer_fn(void *data, char c) @private
+{
+	BufferData *buffer_data = data;
+	if (buffer_data.written >= buffer_data.buffer.len) return PrintFault.BUFFER_EXCEEDED?;
+	buffer_data.buffer[buffer_data.written++] = c;
+}
+
+
+struct BufferData @private
+{
+	char[] buffer;
+	usz written;
+}
+
+
 module std::io @if (env::LIBC);
 import libc;
 
@@ -142,33 +154,3 @@ fn File stdin()
 {
 	return stdin_file;
 }
-
-
-/*
-
-
-error FileError
-{
-	ulong errno;
-}
-
-fn FileError errorFromErrno()
-{
-	return FileError { };
-}
-
-
-
-
-pubic fn void! File.clearerr(File *file) @inline
-{
-	clearerr(file->file);
-}
-
-
-
-fn void File.error(File *file) @inline
-{
-	int err = ferror
-}
-*/
diff --git a/lib/std/io/io_fileinfo.c3 b/lib/std/io/io_fileinfo.c3
deleted file mode 100644
index 3294017f5..000000000
--- a/lib/std/io/io_fileinfo.c3
+++ /dev/null
@@ -1,14 +0,0 @@
-module std::io::file;
-import libc;
-
-
-
-fn bool is_file(String path)
-{
-	return os::native_is_file(path);
-}
-
-fn usz! get_size(String path)
-{
-	return os::native_file_size(path);
-}
\ No newline at end of file
diff --git a/lib/std/io/io_stream.c3 b/lib/std/io/stream.c3
similarity index 84%
rename from lib/std/io/io_stream.c3
rename to lib/std/io/stream.c3
index 7674b1832..05e0c8028 100644
--- a/lib/std/io/io_stream.c3
+++ b/lib/std/io/stream.c3
@@ -120,6 +120,82 @@ fn usz! Stream.read(&self, char[] buffer)
 	return IoError.UNSUPPORTED_OPERATION?;
 }
 
+macro usz! Stream.print(&self, x) @maydiscard
+{
+	return print_gen(self, x);
+}
+
+macro usz! print_gen(self, x)
+{
+	var $Type = $typeof(x);
+	$switch ($Type)
+	$case String:
+		return self.write(x);
+	$case ZString:
+		return self.write(x.as_str());
+	$case DString:
+		return self.write(x.as_str());
+	$default:
+		$if @convertible(x, String):
+			return self.write((String)x);
+		$else
+			return printf("%s", x);
+		$endif
+	$endswitch
+}
+
+macro usz! printn_gen(self, x)
+{
+	usz len = print_gen(self, x)!;
+	self.write_byte('\n')!;
+	self.flush()!;
+	return len + 1;
+}
+
+macro usz! Stream.printn(&self, x) @maydiscard
+{
+	return printn_gen(self, x);
+}
+
+fn usz! Stream.printf(&self, String format, args...) @maydiscard
+{
+	Formatter formatter;
+	if (WriteByteStreamFn func_byte = self.fns.write_byte_fn)
+	{
+		formatter.init((OutputFn)func_byte, self);
+	}
+	else if (WriteStreamFn func = self.fns.write_fn)
+	{
+		formatter.init((OutputFn)&Stream.write_byte, self);
+	}
+	else
+	{
+		return IoError.UNSUPPORTED_OPERATION?;
+	}
+	return formatter.vprintf(format, args)!;
+}
+
+fn usz! Stream.printfn(&self, String format, args...) @maydiscard @inline
+{
+	Formatter formatter;
+	if (WriteByteStreamFn func_byte = self.fns.write_byte_fn)
+	{
+		formatter.init((OutputFn)func_byte, self);
+	}
+	else if (WriteStreamFn func = self.fns.write_fn)
+	{
+		formatter.init((OutputFn)&Stream.write_byte, self);
+	}
+	else
+	{
+		return IoError.UNSUPPORTED_OPERATION?;
+	}
+	usz len = formatter.vprintf(format, args)!;
+	self.write_byte('\n')!;
+	self.flush()!;
+	return len + 1;
+}
+
 fn char! Stream.read_byte(&self) @inline
 {
 	if (ReadByteStreamFn func = self.fns.read_byte_fn) return func(self);
diff --git a/resources/examples/brainfk.c3 b/resources/examples/brainfk.c3
index 6441eb049..c85be28f6 100644
--- a/resources/examples/brainfk.c3
+++ b/resources/examples/brainfk.c3
@@ -36,7 +36,7 @@ fn void! brainf(String program)
 				memory[mem]--;
 			case '.':
 				io::putchar(memory[mem]);
-				io::stdout().flush();
+				io::stdout().flush()!;
 			case ',':
 				memory[mem] = io::stdin().read_byte()!!;
 			case '[':
diff --git a/test/test_suite/bitstruct/bitstruct_be.c3t b/test/test_suite/bitstruct/bitstruct_be.c3t
index 7fde2377d..19e439f42 100644
--- a/test/test_suite/bitstruct/bitstruct_be.c3t
+++ b/test/test_suite/bitstruct/bitstruct_be.c3t
@@ -90,110 +90,272 @@ loop.body:                                        ; preds = %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
   %22 = call ptr @std.io.stdout()
-  %23 = call i64 @std.io.File.printn(ptr %retparam4, ptr %22, ptr null, i64 0)
-  %24 = load ptr, ptr %z, align 8
-  store ptr %24, ptr %.anon5, align 8
-  store i64 0, ptr %.anon6, align 8
-  br label %loop.cond7
+  %23 = call i64 @std.io.File.write(ptr %retparam5, ptr %22, ptr null, i64 0)
+  %not_err = icmp eq i64 %23, 0
+  %24 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
+  br i1 %24, label %after_check, label %assign_optional
 
-loop.cond7:                                       ; preds = %loop.body9, %loop.exit
-  %25 = load i64, ptr %.anon6, align 8
-  %gt8 = icmp ugt i64 4, %25
-  br i1 %gt8, label %loop.body9, label %loop.exit14
+assign_optional:                                  ; preds = %loop.exit
+  store i64 %23, ptr %error_var, align 8
+  br label %guard_block
 
-loop.body9:                                       ; preds = %loop.cond7
-  %26 = load ptr, ptr %.anon5, align 8
-  %27 = load i64, ptr %.anon6, 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 %d10, align 1
-  %30 = insertvalue %any undef, ptr %d10, 0
-  %31 = insertvalue %any %30, i64 ptrtoint (ptr @"$ct.char" to i64), 1
-  %32 = getelementptr inbounds [1 x %any], ptr %varargslots12, i64 0, i64 0
-  store %any %31, ptr %32, align 16
-  %33 = call i64 @std.io.printf(ptr %retparam11, ptr @.str.2, i64 3, ptr %varargslots12, i64 1)
-  %34 = load i64, ptr %.anon6, align 8
-  %add13 = add i64 %34, 1
-  store i64 %add13, ptr %.anon6, align 8
-  br label %loop.cond7
+after_check:                                      ; preds = %loop.exit
+  br label %noerr_block
 
-loop.exit14:                                      ; preds = %loop.cond7
-  %35 = call ptr @std.io.stdout()
-  %36 = call i64 @std.io.File.printn(ptr %retparam15, ptr %35, ptr null, i64 0)
-  %37 = load i32, ptr %abc, align 4
-  %38 = call i32 @llvm.bswap.i32(i32 %37)
-  %39 = and i32 65535, %38
-  %trunc = trunc i32 %39 to i16
-  store i16 %trunc, ptr %taddr18, align 2
-  %40 = insertvalue %any undef, ptr %taddr18, 0
-  %41 = insertvalue %any %40, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
-  %42 = getelementptr inbounds [1 x %any], ptr %varargslots17, i64 0, i64 0
-  store %any %41, ptr %42, align 16
-  %43 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.3, i64 10, ptr %varargslots17, i64 1)
-  %44 = load i32, ptr %abc, align 4
-  %45 = call i32 @llvm.bswap.i32(i32 %44)
-  %46 = and i32 %45, -65536
-  %47 = or i32 %46, 4660
-  %48 = call i32 @llvm.bswap.i32(i32 %47)
-  store i32 %48, ptr %abc, align 4
-  %49 = load i32, ptr %abc, align 4
-  %50 = call i32 @llvm.bswap.i32(i32 %49)
-  %51 = and i32 %50, 65535
-  %52 = or i32 %51, 1450704896
-  %53 = call i32 @llvm.bswap.i32(i32 %52)
-  store i32 %53, ptr %abc, align 4
-  %54 = load i32, ptr %abc, align 4
-  %55 = call i32 @llvm.bswap.i32(i32 %54)
-  %56 = and i32 65535, %55
-  %trunc21 = trunc i32 %56 to i16
-  store i16 %trunc21, ptr %taddr22, align 2
-  %57 = insertvalue %any undef, ptr %taddr22, 0
-  %58 = insertvalue %any %57, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
-  %59 = getelementptr inbounds [1 x %any], ptr %varargslots20, i64 0, i64 0
-  store %any %58, ptr %59, align 16
-  %60 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.4, i64 12, ptr %varargslots20, i64 1)
-  %61 = load ptr, ptr %z, align 8
-  store ptr %61, ptr %.anon23, align 8
-  store i64 0, ptr %.anon24, align 8
-  br label %loop.cond25
+guard_block:                                      ; preds = %assign_optional
+  br label %voiderr
 
-loop.cond25:                                      ; preds = %loop.body27, %loop.exit14
-  %62 = load i64, ptr %.anon24, align 8
-  %gt26 = icmp ugt i64 4, %62
-  br i1 %gt26, label %loop.body27, label %loop.exit32
+noerr_block:                                      ; preds = %after_check
+  %25 = load i64, ptr %retparam5, align 8
+  store i64 %25, ptr %len, align 8
+  %26 = call i64 @std.io.File.write_byte(ptr %22, i8 zeroext 10)
+  %not_err7 = icmp eq i64 %26, 0
+  %27 = call i1 @llvm.expect.i1(i1 %not_err7, i1 true)
+  br i1 %27, label %after_check9, label %assign_optional8
 
-loop.body27:                                      ; preds = %loop.cond25
-  %63 = load ptr, ptr %.anon23, align 8
-  %64 = load i64, ptr %.anon24, 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 %d28, align 1
-  %67 = insertvalue %any undef, ptr %d28, 0
-  %68 = insertvalue %any %67, i64 ptrtoint (ptr @"$ct.char" to i64), 1
-  %69 = getelementptr inbounds [1 x %any], ptr %varargslots30, i64 0, i64 0
-  store %any %68, ptr %69, align 16
-  %70 = call i64 @std.io.printf(ptr %retparam29, ptr @.str.5, i64 3, ptr %varargslots30, i64 1)
-  %71 = load i64, ptr %.anon24, align 8
-  %add31 = add i64 %71, 1
-  store i64 %add31, ptr %.anon24, align 8
-  br label %loop.cond25
+assign_optional8:                                 ; preds = %noerr_block
+  store i64 %26, ptr %error_var6, align 8
+  br label %guard_block10
 
-loop.exit32:                                      ; preds = %loop.cond25
-  %72 = call ptr @std.io.stdout()
-  %73 = call i64 @std.io.File.printn(ptr %retparam33, ptr %72, ptr null, i64 0)
+after_check9:                                     ; preds = %noerr_block
+  br label %noerr_block11
+
+guard_block10:                                    ; preds = %assign_optional8
+  br label %voiderr
+
+noerr_block11:                                    ; preds = %after_check9
+  %28 = call i64 @std.io.File.flush(ptr %22)
+  %not_err13 = icmp eq i64 %28, 0
+  %29 = call i1 @llvm.expect.i1(i1 %not_err13, i1 true)
+  br i1 %29, label %after_check15, label %assign_optional14
+
+assign_optional14:                                ; preds = %noerr_block11
+  store i64 %28, ptr %error_var12, align 8
+  br label %guard_block16
+
+after_check15:                                    ; preds = %noerr_block11
+  br label %noerr_block17
+
+guard_block16:                                    ; preds = %assign_optional14
+  br label %voiderr
+
+noerr_block17:                                    ; preds = %after_check15
+  %30 = load i64, ptr %len, align 8
+  %add18 = add i64 %30, 1
+  br label %voiderr
+
+voiderr:                                          ; preds = %noerr_block17, %guard_block16, %guard_block10, %guard_block
+  %31 = load ptr, ptr %z, align 8
+  store ptr %31, ptr %.anon19, align 8
+  store i64 0, ptr %.anon20, align 8
+  br label %loop.cond21
+
+loop.cond21:                                      ; preds = %loop.body23, %voiderr
+  %32 = load i64, ptr %.anon20, align 8
+  %gt22 = icmp ugt i64 4, %32
+  br i1 %gt22, label %loop.body23, label %loop.exit30
+
+loop.body23:                                      ; preds = %loop.cond21
+  %33 = load ptr, ptr %.anon19, align 8
+  %34 = load i64, ptr %.anon20, align 8
+  %35 = getelementptr inbounds [4 x i8], ptr %33, i64 0, i64 %34
+  %36 = load i8, ptr %35, align 1
+  store i8 %36, ptr %d24, align 1
+  %37 = insertvalue %any undef, ptr %d24, 0
+  %38 = insertvalue %any %37, i64 ptrtoint (ptr @"$ct.char" to i64), 1
+  %39 = getelementptr inbounds [1 x %any], ptr %varargslots26, i64 0, i64 0
+  store %any %38, ptr %39, align 16
+  %40 = call i64 @std.io.printf(ptr %retparam25, ptr @.str.2, i64 3, ptr %varargslots26, i64 1)
+  %41 = load i64, ptr %.anon20, align 8
+  %add29 = add i64 %41, 1
+  store i64 %add29, ptr %.anon20, align 8
+  br label %loop.cond21
+
+loop.exit30:                                      ; preds = %loop.cond21
+  %42 = call ptr @std.io.stdout()
+  %43 = call i64 @std.io.File.write(ptr %retparam34, ptr %42, ptr null, i64 0)
+  %not_err35 = icmp eq i64 %43, 0
+  %44 = call i1 @llvm.expect.i1(i1 %not_err35, i1 true)
+  br i1 %44, label %after_check37, label %assign_optional36
+
+assign_optional36:                                ; preds = %loop.exit30
+  store i64 %43, ptr %error_var32, align 8
+  br label %guard_block38
+
+after_check37:                                    ; preds = %loop.exit30
+  br label %noerr_block39
+
+guard_block38:                                    ; preds = %assign_optional36
+  br label %voiderr53
+
+noerr_block39:                                    ; preds = %after_check37
+  %45 = load i64, ptr %retparam34, align 8
+  store i64 %45, ptr %len31, align 8
+  %46 = call i64 @std.io.File.write_byte(ptr %42, i8 zeroext 10)
+  %not_err41 = icmp eq i64 %46, 0
+  %47 = call i1 @llvm.expect.i1(i1 %not_err41, i1 true)
+  br i1 %47, label %after_check43, label %assign_optional42
+
+assign_optional42:                                ; preds = %noerr_block39
+  store i64 %46, ptr %error_var40, align 8
+  br label %guard_block44
+
+after_check43:                                    ; preds = %noerr_block39
+  br label %noerr_block45
+
+guard_block44:                                    ; preds = %assign_optional42
+  br label %voiderr53
+
+noerr_block45:                                    ; preds = %after_check43
+  %48 = call i64 @std.io.File.flush(ptr %42)
+  %not_err47 = icmp eq i64 %48, 0
+  %49 = call i1 @llvm.expect.i1(i1 %not_err47, i1 true)
+  br i1 %49, label %after_check49, label %assign_optional48
+
+assign_optional48:                                ; preds = %noerr_block45
+  store i64 %48, ptr %error_var46, align 8
+  br label %guard_block50
+
+after_check49:                                    ; preds = %noerr_block45
+  br label %noerr_block51
+
+guard_block50:                                    ; preds = %assign_optional48
+  br label %voiderr53
+
+noerr_block51:                                    ; preds = %after_check49
+  %50 = load i64, ptr %len31, align 8
+  %add52 = add i64 %50, 1
+  br label %voiderr53
+
+voiderr53:                                        ; preds = %noerr_block51, %guard_block50, %guard_block44, %guard_block38
+  %51 = load i32, ptr %abc, align 4
+  %52 = call i32 @llvm.bswap.i32(i32 %51)
+  %53 = and i32 65535, %52
+  %trunc = trunc i32 %53 to i16
+  store i16 %trunc, ptr %taddr56, align 2
+  %54 = insertvalue %any undef, ptr %taddr56, 0
+  %55 = insertvalue %any %54, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
+  %56 = getelementptr inbounds [1 x %any], ptr %varargslots55, i64 0, i64 0
+  store %any %55, ptr %56, align 16
+  %57 = call i64 @std.io.printfn(ptr %retparam54, ptr @.str.3, i64 10, ptr %varargslots55, i64 1)
+  %58 = load i32, ptr %abc, align 4
+  %59 = call i32 @llvm.bswap.i32(i32 %58)
+  %60 = and i32 %59, -65536
+  %61 = or i32 %60, 4660
+  %62 = call i32 @llvm.bswap.i32(i32 %61)
+  store i32 %62, ptr %abc, align 4
+  %63 = load i32, ptr %abc, align 4
+  %64 = call i32 @llvm.bswap.i32(i32 %63)
+  %65 = and i32 %64, 65535
+  %66 = or i32 %65, 1450704896
+  %67 = call i32 @llvm.bswap.i32(i32 %66)
+  store i32 %67, ptr %abc, align 4
+  %68 = load i32, ptr %abc, align 4
+  %69 = call i32 @llvm.bswap.i32(i32 %68)
+  %70 = and i32 65535, %69
+  %trunc61 = trunc i32 %70 to i16
+  store i16 %trunc61, ptr %taddr62, align 2
+  %71 = insertvalue %any undef, ptr %taddr62, 0
+  %72 = insertvalue %any %71, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
+  %73 = getelementptr inbounds [1 x %any], ptr %varargslots60, i64 0, i64 0
+  store %any %72, ptr %73, align 16
+  %74 = call i64 @std.io.printfn(ptr %retparam59, ptr @.str.4, i64 12, ptr %varargslots60, i64 1)
+  %75 = load ptr, ptr %z, align 8
+  store ptr %75, ptr %.anon65, align 8
+  store i64 0, ptr %.anon66, align 8
+  br label %loop.cond67
+
+loop.cond67:                                      ; preds = %loop.body69, %voiderr53
+  %76 = load i64, ptr %.anon66, align 8
+  %gt68 = icmp ugt i64 4, %76
+  br i1 %gt68, label %loop.body69, label %loop.exit76
+
+loop.body69:                                      ; preds = %loop.cond67
+  %77 = load ptr, ptr %.anon65, align 8
+  %78 = load i64, ptr %.anon66, align 8
+  %79 = getelementptr inbounds [4 x i8], ptr %77, i64 0, i64 %78
+  %80 = load i8, ptr %79, align 1
+  store i8 %80, ptr %d70, align 1
+  %81 = insertvalue %any undef, ptr %d70, 0
+  %82 = insertvalue %any %81, i64 ptrtoint (ptr @"$ct.char" to i64), 1
+  %83 = getelementptr inbounds [1 x %any], ptr %varargslots72, i64 0, i64 0
+  store %any %82, ptr %83, align 16
+  %84 = call i64 @std.io.printf(ptr %retparam71, ptr @.str.5, i64 3, ptr %varargslots72, i64 1)
+  %85 = load i64, ptr %.anon66, align 8
+  %add75 = add i64 %85, 1
+  store i64 %add75, ptr %.anon66, align 8
+  br label %loop.cond67
+
+loop.exit76:                                      ; preds = %loop.cond67
+  %86 = call ptr @std.io.stdout()
+  %87 = call i64 @std.io.File.write(ptr %retparam80, ptr %86, ptr null, i64 0)
+  %not_err81 = icmp eq i64 %87, 0
+  %88 = call i1 @llvm.expect.i1(i1 %not_err81, i1 true)
+  br i1 %88, label %after_check83, label %assign_optional82
+
+assign_optional82:                                ; preds = %loop.exit76
+  store i64 %87, ptr %error_var78, align 8
+  br label %guard_block84
+
+after_check83:                                    ; preds = %loop.exit76
+  br label %noerr_block85
+
+guard_block84:                                    ; preds = %assign_optional82
+  br label %voiderr99
+
+noerr_block85:                                    ; preds = %after_check83
+  %89 = load i64, ptr %retparam80, align 8
+  store i64 %89, ptr %len77, align 8
+  %90 = call i64 @std.io.File.write_byte(ptr %86, i8 zeroext 10)
+  %not_err87 = icmp eq i64 %90, 0
+  %91 = call i1 @llvm.expect.i1(i1 %not_err87, i1 true)
+  br i1 %91, label %after_check89, label %assign_optional88
+
+assign_optional88:                                ; preds = %noerr_block85
+  store i64 %90, ptr %error_var86, align 8
+  br label %guard_block90
+
+after_check89:                                    ; preds = %noerr_block85
+  br label %noerr_block91
+
+guard_block90:                                    ; preds = %assign_optional88
+  br label %voiderr99
+
+noerr_block91:                                    ; preds = %after_check89
+  %92 = call i64 @std.io.File.flush(ptr %86)
+  %not_err93 = icmp eq i64 %92, 0
+  %93 = call i1 @llvm.expect.i1(i1 %not_err93, i1 true)
+  br i1 %93, label %after_check95, label %assign_optional94
+
+assign_optional94:                                ; preds = %noerr_block91
+  store i64 %92, ptr %error_var92, align 8
+  br label %guard_block96
+
+after_check95:                                    ; preds = %noerr_block91
+  br label %noerr_block97
+
+guard_block96:                                    ; preds = %assign_optional94
+  br label %voiderr99
+
+noerr_block97:                                    ; preds = %after_check95
+  %94 = load i64, ptr %len77, align 8
+  %add98 = add i64 %94, 1
+  br label %voiderr99
+
+voiderr99:                                        ; preds = %noerr_block97, %guard_block96, %guard_block90, %guard_block84
   store i32 0, ptr %y, align 4
-  %74 = load i32, ptr %y, align 4
+  %95 = load i32, ptr %y, align 4
   store i32 123, ptr %y, align 4
-  %75 = insertvalue %any undef, ptr %y, 0
-  %76 = insertvalue %any %75, i64 ptrtoint (ptr @"$ct.int" to i64), 1
-  %77 = getelementptr inbounds [2 x %any], ptr %varargslots35, i64 0, i64 0
-  store %any %76, ptr %77, align 16
-  %78 = load i32, ptr %y, align 4
-  store i32 %78, ptr %taddr36, align 4
-  %79 = insertvalue %any undef, ptr %taddr36, 0
-  %80 = insertvalue %any %79, i64 ptrtoint (ptr @"$ct.int" to i64), 1
-  %81 = getelementptr inbounds [2 x %any], ptr %varargslots35, i64 0, i64 1
-  store %any %80, ptr %81, align 16
-  %82 = call i64 @std.io.printf(ptr %retparam34, ptr @.str.6, i64 18, ptr %varargslots35, i64 2)
+  %96 = insertvalue %any undef, ptr %y, 0
+  %97 = insertvalue %any %96, i64 ptrtoint (ptr @"$ct.int" to i64), 1
+  %98 = getelementptr inbounds [2 x %any], ptr %varargslots101, i64 0, i64 0
+  store %any %97, ptr %98, align 16
+  %99 = load i32, ptr %y, align 4
+  store i32 %99, ptr %taddr102, align 4
+  %100 = insertvalue %any undef, ptr %taddr102, 0
+  %101 = insertvalue %any %100, i64 ptrtoint (ptr @"$ct.int" to i64), 1
+  %102 = getelementptr inbounds [2 x %any], ptr %varargslots101, i64 0, i64 1
+  store %any %101, ptr %102, align 16
+  %103 = call i64 @std.io.printf(ptr %retparam100, ptr @.str.6, i64 18, ptr %varargslots101, i64 2)
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/compile_time/ct_builtin_time_date.c3t b/test/test_suite/compile_time/ct_builtin_time_date.c3t
index c0282b022..18ca03b0a 100644
--- a/test/test_suite/compile_time/ct_builtin_time_date.c3t
+++ b/test/test_suite/compile_time/ct_builtin_time_date.c3t
@@ -31,16 +31,32 @@ entry:
   %retparam = alloca i64, align 8
   %varargslots = alloca [1 x %any], align 16
   %taddr = alloca i32, align 4
-  %retparam1 = alloca i64, align 8
+  %len = alloca i64, align 8
+  %error_var = alloca i64, align 8
   %retparam2 = alloca i64, align 8
-  %retparam3 = alloca i64, align 8
-  %varargslots4 = alloca [1 x %any], align 16
-  %taddr5 = alloca i64, align 8
-  %retparam6 = alloca i64, align 8
-  %varargslots7 = alloca [1 x %any], align 16
-  %taddr8 = alloca i64, align 8
-  %retparam9 = alloca i64, align 8
-  %retparam10 = alloca i64, align 8
+  %error_var3 = alloca i64, align 8
+  %error_var9 = alloca i64, align 8
+  %len15 = alloca i64, align 8
+  %error_var16 = alloca i64, align 8
+  %retparam18 = alloca i64, align 8
+  %error_var24 = alloca i64, align 8
+  %error_var30 = alloca i64, align 8
+  %retparam38 = alloca i64, align 8
+  %varargslots39 = alloca [1 x %any], align 16
+  %taddr40 = alloca i64, align 8
+  %retparam43 = alloca i64, align 8
+  %varargslots44 = alloca [1 x %any], align 16
+  %taddr45 = alloca i64, align 8
+  %len48 = alloca i64, align 8
+  %error_var49 = alloca i64, align 8
+  %retparam51 = alloca i64, align 8
+  %error_var57 = alloca i64, align 8
+  %error_var63 = alloca i64, align 8
+  %len71 = alloca i64, align 8
+  %error_var72 = alloca i64, align 8
+  %retparam74 = alloca i64, align 8
+  %error_var80 = alloca i64, align 8
+  %error_var86 = alloca i64, align 8
   store i32 %0, ptr %taddr, align 4
   %1 = insertvalue %any undef, ptr %taddr, 0
   %2 = insertvalue %any %1, i64 ptrtoint (ptr @"$ct.int" to i64), 1
@@ -55,25 +71,189 @@ if.then:                                          ; preds = %entry
   br label %if.exit
 if.exit:                                          ; preds = %if.then, %entry
   %5 = call ptr @std.io.stdout()
-  %6 = call i64 @std.io.File.printn(ptr %retparam1, ptr %5, ptr @.str.1, i64 8)
-  %7 = call ptr @std.io.stdout()
-  %8 = call i64 @std.io.File.printn(ptr %retparam2, ptr %7, ptr @.str.2, i64 10)
-  store i64 14, ptr %taddr5, align 8
-  %9 = insertvalue %any undef, ptr %taddr5, 0
-  %10 = insertvalue %any %9, i64 ptrtoint (ptr @"$ct.long" to i64), 1
-  %11 = getelementptr inbounds [1 x %any], ptr %varargslots4, i64 0, i64 0
-  store %any %10, ptr %11, align 16
-  %12 = call i64 @std.io.printfn(ptr %retparam3, ptr @.str.3, i64 2, ptr %varargslots4, i64 1)
-  store i64 6, ptr %taddr8, align 8
-  %13 = insertvalue %any undef, ptr %taddr8, 0
-  %14 = insertvalue %any %13, i64 ptrtoint (ptr @"$ct.long" to i64), 1
-  %15 = getelementptr inbounds [1 x %any], ptr %varargslots7, i64 0, i64 0
-  store %any %14, ptr %15, align 16
-  %16 = call i64 @std.io.printfn(ptr %retparam6, ptr @.str.4, i64 2, ptr %varargslots7, i64 1)
-  %17 = call ptr @std.io.stdout()
-  %18 = call i64 @std.io.File.printn(ptr %retparam9, ptr %17, ptr @.str.5, i64 23)
-  %19 = call ptr @std.io.stdout()
-  %20 = call i64 @std.io.File.printn(ptr %retparam10, ptr %19, ptr @.str.6, i64 4)
+  %6 = call i64 @std.io.File.write(ptr %retparam2, ptr %5, ptr @.str.1, i64 8)
+  %not_err = icmp eq i64 %6, 0
+  %7 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
+  br i1 %7, label %after_check, label %assign_optional
+assign_optional:                                  ; preds = %if.exit
+  store i64 %6, ptr %error_var, align 8
+  br label %guard_block
+after_check:                                      ; preds = %if.exit
+  br label %noerr_block
+guard_block:                                      ; preds = %assign_optional
+  br label %voiderr
+noerr_block:                                      ; preds = %after_check
+  %8 = load i64, ptr %retparam2, align 8
+  store i64 %8, ptr %len, align 8
+  %9 = call i64 @std.io.File.write_byte(ptr %5, i8 zeroext 10)
+  %not_err4 = icmp eq i64 %9, 0
+  %10 = call i1 @llvm.expect.i1(i1 %not_err4, i1 true)
+  br i1 %10, label %after_check6, label %assign_optional5
+assign_optional5:                                 ; preds = %noerr_block
+  store i64 %9, ptr %error_var3, align 8
+  br label %guard_block7
+after_check6:                                     ; preds = %noerr_block
+  br label %noerr_block8
+guard_block7:                                     ; preds = %assign_optional5
+  br label %voiderr
+noerr_block8:                                     ; preds = %after_check6
+  %11 = call i64 @std.io.File.flush(ptr %5)
+  %not_err10 = icmp eq i64 %11, 0
+  %12 = call i1 @llvm.expect.i1(i1 %not_err10, i1 true)
+  br i1 %12, label %after_check12, label %assign_optional11
+assign_optional11:                                ; preds = %noerr_block8
+  store i64 %11, ptr %error_var9, align 8
+  br label %guard_block13
+after_check12:                                    ; preds = %noerr_block8
+  br label %noerr_block14
+guard_block13:                                    ; preds = %assign_optional11
+  br label %voiderr
+noerr_block14:                                    ; preds = %after_check12
+  %13 = load i64, ptr %len, align 8
+  %add = add i64 %13, 1
+  br label %voiderr
+voiderr:                                          ; preds = %noerr_block14, %guard_block13, %guard_block7, %guard_block
+  %14 = call ptr @std.io.stdout()
+  %15 = call i64 @std.io.File.write(ptr %retparam18, ptr %14, ptr @.str.2, i64 10)
+  %not_err19 = icmp eq i64 %15, 0
+  %16 = call i1 @llvm.expect.i1(i1 %not_err19, i1 true)
+  br i1 %16, label %after_check21, label %assign_optional20
+assign_optional20:                                ; preds = %voiderr
+  store i64 %15, ptr %error_var16, align 8
+  br label %guard_block22
+after_check21:                                    ; preds = %voiderr
+  br label %noerr_block23
+guard_block22:                                    ; preds = %assign_optional20
+  br label %voiderr37
+noerr_block23:                                    ; preds = %after_check21
+  %17 = load i64, ptr %retparam18, align 8
+  store i64 %17, ptr %len15, align 8
+  %18 = call i64 @std.io.File.write_byte(ptr %14, i8 zeroext 10)
+  %not_err25 = icmp eq i64 %18, 0
+  %19 = call i1 @llvm.expect.i1(i1 %not_err25, i1 true)
+  br i1 %19, label %after_check27, label %assign_optional26
+assign_optional26:                                ; preds = %noerr_block23
+  store i64 %18, ptr %error_var24, align 8
+  br label %guard_block28
+after_check27:                                    ; preds = %noerr_block23
+  br label %noerr_block29
+guard_block28:                                    ; preds = %assign_optional26
+  br label %voiderr37
+noerr_block29:                                    ; preds = %after_check27
+  %20 = call i64 @std.io.File.flush(ptr %14)
+  %not_err31 = icmp eq i64 %20, 0
+  %21 = call i1 @llvm.expect.i1(i1 %not_err31, i1 true)
+  br i1 %21, label %after_check33, label %assign_optional32
+assign_optional32:                                ; preds = %noerr_block29
+  store i64 %20, ptr %error_var30, align 8
+  br label %guard_block34
+after_check33:                                    ; preds = %noerr_block29
+  br label %noerr_block35
+guard_block34:                                    ; preds = %assign_optional32
+  br label %voiderr37
+noerr_block35:                                    ; preds = %after_check33
+  %22 = load i64, ptr %len15, align 8
+  %add36 = add i64 %22, 1
+  br label %voiderr37
+voiderr37:                                        ; preds = %noerr_block35, %guard_block34, %guard_block28, %guard_block22
+  store i64 14, ptr %taddr40, align 8
+  %23 = insertvalue %any undef, ptr %taddr40, 0
+  %24 = insertvalue %any %23, i64 ptrtoint (ptr @"$ct.long" to i64), 1
+  %25 = getelementptr inbounds [1 x %any], ptr %varargslots39, i64 0, i64 0
+  store %any %24, ptr %25, align 16
+  %26 = call i64 @std.io.printfn(ptr %retparam38, ptr @.str.3, i64 2, ptr %varargslots39, i64 1)
+  store i64 6, ptr %taddr45, align 8
+  %27 = insertvalue %any undef, ptr %taddr45, 0
+  %28 = insertvalue %any %27, i64 ptrtoint (ptr @"$ct.long" to i64), 1
+  %29 = getelementptr inbounds [1 x %any], ptr %varargslots44, i64 0, i64 0
+  store %any %28, ptr %29, align 16
+  %30 = call i64 @std.io.printfn(ptr %retparam43, ptr @.str.4, i64 2, ptr %varargslots44, i64 1)
+  %31 = call ptr @std.io.stdout()
+  %32 = call i64 @std.io.File.write(ptr %retparam51, ptr %31, ptr @.str.5, i64 23)
+  %not_err52 = icmp eq i64 %32, 0
+  %33 = call i1 @llvm.expect.i1(i1 %not_err52, i1 true)
+  br i1 %33, label %after_check54, label %assign_optional53
+assign_optional53:                                ; preds = %voiderr37
+  store i64 %32, ptr %error_var49, align 8
+  br label %guard_block55
+after_check54:                                    ; preds = %voiderr37
+  br label %noerr_block56
+guard_block55:                                    ; preds = %assign_optional53
+  br label %voiderr70
+noerr_block56:                                    ; preds = %after_check54
+  %34 = load i64, ptr %retparam51, align 8
+  store i64 %34, ptr %len48, align 8
+  %35 = call i64 @std.io.File.write_byte(ptr %31, i8 zeroext 10)
+  %not_err58 = icmp eq i64 %35, 0
+  %36 = call i1 @llvm.expect.i1(i1 %not_err58, i1 true)
+  br i1 %36, label %after_check60, label %assign_optional59
+assign_optional59:                                ; preds = %noerr_block56
+  store i64 %35, ptr %error_var57, align 8
+  br label %guard_block61
+after_check60:                                    ; preds = %noerr_block56
+  br label %noerr_block62
+guard_block61:                                    ; preds = %assign_optional59
+  br label %voiderr70
+noerr_block62:                                    ; preds = %after_check60
+  %37 = call i64 @std.io.File.flush(ptr %31)
+  %not_err64 = icmp eq i64 %37, 0
+  %38 = call i1 @llvm.expect.i1(i1 %not_err64, i1 true)
+  br i1 %38, label %after_check66, label %assign_optional65
+assign_optional65:                                ; preds = %noerr_block62
+  store i64 %37, ptr %error_var63, align 8
+  br label %guard_block67
+after_check66:                                    ; preds = %noerr_block62
+  br label %noerr_block68
+guard_block67:                                    ; preds = %assign_optional65
+  br label %voiderr70
+noerr_block68:                                    ; preds = %after_check66
+  %39 = load i64, ptr %len48, align 8
+  %add69 = add i64 %39, 1
+  br label %voiderr70
+voiderr70:                                        ; preds = %noerr_block68, %guard_block67, %guard_block61, %guard_block55
+  %40 = call ptr @std.io.stdout()
+  %41 = call i64 @std.io.File.write(ptr %retparam74, ptr %40, ptr @.str.6, i64 4)
+  %not_err75 = icmp eq i64 %41, 0
+  %42 = call i1 @llvm.expect.i1(i1 %not_err75, i1 true)
+  br i1 %42, label %after_check77, label %assign_optional76
+assign_optional76:                                ; preds = %voiderr70
+  store i64 %41, ptr %error_var72, align 8
+  br label %guard_block78
+after_check77:                                    ; preds = %voiderr70
+  br label %noerr_block79
+guard_block78:                                    ; preds = %assign_optional76
+  br label %voiderr93
+noerr_block79:                                    ; preds = %after_check77
+  %43 = load i64, ptr %retparam74, align 8
+  store i64 %43, ptr %len71, align 8
+  %44 = call i64 @std.io.File.write_byte(ptr %40, i8 zeroext 10)
+  %not_err81 = icmp eq i64 %44, 0
+  %45 = call i1 @llvm.expect.i1(i1 %not_err81, i1 true)
+  br i1 %45, label %after_check83, label %assign_optional82
+assign_optional82:                                ; preds = %noerr_block79
+  store i64 %44, ptr %error_var80, align 8
+  br label %guard_block84
+after_check83:                                    ; preds = %noerr_block79
+  br label %noerr_block85
+guard_block84:                                    ; preds = %assign_optional82
+  br label %voiderr93
+noerr_block85:                                    ; preds = %after_check83
+  %46 = call i64 @std.io.File.flush(ptr %40)
+  %not_err87 = icmp eq i64 %46, 0
+  %47 = call i1 @llvm.expect.i1(i1 %not_err87, i1 true)
+  br i1 %47, label %after_check89, label %assign_optional88
+assign_optional88:                                ; preds = %noerr_block85
+  store i64 %46, ptr %error_var86, align 8
+  br label %guard_block90
+after_check89:                                    ; preds = %noerr_block85
+  br label %noerr_block91
+guard_block90:                                    ; preds = %assign_optional88
+  br label %voiderr93
+noerr_block91:                                    ; preds = %after_check89
+  %48 = load i64, ptr %len71, align 8
+  %add92 = add i64 %48, 1
+  br label %voiderr93
+voiderr93:                                        ; preds = %noerr_block91, %guard_block90, %guard_block84, %guard_block78
   ret void
 }
 ; Function Attrs: nounwind
diff --git a/test/test_suite/compile_time/ct_memberof.c3t b/test/test_suite/compile_time/ct_memberof.c3t
index 60e898c66..bcb9c0c12 100644
--- a/test/test_suite/compile_time/ct_memberof.c3t
+++ b/test/test_suite/compile_time/ct_memberof.c3t
@@ -116,204 +116,519 @@ entry:
 ; Function Attrs: nounwind
 define void @test.test(i32 %0) #0 {
 entry:
+  %len = alloca i64, align 8
+  %error_var = alloca i64, align 8
   %retparam = alloca i64, align 8
-  %retparam1 = alloca i64, align 8
-  %retparam2 = alloca i64, align 8
-  %retparam3 = alloca i64, align 8
-  %retparam4 = alloca i64, align 8
-  %retparam5 = alloca i64, align 8
-  %retparam6 = alloca i64, align 8
-  %retparam7 = alloca i64, align 8
+  %error_var2 = alloca i64, align 8
+  %error_var8 = alloca i64, align 8
+  %len14 = alloca i64, align 8
+  %error_var15 = alloca i64, align 8
+  %retparam17 = alloca i64, align 8
+  %error_var23 = alloca i64, align 8
+  %error_var29 = alloca i64, align 8
+  %len37 = alloca i64, align 8
+  %error_var38 = alloca i64, align 8
+  %retparam40 = alloca i64, align 8
+  %error_var46 = alloca i64, align 8
+  %error_var52 = alloca i64, align 8
+  %len60 = alloca i64, align 8
+  %error_var61 = alloca i64, align 8
+  %retparam63 = alloca i64, align 8
+  %error_var69 = alloca i64, align 8
+  %error_var75 = alloca i64, align 8
+  %len83 = alloca i64, align 8
+  %error_var84 = alloca i64, align 8
+  %retparam86 = alloca i64, align 8
+  %error_var92 = alloca i64, align 8
+  %error_var98 = alloca i64, align 8
+  %len106 = alloca i64, align 8
+  %error_var107 = alloca i64, align 8
+  %retparam109 = alloca i64, align 8
+  %error_var115 = alloca i64, align 8
+  %error_var121 = alloca i64, align 8
+  %len129 = alloca i64, align 8
+  %error_var130 = alloca i64, align 8
+  %retparam132 = alloca i64, align 8
+  %error_var138 = alloca i64, align 8
+  %error_var144 = alloca i64, align 8
+  %retparam152 = alloca i64, align 8
   %varargslots = alloca [1 x %any], align 16
   %taddr = alloca %"char[]", align 8
-  %retparam8 = alloca i64, align 8
-  %varargslots9 = alloca [2 x %any], align 16
-  %taddr10 = alloca %"char[]", align 8
-  %taddr11 = alloca %"char[]", align 8
-  %retparam12 = alloca i64, align 8
-  %varargslots13 = alloca [2 x %any], align 16
-  %taddr14 = alloca %"char[]", align 8
-  %taddr15 = alloca %"char[]", align 8
-  %retparam16 = alloca i64, align 8
-  %varargslots17 = alloca [2 x %any], align 16
-  %taddr18 = alloca %"char[]", align 8
-  %taddr19 = alloca %"char[]", align 8
-  %retparam20 = alloca i64, align 8
-  %varargslots21 = alloca [2 x %any], align 16
-  %taddr22 = alloca %"char[]", align 8
-  %taddr23 = alloca %"char[]", align 8
-  %retparam24 = alloca i64, align 8
-  %varargslots25 = alloca [1 x %any], align 16
-  %taddr26 = alloca %"char[]", align 8
-  %retparam27 = alloca i64, align 8
-  %varargslots28 = alloca [2 x %any], align 16
-  %taddr29 = alloca %"char[]", align 8
-  %taddr30 = alloca %"char[]", align 8
-  %retparam31 = alloca i64, align 8
-  %varargslots32 = alloca [2 x %any], align 16
-  %taddr33 = alloca %"char[]", align 8
-  %taddr34 = alloca %"char[]", align 8
-  %retparam35 = alloca i64, align 8
-  %varargslots36 = alloca [2 x %any], align 16
-  %taddr37 = alloca %"char[]", align 8
-  %taddr38 = alloca %"char[]", align 8
-  %retparam39 = alloca i64, align 8
-  %varargslots40 = alloca [2 x %any], align 16
-  %taddr41 = alloca %"char[]", align 8
-  %taddr42 = alloca %"char[]", align 8
-  %retparam43 = alloca i64, align 8
-  %varargslots44 = alloca [1 x %any], align 16
-  %taddr45 = alloca %"char[]", align 8
-  %retparam46 = alloca i64, align 8
-  %varargslots47 = alloca [2 x %any], align 16
-  %taddr48 = alloca %"char[]", align 8
-  %taddr49 = alloca %"char[]", align 8
-  %retparam50 = alloca i64, align 8
-  %varargslots51 = alloca [2 x %any], align 16
-  %taddr52 = alloca %"char[]", align 8
-  %taddr53 = alloca %"char[]", align 8
+  %retparam155 = alloca i64, align 8
+  %varargslots156 = alloca [2 x %any], align 16
+  %taddr157 = alloca %"char[]", align 8
+  %taddr158 = alloca %"char[]", align 8
+  %retparam161 = alloca i64, align 8
+  %varargslots162 = alloca [2 x %any], align 16
+  %taddr163 = alloca %"char[]", align 8
+  %taddr164 = alloca %"char[]", align 8
+  %retparam167 = alloca i64, align 8
+  %varargslots168 = alloca [2 x %any], align 16
+  %taddr169 = alloca %"char[]", align 8
+  %taddr170 = alloca %"char[]", align 8
+  %retparam173 = alloca i64, align 8
+  %varargslots174 = alloca [2 x %any], align 16
+  %taddr175 = alloca %"char[]", align 8
+  %taddr176 = alloca %"char[]", align 8
+  %retparam179 = alloca i64, align 8
+  %varargslots180 = alloca [1 x %any], align 16
+  %taddr181 = alloca %"char[]", align 8
+  %retparam184 = alloca i64, align 8
+  %varargslots185 = alloca [2 x %any], align 16
+  %taddr186 = alloca %"char[]", align 8
+  %taddr187 = alloca %"char[]", align 8
+  %retparam190 = alloca i64, align 8
+  %varargslots191 = alloca [2 x %any], align 16
+  %taddr192 = alloca %"char[]", align 8
+  %taddr193 = alloca %"char[]", align 8
+  %retparam196 = alloca i64, align 8
+  %varargslots197 = alloca [2 x %any], align 16
+  %taddr198 = alloca %"char[]", align 8
+  %taddr199 = alloca %"char[]", align 8
+  %retparam202 = alloca i64, align 8
+  %varargslots203 = alloca [2 x %any], align 16
+  %taddr204 = alloca %"char[]", align 8
+  %taddr205 = alloca %"char[]", align 8
+  %retparam208 = alloca i64, align 8
+  %varargslots209 = alloca [1 x %any], align 16
+  %taddr210 = alloca %"char[]", align 8
+  %retparam213 = alloca i64, align 8
+  %varargslots214 = alloca [2 x %any], align 16
+  %taddr215 = alloca %"char[]", align 8
+  %taddr216 = alloca %"char[]", align 8
+  %retparam219 = alloca i64, align 8
+  %varargslots220 = alloca [2 x %any], align 16
+  %taddr221 = alloca %"char[]", align 8
+  %taddr222 = alloca %"char[]", align 8
   %1 = call ptr @std.io.stdout()
-  %2 = call i64 @std.io.File.printn(ptr %retparam, ptr %1, ptr @.str, i64 3)
-  %3 = call ptr @std.io.stdout()
-  %4 = call i64 @std.io.File.printn(ptr %retparam1, ptr %3, ptr @.str.10, i64 3)
-  %5 = call ptr @std.io.stdout()
-  %6 = call i64 @std.io.File.printn(ptr %retparam2, ptr %5, ptr @.str.11, i64 6)
-  %7 = call ptr @std.io.stdout()
-  %8 = call i64 @std.io.File.printn(ptr %retparam3, ptr %7, ptr @.str.12, i64 6)
-  %9 = call ptr @std.io.stdout()
-  %10 = call i64 @std.io.File.printn(ptr %retparam4, ptr %9, ptr @.str.13, i64 5)
-  %11 = call ptr @std.io.stdout()
-  %12 = call i64 @std.io.File.printn(ptr %retparam5, ptr %11, ptr @.str.14, i64 4)
-  %13 = call ptr @std.io.stdout()
-  %14 = call i64 @std.io.File.printn(ptr %retparam6, ptr %13, ptr @.str.15, i64 3)
+  %2 = call i64 @std.io.File.write(ptr %retparam, ptr %1, ptr @.str, i64 3)
+  %not_err = icmp eq i64 %2, 0
+  %3 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
+  br i1 %3, label %after_check, label %assign_optional
+assign_optional:                                  ; preds = %entry
+  store i64 %2, ptr %error_var, align 8
+  br label %guard_block
+after_check:                                      ; preds = %entry
+  br label %noerr_block
+guard_block:                                      ; preds = %assign_optional
+  br label %voiderr
+noerr_block:                                      ; preds = %after_check
+  %4 = load i64, ptr %retparam, align 8
+  store i64 %4, ptr %len, align 8
+  %5 = call i64 @std.io.File.write_byte(ptr %1, i8 zeroext 10)
+  %not_err3 = icmp eq i64 %5, 0
+  %6 = call i1 @llvm.expect.i1(i1 %not_err3, i1 true)
+  br i1 %6, label %after_check5, label %assign_optional4
+assign_optional4:                                 ; preds = %noerr_block
+  store i64 %5, ptr %error_var2, align 8
+  br label %guard_block6
+after_check5:                                     ; preds = %noerr_block
+  br label %noerr_block7
+guard_block6:                                     ; preds = %assign_optional4
+  br label %voiderr
+noerr_block7:                                     ; preds = %after_check5
+  %7 = call i64 @std.io.File.flush(ptr %1)
+  %not_err9 = icmp eq i64 %7, 0
+  %8 = call i1 @llvm.expect.i1(i1 %not_err9, i1 true)
+  br i1 %8, label %after_check11, label %assign_optional10
+assign_optional10:                                ; preds = %noerr_block7
+  store i64 %7, ptr %error_var8, align 8
+  br label %guard_block12
+after_check11:                                    ; preds = %noerr_block7
+  br label %noerr_block13
+guard_block12:                                    ; preds = %assign_optional10
+  br label %voiderr
+noerr_block13:                                    ; preds = %after_check11
+  %9 = load i64, ptr %len, align 8
+  %add = add i64 %9, 1
+  br label %voiderr
+voiderr:                                          ; preds = %noerr_block13, %guard_block12, %guard_block6, %guard_block
+  %10 = call ptr @std.io.stdout()
+  %11 = call i64 @std.io.File.write(ptr %retparam17, ptr %10, ptr @.str.10, i64 3)
+  %not_err18 = icmp eq i64 %11, 0
+  %12 = call i1 @llvm.expect.i1(i1 %not_err18, i1 true)
+  br i1 %12, label %after_check20, label %assign_optional19
+assign_optional19:                                ; preds = %voiderr
+  store i64 %11, ptr %error_var15, align 8
+  br label %guard_block21
+after_check20:                                    ; preds = %voiderr
+  br label %noerr_block22
+guard_block21:                                    ; preds = %assign_optional19
+  br label %voiderr36
+noerr_block22:                                    ; preds = %after_check20
+  %13 = load i64, ptr %retparam17, align 8
+  store i64 %13, ptr %len14, align 8
+  %14 = call i64 @std.io.File.write_byte(ptr %10, i8 zeroext 10)
+  %not_err24 = icmp eq i64 %14, 0
+  %15 = call i1 @llvm.expect.i1(i1 %not_err24, i1 true)
+  br i1 %15, label %after_check26, label %assign_optional25
+assign_optional25:                                ; preds = %noerr_block22
+  store i64 %14, ptr %error_var23, align 8
+  br label %guard_block27
+after_check26:                                    ; preds = %noerr_block22
+  br label %noerr_block28
+guard_block27:                                    ; preds = %assign_optional25
+  br label %voiderr36
+noerr_block28:                                    ; preds = %after_check26
+  %16 = call i64 @std.io.File.flush(ptr %10)
+  %not_err30 = icmp eq i64 %16, 0
+  %17 = call i1 @llvm.expect.i1(i1 %not_err30, i1 true)
+  br i1 %17, label %after_check32, label %assign_optional31
+assign_optional31:                                ; preds = %noerr_block28
+  store i64 %16, ptr %error_var29, align 8
+  br label %guard_block33
+after_check32:                                    ; preds = %noerr_block28
+  br label %noerr_block34
+guard_block33:                                    ; preds = %assign_optional31
+  br label %voiderr36
+noerr_block34:                                    ; preds = %after_check32
+  %18 = load i64, ptr %len14, align 8
+  %add35 = add i64 %18, 1
+  br label %voiderr36
+voiderr36:                                        ; preds = %noerr_block34, %guard_block33, %guard_block27, %guard_block21
+  %19 = call ptr @std.io.stdout()
+  %20 = call i64 @std.io.File.write(ptr %retparam40, ptr %19, ptr @.str.11, i64 6)
+  %not_err41 = icmp eq i64 %20, 0
+  %21 = call i1 @llvm.expect.i1(i1 %not_err41, i1 true)
+  br i1 %21, label %after_check43, label %assign_optional42
+assign_optional42:                                ; preds = %voiderr36
+  store i64 %20, ptr %error_var38, align 8
+  br label %guard_block44
+after_check43:                                    ; preds = %voiderr36
+  br label %noerr_block45
+guard_block44:                                    ; preds = %assign_optional42
+  br label %voiderr59
+noerr_block45:                                    ; preds = %after_check43
+  %22 = load i64, ptr %retparam40, align 8
+  store i64 %22, ptr %len37, align 8
+  %23 = call i64 @std.io.File.write_byte(ptr %19, i8 zeroext 10)
+  %not_err47 = icmp eq i64 %23, 0
+  %24 = call i1 @llvm.expect.i1(i1 %not_err47, i1 true)
+  br i1 %24, label %after_check49, label %assign_optional48
+assign_optional48:                                ; preds = %noerr_block45
+  store i64 %23, ptr %error_var46, align 8
+  br label %guard_block50
+after_check49:                                    ; preds = %noerr_block45
+  br label %noerr_block51
+guard_block50:                                    ; preds = %assign_optional48
+  br label %voiderr59
+noerr_block51:                                    ; preds = %after_check49
+  %25 = call i64 @std.io.File.flush(ptr %19)
+  %not_err53 = icmp eq i64 %25, 0
+  %26 = call i1 @llvm.expect.i1(i1 %not_err53, i1 true)
+  br i1 %26, label %after_check55, label %assign_optional54
+assign_optional54:                                ; preds = %noerr_block51
+  store i64 %25, ptr %error_var52, align 8
+  br label %guard_block56
+after_check55:                                    ; preds = %noerr_block51
+  br label %noerr_block57
+guard_block56:                                    ; preds = %assign_optional54
+  br label %voiderr59
+noerr_block57:                                    ; preds = %after_check55
+  %27 = load i64, ptr %len37, align 8
+  %add58 = add i64 %27, 1
+  br label %voiderr59
+voiderr59:                                        ; preds = %noerr_block57, %guard_block56, %guard_block50, %guard_block44
+  %28 = call ptr @std.io.stdout()
+  %29 = call i64 @std.io.File.write(ptr %retparam63, ptr %28, ptr @.str.12, i64 6)
+  %not_err64 = icmp eq i64 %29, 0
+  %30 = call i1 @llvm.expect.i1(i1 %not_err64, i1 true)
+  br i1 %30, label %after_check66, label %assign_optional65
+assign_optional65:                                ; preds = %voiderr59
+  store i64 %29, ptr %error_var61, align 8
+  br label %guard_block67
+after_check66:                                    ; preds = %voiderr59
+  br label %noerr_block68
+guard_block67:                                    ; preds = %assign_optional65
+  br label %voiderr82
+noerr_block68:                                    ; preds = %after_check66
+  %31 = load i64, ptr %retparam63, align 8
+  store i64 %31, ptr %len60, align 8
+  %32 = call i64 @std.io.File.write_byte(ptr %28, i8 zeroext 10)
+  %not_err70 = icmp eq i64 %32, 0
+  %33 = call i1 @llvm.expect.i1(i1 %not_err70, i1 true)
+  br i1 %33, label %after_check72, label %assign_optional71
+assign_optional71:                                ; preds = %noerr_block68
+  store i64 %32, ptr %error_var69, align 8
+  br label %guard_block73
+after_check72:                                    ; preds = %noerr_block68
+  br label %noerr_block74
+guard_block73:                                    ; preds = %assign_optional71
+  br label %voiderr82
+noerr_block74:                                    ; preds = %after_check72
+  %34 = call i64 @std.io.File.flush(ptr %28)
+  %not_err76 = icmp eq i64 %34, 0
+  %35 = call i1 @llvm.expect.i1(i1 %not_err76, i1 true)
+  br i1 %35, label %after_check78, label %assign_optional77
+assign_optional77:                                ; preds = %noerr_block74
+  store i64 %34, ptr %error_var75, align 8
+  br label %guard_block79
+after_check78:                                    ; preds = %noerr_block74
+  br label %noerr_block80
+guard_block79:                                    ; preds = %assign_optional77
+  br label %voiderr82
+noerr_block80:                                    ; preds = %after_check78
+  %36 = load i64, ptr %len60, align 8
+  %add81 = add i64 %36, 1
+  br label %voiderr82
+voiderr82:                                        ; preds = %noerr_block80, %guard_block79, %guard_block73, %guard_block67
+  %37 = call ptr @std.io.stdout()
+  %38 = call i64 @std.io.File.write(ptr %retparam86, ptr %37, ptr @.str.13, i64 5)
+  %not_err87 = icmp eq i64 %38, 0
+  %39 = call i1 @llvm.expect.i1(i1 %not_err87, i1 true)
+  br i1 %39, label %after_check89, label %assign_optional88
+assign_optional88:                                ; preds = %voiderr82
+  store i64 %38, ptr %error_var84, align 8
+  br label %guard_block90
+after_check89:                                    ; preds = %voiderr82
+  br label %noerr_block91
+guard_block90:                                    ; preds = %assign_optional88
+  br label %voiderr105
+noerr_block91:                                    ; preds = %after_check89
+  %40 = load i64, ptr %retparam86, align 8
+  store i64 %40, ptr %len83, align 8
+  %41 = call i64 @std.io.File.write_byte(ptr %37, i8 zeroext 10)
+  %not_err93 = icmp eq i64 %41, 0
+  %42 = call i1 @llvm.expect.i1(i1 %not_err93, i1 true)
+  br i1 %42, label %after_check95, label %assign_optional94
+assign_optional94:                                ; preds = %noerr_block91
+  store i64 %41, ptr %error_var92, align 8
+  br label %guard_block96
+after_check95:                                    ; preds = %noerr_block91
+  br label %noerr_block97
+guard_block96:                                    ; preds = %assign_optional94
+  br label %voiderr105
+noerr_block97:                                    ; preds = %after_check95
+  %43 = call i64 @std.io.File.flush(ptr %37)
+  %not_err99 = icmp eq i64 %43, 0
+  %44 = call i1 @llvm.expect.i1(i1 %not_err99, i1 true)
+  br i1 %44, label %after_check101, label %assign_optional100
+assign_optional100:                               ; preds = %noerr_block97
+  store i64 %43, ptr %error_var98, align 8
+  br label %guard_block102
+after_check101:                                   ; preds = %noerr_block97
+  br label %noerr_block103
+guard_block102:                                   ; preds = %assign_optional100
+  br label %voiderr105
+noerr_block103:                                   ; preds = %after_check101
+  %45 = load i64, ptr %len83, align 8
+  %add104 = add i64 %45, 1
+  br label %voiderr105
+voiderr105:                                       ; preds = %noerr_block103, %guard_block102, %guard_block96, %guard_block90
+  %46 = call ptr @std.io.stdout()
+  %47 = call i64 @std.io.File.write(ptr %retparam109, ptr %46, ptr @.str.14, i64 4)
+  %not_err110 = icmp eq i64 %47, 0
+  %48 = call i1 @llvm.expect.i1(i1 %not_err110, i1 true)
+  br i1 %48, label %after_check112, label %assign_optional111
+assign_optional111:                               ; preds = %voiderr105
+  store i64 %47, ptr %error_var107, align 8
+  br label %guard_block113
+after_check112:                                   ; preds = %voiderr105
+  br label %noerr_block114
+guard_block113:                                   ; preds = %assign_optional111
+  br label %voiderr128
+noerr_block114:                                   ; preds = %after_check112
+  %49 = load i64, ptr %retparam109, align 8
+  store i64 %49, ptr %len106, align 8
+  %50 = call i64 @std.io.File.write_byte(ptr %46, i8 zeroext 10)
+  %not_err116 = icmp eq i64 %50, 0
+  %51 = call i1 @llvm.expect.i1(i1 %not_err116, i1 true)
+  br i1 %51, label %after_check118, label %assign_optional117
+assign_optional117:                               ; preds = %noerr_block114
+  store i64 %50, ptr %error_var115, align 8
+  br label %guard_block119
+after_check118:                                   ; preds = %noerr_block114
+  br label %noerr_block120
+guard_block119:                                   ; preds = %assign_optional117
+  br label %voiderr128
+noerr_block120:                                   ; preds = %after_check118
+  %52 = call i64 @std.io.File.flush(ptr %46)
+  %not_err122 = icmp eq i64 %52, 0
+  %53 = call i1 @llvm.expect.i1(i1 %not_err122, i1 true)
+  br i1 %53, label %after_check124, label %assign_optional123
+assign_optional123:                               ; preds = %noerr_block120
+  store i64 %52, ptr %error_var121, align 8
+  br label %guard_block125
+after_check124:                                   ; preds = %noerr_block120
+  br label %noerr_block126
+guard_block125:                                   ; preds = %assign_optional123
+  br label %voiderr128
+noerr_block126:                                   ; preds = %after_check124
+  %54 = load i64, ptr %len106, align 8
+  %add127 = add i64 %54, 1
+  br label %voiderr128
+voiderr128:                                       ; preds = %noerr_block126, %guard_block125, %guard_block119, %guard_block113
+  %55 = call ptr @std.io.stdout()
+  %56 = call i64 @std.io.File.write(ptr %retparam132, ptr %55, ptr @.str.15, i64 3)
+  %not_err133 = icmp eq i64 %56, 0
+  %57 = call i1 @llvm.expect.i1(i1 %not_err133, i1 true)
+  br i1 %57, label %after_check135, label %assign_optional134
+assign_optional134:                               ; preds = %voiderr128
+  store i64 %56, ptr %error_var130, align 8
+  br label %guard_block136
+after_check135:                                   ; preds = %voiderr128
+  br label %noerr_block137
+guard_block136:                                   ; preds = %assign_optional134
+  br label %voiderr151
+noerr_block137:                                   ; preds = %after_check135
+  %58 = load i64, ptr %retparam132, align 8
+  store i64 %58, ptr %len129, align 8
+  %59 = call i64 @std.io.File.write_byte(ptr %55, i8 zeroext 10)
+  %not_err139 = icmp eq i64 %59, 0
+  %60 = call i1 @llvm.expect.i1(i1 %not_err139, i1 true)
+  br i1 %60, label %after_check141, label %assign_optional140
+assign_optional140:                               ; preds = %noerr_block137
+  store i64 %59, ptr %error_var138, align 8
+  br label %guard_block142
+after_check141:                                   ; preds = %noerr_block137
+  br label %noerr_block143
+guard_block142:                                   ; preds = %assign_optional140
+  br label %voiderr151
+noerr_block143:                                   ; preds = %after_check141
+  %61 = call i64 @std.io.File.flush(ptr %55)
+  %not_err145 = icmp eq i64 %61, 0
+  %62 = call i1 @llvm.expect.i1(i1 %not_err145, i1 true)
+  br i1 %62, label %after_check147, label %assign_optional146
+assign_optional146:                               ; preds = %noerr_block143
+  store i64 %61, ptr %error_var144, align 8
+  br label %guard_block148
+after_check147:                                   ; preds = %noerr_block143
+  br label %noerr_block149
+guard_block148:                                   ; preds = %assign_optional146
+  br label %voiderr151
+noerr_block149:                                   ; preds = %after_check147
+  %63 = load i64, ptr %len129, align 8
+  %add150 = add i64 %63, 1
+  br label %voiderr151
+voiderr151:                                       ; preds = %noerr_block149, %guard_block148, %guard_block142, %guard_block136
   store %"char[]" { ptr @.str.17, i64 3 }, ptr %taddr, align 8
-  %15 = insertvalue %any undef, ptr %taddr, 0
-  %16 = insertvalue %any %15, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %17 = getelementptr inbounds [1 x %any], ptr %varargslots, i64 0, i64 0
-  store %any %16, ptr %17, align 16
-  %18 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
-  store %"char[]" { ptr @.str.19, i64 1 }, ptr %taddr10, align 8
-  %19 = insertvalue %any undef, ptr %taddr10, 0
-  %20 = insertvalue %any %19, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %21 = getelementptr inbounds [2 x %any], ptr %varargslots9, i64 0, i64 0
-  store %any %20, ptr %21, align 16
-  store %"char[]" { ptr @.str.20, i64 3 }, ptr %taddr11, align 8
-  %22 = insertvalue %any undef, ptr %taddr11, 0
-  %23 = insertvalue %any %22, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %24 = getelementptr inbounds [2 x %any], ptr %varargslots9, i64 0, i64 1
-  store %any %23, ptr %24, align 16
-  %25 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.18, i64 6, ptr %varargslots9, i64 2)
-  store %"char[]" { ptr @.str.22, i64 4 }, ptr %taddr14, align 8
-  %26 = insertvalue %any undef, ptr %taddr14, 0
-  %27 = insertvalue %any %26, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %28 = getelementptr inbounds [2 x %any], ptr %varargslots13, i64 0, i64 0
-  store %any %27, ptr %28, align 16
-  store %"char[]" { ptr @.str.23, i64 4 }, ptr %taddr15, align 8
-  %29 = insertvalue %any undef, ptr %taddr15, 0
-  %30 = insertvalue %any %29, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %31 = getelementptr inbounds [2 x %any], ptr %varargslots13, i64 0, i64 1
-  store %any %30, ptr %31, align 16
-  %32 = call i64 @std.io.printfn(ptr %retparam12, ptr @.str.21, i64 6, ptr %varargslots13, i64 2)
-  store %"char[]" zeroinitializer, ptr %taddr18, align 8
-  %33 = insertvalue %any undef, ptr %taddr18, 0
-  %34 = insertvalue %any %33, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %35 = getelementptr inbounds [2 x %any], ptr %varargslots17, i64 0, i64 0
-  store %any %34, ptr %35, align 16
-  store %"char[]" { ptr @.str.25, i64 5 }, ptr %taddr19, align 8
-  %36 = insertvalue %any undef, ptr %taddr19, 0
-  %37 = insertvalue %any %36, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %38 = getelementptr inbounds [2 x %any], ptr %varargslots17, i64 0, i64 1
-  store %any %37, ptr %38, align 16
-  %39 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.24, i64 6, ptr %varargslots17, i64 2)
-  store %"char[]" { ptr @.str.27, i64 1 }, ptr %taddr22, align 8
-  %40 = insertvalue %any undef, ptr %taddr22, 0
-  %41 = insertvalue %any %40, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %42 = getelementptr inbounds [2 x %any], ptr %varargslots21, i64 0, i64 0
-  store %any %41, ptr %42, align 16
-  store %"char[]" { ptr @.str.28, i64 6 }, ptr %taddr23, align 8
-  %43 = insertvalue %any undef, ptr %taddr23, 0
-  %44 = insertvalue %any %43, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %45 = getelementptr inbounds [2 x %any], ptr %varargslots21, i64 0, i64 1
-  store %any %44, ptr %45, align 16
-  %46 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.26, i64 6, ptr %varargslots21, i64 2)
-  store %"char[]" { ptr @.str.30, i64 3 }, ptr %taddr26, align 8
-  %47 = insertvalue %any undef, ptr %taddr26, 0
-  %48 = insertvalue %any %47, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %49 = getelementptr inbounds [1 x %any], ptr %varargslots25, i64 0, i64 0
-  store %any %48, ptr %49, align 16
-  %50 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.29, i64 8, ptr %varargslots25, i64 1)
-  store %"char[]" { ptr @.str.32, i64 1 }, ptr %taddr29, align 8
-  %51 = insertvalue %any undef, ptr %taddr29, 0
-  %52 = insertvalue %any %51, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %53 = getelementptr inbounds [2 x %any], ptr %varargslots28, i64 0, i64 0
-  store %any %52, ptr %53, align 16
-  store %"char[]" { ptr @.str.33, i64 4 }, ptr %taddr30, align 8
-  %54 = insertvalue %any undef, ptr %taddr30, 0
-  %55 = insertvalue %any %54, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %56 = getelementptr inbounds [2 x %any], ptr %varargslots28, i64 0, i64 1
-  store %any %55, ptr %56, align 16
-  %57 = call i64 @std.io.printfn(ptr %retparam27, ptr @.str.31, i64 6, ptr %varargslots28, i64 2)
-  store %"char[]" { ptr @.str.35, i64 1 }, ptr %taddr33, align 8
-  %58 = insertvalue %any undef, ptr %taddr33, 0
-  %59 = insertvalue %any %58, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %60 = getelementptr inbounds [2 x %any], ptr %varargslots32, i64 0, i64 0
-  store %any %59, ptr %60, align 16
-  store %"char[]" { ptr @.str.36, i64 5 }, ptr %taddr34, align 8
-  %61 = insertvalue %any undef, ptr %taddr34, 0
-  %62 = insertvalue %any %61, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %63 = getelementptr inbounds [2 x %any], ptr %varargslots32, i64 0, i64 1
-  store %any %62, ptr %63, align 16
-  %64 = call i64 @std.io.printfn(ptr %retparam31, ptr @.str.34, i64 6, ptr %varargslots32, i64 2)
-  store %"char[]" zeroinitializer, ptr %taddr37, align 8
-  %65 = insertvalue %any undef, ptr %taddr37, 0
-  %66 = insertvalue %any %65, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %67 = getelementptr inbounds [2 x %any], ptr %varargslots36, i64 0, i64 0
-  store %any %66, ptr %67, align 16
-  store %"char[]" { ptr @.str.38, i64 5 }, ptr %taddr38, align 8
-  %68 = insertvalue %any undef, ptr %taddr38, 0
+  %64 = insertvalue %any undef, ptr %taddr, 0
+  %65 = insertvalue %any %64, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %66 = getelementptr inbounds [1 x %any], ptr %varargslots, i64 0, i64 0
+  store %any %65, ptr %66, align 16
+  %67 = call i64 @std.io.printfn(ptr %retparam152, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
+  store %"char[]" { ptr @.str.19, i64 1 }, ptr %taddr157, align 8
+  %68 = insertvalue %any undef, ptr %taddr157, 0
   %69 = insertvalue %any %68, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %70 = getelementptr inbounds [2 x %any], ptr %varargslots36, i64 0, i64 1
+  %70 = getelementptr inbounds [2 x %any], ptr %varargslots156, i64 0, i64 0
   store %any %69, ptr %70, align 16
-  %71 = call i64 @std.io.printfn(ptr %retparam35, ptr @.str.37, i64 6, ptr %varargslots36, i64 2)
-  store %"char[]" { ptr @.str.40, i64 3 }, ptr %taddr41, align 8
-  %72 = insertvalue %any undef, ptr %taddr41, 0
-  %73 = insertvalue %any %72, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %74 = getelementptr inbounds [2 x %any], ptr %varargslots40, i64 0, i64 0
-  store %any %73, ptr %74, align 16
-  store %"char[]" { ptr @.str.41, i64 3 }, ptr %taddr42, align 8
-  %75 = insertvalue %any undef, ptr %taddr42, 0
+  store %"char[]" { ptr @.str.20, i64 3 }, ptr %taddr158, align 8
+  %71 = insertvalue %any undef, ptr %taddr158, 0
+  %72 = insertvalue %any %71, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %73 = getelementptr inbounds [2 x %any], ptr %varargslots156, i64 0, i64 1
+  store %any %72, ptr %73, align 16
+  %74 = call i64 @std.io.printfn(ptr %retparam155, ptr @.str.18, i64 6, ptr %varargslots156, i64 2)
+  store %"char[]" { ptr @.str.22, i64 4 }, ptr %taddr163, align 8
+  %75 = insertvalue %any undef, ptr %taddr163, 0
   %76 = insertvalue %any %75, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %77 = getelementptr inbounds [2 x %any], ptr %varargslots40, i64 0, i64 1
+  %77 = getelementptr inbounds [2 x %any], ptr %varargslots162, i64 0, i64 0
   store %any %76, ptr %77, align 16
-  %78 = call i64 @std.io.printfn(ptr %retparam39, ptr @.str.39, i64 6, ptr %varargslots40, i64 2)
-  store %"char[]" { ptr @.str.43, i64 4 }, ptr %taddr45, align 8
-  %79 = insertvalue %any undef, ptr %taddr45, 0
-  %80 = insertvalue %any %79, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %81 = getelementptr inbounds [1 x %any], ptr %varargslots44, i64 0, i64 0
-  store %any %80, ptr %81, align 16
-  %82 = call i64 @std.io.printfn(ptr %retparam43, ptr @.str.42, i64 8, ptr %varargslots44, i64 1)
-  store %"char[]" { ptr @.str.45, i64 1 }, ptr %taddr48, align 8
-  %83 = insertvalue %any undef, ptr %taddr48, 0
-  %84 = insertvalue %any %83, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %85 = getelementptr inbounds [2 x %any], ptr %varargslots47, i64 0, i64 0
-  store %any %84, ptr %85, align 16
-  store %"char[]" { ptr @.str.46, i64 3 }, ptr %taddr49, align 8
-  %86 = insertvalue %any undef, ptr %taddr49, 0
-  %87 = insertvalue %any %86, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %88 = getelementptr inbounds [2 x %any], ptr %varargslots47, i64 0, i64 1
-  store %any %87, ptr %88, align 16
-  %89 = call i64 @std.io.printfn(ptr %retparam46, ptr @.str.44, i64 6, ptr %varargslots47, i64 2)
-  store %"char[]" { ptr @.str.48, i64 1 }, ptr %taddr52, align 8
-  %90 = insertvalue %any undef, ptr %taddr52, 0
-  %91 = insertvalue %any %90, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %92 = getelementptr inbounds [2 x %any], ptr %varargslots51, i64 0, i64 0
-  store %any %91, ptr %92, align 16
-  store %"char[]" { ptr @.str.49, i64 5 }, ptr %taddr53, align 8
-  %93 = insertvalue %any undef, ptr %taddr53, 0
-  %94 = insertvalue %any %93, i64 ptrtoint (ptr @"$ct.String" to i64), 1
-  %95 = getelementptr inbounds [2 x %any], ptr %varargslots51, i64 0, i64 1
-  store %any %94, ptr %95, align 16
-  %96 = call i64 @std.io.printfn(ptr %retparam50, ptr @.str.47, i64 6, ptr %varargslots51, i64 2)
+  store %"char[]" { ptr @.str.23, i64 4 }, ptr %taddr164, align 8
+  %78 = insertvalue %any undef, ptr %taddr164, 0
+  %79 = insertvalue %any %78, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %80 = getelementptr inbounds [2 x %any], ptr %varargslots162, i64 0, i64 1
+  store %any %79, ptr %80, align 16
+  %81 = call i64 @std.io.printfn(ptr %retparam161, ptr @.str.21, i64 6, ptr %varargslots162, i64 2)
+  store %"char[]" zeroinitializer, ptr %taddr169, align 8
+  %82 = insertvalue %any undef, ptr %taddr169, 0
+  %83 = insertvalue %any %82, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %84 = getelementptr inbounds [2 x %any], ptr %varargslots168, i64 0, i64 0
+  store %any %83, ptr %84, align 16
+  store %"char[]" { ptr @.str.25, i64 5 }, ptr %taddr170, align 8
+  %85 = insertvalue %any undef, ptr %taddr170, 0
+  %86 = insertvalue %any %85, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %87 = getelementptr inbounds [2 x %any], ptr %varargslots168, i64 0, i64 1
+  store %any %86, ptr %87, align 16
+  %88 = call i64 @std.io.printfn(ptr %retparam167, ptr @.str.24, i64 6, ptr %varargslots168, i64 2)
+  store %"char[]" { ptr @.str.27, i64 1 }, ptr %taddr175, align 8
+  %89 = insertvalue %any undef, ptr %taddr175, 0
+  %90 = insertvalue %any %89, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %91 = getelementptr inbounds [2 x %any], ptr %varargslots174, i64 0, i64 0
+  store %any %90, ptr %91, align 16
+  store %"char[]" { ptr @.str.28, i64 6 }, ptr %taddr176, align 8
+  %92 = insertvalue %any undef, ptr %taddr176, 0
+  %93 = insertvalue %any %92, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %94 = getelementptr inbounds [2 x %any], ptr %varargslots174, i64 0, i64 1
+  store %any %93, ptr %94, align 16
+  %95 = call i64 @std.io.printfn(ptr %retparam173, ptr @.str.26, i64 6, ptr %varargslots174, i64 2)
+  store %"char[]" { ptr @.str.30, i64 3 }, ptr %taddr181, align 8
+  %96 = insertvalue %any undef, ptr %taddr181, 0
+  %97 = insertvalue %any %96, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %98 = getelementptr inbounds [1 x %any], ptr %varargslots180, i64 0, i64 0
+  store %any %97, ptr %98, align 16
+  %99 = call i64 @std.io.printfn(ptr %retparam179, ptr @.str.29, i64 8, ptr %varargslots180, i64 1)
+  store %"char[]" { ptr @.str.32, i64 1 }, ptr %taddr186, align 8
+  %100 = insertvalue %any undef, ptr %taddr186, 0
+  %101 = insertvalue %any %100, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %102 = getelementptr inbounds [2 x %any], ptr %varargslots185, i64 0, i64 0
+  store %any %101, ptr %102, align 16
+  store %"char[]" { ptr @.str.33, i64 4 }, ptr %taddr187, align 8
+  %103 = insertvalue %any undef, ptr %taddr187, 0
+  %104 = insertvalue %any %103, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %105 = getelementptr inbounds [2 x %any], ptr %varargslots185, i64 0, i64 1
+  store %any %104, ptr %105, align 16
+  %106 = call i64 @std.io.printfn(ptr %retparam184, ptr @.str.31, i64 6, ptr %varargslots185, i64 2)
+  store %"char[]" { ptr @.str.35, i64 1 }, ptr %taddr192, align 8
+  %107 = insertvalue %any undef, ptr %taddr192, 0
+  %108 = insertvalue %any %107, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %109 = getelementptr inbounds [2 x %any], ptr %varargslots191, i64 0, i64 0
+  store %any %108, ptr %109, align 16
+  store %"char[]" { ptr @.str.36, i64 5 }, ptr %taddr193, align 8
+  %110 = insertvalue %any undef, ptr %taddr193, 0
+  %111 = insertvalue %any %110, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %112 = getelementptr inbounds [2 x %any], ptr %varargslots191, i64 0, i64 1
+  store %any %111, ptr %112, align 16
+  %113 = call i64 @std.io.printfn(ptr %retparam190, ptr @.str.34, i64 6, ptr %varargslots191, i64 2)
+  store %"char[]" zeroinitializer, ptr %taddr198, align 8
+  %114 = insertvalue %any undef, ptr %taddr198, 0
+  %115 = insertvalue %any %114, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %116 = getelementptr inbounds [2 x %any], ptr %varargslots197, i64 0, i64 0
+  store %any %115, ptr %116, align 16
+  store %"char[]" { ptr @.str.38, i64 5 }, ptr %taddr199, align 8
+  %117 = insertvalue %any undef, ptr %taddr199, 0
+  %118 = insertvalue %any %117, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %119 = getelementptr inbounds [2 x %any], ptr %varargslots197, i64 0, i64 1
+  store %any %118, ptr %119, align 16
+  %120 = call i64 @std.io.printfn(ptr %retparam196, ptr @.str.37, i64 6, ptr %varargslots197, i64 2)
+  store %"char[]" { ptr @.str.40, i64 3 }, ptr %taddr204, align 8
+  %121 = insertvalue %any undef, ptr %taddr204, 0
+  %122 = insertvalue %any %121, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %123 = getelementptr inbounds [2 x %any], ptr %varargslots203, i64 0, i64 0
+  store %any %122, ptr %123, align 16
+  store %"char[]" { ptr @.str.41, i64 3 }, ptr %taddr205, align 8
+  %124 = insertvalue %any undef, ptr %taddr205, 0
+  %125 = insertvalue %any %124, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %126 = getelementptr inbounds [2 x %any], ptr %varargslots203, i64 0, i64 1
+  store %any %125, ptr %126, align 16
+  %127 = call i64 @std.io.printfn(ptr %retparam202, ptr @.str.39, i64 6, ptr %varargslots203, i64 2)
+  store %"char[]" { ptr @.str.43, i64 4 }, ptr %taddr210, align 8
+  %128 = insertvalue %any undef, ptr %taddr210, 0
+  %129 = insertvalue %any %128, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %130 = getelementptr inbounds [1 x %any], ptr %varargslots209, i64 0, i64 0
+  store %any %129, ptr %130, align 16
+  %131 = call i64 @std.io.printfn(ptr %retparam208, ptr @.str.42, i64 8, ptr %varargslots209, i64 1)
+  store %"char[]" { ptr @.str.45, i64 1 }, ptr %taddr215, align 8
+  %132 = insertvalue %any undef, ptr %taddr215, 0
+  %133 = insertvalue %any %132, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %134 = getelementptr inbounds [2 x %any], ptr %varargslots214, i64 0, i64 0
+  store %any %133, ptr %134, align 16
+  store %"char[]" { ptr @.str.46, i64 3 }, ptr %taddr216, align 8
+  %135 = insertvalue %any undef, ptr %taddr216, 0
+  %136 = insertvalue %any %135, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %137 = getelementptr inbounds [2 x %any], ptr %varargslots214, i64 0, i64 1
+  store %any %136, ptr %137, align 16
+  %138 = call i64 @std.io.printfn(ptr %retparam213, ptr @.str.44, i64 6, ptr %varargslots214, i64 2)
+  store %"char[]" { ptr @.str.48, i64 1 }, ptr %taddr221, align 8
+  %139 = insertvalue %any undef, ptr %taddr221, 0
+  %140 = insertvalue %any %139, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %141 = getelementptr inbounds [2 x %any], ptr %varargslots220, i64 0, i64 0
+  store %any %140, ptr %141, align 16
+  store %"char[]" { ptr @.str.49, i64 5 }, ptr %taddr222, align 8
+  %142 = insertvalue %any undef, ptr %taddr222, 0
+  %143 = insertvalue %any %142, i64 ptrtoint (ptr @"$ct.String" to i64), 1
+  %144 = getelementptr inbounds [2 x %any], ptr %varargslots220, i64 0, i64 1
+  store %any %143, ptr %144, align 16
+  %145 = call i64 @std.io.printfn(ptr %retparam219, ptr @.str.47, i64 6, ptr %varargslots220, i64 2)
   ret void
 }
 ; Function Attrs: nounwind
diff --git a/test/test_suite/errors/general_error_regression.c3t b/test/test_suite/errors/general_error_regression.c3t
index 160b85300..213cfc8d2 100644
--- a/test/test_suite/errors/general_error_regression.c3t
+++ b/test/test_suite/errors/general_error_regression.c3t
@@ -74,27 +74,201 @@ fn void main()
 
 define void @foo.Foo.hello(ptr %0) #0 {
 entry:
+  %len = alloca i64, align 8
+  %error_var = alloca i64, align 8
   %retparam = alloca i64, align 8
+  %error_var2 = alloca i64, align 8
+  %error_var8 = alloca i64, align 8
   %1 = call ptr @std.io.stdout()
-  %2 = call i64 @std.io.File.printn(ptr %retparam, ptr %1, ptr @.str.12, i64 14)
+  %2 = call i64 @std.io.File.write(ptr %retparam, ptr %1, ptr @.str.12, i64 14)
+  %not_err = icmp eq i64 %2, 0
+  %3 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
+  br i1 %3, label %after_check, label %assign_optional
+
+assign_optional:                                  ; preds = %entry
+  store i64 %2, ptr %error_var, align 8
+  br label %guard_block
+
+after_check:                                      ; preds = %entry
+  br label %noerr_block
+
+guard_block:                                      ; preds = %assign_optional
+  br label %voiderr
+
+noerr_block:                                      ; preds = %after_check
+  %4 = load i64, ptr %retparam, align 8
+  store i64 %4, ptr %len, align 8
+  %5 = call i64 @std.io.File.write_byte(ptr %1, i8 zeroext 10)
+  %not_err3 = icmp eq i64 %5, 0
+  %6 = call i1 @llvm.expect.i1(i1 %not_err3, i1 true)
+  br i1 %6, label %after_check5, label %assign_optional4
+
+assign_optional4:                                 ; preds = %noerr_block
+  store i64 %5, ptr %error_var2, align 8
+  br label %guard_block6
+
+after_check5:                                     ; preds = %noerr_block
+  br label %noerr_block7
+
+guard_block6:                                     ; preds = %assign_optional4
+  br label %voiderr
+
+noerr_block7:                                     ; preds = %after_check5
+  %7 = call i64 @std.io.File.flush(ptr %1)
+  %not_err9 = icmp eq i64 %7, 0
+  %8 = call i1 @llvm.expect.i1(i1 %not_err9, i1 true)
+  br i1 %8, label %after_check11, label %assign_optional10
+
+assign_optional10:                                ; preds = %noerr_block7
+  store i64 %7, ptr %error_var8, align 8
+  br label %guard_block12
+
+after_check11:                                    ; preds = %noerr_block7
+  br label %noerr_block13
+
+guard_block12:                                    ; preds = %assign_optional10
+  br label %voiderr
+
+noerr_block13:                                    ; preds = %after_check11
+  %9 = load i64, ptr %len, align 8
+  %add = add i64 %9, 1
+  br label %voiderr
+
+voiderr:                                          ; preds = %noerr_block13, %guard_block12, %guard_block6, %guard_block
   ret void
 }
 
 ; Function Attrs: nounwind
 define void @foo.Bar.hello(ptr %0) #0 {
 entry:
+  %len = alloca i64, align 8
+  %error_var = alloca i64, align 8
   %retparam = alloca i64, align 8
+  %error_var2 = alloca i64, align 8
+  %error_var8 = alloca i64, align 8
   %1 = call ptr @std.io.stdout()
-  %2 = call i64 @std.io.File.printn(ptr %retparam, ptr %1, ptr @.str.13, i64 14)
+  %2 = call i64 @std.io.File.write(ptr %retparam, ptr %1, ptr @.str.13, i64 14)
+  %not_err = icmp eq i64 %2, 0
+  %3 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
+  br i1 %3, label %after_check, label %assign_optional
+
+assign_optional:                                  ; preds = %entry
+  store i64 %2, ptr %error_var, align 8
+  br label %guard_block
+
+after_check:                                      ; preds = %entry
+  br label %noerr_block
+
+guard_block:                                      ; preds = %assign_optional
+  br label %voiderr
+
+noerr_block:                                      ; preds = %after_check
+  %4 = load i64, ptr %retparam, align 8
+  store i64 %4, ptr %len, align 8
+  %5 = call i64 @std.io.File.write_byte(ptr %1, i8 zeroext 10)
+  %not_err3 = icmp eq i64 %5, 0
+  %6 = call i1 @llvm.expect.i1(i1 %not_err3, i1 true)
+  br i1 %6, label %after_check5, label %assign_optional4
+
+assign_optional4:                                 ; preds = %noerr_block
+  store i64 %5, ptr %error_var2, align 8
+  br label %guard_block6
+
+after_check5:                                     ; preds = %noerr_block
+  br label %noerr_block7
+
+guard_block6:                                     ; preds = %assign_optional4
+  br label %voiderr
+
+noerr_block7:                                     ; preds = %after_check5
+  %7 = call i64 @std.io.File.flush(ptr %1)
+  %not_err9 = icmp eq i64 %7, 0
+  %8 = call i1 @llvm.expect.i1(i1 %not_err9, i1 true)
+  br i1 %8, label %after_check11, label %assign_optional10
+
+assign_optional10:                                ; preds = %noerr_block7
+  store i64 %7, ptr %error_var8, align 8
+  br label %guard_block12
+
+after_check11:                                    ; preds = %noerr_block7
+  br label %noerr_block13
+
+guard_block12:                                    ; preds = %assign_optional10
+  br label %voiderr
+
+noerr_block13:                                    ; preds = %after_check11
+  %9 = load i64, ptr %len, align 8
+  %add = add i64 %9, 1
+  br label %voiderr
+
+voiderr:                                          ; preds = %noerr_block13, %guard_block12, %guard_block6, %guard_block
   ret void
 }
 
 ; Function Attrs: nounwind
 define void @foo.MyEnum.hello(ptr %0) #0 {
 entry:
+  %len = alloca i64, align 8
+  %error_var = alloca i64, align 8
   %retparam = alloca i64, align 8
+  %error_var2 = alloca i64, align 8
+  %error_var8 = alloca i64, align 8
   %1 = call ptr @std.io.stdout()
-  %2 = call i64 @std.io.File.printn(ptr %retparam, ptr %1, ptr @.str.14, i64 17)
+  %2 = call i64 @std.io.File.write(ptr %retparam, ptr %1, ptr @.str.14, i64 17)
+  %not_err = icmp eq i64 %2, 0
+  %3 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
+  br i1 %3, label %after_check, label %assign_optional
+
+assign_optional:                                  ; preds = %entry
+  store i64 %2, ptr %error_var, align 8
+  br label %guard_block
+
+after_check:                                      ; preds = %entry
+  br label %noerr_block
+
+guard_block:                                      ; preds = %assign_optional
+  br label %voiderr
+
+noerr_block:                                      ; preds = %after_check
+  %4 = load i64, ptr %retparam, align 8
+  store i64 %4, ptr %len, align 8
+  %5 = call i64 @std.io.File.write_byte(ptr %1, i8 zeroext 10)
+  %not_err3 = icmp eq i64 %5, 0
+  %6 = call i1 @llvm.expect.i1(i1 %not_err3, i1 true)
+  br i1 %6, label %after_check5, label %assign_optional4
+
+assign_optional4:                                 ; preds = %noerr_block
+  store i64 %5, ptr %error_var2, align 8
+  br label %guard_block6
+
+after_check5:                                     ; preds = %noerr_block
+  br label %noerr_block7
+
+guard_block6:                                     ; preds = %assign_optional4
+  br label %voiderr
+
+noerr_block7:                                     ; preds = %after_check5
+  %7 = call i64 @std.io.File.flush(ptr %1)
+  %not_err9 = icmp eq i64 %7, 0
+  %8 = call i1 @llvm.expect.i1(i1 %not_err9, i1 true)
+  br i1 %8, label %after_check11, label %assign_optional10
+
+assign_optional10:                                ; preds = %noerr_block7
+  store i64 %7, ptr %error_var8, align 8
+  br label %guard_block12
+
+after_check11:                                    ; preds = %noerr_block7
+  br label %noerr_block13
+
+guard_block12:                                    ; preds = %assign_optional10
+  br label %voiderr
+
+noerr_block13:                                    ; preds = %after_check11
+  %9 = load i64, ptr %len, align 8
+  %add = add i64 %9, 1
+  br label %voiderr
+
+voiderr:                                          ; preds = %noerr_block13, %guard_block12, %guard_block6, %guard_block
   ret void
 }
 
diff --git a/test/test_suite/errors/multiple_catch.c3t b/test/test_suite/errors/multiple_catch.c3t
index 19c89d6b4..10662d6d1 100644
--- a/test/test_suite/errors/multiple_catch.c3t
+++ b/test/test_suite/errors/multiple_catch.c3t
@@ -54,11 +54,15 @@ entry:
   %varargslots22 = alloca [1 x %any], align 16
   %temp_err = alloca i64, align 8
   %retparam27 = alloca i32, align 4
-  %retparam38 = alloca i64, align 8
-  %err42 = alloca i64, align 8
-  %retparam44 = alloca i32, align 4
-  %retparam55 = alloca i64, align 8
-  %varargslots56 = alloca [1 x %any], align 16
+  %len = alloca i64, align 8
+  %error_var = alloca i64, align 8
+  %retparam39 = alloca i64, align 8
+  %error_var43 = alloca i64, align 8
+  %error_var49 = alloca i64, align 8
+  %err56 = alloca i64, align 8
+  %retparam58 = alloca i32, align 4
+  %retparam69 = alloca i64, align 8
+  %varargslots70 = alloca [1 x %any], align 16
   br label %testblock
 
 testblock:                                        ; preds = %entry
@@ -177,56 +181,110 @@ after_check34:                                    ; preds = %testblock31
 end_block35:                                      ; preds = %after_check34, %assign_optional33, %assign_optional29
   %22 = load i64, ptr %temp_err, align 8
   %neq36 = icmp ne i64 %22, 0
-  br i1 %neq36, label %if.then37, label %if.exit41
+  br i1 %neq36, label %if.then37, label %if.exit55
 
 if.then37:                                        ; preds = %end_block35
   %23 = call ptr @std.io.stdout()
-  %24 = call i64 @std.io.File.printn(ptr %retparam38, ptr %23, ptr @.str.5, i64 4)
-  br label %if.exit41
+  %24 = call i64 @std.io.File.write(ptr %retparam39, ptr %23, ptr @.str.5, i64 4)
+  %not_err40 = icmp eq i64 %24, 0
+  %25 = call i1 @llvm.expect.i1(i1 %not_err40, i1 true)
+  br i1 %25, label %after_check42, label %assign_optional41
 
-if.exit41:                                        ; preds = %if.then37, %end_block35
-  br label %testblock43
+assign_optional41:                                ; preds = %if.then37
+  store i64 %24, ptr %error_var, align 8
+  br label %guard_block
 
-testblock43:                                      ; preds = %if.exit41
-  %25 = call i64 @demo1.hello(ptr %retparam44, i32 0)
-  %not_err45 = icmp eq i64 %25, 0
-  %26 = call i1 @llvm.expect.i1(i1 %not_err45, i1 true)
-  br i1 %26, label %after_check47, label %assign_optional46
+after_check42:                                    ; preds = %if.then37
+  br label %noerr_block
 
-assign_optional46:                                ; preds = %testblock43
-  store i64 %25, ptr %err42, align 8
-  br label %end_block52
+guard_block:                                      ; preds = %assign_optional41
+  br label %voiderr
 
-after_check47:                                    ; preds = %testblock43
-  br label %testblock48
+noerr_block:                                      ; preds = %after_check42
+  %26 = load i64, ptr %retparam39, align 8
+  store i64 %26, ptr %len, align 8
+  %27 = call i64 @std.io.File.write_byte(ptr %23, i8 zeroext 10)
+  %not_err44 = icmp eq i64 %27, 0
+  %28 = call i1 @llvm.expect.i1(i1 %not_err44, i1 true)
+  br i1 %28, label %after_check46, label %assign_optional45
 
-testblock48:                                      ; preds = %after_check47
-  %27 = call i64 @demo1.bye()
-  %not_err49 = icmp eq i64 %27, 0
-  %28 = call i1 @llvm.expect.i1(i1 %not_err49, i1 true)
-  br i1 %28, label %after_check51, label %assign_optional50
+assign_optional45:                                ; preds = %noerr_block
+  store i64 %27, ptr %error_var43, align 8
+  br label %guard_block47
 
-assign_optional50:                                ; preds = %testblock48
-  store i64 %27, ptr %err42, align 8
-  br label %end_block52
+after_check46:                                    ; preds = %noerr_block
+  br label %noerr_block48
 
-after_check51:                                    ; preds = %testblock48
-  store i64 0, ptr %err42, align 8
-  br label %end_block52
+guard_block47:                                    ; preds = %assign_optional45
+  br label %voiderr
 
-end_block52:                                      ; preds = %after_check51, %assign_optional50, %assign_optional46
-  %29 = load i64, ptr %err42, align 8
-  %neq53 = icmp ne i64 %29, 0
-  br i1 %neq53, label %if.then54, label %if.exit59
+noerr_block48:                                    ; preds = %after_check46
+  %29 = call i64 @std.io.File.flush(ptr %23)
+  %not_err50 = icmp eq i64 %29, 0
+  %30 = call i1 @llvm.expect.i1(i1 %not_err50, i1 true)
+  br i1 %30, label %after_check52, label %assign_optional51
 
-if.then54:                                        ; preds = %end_block52
-  %30 = insertvalue %any undef, ptr %err42, 0
-  %31 = insertvalue %any %30, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1
-  %32 = getelementptr inbounds [1 x %any], ptr %varargslots56, i64 0, i64 0
-  store %any %31, ptr %32, align 16
-  %33 = call i64 @std.io.printfn(ptr %retparam55, ptr @.str.6, i64 8, ptr %varargslots56, i64 1)
-  br label %if.exit59
+assign_optional51:                                ; preds = %noerr_block48
+  store i64 %29, ptr %error_var49, align 8
+  br label %guard_block53
 
-if.exit59:                                        ; preds = %if.then54, %end_block52
+after_check52:                                    ; preds = %noerr_block48
+  br label %noerr_block54
+
+guard_block53:                                    ; preds = %assign_optional51
+  br label %voiderr
+
+noerr_block54:                                    ; preds = %after_check52
+  %31 = load i64, ptr %len, align 8
+  %add = add i64 %31, 1
+  br label %voiderr
+
+voiderr:                                          ; preds = %noerr_block54, %guard_block53, %guard_block47, %guard_block
+  br label %if.exit55
+
+if.exit55:                                        ; preds = %voiderr, %end_block35
+  br label %testblock57
+
+testblock57:                                      ; preds = %if.exit55
+  %32 = call i64 @demo1.hello(ptr %retparam58, i32 0)
+  %not_err59 = icmp eq i64 %32, 0
+  %33 = call i1 @llvm.expect.i1(i1 %not_err59, i1 true)
+  br i1 %33, label %after_check61, label %assign_optional60
+
+assign_optional60:                                ; preds = %testblock57
+  store i64 %32, ptr %err56, align 8
+  br label %end_block66
+
+after_check61:                                    ; preds = %testblock57
+  br label %testblock62
+
+testblock62:                                      ; preds = %after_check61
+  %34 = call i64 @demo1.bye()
+  %not_err63 = icmp eq i64 %34, 0
+  %35 = call i1 @llvm.expect.i1(i1 %not_err63, i1 true)
+  br i1 %35, label %after_check65, label %assign_optional64
+
+assign_optional64:                                ; preds = %testblock62
+  store i64 %34, ptr %err56, align 8
+  br label %end_block66
+
+after_check65:                                    ; preds = %testblock62
+  store i64 0, ptr %err56, align 8
+  br label %end_block66
+
+end_block66:                                      ; preds = %after_check65, %assign_optional64, %assign_optional60
+  %36 = load i64, ptr %err56, align 8
+  %neq67 = icmp ne i64 %36, 0
+  br i1 %neq67, label %if.then68, label %if.exit73
+
+if.then68:                                        ; preds = %end_block66
+  %37 = insertvalue %any undef, ptr %err56, 0
+  %38 = insertvalue %any %37, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1
+  %39 = getelementptr inbounds [1 x %any], ptr %varargslots70, i64 0, i64 0
+  store %any %38, ptr %39, align 16
+  %40 = call i64 @std.io.printfn(ptr %retparam69, ptr @.str.6, i64 8, ptr %varargslots70, i64 1)
+  br label %if.exit73
+
+if.exit73:                                        ; preds = %if.then68, %end_block66
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/errors/or_and_rethrow.c3t b/test/test_suite/errors/or_and_rethrow.c3t
index f7c39caee..c717d3e77 100644
--- a/test/test_suite/errors/or_and_rethrow.c3t
+++ b/test/test_suite/errors/or_and_rethrow.c3t
@@ -46,12 +46,28 @@ entry:
   %taddr = alloca i32, align 4
   %error_var = alloca i64, align 8
   %blockret = alloca i32, align 4
-  %retparam1 = alloca i64, align 8
-  %retparam2 = alloca i64, align 8
-  %error_var3 = alloca i64, align 8
-  %blockret4 = alloca i32, align 4
-  %retparam8 = alloca i64, align 8
-  %retparam10 = alloca i64, align 8
+  %len = alloca i64, align 8
+  %error_var2 = alloca i64, align 8
+  %retparam4 = alloca i64, align 8
+  %error_var6 = alloca i64, align 8
+  %error_var12 = alloca i64, align 8
+  %len19 = alloca i64, align 8
+  %error_var20 = alloca i64, align 8
+  %retparam22 = alloca i64, align 8
+  %error_var28 = alloca i64, align 8
+  %error_var34 = alloca i64, align 8
+  %error_var42 = alloca i64, align 8
+  %blockret43 = alloca i32, align 4
+  %len49 = alloca i64, align 8
+  %error_var50 = alloca i64, align 8
+  %retparam52 = alloca i64, align 8
+  %error_var58 = alloca i64, align 8
+  %error_var64 = alloca i64, align 8
+  %len74 = alloca i64, align 8
+  %error_var75 = alloca i64, align 8
+  %retparam77 = alloca i64, align 8
+  %error_var83 = alloca i64, align 8
+  %error_var89 = alloca i64, align 8
   store i32 %0, ptr %taddr, align 4
   %1 = insertvalue %any undef, ptr %taddr, 0
   %2 = insertvalue %any %1, i64 ptrtoint (ptr @"$ct.int" to i64), 1
@@ -78,26 +94,247 @@ or.phi:                                           ; preds = %entry
 
 if.then:                                          ; preds = %or.phi
   %6 = call ptr @std.io.stdout()
-  %7 = call i64 @std.io.File.printn(ptr %retparam1, ptr %6, ptr @.str.2, i64 3)
+  %7 = call i64 @std.io.File.write(ptr %retparam4, ptr %6, ptr @.str.2, i64 3)
+  %not_err = icmp eq i64 %7, 0
+  %8 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
+  br i1 %8, label %after_check, label %assign_optional
+
+assign_optional:                                  ; preds = %if.then
+  store i64 %7, ptr %error_var2, align 8
+  br label %guard_block5
+
+after_check:                                      ; preds = %if.then
+  br label %noerr_block
+
+guard_block5:                                     ; preds = %assign_optional
+  br label %voiderr
+
+noerr_block:                                      ; preds = %after_check
+  %9 = load i64, ptr %retparam4, align 8
+  store i64 %9, ptr %len, align 8
+  %10 = call i64 @std.io.File.write_byte(ptr %6, i8 zeroext 10)
+  %not_err7 = icmp eq i64 %10, 0
+  %11 = call i1 @llvm.expect.i1(i1 %not_err7, i1 true)
+  br i1 %11, label %after_check9, label %assign_optional8
+
+assign_optional8:                                 ; preds = %noerr_block
+  store i64 %10, ptr %error_var6, align 8
+  br label %guard_block10
+
+after_check9:                                     ; preds = %noerr_block
+  br label %noerr_block11
+
+guard_block10:                                    ; preds = %assign_optional8
+  br label %voiderr
+
+noerr_block11:                                    ; preds = %after_check9
+  %12 = call i64 @std.io.File.flush(ptr %6)
+  %not_err13 = icmp eq i64 %12, 0
+  %13 = call i1 @llvm.expect.i1(i1 %not_err13, i1 true)
+  br i1 %13, label %after_check15, label %assign_optional14
+
+assign_optional14:                                ; preds = %noerr_block11
+  store i64 %12, ptr %error_var12, align 8
+  br label %guard_block16
+
+after_check15:                                    ; preds = %noerr_block11
+  br label %noerr_block17
+
+guard_block16:                                    ; preds = %assign_optional14
+  br label %voiderr
+
+noerr_block17:                                    ; preds = %after_check15
+  %14 = load i64, ptr %len, align 8
+  %add = add i64 %14, 1
+  br label %voiderr
+
+voiderr:                                          ; preds = %noerr_block17, %guard_block16, %guard_block10, %guard_block5
   br label %if.exit
 
-if.exit:                                          ; preds = %if.then
-  %8 = call ptr @std.io.stdout()
-  %9 = call i64 @std.io.File.printn(ptr %retparam2, ptr %8, ptr @.str.3, i64 9)
-  store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var3, align 8
-  br label %opt_block_cleanup5
+if.exit:                                          ; preds = %voiderr
+  %15 = call ptr @std.io.stdout()
+  %16 = call i64 @std.io.File.write(ptr %retparam22, ptr %15, ptr @.str.3, i64 9)
+  %not_err23 = icmp eq i64 %16, 0
+  %17 = call i1 @llvm.expect.i1(i1 %not_err23, i1 true)
+  br i1 %17, label %after_check25, label %assign_optional24
 
-opt_block_cleanup5:                               ; preds = %if.exit
+assign_optional24:                                ; preds = %if.exit
+  store i64 %16, ptr %error_var20, align 8
+  br label %guard_block26
+
+after_check25:                                    ; preds = %if.exit
+  br label %noerr_block27
+
+guard_block26:                                    ; preds = %assign_optional24
+  br label %voiderr41
+
+noerr_block27:                                    ; preds = %after_check25
+  %18 = load i64, ptr %retparam22, align 8
+  store i64 %18, ptr %len19, align 8
+  %19 = call i64 @std.io.File.write_byte(ptr %15, i8 zeroext 10)
+  %not_err29 = icmp eq i64 %19, 0
+  %20 = call i1 @llvm.expect.i1(i1 %not_err29, i1 true)
+  br i1 %20, label %after_check31, label %assign_optional30
+
+assign_optional30:                                ; preds = %noerr_block27
+  store i64 %19, ptr %error_var28, align 8
+  br label %guard_block32
+
+after_check31:                                    ; preds = %noerr_block27
+  br label %noerr_block33
+
+guard_block32:                                    ; preds = %assign_optional30
+  br label %voiderr41
+
+noerr_block33:                                    ; preds = %after_check31
+  %21 = call i64 @std.io.File.flush(ptr %15)
+  %not_err35 = icmp eq i64 %21, 0
+  %22 = call i1 @llvm.expect.i1(i1 %not_err35, i1 true)
+  br i1 %22, label %after_check37, label %assign_optional36
+
+assign_optional36:                                ; preds = %noerr_block33
+  store i64 %21, ptr %error_var34, align 8
+  br label %guard_block38
+
+after_check37:                                    ; preds = %noerr_block33
+  br label %noerr_block39
+
+guard_block38:                                    ; preds = %assign_optional36
+  br label %voiderr41
+
+noerr_block39:                                    ; preds = %after_check37
+  %23 = load i64, ptr %len19, align 8
+  %add40 = add i64 %23, 1
+  br label %voiderr41
+
+voiderr41:                                        ; preds = %noerr_block39, %guard_block38, %guard_block32, %guard_block26
+  store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var42, align 8
+  br label %opt_block_cleanup44
+
+opt_block_cleanup44:                              ; preds = %voiderr41
   call void @foo.blurb()
-  br label %guard_block6
+  br label %guard_block45
 
-guard_block6:                                     ; preds = %opt_block_cleanup5
-  %10 = load i64, ptr %error_var3, align 8
-  ret i64 %10
+guard_block45:                                    ; preds = %opt_block_cleanup44
+  %24 = load i64, ptr %error_var42, align 8
+  ret i64 %24
 
-if.exit9:                                         ; No predecessors!
-  %11 = call ptr @std.io.stdout()
-  %12 = call i64 @std.io.File.printn(ptr %retparam10, ptr %11, ptr @.str.5, i64 7)
+if.then47:                                        ; No predecessors!
+  %25 = call ptr @std.io.stdout()
+  %26 = call i64 @std.io.File.write(ptr %retparam52, ptr %25, ptr @.str.4, i64 3)
+  %not_err53 = icmp eq i64 %26, 0
+  %27 = call i1 @llvm.expect.i1(i1 %not_err53, i1 true)
+  br i1 %27, label %after_check55, label %assign_optional54
+
+assign_optional54:                                ; preds = %if.then47
+  store i64 %26, ptr %error_var50, align 8
+  br label %guard_block56
+
+after_check55:                                    ; preds = %if.then47
+  br label %noerr_block57
+
+guard_block56:                                    ; preds = %assign_optional54
+  br label %voiderr71
+
+noerr_block57:                                    ; preds = %after_check55
+  %28 = load i64, ptr %retparam52, align 8
+  store i64 %28, ptr %len49, align 8
+  %29 = call i64 @std.io.File.write_byte(ptr %25, i8 zeroext 10)
+  %not_err59 = icmp eq i64 %29, 0
+  %30 = call i1 @llvm.expect.i1(i1 %not_err59, i1 true)
+  br i1 %30, label %after_check61, label %assign_optional60
+
+assign_optional60:                                ; preds = %noerr_block57
+  store i64 %29, ptr %error_var58, align 8
+  br label %guard_block62
+
+after_check61:                                    ; preds = %noerr_block57
+  br label %noerr_block63
+
+guard_block62:                                    ; preds = %assign_optional60
+  br label %voiderr71
+
+noerr_block63:                                    ; preds = %after_check61
+  %31 = call i64 @std.io.File.flush(ptr %25)
+  %not_err65 = icmp eq i64 %31, 0
+  %32 = call i1 @llvm.expect.i1(i1 %not_err65, i1 true)
+  br i1 %32, label %after_check67, label %assign_optional66
+
+assign_optional66:                                ; preds = %noerr_block63
+  store i64 %31, ptr %error_var64, align 8
+  br label %guard_block68
+
+after_check67:                                    ; preds = %noerr_block63
+  br label %noerr_block69
+
+guard_block68:                                    ; preds = %assign_optional66
+  br label %voiderr71
+
+noerr_block69:                                    ; preds = %after_check67
+  %33 = load i64, ptr %len49, align 8
+  %add70 = add i64 %33, 1
+  br label %voiderr71
+
+voiderr71:                                        ; preds = %noerr_block69, %guard_block68, %guard_block62, %guard_block56
+  br label %if.exit72
+
+if.exit72:                                        ; preds = %voiderr71
+  %34 = call ptr @std.io.stdout()
+  %35 = call i64 @std.io.File.write(ptr %retparam77, ptr %34, ptr @.str.5, i64 7)
+  %not_err78 = icmp eq i64 %35, 0
+  %36 = call i1 @llvm.expect.i1(i1 %not_err78, i1 true)
+  br i1 %36, label %after_check80, label %assign_optional79
+
+assign_optional79:                                ; preds = %if.exit72
+  store i64 %35, ptr %error_var75, align 8
+  br label %guard_block81
+
+after_check80:                                    ; preds = %if.exit72
+  br label %noerr_block82
+
+guard_block81:                                    ; preds = %assign_optional79
+  br label %voiderr96
+
+noerr_block82:                                    ; preds = %after_check80
+  %37 = load i64, ptr %retparam77, align 8
+  store i64 %37, ptr %len74, align 8
+  %38 = call i64 @std.io.File.write_byte(ptr %34, i8 zeroext 10)
+  %not_err84 = icmp eq i64 %38, 0
+  %39 = call i1 @llvm.expect.i1(i1 %not_err84, i1 true)
+  br i1 %39, label %after_check86, label %assign_optional85
+
+assign_optional85:                                ; preds = %noerr_block82
+  store i64 %38, ptr %error_var83, align 8
+  br label %guard_block87
+
+after_check86:                                    ; preds = %noerr_block82
+  br label %noerr_block88
+
+guard_block87:                                    ; preds = %assign_optional85
+  br label %voiderr96
+
+noerr_block88:                                    ; preds = %after_check86
+  %40 = call i64 @std.io.File.flush(ptr %34)
+  %not_err90 = icmp eq i64 %40, 0
+  %41 = call i1 @llvm.expect.i1(i1 %not_err90, i1 true)
+  br i1 %41, label %after_check92, label %assign_optional91
+
+assign_optional91:                                ; preds = %noerr_block88
+  store i64 %40, ptr %error_var89, align 8
+  br label %guard_block93
+
+after_check92:                                    ; preds = %noerr_block88
+  br label %noerr_block94
+
+guard_block93:                                    ; preds = %assign_optional91
+  br label %voiderr96
+
+noerr_block94:                                    ; preds = %after_check92
+  %42 = load i64, ptr %len74, align 8
+  %add95 = add i64 %42, 1
+  br label %voiderr96
+
+voiderr96:                                        ; preds = %noerr_block94, %guard_block93, %guard_block87, %guard_block81
   ret i64 0
 }
 
@@ -109,10 +346,18 @@ entry:
   %taddr = alloca i32, align 4
   %error_var = alloca i64, align 8
   %blockret = alloca i32, align 4
-  %retparam1 = alloca i64, align 8
+  %len = alloca i64, align 8
   %error_var2 = alloca i64, align 8
-  %blockret3 = alloca i32, align 4
-  %retparam7 = alloca i64, align 8
+  %retparam4 = alloca i64, align 8
+  %error_var6 = alloca i64, align 8
+  %error_var12 = alloca i64, align 8
+  %error_var18 = alloca i64, align 8
+  %blockret19 = alloca i32, align 4
+  %len25 = alloca i64, align 8
+  %error_var26 = alloca i64, align 8
+  %retparam28 = alloca i64, align 8
+  %error_var34 = alloca i64, align 8
+  %error_var40 = alloca i64, align 8
   store i32 %0, ptr %taddr, align 4
   %1 = insertvalue %any undef, ptr %taddr, 0
   %2 = insertvalue %any %1, i64 ptrtoint (ptr @"$ct.int" to i64), 1
@@ -139,21 +384,129 @@ and.phi:                                          ; preds = %entry
 
 if.exit:                                          ; preds = %and.phi
   %6 = call ptr @std.io.stdout()
-  %7 = call i64 @std.io.File.printn(ptr %retparam1, ptr %6, ptr @.str.7, i64 9)
-  store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var2, align 8
-  br label %opt_block_cleanup4
+  %7 = call i64 @std.io.File.write(ptr %retparam4, ptr %6, ptr @.str.7, i64 9)
+  %not_err = icmp eq i64 %7, 0
+  %8 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
+  br i1 %8, label %after_check, label %assign_optional
 
-opt_block_cleanup4:                               ; preds = %if.exit
-  call void @foo.blurb()
+assign_optional:                                  ; preds = %if.exit
+  store i64 %7, ptr %error_var2, align 8
   br label %guard_block5
 
-guard_block5:                                     ; preds = %opt_block_cleanup4
-  %8 = load i64, ptr %error_var2, align 8
-  ret i64 %8
+after_check:                                      ; preds = %if.exit
+  br label %noerr_block
 
-if.exit6:                                         ; No predecessors!
-  %9 = call ptr @std.io.stdout()
-  %10 = call i64 @std.io.File.printn(ptr %retparam7, ptr %9, ptr @.str.8, i64 7)
+guard_block5:                                     ; preds = %assign_optional
+  br label %voiderr
+
+noerr_block:                                      ; preds = %after_check
+  %9 = load i64, ptr %retparam4, align 8
+  store i64 %9, ptr %len, align 8
+  %10 = call i64 @std.io.File.write_byte(ptr %6, i8 zeroext 10)
+  %not_err7 = icmp eq i64 %10, 0
+  %11 = call i1 @llvm.expect.i1(i1 %not_err7, i1 true)
+  br i1 %11, label %after_check9, label %assign_optional8
+
+assign_optional8:                                 ; preds = %noerr_block
+  store i64 %10, ptr %error_var6, align 8
+  br label %guard_block10
+
+after_check9:                                     ; preds = %noerr_block
+  br label %noerr_block11
+
+guard_block10:                                    ; preds = %assign_optional8
+  br label %voiderr
+
+noerr_block11:                                    ; preds = %after_check9
+  %12 = call i64 @std.io.File.flush(ptr %6)
+  %not_err13 = icmp eq i64 %12, 0
+  %13 = call i1 @llvm.expect.i1(i1 %not_err13, i1 true)
+  br i1 %13, label %after_check15, label %assign_optional14
+
+assign_optional14:                                ; preds = %noerr_block11
+  store i64 %12, ptr %error_var12, align 8
+  br label %guard_block16
+
+after_check15:                                    ; preds = %noerr_block11
+  br label %noerr_block17
+
+guard_block16:                                    ; preds = %assign_optional14
+  br label %voiderr
+
+noerr_block17:                                    ; preds = %after_check15
+  %14 = load i64, ptr %len, align 8
+  %add = add i64 %14, 1
+  br label %voiderr
+
+voiderr:                                          ; preds = %noerr_block17, %guard_block16, %guard_block10, %guard_block5
+  store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var18, align 8
+  br label %opt_block_cleanup20
+
+opt_block_cleanup20:                              ; preds = %voiderr
+  call void @foo.blurb()
+  br label %guard_block21
+
+guard_block21:                                    ; preds = %opt_block_cleanup20
+  %15 = load i64, ptr %error_var18, align 8
+  ret i64 %15
+
+if.exit23:                                        ; No predecessors!
+  %16 = call ptr @std.io.stdout()
+  %17 = call i64 @std.io.File.write(ptr %retparam28, ptr %16, ptr @.str.8, i64 7)
+  %not_err29 = icmp eq i64 %17, 0
+  %18 = call i1 @llvm.expect.i1(i1 %not_err29, i1 true)
+  br i1 %18, label %after_check31, label %assign_optional30
+
+assign_optional30:                                ; preds = %if.exit23
+  store i64 %17, ptr %error_var26, align 8
+  br label %guard_block32
+
+after_check31:                                    ; preds = %if.exit23
+  br label %noerr_block33
+
+guard_block32:                                    ; preds = %assign_optional30
+  br label %voiderr47
+
+noerr_block33:                                    ; preds = %after_check31
+  %19 = load i64, ptr %retparam28, align 8
+  store i64 %19, ptr %len25, align 8
+  %20 = call i64 @std.io.File.write_byte(ptr %16, i8 zeroext 10)
+  %not_err35 = icmp eq i64 %20, 0
+  %21 = call i1 @llvm.expect.i1(i1 %not_err35, i1 true)
+  br i1 %21, label %after_check37, label %assign_optional36
+
+assign_optional36:                                ; preds = %noerr_block33
+  store i64 %20, ptr %error_var34, align 8
+  br label %guard_block38
+
+after_check37:                                    ; preds = %noerr_block33
+  br label %noerr_block39
+
+guard_block38:                                    ; preds = %assign_optional36
+  br label %voiderr47
+
+noerr_block39:                                    ; preds = %after_check37
+  %22 = call i64 @std.io.File.flush(ptr %16)
+  %not_err41 = icmp eq i64 %22, 0
+  %23 = call i1 @llvm.expect.i1(i1 %not_err41, i1 true)
+  br i1 %23, label %after_check43, label %assign_optional42
+
+assign_optional42:                                ; preds = %noerr_block39
+  store i64 %22, ptr %error_var40, align 8
+  br label %guard_block44
+
+after_check43:                                    ; preds = %noerr_block39
+  br label %noerr_block45
+
+guard_block44:                                    ; preds = %assign_optional42
+  br label %voiderr47
+
+noerr_block45:                                    ; preds = %after_check43
+  %24 = load i64, ptr %len25, align 8
+  %add46 = add i64 %24, 1
+  br label %voiderr47
+
+voiderr47:                                        ; preds = %noerr_block45, %guard_block44, %guard_block38, %guard_block32
   ret i64 0
 }
 
diff --git a/test/test_suite/from_docs/examples_defer.c3t b/test/test_suite/from_docs/examples_defer.c3t
index 24b2c27a4..5c442e8bf 100644
--- a/test/test_suite/from_docs/examples_defer.c3t
+++ b/test/test_suite/from_docs/examples_defer.c3t
@@ -25,36 +25,224 @@ fn void main()
 
 define void @defer1.test(i32 %0) #0 {
 entry:
+  %retparam = alloca i64, align 8
+  %len = alloca i64, align 8
+  %error_var = alloca i64, align 8
+  %retparam2 = alloca i64, align 8
+  %error_var3 = alloca i64, align 8
+  %error_var9 = alloca i64, align 8
+  %retparam17 = alloca i64, align 8
+  %retparam20 = alloca i64, align 8
+  %len23 = alloca i64, align 8
+  %error_var24 = alloca i64, align 8
+  %retparam26 = alloca i64, align 8
+  %error_var32 = alloca i64, align 8
+  %error_var38 = alloca i64, align 8
+  %retparam47 = alloca i64, align 8
+  %retparam50 = alloca i64, align 8
+  %retparam53 = alloca i64, align 8
+  %len56 = alloca i64, align 8
+  %error_var57 = alloca i64, align 8
+  %retparam59 = alloca i64, align 8
+  %error_var65 = alloca i64, align 8
+  %error_var71 = alloca i64, align 8
   %eq = icmp eq i32 %0, 1
   br i1 %eq, label %if.then, label %if.exit
+
 if.then:                                          ; preds = %entry
   %1 = call ptr @std.io.stdout()
-  %2 = call i64 @std.io.File.print(ptr %retparam, ptr %1, ptr @.str, i64 1)
+  %2 = call i64 @std.io.File.write(ptr %retparam, ptr %1, ptr @.str, i64 1)
   %3 = call ptr @std.io.stdout()
-  %4 = call i64 @std.io.File.printn(ptr %retparam1, ptr %3, ptr null, i64 0)
+  %4 = call i64 @std.io.File.write(ptr %retparam2, ptr %3, ptr null, i64 0)
+  %not_err = icmp eq i64 %4, 0
+  %5 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
+  br i1 %5, label %after_check, label %assign_optional
+
+assign_optional:                                  ; preds = %if.then
+  store i64 %4, ptr %error_var, align 8
+  br label %guard_block
+
+after_check:                                      ; preds = %if.then
+  br label %noerr_block
+
+guard_block:                                      ; preds = %assign_optional
+  br label %voiderr
+
+noerr_block:                                      ; preds = %after_check
+  %6 = load i64, ptr %retparam2, align 8
+  store i64 %6, ptr %len, align 8
+  %7 = call i64 @std.io.File.write_byte(ptr %3, i8 zeroext 10)
+  %not_err4 = icmp eq i64 %7, 0
+  %8 = call i1 @llvm.expect.i1(i1 %not_err4, i1 true)
+  br i1 %8, label %after_check6, label %assign_optional5
+
+assign_optional5:                                 ; preds = %noerr_block
+  store i64 %7, ptr %error_var3, align 8
+  br label %guard_block7
+
+after_check6:                                     ; preds = %noerr_block
+  br label %noerr_block8
+
+guard_block7:                                     ; preds = %assign_optional5
+  br label %voiderr
+
+noerr_block8:                                     ; preds = %after_check6
+  %9 = call i64 @std.io.File.flush(ptr %3)
+  %not_err10 = icmp eq i64 %9, 0
+  %10 = call i1 @llvm.expect.i1(i1 %not_err10, i1 true)
+  br i1 %10, label %after_check12, label %assign_optional11
+
+assign_optional11:                                ; preds = %noerr_block8
+  store i64 %9, ptr %error_var9, align 8
+  br label %guard_block13
+
+after_check12:                                    ; preds = %noerr_block8
+  br label %noerr_block14
+
+guard_block13:                                    ; preds = %assign_optional11
+  br label %voiderr
+
+noerr_block14:                                    ; preds = %after_check12
+  %11 = load i64, ptr %len, align 8
+  %add = add i64 %11, 1
+  br label %voiderr
+
+voiderr:                                          ; preds = %noerr_block14, %guard_block13, %guard_block7, %guard_block
   ret void
+
 if.exit:                                          ; preds = %entry
-  %eq2 = icmp eq i32 %0, 0
-  br i1 %eq2, label %if.then3, label %if.exit7
-if.then3:                                         ; preds = %if.exit
-  %5 = call ptr @std.io.stdout()
-  %6 = call i64 @std.io.File.print(ptr %retparam4, ptr %5, ptr @.str.1, i64 1)
-  %7 = call ptr @std.io.stdout()
-  %8 = call i64 @std.io.File.print(ptr %retparam5, ptr %7, ptr @.str.2, i64 1)
-  %9 = call ptr @std.io.stdout()
-  %10 = call i64 @std.io.File.printn(ptr %retparam6, ptr %9, ptr null, i64 0)
+  %eq15 = icmp eq i32 %0, 0
+  br i1 %eq15, label %if.then16, label %if.exit46
+
+if.then16:                                        ; preds = %if.exit
+  %12 = call ptr @std.io.stdout()
+  %13 = call i64 @std.io.File.write(ptr %retparam17, ptr %12, ptr @.str.1, i64 1)
+  %14 = call ptr @std.io.stdout()
+  %15 = call i64 @std.io.File.write(ptr %retparam20, ptr %14, ptr @.str.2, i64 1)
+  %16 = call ptr @std.io.stdout()
+  %17 = call i64 @std.io.File.write(ptr %retparam26, ptr %16, ptr null, i64 0)
+  %not_err27 = icmp eq i64 %17, 0
+  %18 = call i1 @llvm.expect.i1(i1 %not_err27, i1 true)
+  br i1 %18, label %after_check29, label %assign_optional28
+
+assign_optional28:                                ; preds = %if.then16
+  store i64 %17, ptr %error_var24, align 8
+  br label %guard_block30
+
+after_check29:                                    ; preds = %if.then16
+  br label %noerr_block31
+
+guard_block30:                                    ; preds = %assign_optional28
+  br label %voiderr45
+
+noerr_block31:                                    ; preds = %after_check29
+  %19 = load i64, ptr %retparam26, align 8
+  store i64 %19, ptr %len23, align 8
+  %20 = call i64 @std.io.File.write_byte(ptr %16, i8 zeroext 10)
+  %not_err33 = icmp eq i64 %20, 0
+  %21 = call i1 @llvm.expect.i1(i1 %not_err33, i1 true)
+  br i1 %21, label %after_check35, label %assign_optional34
+
+assign_optional34:                                ; preds = %noerr_block31
+  store i64 %20, ptr %error_var32, align 8
+  br label %guard_block36
+
+after_check35:                                    ; preds = %noerr_block31
+  br label %noerr_block37
+
+guard_block36:                                    ; preds = %assign_optional34
+  br label %voiderr45
+
+noerr_block37:                                    ; preds = %after_check35
+  %22 = call i64 @std.io.File.flush(ptr %16)
+  %not_err39 = icmp eq i64 %22, 0
+  %23 = call i1 @llvm.expect.i1(i1 %not_err39, i1 true)
+  br i1 %23, label %after_check41, label %assign_optional40
+
+assign_optional40:                                ; preds = %noerr_block37
+  store i64 %22, ptr %error_var38, align 8
+  br label %guard_block42
+
+after_check41:                                    ; preds = %noerr_block37
+  br label %noerr_block43
+
+guard_block42:                                    ; preds = %assign_optional40
+  br label %voiderr45
+
+noerr_block43:                                    ; preds = %after_check41
+  %24 = load i64, ptr %len23, align 8
+  %add44 = add i64 %24, 1
+  br label %voiderr45
+
+voiderr45:                                        ; preds = %noerr_block43, %guard_block42, %guard_block36, %guard_block30
   ret void
-if.exit7:                                         ; preds = %if.exit
-  %11 = call ptr @std.io.stdout()
-  %12 = call i64 @std.io.File.print(ptr %retparam8, ptr %11, ptr @.str.3, i64 1)
-  %13 = call ptr @std.io.stdout()
-  %14 = call i64 @std.io.File.print(ptr %retparam9, ptr %13, ptr @.str.4, i64 1)
-  %15 = call ptr @std.io.stdout()
-  %16 = call i64 @std.io.File.print(ptr %retparam10, ptr %15, ptr @.str.5, i64 1)
-  %17 = call ptr @std.io.stdout()
-  %18 = call i64 @std.io.File.printn(ptr %retparam11, ptr %17, ptr null, i64 0)
+
+if.exit46:                                        ; preds = %if.exit
+  %25 = call ptr @std.io.stdout()
+  %26 = call i64 @std.io.File.write(ptr %retparam47, ptr %25, ptr @.str.3, i64 1)
+  %27 = call ptr @std.io.stdout()
+  %28 = call i64 @std.io.File.write(ptr %retparam50, ptr %27, ptr @.str.4, i64 1)
+  %29 = call ptr @std.io.stdout()
+  %30 = call i64 @std.io.File.write(ptr %retparam53, ptr %29, ptr @.str.5, i64 1)
+  %31 = call ptr @std.io.stdout()
+  %32 = call i64 @std.io.File.write(ptr %retparam59, ptr %31, ptr null, i64 0)
+  %not_err60 = icmp eq i64 %32, 0
+  %33 = call i1 @llvm.expect.i1(i1 %not_err60, i1 true)
+  br i1 %33, label %after_check62, label %assign_optional61
+
+assign_optional61:                                ; preds = %if.exit46
+  store i64 %32, ptr %error_var57, align 8
+  br label %guard_block63
+
+after_check62:                                    ; preds = %if.exit46
+  br label %noerr_block64
+
+guard_block63:                                    ; preds = %assign_optional61
+  br label %voiderr78
+
+noerr_block64:                                    ; preds = %after_check62
+  %34 = load i64, ptr %retparam59, align 8
+  store i64 %34, ptr %len56, align 8
+  %35 = call i64 @std.io.File.write_byte(ptr %31, i8 zeroext 10)
+  %not_err66 = icmp eq i64 %35, 0
+  %36 = call i1 @llvm.expect.i1(i1 %not_err66, i1 true)
+  br i1 %36, label %after_check68, label %assign_optional67
+
+assign_optional67:                                ; preds = %noerr_block64
+  store i64 %35, ptr %error_var65, align 8
+  br label %guard_block69
+
+after_check68:                                    ; preds = %noerr_block64
+  br label %noerr_block70
+
+guard_block69:                                    ; preds = %assign_optional67
+  br label %voiderr78
+
+noerr_block70:                                    ; preds = %after_check68
+  %37 = call i64 @std.io.File.flush(ptr %31)
+  %not_err72 = icmp eq i64 %37, 0
+  %38 = call i1 @llvm.expect.i1(i1 %not_err72, i1 true)
+  br i1 %38, label %after_check74, label %assign_optional73
+
+assign_optional73:                                ; preds = %noerr_block70
+  store i64 %37, ptr %error_var71, align 8
+  br label %guard_block75
+
+after_check74:                                    ; preds = %noerr_block70
+  br label %noerr_block76
+
+guard_block75:                                    ; preds = %assign_optional73
+  br label %voiderr78
+
+noerr_block76:                                    ; preds = %after_check74
+  %39 = load i64, ptr %len56, align 8
+  %add77 = add i64 %39, 1
+  br label %voiderr78
+
+voiderr78:                                        ; preds = %noerr_block76, %guard_block75, %guard_block69, %guard_block63
   ret void
 }
+
 ; Function Attrs: nounwind
 define void @defer1.main() #0 {
 entry:
diff --git a/test/test_suite/from_docs/examples_forswitch.c3t b/test/test_suite/from_docs/examples_forswitch.c3t
index bdc1ab8cc..ffc57631f 100644
--- a/test/test_suite/from_docs/examples_forswitch.c3t
+++ b/test/test_suite/from_docs/examples_forswitch.c3t
@@ -94,10 +94,12 @@ entry:
   %i = alloca i32, align 4
   store i32 0, ptr %i, align 4
   br label %loop.cond
+
 loop.cond:                                        ; preds = %loop.body, %entry
   %0 = load i32, ptr %i, align 4
   %lt = icmp slt i32 %0, 10
   br i1 %lt, label %loop.body, label %loop.exit
+
 loop.body:                                        ; preds = %loop.cond
   %1 = load i32, ptr %i, align 4
   %2 = call i32 (ptr, ...) @printf(ptr @.str, i32 %1)
@@ -105,120 +107,608 @@ loop.body:                                        ; preds = %loop.cond
   %add = add i32 %3, 1
   store i32 %add, ptr %i, align 4
   br label %loop.cond
+
 loop.exit:                                        ; preds = %loop.cond
   %4 = load ptr, ptr @std.core.builtin.panic, align 8
   call void %4(ptr @.panic_msg, i64 19, ptr @.file, i64 21, ptr @.func, i64 11, i32 14)
   unreachable
 }
+
 ; Function Attrs: nounwind
 define void @examples.demo_enum(i32 %0) #0 {
 entry:
   %switch = alloca i32, align 4
+  %len = alloca i64, align 8
+  %error_var = alloca i64, align 8
   %retparam = alloca i64, align 8
-  %retparam2 = alloca i64, align 8
-  %switch3 = alloca i32, align 4
-  %retparam6 = alloca i64, align 8
-  %retparam8 = alloca i64, align 8
-  %switch10 = alloca i32, align 4
-  %retparam14 = alloca i64, align 8
-  %switch17 = alloca i32, align 4
-  %switch21 = alloca i32, align 4
+  %error_var2 = alloca i64, align 8
+  %error_var8 = alloca i64, align 8
+  %len15 = alloca i64, align 8
+  %error_var16 = alloca i64, align 8
+  %retparam18 = alloca i64, align 8
+  %error_var24 = alloca i64, align 8
+  %error_var30 = alloca i64, align 8
+  %switch38 = alloca i32, align 4
+  %len41 = alloca i64, align 8
+  %error_var42 = alloca i64, align 8
+  %retparam44 = alloca i64, align 8
+  %error_var50 = alloca i64, align 8
+  %error_var56 = alloca i64, align 8
+  %len65 = alloca i64, align 8
+  %error_var66 = alloca i64, align 8
+  %retparam68 = alloca i64, align 8
+  %error_var74 = alloca i64, align 8
+  %error_var80 = alloca i64, align 8
+  %switch89 = alloca i32, align 4
+  %len93 = alloca i64, align 8
+  %error_var94 = alloca i64, align 8
+  %retparam96 = alloca i64, align 8
+  %error_var102 = alloca i64, align 8
+  %error_var108 = alloca i64, align 8
+  %switch118 = alloca i32, align 4
+  %switch122 = alloca i32, align 4
   %a = alloca i32, align 4
-  %retparam24 = alloca i64, align 8
-  %a26 = alloca i32, align 4
-  %retparam27 = alloca i64, align 8
-  %retparam29 = alloca i64, align 8
+  %len125 = alloca i64, align 8
+  %error_var126 = alloca i64, align 8
+  %retparam128 = alloca i64, align 8
+  %error_var134 = alloca i64, align 8
+  %error_var140 = alloca i64, align 8
+  %a149 = alloca i32, align 4
+  %len150 = alloca i64, align 8
+  %error_var151 = alloca i64, align 8
+  %retparam153 = alloca i64, align 8
+  %error_var159 = alloca i64, align 8
+  %error_var165 = alloca i64, align 8
+  %len174 = alloca i64, align 8
+  %error_var175 = alloca i64, align 8
+  %retparam177 = alloca i64, align 8
+  %error_var183 = alloca i64, align 8
+  %error_var189 = alloca i64, align 8
   store i32 %0, ptr %switch, align 4
   br label %switch.entry
+
 switch.entry:                                     ; preds = %entry
   %1 = load i32, ptr %switch, align 4
   switch i32 %1, label %switch.exit [
     i32 0, label %switch.case
     i32 1, label %switch.case
-    i32 2, label %switch.case1
+    i32 2, label %switch.case14
   ]
+
 switch.case:                                      ; preds = %switch.entry, %switch.entry
   %2 = call ptr @std.io.stdout()
-  %3 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr @.str.1, i64 8)
+  %3 = call i64 @std.io.File.write(ptr %retparam, ptr %2, ptr @.str.1, i64 8)
+  %not_err = icmp eq i64 %3, 0
+  %4 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
+  br i1 %4, label %after_check, label %assign_optional
+
+assign_optional:                                  ; preds = %switch.case
+  store i64 %3, ptr %error_var, align 8
+  br label %guard_block
+
+after_check:                                      ; preds = %switch.case
+  br label %noerr_block
+
+guard_block:                                      ; preds = %assign_optional
+  br label %voiderr
+
+noerr_block:                                      ; preds = %after_check
+  %5 = load i64, ptr %retparam, align 8
+  store i64 %5, ptr %len, align 8
+  %6 = call i64 @std.io.File.write_byte(ptr %2, i8 zeroext 10)
+  %not_err3 = icmp eq i64 %6, 0
+  %7 = call i1 @llvm.expect.i1(i1 %not_err3, i1 true)
+  br i1 %7, label %after_check5, label %assign_optional4
+
+assign_optional4:                                 ; preds = %noerr_block
+  store i64 %6, ptr %error_var2, align 8
+  br label %guard_block6
+
+after_check5:                                     ; preds = %noerr_block
+  br label %noerr_block7
+
+guard_block6:                                     ; preds = %assign_optional4
+  br label %voiderr
+
+noerr_block7:                                     ; preds = %after_check5
+  %8 = call i64 @std.io.File.flush(ptr %2)
+  %not_err9 = icmp eq i64 %8, 0
+  %9 = call i1 @llvm.expect.i1(i1 %not_err9, i1 true)
+  br i1 %9, label %after_check11, label %assign_optional10
+
+assign_optional10:                                ; preds = %noerr_block7
+  store i64 %8, ptr %error_var8, align 8
+  br label %guard_block12
+
+after_check11:                                    ; preds = %noerr_block7
+  br label %noerr_block13
+
+guard_block12:                                    ; preds = %assign_optional10
+  br label %voiderr
+
+noerr_block13:                                    ; preds = %after_check11
+  %10 = load i64, ptr %len, align 8
+  %add = add i64 %10, 1
+  br label %voiderr
+
+voiderr:                                          ; preds = %noerr_block13, %guard_block12, %guard_block6, %guard_block
   br label %switch.exit
-switch.case1:                                     ; preds = %switch.entry
-  %4 = call ptr @std.io.stdout()
-  %5 = call i64 @std.io.File.printn(ptr %retparam2, ptr %4, ptr @.str.2, i64 4)
+
+switch.case14:                                    ; preds = %switch.entry
+  %11 = call ptr @std.io.stdout()
+  %12 = call i64 @std.io.File.write(ptr %retparam18, ptr %11, ptr @.str.2, i64 4)
+  %not_err19 = icmp eq i64 %12, 0
+  %13 = call i1 @llvm.expect.i1(i1 %not_err19, i1 true)
+  br i1 %13, label %after_check21, label %assign_optional20
+
+assign_optional20:                                ; preds = %switch.case14
+  store i64 %12, ptr %error_var16, align 8
+  br label %guard_block22
+
+after_check21:                                    ; preds = %switch.case14
+  br label %noerr_block23
+
+guard_block22:                                    ; preds = %assign_optional20
+  br label %voiderr37
+
+noerr_block23:                                    ; preds = %after_check21
+  %14 = load i64, ptr %retparam18, align 8
+  store i64 %14, ptr %len15, align 8
+  %15 = call i64 @std.io.File.write_byte(ptr %11, i8 zeroext 10)
+  %not_err25 = icmp eq i64 %15, 0
+  %16 = call i1 @llvm.expect.i1(i1 %not_err25, i1 true)
+  br i1 %16, label %after_check27, label %assign_optional26
+
+assign_optional26:                                ; preds = %noerr_block23
+  store i64 %15, ptr %error_var24, align 8
+  br label %guard_block28
+
+after_check27:                                    ; preds = %noerr_block23
+  br label %noerr_block29
+
+guard_block28:                                    ; preds = %assign_optional26
+  br label %voiderr37
+
+noerr_block29:                                    ; preds = %after_check27
+  %17 = call i64 @std.io.File.flush(ptr %11)
+  %not_err31 = icmp eq i64 %17, 0
+  %18 = call i1 @llvm.expect.i1(i1 %not_err31, i1 true)
+  br i1 %18, label %after_check33, label %assign_optional32
+
+assign_optional32:                                ; preds = %noerr_block29
+  store i64 %17, ptr %error_var30, align 8
+  br label %guard_block34
+
+after_check33:                                    ; preds = %noerr_block29
+  br label %noerr_block35
+
+guard_block34:                                    ; preds = %assign_optional32
+  br label %voiderr37
+
+noerr_block35:                                    ; preds = %after_check33
+  %19 = load i64, ptr %len15, align 8
+  %add36 = add i64 %19, 1
+  br label %voiderr37
+
+voiderr37:                                        ; preds = %noerr_block35, %guard_block34, %guard_block28, %guard_block22
   br label %switch.exit
-switch.exit:                                      ; preds = %switch.case1, %switch.case, %switch.entry
-  store i32 %0, ptr %switch3, align 4
-  br label %switch.entry4
-switch.entry4:                                    ; preds = %switch.exit
-  %6 = load i32, ptr %switch3, align 4
-  switch i32 %6, label %switch.exit9 [
-    i32 0, label %switch.case5
-    i32 1, label %switch.case5
-    i32 2, label %switch.case7
+
+switch.exit:                                      ; preds = %voiderr37, %voiderr, %switch.entry
+  store i32 %0, ptr %switch38, align 4
+  br label %switch.entry39
+
+switch.entry39:                                   ; preds = %switch.exit
+  %20 = load i32, ptr %switch38, align 4
+  switch i32 %20, label %switch.exit88 [
+    i32 0, label %switch.case40
+    i32 1, label %switch.case40
+    i32 2, label %switch.case64
   ]
-switch.case5:                                     ; preds = %switch.entry4, %switch.entry4
-  %7 = call ptr @std.io.stdout()
-  %8 = call i64 @std.io.File.printn(ptr %retparam6, ptr %7, ptr @.str.3, i64 8)
-  br label %switch.exit9
-switch.case7:                                     ; preds = %switch.entry4
-  %9 = call ptr @std.io.stdout()
-  %10 = call i64 @std.io.File.printn(ptr %retparam8, ptr %9, ptr @.str.4, i64 4)
-  br label %switch.exit9
-switch.exit9:                                     ; preds = %switch.case7, %switch.case5, %switch.entry4
-  store i32 %0, ptr %switch10, align 4
-  br label %switch.entry11
-switch.entry11:                                   ; preds = %switch.exit9
-  %11 = load i32, ptr %switch10, align 4
-  switch i32 %11, label %switch.exit16 [
-    i32 0, label %switch.case12
-    i32 1, label %switch.case13
-    i32 2, label %switch.case15
+
+switch.case40:                                    ; preds = %switch.entry39, %switch.entry39
+  %21 = call ptr @std.io.stdout()
+  %22 = call i64 @std.io.File.write(ptr %retparam44, ptr %21, ptr @.str.3, i64 8)
+  %not_err45 = icmp eq i64 %22, 0
+  %23 = call i1 @llvm.expect.i1(i1 %not_err45, i1 true)
+  br i1 %23, label %after_check47, label %assign_optional46
+
+assign_optional46:                                ; preds = %switch.case40
+  store i64 %22, ptr %error_var42, align 8
+  br label %guard_block48
+
+after_check47:                                    ; preds = %switch.case40
+  br label %noerr_block49
+
+guard_block48:                                    ; preds = %assign_optional46
+  br label %voiderr63
+
+noerr_block49:                                    ; preds = %after_check47
+  %24 = load i64, ptr %retparam44, align 8
+  store i64 %24, ptr %len41, align 8
+  %25 = call i64 @std.io.File.write_byte(ptr %21, i8 zeroext 10)
+  %not_err51 = icmp eq i64 %25, 0
+  %26 = call i1 @llvm.expect.i1(i1 %not_err51, i1 true)
+  br i1 %26, label %after_check53, label %assign_optional52
+
+assign_optional52:                                ; preds = %noerr_block49
+  store i64 %25, ptr %error_var50, align 8
+  br label %guard_block54
+
+after_check53:                                    ; preds = %noerr_block49
+  br label %noerr_block55
+
+guard_block54:                                    ; preds = %assign_optional52
+  br label %voiderr63
+
+noerr_block55:                                    ; preds = %after_check53
+  %27 = call i64 @std.io.File.flush(ptr %21)
+  %not_err57 = icmp eq i64 %27, 0
+  %28 = call i1 @llvm.expect.i1(i1 %not_err57, i1 true)
+  br i1 %28, label %after_check59, label %assign_optional58
+
+assign_optional58:                                ; preds = %noerr_block55
+  store i64 %27, ptr %error_var56, align 8
+  br label %guard_block60
+
+after_check59:                                    ; preds = %noerr_block55
+  br label %noerr_block61
+
+guard_block60:                                    ; preds = %assign_optional58
+  br label %voiderr63
+
+noerr_block61:                                    ; preds = %after_check59
+  %29 = load i64, ptr %len41, align 8
+  %add62 = add i64 %29, 1
+  br label %voiderr63
+
+voiderr63:                                        ; preds = %noerr_block61, %guard_block60, %guard_block54, %guard_block48
+  br label %switch.exit88
+
+switch.case64:                                    ; preds = %switch.entry39
+  %30 = call ptr @std.io.stdout()
+  %31 = call i64 @std.io.File.write(ptr %retparam68, ptr %30, ptr @.str.4, i64 4)
+  %not_err69 = icmp eq i64 %31, 0
+  %32 = call i1 @llvm.expect.i1(i1 %not_err69, i1 true)
+  br i1 %32, label %after_check71, label %assign_optional70
+
+assign_optional70:                                ; preds = %switch.case64
+  store i64 %31, ptr %error_var66, align 8
+  br label %guard_block72
+
+after_check71:                                    ; preds = %switch.case64
+  br label %noerr_block73
+
+guard_block72:                                    ; preds = %assign_optional70
+  br label %voiderr87
+
+noerr_block73:                                    ; preds = %after_check71
+  %33 = load i64, ptr %retparam68, align 8
+  store i64 %33, ptr %len65, align 8
+  %34 = call i64 @std.io.File.write_byte(ptr %30, i8 zeroext 10)
+  %not_err75 = icmp eq i64 %34, 0
+  %35 = call i1 @llvm.expect.i1(i1 %not_err75, i1 true)
+  br i1 %35, label %after_check77, label %assign_optional76
+
+assign_optional76:                                ; preds = %noerr_block73
+  store i64 %34, ptr %error_var74, align 8
+  br label %guard_block78
+
+after_check77:                                    ; preds = %noerr_block73
+  br label %noerr_block79
+
+guard_block78:                                    ; preds = %assign_optional76
+  br label %voiderr87
+
+noerr_block79:                                    ; preds = %after_check77
+  %36 = call i64 @std.io.File.flush(ptr %30)
+  %not_err81 = icmp eq i64 %36, 0
+  %37 = call i1 @llvm.expect.i1(i1 %not_err81, i1 true)
+  br i1 %37, label %after_check83, label %assign_optional82
+
+assign_optional82:                                ; preds = %noerr_block79
+  store i64 %36, ptr %error_var80, align 8
+  br label %guard_block84
+
+after_check83:                                    ; preds = %noerr_block79
+  br label %noerr_block85
+
+guard_block84:                                    ; preds = %assign_optional82
+  br label %voiderr87
+
+noerr_block85:                                    ; preds = %after_check83
+  %38 = load i64, ptr %len65, align 8
+  %add86 = add i64 %38, 1
+  br label %voiderr87
+
+voiderr87:                                        ; preds = %noerr_block85, %guard_block84, %guard_block78, %guard_block72
+  br label %switch.exit88
+
+switch.exit88:                                    ; preds = %voiderr87, %voiderr63, %switch.entry39
+  store i32 %0, ptr %switch89, align 4
+  br label %switch.entry90
+
+switch.entry90:                                   ; preds = %switch.exit88
+  %39 = load i32, ptr %switch89, align 4
+  switch i32 %39, label %switch.exit117 [
+    i32 0, label %switch.case91
+    i32 1, label %switch.case92
+    i32 2, label %switch.case116
   ]
-switch.case12:                                    ; preds = %switch.entry11
-  br label %switch.exit16
-switch.case13:                                    ; preds = %switch.entry11
-  %12 = call ptr @std.io.stdout()
-  %13 = call i64 @std.io.File.printn(ptr %retparam14, ptr %12, ptr @.str.5, i64 6)
-  br label %switch.exit16
-switch.case15:                                    ; preds = %switch.entry11
-  br label %switch.exit16
-switch.exit16:                                    ; preds = %switch.case15, %switch.case13, %switch.case12, %switch.entry11
-  store i32 %0, ptr %switch17, align 4
-  br label %switch.entry18
-switch.entry18:                                   ; preds = %switch.exit16
-  %14 = load i32, ptr %switch17, align 4
-  switch i32 %14, label %switch.default [
-    i32 0, label %switch.case19
-    i32 1, label %switch.case19
-    i32 2, label %switch.case19
+
+switch.case91:                                    ; preds = %switch.entry90
+  br label %switch.exit117
+
+switch.case92:                                    ; preds = %switch.entry90
+  %40 = call ptr @std.io.stdout()
+  %41 = call i64 @std.io.File.write(ptr %retparam96, ptr %40, ptr @.str.5, i64 6)
+  %not_err97 = icmp eq i64 %41, 0
+  %42 = call i1 @llvm.expect.i1(i1 %not_err97, i1 true)
+  br i1 %42, label %after_check99, label %assign_optional98
+
+assign_optional98:                                ; preds = %switch.case92
+  store i64 %41, ptr %error_var94, align 8
+  br label %guard_block100
+
+after_check99:                                    ; preds = %switch.case92
+  br label %noerr_block101
+
+guard_block100:                                   ; preds = %assign_optional98
+  br label %voiderr115
+
+noerr_block101:                                   ; preds = %after_check99
+  %43 = load i64, ptr %retparam96, align 8
+  store i64 %43, ptr %len93, align 8
+  %44 = call i64 @std.io.File.write_byte(ptr %40, i8 zeroext 10)
+  %not_err103 = icmp eq i64 %44, 0
+  %45 = call i1 @llvm.expect.i1(i1 %not_err103, i1 true)
+  br i1 %45, label %after_check105, label %assign_optional104
+
+assign_optional104:                               ; preds = %noerr_block101
+  store i64 %44, ptr %error_var102, align 8
+  br label %guard_block106
+
+after_check105:                                   ; preds = %noerr_block101
+  br label %noerr_block107
+
+guard_block106:                                   ; preds = %assign_optional104
+  br label %voiderr115
+
+noerr_block107:                                   ; preds = %after_check105
+  %46 = call i64 @std.io.File.flush(ptr %40)
+  %not_err109 = icmp eq i64 %46, 0
+  %47 = call i1 @llvm.expect.i1(i1 %not_err109, i1 true)
+  br i1 %47, label %after_check111, label %assign_optional110
+
+assign_optional110:                               ; preds = %noerr_block107
+  store i64 %46, ptr %error_var108, align 8
+  br label %guard_block112
+
+after_check111:                                   ; preds = %noerr_block107
+  br label %noerr_block113
+
+guard_block112:                                   ; preds = %assign_optional110
+  br label %voiderr115
+
+noerr_block113:                                   ; preds = %after_check111
+  %48 = load i64, ptr %len93, align 8
+  %add114 = add i64 %48, 1
+  br label %voiderr115
+
+voiderr115:                                       ; preds = %noerr_block113, %guard_block112, %guard_block106, %guard_block100
+  br label %switch.exit117
+
+switch.case116:                                   ; preds = %switch.entry90
+  br label %switch.exit117
+
+switch.exit117:                                   ; preds = %switch.case116, %voiderr115, %switch.case91, %switch.entry90
+  store i32 %0, ptr %switch118, align 4
+  br label %switch.entry119
+
+switch.entry119:                                  ; preds = %switch.exit117
+  %49 = load i32, ptr %switch118, align 4
+  switch i32 %49, label %switch.default [
+    i32 0, label %switch.case120
+    i32 1, label %switch.case120
+    i32 2, label %switch.case120
   ]
-switch.case19:                                    ; preds = %switch.entry18, %switch.entry18, %switch.entry18
-  br label %switch.exit20
-switch.default:                                   ; preds = %switch.entry18
-  br label %switch.exit20
-switch.exit20:                                    ; preds = %switch.default, %switch.case19
-  store i32 %0, ptr %switch21, align 4
-  br label %switch.entry22
-switch.entry22:                                   ; preds = %switch.exit20
-  %15 = load i32, ptr %switch21, align 4
-  switch i32 %15, label %switch.exit30 [
-    i32 0, label %switch.case23
-    i32 1, label %switch.case25
-    i32 2, label %switch.case28
+
+switch.case120:                                   ; preds = %switch.entry119, %switch.entry119, %switch.entry119
+  br label %switch.exit121
+
+switch.default:                                   ; preds = %switch.entry119
+  br label %switch.exit121
+
+switch.exit121:                                   ; preds = %switch.default, %switch.case120
+  store i32 %0, ptr %switch122, align 4
+  br label %switch.entry123
+
+switch.entry123:                                  ; preds = %switch.exit121
+  %50 = load i32, ptr %switch122, align 4
+  switch i32 %50, label %switch.exit197 [
+    i32 0, label %switch.case124
+    i32 1, label %switch.case148
+    i32 2, label %switch.case173
   ]
-switch.case23:                                    ; preds = %switch.entry22
+
+switch.case124:                                   ; preds = %switch.entry123
   store i32 1, ptr %a, align 4
-  %16 = call ptr @std.io.stdout()
-  %17 = call i64 @std.io.File.printn(ptr %retparam24, ptr %16, ptr @.str.6, i64 1)
-  br label %switch.case25
-switch.case25:                                    ; preds = %switch.entry22, %switch.case23
-  store i32 2, ptr %a26, align 4
-  %18 = call ptr @std.io.stdout()
-  %19 = call i64 @std.io.File.printn(ptr %retparam27, ptr %18, ptr @.str.7, i64 1)
-  br label %switch.case28
-switch.case28:                                    ; preds = %switch.entry22, %switch.case25
-  %20 = call ptr @std.io.stdout()
-  %21 = call i64 @std.io.File.printn(ptr %retparam29, ptr %20, ptr @.str.8, i64 1)
-  br label %switch.exit30
-switch.exit30:                                    ; preds = %switch.case28, %switch.entry22
+  %51 = call ptr @std.io.stdout()
+  %52 = call i64 @std.io.File.write(ptr %retparam128, ptr %51, ptr @.str.6, i64 1)
+  %not_err129 = icmp eq i64 %52, 0
+  %53 = call i1 @llvm.expect.i1(i1 %not_err129, i1 true)
+  br i1 %53, label %after_check131, label %assign_optional130
+
+assign_optional130:                               ; preds = %switch.case124
+  store i64 %52, ptr %error_var126, align 8
+  br label %guard_block132
+
+after_check131:                                   ; preds = %switch.case124
+  br label %noerr_block133
+
+guard_block132:                                   ; preds = %assign_optional130
+  br label %voiderr147
+
+noerr_block133:                                   ; preds = %after_check131
+  %54 = load i64, ptr %retparam128, align 8
+  store i64 %54, ptr %len125, align 8
+  %55 = call i64 @std.io.File.write_byte(ptr %51, i8 zeroext 10)
+  %not_err135 = icmp eq i64 %55, 0
+  %56 = call i1 @llvm.expect.i1(i1 %not_err135, i1 true)
+  br i1 %56, label %after_check137, label %assign_optional136
+
+assign_optional136:                               ; preds = %noerr_block133
+  store i64 %55, ptr %error_var134, align 8
+  br label %guard_block138
+
+after_check137:                                   ; preds = %noerr_block133
+  br label %noerr_block139
+
+guard_block138:                                   ; preds = %assign_optional136
+  br label %voiderr147
+
+noerr_block139:                                   ; preds = %after_check137
+  %57 = call i64 @std.io.File.flush(ptr %51)
+  %not_err141 = icmp eq i64 %57, 0
+  %58 = call i1 @llvm.expect.i1(i1 %not_err141, i1 true)
+  br i1 %58, label %after_check143, label %assign_optional142
+
+assign_optional142:                               ; preds = %noerr_block139
+  store i64 %57, ptr %error_var140, align 8
+  br label %guard_block144
+
+after_check143:                                   ; preds = %noerr_block139
+  br label %noerr_block145
+
+guard_block144:                                   ; preds = %assign_optional142
+  br label %voiderr147
+
+noerr_block145:                                   ; preds = %after_check143
+  %59 = load i64, ptr %len125, align 8
+  %add146 = add i64 %59, 1
+  br label %voiderr147
+
+voiderr147:                                       ; preds = %noerr_block145, %guard_block144, %guard_block138, %guard_block132
+  br label %switch.case148
+
+switch.case148:                                   ; preds = %switch.entry123, %voiderr147
+  store i32 2, ptr %a149, align 4
+  %60 = call ptr @std.io.stdout()
+  %61 = call i64 @std.io.File.write(ptr %retparam153, ptr %60, ptr @.str.7, i64 1)
+  %not_err154 = icmp eq i64 %61, 0
+  %62 = call i1 @llvm.expect.i1(i1 %not_err154, i1 true)
+  br i1 %62, label %after_check156, label %assign_optional155
+
+assign_optional155:                               ; preds = %switch.case148
+  store i64 %61, ptr %error_var151, align 8
+  br label %guard_block157
+
+after_check156:                                   ; preds = %switch.case148
+  br label %noerr_block158
+
+guard_block157:                                   ; preds = %assign_optional155
+  br label %voiderr172
+
+noerr_block158:                                   ; preds = %after_check156
+  %63 = load i64, ptr %retparam153, align 8
+  store i64 %63, ptr %len150, align 8
+  %64 = call i64 @std.io.File.write_byte(ptr %60, i8 zeroext 10)
+  %not_err160 = icmp eq i64 %64, 0
+  %65 = call i1 @llvm.expect.i1(i1 %not_err160, i1 true)
+  br i1 %65, label %after_check162, label %assign_optional161
+
+assign_optional161:                               ; preds = %noerr_block158
+  store i64 %64, ptr %error_var159, align 8
+  br label %guard_block163
+
+after_check162:                                   ; preds = %noerr_block158
+  br label %noerr_block164
+
+guard_block163:                                   ; preds = %assign_optional161
+  br label %voiderr172
+
+noerr_block164:                                   ; preds = %after_check162
+  %66 = call i64 @std.io.File.flush(ptr %60)
+  %not_err166 = icmp eq i64 %66, 0
+  %67 = call i1 @llvm.expect.i1(i1 %not_err166, i1 true)
+  br i1 %67, label %after_check168, label %assign_optional167
+
+assign_optional167:                               ; preds = %noerr_block164
+  store i64 %66, ptr %error_var165, align 8
+  br label %guard_block169
+
+after_check168:                                   ; preds = %noerr_block164
+  br label %noerr_block170
+
+guard_block169:                                   ; preds = %assign_optional167
+  br label %voiderr172
+
+noerr_block170:                                   ; preds = %after_check168
+  %68 = load i64, ptr %len150, align 8
+  %add171 = add i64 %68, 1
+  br label %voiderr172
+
+voiderr172:                                       ; preds = %noerr_block170, %guard_block169, %guard_block163, %guard_block157
+  br label %switch.case173
+
+switch.case173:                                   ; preds = %switch.entry123, %voiderr172
+  %69 = call ptr @std.io.stdout()
+  %70 = call i64 @std.io.File.write(ptr %retparam177, ptr %69, ptr @.str.8, i64 1)
+  %not_err178 = icmp eq i64 %70, 0
+  %71 = call i1 @llvm.expect.i1(i1 %not_err178, i1 true)
+  br i1 %71, label %after_check180, label %assign_optional179
+
+assign_optional179:                               ; preds = %switch.case173
+  store i64 %70, ptr %error_var175, align 8
+  br label %guard_block181
+
+after_check180:                                   ; preds = %switch.case173
+  br label %noerr_block182
+
+guard_block181:                                   ; preds = %assign_optional179
+  br label %voiderr196
+
+noerr_block182:                                   ; preds = %after_check180
+  %72 = load i64, ptr %retparam177, align 8
+  store i64 %72, ptr %len174, align 8
+  %73 = call i64 @std.io.File.write_byte(ptr %69, i8 zeroext 10)
+  %not_err184 = icmp eq i64 %73, 0
+  %74 = call i1 @llvm.expect.i1(i1 %not_err184, i1 true)
+  br i1 %74, label %after_check186, label %assign_optional185
+
+assign_optional185:                               ; preds = %noerr_block182
+  store i64 %73, ptr %error_var183, align 8
+  br label %guard_block187
+
+after_check186:                                   ; preds = %noerr_block182
+  br label %noerr_block188
+
+guard_block187:                                   ; preds = %assign_optional185
+  br label %voiderr196
+
+noerr_block188:                                   ; preds = %after_check186
+  %75 = call i64 @std.io.File.flush(ptr %69)
+  %not_err190 = icmp eq i64 %75, 0
+  %76 = call i1 @llvm.expect.i1(i1 %not_err190, i1 true)
+  br i1 %76, label %after_check192, label %assign_optional191
+
+assign_optional191:                               ; preds = %noerr_block188
+  store i64 %75, ptr %error_var189, align 8
+  br label %guard_block193
+
+after_check192:                                   ; preds = %noerr_block188
+  br label %noerr_block194
+
+guard_block193:                                   ; preds = %assign_optional191
+  br label %voiderr196
+
+noerr_block194:                                   ; preds = %after_check192
+  %77 = load i64, ptr %len174, align 8
+  %add195 = add i64 %77, 1
+  br label %voiderr196
+
+voiderr196:                                       ; preds = %noerr_block194, %guard_block193, %guard_block187, %guard_block181
+  br label %switch.exit197
+
+switch.exit197:                                   ; preds = %voiderr196, %switch.entry123
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/initializer_lists/subarrays.c3t b/test/test_suite/initializer_lists/subarrays.c3t
index cb6c5d853..bf7436acd 100644
--- a/test/test_suite/initializer_lists/subarrays.c3t
+++ b/test/test_suite/initializer_lists/subarrays.c3t
@@ -72,12 +72,20 @@ entry:
   %literal = alloca [3 x i32], align 4
   %y = alloca ptr, align 8
   %literal2 = alloca [3 x i32], align 4
+  %len = alloca i64, align 8
+  %error_var = alloca i64, align 8
   %retparam = alloca i64, align 8
+  %error_var4 = alloca i64, align 8
+  %error_var10 = alloca i64, align 8
   %ffe = alloca %Baz, align 8
   %azz = alloca [1 x i32], align 4
   %xy = alloca i8, align 1
-  %literal6 = alloca [3 x i32], align 4
-  %retparam8 = alloca i64, align 8
+  %literal19 = alloca [3 x i32], align 4
+  %len21 = alloca i64, align 8
+  %error_var22 = alloca i64, align 8
+  %retparam24 = alloca i64, align 8
+  %error_var30 = alloca i64, align 8
+  %error_var36 = alloca i64, align 8
   %b = alloca %Bar, align 4
   %z = alloca %Baz, align 8
   %sub = alloca %"int[]", align 8
@@ -98,46 +106,128 @@ entry:
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal2, ptr align 4 @.__const.5, i32 12, i1 false)
   store ptr %literal2, ptr %y, align 8
   %7 = call ptr @std.io.stdout()
-  %8 = call i64 @std.io.File.printn(ptr %retparam, ptr %7, ptr @.str.6, i64 6)
-  %9 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1
-  %10 = load i64, ptr %9, align 8
-  %trunc = trunc i64 %10 to i32
-  %11 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0
-  %12 = load ptr, ptr %11, align 8
-  %ptroffset3 = getelementptr inbounds i32, ptr %12, i64 1
-  %13 = load i32, ptr %ptroffset3, align 4
-  %14 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %trunc, i32 %13)
-  %15 = load ptr, ptr %y, align 8
-  %ptroffset4 = getelementptr inbounds i32, ptr %15, i64 1
-  %16 = load i32, ptr %ptroffset4, align 4
-  %17 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %16)
-  %18 = load ptr, ptr @subarrays.fofeo, align 8
-  %ptroffset5 = getelementptr inbounds i32, ptr %18, i64 1
-  %19 = load i32, ptr %ptroffset5, align 4
-  %20 = call i32 (ptr, ...) @printf(ptr @.str.9, i32 %19)
+  %8 = call i64 @std.io.File.write(ptr %retparam, ptr %7, ptr @.str.6, i64 6)
+  %not_err = icmp eq i64 %8, 0
+  %9 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
+  br i1 %9, label %after_check, label %assign_optional
+assign_optional:                                  ; preds = %entry
+  store i64 %8, ptr %error_var, align 8
+  br label %guard_block
+after_check:                                      ; preds = %entry
+  br label %noerr_block
+guard_block:                                      ; preds = %assign_optional
+  br label %voiderr
+noerr_block:                                      ; preds = %after_check
+  %10 = load i64, ptr %retparam, align 8
+  store i64 %10, ptr %len, align 8
+  %11 = call i64 @std.io.File.write_byte(ptr %7, i8 zeroext 10)
+  %not_err5 = icmp eq i64 %11, 0
+  %12 = call i1 @llvm.expect.i1(i1 %not_err5, i1 true)
+  br i1 %12, label %after_check7, label %assign_optional6
+assign_optional6:                                 ; preds = %noerr_block
+  store i64 %11, ptr %error_var4, align 8
+  br label %guard_block8
+after_check7:                                     ; preds = %noerr_block
+  br label %noerr_block9
+guard_block8:                                     ; preds = %assign_optional6
+  br label %voiderr
+noerr_block9:                                     ; preds = %after_check7
+  %13 = call i64 @std.io.File.flush(ptr %7)
+  %not_err11 = icmp eq i64 %13, 0
+  %14 = call i1 @llvm.expect.i1(i1 %not_err11, i1 true)
+  br i1 %14, label %after_check13, label %assign_optional12
+assign_optional12:                                ; preds = %noerr_block9
+  store i64 %13, ptr %error_var10, align 8
+  br label %guard_block14
+after_check13:                                    ; preds = %noerr_block9
+  br label %noerr_block15
+guard_block14:                                    ; preds = %assign_optional12
+  br label %voiderr
+noerr_block15:                                    ; preds = %after_check13
+  %15 = load i64, ptr %len, align 8
+  %add = add i64 %15, 1
+  br label %voiderr
+voiderr:                                          ; preds = %noerr_block15, %guard_block14, %guard_block8, %guard_block
+  %16 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1
+  %17 = load i64, ptr %16, align 8
+  %trunc = trunc i64 %17 to i32
+  %18 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0
+  %19 = load ptr, ptr %18, align 8
+  %ptroffset16 = getelementptr inbounds i32, ptr %19, i64 1
+  %20 = load i32, ptr %ptroffset16, align 4
+  %21 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %trunc, i32 %20)
+  %22 = load ptr, ptr %y, align 8
+  %ptroffset17 = getelementptr inbounds i32, ptr %22, i64 1
+  %23 = load i32, ptr %ptroffset17, align 4
+  %24 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %23)
+  %25 = load ptr, ptr @subarrays.fofeo, align 8
+  %ptroffset18 = getelementptr inbounds i32, ptr %25, i64 1
+  %26 = load i32, ptr %ptroffset18, align 4
+  %27 = call i32 (ptr, ...) @printf(ptr @.str.9, i32 %26)
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %ffe, ptr align 8 @.__const.10, i32 8, i1 false)
-  %21 = getelementptr inbounds [1 x i32], ptr %azz, i64 0, i64 0
-  store i32 0, ptr %21, align 4
-  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal6, ptr align 4 @.__const.11, i32 12, i1 false)
-  %22 = insertvalue %"int[]" undef, ptr %literal6, 0
-  %23 = insertvalue %"int[]" %22, i64 3, 1
-  %24 = extractvalue %"int[]" %23, 1
-  %not = icmp eq i64 %24, 0
-  %25 = zext i1 %not to i8
-  store i8 %25, ptr %xy, align 1
-  %26 = load i8, ptr %xy, align 1
-  %27 = trunc i8 %26 to i1
-  %not7 = xor i1 %27, true
-  br i1 %not7, label %if.then, label %if.exit
-if.then:                                          ; preds = %entry
-  %28 = call ptr @std.io.stdout()
-  %29 = call i64 @std.io.File.printn(ptr %retparam8, ptr %28, ptr @.str.12, i64 2)
+  %28 = getelementptr inbounds [1 x i32], ptr %azz, i64 0, i64 0
+  store i32 0, ptr %28, align 4
+  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal19, ptr align 4 @.__const.11, i32 12, i1 false)
+  %29 = insertvalue %"int[]" undef, ptr %literal19, 0
+  %30 = insertvalue %"int[]" %29, i64 3, 1
+  %31 = extractvalue %"int[]" %30, 1
+  %not = icmp eq i64 %31, 0
+  %32 = zext i1 %not to i8
+  store i8 %32, ptr %xy, align 1
+  %33 = load i8, ptr %xy, align 1
+  %34 = trunc i8 %33 to i1
+  %not20 = xor i1 %34, true
+  br i1 %not20, label %if.then, label %if.exit
+if.then:                                          ; preds = %voiderr
+  %35 = call ptr @std.io.stdout()
+  %36 = call i64 @std.io.File.write(ptr %retparam24, ptr %35, ptr @.str.12, i64 2)
+  %not_err25 = icmp eq i64 %36, 0
+  %37 = call i1 @llvm.expect.i1(i1 %not_err25, i1 true)
+  br i1 %37, label %after_check27, label %assign_optional26
+assign_optional26:                                ; preds = %if.then
+  store i64 %36, ptr %error_var22, align 8
+  br label %guard_block28
+after_check27:                                    ; preds = %if.then
+  br label %noerr_block29
+guard_block28:                                    ; preds = %assign_optional26
+  br label %voiderr43
+noerr_block29:                                    ; preds = %after_check27
+  %38 = load i64, ptr %retparam24, align 8
+  store i64 %38, ptr %len21, align 8
+  %39 = call i64 @std.io.File.write_byte(ptr %35, i8 zeroext 10)
+  %not_err31 = icmp eq i64 %39, 0
+  %40 = call i1 @llvm.expect.i1(i1 %not_err31, i1 true)
+  br i1 %40, label %after_check33, label %assign_optional32
+assign_optional32:                                ; preds = %noerr_block29
+  store i64 %39, ptr %error_var30, align 8
+  br label %guard_block34
+after_check33:                                    ; preds = %noerr_block29
+  br label %noerr_block35
+guard_block34:                                    ; preds = %assign_optional32
+  br label %voiderr43
+noerr_block35:                                    ; preds = %after_check33
+  %41 = call i64 @std.io.File.flush(ptr %35)
+  %not_err37 = icmp eq i64 %41, 0
+  %42 = call i1 @llvm.expect.i1(i1 %not_err37, i1 true)
+  br i1 %42, label %after_check39, label %assign_optional38
+assign_optional38:                                ; preds = %noerr_block35
+  store i64 %41, ptr %error_var36, align 8
+  br label %guard_block40
+after_check39:                                    ; preds = %noerr_block35
+  br label %noerr_block41
+guard_block40:                                    ; preds = %assign_optional38
+  br label %voiderr43
+noerr_block41:                                    ; preds = %after_check39
+  %43 = load i64, ptr %len21, align 8
+  %add42 = add i64 %43, 1
+  br label %voiderr43
+voiderr43:                                        ; preds = %noerr_block41, %guard_block40, %guard_block34, %guard_block28
   br label %if.exit
-if.exit:                                          ; preds = %if.then, %entry
-  %30 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 0
-  store i32 0, ptr %30, align 4
-  %31 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1
-  store i32 0, ptr %31, align 4
+if.exit:                                          ; preds = %voiderr43, %voiderr
+  %44 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 0
+  store i32 0, ptr %44, align 4
+  %45 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1
+  store i32 0, ptr %45, align 4
   call void @llvm.memset.p0.i64(ptr align 8 %z, i8 0, i64 8, i1 false)
   store %"int[]" zeroinitializer, ptr %sub, align 8
   store %"Bar[]" zeroinitializer, ptr %foo, align 8
diff --git a/test/test_suite/methods/enum_distinct_err_methods.c3t b/test/test_suite/methods/enum_distinct_err_methods.c3t
index c29bda02b..9f805874e 100644
--- a/test/test_suite/methods/enum_distinct_err_methods.c3t
+++ b/test/test_suite/methods/enum_distinct_err_methods.c3t
@@ -46,25 +46,160 @@ fn int main()
 
 define void @foo.Foo.hello(ptr %0) #0 {
 entry:
+  %len = alloca i64, align 8
+  %error_var = alloca i64, align 8
   %retparam = alloca i64, align 8
+  %error_var2 = alloca i64, align 8
+  %error_var8 = alloca i64, align 8
   %1 = call ptr @std.io.stdout()
-  %2 = call i64 @std.io.File.printn(ptr %retparam, ptr %1, ptr @.str, i64 14)
+  %2 = call i64 @std.io.File.write(ptr %retparam, ptr %1, ptr @.str, i64 14)
+  %not_err = icmp eq i64 %2, 0
+  %3 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
+  br i1 %3, label %after_check, label %assign_optional
+assign_optional:                                  ; preds = %entry
+  store i64 %2, ptr %error_var, align 8
+  br label %guard_block
+after_check:                                      ; preds = %entry
+  br label %noerr_block
+guard_block:                                      ; preds = %assign_optional
+  br label %voiderr
+noerr_block:                                      ; preds = %after_check
+  %4 = load i64, ptr %retparam, align 8
+  store i64 %4, ptr %len, align 8
+  %5 = call i64 @std.io.File.write_byte(ptr %1, i8 zeroext 10)
+  %not_err3 = icmp eq i64 %5, 0
+  %6 = call i1 @llvm.expect.i1(i1 %not_err3, i1 true)
+  br i1 %6, label %after_check5, label %assign_optional4
+assign_optional4:                                 ; preds = %noerr_block
+  store i64 %5, ptr %error_var2, align 8
+  br label %guard_block6
+after_check5:                                     ; preds = %noerr_block
+  br label %noerr_block7
+guard_block6:                                     ; preds = %assign_optional4
+  br label %voiderr
+noerr_block7:                                     ; preds = %after_check5
+  %7 = call i64 @std.io.File.flush(ptr %1)
+  %not_err9 = icmp eq i64 %7, 0
+  %8 = call i1 @llvm.expect.i1(i1 %not_err9, i1 true)
+  br i1 %8, label %after_check11, label %assign_optional10
+assign_optional10:                                ; preds = %noerr_block7
+  store i64 %7, ptr %error_var8, align 8
+  br label %guard_block12
+after_check11:                                    ; preds = %noerr_block7
+  br label %noerr_block13
+guard_block12:                                    ; preds = %assign_optional10
+  br label %voiderr
+noerr_block13:                                    ; preds = %after_check11
+  %9 = load i64, ptr %len, align 8
+  %add = add i64 %9, 1
+  br label %voiderr
+voiderr:                                          ; preds = %noerr_block13, %guard_block12, %guard_block6, %guard_block
   ret void
 }
 ; Function Attrs: nounwind
 define void @foo.Bar.hello(ptr %0) #0 {
 entry:
+  %len = alloca i64, align 8
+  %error_var = alloca i64, align 8
   %retparam = alloca i64, align 8
+  %error_var2 = alloca i64, align 8
+  %error_var8 = alloca i64, align 8
   %1 = call ptr @std.io.stdout()
-  %2 = call i64 @std.io.File.printn(ptr %retparam, ptr %1, ptr @.str.1, i64 14)
+  %2 = call i64 @std.io.File.write(ptr %retparam, ptr %1, ptr @.str.1, i64 14)
+  %not_err = icmp eq i64 %2, 0
+  %3 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
+  br i1 %3, label %after_check, label %assign_optional
+assign_optional:                                  ; preds = %entry
+  store i64 %2, ptr %error_var, align 8
+  br label %guard_block
+after_check:                                      ; preds = %entry
+  br label %noerr_block
+guard_block:                                      ; preds = %assign_optional
+  br label %voiderr
+noerr_block:                                      ; preds = %after_check
+  %4 = load i64, ptr %retparam, align 8
+  store i64 %4, ptr %len, align 8
+  %5 = call i64 @std.io.File.write_byte(ptr %1, i8 zeroext 10)
+  %not_err3 = icmp eq i64 %5, 0
+  %6 = call i1 @llvm.expect.i1(i1 %not_err3, i1 true)
+  br i1 %6, label %after_check5, label %assign_optional4
+assign_optional4:                                 ; preds = %noerr_block
+  store i64 %5, ptr %error_var2, align 8
+  br label %guard_block6
+after_check5:                                     ; preds = %noerr_block
+  br label %noerr_block7
+guard_block6:                                     ; preds = %assign_optional4
+  br label %voiderr
+noerr_block7:                                     ; preds = %after_check5
+  %7 = call i64 @std.io.File.flush(ptr %1)
+  %not_err9 = icmp eq i64 %7, 0
+  %8 = call i1 @llvm.expect.i1(i1 %not_err9, i1 true)
+  br i1 %8, label %after_check11, label %assign_optional10
+assign_optional10:                                ; preds = %noerr_block7
+  store i64 %7, ptr %error_var8, align 8
+  br label %guard_block12
+after_check11:                                    ; preds = %noerr_block7
+  br label %noerr_block13
+guard_block12:                                    ; preds = %assign_optional10
+  br label %voiderr
+noerr_block13:                                    ; preds = %after_check11
+  %9 = load i64, ptr %len, align 8
+  %add = add i64 %9, 1
+  br label %voiderr
+voiderr:                                          ; preds = %noerr_block13, %guard_block12, %guard_block6, %guard_block
   ret void
 }
 ; Function Attrs: nounwind
 define void @foo.MyEnum.hello(ptr %0) #0 {
 entry:
+  %len = alloca i64, align 8
+  %error_var = alloca i64, align 8
   %retparam = alloca i64, align 8
+  %error_var2 = alloca i64, align 8
+  %error_var8 = alloca i64, align 8
   %1 = call ptr @std.io.stdout()
-  %2 = call i64 @std.io.File.printn(ptr %retparam, ptr %1, ptr @.str.2, i64 17)
+  %2 = call i64 @std.io.File.write(ptr %retparam, ptr %1, ptr @.str.2, i64 17)
+  %not_err = icmp eq i64 %2, 0
+  %3 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
+  br i1 %3, label %after_check, label %assign_optional
+assign_optional:                                  ; preds = %entry
+  store i64 %2, ptr %error_var, align 8
+  br label %guard_block
+after_check:                                      ; preds = %entry
+  br label %noerr_block
+guard_block:                                      ; preds = %assign_optional
+  br label %voiderr
+noerr_block:                                      ; preds = %after_check
+  %4 = load i64, ptr %retparam, align 8
+  store i64 %4, ptr %len, align 8
+  %5 = call i64 @std.io.File.write_byte(ptr %1, i8 zeroext 10)
+  %not_err3 = icmp eq i64 %5, 0
+  %6 = call i1 @llvm.expect.i1(i1 %not_err3, i1 true)
+  br i1 %6, label %after_check5, label %assign_optional4
+assign_optional4:                                 ; preds = %noerr_block
+  store i64 %5, ptr %error_var2, align 8
+  br label %guard_block6
+after_check5:                                     ; preds = %noerr_block
+  br label %noerr_block7
+guard_block6:                                     ; preds = %assign_optional4
+  br label %voiderr
+noerr_block7:                                     ; preds = %after_check5
+  %7 = call i64 @std.io.File.flush(ptr %1)
+  %not_err9 = icmp eq i64 %7, 0
+  %8 = call i1 @llvm.expect.i1(i1 %not_err9, i1 true)
+  br i1 %8, label %after_check11, label %assign_optional10
+assign_optional10:                                ; preds = %noerr_block7
+  store i64 %7, ptr %error_var8, align 8
+  br label %guard_block12
+after_check11:                                    ; preds = %noerr_block7
+  br label %noerr_block13
+guard_block12:                                    ; preds = %assign_optional10
+  br label %voiderr
+noerr_block13:                                    ; preds = %after_check11
+  %9 = load i64, ptr %len, align 8
+  %add = add i64 %9, 1
+  br label %voiderr
+voiderr:                                          ; preds = %noerr_block13, %guard_block12, %guard_block6, %guard_block
   ret void
 }
 ; Function Attrs: nounwind
diff --git a/test/unit/stdlib/io/file_read_write_any.c3 b/test/unit/stdlib/io/file_read_write_any.c3
index 420400296..a13425c78 100644
--- a/test/unit/stdlib/io/file_read_write_any.c3
+++ b/test/unit/stdlib/io/file_read_write_any.c3
@@ -58,7 +58,7 @@ fn void! read_write_any()
     File file = file::open("__file_read_write_any_test_file", "wb")!!;
 
     file.write_any(&data)!!;
-    file.flush();
+    file.flush()!;
     file.close()!!;
 
     file = file::open("__file_read_write_any_test_file", "rb")!!;