0.5.3: Single-module not respected. Fix issue with compiler defined types. Fix optimization levels for projects. Use GEP i8 on offsets. Optimize foreach on len 1 arrays. Move panic blocks last. Fix generic module wildcard imports. Deprecate init_temp / init_new. Fix issue with macro vaarg and untyped lists. Fix extern const globals.

test/test_suite/bitstruct/bitstruct_ops.c3t

@@ -55,38 +55,38 @@ entry:
   %varargslots3 = alloca [2 x %"any*"], align 16
   %taddr5 = alloca i8, align 1
   %taddr8 = alloca i8, align 1
-  %retparam9 = alloca i64, align 8
+  %retparam10 = alloca i64, align 8
   %f5 = alloca i32, align 4
-  %varargslots10 = alloca [2 x %"any*"], align 16
-  %taddr12 = alloca i8, align 1
-  %taddr15 = alloca i8, align 1
-  %retparam16 = alloca i64, align 8
-  %varargslots18 = alloca [2 x %"any*"], align 16
-  %taddr20 = alloca i8, align 1
-  %taddr23 = alloca i8, align 1
-  %retparam24 = alloca i64, align 8
+  %varargslots11 = alloca [2 x %"any*"], align 16
+  %taddr13 = alloca i8, align 1
+  %taddr16 = alloca i8, align 1
+  %retparam18 = alloca i64, align 8
+  %varargslots20 = alloca [2 x %"any*"], align 16
+  %taddr22 = alloca i8, align 1
+  %taddr25 = alloca i8, align 1
+  %retparam27 = alloca i64, align 8
   %b1 = alloca [13 x i8], align 1
   %b2 = alloca [13 x i8], align 1
   %b3 = alloca [13 x i8], align 1
   %0 = alloca i104, align 1
-  %varargslots26 = alloca [3 x %"any*"], align 16
-  %taddr27 = alloca i8, align 1
-  %taddr29 = alloca i8, align 1
-  %taddr31 = alloca i8, align 1
-  %retparam32 = alloca i64, align 8
+  %varargslots29 = alloca [3 x %"any*"], align 16
+  %taddr30 = alloca i8, align 1
+  %taddr32 = alloca i8, align 1
+  %taddr36 = alloca i8, align 1
+  %retparam38 = alloca i64, align 8
   %1 = alloca i104, align 1
-  %varargslots34 = alloca [3 x %"any*"], align 16
-  %taddr35 = alloca i8, align 1
-  %taddr37 = alloca i8, align 1
-  %taddr39 = alloca i8, align 1
-  %retparam40 = alloca i64, align 8
-  %taddr41 = alloca [13 x i8], align 1
-  %2 = alloca i104, align 1
-  %varargslots43 = alloca [3 x %"any*"], align 16
-  %taddr44 = alloca i8, align 1
-  %taddr46 = alloca i8, align 1
-  %taddr48 = alloca i8, align 1
+  %varargslots40 = alloca [3 x %"any*"], align 16
+  %taddr41 = alloca i8, align 1
+  %taddr43 = alloca i8, align 1
+  %taddr47 = alloca i8, align 1
   %retparam49 = alloca i64, align 8
+  %taddr50 = alloca [13 x i8], align 1
+  %2 = alloca i104, align 1
+  %varargslots52 = alloca [3 x %"any*"], align 16
+  %taddr53 = alloca i8, align 1
+  %taddr55 = alloca i8, align 1
+  %taddr59 = alloca i8, align 1
+  %retparam61 = alloca i64, align 8
   store i32 3, ptr %f1, align 4
   store i32 1, ptr %f2, align 4
   %3 = load i32, ptr %f1, align 4
@@ -99,191 +99,178 @@ entry:
   store i8 %trunc, ptr %taddr, align 1
   %7 = insertvalue %"any*" undef, ptr %taddr, 0
   %8 = insertvalue %"any*" %7, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %9 = getelementptr inbounds [2 x %"any*"], ptr %varargslots, i64 0, i64 0
