// #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::printfln("%s %s %s", x.x, x.y, x.w);
	io::printfln("%s %s %s", y.b.x, y.b.y, y.b.w);
	io::printfln("%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::printfln("%s %s %s", x.x, x.y, x.w);
    io::printfln("%s %s %s", y.b.x, y.b.y, y.b.w);
    io::printfln("%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
  %taddr = alloca %"char[]", align 8
  %vararg = alloca %"variant[]", align 8
  %varargslots = alloca [3 x %variant], align 16
  %taddr11 = alloca i32, align 4
  %taddr14 = alloca i32, align 4
  %taddr17 = alloca i8, align 1
  %retparam20 = alloca i64, align 8
  %taddr21 = alloca %"char[]", align 8
  %vararg24 = alloca %"variant[]", align 8
  %varargslots25 = alloca [3 x %variant], align 16
  %taddr27 = alloca i32, align 4
  %taddr30 = alloca i32, align 4
  %taddr33 = alloca i8, align 1
  %retparam39 = alloca i64, align 8
  %taddr40 = alloca %"char[]", align 8
  %vararg43 = alloca %"variant[]", align 8
  %varargslots44 = alloca [3 x %variant], align 16
  %taddr52 = alloca i32, align 4
  %taddr60 = alloca i32, align 4
  %taddr62 = alloca i8, align 1
  %retparam82 = alloca i64, align 8
  %taddr83 = alloca %"char[]", align 8
  %vararg86 = alloca %"variant[]", align 8
  %varargslots87 = alloca [3 x %variant], align 16
  %taddr89 = alloca i32, align 4
  %taddr92 = alloca i32, align 4
  %taddr95 = alloca i8, align 1
  %retparam101 = alloca i64, align 8
  %taddr102 = alloca %"char[]", align 8
  %vararg105 = alloca %"variant[]", align 8
  %varargslots106 = alloca [3 x %variant], align 16
  %taddr108 = alloca i32, align 4
  %taddr111 = alloca i32, align 4
  %taddr114 = alloca i8, align 1
  %retparam120 = alloca i64, align 8
  %taddr121 = alloca %"char[]", align 8
  %vararg124 = alloca %"variant[]", align 8
  %varargslots125 = alloca [3 x %variant], align 16
  %taddr133 = alloca i32, align 4
  %taddr141 = alloca i32, align 4
  %taddr143 = alloca i8, align 1
  store i64 0, i64* %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, i64* %x, align 8
  %6 = bitcast %Abc* %y to i8*
  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %6, i8* align 8 bitcast (%Abc* @.__const to i8*), i32 16, i1 false)
  %7 = bitcast %Abc* %d to i8*
  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %7, i8* align 8 bitcast (%Abc* @.__const.1 to i8*), i32 16, i1 false)
  %8 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
  store i8 0, i8* %8, align 1
  %9 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
  store i8 0, i8* %9, align 1
  %10 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
  store i8 0, i8* %10, align 1
  %11 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
  store i8 0, i8* %11, align 1
  %12 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
  store i8 0, i8* %12, align 1
  %13 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
  store i8 0, i8* %13, align 1
  %14 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
  store i8 0, i8* %14, align 1
  %15 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
  store i8 0, i8* %15, align 1
  %16 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
  store i8 0, i8* %16, align 1
  %17 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
  store i8 0, i8* %17, align 1
  %18 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
  store i8 0, i8* %18, align 1
  %19 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
  store i8 0, i8* %19, align 1
  %20 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
  store i8 0, i8* %20, align 1
  %21 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
  store i8 0, i8* %21, align 1
  %22 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
  store i8 0, i8* %22, align 1
  %23 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
  store i8 0, i8* %23, align 1
  %24 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
  %ztrunc = trunc i32 %0 to i8
  store i8 %ztrunc, i8* %24, align 1
  %lshrl = lshr i32 %0, 8
  %25 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
  %ztrunc2 = trunc i32 %lshrl to i8
  store i8 %ztrunc2, i8* %25, align 1
  %lshrl3 = lshr i32 %lshrl, 8
  %26 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
  %ztrunc4 = trunc i32 %lshrl3 to i8
  store i8 %ztrunc4, i8* %26, align 1
  %lshrl5 = lshr i32 %lshrl3, 8
  %27 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
  %ztrunc6 = trunc i32 %lshrl5 to i8
  store i8 %ztrunc6, i8* %27, align 1
  %lshrl7 = lshr i32 %lshrl5, 8
  %lt8 = icmp slt i32 %0, 100
  %28 = zext i1 %lt8 to i8
  %shl9 = shl i8 %28, 7
  %29 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
  %30 = load i8, i8* %29, align 1
  %31 = and i8 %30, 127
  %32 = or i8 %31, %shl9
  store i8 %32, i8* %29, align 1
  store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i64 8 }, %"char[]"* %taddr, align 8
  %33 = bitcast %"char[]"* %taddr to { i8*, i64 }*
  %34 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %33, i32 0, i32 0
  %lo = load i8*, i8** %34, align 8
  %35 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %33, i32 0, i32 1
  %hi = load i64, i64* %35, align 8
  %36 = load i64, i64* %x, align 8
  %37 = and i64 4294967295, %36
  %ztrunc10 = trunc i64 %37 to i32
  store i32 %ztrunc10, i32* %taddr11, align 4
  %38 = bitcast i32* %taddr11 to i8*
  %39 = insertvalue %variant undef, i8* %38, 0
  %40 = insertvalue %variant %39, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
  %41 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 0
  store %variant %40, %variant* %41, align 16
  %42 = load i64, i64* %x, align 8
  %lshrl12 = lshr i64 %42, 32
  %43 = and i64 2147483647, %lshrl12
  %ztrunc13 = trunc i64 %43 to i32
  store i32 %ztrunc13, i32* %taddr14, align 4
  %44 = bitcast i32* %taddr14 to i8*
  %45 = insertvalue %variant undef, i8* %44, 0
  %46 = insertvalue %variant %45, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
  %47 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 1
  store %variant %46, %variant* %47, align 16
  %48 = load i64, i64* %x, align 8
  %lshrl15 = lshr i64 %48, 63
  %49 = and i64 1, %lshrl15
  %ztrunc16 = trunc i64 %49 to i8
  store i8 %ztrunc16, i8* %taddr17, align 1
  %50 = insertvalue %variant undef, i8* %taddr17, 0
  %51 = insertvalue %variant %50, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
  %52 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 2
  store %variant %51, %variant* %52, align 16
  %53 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1
  store i64 3, i64* %53, align 8
  %54 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0
  %55 = bitcast [3 x %variant]* %varargslots to %variant*
  store %variant* %55, %variant** %54, align 8
  %56 = bitcast %"variant[]"* %vararg to { i8*, i64 }*
  %57 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %56, i32 0, i32 0
  %lo18 = load i8*, i8** %57, align 8
  %58 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %56, i32 0, i32 1
  %hi19 = load i64, i64* %58, align 8
  %59 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo18, i64 %hi19)
  %not_err = icmp eq i64 %59, 0
  br i1 %not_err, label %after_check, label %voiderr

