LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_C99DataTagRepr_Unit
static struct mirth_c99_C99DataUnitRepr* mtp_mirth_c99_C99DataTagRepr_Unit (struct mirth_c99_C99DataTagRepr in_C99DataTagRepr_1) {
	struct mirth_c99_C99DataTagRepr_Unit v3 = *in_C99DataTagRepr_1.ptr.Unit;
	if (!--(in_C99DataTagRepr_1.ptr.Unit->refs)) {
		free(in_C99DataTagRepr_1.ptr.Unit);
	} else {
		incref(MK_mirth_c99_C99DataUnitRepr(v3.mC99DataUnitRepr));
	}
	return v3.mC99DataUnitRepr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0xaf06a
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xaf06f
incl (%rax)
jmp 0xaf06f
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_C99DataTagRepr_Enum
static struct mirth_c99_C99DataEnumTagRepr* mtp_mirth_c99_C99DataTagRepr_Enum (struct mirth_c99_C99DataTagRepr in_C99DataTagRepr_1) {
	struct mirth_c99_C99DataTagRepr_Enum v3 = *in_C99DataTagRepr_1.ptr.Enum;
	if (!--(in_C99DataTagRepr_1.ptr.Enum->refs)) {
		free(in_C99DataTagRepr_1.ptr.Enum);
	} else {
		incref(MK_mirth_c99_C99DataEnumTagRepr(v3.mC99DataEnumTagRepr));
	}
	return v3.mC99DataEnumTagRepr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0xaf0a5
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xaf0aa
incl (%rax)
jmp 0xaf0aa
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_C99DataTagRepr_Trans
static struct mirth_c99_C99DataTransRepr* mtp_mirth_c99_C99DataTagRepr_Trans (struct mirth_c99_C99DataTagRepr in_C99DataTagRepr_1) {
	struct mirth_c99_C99DataTagRepr_Trans v3 = *in_C99DataTagRepr_1.ptr.Trans;
	if (!--(in_C99DataTagRepr_1.ptr.Trans->refs)) {
		free(in_C99DataTagRepr_1.ptr.Trans);
	} else {
		incref(MK_mirth_c99_C99DataTransRepr(v3.mC99DataTransRepr));
	}
	return v3.mC99DataTransRepr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0xaf0e0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xaf0e5
incl (%rax)
jmp 0xaf0e5
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_C99DataTagRepr_Struct
static struct mirth_c99_C99DataStructRepr* mtp_mirth_c99_C99DataTagRepr_Struct (struct mirth_c99_C99DataTagRepr in_C99DataTagRepr_1) {
	struct mirth_c99_C99DataTagRepr_Struct v3 = *in_C99DataTagRepr_1.ptr.Struct;
	if (!--(in_C99DataTagRepr_1.ptr.Struct->refs)) {
		free(in_C99DataTagRepr_1.ptr.Struct);
	} else {
		incref(MK_mirth_c99_C99DataStructRepr(v3.mC99DataStructRepr));
	}
	return v3.mC99DataStructRepr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0xaf11b
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xaf120
incl (%rax)
jmp 0xaf120
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_C99DataTagRepr_Sum
static struct mirth_c99_C99DataSumTagRepr mtp_mirth_c99_C99DataTagRepr_Sum (struct mirth_c99_C99DataTagRepr in_C99DataTagRepr_1) {
	struct mirth_c99_C99DataTagRepr_Sum v3 = *in_C99DataTagRepr_1.ptr.Sum;
	if (!--(in_C99DataTagRepr_1.ptr.Sum->refs)) {
		free(in_C99DataTagRepr_1.ptr.Sum);
	} else {
		incref(MK_mirth_c99_C99DataSumTagRepr(v3.mC99DataSumTagRepr));
	}
	return v3.mC99DataSumTagRepr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x8(%rdi), %ebx
movq 0x10(%rdi), %r14
decl (%rdi)
je 0xaf15b
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r14, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0xaf160
incl (%rax)
jmp 0xaf160
callq 0x5030
movl %ebx, %eax
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99_freshzenamezx
static STR* mw_mirth_c99_zaC99_freshzenamezx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99* in_zaC99_2, struct mirth_mirth_zaMirth* *out_zaMirth_3, struct mirth_c99_zaC99* *out_zaC99_4) {
	STR* v6;
	STRLIT(v6, "v", 1);
	struct mirth_mirth_zaMirth* v7;
	struct mirth_c99_zaC99* v8;
	STR* v9 = mw_mirth_c99_zaC99_freshzenamezeonzx(in_zaMirth_1, in_zaC99_2, v6, &v7, &v8);
	*out_zaC99_4 = v8;
	*out_zaMirth_3 = v7;
	return v9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movq %rdi, %r12
movq 0x1068a29(%rip), %rdx   # 0x1117ce8
testq %rdx, %rdx
jne 0xaf2e4
movl $0x1, %edi
callq 0xf5e4
movq %rax, %rdx
movq $0x1, 0x10(%rax)
movb $0x76, 0x18(%rax)
movq %rax, 0x1068a04(%rip)   # 0x1117ce8
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0xaf302
incl (%rax)
leaq -0x40(%rbp), %r13
leaq -0x38(%rbp), %rbx
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rcx
movq %rbx, %r8
callq 0xac8ce
movq (%rbx), %rcx
movq %rcx, (%r14)
movq (%r13), %rcx
movq -0x30(%rbp), %rdx
movq %rcx, (%rdx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99ValuezfResource_convertzedatazx
static void mw_mirth_c99_zaC99ValuezfResource_convertzedatazx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99Branch* in_zaC99Branch_2, struct std_either_zaEither_2 in_zaC99ValuezfResource_3, uint64_t in_Data_4, struct mirth_mirth_zaMirth* *out_zaMirth_5, struct mirth_c99_zaC99Branch* *out_zaC99Branch_6, struct std_either_zaEither_2 *out_zaC99ValuezfResource_7) {
	struct mirth_c99_C99ReprType v8 = mtw_mirth_c99_C99ReprType_Data(in_Data_4);
	struct mirth_mirth_zaMirth* v9;
	struct mirth_c99_zaC99Branch* v10;
	struct std_either_zaEither_2 v11;
	mw_mirth_c99_zaC99ValuezfResource_convertzevaluezfresourcezx(in_zaMirth_1, in_zaC99Branch_2, v8, in_zaC99ValuezfResource_3, &v9, &v10, &v11);
	struct mirth_mirth_zaMirth* v12;
	bool v13 = mw_mirth_data_Data_iszeresourcezy(v9, in_Data_4, &v12);
	struct mirth_c99_zaC99Branch* branch_zaC99Branch_14;
	struct mirth_mirth_zaMirth* branch_zaMirth_15;
	struct std_either_zaEither_2 branch_zaC99ValuezfResource_16;
	if (v13) {
		struct mirth_c99_zaC99Resource* v17;
		mw_mirth_c99_zaC99ValuezfResource_turnzeintozeresourcezx(v11, &v17);
		struct std_either_zaEither_2 v18;
		mw_mirth_c99_zaC99ValuezfResource_zaRight(v17, &v18);
		branch_zaC99ValuezfResource_16 = v18;
		branch_zaMirth_15 = v12;
		branch_zaC99Branch_14 = v10;
	} else {
		struct mirth_c99_zaC99Value* v19;
		mw_mirth_c99_zaC99ValuezfResource_turnzeintozevaluezx(v11, &v19);
		struct std_either_zaEither_2 v20;
		mw_mirth_c99_zaC99ValuezfResource_zaLeft(v19, &v20);
		branch_zaC99ValuezfResource_16 = v20;
		branch_zaMirth_15 = v12;
		branch_zaC99Branch_14 = v10;
	}
	*out_zaC99ValuezfResource_7 = branch_zaC99ValuezfResource_16;
	*out_zaC99Branch_6 = branch_zaC99Branch_14;
	*out_zaMirth_5 = branch_zaMirth_15;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, -0x50(%rbp)
movq %r8, %r14
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
callq 0x9c4cb
subq $0x8, %rsp
leaq -0x38(%rbp), %r11
leaq -0x70(%rbp), %r10
movq %rbx, %rdi
movq %r13, %rsi
movl $0x15, %edx
movq %rax, %rcx
movl %r12d, %r8d
movq %r15, %r9
leaq -0x48(%rbp), %rax
pushq %rax
pushq %r11
pushq %r10
movq %r10, %rbx
callq 0xb2f5e
addq $0x20, %rsp
movq (%rbx), %rdi
leaq -0x30(%rbp), %rdx
movq %r14, %rsi
callq 0x207b0
testb %al, %al
je 0xaf3d0
movl -0x48(%rbp), %edi
movq -0x40(%rbp), %rsi
leaq -0x58(%rbp), %rbx
movq %rbx, %rdx
callq 0xb3078
movq (%rbx), %rdi
leaq -0x68(%rbp), %rsi
callq 0xb2a4b
jmp 0xaf3ef
movl -0x48(%rbp), %edi
movq -0x40(%rbp), %rsi
leaq -0x58(%rbp), %rbx
movq %rbx, %rdx
callq 0xb3117
movq (%rbx), %rdi
leaq -0x68(%rbp), %rsi
callq 0xb2efb
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movups -0x68(%rbp), %xmm0
movq 0x18(%rbp), %rdx
movups %xmm0, (%rdx)
movq 0x10(%rbp), %rdx
movq %rcx, (%rdx)
movq -0x50(%rbp), %rcx
movq %rax, (%rcx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99ValuezfResource_rdrop
static void mw_mirth_c99_zaC99ValuezfResource_rdrop (struct std_either_zaEither_2 in_zaC99ValuezfResource_1) {
	switch ((in_zaC99ValuezfResource_1).tag) {
		case std_either_zaEither_2_zaLeft: {
			VAL v2;
			mtp_std_either_zaEither_2_zaLeft(in_zaC99ValuezfResource_1, &v2);
			mw_mirth_c99_zaC99Value_rdrop(V_mirth_c99_zaC99Value(v2));
		} break;
		case std_either_zaEither_2_zaRight: {
			VAL v3;
			mtp_std_either_zaEither_2_zaRight(in_zaC99ValuezfResource_1, &v3);
			mw_mirth_c99_zaC99Resource_rdrop(V_mirth_c99_zaC99Resource(v3));
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x1, %edi
je 0xaf644
testl %edi, %edi
jne 0xaf65d
movq (%rsi), %rbx
movq %rsi, %rdi
callq 0x5030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb2deb
movq (%rsi), %rbx
movq %rsi, %rdi
callq 0x5030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb2e73
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x31057(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x3105c(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataUnitRepr_vzemacrozeprefixzesuffix
static VAL mw_mirth_c99_C99DataUnitRepr_vzemacrozeprefixzesuffix (struct mirth_c99_C99DataUnitRepr* in_C99DataUnitRepr_1, VAL *out__3) {
	decref(MK_mirth_c99_C99DataUnitRepr(in_C99DataUnitRepr_1));
	STR* v4;
	STRLIT(v4, "(", 1);
	STR* v5;
	STRLIT(v5, ", 0)", 4);
	*out__3 = MKSTR(v5);
	return MKSTR(v4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq %rdi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xb2194
decl (%rax)
jne 0xb2194
leaq 0x60c32(%rip), %rsi     # 0x112dc1
callq 0xd13d
movq 0x1065a5d(%rip), %r14   # 0x1117bf8
testq %r14, %r14
jne 0xb21c0
movl $0x1, %edi
callq 0xf5e4
movq %rax, %r14
movq $0x1, 0x10(%rax)
movb $0x28, 0x18(%rax)
movq %rax, 0x1065a38(%rip)   # 0x1117bf8
movq %r14, %rax
andq %r15, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0xb21d6
incl (%rax)
movq 0x1065a23(%rip), %rax   # 0x1117c00
testq %rax, %rax
jne 0xb2202
movl $0x4, %edi
callq 0xf5e4
movq $0x4, 0x10(%rax)
movl $0x2930202c, 0x18(%rax) # imm = 0x2930202C
movq %rax, 0x10659fe(%rip)   # 0x1117c00
andq %rax, %r15
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0xb2214
incl (%r15)
leaq 0x5ef3e(%rip), %rdx     # 0x111159
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataEnumRepr_vzemacrozeprefixzesuffix
static STR* mw_mirth_c99_C99DataEnumRepr_vzemacrozeprefixzesuffix (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_C99DataEnumRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3, VAL *out__5) {
	struct mirth_mirth_zaMirth* v6;
	STR* v7 = mw_mirth_c99_C99DataEnumRepr_cname(in_zaMirth_1, in_C99DataEnumRepr_2, &v6);
	STR* v8 = mw_std_prim_Str_Str_1_sp36(v7);
	STR* v9;
	STRLIT(v9, ")", 1);
	*out__5 = MKSTR(v9);
	*out_zaMirth_3 = v6;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %rbx
leaq -0x28(%rbp), %r15
movq %r15, %rdx
callq 0x9b7b1
movq (%r15), %r12
movq %rax, %rdi
callq 0xb25a9
movq %rax, %r15
movq 0x10659a2(%rip), %rax   # 0x1117c08
testq %rax, %rax
jne 0xb2288
movl $0x1, %edi
callq 0xf5e4
movq $0x1, 0x10(%rax)
movb $0x29, 0x18(%rax)
movq %rax, 0x1065980(%rip)   # 0x1117c08
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0xb22a5
incl (%rcx)
leaq 0x5eead(%rip), %rcx     # 0x111159
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
movq %r12, (%rbx)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataTransRepr_vzemacrozeprefixzesuffix
static STR* mw_mirth_c99_C99DataTransRepr_vzemacrozeprefixzesuffix (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataTransRepr* in_C99DataTransRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3, STR* *out_Str_5) {
	struct mirth_c99_C99ReprType v6 = in_C99DataTransRepr_2->mc99zerepr;
	incref(MK_mirth_c99_C99ReprType(v6));
	decref(MK_mirth_c99_C99DataTransRepr(in_C99DataTransRepr_2));
	struct mirth_mirth_zaMirth* v7;
	STR* v8;
	STR* v9 = mw_mirth_c99_C99ReprType_vzemacrozeprefixzesuffix(in_zaMirth_1, v6, &v7, &v8);
	*out_Str_5 = v8;
	*out_zaMirth_3 = v7;
	return v9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rdi, %r15
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movl 0x30(%rsi), %r12d
movq 0x38(%rsi), %r13
movq %r13, %rcx
andq %rax, %rcx
sete %dl
testb $0x3, %r13b
setne %dil
orb %dl, %dil
jne 0xb230c
incl (%rcx)
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xb2333
decl (%rax)
jne 0xb2333
leaq 0x60b29(%rip), %rax     # 0x112e51
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd13d
leaq -0x48(%rbp), %rbx
leaq -0x40(%rbp), %r14
movq %r15, %rdi
movl %r12d, %esi
movq %r13, %rdx
movq %rbx, %rcx
movq %r14, %r8
callq 0xb11ca
movq (%r14), %rcx
movq -0x30(%rbp), %rdx
movq %rcx, (%rdx)
movq (%rbx), %rcx
movq -0x38(%rbp), %rdx
movq %rcx, (%rdx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataStructRepr_vzemacrozeprefixzesuffix
static STR* mw_mirth_c99_C99DataStructRepr_vzemacrozeprefixzesuffix (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataStructRepr* in_C99DataStructRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3, STR* *out_Str_5) {
	STR* v6;
	STRLIT(v6, "", 0);
	STR* v7;
	STRLIT(v7, "V_", 2);
	STR* v8;
	mw_std_str_zaStr_pushzestrzx(v7, v6, &v8);
	STR* v9 = in_C99DataStructRepr_2->mcname;
	incref(MKSTR(v9));
	decref(MK_mirth_c99_C99DataStructRepr(in_C99DataStructRepr_2));
	STR* v10;
	mw_std_str_zaStr_pushzestrzx(v9, v8, &v10);
	STR* v11;
	STRLIT(v11, "(", 1);
	STR* v12;
	mw_std_str_zaStr_pushzestrzx(v11, v10, &v12);
	STR* v13;
	STRLIT(v13, ")", 1);
	*out_Str_5 = v13;
	*out_zaMirth_3 = in_zaMirth_1;
	return v12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rsi, %r12
movq %rdi, %r15
movq 0x1065890(%rip), %r13   # 0x1117c28
testq %r13, %r13
jne 0xb23b6
xorl %edi, %edi
callq 0xf5e4
movq %rax, %r13
movq $0x0, 0x10(%rax)
movq %rax, 0x1065872(%rip)   # 0x1117c28
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
movq %r13, %rax
andq %r14, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0xb23d6
incl (%rax)
movq 0x1065853(%rip), %rsi   # 0x1117c30
testq %rsi, %rsi
jne 0xb2404
movl $0x2, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x2, 0x10(%rax)
movw $0x5f56, 0x18(%rax)     # imm = 0x5F56
movq %rax, 0x106582c(%rip)   # 0x1117c30
movq %rsi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xb241a
incl (%rax)
movq %r13, %rdi
callq 0xe069
movq %rax, %r13
movq 0x10(%r12), %rbx
movq %rbx, %rax
andq %r14, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xb243f
incl (%rax)
movq %r12, %rax
andq %r14, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0xb2466
decl (%rax)
jne 0xb2466
leaq 0x60a3b(%rip), %rsi     # 0x112e99
movq %r12, %rdi
callq 0xd13d
movq %r13, %rdi
movq %rbx, %rsi
callq 0xe069
movq %rax, %rbx
movq 0x10657bd(%rip), %rsi   # 0x1117c38
testq %rsi, %rsi
jne 0xb24a0
movl $0x1, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x1, 0x10(%rax)
movb $0x28, 0x18(%rax)
movq %rax, 0x1065798(%rip)   # 0x1117c38
movq %rsi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xb24b6
incl (%rax)
movq %rbx, %rdi
callq 0xe069
movq %rax, %rbx
movq 0x1065778(%rip), %rax   # 0x1117c40
testq %rax, %rax
jne 0xb24ea
movl $0x1, %edi
callq 0xf5e4
movq $0x1, 0x10(%rax)
movb $0x29, 0x18(%rax)
movq %rax, 0x1065756(%rip)   # 0x1117c40
andq %rax, %r14
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0xb24fc
incl (%r14)
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
movq -0x38(%rbp), %rax
movq %r15, (%rax)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataSumRepr_vzemacrozeprefixzesuffix
static STR* mw_mirth_c99_C99DataSumRepr_vzemacrozeprefixzesuffix (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataSumRepr* in_C99DataSumRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3, VAL *out__5) {
	struct mirth_mirth_zaMirth* v6;
	STR* v7 = mw_mirth_c99_C99DataSumRepr_cname(in_zaMirth_1, in_C99DataSumRepr_2, &v6);
	STR* v8 = mw_std_prim_Str_Str_1_sp36(v7);
	STR* v9;
	STRLIT(v9, ")", 1);
	*out__5 = MKSTR(v9);
	*out_zaMirth_3 = v6;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
leaq -0x20(%rbp), %rdx
callq 0xa0ea2
movq %rax, %rdi
callq 0xb25a9
movq %rax, %r15
movq 0x1065701(%rip), %rax   # 0x1117c48
testq %rax, %rax
jne 0xb2569
movl $0x1, %edi
callq 0xf5e4
movq $0x1, 0x10(%rax)
movb $0x29, 0x18(%rax)
movq %rax, 0x10656df(%rip)   # 0x1117c48
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0xb2586
incl (%rcx)
leaq 0x5ebcc(%rip), %rcx     # 0x111159
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
movq -0x20(%rbp), %rax
movq %rax, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_prim_Str_Str_1_sp36
static STR* mw_std_prim_Str_Str_1_sp36 (STR* in_Str_1) {
	STR* v3;
	STRLIT(v3, "", 0);
	STR* v4;
	STRLIT(v4, "V_", 2);
	STR* v5;
	mw_std_str_zaStr_pushzestrzx(v4, v3, &v5);
	STR* v6;
	mw_std_str_zaStr_pushzestrzx(in_Str_1, v5, &v6);
	STR* v7;
	STRLIT(v7, "(", 1);
	STR* v8;
	mw_std_str_zaStr_pushzestrzx(v7, v6, &v8);
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1065653(%rip), %r14   # 0x1117c10
testq %r14, %r14
jne 0xb25db
xorl %edi, %edi
callq 0xf5e4
movq %rax, %r14
movq $0x0, 0x10(%rax)
movq %rax, 0x1065635(%rip)   # 0x1117c10
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq %r14, %rax
andq %r15, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0xb25fb
incl (%rax)
movq 0x1065616(%rip), %rsi   # 0x1117c18
testq %rsi, %rsi
jne 0xb2629
movl $0x2, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x2, 0x10(%rax)
movw $0x5f56, 0x18(%rax)     # imm = 0x5F56
movq %rax, 0x10655ef(%rip)   # 0x1117c18
movq %rsi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xb263f
incl (%rax)
movq %r14, %rdi
callq 0xe069
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe069
movq %rax, %rbx
movq 0x10655c4(%rip), %rsi   # 0x1117c20
testq %rsi, %rsi
jne 0xb2681
movl $0x1, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x1, 0x10(%rax)
movb $0x28, 0x18(%rax)
movq %rax, 0x106559f(%rip)   # 0x1117c20
andq %rsi, %r15
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xb2695
incl (%r15)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe069
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99_freshzeresourcezenamezx
static STR* mw_mirth_c99_zaC99_freshzeresourcezenamezx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99* in_zaC99_2, struct mirth_mirth_zaMirth* *out_zaMirth_3, struct mirth_c99_zaC99* *out_zaC99_4) {
	STR* v6;
	STRLIT(v6, "r", 1);
	struct mirth_mirth_zaMirth* v7;
	struct mirth_c99_zaC99* v8;
	STR* v9 = mw_mirth_c99_zaC99_freshzenamezeonzx(in_zaMirth_1, in_zaC99_2, v6, &v7, &v8);
	*out_zaC99_4 = v8;
	*out_zaMirth_3 = v7;
	return v9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movq %rdi, %r12
movq 0x10652b1(%rip), %rdx   # 0x1117c80
testq %rdx, %rdx
jne 0xb29f4
movl $0x1, %edi
callq 0xf5e4
movq %rax, %rdx
movq $0x1, 0x10(%rax)
movb $0x72, 0x18(%rax)
movq %rax, 0x106528c(%rip)   # 0x1117c80
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0xb2a12
incl (%rax)
leaq -0x40(%rbp), %r13
leaq -0x38(%rbp), %rbx
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rcx
movq %rbx, %r8
callq 0xac8ce
movq (%rbx), %rcx
movq %rcx, (%r14)
movq (%r13), %rcx
movq -0x30(%rbp), %rdx
movq %rcx, (%rdx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_std_either_zaEither_2_zaRight
static void mtw_std_either_zaEither_2_zaRight (VAL in_zab_1, struct std_either_zaEither_2 *out_zaEither_2) {
	struct std_either_zaEither_2_zaRight* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->m0 = in_zab_1;
	struct std_either_zaEither_2 v4 = { .tag=std_either_zaEither_2_zaRight, .ptr.zaRight=v3 };
	*out_zaEither_2 = v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0xb2a89
movq %r14, (%rax)
leaq 0x60782(%rip), %rcx     # 0x1131f8
movq %rcx, 0x8(%rax)
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x472d3(%rip), %rsi     # 0xf9d63
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99Value_rdrop
static void mw_mirth_c99_zaC99Value_rdrop (struct mirth_c99_zaC99Value* in_zaC99Value_1) {
	struct mirth_c99_C99ReprType v2;
	STR* v3;
	mtp_mirth_c99_zaC99Value_zaC99Value(in_zaC99Value_1, &v2, &v3);
	decref(MK_mirth_c99_C99ReprType(v2));
	decref(MKSTR(v3));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x8(%rdi), %r12
movq 0x10(%rdi), %rbx
movl (%rdi), %r14d
callq 0x5030
movq %r12, %rax
andq %r15, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0xb2e3e
decl (%rax)
jne 0xb2e3e
shlq $0x30, %r14
orq %r12, %r14
leaq 0x600f3(%rip), %rsi     # 0x112f29
movq %r14, %rdi
callq 0xd13d
andq %rbx, %r15
sete %al
testb $0x3, %bl
setne %cl
orb %al, %cl
jne 0xb2e53
decl (%r15)
je 0xb2e5c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5e2f6(%rip), %rsi     # 0x111159
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd13d
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99Resource_rdrop
static void mw_mirth_c99_zaC99Resource_rdrop (struct mirth_c99_zaC99Resource* in_zaC99Resource_1) {
	struct mirth_c99_C99ReprType v2;
	STR* v3;
	mtp_mirth_c99_zaC99Resource_zaC99Resource(in_zaC99Resource_1, &v2, &v3);
	decref(MK_mirth_c99_C99ReprType(v2));
	decref(MKSTR(v3));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x8(%rdi), %r12
movq 0x10(%rdi), %rbx
movl (%rdi), %r14d
callq 0x5030
movq %r12, %rax
andq %r15, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0xb2ec6
decl (%rax)
jne 0xb2ec6
shlq $0x30, %r14
orq %r12, %r14
leaq 0x6006b(%rip), %rsi     # 0x112f29
movq %r14, %rdi
callq 0xd13d
andq %rbx, %r15
sete %al
testb $0x3, %bl
setne %cl
orb %al, %cl
jne 0xb2edb
decl (%r15)
je 0xb2ee4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5e26e(%rip), %rsi     # 0x111159
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd13d
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_std_either_zaEither_2_zaLeft
static void mtw_std_either_zaEither_2_zaLeft (VAL in_zaa_1, struct std_either_zaEither_2 *out_zaEither_2) {
	struct std_either_zaEither_2_zaLeft* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->m0 = in_zaa_1;
	struct std_either_zaEither_2 v4 = { .tag=std_either_zaEither_2_zaLeft, .ptr.zaLeft=v3 };
	*out_zaEither_2 = v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0xb2f39
movq %r14, (%rax)
leaq 0x6028a(%rip), %rcx     # 0x1131b0
movq %rcx, 0x8(%rax)
movl $0x0, (%rbx)
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x46e8d(%rip), %rsi     # 0xf9dcd
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99ValuezfResource_turnzeintozeresourcezx
static void mw_mirth_c99_zaC99ValuezfResource_turnzeintozeresourcezx (struct std_either_zaEither_2 in_zaC99ValuezfResource_1, struct mirth_c99_zaC99Resource* *out_zaC99Resource_2) {
	struct mirth_c99_zaC99Resource* branch_zaC99Resource_3;
	switch ((in_zaC99ValuezfResource_1).tag) {
		case std_either_zaEither_2_zaLeft: {
			VAL v4;
			mtp_std_either_zaEither_2_zaLeft(in_zaC99ValuezfResource_1, &v4);
			struct mirth_c99_zaC99Resource* v5;
			mw_mirth_c99_zaC99Value_turnzeintozeresourcezx(V_mirth_c99_zaC99Value(v4), &v5);
			branch_zaC99Resource_3 = v5;
		} break;
		case std_either_zaEither_2_zaRight: {
			VAL v6;
			mtp_std_either_zaEither_2_zaRight(in_zaC99ValuezfResource_1, &v6);
			branch_zaC99Resource_3 = V_mirth_c99_zaC99Resource(v6);
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaC99Resource_2 = branch_zaC99Resource_3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpl $0x1, %edi
je 0xb30ca
testl %edi, %edi
jne 0xb30e7
movq (%rsi), %r14
movq %rsi, %rdi
callq 0x5030
movl (%r14), %r15d
movq 0x8(%r14), %r12
movq 0x10(%r14), %r13
movq %r14, %rdi
callq 0x5030
leaq -0x30(%rbp), %r14
movl %r15d, %edi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0xae736
movq (%r14), %r14
jmp 0xb30d5
movq (%rsi), %r14
movq %rsi, %rdi
callq 0x5030
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x2d5cd(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x2d5d2(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99ValuezfResource_turnzeintozevaluezx
static void mw_mirth_c99_zaC99ValuezfResource_turnzeintozevaluezx (struct std_either_zaEither_2 in_zaC99ValuezfResource_1, struct mirth_c99_zaC99Value* *out_zaC99Value_2) {
	struct mirth_c99_zaC99Value* branch_zaC99Value_3;
	switch ((in_zaC99ValuezfResource_1).tag) {
		case std_either_zaEither_2_zaLeft: {
			VAL v4;
			mtp_std_either_zaEither_2_zaLeft(in_zaC99ValuezfResource_1, &v4);
			branch_zaC99Value_3 = V_mirth_c99_zaC99Value(v4);
		} break;
		case std_either_zaEither_2_zaRight: {
			VAL v5;
			mtp_std_either_zaEither_2_zaRight(in_zaC99ValuezfResource_1, &v5);
			struct mirth_c99_zaC99Value* v6;
			mw_mirth_c99_zaC99Resource_turnzeintozevaluezx(V_mirth_c99_zaC99Resource(v5), &v6);
			branch_zaC99Value_3 = v6;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaC99Value_2 = branch_zaC99Value_3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpl $0x1, %edi
je 0xb313e
testl %edi, %edi
jne 0xb3186
movq (%rsi), %r14
movq %rsi, %rdi
callq 0x5030
jmp 0xb3174
movq (%rsi), %r14
movq %rsi, %rdi
callq 0x5030
movl (%r14), %r15d
movq 0x8(%r14), %r12
movq 0x10(%r14), %r13
movq %r14, %rdi
callq 0x5030
leaq -0x30(%rbp), %r14
movl %r15d, %edi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0xae5e3
movq (%r14), %r14
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x2d52e(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x2d533(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99ValuezfResource_consumezeas
static STR* mw_mirth_c99_zaC99ValuezfResource_consumezeas (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99ReprType in_C99ReprType_2, struct std_either_zaEither_2 in_zaC99ValuezfResource_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	struct mirth_mirth_zaMirth* branch_zaMirth_6;
	STR* branch_Str_7;
	switch ((in_zaC99ValuezfResource_3).tag) {
		case std_either_zaEither_2_zaLeft: {
			VAL v8;
			mtp_std_either_zaEither_2_zaLeft(in_zaC99ValuezfResource_3, &v8);
			struct mirth_mirth_zaMirth* v9;
			STR* v10 = mw_mirth_c99_zaC99Value_consumezeas(in_zaMirth_1, in_C99ReprType_2, V_mirth_c99_zaC99Value(v8), &v9);
			branch_Str_7 = v10;
			branch_zaMirth_6 = v9;
		} break;
		case std_either_zaEither_2_zaRight: {
			VAL v11;
			mtp_std_either_zaEither_2_zaRight(in_zaC99ValuezfResource_3, &v11);
			struct mirth_mirth_zaMirth* v12;
			STR* v13 = mw_mirth_c99_zaC99Resource_consumezeas(in_zaMirth_1, in_C99ReprType_2, V_mirth_c99_zaC99Resource(v11), &v12);
			branch_Str_7 = v13;
			branch_zaMirth_6 = v12;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_4 = branch_zaMirth_6;
	return branch_Str_7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
cmpl $0x1, %ecx
je 0xb4c81
testl %ecx, %ecx
jne 0xb4cb9
movq (%r8), %r13
movq %r8, %rdi
callq 0x5030
leaq -0x30(%rbp), %r8
movq %r12, %rdi
movl %r15d, %esi
movq %r14, %rdx
movq %r13, %rcx
movq %r8, %r14
callq 0xb32da
jmp 0xb4ca4
movq (%r8), %r13
movq %r8, %rdi
callq 0x5030
leaq -0x30(%rbp), %r8
movq %r12, %rdi
movl %r15d, %esi
movq %r14, %rdx
movq %r13, %rcx
movq %r8, %r14
callq 0xb3f11
movq (%r14), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x2b9fb(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x2ba00(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99APIArg_popzeconsumezephysicalzx
static struct std_maybe_Maybe_1 mw_mirth_c99_C99APIArg_popzeconsumezephysicalzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99Branch* in_zaC99Branch_2, struct mirth_c99_C99APIArg* in_C99APIArg_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_c99_zaC99Branch* *out_zaC99Branch_5) {
	incref(MK_mirth_c99_C99APIArg(in_C99APIArg_3));
	struct mirth_mirth_zaMirth* v7;
	struct mirth_c99_zaC99Branch* v8;
	STR* v9 = mw_mirth_c99_C99APIArg_popzeconsumezx(in_zaMirth_1, in_zaC99Branch_2, in_C99APIArg_3, &v7, &v8);
	struct mirth_mirth_zaMirth* v10;
	bool v11 = mw_mirth_c99_C99APIArg_iszephysicalzy(v7, in_C99APIArg_3, &v10);
	struct mirth_c99_zaC99Branch* branch_zaC99Branch_12;
	struct mirth_mirth_zaMirth* branch_zaMirth_13;
	struct std_maybe_Maybe_1 branch_Maybe_14;
	if (v11) {
		struct std_maybe_Maybe_1 v15 = mtw_std_maybe_Maybe_1_Some(MKSTR(v9));
		branch_Maybe_14 = v15;
		branch_zaMirth_13 = v10;
		branch_zaC99Branch_12 = v8;
	} else {
		decref(MKSTR(v9));
		struct std_maybe_Maybe_1 v16 = { .tag=std_maybe_Maybe_1_None };
		branch_Maybe_14 = v16;
		branch_zaMirth_13 = v10;
		branch_zaC99Branch_12 = v8;
	}
	*out_zaC99Branch_5 = branch_zaC99Branch_12;
	*out_zaMirth_4 = branch_zaMirth_13;
	return branch_Maybe_14;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, -0x30(%rbp)
movq %rdx, %r12
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movq %rdx, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0xb5460
incl (%rax)
leaq -0x48(%rbp), %r13
leaq -0x40(%rbp), %r8
movq %r12, %rdx
movq %r13, %rcx
callq 0xb507d
movq %rax, %r15
movq (%r13), %rdi
leaq -0x38(%rbp), %rdx
movq %r12, %rsi
callq 0xacba1
testb %al, %al
je 0xb54a0
leaq 0x5bcc8(%rip), %rsi     # 0x111159
movq %r15, %rdi
callq 0x9353
movl $0x1, %eax
jmp 0xb54cb
movq %r15, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0xb54c7
decl (%rax)
jne 0xb54c7
leaq 0x5bc9a(%rip), %rsi     # 0x111159
movq %r15, %rdi
callq 0xd13d
xorl %eax, %eax
xorl %edx, %edx
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rsi
movq %rcx, (%r14)
movq -0x30(%rbp), %rcx
movq %rsi, (%rcx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99Stack_rdrop
static void mw_mirth_c99_zaC99Stack_rdrop (struct mirth_c99_zaC99Stack in_zaC99Stack_1) {
	switch ((in_zaC99Stack_1).tag) {
		case mirth_c99_zaC99Stack_zaNil: {
		} break;
		case mirth_c99_zaC99Stack_zaCons: {
			struct mirth_c99_zaC99Stack v2;
			struct mirth_c99_zaC99Value* v3;
			mtp_mirth_c99_zaC99Stack_zaCons(in_zaC99Stack_1, &v2, &v3);
			mw_mirth_c99_zaC99Value_rdrop(v3);
			mw_mirth_c99_zaC99Stack_rdrop(v2);
		} break;
		case mirth_c99_zaC99Stack_zaWith: {
			struct mirth_c99_zaC99Stack v4;
			struct mirth_c99_zaC99Resource* v5;
			mtp_mirth_c99_zaC99Stack_zaWith(in_zaC99Stack_1, &v4, &v5);
			mw_mirth_c99_zaC99Resource_rdrop(v5);
			mw_mirth_c99_zaC99Stack_rdrop(v4);
		} break;
		case mirth_c99_zaC99Stack_zaConsLabel: {
			struct mirth_c99_zaC99Stack v6;
			struct mirth_c99_zaC99Value* v7;
			uint64_t v8 = mtp_mirth_c99_zaC99Stack_zaConsLabel(in_zaC99Stack_1, &v6, &v7);
			mw_mirth_c99_zaC99Value_rdrop(v7);
			mw_mirth_c99_zaC99Stack_rdrop(v6);
		} break;
		case mirth_c99_zaC99Stack_zaWithLabel: {
			struct mirth_c99_zaC99Stack v9;
			struct mirth_c99_zaC99Resource* v10;
			uint64_t v11 = mtp_mirth_c99_zaC99Stack_zaWithLabel(in_zaC99Stack_1, &v9, &v10);
			mw_mirth_c99_zaC99Resource_rdrop(v10);
			mw_mirth_c99_zaC99Stack_rdrop(v9);
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
leaq 0x2a6f5(%rip), %r15     # 0xe0058
cmpl $0x4, %ebx
ja 0xb59ba
movl %ebx, %eax
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movl (%rsi), %ebx
movq 0x8(%rsi), %r12
movq 0x10(%rsi), %r14
movq %rsi, %rdi
callq 0x5030
movq %r14, %rdi
callq 0xb2deb
movq %r12, %rsi
jmp 0xb5963
movl (%rsi), %ebx
movq 0x8(%rsi), %r12
movq 0x10(%rsi), %r14
movq %rsi, %rdi
callq 0x5030
movq %r14, %rdi
callq 0xb2e73
movq %r12, %rsi
jmp 0xb5963
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x2acfa(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x2acff(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99ReprType_cast
static STR* mw_mirth_c99_C99ReprType_cast (struct mirth_mirth_zaMirth* in_zaMirth_1, STR* in_Str_2, struct mirth_c99_C99ReprType in_C99ReprType_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	STR* v6;
	STRLIT(v6, "", 0);
	STR* v7;
	STRLIT(v7, "((", 2);
	STR* v8;
	mw_std_str_zaStr_pushzestrzx(v7, v6, &v8);
	struct mirth_mirth_zaMirth* v9;
	STR* v10 = mw_mirth_c99_C99ReprType_underlyingzec99zetype(in_zaMirth_1, in_C99ReprType_3, &v9);
	STR* v11;
	mw_std_str_zaStr_pushzestrzx(v10, v8, &v11);
	STR* v12;
	STRLIT(v12, ")(", 2);
	STR* v13;
	mw_std_str_zaStr_pushzestrzx(v12, v11, &v13);
	STR* v14;
	mw_std_str_zaStr_pushzestrzx(in_Str_2, v13, &v14);
	STR* v15;
	STRLIT(v15, "))", 2);
	STR* v16;
	mw_std_str_zaStr_pushzestrzx(v15, v14, &v16);
	*out_zaMirth_4 = v9;
	return v16;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x38(%rbp)
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, -0x30(%rbp)
movq %rdi, %r13
movq 0x1061d3f(%rip), %rbx   # 0x1117f70
testq %rbx, %rbx
jne 0xb624f
xorl %edi, %edi
callq 0xf5e4
movq %rax, %rbx
movq $0x0, 0x10(%rax)
movq %rax, 0x1061d21(%rip)   # 0x1117f70
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
movq %rbx, %rax
andq %r14, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xb626e
incl (%rax)
movq 0x1061d03(%rip), %rsi   # 0x1117f78
testq %rsi, %rsi
jne 0xb629c
movl $0x2, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x2, 0x10(%rax)
movw $0x2828, 0x18(%rax)     # imm = 0x2828
movq %rax, 0x1061cdc(%rip)   # 0x1117f78
movq %rsi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xb62b2
incl (%rax)
movq %rbx, %rdi
callq 0xe069
movq %rax, %rbx
leaq -0x40(%rbp), %rcx
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0xa59d1
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe069
movq %rax, %rbx
movq 0x1061c9c(%rip), %rsi   # 0x1117f80
testq %rsi, %rsi
jne 0xb630b
movl $0x2, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x2, 0x10(%rax)
movw $0x2829, 0x18(%rax)     # imm = 0x2829
movq %rax, 0x1061c75(%rip)   # 0x1117f80
movq %rsi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xb6321
incl (%rax)
movq %rbx, %rdi
callq 0xe069
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0xe069
movq %rax, %rbx
movq 0x1061c49(%rip), %rsi   # 0x1117f88
testq %rsi, %rsi
jne 0xb6366
movl $0x2, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x2, 0x10(%rax)
movw $0x2929, 0x18(%rax)     # imm = 0x2929
movq %rax, 0x1061c22(%rip)   # 0x1117f88
andq %rsi, %r14
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xb637a
incl (%r14)
movq %rbx, %rdi
callq 0xe069
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdx
movq %rcx, (%rdx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99ValuezfResource_consumezeaszedata
static STR* mw_mirth_c99_zaC99ValuezfResource_consumezeaszedata (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Data_2, struct std_either_zaEither_2 in_zaC99ValuezfResource_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	struct mirth_mirth_zaMirth* branch_zaMirth_6;
	STR* branch_Str_7;
	switch ((in_zaC99ValuezfResource_3).tag) {
		case std_either_zaEither_2_zaLeft: {
			VAL v8;
			mtp_std_either_zaEither_2_zaLeft(in_zaC99ValuezfResource_3, &v8);
			struct mirth_mirth_zaMirth* v9;
			STR* v10 = mw_mirth_c99_zaC99Value_consumezeaszedata(in_zaMirth_1, V_mirth_c99_zaC99Value(v8), in_Data_2, &v9);
			branch_Str_7 = v10;
			branch_zaMirth_6 = v9;
		} break;
		case std_either_zaEither_2_zaRight: {
			VAL v11;
			mtp_std_either_zaEither_2_zaRight(in_zaC99ValuezfResource_3, &v11);
			struct mirth_mirth_zaMirth* v12;
			STR* v13 = mw_mirth_c99_zaC99Resource_consumezeaszedata(in_zaMirth_1, V_mirth_c99_zaC99Resource(v11), in_Data_2, &v12);
			branch_Str_7 = v13;
			branch_zaMirth_6 = v12;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_4 = branch_zaMirth_6;
	return branch_Str_7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x1, %edx
je 0xb6641
testl %edx, %edx
jne 0xb6681
movq (%rcx), %r12
movq %rcx, %rdi
callq 0x5030
movq %r15, %rdi
callq 0x9c4cb
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movl $0x15, %esi
movq %rax, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0xb32da
jmp 0xb666e
movq (%rcx), %r12
movq %rcx, %rdi
callq 0x5030
movq %r15, %rdi
callq 0x9c4cb
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movl $0x15, %esi
movq %rax, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0xb3f11
movq (%r15), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x2a033(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x2a038(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_prim_Str_Str_1_sp46
static STR* mw_std_prim_Str_Str_1_sp46 (struct mirth_c99_C99DataStructField* in_C99DataStructField_1, STR* in_Str_2, STR* *out_Str_3, struct mirth_c99_C99DataStructField* *out_C99DataStructField_4) {
	STR* v6;
	STRLIT(v6, "", 0);
	incref(MKSTR(in_Str_2));
	STR* v7;
	mw_std_str_zaStr_pushzestrzx(in_Str_2, v6, &v7);
	STR* v8;
	STRLIT(v8, ".", 1);
	STR* v9;
	mw_std_str_zaStr_pushzestrzx(v8, v7, &v9);
	incref(MK_mirth_c99_C99DataStructField(in_C99DataStructField_1));
	STR* v10 = in_C99DataStructField_1->mcname;
	incref(MKSTR(v10));
	decref(MK_mirth_c99_C99DataStructField(in_C99DataStructField_1));
	STR* v11;
	mw_std_str_zaStr_pushzestrzx(v10, v9, &v11);
	*out_C99DataStructField_4 = in_C99DataStructField_1;
	*out_Str_3 = in_Str_2;
	return v11;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rsi, %r15
movq %rdi, %r12
movq 0x106093e(%rip), %rdi   # 0x1117fe0
testq %rdi, %rdi
jne 0xb76c0
xorl %edi, %edi
callq 0xf5e4
movq %rax, %rdi
movq $0x0, 0x10(%rax)
movq %rax, 0x1060920(%rip)   # 0x1117fe0
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
movq %rdi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xb76e0
incl (%rax)
movq %r15, %rax
andq %r14, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0xb76f6
incl (%rax)
movq %r15, %rsi
callq 0xe069
movq %rax, %r13
movq 0x10608e0(%rip), %rsi   # 0x1117fe8
testq %rsi, %rsi
jne 0xb772d
movl $0x1, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x1, 0x10(%rax)
movb $0x2e, 0x18(%rax)
movq %rax, 0x10608bb(%rip)   # 0x1117fe8
movq %rsi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xb7743
incl (%rax)
movq %r13, %rdi
callq 0xe069
movq %rax, %r13
movq %r12, %rax
andq %r14, %rax
setne %dl
testb $0x3, %r12b
sete %cl
andb %dl, %cl
cmpb $0x1, %cl
jne 0xb7767
incl (%rax)
movq 0x28(%r12), %rbx
andq %rbx, %r14
sete %dl
testb $0x3, %bl
setne %sil
orb %dl, %sil
jne 0xb7781
incl (%r14)
testb %cl, %cl
je 0xb7798
decl (%rax)
jne 0xb7798
leaq 0x5b7e1(%rip), %rsi     # 0x112f71
movq %r12, %rdi
callq 0xd13d
movq %r13, %rdi
movq %rbx, %rsi
callq 0xe069
movq -0x30(%rbp), %rcx
movq %r12, (%rcx)
movq -0x38(%rbp), %rcx
movq %r15, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99_c99zelinezeif_1_sp34
static void mw_mirth_c99_zaC99_c99zelinezeif_1_sp34 (struct mirth_mirth_zaMirth* in_zaMirth_1, bool in_Bool_2, struct mirth_c99_zaC99* in_zaC99_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_c99_zaC99* *out_zaC99_5) {
	bool v6 = in_zaC99_3->mputzeenabled;
	bool v7 = (in_Bool_2 && v6);
	in_zaC99_3->mputzeenabled = v7;
	struct mirth_mirth_zaMirth* v8;
	struct mirth_c99_zaC99* v9;
	mw_mirth_c99_zaC99_indent(in_zaMirth_1, in_zaC99_3, &v8, &v9);
	STR* v10;
	STRLIT(v10, "} else {", 8);
	struct mirth_mirth_zaMirth* v11;
	struct mirth_c99_zaC99* v12;
	mw_mirth_c99_zaC99_put(v8, v9, v10, &v11, &v12);
	struct mirth_mirth_zaMirth* v13;
	struct mirth_c99_zaC99* v14;
	mw_mirth_c99_zaC99_line(v11, v12, &v13, &v14);
	v14->mputzeenabled = v6;
	*out_zaC99_5 = v14;
	*out_zaMirth_4 = v13;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movq %rcx, -0x30(%rbp)
movl 0x18(%rdx), %r13d
testl %esi, %esi
cmovnel %r13d, %esi
movb %sil, 0x18(%rdx)
leaq -0x40(%rbp), %rax
leaq -0x38(%rbp), %rcx
movq %rdx, %rsi
movq %rax, %rdx
callq 0x93675
movq 0x1060665(%rip), %rdx   # 0x1118000
testq %rdx, %rdx
jne 0xb79ca
movl $0x8, %edi
callq 0xf5e4
movq %rax, %rdx
movq $0x8, 0x10(%rax)
movabsq $0x7b2065736c65207d, %rax # imm = 0x7B2065736C65207D
movq %rax, 0x18(%rdx)
movq %rdx, 0x1060636(%rip)   # 0x1118000
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0xb79e8
incl (%rax)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %r15, %rcx
movq %r12, %r8
callq 0x9221b
movq (%r15), %rbx
movq (%r12), %r12
cmpb $0x1, 0x18(%r12)
jne 0xb7a30
movq 0x28(%r12), %rsi
leaq -0x58(%rbp), %r15
movl $0xa, %edi
movq %r15, %rdx
callq 0x92a13
movq (%r15), %rax
movq %rax, 0x28(%r12)
movb %r13b, 0x18(%r12)
movq %r12, (%r14)
movq -0x30(%rbp), %rax
movq %rbx, (%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq