diff --git a/releasenotes.md b/releasenotes.md
index 9c6a9e4dd..f5a32199c 100644
--- a/releasenotes.md
+++ b/releasenotes.md
@@ -33,6 +33,7 @@
 - Lambda / function type would accidentally be processed as a method.
 - Fix error message when not finding a particular function.
 - Crash invoking a `@body` argument with the wrong number of parameters.
+- Fix reordering semantics in struct assignment.
 
 ### Stdlib changes
 - Additional init functions for hashmap.
diff --git a/src/compiler/llvm_codegen_expr.c b/src/compiler/llvm_codegen_expr.c
index ec44fba76..13ce4235d 100644
--- a/src/compiler/llvm_codegen_expr.c
+++ b/src/compiler/llvm_codegen_expr.c
@@ -94,7 +94,7 @@ LLVMValueRef llvm_emit_expect_raw(GenContext *c, LLVMValueRef expect_true)
 	return llvm_emit_call_intrinsic(c, intrinsic_id.expect, &c->bool_type, 1, values, 2);
 }
 
-BEValue llvm_emit_assign_expr(GenContext *c, BEValue *ref, Expr *expr, LLVMValueRef optional)
+BEValue llvm_emit_assign_expr(GenContext *c, BEValue *ref, Expr *expr, LLVMValueRef optional, bool is_init)
 {
 	assert(llvm_value_is_addr(ref));
 
@@ -103,7 +103,6 @@ BEValue llvm_emit_assign_expr(GenContext *c, BEValue *ref, Expr *expr, LLVMValue
 	// Special optimization of handling of optional
 	if (expr->expr_kind == EXPR_OPTIONAL)
 	{
-
 		PUSH_CLEAR_CATCH();
 
 		BEValue result;
@@ -163,7 +162,19 @@ BEValue llvm_emit_assign_expr(GenContext *c, BEValue *ref, Expr *expr, LLVMValue
 	}
 	else if (expr_is_init_list(expr))
 	{
-		llvm_emit_initialize_reference(c, ref, expr);
+		if (is_init)
+		{
+			llvm_emit_initialize_reference(c, ref, expr);
+		}
+		else
+		{
+			BEValue val;
+			AlignSize alignment = type_alloca_alignment(ref->type);
+			LLVMValueRef temp = llvm_emit_alloca(c, llvm_get_type(c, ref->type), alignment, ".assign_list");
+			llvm_value_set_address(&val, temp, ref->type, alignment);
+			llvm_emit_initialize_reference(c, &val, expr);
+			llvm_store(c, ref, &val);
+		}
 		value = *ref;
 	}
 	else
@@ -4737,7 +4748,7 @@ static void llvm_emit_binary_expr(GenContext *c, BEValue *be_value, Expr *expr)
 		}
 
 		// Emit the result.
-		*be_value = llvm_emit_assign_expr(c, be_value, exprptr(expr->binary_expr.right), optional_ref);
+		*be_value = llvm_emit_assign_expr(c, be_value, exprptr(expr->binary_expr.right), optional_ref, false);
 		return;
 	}
 
diff --git a/src/compiler/llvm_codegen_internal.h b/src/compiler/llvm_codegen_internal.h
index 2c7e71fe6..cef69f56f 100644
--- a/src/compiler/llvm_codegen_internal.h
+++ b/src/compiler/llvm_codegen_internal.h
@@ -531,7 +531,7 @@ void llvm_emit_compound_stmt(GenContext *c, Ast *ast);
 LLVMValueRef llvm_emit_const_bitstruct(GenContext *c, ConstInitializer *initializer);
 void llvm_emit_function_body(GenContext *context, Decl *decl);
 void llvm_emit_dynamic_functions(GenContext *context, Decl **funcs);
-BEValue llvm_emit_assign_expr(GenContext *c, BEValue *ref, Expr *expr, LLVMValueRef optional);
+BEValue llvm_emit_assign_expr(GenContext *c, BEValue *ref, Expr *expr, LLVMValueRef optional, bool is_init);
 INLINE void llvm_emit_exprid(GenContext *c, BEValue *value, ExprId expr);
 INLINE void llvm_emit_statement_chain(GenContext *c, AstId current);
 void llvm_emit_initialize_reference_temporary_const(GenContext *c, BEValue *ref, ConstInitializer *initializer);
diff --git a/src/compiler/llvm_codegen_stmt.c b/src/compiler/llvm_codegen_stmt.c
index 767b6caf0..8c0f3ed1d 100644
--- a/src/compiler/llvm_codegen_stmt.c
+++ b/src/compiler/llvm_codegen_stmt.c
@@ -133,7 +133,7 @@ void llvm_emit_local_decl(GenContext *c, Decl *decl, BEValue *value)
 	{
 		llvm_value_set_decl_address(c, value, decl);
 		value->kind = BE_ADDRESS;
-		BEValue res = llvm_emit_assign_expr(c, value, decl->var.init_expr, decl->var.optional_ref);
+		BEValue res = llvm_emit_assign_expr(c, value, decl->var.init_expr, decl->var.optional_ref, true);
 		if (!is_optional) *value = res;
 		return;
 	}
diff --git a/test/test_suite/bitstruct/bitstruct_initializer.c3t b/test/test_suite/bitstruct/bitstruct_initializer.c3t
index fa136861f..b20b1106a 100644
--- a/test/test_suite/bitstruct/bitstruct_initializer.c3t
+++ b/test/test_suite/bitstruct/bitstruct_initializer.c3t
@@ -51,39 +51,43 @@ fn void main()
 define void @test.hello(i32 %0) #0 {
 entry:
   %x = alloca i64, align 8
+  %.assign_list = alloca i64, align 8
   %y = alloca %Abc, align 8
   %d = alloca %Abc, align 8
   %b = alloca [8 x i8], align 1
+  %.assign_list10 = alloca [8 x i8], align 1
   %varargslots = alloca [3 x %any], align 16
   %taddr = alloca i32, align 4
-  %taddr32 = alloca i32, align 4
-  %taddr36 = alloca i8, align 1
+  %taddr33 = alloca i32, align 4
+  %taddr37 = alloca i8, align 1
   %retparam = alloca i64, align 8
-  %varargslots38 = alloca [3 x %any], align 16
-  %taddr41 = alloca i32, align 4
-  %taddr45 = alloca i32, align 4
-  %taddr50 = alloca i8, align 1
-  %retparam52 = alloca i64, align 8
-  %varargslots53 = alloca [3 x %any], align 16
-  %taddr64 = alloca i32, align 4
-  %taddr76 = alloca i32, align 4
-  %taddr80 = alloca i8, align 1
-  %retparam82 = alloca i64, align 8
-  %varargslots113 = alloca [3 x %any], align 16
-  %taddr115 = alloca i32, align 4
+  %varargslots39 = alloca [3 x %any], align 16
+  %taddr42 = alloca i32, align 4
+  %taddr46 = alloca i32, align 4
+  %taddr51 = alloca i8, align 1
+  %retparam53 = alloca i64, align 8
+  %varargslots54 = alloca [3 x %any], align 16
+  %taddr65 = alloca i32, align 4
+  %taddr77 = alloca i32, align 4
+  %taddr81 = alloca i8, align 1
+  %retparam83 = alloca i64, align 8
+  %.assign_list84 = alloca i64, align 8
+  %.assign_list89 = alloca [8 x i8], align 1
+  %varargslots116 = alloca [3 x %any], align 16
   %taddr118 = alloca i32, align 4
-  %taddr122 = alloca i8, align 1
-  %retparam124 = alloca i64, align 8
-  %varargslots125 = alloca [3 x %any], align 16
-  %taddr128 = alloca i32, align 4
-  %taddr132 = alloca i32, align 4
-  %taddr137 = alloca i8, align 1
-  %retparam139 = alloca i64, align 8
-  %varargslots140 = alloca [3 x %any], align 16
-  %taddr151 = alloca i32, align 4
-  %taddr163 = alloca i32, align 4
-  %taddr167 = alloca i8, align 1
-  %retparam169 = alloca i64, align 8
+  %taddr121 = alloca i32, align 4
+  %taddr125 = alloca i8, align 1
+  %retparam127 = alloca i64, align 8
+  %varargslots128 = alloca [3 x %any], align 16
+  %taddr131 = alloca i32, align 4
+  %taddr135 = alloca i32, align 4
+  %taddr140 = alloca i8, align 1
+  %retparam142 = alloca i64, align 8
+  %varargslots143 = alloca [3 x %any], align 16
+  %taddr154 = alloca i32, align 4
+  %taddr166 = alloca i32, align 4
+  %taddr170 = alloca i8, align 1
+  %retparam172 = alloca i64, align 8
   store i64 0, ptr %x, align 8
   %zext = zext i32 %0 to i64
   %1 = and i64 %zext, 4294967295
@@ -94,7 +98,9 @@ entry:
   %3 = and i64 %shl, -9223372036854775808
   %4 = and i64 %1, 9223372036854775807
   %5 = or i64 %4, %3
-  store i64 %5, ptr %x, align 8
+  store i64 %5, ptr %.assign_list, align 8
+  %6 = load i64, ptr %.assign_list, align 8
+  store i64 %6, ptr %x, align 8
   store i32 0, ptr %y, align 8
   %ptradd = getelementptr inbounds i8, ptr %y, i64 8
   store i64 42949672992, ptr %ptradd, align 8
@@ -116,330 +122,334 @@ entry:
   store i8 0, ptr %ptradd8, align 1
   %ptradd9 = getelementptr inbounds i8, ptr %b, i64 7
   store i8 0, ptr %ptradd9, align 1
-  store i8 0, ptr %b, align 1
-  %ptradd10 = getelementptr inbounds i8, ptr %b, i64 1
-  store i8 0, ptr %ptradd10, align 1
-  %ptradd11 = getelementptr inbounds i8, ptr %b, i64 2
+  store i8 0, ptr %.assign_list10, align 1
+  %ptradd11 = getelementptr inbounds i8, ptr %.assign_list10, i64 1
   store i8 0, ptr %ptradd11, align 1
-  %ptradd12 = getelementptr inbounds i8, ptr %b, i64 3
+  %ptradd12 = getelementptr inbounds i8, ptr %.assign_list10, i64 2
   store i8 0, ptr %ptradd12, align 1
-  %ptradd13 = getelementptr inbounds i8, ptr %b, i64 4
+  %ptradd13 = getelementptr inbounds i8, ptr %.assign_list10, i64 3
   store i8 0, ptr %ptradd13, align 1
-  %ptradd14 = getelementptr inbounds i8, ptr %b, i64 5
+  %ptradd14 = getelementptr inbounds i8, ptr %.assign_list10, i64 4
   store i8 0, ptr %ptradd14, align 1
-  %ptradd15 = getelementptr inbounds i8, ptr %b, i64 6
+  %ptradd15 = getelementptr inbounds i8, ptr %.assign_list10, i64 5
   store i8 0, ptr %ptradd15, align 1
-  %ptradd16 = getelementptr inbounds i8, ptr %b, i64 7
+  %ptradd16 = getelementptr inbounds i8, ptr %.assign_list10, i64 6
   store i8 0, ptr %ptradd16, align 1
+  %ptradd17 = getelementptr inbounds i8, ptr %.assign_list10, i64 7
+  store i8 0, ptr %ptradd17, align 1
   %trunc = trunc i32 %0 to i8
-  store i8 %trunc, ptr %b, align 1
+  store i8 %trunc, ptr %.assign_list10, align 1
   %lshrl = lshr i32 %0, 8
-  %ptradd17 = getelementptr inbounds i8, ptr %b, i64 1
-  %trunc18 = trunc i32 %lshrl to i8
-  store i8 %trunc18, ptr %ptradd17, align 1
-  %lshrl19 = lshr i32 %lshrl, 8
-  %ptradd20 = getelementptr inbounds i8, ptr %b, i64 2
-  %trunc21 = trunc i32 %lshrl19 to i8
-  store i8 %trunc21, ptr %ptradd20, align 1
-  %lshrl22 = lshr i32 %lshrl19, 8
-  %ptradd23 = getelementptr inbounds i8, ptr %b, i64 3
-  %trunc24 = trunc i32 %lshrl22 to i8
-  store i8 %trunc24, ptr %ptradd23, align 1
-  %lshrl25 = lshr i32 %lshrl22, 8
-  %lt26 = icmp slt i32 %0, 100
-  %6 = zext i1 %lt26 to i8
-  %shl27 = shl i8 %6, 7
-  %ptradd28 = getelementptr inbounds i8, ptr %b, i64 7
-  %7 = load i8, ptr %ptradd28, align 1
-  %8 = and i8 %7, 127
-  %9 = or i8 %8, %shl27
-  store i8 %9, ptr %ptradd28, align 1
-  %10 = load i64, ptr %x, align 8
-  %11 = and i64 4294967295, %10
-  %trunc29 = trunc i64 %11 to i32
-  store i32 %trunc29, ptr %taddr, align 4
-  %12 = insertvalue %any undef, ptr %taddr, 0
-  %13 = insertvalue %any %12, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
-  store %any %13, ptr %varargslots, align 16
-  %14 = load i64, ptr %x, align 8
-  %lshrl30 = lshr i64 %14, 32
-  %15 = and i64 2147483647, %lshrl30
-  %trunc31 = trunc i64 %15 to i32
-  store i32 %trunc31, ptr %taddr32, align 4
-  %16 = insertvalue %any undef, ptr %taddr32, 0
-  %17 = insertvalue %any %16, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
-  %ptradd33 = getelementptr inbounds i8, ptr %varargslots, i64 16
-  store %any %17, ptr %ptradd33, align 16
-  %18 = load i64, ptr %x, align 8
-  %lshrl34 = lshr i64 %18, 63
-  %19 = and i64 1, %lshrl34
-  %trunc35 = trunc i64 %19 to i8
-  store i8 %trunc35, ptr %taddr36, align 1
-  %20 = insertvalue %any undef, ptr %taddr36, 0
-  %21 = insertvalue %any %20, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %ptradd37 = getelementptr inbounds i8, ptr %varargslots, i64 32
-  store %any %21, ptr %ptradd37, align 16
-  %22 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 3)
-  %ptradd39 = getelementptr inbounds i8, ptr %y, i64 8
-  %23 = load i64, ptr %ptradd39, align 8
-  %24 = and i64 4294967295, %23
-  %trunc40 = trunc i64 %24 to i32
-  store i32 %trunc40, ptr %taddr41, align 4
-  %25 = insertvalue %any undef, ptr %taddr41, 0
-  %26 = insertvalue %any %25, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
-  store %any %26, ptr %varargslots38, align 16
-  %ptradd42 = getelementptr inbounds i8, ptr %y, i64 8
-  %27 = load i64, ptr %ptradd42, align 8
-  %lshrl43 = lshr i64 %27, 32
-  %28 = and i64 2147483647, %lshrl43
-  %trunc44 = trunc i64 %28 to i32
-  store i32 %trunc44, ptr %taddr45, align 4
-  %29 = insertvalue %any undef, ptr %taddr45, 0
-  %30 = insertvalue %any %29, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
-  %ptradd46 = getelementptr inbounds i8, ptr %varargslots38, i64 16
-  store %any %30, ptr %ptradd46, align 16
-  %ptradd47 = getelementptr inbounds i8, ptr %y, i64 8
-  %31 = load i64, ptr %ptradd47, align 8
-  %lshrl48 = lshr i64 %31, 63
-  %32 = and i64 1, %lshrl48
-  %trunc49 = trunc i64 %32 to i8
-  store i8 %trunc49, ptr %taddr50, align 1
-  %33 = insertvalue %any undef, ptr %taddr50, 0
-  %34 = insertvalue %any %33, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %ptradd51 = getelementptr inbounds i8, ptr %varargslots38, i64 32
-  store %any %34, ptr %ptradd51, align 16
-  %35 = call i64 @std.io.printfn(ptr %retparam52, ptr @.str.1, i64 8, ptr %varargslots38, i64 3)
-  %36 = load i8, ptr %b, align 1
-  %zext54 = zext i8 %36 to i32
-  %ptradd55 = getelementptr inbounds i8, ptr %b, i64 1
-  %37 = load i8, ptr %ptradd55, align 1
-  %zext56 = zext i8 %37 to i32
-  %shl57 = shl i32 %zext56, 8
-  %38 = or i32 %shl57, %zext54
-  %ptradd58 = getelementptr inbounds i8, ptr %b, i64 2
-  %39 = load i8, ptr %ptradd58, align 1
-  %zext59 = zext i8 %39 to i32
-  %shl60 = shl i32 %zext59, 16
-  %40 = or i32 %shl60, %38
-  %ptradd61 = getelementptr inbounds i8, ptr %b, i64 3
-  %41 = load i8, ptr %ptradd61, align 1
-  %zext62 = zext i8 %41 to i32
-  %shl63 = shl i32 %zext62, 24
-  %42 = or i32 %shl63, %40
-  store i32 %42, ptr %taddr64, align 4
-  %43 = insertvalue %any undef, ptr %taddr64, 0
-  %44 = insertvalue %any %43, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
-  store %any %44, ptr %varargslots53, align 16
-  %ptradd65 = getelementptr inbounds i8, ptr %b, i64 4
-  %45 = load i8, ptr %ptradd65, align 1
-  %zext66 = zext i8 %45 to i32
-  %ptradd67 = getelementptr inbounds i8, ptr %b, i64 5
-  %46 = load i8, ptr %ptradd67, align 1
-  %zext68 = zext i8 %46 to i32
-  %shl69 = shl i32 %zext68, 8
-  %47 = or i32 %shl69, %zext66
-  %ptradd70 = getelementptr inbounds i8, ptr %b, i64 6
-  %48 = load i8, ptr %ptradd70, align 1
-  %zext71 = zext i8 %48 to i32
-  %shl72 = shl i32 %zext71, 16
-  %49 = or i32 %shl72, %47
-  %ptradd73 = getelementptr inbounds i8, ptr %b, i64 7
-  %50 = load i8, ptr %ptradd73, align 1
-  %zext74 = zext i8 %50 to i32
-  %shl75 = shl i32 %zext74, 24
-  %51 = or i32 %shl75, %49
-  %52 = and i32 2147483647, %51
-  store i32 %52, ptr %taddr76, align 4
-  %53 = insertvalue %any undef, ptr %taddr76, 0
-  %54 = insertvalue %any %53, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
-  %ptradd77 = getelementptr inbounds i8, ptr %varargslots53, i64 16
-  store %any %54, ptr %ptradd77, align 16
-  %ptradd78 = getelementptr inbounds i8, ptr %b, i64 7
-  %55 = load i8, ptr %ptradd78, align 1
-  %lshrl79 = lshr i8 %55, 7
-  %56 = trunc i8 %lshrl79 to i1
-  %57 = zext i1 %56 to i8
-  store i8 %57, ptr %taddr80, align 1
-  %58 = insertvalue %any undef, ptr %taddr80, 0
-  %59 = insertvalue %any %58, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %ptradd81 = getelementptr inbounds i8, ptr %varargslots53, i64 32
-  store %any %59, ptr %ptradd81, align 16
-  %60 = call i64 @std.io.printfn(ptr %retparam82, ptr @.str.2, i64 8, ptr %varargslots53, i64 3)
+  %ptradd18 = getelementptr inbounds i8, ptr %.assign_list10, i64 1
+  %trunc19 = trunc i32 %lshrl to i8
+  store i8 %trunc19, ptr %ptradd18, align 1
+  %lshrl20 = lshr i32 %lshrl, 8
+  %ptradd21 = getelementptr inbounds i8, ptr %.assign_list10, i64 2
+  %trunc22 = trunc i32 %lshrl20 to i8
+  store i8 %trunc22, ptr %ptradd21, align 1
+  %lshrl23 = lshr i32 %lshrl20, 8
+  %ptradd24 = getelementptr inbounds i8, ptr %.assign_list10, i64 3
+  %trunc25 = trunc i32 %lshrl23 to i8
+  store i8 %trunc25, ptr %ptradd24, align 1
+  %lshrl26 = lshr i32 %lshrl23, 8
+  %lt27 = icmp slt i32 %0, 100
+  %7 = zext i1 %lt27 to i8
+  %shl28 = shl i8 %7, 7
+  %ptradd29 = getelementptr inbounds i8, ptr %.assign_list10, i64 7
+  %8 = load i8, ptr %ptradd29, align 1
+  %9 = and i8 %8, 127
+  %10 = or i8 %9, %shl28
+  store i8 %10, ptr %ptradd29, align 1
+  call void @llvm.memcpy.p0.p0.i32(ptr align 1 %b, ptr align 1 %.assign_list10, i32 8, i1 false)
+  %11 = load i64, ptr %x, align 8
+  %12 = and i64 4294967295, %11
+  %trunc30 = trunc i64 %12 to i32
+  store i32 %trunc30, ptr %taddr, align 4
+  %13 = insertvalue %any undef, ptr %taddr, 0
+  %14 = insertvalue %any %13, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
+  store %any %14, ptr %varargslots, align 16
+  %15 = load i64, ptr %x, align 8
+  %lshrl31 = lshr i64 %15, 32
+  %16 = and i64 2147483647, %lshrl31
+  %trunc32 = trunc i64 %16 to i32
+  store i32 %trunc32, ptr %taddr33, align 4
+  %17 = insertvalue %any undef, ptr %taddr33, 0
+  %18 = insertvalue %any %17, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
+  %ptradd34 = getelementptr inbounds i8, ptr %varargslots, i64 16
+  store %any %18, ptr %ptradd34, align 16
+  %19 = load i64, ptr %x, align 8
+  %lshrl35 = lshr i64 %19, 63
+  %20 = and i64 1, %lshrl35
+  %trunc36 = trunc i64 %20 to i8
+  store i8 %trunc36, ptr %taddr37, align 1
+  %21 = insertvalue %any undef, ptr %taddr37, 0
+  %22 = insertvalue %any %21, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  %ptradd38 = getelementptr inbounds i8, ptr %varargslots, i64 32
+  store %any %22, ptr %ptradd38, align 16
+  %23 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 3)
+  %ptradd40 = getelementptr inbounds i8, ptr %y, i64 8
+  %24 = load i64, ptr %ptradd40, align 8
+  %25 = and i64 4294967295, %24
+  %trunc41 = trunc i64 %25 to i32
+  store i32 %trunc41, ptr %taddr42, align 4
+  %26 = insertvalue %any undef, ptr %taddr42, 0
+  %27 = insertvalue %any %26, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
+  store %any %27, ptr %varargslots39, align 16
+  %ptradd43 = getelementptr inbounds i8, ptr %y, i64 8
+  %28 = load i64, ptr %ptradd43, align 8
+  %lshrl44 = lshr i64 %28, 32
+  %29 = and i64 2147483647, %lshrl44
+  %trunc45 = trunc i64 %29 to i32
+  store i32 %trunc45, ptr %taddr46, align 4
+  %30 = insertvalue %any undef, ptr %taddr46, 0
+  %31 = insertvalue %any %30, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
+  %ptradd47 = getelementptr inbounds i8, ptr %varargslots39, i64 16
+  store %any %31, ptr %ptradd47, align 16
+  %ptradd48 = getelementptr inbounds i8, ptr %y, i64 8
+  %32 = load i64, ptr %ptradd48, align 8
+  %lshrl49 = lshr i64 %32, 63
+  %33 = and i64 1, %lshrl49
+  %trunc50 = trunc i64 %33 to i8
+  store i8 %trunc50, ptr %taddr51, align 1
+  %34 = insertvalue %any undef, ptr %taddr51, 0
+  %35 = insertvalue %any %34, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  %ptradd52 = getelementptr inbounds i8, ptr %varargslots39, i64 32
+  store %any %35, ptr %ptradd52, align 16
+  %36 = call i64 @std.io.printfn(ptr %retparam53, ptr @.str.1, i64 8, ptr %varargslots39, i64 3)
+  %37 = load i8, ptr %b, align 1
+  %zext55 = zext i8 %37 to i32
+  %ptradd56 = getelementptr inbounds i8, ptr %b, i64 1
+  %38 = load i8, ptr %ptradd56, align 1
+  %zext57 = zext i8 %38 to i32
+  %shl58 = shl i32 %zext57, 8
+  %39 = or i32 %shl58, %zext55
+  %ptradd59 = getelementptr inbounds i8, ptr %b, i64 2
+  %40 = load i8, ptr %ptradd59, align 1
+  %zext60 = zext i8 %40 to i32
+  %shl61 = shl i32 %zext60, 16
+  %41 = or i32 %shl61, %39
+  %ptradd62 = getelementptr inbounds i8, ptr %b, i64 3
+  %42 = load i8, ptr %ptradd62, align 1
+  %zext63 = zext i8 %42 to i32
+  %shl64 = shl i32 %zext63, 24
+  %43 = or i32 %shl64, %41
+  store i32 %43, ptr %taddr65, align 4
+  %44 = insertvalue %any undef, ptr %taddr65, 0
+  %45 = insertvalue %any %44, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
+  store %any %45, ptr %varargslots54, align 16
+  %ptradd66 = getelementptr inbounds i8, ptr %b, i64 4
+  %46 = load i8, ptr %ptradd66, align 1
+  %zext67 = zext i8 %46 to i32
+  %ptradd68 = getelementptr inbounds i8, ptr %b, i64 5
+  %47 = load i8, ptr %ptradd68, align 1
+  %zext69 = zext i8 %47 to i32
+  %shl70 = shl i32 %zext69, 8
+  %48 = or i32 %shl70, %zext67
+  %ptradd71 = getelementptr inbounds i8, ptr %b, i64 6
+  %49 = load i8, ptr %ptradd71, align 1
+  %zext72 = zext i8 %49 to i32
+  %shl73 = shl i32 %zext72, 16
+  %50 = or i32 %shl73, %48
+  %ptradd74 = getelementptr inbounds i8, ptr %b, i64 7
+  %51 = load i8, ptr %ptradd74, align 1
+  %zext75 = zext i8 %51 to i32
+  %shl76 = shl i32 %zext75, 24
+  %52 = or i32 %shl76, %50
+  %53 = and i32 2147483647, %52
+  store i32 %53, ptr %taddr77, align 4
+  %54 = insertvalue %any undef, ptr %taddr77, 0
+  %55 = insertvalue %any %54, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
+  %ptradd78 = getelementptr inbounds i8, ptr %varargslots54, i64 16
+  store %any %55, ptr %ptradd78, align 16
+  %ptradd79 = getelementptr inbounds i8, ptr %b, i64 7
+  %56 = load i8, ptr %ptradd79, align 1
+  %lshrl80 = lshr i8 %56, 7
+  %57 = trunc i8 %lshrl80 to i1
+  %58 = zext i1 %57 to i8
+  store i8 %58, ptr %taddr81, align 1
+  %59 = insertvalue %any undef, ptr %taddr81, 0
+  %60 = insertvalue %any %59, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  %ptradd82 = getelementptr inbounds i8, ptr %varargslots54, i64 32
+  store %any %60, ptr %ptradd82, align 16
+  %61 = call i64 @std.io.printfn(ptr %retparam83, ptr @.str.2, i64 8, ptr %varargslots54, i64 3)
   %add = add i32 %0, 1