after_check:                                      ; preds = %entry
  br label %voiderr

voiderr:                                          ; preds = %after_check, %entry
  store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i32 0, i32 0), i64 8 }, %"char[]"* %taddr21, align 8
  %60 = bitcast %"char[]"* %taddr21 to { i8*, i64 }*
  %61 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 0
  %lo22 = load i8*, i8** %61, align 8
  %62 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 1
  %hi23 = load i64, i64* %62, align 8
  %63 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
  %64 = load i64, i64* %63, align 8
  %65 = and i64 4294967295, %64
  %ztrunc26 = trunc i64 %65 to i32
  store i32 %ztrunc26, i32* %taddr27, align 4
  %66 = bitcast i32* %taddr27 to i8*
  %67 = insertvalue %variant undef, i8* %66, 0
  %68 = insertvalue %variant %67, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
  %69 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots25, i64 0, i64 0
  store %variant %68, %variant* %69, align 16
  %70 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
  %71 = load i64, i64* %70, align 8
  %lshrl28 = lshr i64 %71, 32
  %72 = and i64 2147483647, %lshrl28
  %ztrunc29 = trunc i64 %72 to i32
  store i32 %ztrunc29, i32* %taddr30, align 4
  %73 = bitcast i32* %taddr30 to i8*
  %74 = insertvalue %variant undef, i8* %73, 0
  %75 = insertvalue %variant %74, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
  %76 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots25, i64 0, i64 1
  store %variant %75, %variant* %76, align 16
  %77 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
  %78 = load i64, i64* %77, align 8
  %lshrl31 = lshr i64 %78, 63
  %79 = and i64 1, %lshrl31
  %ztrunc32 = trunc i64 %79 to i8
  store i8 %ztrunc32, i8* %taddr33, align 1
  %80 = insertvalue %variant undef, i8* %taddr33, 0
  %81 = insertvalue %variant %80, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
  %82 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots25, i64 0, i64 2
  store %variant %81, %variant* %82, align 16
  %83 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg24, i32 0, i32 1
  store i64 3, i64* %83, align 8
  %84 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg24, i32 0, i32 0
  %85 = bitcast [3 x %variant]* %varargslots25 to %variant*
  store %variant* %85, %variant** %84, align 8
  %86 = bitcast %"variant[]"* %vararg24 to { i8*, i64 }*
  %87 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %86, i32 0, i32 0
  %lo34 = load i8*, i8** %87, align 8
  %88 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %86, i32 0, i32 1
  %hi35 = load i64, i64* %88, align 8
  %89 = call i64 @std_io_printfln(i64* %retparam20, i8* %lo22, i64 %hi23, i8* %lo34, i64 %hi35)
  %not_err36 = icmp eq i64 %89, 0
  br i1 %not_err36, label %after_check37, label %voiderr38

