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

bitstruct Foo : int
{
	bool a : 0;
	bool b : 1;
}

bitstruct Bar : char[13]
{
	bool z : 0;
	bool w : 1;
	bool gh : 25;
}
fn void main()
{
	Foo f1 = { true, true };
	Foo f2 = { true, false };

	Foo f3 = f1 & f2;
	io::printfn("%s %s", f3.a, f3.b);
	Foo f4 = (f1 | ~f2) ^ f3;
	io::printfn("%s %s", f4.a, f4.b);
	Foo f5 = Foo { true, false } | Foo { false, true };
	io::printfn("%s %s", f5.a, f5.b);

	f5 &= f2;
	io::printfn("%s %s", f5.a, f5.b);

	Bar b1 = { true, true, true };
	Bar b2 = { true, false, false };

	Bar b3 = b1 & b2;
	io::printfn("%s %s %s", b3.z, b3.w, b3.gh);
	b3 = ~b3;
	io::printfn("%s %s %s", b3.z, b3.w, b3.gh);
	b3 ^= Bar { true, true, false };
	io::printfn("%s %s %s", b3.z, b3.w, b3.gh);
}

/* #expect: test.ll

define void @test.main() #0 {
entry:
  %f1 = alloca i32, align 4
  %f2 = alloca i32, align 4
  %f3 = alloca i32, align 4
  %retparam = alloca i64, align 8
  %varargslots = alloca [2 x %variant], align 16
  %taddr = alloca i8, align 1
  %taddr2 = alloca i8, align 1
  %f4 = alloca i32, align 4
  %retparam3 = alloca i64, align 8
  %varargslots4 = alloca [2 x %variant], align 16
  %taddr6 = alloca i8, align 1
  %taddr9 = alloca i8, align 1
  %f5 = alloca i32, align 4
  %retparam10 = alloca i64, align 8
  %varargslots11 = alloca [2 x %variant], align 16
  %taddr13 = alloca i8, align 1
  %taddr16 = alloca i8, align 1
  %retparam18 = alloca i64, align 8
  %varargslots19 = alloca [2 x %variant], align 16
  %taddr21 = alloca i8, align 1
  %taddr24 = alloca i8, align 1
  %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
  %retparam26 = alloca i64, align 8
  %varargslots27 = alloca [3 x %variant], align 16
  %taddr28 = alloca i8, align 1
  %taddr30 = alloca i8, align 1
  %taddr32 = alloca i8, align 1
  %1 = alloca i104, align 1
  %retparam34 = alloca i64, align 8
  %varargslots35 = alloca [3 x %variant], align 16
  %taddr36 = alloca i8, align 1
  %taddr38 = alloca i8, align 1
  %taddr40 = alloca i8, align 1
  %taddr41 = alloca [13 x i8], align 1
  %2 = alloca i104, align 1
  %retparam43 = alloca i64, align 8
  %varargslots44 = alloca [3 x %variant], align 16
  %taddr45 = alloca i8, align 1
  %taddr47 = alloca i8, align 1
  %taddr49 = alloca i8, align 1
  store i32 3, ptr %f1, align 4
  store i32 1, ptr %f2, align 4
  %3 = load i32, ptr %f1, align 4
  %4 = load i32, ptr %f2, align 4
  %and = and i32 %3, %4
  store i32 %and, ptr %f3, align 4
  %5 = load i32, ptr %f3, align 4
  %6 = and i32 1, %5
  %trunc = trunc i32 %6 to i8
  store i8 %trunc, ptr %taddr, align 1
  %7 = insertvalue %variant undef, ptr %taddr, 0
  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %9 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
  store %variant %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 i8 %trunc1, ptr %taddr2, align 1
  %12 = insertvalue %variant undef, ptr %taddr2, 0
  %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %14 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
  store %variant %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
  store i32 %xor, ptr %f4, align 4
  %19 = load i32, ptr %f4, align 4
  %20 = and i32 1, %19
  %trunc5 = trunc i32 %20 to i8
  store i8 %trunc5, ptr %taddr6, align 1
  %21 = insertvalue %variant undef, ptr %taddr6, 0
  %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %23 = getelementptr inbounds [2 x %variant], ptr %varargslots4, i64 0, i64 0
  store %variant %22, ptr %23, align 16
  %24 = load i32, ptr %f4, align 4
  %lshrl7 = lshr i32 %24, 1
  %25 = and i32 1, %lshrl7
  %trunc8 = trunc i32 %25 to i8
  store i8 %trunc8, ptr %taddr9, align 1
  %26 = insertvalue %variant undef, ptr %taddr9, 0
  %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %28 = getelementptr inbounds [2 x %variant], ptr %varargslots4, i64 0, i64 1
  store %variant %27, ptr %28, align 16
  %29 = call i64 @std.io.printfn(ptr %retparam3, ptr @.str.1, i64 5, ptr %varargslots4, i64 2)
  store i32 3, ptr %f5, align 4
  %30 = load i32, ptr %f5, align 4
  %31 = and i32 1, %30
  %trunc12 = trunc i32 %31 to i8
  store i8 %trunc12, ptr %taddr13, align 1
  %32 = insertvalue %variant undef, ptr %taddr13, 0
  %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %34 = getelementptr inbounds [2 x %variant], ptr %varargslots11, i64 0, i64 0
  store %variant %33, ptr %34, align 16
  %35 = load i32, ptr %f5, align 4
  %lshrl14 = lshr i32 %35, 1
  %36 = and i32 1, %lshrl14
  %trunc15 = trunc i32 %36 to i8
  store i8 %trunc15, ptr %taddr16, align 1
  %37 = insertvalue %variant undef, ptr %taddr16, 0
  %38 = insertvalue %variant %37, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %39 = getelementptr inbounds [2 x %variant], ptr %varargslots11, i64 0, i64 1
  store %variant %38, ptr %39, align 16
  %40 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.2, i64 5, ptr %varargslots11, i64 2)
  %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
  %trunc20 = trunc i32 %44 to i8
  store i8 %trunc20, ptr %taddr21, align 1
  %45 = insertvalue %variant undef, ptr %taddr21, 0
  %46 = insertvalue %variant %45, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %47 = getelementptr inbounds [2 x %variant], ptr %varargslots19, i64 0, i64 0
  store %variant %46, ptr %47, align 16
  %48 = load i32, ptr %f5, align 4
  %lshrl22 = lshr i32 %48, 1
  %49 = and i32 1, %lshrl22
  %trunc23 = trunc i32 %49 to i8
  store i8 %trunc23, ptr %taddr24, align 1
  %50 = insertvalue %variant undef, ptr %taddr24, 0
  %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %52 = getelementptr inbounds [2 x %variant], ptr %varargslots19, i64 0, i64 1
  store %variant %51, ptr %52, align 16
  %53 = call i64 @std.io.printfn(ptr %retparam18, ptr @.str.3, i64 5, ptr %varargslots19, 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 8
  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 %taddr28, align 1
  %60 = insertvalue %variant undef, ptr %taddr28, 0
  %61 = insertvalue %variant %60, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %62 = getelementptr inbounds [3 x %variant], ptr %varargslots27, i64 0, i64 0
  store %variant %61, ptr %62, align 16
  %63 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
  %64 = load i8, ptr %63, align 1
  %lshrl29 = lshr i8 %64, 1
  %65 = trunc i8 %lshrl29 to i1
  %66 = zext i1 %65 to i8
  store i8 %66, ptr %taddr30, align 1
  %67 = insertvalue %variant undef, ptr %taddr30, 0
  %68 = insertvalue %variant %67, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %69 = getelementptr inbounds [3 x %variant], ptr %varargslots27, i64 0, i64 1
  store %variant %68, ptr %69, align 16
  %70 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 3
  %71 = load i8, ptr %70, align 1
  %lshrl31 = lshr i8 %71, 1
  %72 = trunc i8 %lshrl31 to i1
  %73 = zext i1 %72 to i8
  store i8 %73, ptr %taddr32, align 1
  %74 = insertvalue %variant undef, ptr %taddr32, 0
  %75 = insertvalue %variant %74, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %76 = getelementptr inbounds [3 x %variant], ptr %varargslots27, i64 0, i64 2
  store %variant %75, ptr %76, align 16
  %77 = call i64 @std.io.printfn(ptr %retparam26, ptr @.str.4, i64 8, ptr %varargslots27, i64 3)
  %78 = load i104, ptr %b3, align 1
  %bnot33 = xor i104 %78, -1
  store i104 %bnot33, ptr %1, align 8
  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 %taddr36, align 1
  %83 = insertvalue %variant undef, ptr %taddr36, 0
  %84 = insertvalue %variant %83, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %85 = getelementptr inbounds [3 x %variant], ptr %varargslots35, i64 0, i64 0
  store %variant %84, ptr %85, align 16
  %86 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
  %87 = load i8, ptr %86, align 1
  %lshrl37 = lshr i8 %87, 1
  %88 = trunc i8 %lshrl37 to i1
  %89 = zext i1 %88 to i8
  store i8 %89, ptr %taddr38, align 1
  %90 = insertvalue %variant undef, ptr %taddr38, 0
  %91 = insertvalue %variant %90, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %92 = getelementptr inbounds [3 x %variant], ptr %varargslots35, i64 0, i64 1
  store %variant %91, ptr %92, align 16
  %93 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 3
  %94 = load i8, ptr %93, align 1
  %lshrl39 = lshr i8 %94, 1
  %95 = trunc i8 %lshrl39 to i1
  %96 = zext i1 %95 to i8
  store i8 %96, ptr %taddr40, align 1
  %97 = insertvalue %variant undef, ptr %taddr40, 0
  %98 = insertvalue %variant %97, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %99 = getelementptr inbounds [3 x %variant], ptr %varargslots35, i64 0, i64 2
  store %variant %98, ptr %99, align 16
  %100 = call i64 @std.io.printfn(ptr %retparam34, ptr @.str.5, i64 8, ptr %varargslots35, 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 8
  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 %taddr45, align 1
  %107 = insertvalue %variant undef, ptr %taddr45, 0
  %108 = insertvalue %variant %107, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %109 = getelementptr inbounds [3 x %variant], ptr %varargslots44, i64 0, i64 0
  store %variant %108, ptr %109, align 16
  %110 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
  %111 = load i8, ptr %110, align 1
  %lshrl46 = lshr i8 %111, 1
  %112 = trunc i8 %lshrl46 to i1
  %113 = zext i1 %112 to i8
  store i8 %113, ptr %taddr47, align 1
  %114 = insertvalue %variant undef, ptr %taddr47, 0
  %115 = insertvalue %variant %114, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %116 = getelementptr inbounds [3 x %variant], ptr %varargslots44, i64 0, i64 1
  store %variant %115, ptr %116, align 16
  %117 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 3
  %118 = load i8, ptr %117, align 1
  %lshrl48 = lshr i8 %118, 1
  %119 = trunc i8 %lshrl48 to i1
  %120 = zext i1 %119 to i8
  store i8 %120, ptr %taddr49, align 1
  %121 = insertvalue %variant undef, ptr %taddr49, 0
  %122 = insertvalue %variant %121, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %123 = getelementptr inbounds [3 x %variant], ptr %varargslots44, i64 0, i64 2
  store %variant %122, ptr %123, align 16
  %124 = call i64 @std.io.printfn(ptr %retparam43, ptr @.str.6, i64 8, ptr %varargslots44, i64 3)
  ret void
}