-  %zext83 = zext i32 %add to i64
-  %61 = and i64 %zext83, 4294967295
-  %62 = and i64 %61, -9223372032559808513
-  %63 = or i64 %62, 4294967296
+  %zext85 = zext i32 %add to i64
+  %62 = and i64 %zext85, 4294967295
+  %63 = and i64 %62, -9223372032559808513
+  %64 = or i64 %63, 4294967296
   %gt = icmp sgt i32 %0, 100
-  %64 = zext i1 %gt to i8
-  %zext84 = zext i8 %64 to i64
-  %shl85 = shl i64 %zext84, 63
-  %65 = and i64 %shl85, -9223372036854775808
-  %66 = and i64 %63, 9223372036854775807
-  %67 = or i64 %66, %65
-  store i64 %67, ptr %x, align 8
-  %ptradd86 = getelementptr inbounds i8, ptr %y, i64 8
-  store i64 -9223371989610135519, ptr %ptradd86, align 8
-  store i8 0, ptr %b, align 1
-  %ptradd87 = getelementptr inbounds i8, ptr %b, i64 1
-  store i8 0, ptr %ptradd87, align 1
-  %ptradd88 = getelementptr inbounds i8, ptr %b, i64 2
-  store i8 0, ptr %ptradd88, align 1
-  %ptradd89 = getelementptr inbounds i8, ptr %b, i64 3
-  store i8 0, ptr %ptradd89, align 1
-  %ptradd90 = getelementptr inbounds i8, ptr %b, i64 4
+  %65 = zext i1 %gt to i8
+  %zext86 = zext i8 %65 to i64
+  %shl87 = shl i64 %zext86, 63
+  %66 = and i64 %shl87, -9223372036854775808
+  %67 = and i64 %64, 9223372036854775807
+  %68 = or i64 %67, %66
+  store i64 %68, ptr %.assign_list84, align 8
+  %69 = load i64, ptr %.assign_list84, align 8
+  store i64 %69, ptr %x, align 8
+  %ptradd88 = getelementptr inbounds i8, ptr %y, i64 8
+  store i64 -9223371989610135519, ptr %ptradd88, align 8
+  store i8 0, ptr %.assign_list89, align 1
+  %ptradd90 = getelementptr inbounds i8, ptr %.assign_list89, i64 1
   store i8 0, ptr %ptradd90, align 1