after_check37:                                    ; preds = %voiderr
  br label %voiderr38

voiderr38:                                        ; preds = %after_check37, %voiderr
  store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i32 0, i32 0), i64 8 }, %"char[]"* %taddr40, align 8
  %90 = bitcast %"char[]"* %taddr40 to { i8*, i64 }*
  %91 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %90, i32 0, i32 0
  %lo41 = load i8*, i8** %91, align 8
  %92 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %90, i32 0, i32 1
  %hi42 = load i64, i64* %92, align 8
  %93 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
  %94 = load i8, i8* %93, align 1
  %zext45 = zext i8 %94 to i32
  %95 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
  %96 = load i8, i8* %95, align 1
  %zext46 = zext i8 %96 to i32
  %shl47 = shl i32 %zext46, 8
  %97 = or i32 %shl47, %zext45
  %98 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
  %99 = load i8, i8* %98, align 1
  %zext48 = zext i8 %99 to i32
  %shl49 = shl i32 %zext48, 16
  %100 = or i32 %shl49, %97
  %101 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
  %102 = load i8, i8* %101, align 1
  %zext50 = zext i8 %102 to i32
  %shl51 = shl i32 %zext50, 24
  %103 = or i32 %shl51, %100
  store i32 %103, i32* %taddr52, align 4
  %104 = bitcast i32* %taddr52 to i8*
  %105 = insertvalue %variant undef, i8* %104, 0
  %106 = insertvalue %variant %105, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
  %107 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots44, i64 0, i64 0
  store %variant %106, %variant* %107, align 16
  %108 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
  %109 = load i8, i8* %108, align 1
  %zext53 = zext i8 %109 to i32
  %110 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
  %111 = load i8, i8* %110, align 1
  %zext54 = zext i8 %111 to i32
  %shl55 = shl i32 %zext54, 8
  %112 = or i32 %shl55, %zext53
  %113 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
  %114 = load i8, i8* %113, align 1
  %zext56 = zext i8 %114 to i32
  %shl57 = shl i32 %zext56, 16
  %115 = or i32 %shl57, %112
  %116 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
  %117 = load i8, i8* %116, align 1
  %zext58 = zext i8 %117 to i32
  %shl59 = shl i32 %zext58, 24
  %118 = or i32 %shl59, %115
  %119 = and i32 2147483647, %118
  store i32 %119, i32* %taddr60, align 4
  %120 = bitcast i32* %taddr60 to i8*
  %121 = insertvalue %variant undef, i8* %120, 0
  %122 = insertvalue %variant %121, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
  %123 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots44, i64 0, i64 1
  store %variant %122, %variant* %123, align 16
  %124 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
  %125 = load i8, i8* %124, align 1
  %lshrl61 = lshr i8 %125, 7
  %126 = trunc i8 %lshrl61 to i1
  %127 = zext i1 %126 to i8
  store i8 %127, i8* %taddr62, align 1
  %128 = insertvalue %variant undef, i8* %taddr62, 0
  %129 = insertvalue %variant %128, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
  %130 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots44, i64 0, i64 2
  store %variant %129, %variant* %130, align 16
  %131 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg43, i32 0, i32 1
  store i64 3, i64* %131, align 8
  %132 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg43, i32 0, i32 0
  %133 = bitcast [3 x %variant]* %varargslots44 to %variant*
  store %variant* %133, %variant** %132, align 8
  %134 = bitcast %"variant[]"* %vararg43 to { i8*, i64 }*
  %135 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %134, i32 0, i32 0
  %lo63 = load i8*, i8** %135, align 8
  %136 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %134, i32 0, i32 1
  %hi64 = load i64, i64* %136, align 8
  %137 = call i64 @std_io_printfln(i64* %retparam39, i8* %lo41, i64 %hi42, i8* %lo63, i64 %hi64)
  %not_err65 = icmp eq i64 %137, 0
  br i1 %not_err65, label %after_check66, label %voiderr67

