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
  %retparam = alloca i64, align 8
  %varargslots = alloca [3 x %variant], align 16
  %taddr = alloca i32, align 4
  %taddr13 = alloca i32, align 4
  %taddr16 = alloca i8, align 1
  %retparam17 = alloca i64, align 8
  %varargslots18 = alloca [3 x %variant], align 16
  %taddr20 = alloca i32, align 4
  %taddr23 = alloca i32, align 4
  %taddr26 = alloca i8, align 1
  %retparam27 = alloca i64, align 8
  %varargslots28 = alloca [3 x %variant], align 16
  %taddr36 = alloca i32, align 4
  %taddr44 = alloca i32, align 4
  %taddr46 = alloca i8, align 1
  %retparam61 = alloca i64, align 8
  %varargslots62 = alloca [3 x %variant], align 16
  %taddr64 = alloca i32, align 4
  %taddr67 = alloca i32, align 4
  %taddr70 = alloca i8, align 1
  %retparam71 = alloca i64, align 8
  %varargslots72 = alloca [3 x %variant], align 16
  %taddr74 = alloca i32, align 4
  %taddr77 = alloca i32, align 4
  %taddr80 = alloca i8, align 1
  %retparam81 = alloca i64, align 8
  %varargslots82 = alloca [3 x %variant], align 16
  %taddr90 = alloca i32, align 4
  %taddr98 = alloca i32, align 4
  %taddr100 = alloca i8, align 1
  store i64 0, ptr %x, align 8
  %zext = zext i32 %0 to i64
  %1 = and i64 %zext, 4294967295
  %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
  %ztrunc = trunc i32 %0 to i8
  store i8 %ztrunc, ptr %22, align 1
  %lshrl = lshr i32 %0, 8
  %23 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
  %ztrunc2 = trunc i32 %lshrl to i8
  store i8 %ztrunc2, ptr %23, align 1
  %lshrl3 = lshr i32 %lshrl, 8
  %24 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
  %ztrunc4 = trunc i32 %lshrl3 to i8
  store i8 %ztrunc4, ptr %24, align 1
  %lshrl5 = lshr i32 %lshrl3, 8
  %25 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
  %ztrunc6 = trunc i32 %lshrl5 to i8
  store i8 %ztrunc6, 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
  %ztrunc10 = trunc i64 %32 to i32
  store i32 %ztrunc10, ptr %taddr, align 4
  %33 = insertvalue %variant undef, ptr %taddr, 0
  %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %35 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 0
  store %variant %34, ptr %35, align 16
  %36 = load i64, ptr %x, align 8
  %lshrl11 = lshr i64 %36, 32
  %37 = and i64 2147483647, %lshrl11
  %ztrunc12 = trunc i64 %37 to i32
  store i32 %ztrunc12, ptr %taddr13, align 4
  %38 = insertvalue %variant undef, ptr %taddr13, 0
  %39 = insertvalue %variant %38, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %40 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 1
  store %variant %39, ptr %40, align 16
  %41 = load i64, ptr %x, align 8
  %lshrl14 = lshr i64 %41, 63
  %42 = and i64 1, %lshrl14
  %ztrunc15 = trunc i64 %42 to i8
  store i8 %ztrunc15, ptr %taddr16, align 1
  %43 = insertvalue %variant undef, ptr %taddr16, 0
  %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %45 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 2
  store %variant %44, ptr %45, align 16
  %46 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 3)
  %47 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
  %48 = load i64, ptr %47, align 8
  %49 = and i64 4294967295, %48
  %ztrunc19 = trunc i64 %49 to i32
  store i32 %ztrunc19, ptr %taddr20, align 4
  %50 = insertvalue %variant undef, ptr %taddr20, 0
  %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %52 = getelementptr inbounds [3 x %variant], ptr %varargslots18, i64 0, i64 0
  store %variant %51, ptr %52, align 16
  %53 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
  %54 = load i64, ptr %53, align 8
  %lshrl21 = lshr i64 %54, 32
  %55 = and i64 2147483647, %lshrl21
  %ztrunc22 = trunc i64 %55 to i32
  store i32 %ztrunc22, ptr %taddr23, align 4
  %56 = insertvalue %variant undef, ptr %taddr23, 0
  %57 = insertvalue %variant %56, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %58 = getelementptr inbounds [3 x %variant], ptr %varargslots18, i64 0, i64 1
  store %variant %57, ptr %58, align 16
  %59 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
  %60 = load i64, ptr %59, align 8
  %lshrl24 = lshr i64 %60, 63
  %61 = and i64 1, %lshrl24
  %ztrunc25 = trunc i64 %61 to i8
  store i8 %ztrunc25, ptr %taddr26, align 1
  %62 = insertvalue %variant undef, ptr %taddr26, 0
  %63 = insertvalue %variant %62, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %64 = getelementptr inbounds [3 x %variant], ptr %varargslots18, i64 0, i64 2
  store %variant %63, ptr %64, align 16
  %65 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.2, i64 8, ptr %varargslots18, i64 3)
  %66 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
  %67 = load i8, ptr %66, align 1
  %zext29 = zext i8 %67 to i32
  %68 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
  %69 = load i8, ptr %68, align 1
  %zext30 = zext i8 %69 to i32
  %shl31 = shl i32 %zext30, 8
  %70 = or i32 %shl31, %zext29
  %71 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
  %72 = load i8, ptr %71, align 1
  %zext32 = zext i8 %72 to i32
  %shl33 = shl i32 %zext32, 16
  %73 = or i32 %shl33, %70
  %74 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
  %75 = load i8, ptr %74, align 1
  %zext34 = zext i8 %75 to i32
  %shl35 = shl i32 %zext34, 24
  %76 = or i32 %shl35, %73
  store i32 %76, ptr %taddr36, align 4
  %77 = insertvalue %variant undef, ptr %taddr36, 0
  %78 = insertvalue %variant %77, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %79 = getelementptr inbounds [3 x %variant], ptr %varargslots28, i64 0, i64 0
  store %variant %78, ptr %79, align 16
  %80 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
  %81 = load i8, ptr %80, align 1
  %zext37 = zext i8 %81 to i32
  %82 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
  %83 = load i8, ptr %82, align 1
  %zext38 = zext i8 %83 to i32
  %shl39 = shl i32 %zext38, 8
  %84 = or i32 %shl39, %zext37
  %85 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6
  %86 = load i8, ptr %85, align 1
  %zext40 = zext i8 %86 to i32
  %shl41 = shl i32 %zext40, 16
  %87 = or i32 %shl41, %84
  %88 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
  %89 = load i8, ptr %88, align 1
  %zext42 = zext i8 %89 to i32
  %shl43 = shl i32 %zext42, 24
  %90 = or i32 %shl43, %87
  %91 = and i32 2147483647, %90
  store i32 %91, ptr %taddr44, align 4
  %92 = insertvalue %variant undef, ptr %taddr44, 0
  %93 = insertvalue %variant %92, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %94 = getelementptr inbounds [3 x %variant], ptr %varargslots28, i64 0, i64 1
  store %variant %93, ptr %94, align 16
  %95 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
  %96 = load i8, ptr %95, align 1
  %lshrl45 = lshr i8 %96, 7
  %97 = trunc i8 %lshrl45 to i1
  %98 = zext i1 %97 to i8
  store i8 %98, ptr %taddr46, align 1
  %99 = insertvalue %variant undef, ptr %taddr46, 0
  %100 = insertvalue %variant %99, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %101 = getelementptr inbounds [3 x %variant], ptr %varargslots28, i64 0, i64 2
  store %variant %100, ptr %101, align 16
  %102 = call i64 @std.io.printfn(ptr %retparam27, ptr @.str.3, i64 8, ptr %varargslots28, 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
  %ztrunc51 = trunc i32 %add50 to i8
  store i8 %ztrunc51, ptr %119, align 1
  %lshrl52 = lshr i32 %add50, 8
  %120 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
  %ztrunc53 = trunc i32 %lshrl52 to i8
  store i8 %ztrunc53, ptr %120, align 1
  %lshrl54 = lshr i32 %lshrl52, 8
  %121 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
  %ztrunc55 = trunc i32 %lshrl54 to i8
  store i8 %ztrunc55, ptr %121, align 1
  %lshrl56 = lshr i32 %lshrl54, 8
  %122 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
  %ztrunc57 = trunc i32 %lshrl56 to i8
  store i8 %ztrunc57, ptr %122, align 1
  %lshrl58 = lshr i32 %lshrl56, 8
  %123 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
  store i8 1, ptr %123, align 1
  %124 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
  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
  %ztrunc63 = trunc i64 %135 to i32
  store i32 %ztrunc63, ptr %taddr64, align 4
  %136 = insertvalue %variant undef, ptr %taddr64, 0
  %137 = insertvalue %variant %136, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %138 = getelementptr inbounds [3 x %variant], ptr %varargslots62, i64 0, i64 0
  store %variant %137, ptr %138, align 16
  %139 = load i64, ptr %x, align 8
  %lshrl65 = lshr i64 %139, 32
  %140 = and i64 2147483647, %lshrl65
  %ztrunc66 = trunc i64 %140 to i32
  store i32 %ztrunc66, ptr %taddr67, align 4
  %141 = insertvalue %variant undef, ptr %taddr67, 0
  %142 = insertvalue %variant %141, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %143 = getelementptr inbounds [3 x %variant], ptr %varargslots62, i64 0, i64 1
  store %variant %142, ptr %143, align 16
  %144 = load i64, ptr %x, align 8
  %lshrl68 = lshr i64 %144, 63
  %145 = and i64 1, %lshrl68
  %ztrunc69 = trunc i64 %145 to i8
  store i8 %ztrunc69, ptr %taddr70, align 1
  %146 = insertvalue %variant undef, ptr %taddr70, 0
  %147 = insertvalue %variant %146, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %148 = getelementptr inbounds [3 x %variant], ptr %varargslots62, i64 0, i64 2
  store %variant %147, ptr %148, align 16
  %149 = call i64 @std.io.printfn(ptr %retparam61, ptr @.str.4, i64 8, ptr %varargslots62, i64 3)
  %150 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
  %151 = load i64, ptr %150, align 8
  %152 = and i64 4294967295, %151
  %ztrunc73 = trunc i64 %152 to i32
  store i32 %ztrunc73, ptr %taddr74, align 4
  %153 = insertvalue %variant undef, ptr %taddr74, 0
  %154 = insertvalue %variant %153, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %155 = getelementptr inbounds [3 x %variant], ptr %varargslots72, i64 0, i64 0
  store %variant %154, ptr %155, align 16
  %156 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
  %157 = load i64, ptr %156, align 8
  %lshrl75 = lshr i64 %157, 32
  %158 = and i64 2147483647, %lshrl75
  %ztrunc76 = trunc i64 %158 to i32
  store i32 %ztrunc76, ptr %taddr77, align 4
  %159 = insertvalue %variant undef, ptr %taddr77, 0
  %160 = insertvalue %variant %159, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %161 = getelementptr inbounds [3 x %variant], ptr %varargslots72, i64 0, i64 1
  store %variant %160, ptr %161, align 16
  %162 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
  %163 = load i64, ptr %162, align 8
  %lshrl78 = lshr i64 %163, 63
  %164 = and i64 1, %lshrl78
  %ztrunc79 = trunc i64 %164 to i8
  store i8 %ztrunc79, ptr %taddr80, align 1
  %165 = insertvalue %variant undef, ptr %taddr80, 0
  %166 = insertvalue %variant %165, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %167 = getelementptr inbounds [3 x %variant], ptr %varargslots72, i64 0, i64 2
  store %variant %166, ptr %167, align 16
  %168 = call i64 @std.io.printfn(ptr %retparam71, ptr @.str.5, i64 8, ptr %varargslots72, i64 3)
  %169 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
  %170 = load i8, ptr %169, align 1
  %zext83 = zext i8 %170 to i32
  %171 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
  %172 = load i8, ptr %171, align 1
  %zext84 = zext i8 %172 to i32
  %shl85 = shl i32 %zext84, 8
  %173 = or i32 %shl85, %zext83
  %174 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
  %175 = load i8, ptr %174, align 1
  %zext86 = zext i8 %175 to i32
  %shl87 = shl i32 %zext86, 16
  %176 = or i32 %shl87, %173
  %177 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
  %178 = load i8, ptr %177, align 1
  %zext88 = zext i8 %178 to i32
  %shl89 = shl i32 %zext88, 24
  %179 = or i32 %shl89, %176
  store i32 %179, ptr %taddr90, align 4
  %180 = insertvalue %variant undef, ptr %taddr90, 0
  %181 = insertvalue %variant %180, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %182 = getelementptr inbounds [3 x %variant], ptr %varargslots82, i64 0, i64 0
  store %variant %181, ptr %182, align 16
  %183 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
  %184 = load i8, ptr %183, align 1
  %zext91 = zext i8 %184 to i32
  %185 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
  %186 = load i8, ptr %185, align 1
  %zext92 = zext i8 %186 to i32
  %shl93 = shl i32 %zext92, 8
  %187 = or i32 %shl93, %zext91
  %188 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6
  %189 = load i8, ptr %188, align 1
  %zext94 = zext i8 %189 to i32
  %shl95 = shl i32 %zext94, 16
  %190 = or i32 %shl95, %187
  %191 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
  %192 = load i8, ptr %191, align 1
  %zext96 = zext i8 %192 to i32
  %shl97 = shl i32 %zext96, 24
  %193 = or i32 %shl97, %190
  %194 = and i32 2147483647, %193
  store i32 %194, ptr %taddr98, align 4
  %195 = insertvalue %variant undef, ptr %taddr98, 0
  %196 = insertvalue %variant %195, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %197 = getelementptr inbounds [3 x %variant], ptr %varargslots82, i64 0, i64 1
  store %variant %196, ptr %197, align 16
  %198 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
  %199 = load i8, ptr %198, align 1
  %lshrl99 = lshr i8 %199, 7
  %200 = trunc i8 %lshrl99 to i1
  %201 = zext i1 %200 to i8
  store i8 %201, ptr %taddr100, align 1
  %202 = insertvalue %variant undef, ptr %taddr100, 0
  %203 = insertvalue %variant %202, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %204 = getelementptr inbounds [3 x %variant], ptr %varargslots82, i64 0, i64 2
  store %variant %203, ptr %204, align 16
  %205 = call i64 @std.io.printfn(ptr %retparam81, ptr @.str.6, i64 8, ptr %varargslots82, i64 3)
  ret void
}

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