-  %ptradd91 = getelementptr inbounds i8, ptr %b, i64 5
+  %ptradd91 = getelementptr inbounds i8, ptr %.assign_list89, i64 2
   store i8 0, ptr %ptradd91, align 1
-  %ptradd92 = getelementptr inbounds i8, ptr %b, i64 6
+  %ptradd92 = getelementptr inbounds i8, ptr %.assign_list89, i64 3
   store i8 0, ptr %ptradd92, align 1
-  %ptradd93 = getelementptr inbounds i8, ptr %b, i64 7
+  %ptradd93 = getelementptr inbounds i8, ptr %.assign_list89, i64 4
   store i8 0, ptr %ptradd93, align 1
-  %add94 = add i32 %0, 1
-  %trunc95 = trunc i32 %add94 to i8
-  store i8 %trunc95, ptr %b, align 1
-  %lshrl96 = lshr i32 %add94, 8
-  %ptradd97 = getelementptr inbounds i8, ptr %b, i64 1
-  %trunc98 = trunc i32 %lshrl96 to i8
-  store i8 %trunc98, ptr %ptradd97, align 1
-  %lshrl99 = lshr i32 %lshrl96, 8
-  %ptradd100 = getelementptr inbounds i8, ptr %b, i64 2
+  %ptradd94 = getelementptr inbounds i8, ptr %.assign_list89, i64 5
+  store i8 0, ptr %ptradd94, align 1
+  %ptradd95 = getelementptr inbounds i8, ptr %.assign_list89, i64 6
+  store i8 0, ptr %ptradd95, align 1
+  %ptradd96 = getelementptr inbounds i8, ptr %.assign_list89, i64 7
+  store i8 0, ptr %ptradd96, align 1
+  %add97 = add i32 %0, 1
+  %trunc98 = trunc i32 %add97 to i8
+  store i8 %trunc98, ptr %.assign_list89, align 1
+  %lshrl99 = lshr i32 %add97, 8
+  %ptradd100 = getelementptr inbounds i8, ptr %.assign_list89, i64 1
   %trunc101 = trunc i32 %lshrl99 to i8
   store i8 %trunc101, ptr %ptradd100, align 1
   %lshrl102 = lshr i32 %lshrl99, 8
