c3c/test/test_suite/bitstruct/bitstruct_initializer.c3t

// #target: macos-x64
module test;
import std::io;

bitstruct Foo : ulong
{
	uint x : 0..31;
	uint y : 32..62;
	bool w : 63;
}

bitstruct Bar : char[8]
{
	uint x : 0..31;
	uint y : 32..62;
	bool w : 63;
}
struct Abc
{
	int x;
	Foo b;
}

fn void hello(int z)
{
	Foo x;
	x = { .x = z, .w = z < 100 };
	Abc y = { .b.x = 32, .b.y = 10 };
	Abc d = { .b = { 23, 11, true } };
	Bar b;
	b = { .x = z, .w = z < 100 };
	io::printfn("%s %s %s", x.x, x.y, x.w);
	io::printfn("%s %s %s", y.b.x, y.b.y, y.b.w);
	io::printfn("%s %s %s", b.x, b.y, b.w);
	x = { z + 1, 1, z > 100 };
	y.b = { 33, 11, true };
	b = {  z + 1, 1, z > 100 };
	io::printfn("%s %s %s", x.x, x.y, x.w);
    io::printfn("%s %s %s", y.b.x, y.b.y, y.b.w);
    io::printfn("%s %s %s", b.x, b.y, b.w);

}

fn void main()
{
	hello(12);
}

/* #expect: test.ll

define void @test.hello(i32 %0) #0 {
entry:
  %x = alloca i64, align 8
  %y = alloca %Abc, align 8
  %d = alloca %Abc, align 8
  %b = alloca [8 x i8], align 1
  %varargslots = alloca [3 x %"any*"], align 16
  %taddr = alloca i32, align 4
  %taddr13 = alloca i32, align 4
  %taddr16 = alloca i8, align 1
  %retparam = alloca i64, align 8
  %varargslots17 = alloca [3 x %"any*"], align 16
  %taddr19 = alloca i32, align 4
  %taddr22 = alloca i32, align 4
  %taddr25 = alloca i8, align 1
  %retparam26 = alloca i64, align 8
  %varargslots27 = alloca [3 x %"any*"], align 16
  %taddr35 = alloca i32, align 4
  %taddr43 = alloca i32, align 4
  %taddr45 = alloca i8, align 1
  %retparam46 = alloca i64, align 8
  %varargslots61 = alloca [3 x %"any*"], align 16
  %taddr63 = alloca i32, align 4
  %taddr66 = alloca i32, align 4
  %taddr69 = alloca i8, align 1
  %retparam70 = alloca i64, align 8
  %varargslots71 = alloca [3 x %"any*"], align 16
  %taddr73 = alloca i32, align 4
  %taddr76 = alloca i32, align 4
  %taddr79 = alloca i8, align 1
  %retparam80 = alloca i64, align 8
  %varargslots81 = alloca [3 x %"any*"], align 16
  %taddr89 = alloca i32, align 4
  %taddr97 = alloca i32, align 4
  %taddr99 = alloca i8, align 1
  %retparam100 = alloca i64, align 8
  store i64 0, ptr %x, align 8
  %zext = zext i32 %0 to i64
  %1 = and i64 %zext, 4294967295
  %lt = icmp slt i32 %0, 100
  %2 = zext i1 %lt to i8
  %zext1 = zext i8 %2 to i64
  %shl = shl i64 %zext1, 63
  %3 = and i64 %shl, -9223372036854775808
  %4 = and i64 %1, 9223372036854775807
  %5 = or i64 %4, %3
  store i64 %5, ptr %x, align 8
  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %y, ptr align 8 @.__const, i32 16, i1 false)
  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %d, ptr align 8 @.__const.1, i32 16, i1 false)
  %6 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
  store i8 0, ptr %6, align 1
  %7 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
  store i8 0, ptr %7, align 1
  %8 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
  store i8 0, ptr %8, align 1
  %9 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
  store i8 0, ptr %9, align 1
  %10 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
  store i8 0, ptr %10, align 1
  %11 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
  store i8 0, ptr %11, align 1
  %12 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6
  store i8 0, ptr %12, align 1
  %13 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
  store i8 0, ptr %13, align 1
  %14 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
  store i8 0, ptr %14, align 1
  %15 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
  store i8 0, ptr %15, align 1
  %16 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
  store i8 0, ptr %16, align 1
  %17 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
  store i8 0, ptr %17, align 1
  %18 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
  store i8 0, ptr %18, align 1
  %19 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
  store i8 0, ptr %19, align 1
  %20 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6
  store i8 0, ptr %20, align 1
  %21 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
  store i8 0, ptr %21, align 1
  %22 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
  %trunc = trunc i32 %0 to i8
  store i8 %trunc, ptr %22, align 1
  %lshrl = lshr i32 %0, 8
  %23 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
  %trunc2 = trunc i32 %lshrl to i8
  store i8 %trunc2, ptr %23, align 1
  %lshrl3 = lshr i32 %lshrl, 8
  %24 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
  %trunc4 = trunc i32 %lshrl3 to i8
  store i8 %trunc4, ptr %24, align 1
  %lshrl5 = lshr i32 %lshrl3, 8
  %25 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
  %trunc6 = trunc i32 %lshrl5 to i8
  store i8 %trunc6, ptr %25, align 1
  %lshrl7 = lshr i32 %lshrl5, 8
  %lt8 = icmp slt i32 %0, 100
  %26 = zext i1 %lt8 to i8
  %shl9 = shl i8 %26, 7
  %27 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
  %28 = load i8, ptr %27, align 1
  %29 = and i8 %28, 127
  %30 = or i8 %29, %shl9
  store i8 %30, ptr %27, align 1
  %31 = load i64, ptr %x, align 8
  %32 = and i64 4294967295, %31
  %trunc10 = trunc i64 %32 to i32
  store i32 %trunc10, ptr %taddr, align 4
  %33 = insertvalue %"any*" undef, ptr %taddr, 0
  %34 = insertvalue %"any*" %33, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %35 = getelementptr inbounds [3 x %"any*"], ptr %varargslots, i64 0, i64 0
  store %"any*" %34, ptr %35, align 16
  %36 = load i64, ptr %x, align 8
  %lshrl11 = lshr i64 %36, 32
  %37 = and i64 2147483647, %lshrl11
  %trunc12 = trunc i64 %37 to i32
  store i32 %trunc12, ptr %taddr13, align 4
  %38 = insertvalue %"any*" undef, ptr %taddr13, 0
  %39 = insertvalue %"any*" %38, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %40 = getelementptr inbounds [3 x %"any*"], ptr %varargslots, i64 0, i64 1
  store %"any*" %39, ptr %40, align 16
  %41 = load i64, ptr %x, align 8
  %lshrl14 = lshr i64 %41, 63
  %42 = and i64 1, %lshrl14
  %trunc15 = trunc i64 %42 to i8
  store i8 %trunc15, ptr %taddr16, align 1
  %43 = insertvalue %"any*" undef, ptr %taddr16, 0
  %44 = insertvalue %"any*" %43, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %45 = getelementptr inbounds [3 x %"any*"], ptr %varargslots, i64 0, i64 2
  store %"any*" %44, ptr %45, align 16
  %46 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 3)
  %47 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
  %48 = load i64, ptr %47, align 8
  %49 = and i64 4294967295, %48
  %trunc18 = trunc i64 %49 to i32
  store i32 %trunc18, ptr %taddr19, align 4
  %50 = insertvalue %"any*" undef, ptr %taddr19, 0
  %51 = insertvalue %"any*" %50, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %52 = getelementptr inbounds [3 x %"any*"], ptr %varargslots17, i64 0, i64 0
  store %"any*" %51, ptr %52, align 16
  %53 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
  %54 = load i64, ptr %53, align 8
  %lshrl20 = lshr i64 %54, 32
  %55 = and i64 2147483647, %lshrl20
  %trunc21 = trunc i64 %55 to i32
  store i32 %trunc21, ptr %taddr22, align 4
  %56 = insertvalue %"any*" undef, ptr %taddr22, 0
  %57 = insertvalue %"any*" %56, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %58 = getelementptr inbounds [3 x %"any*"], ptr %varargslots17, i64 0, i64 1
  store %"any*" %57, ptr %58, align 16
  %59 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
  %60 = load i64, ptr %59, align 8
  %lshrl23 = lshr i64 %60, 63
  %61 = and i64 1, %lshrl23
  %trunc24 = trunc i64 %61 to i8
  store i8 %trunc24, ptr %taddr25, align 1
  %62 = insertvalue %"any*" undef, ptr %taddr25, 0
  %63 = insertvalue %"any*" %62, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %64 = getelementptr inbounds [3 x %"any*"], ptr %varargslots17, i64 0, i64 2
  store %"any*" %63, ptr %64, align 16
  %65 = call i64 @std.io.printfn(ptr %retparam26, ptr @.str.2, i64 8, ptr %varargslots17, i64 3)
  %66 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
  %67 = load i8, ptr %66, align 1
  %zext28 = zext i8 %67 to i32
  %68 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
  %69 = load i8, ptr %68, align 1
  %zext29 = zext i8 %69 to i32
  %shl30 = shl i32 %zext29, 8
  %70 = or i32 %shl30, %zext28
  %71 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
  %72 = load i8, ptr %71, align 1
  %zext31 = zext i8 %72 to i32
  %shl32 = shl i32 %zext31, 16
  %73 = or i32 %shl32, %70
  %74 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
  %75 = load i8, ptr %74, align 1
  %zext33 = zext i8 %75 to i32
  %shl34 = shl i32 %zext33, 24
  %76 = or i32 %shl34, %73
  store i32 %76, ptr %taddr35, align 4
  %77 = insertvalue %"any*" undef, ptr %taddr35, 0
  %78 = insertvalue %"any*" %77, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %79 = getelementptr inbounds [3 x %"any*"], ptr %varargslots27, i64 0, i64 0
  store %"any*" %78, ptr %79, align 16
  %80 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
  %81 = load i8, ptr %80, align 1
  %zext36 = zext i8 %81 to i32
  %82 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
  %83 = load i8, ptr %82, align 1
  %zext37 = zext i8 %83 to i32
  %shl38 = shl i32 %zext37, 8
  %84 = or i32 %shl38, %zext36
  %85 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6
  %86 = load i8, ptr %85, align 1
  %zext39 = zext i8 %86 to i32
  %shl40 = shl i32 %zext39, 16
  %87 = or i32 %shl40, %84
  %88 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
  %89 = load i8, ptr %88, align 1
  %zext41 = zext i8 %89 to i32
  %shl42 = shl i32 %zext41, 24
  %90 = or i32 %shl42, %87
  %91 = and i32 2147483647, %90
  store i32 %91, ptr %taddr43, align 4
  %92 = insertvalue %"any*" undef, ptr %taddr43, 0
  %93 = insertvalue %"any*" %92, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %94 = getelementptr inbounds [3 x %"any*"], ptr %varargslots27, i64 0, i64 1
  store %"any*" %93, ptr %94, align 16
  %95 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
  %96 = load i8, ptr %95, align 1
  %lshrl44 = lshr i8 %96, 7
  %97 = trunc i8 %lshrl44 to i1
  %98 = zext i1 %97 to i8
  store i8 %98, ptr %taddr45, align 1
  %99 = insertvalue %"any*" undef, ptr %taddr45, 0
  %100 = insertvalue %"any*" %99, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %101 = getelementptr inbounds [3 x %"any*"], ptr %varargslots27, i64 0, i64 2
  store %"any*" %100, ptr %101, align 16
  %102 = call i64 @std.io.printfn(ptr %retparam46, ptr @.str.3, i64 8, ptr %varargslots27, i64 3)
  %add = add i32 %0, 1
  %zext47 = zext i32 %add to i64
  %103 = and i64 %zext47, 4294967295
  %104 = and i64 %103, -9223372032559808513
  %105 = or i64 %104, 4294967296
  %gt = icmp sgt i32 %0, 100
  %106 = zext i1 %gt to i8
  %zext48 = zext i8 %106 to i64
  %shl49 = shl i64 %zext48, 63
  %107 = and i64 %shl49, -9223372036854775808
  %108 = and i64 %105, 9223372036854775807
  %109 = or i64 %108, %107
  store i64 %109, ptr %x, align 8
  %110 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
  store i64 -9223371989610135519, ptr %110, align 8
  %111 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
  store i8 0, ptr %111, align 1
  %112 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
  store i8 0, ptr %112, align 1
  %113 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
  store i8 0, ptr %113, align 1
  %114 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
  store i8 0, ptr %114, align 1
  %115 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
  store i8 0, ptr %115, align 1
  %116 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
  store i8 0, ptr %116, align 1
  %117 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6
  store i8 0, ptr %117, align 1
  %118 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
  store i8 0, ptr %118, align 1
  %add50 = add i32 %0, 1
  %119 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
  %trunc51 = trunc i32 %add50 to i8
  store i8 %trunc51, ptr %119, align 1
  %lshrl52 = lshr i32 %add50, 8
  %120 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
  %trunc53 = trunc i32 %lshrl52 to i8
  store i8 %trunc53, ptr %120, align 1
  %lshrl54 = lshr i32 %lshrl52, 8
  %121 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
  %trunc55 = trunc i32 %lshrl54 to i8
  store i8 %trunc55, ptr %121, align 1
  %lshrl56 = lshr i32 %lshrl54, 8
  %122 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
  %trunc57 = trunc i32 %lshrl56 to i8
  store i8 %trunc57, ptr %122, align 1
  %lshrl58 = lshr i32 %lshrl56, 8
  %123 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
  store i8 1, ptr %123, align 1
  %124 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
  store i8 0, ptr %124, align 1
  %125 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6
  store i8 0, ptr %125, align 1
  %126 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
  %127 = load i8, ptr %126, align 1
  %128 = and i8 %127, -128
  store i8 %128, ptr %126, align 1
  %gt59 = icmp sgt i32 %0, 100
  %129 = zext i1 %gt59 to i8
  %shl60 = shl i8 %129, 7
  %130 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
  %131 = load i8, ptr %130, align 1
  %132 = and i8 %131, 127
  %133 = or i8 %132, %shl60
  store i8 %133, ptr %130, align 1
  %134 = load i64, ptr %x, align 8
  %135 = and i64 4294967295, %134
  %trunc62 = trunc i64 %135 to i32
  store i32 %trunc62, ptr %taddr63, align 4
  %136 = insertvalue %"any*" undef, ptr %taddr63, 0
  %137 = insertvalue %"any*" %136, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %138 = getelementptr inbounds [3 x %"any*"], ptr %varargslots61, i64 0, i64 0
  store %"any*" %137, ptr %138, align 16
  %139 = load i64, ptr %x, align 8
  %lshrl64 = lshr i64 %139, 32
  %140 = and i64 2147483647, %lshrl64
  %trunc65 = trunc i64 %140 to i32
  store i32 %trunc65, ptr %taddr66, align 4
  %141 = insertvalue %"any*" undef, ptr %taddr66, 0
  %142 = insertvalue %"any*" %141, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %143 = getelementptr inbounds [3 x %"any*"], ptr %varargslots61, i64 0, i64 1
  store %"any*" %142, ptr %143, align 16
  %144 = load i64, ptr %x, align 8
  %lshrl67 = lshr i64 %144, 63
  %145 = and i64 1, %lshrl67
  %trunc68 = trunc i64 %145 to i8
  store i8 %trunc68, ptr %taddr69, align 1
  %146 = insertvalue %"any*" undef, ptr %taddr69, 0
  %147 = insertvalue %"any*" %146, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %148 = getelementptr inbounds [3 x %"any*"], ptr %varargslots61, i64 0, i64 2
  store %"any*" %147, ptr %148, align 16
  %149 = call i64 @std.io.printfn(ptr %retparam70, ptr @.str.4, i64 8, ptr %varargslots61, i64 3)
  %150 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
  %151 = load i64, ptr %150, align 8
  %152 = and i64 4294967295, %151
  %trunc72 = trunc i64 %152 to i32
  store i32 %trunc72, ptr %taddr73, align 4
  %153 = insertvalue %"any*" undef, ptr %taddr73, 0
  %154 = insertvalue %"any*" %153, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %155 = getelementptr inbounds [3 x %"any*"], ptr %varargslots71, i64 0, i64 0
  store %"any*" %154, ptr %155, align 16
  %156 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
  %157 = load i64, ptr %156, align 8
  %lshrl74 = lshr i64 %157, 32
  %158 = and i64 2147483647, %lshrl74
  %trunc75 = trunc i64 %158 to i32
  store i32 %trunc75, ptr %taddr76, align 4
  %159 = insertvalue %"any*" undef, ptr %taddr76, 0
  %160 = insertvalue %"any*" %159, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %161 = getelementptr inbounds [3 x %"any*"], ptr %varargslots71, i64 0, i64 1
  store %"any*" %160, ptr %161, align 16
  %162 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
  %163 = load i64, ptr %162, align 8
  %lshrl77 = lshr i64 %163, 63
  %164 = and i64 1, %lshrl77
  %trunc78 = trunc i64 %164 to i8
  store i8 %trunc78, ptr %taddr79, align 1
  %165 = insertvalue %"any*" undef, ptr %taddr79, 0
  %166 = insertvalue %"any*" %165, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %167 = getelementptr inbounds [3 x %"any*"], ptr %varargslots71, i64 0, i64 2
  store %"any*" %166, ptr %167, align 16
  %168 = call i64 @std.io.printfn(ptr %retparam80, ptr @.str.5, i64 8, ptr %varargslots71, i64 3)
  %169 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
  %170 = load i8, ptr %169, align 1
  %zext82 = zext i8 %170 to i32
  %171 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
  %172 = load i8, ptr %171, align 1
  %zext83 = zext i8 %172 to i32
  %shl84 = shl i32 %zext83, 8
  %173 = or i32 %shl84, %zext82
  %174 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
  %175 = load i8, ptr %174, align 1
  %zext85 = zext i8 %175 to i32
  %shl86 = shl i32 %zext85, 16
  %176 = or i32 %shl86, %173
  %177 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
  %178 = load i8, ptr %177, align 1
  %zext87 = zext i8 %178 to i32
  %shl88 = shl i32 %zext87, 24
  %179 = or i32 %shl88, %176
  store i32 %179, ptr %taddr89, align 4
  %180 = insertvalue %"any*" undef, ptr %taddr89, 0
  %181 = insertvalue %"any*" %180, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %182 = getelementptr inbounds [3 x %"any*"], ptr %varargslots81, i64 0, i64 0
  store %"any*" %181, ptr %182, align 16
  %183 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
  %184 = load i8, ptr %183, align 1
  %zext90 = zext i8 %184 to i32
  %185 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
  %186 = load i8, ptr %185, align 1
  %zext91 = zext i8 %186 to i32
  %shl92 = shl i32 %zext91, 8
  %187 = or i32 %shl92, %zext90
  %188 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6
  %189 = load i8, ptr %188, align 1
  %zext93 = zext i8 %189 to i32
  %shl94 = shl i32 %zext93, 16
  %190 = or i32 %shl94, %187
  %191 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
  %192 = load i8, ptr %191, align 1
  %zext95 = zext i8 %192 to i32
  %shl96 = shl i32 %zext95, 24
  %193 = or i32 %shl96, %190
  %194 = and i32 2147483647, %193
  store i32 %194, ptr %taddr97, align 4
  %195 = insertvalue %"any*" undef, ptr %taddr97, 0
  %196 = insertvalue %"any*" %195, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %197 = getelementptr inbounds [3 x %"any*"], ptr %varargslots81, i64 0, i64 1
  store %"any*" %196, ptr %197, align 16
  %198 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
  %199 = load i8, ptr %198, align 1
  %lshrl98 = lshr i8 %199, 7
  %200 = trunc i8 %lshrl98 to i1
  %201 = zext i1 %200 to i8
  store i8 %201, ptr %taddr99, align 1
  %202 = insertvalue %"any*" undef, ptr %taddr99, 0
  %203 = insertvalue %"any*" %202, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %204 = getelementptr inbounds [3 x %"any*"], ptr %varargslots81, i64 0, i64 2
  store %"any*" %203, ptr %204, align 16
  %205 = call i64 @std.io.printfn(ptr %retparam100, ptr @.str.6, i64 8, ptr %varargslots81, i64 3)
  ret void
}

; Function Attrs: nounwind
define void @test.main() #0 {
entry:
  call void @test.hello(i32 12)
  ret void
}