-  store %"any*" %8, ptr %9, align 16
-  %10 = load i32, ptr %f3, align 4
-  %lshrl = lshr i32 %10, 1
-  %11 = and i32 1, %lshrl
-  %trunc1 = trunc i32 %11 to i8
+  store %"any*" %8, ptr %varargslots, align 16
+  %9 = load i32, ptr %f3, align 4
+  %lshrl = lshr i32 %9, 1
+  %10 = and i32 1, %lshrl
+  %trunc1 = trunc i32 %10 to i8
   store i8 %trunc1, ptr %taddr2, align 1
-  %12 = insertvalue %"any*" undef, ptr %taddr2, 0
-  %13 = insertvalue %"any*" %12, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %14 = getelementptr inbounds [2 x %"any*"], ptr %varargslots, i64 0, i64 1
-  store %"any*" %13, ptr %14, align 16
-  %15 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2)
-  %16 = load i32, ptr %f1, align 4
-  %17 = load i32, ptr %f2, align 4
-  %bnot = xor i32 %17, -1
-  %or = or i32 %16, %bnot
-  %18 = load i32, ptr %f3, align 4
-  %xor = xor i32 %or, %18
+  %11 = insertvalue %"any*" undef, ptr %taddr2, 0
+  %12 = insertvalue %"any*" %11, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  %ptradd = getelementptr inbounds i8, ptr %varargslots, i64 16
+  store %"any*" %12, ptr %ptradd, align 16
+  %13 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2)
+  %14 = load i32, ptr %f1, align 4
+  %15 = load i32, ptr %f2, align 4
+  %bnot = xor i32 %15, -1
+  %or = or i32 %14, %bnot
+  %16 = load i32, ptr %f3, align 4
+  %xor = xor i32 %or, %16
   store i32 %xor, ptr %f4, align 4
-  %19 = load i32, ptr %f4, align 4
-  %20 = and i32 1, %19
-  %trunc4 = trunc i32 %20 to i8
+  %17 = load i32, ptr %f4, align 4
+  %18 = and i32 1, %17
+  %trunc4 = trunc i32 %18 to i8
   store i8 %trunc4, ptr %taddr5, align 1
-  %21 = insertvalue %"any*" undef, ptr %taddr5, 0
-  %22 = insertvalue %"any*" %21, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %23 = getelementptr inbounds [2 x %"any*"], ptr %varargslots3, i64 0, i64 0
-  store %"any*" %22, ptr %23, align 16
-  %24 = load i32, ptr %f4, align 4
-  %lshrl6 = lshr i32 %24, 1
-  %25 = and i32 1, %lshrl6
-  %trunc7 = trunc i32 %25 to i8
+  %19 = insertvalue %"any*" undef, ptr %taddr5, 0
+  %20 = insertvalue %"any*" %19, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  store %"any*" %20, ptr %varargslots3, align 16
+  %21 = load i32, ptr %f4, align 4
+  %lshrl6 = lshr i32 %21, 1
+  %22 = and i32 1, %lshrl6
+  %trunc7 = trunc i32 %22 to i8
   store i8 %trunc7, ptr %taddr8, align 1
-  %26 = insertvalue %"any*" undef, ptr %taddr8, 0
-  %27 = insertvalue %"any*" %26, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %28 = getelementptr inbounds [2 x %"any*"], ptr %varargslots3, i64 0, i64 1
-  store %"any*" %27, ptr %28, align 16
-  %29 = call i64 @std.io.printfn(ptr %retparam9, ptr @.str.1, i64 5, ptr %varargslots3, i64 2)
+  %23 = insertvalue %"any*" undef, ptr %taddr8, 0
+  %24 = insertvalue %"any*" %23, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  %ptradd9 = getelementptr inbounds i8, ptr %varargslots3, i64 16
+  store %"any*" %24, ptr %ptradd9, align 16
+  %25 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.1, i64 5, ptr %varargslots3, i64 2)
   store i32 3, ptr %f5, align 4
+  %26 = load i32, ptr %f5, align 4
+  %27 = and i32 1, %26
+  %trunc12 = trunc i32 %27 to i8
+  store i8 %trunc12, ptr %taddr13, align 1
+  %28 = insertvalue %"any*" undef, ptr %taddr13, 0
+  %29 = insertvalue %"any*" %28, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  store %"any*" %29, ptr %varargslots11, align 16
   %30 = load i32, ptr %f5, align 4