-  %ptradd103 = getelementptr inbounds i8, ptr %b, i64 3
+  %ptradd103 = getelementptr inbounds i8, ptr %.assign_list89, i64 2
   %trunc104 = trunc i32 %lshrl102 to i8
   store i8 %trunc104, ptr %ptradd103, align 1
   %lshrl105 = lshr i32 %lshrl102, 8
-  %ptradd106 = getelementptr inbounds i8, ptr %b, i64 4
-  store i8 1, ptr %ptradd106, align 1
-  %ptradd107 = getelementptr inbounds i8, ptr %b, i64 5
-  store i8 0, ptr %ptradd107, align 1
-  %ptradd108 = getelementptr inbounds i8, ptr %b, i64 6
-  store i8 0, ptr %ptradd108, align 1
-  %ptradd109 = getelementptr inbounds i8, ptr %b, i64 7
-  %68 = load i8, ptr %ptradd109, align 1
-  %69 = and i8 %68, -128
-  store i8 %69, ptr %ptradd109, align 1
-  %gt110 = icmp sgt i32 %0, 100
-  %70 = zext i1 %gt110 to i8
-  %shl111 = shl i8 %70, 7
-  %ptradd112 = getelementptr inbounds i8, ptr %b, i64 7
-  %71 = load i8, ptr %ptradd112, align 1
-  %72 = and i8 %71, 127
-  %73 = or i8 %72, %shl111
-  store i8 %73, ptr %ptradd112, align 1
-  %74 = load i64, ptr %x, align 8
-  %75 = and i64 4294967295, %74
-  %trunc114 = trunc i64 %75 to i32
-  store i32 %trunc114, ptr %taddr115, align 4
-  %76 = insertvalue %any undef, ptr %taddr115, 0
-  %77 = insertvalue %any %76, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
-  store %any %77, ptr %varargslots113, align 16
-  %78 = load i64, ptr %x, align 8
-  %lshrl116 = lshr i64 %78, 32
-  %79 = and i64 2147483647, %lshrl116
-  %trunc117 = trunc i64 %79 to i32
+  %ptradd106 = getelementptr inbounds i8, ptr %.assign_list89, i64 3
+  %trunc107 = trunc i32 %lshrl105 to i8
+  store i8 %trunc107, ptr %ptradd106, align 1
+  %lshrl108 = lshr i32 %lshrl105, 8
+  %ptradd109 = getelementptr inbounds i8, ptr %.assign_list89, i64 4
+  store i8 1, ptr %ptradd109, align 1
+  %ptradd110 = getelementptr inbounds i8, ptr %.assign_list89, i64 5
+  store i8 0, ptr %ptradd110, align 1
+  %ptradd111 = getelementptr inbounds i8, ptr %.assign_list89, i64 6
+  store i8 0, ptr %ptradd111, align 1
+  %ptradd112 = getelementptr inbounds i8, ptr %.assign_list89, i64 7
+  %70 = load i8, ptr %ptradd112, align 1
+  %71 = and i8 %70, -128
+  store i8 %71, ptr %ptradd112, align 1
+  %gt113 = icmp sgt i32 %0, 100
+  %72 = zext i1 %gt113 to i8
+  %shl114 = shl i8 %72, 7
+  %ptradd115 = getelementptr inbounds i8, ptr %.assign_list89, i64 7
+  %73 = load i8, ptr %ptradd115, align 1
+  %74 = and i8 %73, 127
+  %75 = or i8 %74, %shl114
+  store i8 %75, ptr %ptradd115, align 1
+  call void @llvm.memcpy.p0.p0.i32(ptr align 1 %b, ptr align 1 %.assign_list89, i32 8, i1 false)
+  %76 = load i64, ptr %x, align 8
+  %77 = and i64 4294967295, %76
+  %trunc117 = trunc i64 %77 to i32
   store i32 %trunc117, ptr %taddr118, align 4
-  %80 = insertvalue %any undef, ptr %taddr118, 0
-  %81 = insertvalue %any %80, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
-  %ptradd119 = getelementptr inbounds i8, ptr %varargslots113, i64 16
-  store %any %81, ptr %ptradd119, align 16
-  %82 = load i64, ptr %x, align 8
-  %lshrl120 = lshr i64 %82, 63
-  %83 = and i64 1, %lshrl120
-  %trunc121 = trunc i64 %83 to i8
-  store i8 %trunc121, ptr %taddr122, align 1
-  %84 = insertvalue %any undef, ptr %taddr122, 0
-  %85 = insertvalue %any %84, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %ptradd123 = getelementptr inbounds i8, ptr %varargslots113, i64 32
-  store %any %85, ptr %ptradd123, align 16
-  %86 = call i64 @std.io.printfn(ptr %retparam124, ptr @.str.3, i64 8, ptr %varargslots113, i64 3)
-  %ptradd126 = getelementptr inbounds i8, ptr %y, i64 8
-  %87 = load i64, ptr %ptradd126, align 8
-  %88 = and i64 4294967295, %87
-  %trunc127 = trunc i64 %88 to i32
-  store i32 %trunc127, ptr %taddr128, align 4
-  %89 = insertvalue %any undef, ptr %taddr128, 0
-  %90 = insertvalue %any %89, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
-  store %any %90, ptr %varargslots125, align 16
+  %78 = insertvalue %any undef, ptr %taddr118, 0
+  %79 = insertvalue %any %78, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
+  store %any %79, ptr %varargslots116, align 16
+  %80 = load i64, ptr %x, align 8
+  %lshrl119 = lshr i64 %80, 32
+  %81 = and i64 2147483647, %lshrl119
+  %trunc120 = trunc i64 %81 to i32
+  store i32 %trunc120, ptr %taddr121, align 4
+  %82 = insertvalue %any undef, ptr %taddr121, 0
+  %83 = insertvalue %any %82, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
+  %ptradd122 = getelementptr inbounds i8, ptr %varargslots116, i64 16
+  store %any %83, ptr %ptradd122, align 16
+  %84 = load i64, ptr %x, align 8
+  %lshrl123 = lshr i64 %84, 63
+  %85 = and i64 1, %lshrl123
+  %trunc124 = trunc i64 %85 to i8
+  store i8 %trunc124, ptr %taddr125, align 1
+  %86 = insertvalue %any undef, ptr %taddr125, 0
+  %87 = insertvalue %any %86, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  %ptradd126 = getelementptr inbounds i8, ptr %varargslots116, i64 32
+  store %any %87, ptr %ptradd126, align 16
+  %88 = call i64 @std.io.printfn(ptr %retparam127, ptr @.str.3, i64 8, ptr %varargslots116, i64 3)
   %ptradd129 = getelementptr inbounds i8, ptr %y, i64 8
-  %91 = load i64, ptr %ptradd129, align 8
-  %lshrl130 = lshr i64 %91, 32
-  %92 = and i64 2147483647, %lshrl130
-  %trunc131 = trunc i64 %92 to i32
-  store i32 %trunc131, ptr %taddr132, align 4
-  %93 = insertvalue %any undef, ptr %taddr132, 0
-  %94 = insertvalue %any %93, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
-  %ptradd133 = getelementptr inbounds i8, ptr %varargslots125, i64 16
-  store %any %94, ptr %ptradd133, align 16
-  %ptradd134 = getelementptr inbounds i8, ptr %y, i64 8
-  %95 = load i64, ptr %ptradd134, align 8
-  %lshrl135 = lshr i64 %95, 63
-  %96 = and i64 1, %lshrl135
-  %trunc136 = trunc i64 %96 to i8
-  store i8 %trunc136, ptr %taddr137, align 1
-  %97 = insertvalue %any undef, ptr %taddr137, 0
-  %98 = insertvalue %any %97, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %ptradd138 = getelementptr inbounds i8, ptr %varargslots125, i64 32
-  store %any %98, ptr %ptradd138, align 16
-  %99 = call i64 @std.io.printfn(ptr %retparam139, ptr @.str.4, i64 8, ptr %varargslots125, i64 3)
-  %100 = load i8, ptr %b, align 1
-  %zext141 = zext i8 %100 to i32
-  %ptradd142 = getelementptr inbounds i8, ptr %b, i64 1
-  %101 = load i8, ptr %ptradd142, align 1
-  %zext143 = zext i8 %101 to i32
-  %shl144 = shl i32 %zext143, 8
-  %102 = or i32 %shl144, %zext141
-  %ptradd145 = getelementptr inbounds i8, ptr %b, i64 2
+  %89 = load i64, ptr %ptradd129, align 8
+  %90 = and i64 4294967295, %89
+  %trunc130 = trunc i64 %90 to i32
+  store i32 %trunc130, ptr %taddr131, align 4
+  %91 = insertvalue %any undef, ptr %taddr131, 0
+  %92 = insertvalue %any %91, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
+  store %any %92, ptr %varargslots128, align 16
+  %ptradd132 = getelementptr inbounds i8, ptr %y, i64 8
+  %93 = load i64, ptr %ptradd132, align 8
+  %lshrl133 = lshr i64 %93, 32
+  %94 = and i64 2147483647, %lshrl133
+  %trunc134 = trunc i64 %94 to i32
+  store i32 %trunc134, ptr %taddr135, align 4
+  %95 = insertvalue %any undef, ptr %taddr135, 0
+  %96 = insertvalue %any %95, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
+  %ptradd136 = getelementptr inbounds i8, ptr %varargslots128, i64 16
+  store %any %96, ptr %ptradd136, align 16
+  %ptradd137 = getelementptr inbounds i8, ptr %y, i64 8
+  %97 = load i64, ptr %ptradd137, align 8
+  %lshrl138 = lshr i64 %97, 63
+  %98 = and i64 1, %lshrl138
+  %trunc139 = trunc i64 %98 to i8
+  store i8 %trunc139, ptr %taddr140, align 1
+  %99 = insertvalue %any undef, ptr %taddr140, 0
+  %100 = insertvalue %any %99, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  %ptradd141 = getelementptr inbounds i8, ptr %varargslots128, i64 32
+  store %any %100, ptr %ptradd141, align 16
+  %101 = call i64 @std.io.printfn(ptr %retparam142, ptr @.str.4, i64 8, ptr %varargslots128, i64 3)
+  %102 = load i8, ptr %b, align 1
+  %zext144 = zext i8 %102 to i32
+  %ptradd145 = getelementptr inbounds i8, ptr %b, i64 1
   %103 = load i8, ptr %ptradd145, align 1
   %zext146 = zext i8 %103 to i32
-  %shl147 = shl i32 %zext146, 16
-  %104 = or i32 %shl147, %102
-  %ptradd148 = getelementptr inbounds i8, ptr %b, i64 3
+  %shl147 = shl i32 %zext146, 8
+  %104 = or i32 %shl147, %zext144
+  %ptradd148 = getelementptr inbounds i8, ptr %b, i64 2
   %105 = load i8, ptr %ptradd148, align 1
   %zext149 = zext i8 %105 to i32
-  %shl150 = shl i32 %zext149, 24
+  %shl150 = shl i32 %zext149, 16
   %106 = or i32 %shl150, %104
-  store i32 %106, ptr %taddr151, align 4
-  %107 = insertvalue %any undef, ptr %taddr151, 0
-  %108 = insertvalue %any %107, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
-  store %any %108, ptr %varargslots140, align 16
-  %ptradd152 = getelementptr inbounds i8, ptr %b, i64 4
-  %109 = load i8, ptr %ptradd152, align 1
-  %zext153 = zext i8 %109 to i32
-  %ptradd154 = getelementptr inbounds i8, ptr %b, i64 5
-  %110 = load i8, ptr %ptradd154, align 1
-  %zext155 = zext i8 %110 to i32
-  %shl156 = shl i32 %zext155, 8
-  %111 = or i32 %shl156, %zext153
-  %ptradd157 = getelementptr inbounds i8, ptr %b, i64 6
+  %ptradd151 = getelementptr inbounds i8, ptr %b, i64 3
+  %107 = load i8, ptr %ptradd151, align 1
+  %zext152 = zext i8 %107 to i32
+  %shl153 = shl i32 %zext152, 24
+  %108 = or i32 %shl153, %106
+  store i32 %108, ptr %taddr154, align 4
+  %109 = insertvalue %any undef, ptr %taddr154, 0
+  %110 = insertvalue %any %109, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
+  store %any %110, ptr %varargslots143, align 16
+  %ptradd155 = getelementptr inbounds i8, ptr %b, i64 4
+  %111 = load i8, ptr %ptradd155, align 1
+  %zext156 = zext i8 %111 to i32
+  %ptradd157 = getelementptr inbounds i8, ptr %b, i64 5
   %112 = load i8, ptr %ptradd157, align 1
   %zext158 = zext i8 %112 to i32
-  %shl159 = shl i32 %zext158, 16
-  %113 = or i32 %shl159, %111
-  %ptradd160 = getelementptr inbounds i8, ptr %b, i64 7
+  %shl159 = shl i32 %zext158, 8
+  %113 = or i32 %shl159, %zext156
+  %ptradd160 = getelementptr inbounds i8, ptr %b, i64 6
   %114 = load i8, ptr %ptradd160, align 1
   %zext161 = zext i8 %114 to i32
-  %shl162 = shl i32 %zext161, 24
+  %shl162 = shl i32 %zext161, 16
   %115 = or i32 %shl162, %113
-  %116 = and i32 2147483647, %115
-  store i32 %116, ptr %taddr163, align 4
-  %117 = insertvalue %any undef, ptr %taddr163, 0
-  %118 = insertvalue %any %117, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
-  %ptradd164 = getelementptr inbounds i8, ptr %varargslots140, i64 16
-  store %any %118, ptr %ptradd164, align 16
-  %ptradd165 = getelementptr inbounds i8, ptr %b, i64 7
-  %119 = load i8, ptr %ptradd165, align 1
-  %lshrl166 = lshr i8 %119, 7
-  %120 = trunc i8 %lshrl166 to i1
-  %121 = zext i1 %120 to i8
-  store i8 %121, ptr %taddr167, align 1
-  %122 = insertvalue %any undef, ptr %taddr167, 0
-  %123 = insertvalue %any %122, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  %ptradd168 = getelementptr inbounds i8, ptr %varargslots140, i64 32
-  store %any %123, ptr %ptradd168, align 16
-  %124 = call i64 @std.io.printfn(ptr %retparam169, ptr @.str.5, i64 8, ptr %varargslots140, i64 3)
+  %ptradd163 = getelementptr inbounds i8, ptr %b, i64 7
+  %116 = load i8, ptr %ptradd163, align 1
+  %zext164 = zext i8 %116 to i32
+  %shl165 = shl i32 %zext164, 24
+  %117 = or i32 %shl165, %115
+  %118 = and i32 2147483647, %117
+  store i32 %118, ptr %taddr166, align 4
+  %119 = insertvalue %any undef, ptr %taddr166, 0
+  %120 = insertvalue %any %119, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
+  %ptradd167 = getelementptr inbounds i8, ptr %varargslots143, i64 16
+  store %any %120, ptr %ptradd167, align 16
+  %ptradd168 = getelementptr inbounds i8, ptr %b, i64 7
+  %121 = load i8, ptr %ptradd168, align 1
+  %lshrl169 = lshr i8 %121, 7
+  %122 = trunc i8 %lshrl169 to i1
+  %123 = zext i1 %122 to i8
+  store i8 %123, ptr %taddr170, align 1
+  %124 = insertvalue %any undef, ptr %taddr170, 0
+  %125 = insertvalue %any %124, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
+  %ptradd171 = getelementptr inbounds i8, ptr %varargslots143, i64 32
+  store %any %125, ptr %ptradd171, align 16
+  %126 = call i64 @std.io.printfn(ptr %retparam172, ptr @.str.5, i64 8, ptr %varargslots143, i64 3)
   ret void
 }
 
diff --git a/test/test_suite/struct/struct_reinit.c3t b/test/test_suite/struct/struct_reinit.c3t
new file mode 100644
index 000000000..1f9ccde30
--- /dev/null
+++ b/test/test_suite/struct/struct_reinit.c3t
@@ -0,0 +1,40 @@
+// #target: macos-x64
+module test;
+import std;
+struct Abc
+{
+	int a;
+	int b;
+}
+
+fn void print(Abc* x)
+{
+	io::printfn("%d %d", x.a, x.b);
+}
+fn void main()
+{
+	Abc x = { 1, 4};
+	print(&x) @noinline;
+	x = Abc { x.b, x.a };
+	print(&x) @noinline;
+}
+
+/* #expect: test.ll
+
+define void @test.main() #0 {
+entry:
+  %x = alloca %Abc, align 4
+  %.assign_list = alloca %Abc, align 4
+  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %x, ptr align 4 @.__const, i32 8, i1 false)
+  call void @test.print(ptr %x) #3
+  %ptradd = getelementptr inbounds i8, ptr %x, i64 4
+  %0 = load i32, ptr %ptradd, align 4
+  store i32 %0, ptr %.assign_list, align 4
+  %ptradd1 = getelementptr inbounds i8, ptr %.assign_list, i64 4
+  %1 = load i32, ptr %x, align 4
+  store i32 %1, ptr %ptradd1, align 4
+  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %x, ptr align 4 %.assign_list, i32 8, i1 false)
+  call void @test.print(ptr %x) #3
+  ret void
+}
+