after_check66:                                    ; preds = %voiderr38
  br label %voiderr67

voiderr67:                                        ; preds = %after_check66, %voiderr38
  %add = add i32 %0, 1
  %zext68 = zext i32 %add to i64
  %138 = and i64 %zext68, 4294967295
  %139 = and i64 %138, -9223372032559808513
  %140 = or i64 %139, 4294967296
  %gt = icmp sgt i32 %0, 100
  %141 = zext i1 %gt to i8
  %zext69 = zext i8 %141 to i64
  %shl70 = shl i64 %zext69, 63
  %142 = and i64 %shl70, -9223372036854775808
  %143 = and i64 %140, 9223372036854775807
  %144 = or i64 %143, %142
  store i64 %144, i64* %x, align 8
  %145 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
  store i64 -9223371989610135519, i64* %145, align 8
  %146 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
  store i8 0, i8* %146, align 1
  %147 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
  store i8 0, i8* %147, align 1
  %148 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
  store i8 0, i8* %148, align 1
  %149 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
  store i8 0, i8* %149, align 1
  %150 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
  store i8 0, i8* %150, align 1
  %151 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
  store i8 0, i8* %151, align 1
  %152 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
  store i8 0, i8* %152, align 1
  %153 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
  store i8 0, i8* %153, align 1
  %add71 = add i32 %0, 1
  %154 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
  %ztrunc72 = trunc i32 %add71 to i8
  store i8 %ztrunc72, i8* %154, align 1
  %lshrl73 = lshr i32 %add71, 8
  %155 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
  %ztrunc74 = trunc i32 %lshrl73 to i8
  store i8 %ztrunc74, i8* %155, align 1
  %lshrl75 = lshr i32 %lshrl73, 8
  %156 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
  %ztrunc76 = trunc i32 %lshrl75 to i8
  store i8 %ztrunc76, i8* %156, align 1
  %lshrl77 = lshr i32 %lshrl75, 8
  %157 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
  %ztrunc78 = trunc i32 %lshrl77 to i8
  store i8 %ztrunc78, i8* %157, align 1
  %lshrl79 = lshr i32 %lshrl77, 8
  %158 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
  store i8 1, i8* %158, align 1
  %159 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
  store i8 0, i8* %159, align 1
  %160 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
  store i8 0, i8* %160, align 1
  %161 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
  %162 = load i8, i8* %161, align 1
  %163 = and i8 %162, -128
  store i8 %163, i8* %161, align 1
  %gt80 = icmp sgt i32 %0, 100
  %164 = zext i1 %gt80 to i8
  %shl81 = shl i8 %164, 7
  %165 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
  %166 = load i8, i8* %165, align 1
  %167 = and i8 %166, 127
  %168 = or i8 %167, %shl81
  store i8 %168, i8* %165, align 1
  store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i32 0, i32 0), i64 8 }, %"char[]"* %taddr83, align 8
  %169 = bitcast %"char[]"* %taddr83 to { i8*, i64 }*
  %170 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %169, i32 0, i32 0
  %lo84 = load i8*, i8** %170, align 8
  %171 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %169, i32 0, i32 1
  %hi85 = load i64, i64* %171, align 8
  %172 = load i64, i64* %x, align 8
  %173 = and i64 4294967295, %172
  %ztrunc88 = trunc i64 %173 to i32
  store i32 %ztrunc88, i32* %taddr89, align 4
  %174 = bitcast i32* %taddr89 to i8*
  %175 = insertvalue %variant undef, i8* %174, 0
  %176 = insertvalue %variant %175, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
  %177 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots87, i64 0, i64 0
  store %variant %176, %variant* %177, align 16
  %178 = load i64, i64* %x, align 8
  %lshrl90 = lshr i64 %178, 32
  %179 = and i64 2147483647, %lshrl90
  %ztrunc91 = trunc i64 %179 to i32
  store i32 %ztrunc91, i32* %taddr92, align 4
  %180 = bitcast i32* %taddr92 to i8*
  %181 = insertvalue %variant undef, i8* %180, 0
  %182 = insertvalue %variant %181, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
  %183 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots87, i64 0, i64 1
  store %variant %182, %variant* %183, align 16
  %184 = load i64, i64* %x, align 8
  %lshrl93 = lshr i64 %184, 63
  %185 = and i64 1, %lshrl93
  %ztrunc94 = trunc i64 %185 to i8
  store i8 %ztrunc94, i8* %taddr95, align 1
  %186 = insertvalue %variant undef, i8* %taddr95, 0
  %187 = insertvalue %variant %186, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
  %188 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots87, i64 0, i64 2
  store %variant %187, %variant* %188, align 16
  %189 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg86, i32 0, i32 1
  store i64 3, i64* %189, align 8
  %190 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg86, i32 0, i32 0
  %191 = bitcast [3 x %variant]* %varargslots87 to %variant*
  store %variant* %191, %variant** %190, align 8
  %192 = bitcast %"variant[]"* %vararg86 to { i8*, i64 }*
  %193 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %192, i32 0, i32 0
  %lo96 = load i8*, i8** %193, align 8
  %194 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %192, i32 0, i32 1
  %hi97 = load i64, i64* %194, align 8
  %195 = call i64 @std_io_printfln(i64* %retparam82, i8* %lo84, i64 %hi85, i8* %lo96, i64 %hi97)
  %not_err98 = icmp eq i64 %195, 0
  br i1 %not_err98, label %after_check99, label %voiderr100

after_check99:                                    ; preds = %voiderr67
  br label %voiderr100

voiderr100:                                       ; preds = %after_check99, %voiderr67
  store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i32 0, i32 0), i64 8 }, %"char[]"* %taddr102, align 8
  %196 = bitcast %"char[]"* %taddr102 to { i8*, i64 }*
  %197 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %196, i32 0, i32 0
  %lo103 = load i8*, i8** %197, align 8
  %198 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %196, i32 0, i32 1
  %hi104 = load i64, i64* %198, align 8
  %199 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
  %200 = load i64, i64* %199, align 8
  %201 = and i64 4294967295, %200
  %ztrunc107 = trunc i64 %201 to i32
  store i32 %ztrunc107, i32* %taddr108, align 4
  %202 = bitcast i32* %taddr108 to i8*
  %203 = insertvalue %variant undef, i8* %202, 0
  %204 = insertvalue %variant %203, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
  %205 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots106, i64 0, i64 0
  store %variant %204, %variant* %205, align 16
  %206 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
  %207 = load i64, i64* %206, align 8
  %lshrl109 = lshr i64 %207, 32
  %208 = and i64 2147483647, %lshrl109
  %ztrunc110 = trunc i64 %208 to i32
  store i32 %ztrunc110, i32* %taddr111, align 4
  %209 = bitcast i32* %taddr111 to i8*
  %210 = insertvalue %variant undef, i8* %209, 0
  %211 = insertvalue %variant %210, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
  %212 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots106, i64 0, i64 1
  store %variant %211, %variant* %212, align 16
  %213 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
  %214 = load i64, i64* %213, align 8
  %lshrl112 = lshr i64 %214, 63
  %215 = and i64 1, %lshrl112
  %ztrunc113 = trunc i64 %215 to i8
  store i8 %ztrunc113, i8* %taddr114, align 1
  %216 = insertvalue %variant undef, i8* %taddr114, 0
  %217 = insertvalue %variant %216, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
  %218 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots106, i64 0, i64 2
  store %variant %217, %variant* %218, align 16
  %219 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg105, i32 0, i32 1
  store i64 3, i64* %219, align 8
  %220 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg105, i32 0, i32 0
  %221 = bitcast [3 x %variant]* %varargslots106 to %variant*
  store %variant* %221, %variant** %220, align 8
  %222 = bitcast %"variant[]"* %vararg105 to { i8*, i64 }*
  %223 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %222, i32 0, i32 0
  %lo115 = load i8*, i8** %223, align 8
  %224 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %222, i32 0, i32 1
  %hi116 = load i64, i64* %224, align 8
  %225 = call i64 @std_io_printfln(i64* %retparam101, i8* %lo103, i64 %hi104, i8* %lo115, i64 %hi116)
  %not_err117 = icmp eq i64 %225, 0
  br i1 %not_err117, label %after_check118, label %voiderr119

after_check118:                                   ; preds = %voiderr100
  br label %voiderr119

voiderr119:                                       ; preds = %after_check118, %voiderr100
  store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.6, i32 0, i32 0), i64 8 }, %"char[]"* %taddr121, align 8
  %226 = bitcast %"char[]"* %taddr121 to { i8*, i64 }*
  %227 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %226, i32 0, i32 0
  %lo122 = load i8*, i8** %227, align 8
  %228 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %226, i32 0, i32 1
  %hi123 = load i64, i64* %228, align 8
  %229 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
  %230 = load i8, i8* %229, align 1
  %zext126 = zext i8 %230 to i32
  %231 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
  %232 = load i8, i8* %231, align 1
  %zext127 = zext i8 %232 to i32
  %shl128 = shl i32 %zext127, 8
  %233 = or i32 %shl128, %zext126
  %234 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
  %235 = load i8, i8* %234, align 1
  %zext129 = zext i8 %235 to i32
  %shl130 = shl i32 %zext129, 16
  %236 = or i32 %shl130, %233
  %237 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
  %238 = load i8, i8* %237, align 1
  %zext131 = zext i8 %238 to i32
  %shl132 = shl i32 %zext131, 24
  %239 = or i32 %shl132, %236
  store i32 %239, i32* %taddr133, align 4
  %240 = bitcast i32* %taddr133 to i8*
  %241 = insertvalue %variant undef, i8* %240, 0
  %242 = insertvalue %variant %241, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
  %243 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots125, i64 0, i64 0
  store %variant %242, %variant* %243, align 16
  %244 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
  %245 = load i8, i8* %244, align 1
  %zext134 = zext i8 %245 to i32
  %246 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
  %247 = load i8, i8* %246, align 1
  %zext135 = zext i8 %247 to i32
  %shl136 = shl i32 %zext135, 8
  %248 = or i32 %shl136, %zext134
  %249 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
  %250 = load i8, i8* %249, align 1
  %zext137 = zext i8 %250 to i32
  %shl138 = shl i32 %zext137, 16
  %251 = or i32 %shl138, %248
  %252 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
  %253 = load i8, i8* %252, align 1
  %zext139 = zext i8 %253 to i32
  %shl140 = shl i32 %zext139, 24
  %254 = or i32 %shl140, %251
  %255 = and i32 2147483647, %254
  store i32 %255, i32* %taddr141, align 4
  %256 = bitcast i32* %taddr141 to i8*
  %257 = insertvalue %variant undef, i8* %256, 0
  %258 = insertvalue %variant %257, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
  %259 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots125, i64 0, i64 1
  store %variant %258, %variant* %259, align 16
  %260 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
  %261 = load i8, i8* %260, align 1
  %lshrl142 = lshr i8 %261, 7
  %262 = trunc i8 %lshrl142 to i1
  %263 = zext i1 %262 to i8
  store i8 %263, i8* %taddr143, align 1
  %264 = insertvalue %variant undef, i8* %taddr143, 0
  %265 = insertvalue %variant %264, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
  %266 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots125, i64 0, i64 2
  store %variant %265, %variant* %266, align 16
  %267 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg124, i32 0, i32 1
  store i64 3, i64* %267, align 8
  %268 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg124, i32 0, i32 0
  %269 = bitcast [3 x %variant]* %varargslots125 to %variant*
  store %variant* %269, %variant** %268, align 8
  %270 = bitcast %"variant[]"* %vararg124 to { i8*, i64 }*
  %271 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %270, i32 0, i32 0
  %lo144 = load i8*, i8** %271, align 8
  %272 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %270, i32 0, i32 1
  %hi145 = load i64, i64* %272, align 8
  %273 = call i64 @std_io_printfln(i64* %retparam120, i8* %lo122, i64 %hi123, i8* %lo144, i64 %hi145)
  %not_err146 = icmp eq i64 %273, 0
  br i1 %not_err146, label %after_check147, label %voiderr148

after_check147:                                   ; preds = %voiderr119
  br label %voiderr148

voiderr148:                                       ; preds = %after_check147, %voiderr119
  ret void
}