-  %31 = and i32 1, %30
-  %trunc11 = trunc i32 %31 to i8
-  store i8 %trunc11, ptr %taddr12, align 1
-  %32 = insertvalue %"any*" undef, ptr %taddr12, 0
+  %lshrl14 = lshr i32 %30, 1
+  %31 = and i32 1, %lshrl14
+  %trunc15 = trunc i32 %31 to i8
+  store i8 %trunc15, ptr %taddr16, align 1
+  %32 = insertvalue %"any*" undef, ptr %taddr16, 0
   %33 = insertvalue %"any*" %32, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %34 = getelementptr inbounds [2 x %"any*"], ptr %varargslots10, i64 0, i64 0
-  store %"any*" %33, ptr %34, align 16
+  %ptradd17 = getelementptr inbounds i8, ptr %varargslots11, i64 16
+  store %"any*" %33, ptr %ptradd17, align 16
+  %34 = call i64 @std.io.printfn(ptr %retparam18, ptr @.str.2, i64 5, ptr %varargslots11, i64 2)
   %35 = load i32, ptr %f5, align 4
-  %lshrl13 = lshr i32 %35, 1
-  %36 = and i32 1, %lshrl13
-  %trunc14 = trunc i32 %36 to i8
-  store i8 %trunc14, ptr %taddr15, align 1
-  %37 = insertvalue %"any*" undef, ptr %taddr15, 0
-  %38 = insertvalue %"any*" %37, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %39 = getelementptr inbounds [2 x %"any*"], ptr %varargslots10, i64 0, i64 1
-  store %"any*" %38, ptr %39, align 16
-  %40 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.2, i64 5, ptr %varargslots10, i64 2)
+  %36 = load i32, ptr %f2, align 4
+  %and19 = and i32 %35, %36
+  store i32 %and19, ptr %f5, align 4
+  %37 = load i32, ptr %f5, align 4
+  %38 = and i32 1, %37
+  %trunc21 = trunc i32 %38 to i8
+  store i8 %trunc21, ptr %taddr22, align 1
+  %39 = insertvalue %"any*" undef, ptr %taddr22, 0
+  %40 = insertvalue %"any*" %39, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  store %"any*" %40, ptr %varargslots20, align 16
   %41 = load i32, ptr %f5, align 4
-  %42 = load i32, ptr %f2, align 4
-  %and17 = and i32 %41, %42
-  store i32 %and17, ptr %f5, align 4
-  %43 = load i32, ptr %f5, align 4
-  %44 = and i32 1, %43
-  %trunc19 = trunc i32 %44 to i8
-  store i8 %trunc19, ptr %taddr20, align 1
-  %45 = insertvalue %"any*" undef, ptr %taddr20, 0
-  %46 = insertvalue %"any*" %45, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %47 = getelementptr inbounds [2 x %"any*"], ptr %varargslots18, i64 0, i64 0
-  store %"any*" %46, ptr %47, align 16
-  %48 = load i32, ptr %f5, align 4
-  %lshrl21 = lshr i32 %48, 1
-  %49 = and i32 1, %lshrl21
-  %trunc22 = trunc i32 %49 to i8
-  store i8 %trunc22, ptr %taddr23, align 1
-  %50 = insertvalue %"any*" undef, ptr %taddr23, 0
-  %51 = insertvalue %"any*" %50, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %52 = getelementptr inbounds [2 x %"any*"], ptr %varargslots18, i64 0, i64 1
-  store %"any*" %51, ptr %52, align 16
-  %53 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.3, i64 5, ptr %varargslots18, i64 2)
+  %lshrl23 = lshr i32 %41, 1
+  %42 = and i32 1, %lshrl23
+  %trunc24 = trunc i32 %42 to i8
+  store i8 %trunc24, ptr %taddr25, align 1
+  %43 = insertvalue %"any*" undef, ptr %taddr25, 0
+  %44 = insertvalue %"any*" %43, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  %ptradd26 = getelementptr inbounds i8, ptr %varargslots20, i64 16
+  store %"any*" %44, ptr %ptradd26, align 16
+  %45 = call i64 @std.io.printfn(ptr %retparam27, ptr @.str.3, i64 5, ptr %varargslots20, i64 2)
   store [13 x i8] c"\03\00\00\02\00\00\00\00\00\00\00\00\00", ptr %b1, align 1
   store [13 x i8] c"\01\00\00\00\00\00\00\00\00\00\00\00\00", ptr %b2, align 1
-  %54 = load i104, ptr %b1, align 1
-  %55 = load i104, ptr %b2, align 1
-  %and25 = and i104 %54, %55
-  store i104 %and25, ptr %0, align 1
+  %46 = load i104, ptr %b1, align 1
+  %47 = load i104, ptr %b2, align 1
+  %and28 = and i104 %46, %47
+  store i104 %and28, ptr %0, align 1
   call void @llvm.memcpy.p0.p0.i32(ptr align 1 %b3, ptr align 1 %0, i32 13, i1 false)
-  %56 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
-  %57 = load i8, ptr %56, align 1
-  %58 = trunc i8 %57 to i1
-  %59 = zext i1 %58 to i8
-  store i8 %59, ptr %taddr27, align 1
-  %60 = insertvalue %"any*" undef, ptr %taddr27, 0
-  %61 = insertvalue %"any*" %60, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %62 = getelementptr inbounds [3 x %"any*"], ptr %varargslots26, i64 0, i64 0
-  store %"any*" %61, ptr %62, align 16
-  %63 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
-  %64 = load i8, ptr %63, align 1
-  %lshrl28 = lshr i8 %64, 1
-  %65 = trunc i8 %lshrl28 to i1
-  %66 = zext i1 %65 to i8
-  store i8 %66, ptr %taddr29, align 1
-  %67 = insertvalue %"any*" undef, ptr %taddr29, 0
-  %68 = insertvalue %"any*" %67, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %69 = getelementptr inbounds [3 x %"any*"], ptr %varargslots26, i64 0, i64 1
-  store %"any*" %68, ptr %69, align 16
-  %70 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 3
-  %71 = load i8, ptr %70, align 1
-  %lshrl30 = lshr i8 %71, 1
-  %72 = trunc i8 %lshrl30 to i1
-  %73 = zext i1 %72 to i8
-  store i8 %73, ptr %taddr31, align 1
-  %74 = insertvalue %"any*" undef, ptr %taddr31, 0
-  %75 = insertvalue %"any*" %74, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %76 = getelementptr inbounds [3 x %"any*"], ptr %varargslots26, i64 0, i64 2
-  store %"any*" %75, ptr %76, align 16
-  %77 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.4, i64 8, ptr %varargslots26, i64 3)
-  %78 = load i104, ptr %b3, align 1
-  %bnot33 = xor i104 %78, -1
-  store i104 %bnot33, ptr %1, align 1
+  %48 = load i8, ptr %b3, align 1
+  %49 = trunc i8 %48 to i1
+  %50 = zext i1 %49 to i8
+  store i8 %50, ptr %taddr30, align 1
+  %51 = insertvalue %"any*" undef, ptr %taddr30, 0
+  %52 = insertvalue %"any*" %51, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  store %"any*" %52, ptr %varargslots29, align 16
+  %53 = load i8, ptr %b3, align 1
+  %lshrl31 = lshr i8 %53, 1
+  %54 = trunc i8 %lshrl31 to i1
+  %55 = zext i1 %54 to i8
+  store i8 %55, ptr %taddr32, align 1
+  %56 = insertvalue %"any*" undef, ptr %taddr32, 0
+  %57 = insertvalue %"any*" %56, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  %ptradd33 = getelementptr inbounds i8, ptr %varargslots29, i64 16
+  store %"any*" %57, ptr %ptradd33, align 16
+  %ptradd34 = getelementptr inbounds i8, ptr %b3, i64 3
+  %58 = load i8, ptr %ptradd34, align 1
+  %lshrl35 = lshr i8 %58, 1
+  %59 = trunc i8 %lshrl35 to i1
+  %60 = zext i1 %59 to i8
+  store i8 %60, ptr %taddr36, align 1
+  %61 = insertvalue %"any*" undef, ptr %taddr36, 0
+  %62 = insertvalue %"any*" %61, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  %ptradd37 = getelementptr inbounds i8, ptr %varargslots29, i64 32
+  store %"any*" %62, ptr %ptradd37, align 16
+  %63 = call i64 @std.io.printfn(ptr %retparam38, ptr @.str.4, i64 8, ptr %varargslots29, i64 3)
+  %64 = load i104, ptr %b3, align 1
+  %bnot39 = xor i104 %64, -1
+  store i104 %bnot39, ptr %1, align 1
   call void @llvm.memcpy.p0.p0.i32(ptr align 1 %b3, ptr align 1 %1, i32 13, i1 false)
-  %79 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
-  %80 = load i8, ptr %79, align 1
-  %81 = trunc i8 %80 to i1
-  %82 = zext i1 %81 to i8
-  store i8 %82, ptr %taddr35, align 1
-  %83 = insertvalue %"any*" undef, ptr %taddr35, 0
-  %84 = insertvalue %"any*" %83, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %85 = getelementptr inbounds [3 x %"any*"], ptr %varargslots34, i64 0, i64 0
-  store %"any*" %84, ptr %85, align 16
-  %86 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
-  %87 = load i8, ptr %86, align 1
-  %lshrl36 = lshr i8 %87, 1
-  %88 = trunc i8 %lshrl36 to i1
-  %89 = zext i1 %88 to i8
-  store i8 %89, ptr %taddr37, align 1
-  %90 = insertvalue %"any*" undef, ptr %taddr37, 0
-  %91 = insertvalue %"any*" %90, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %92 = getelementptr inbounds [3 x %"any*"], ptr %varargslots34, i64 0, i64 1
-  store %"any*" %91, ptr %92, align 16
-  %93 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 3
-  %94 = load i8, ptr %93, align 1
-  %lshrl38 = lshr i8 %94, 1
-  %95 = trunc i8 %lshrl38 to i1
-  %96 = zext i1 %95 to i8
-  store i8 %96, ptr %taddr39, align 1
-  %97 = insertvalue %"any*" undef, ptr %taddr39, 0
-  %98 = insertvalue %"any*" %97, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %99 = getelementptr inbounds [3 x %"any*"], ptr %varargslots34, i64 0, i64 2
-  store %"any*" %98, ptr %99, align 16
-  %100 = call i64 @std.io.printfn(ptr %retparam40, ptr @.str.5, i64 8, ptr %varargslots34, i64 3)
-  store [13 x i8] c"\03\00\00\00\00\00\00\00\00\00\00\00\00", ptr %taddr41, align 1
-  %101 = load i104, ptr %b3, align 1
-  %102 = load i104, ptr %taddr41, align 1
-  %xor42 = xor i104 %101, %102
-  store i104 %xor42, ptr %2, align 1
+  %65 = load i8, ptr %b3, align 1
+  %66 = trunc i8 %65 to i1
+  %67 = zext i1 %66 to i8
+  store i8 %67, ptr %taddr41, align 1
+  %68 = insertvalue %"any*" undef, ptr %taddr41, 0
+  %69 = insertvalue %"any*" %68, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  store %"any*" %69, ptr %varargslots40, align 16
+  %70 = load i8, ptr %b3, align 1
+  %lshrl42 = lshr i8 %70, 1
+  %71 = trunc i8 %lshrl42 to i1
+  %72 = zext i1 %71 to i8
+  store i8 %72, ptr %taddr43, align 1
+  %73 = insertvalue %"any*" undef, ptr %taddr43, 0
+  %74 = insertvalue %"any*" %73, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  %ptradd44 = getelementptr inbounds i8, ptr %varargslots40, i64 16
+  store %"any*" %74, ptr %ptradd44, align 16
+  %ptradd45 = getelementptr inbounds i8, ptr %b3, i64 3
+  %75 = load i8, ptr %ptradd45, align 1
+  %lshrl46 = lshr i8 %75, 1
+  %76 = trunc i8 %lshrl46 to i1
+  %77 = zext i1 %76 to i8
+  store i8 %77, ptr %taddr47, align 1
+  %78 = insertvalue %"any*" undef, ptr %taddr47, 0
+  %79 = insertvalue %"any*" %78, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  %ptradd48 = getelementptr inbounds i8, ptr %varargslots40, i64 32
+  store %"any*" %79, ptr %ptradd48, align 16
+  %80 = call i64 @std.io.printfn(ptr %retparam49, ptr @.str.5, i64 8, ptr %varargslots40, i64 3)
+  store [13 x i8] c"\03\00\00\00\00\00\00\00\00\00\00\00\00", ptr %taddr50, align 1
+  %81 = load i104, ptr %b3, align 1
+  %82 = load i104, ptr %taddr50, align 1
+  %xor51 = xor i104 %81, %82
+  store i104 %xor51, ptr %2, align 1
   call void @llvm.memcpy.p0.p0.i32(ptr align 1 %b3, ptr align 1 %2, i32 13, i1 false)
-  %103 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
-  %104 = load i8, ptr %103, align 1
-  %105 = trunc i8 %104 to i1
-  %106 = zext i1 %105 to i8
-  store i8 %106, ptr %taddr44, align 1
-  %107 = insertvalue %"any*" undef, ptr %taddr44, 0
-  %108 = insertvalue %"any*" %107, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %109 = getelementptr inbounds [3 x %"any*"], ptr %varargslots43, i64 0, i64 0
-  store %"any*" %108, ptr %109, align 16
-  %110 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
-  %111 = load i8, ptr %110, align 1
-  %lshrl45 = lshr i8 %111, 1
-  %112 = trunc i8 %lshrl45 to i1
-  %113 = zext i1 %112 to i8
-  store i8 %113, ptr %taddr46, align 1
-  %114 = insertvalue %"any*" undef, ptr %taddr46, 0
-  %115 = insertvalue %"any*" %114, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %116 = getelementptr inbounds [3 x %"any*"], ptr %varargslots43, i64 0, i64 1
-  store %"any*" %115, ptr %116, align 16
-  %117 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 3
-  %118 = load i8, ptr %117, align 1
-  %lshrl47 = lshr i8 %118, 1
-  %119 = trunc i8 %lshrl47 to i1
-  %120 = zext i1 %119 to i8
-  store i8 %120, ptr %taddr48, align 1
-  %121 = insertvalue %"any*" undef, ptr %taddr48, 0
-  %122 = insertvalue %"any*" %121, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %123 = getelementptr inbounds [3 x %"any*"], ptr %varargslots43, i64 0, i64 2
-  store %"any*" %122, ptr %123, align 16
-  %124 = call i64 @std.io.printfn(ptr %retparam49, ptr @.str.6, i64 8, ptr %varargslots43, i64 3)
+  %83 = load i8, ptr %b3, align 1
+  %84 = trunc i8 %83 to i1
+  %85 = zext i1 %84 to i8
+  store i8 %85, ptr %taddr53, align 1
+  %86 = insertvalue %"any*" undef, ptr %taddr53, 0
+  %87 = insertvalue %"any*" %86, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  store %"any*" %87, ptr %varargslots52, align 16
+  %88 = load i8, ptr %b3, align 1
+  %lshrl54 = lshr i8 %88, 1
+  %89 = trunc i8 %lshrl54 to i1
+  %90 = zext i1 %89 to i8
+  store i8 %90, ptr %taddr55, align 1
+  %91 = insertvalue %"any*" undef, ptr %taddr55, 0
+  %92 = insertvalue %"any*" %91, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  %ptradd56 = getelementptr inbounds i8, ptr %varargslots52, i64 16
+  store %"any*" %92, ptr %ptradd56, align 16
+  %ptradd57 = getelementptr inbounds i8, ptr %b3, i64 3
+  %93 = load i8, ptr %ptradd57, align 1
+  %lshrl58 = lshr i8 %93, 1
+  %94 = trunc i8 %lshrl58 to i1
+  %95 = zext i1 %94 to i8
+  store i8 %95, ptr %taddr59, align 1
+  %96 = insertvalue %"any*" undef, ptr %taddr59, 0
+  %97 = insertvalue %"any*" %96, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  %ptradd60 = getelementptr inbounds i8, ptr %varargslots52, i64 32
+  store %"any*" %97, ptr %ptradd60, align 16
+  %98 = call i64 @std.io.printfn(ptr %retparam61, ptr @.str.6, i64 8, ptr %varargslots52, i64 3)
   ret void
 }