LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99_c99zeline_1_sp2
static void mw_mirth_c99_zaC99_c99zeline_1_sp2 (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) {
	struct mirth_mirth_zaMirth* v5;
	struct mirth_c99_zaC99* v6;
	mw_mirth_c99_zaC99_indent(in_zaMirth_1, in_zaC99_2, &v5, &v6);
	STR* v7;
	STRLIT(v7, "}", 1);
	struct mirth_mirth_zaMirth* v8;
	struct mirth_c99_zaC99* v9;
	mw_mirth_c99_zaC99_put(v5, v6, v7, &v8, &v9);
	struct mirth_mirth_zaMirth* v10;
	struct mirth_c99_zaC99* v11;
	mw_mirth_c99_zaC99_line(v8, v9, &v10, &v11);
	*out_zaC99_4 = v11;
	*out_zaMirth_3 = v10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %rbx
leaq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x95d84
cmpq $0x0, 0x1084697(%rip)   # 0x111ab58
jne 0x964e0
movl $0x1, %edi
callq 0xf9f7
movq $0x1, 0x10(%rax)
movb $0x7d, 0x18(%rax)
movq %rax, 0x1084678(%rip)   # 0x111ab58
movq 0x1084671(%rip), %rdx   # 0x111ab58
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x96505
incl (%rax)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %r15
leaq -0x40(%rbp), %r12
movq %r15, %rcx
movq %r12, %r8
callq 0x94972
movq (%r15), %r13
movq (%r12), %r12
cmpb $0x1, 0x18(%r12)
jne 0x9654d
movq 0x28(%r12), %rsi
leaq -0x50(%rbp), %r15
movl $0xa, %edi
movq %r15, %rdx
callq 0x95160
movq (%r15), %rax
movq %rax, 0x28(%r12)
movq %r12, (%r14)
movq %r13, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_name_QName_mangled
static STR* mw_mirth_name_QName_mangled (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_name_QName* in_QName_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	STR* v5;
	STRLIT(v5, "", 0);
	struct mirth_mirth_zaMirth* v6;
	STR* v7;
	mw_mirth_name_QName_mangledzj(in_zaMirth_1, v5, in_QName_2, &v6, &v7);
	*out_zaMirth_3 = v6;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x108456c(%rip)   # 0x111aaf0
jne 0x9659c
xorl %edi, %edi
callq 0xf9f7
movq $0x0, 0x10(%rax)
movq %rax, 0x1084554(%rip)   # 0x111aaf0
movq 0x108454d(%rip), %rsi   # 0x111aaf0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x965c0
incl (%rax)
leaq -0x38(%rbp), %r12
leaq -0x30(%rbp), %r13
movq %r15, %rdi
movq %r14, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0x965f3
movq (%r12), %rax
movq %rax, (%rbx)
movq (%r13), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_table_Field_cname
static STR* mw_mirth_table_Field_cname (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Field_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_table_Field_cname, in_Field_2);
	bool v6 = mut_is_set(v5);
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	STR* branch_Str_8;
	if (v6) {
		VAL v9 = mut_get(v5);
		branch_Str_8 = value_str(v9);
		branch_zaMirth_7 = in_zaMirth_1;
	} else {
		STR* v10;
		STRLIT(v10, "", 0);
		STR* v11;
		STRLIT(v11, "mfld_", 5);
		STR* v12;
		mw_std_str_zaStr_pushzestrzx(v11, v10, &v12);
		struct mirth_mirth_zaMirth* v13;
		struct mirth_name_QName* v14 = mw_mirth_table_Field_qnamezehard(in_zaMirth_1, in_Field_2, &v13);
		struct mirth_mirth_zaMirth* v15;
		STR* v16;
		mw_mirth_name_QName_mangledzj(v13, v12, v14, &v15, &v16);
		incref(MKSTR(v16));
		mut_set(MKSTR(v16), v5);
		branch_Str_8 = v16;
		branch_zaMirth_7 = v15;
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_Str_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x1083e44(%rip), %rdi   # 0x111ab70
callq 0x13ff0
movq %rax, %r14
movq %rax, %rdi
callq 0x153b0
testb %al, %al
je 0x96d5b
movq %r14, %rdi
callq 0x140f0
movq %rax, %rdi
movq %rdx, %rsi
callq 0x942c
movq %rax, %r12
jmp 0x96e67
movq %rbx, -0x38(%rbp)
cmpq $0x0, 0x1083e19(%rip)   # 0x111ab80
jne 0x96d7f
xorl %edi, %edi
callq 0xf9f7
movq $0x0, 0x10(%rax)
movq %rax, 0x1083e01(%rip)   # 0x111ab80
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movq 0x1083df0(%rip), %r13   # 0x111ab80
movq %r13, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0x96da6
incl (%rax)
cmpq $0x0, 0x1083dda(%rip)   # 0x111ab88
jne 0x96dd4
movl $0x5, %edi
callq 0xf9f7
movq $0x5, 0x10(%rax)
movl $0x646c666d, 0x18(%rax) # imm = 0x646C666D
movb $0x5f, 0x1c(%rax)
movq %rax, 0x1083db4(%rip)   # 0x111ab88
movq 0x1083dad(%rip), %rsi   # 0x111ab88
movq %rsi, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x96df1
incl (%rax)
movq %r13, %rdi
callq 0xe43c
movq %rax, %r13
leaq 0x1081dcd(%rip), %rdi   # 0x1118bd0
movq %r12, %rsi
callq 0x13ff0
leaq -0x30(%rbp), %r12
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1a972
movq (%r12), %rdi
leaq -0x30(%rbp), %rcx
leaq -0x40(%rbp), %r15
movq %r13, %rsi
movq %rax, %rdx
movq %r15, %r8
callq 0x965f3
movq (%r15), %r12
andq %r12, %rbx
sete %al
testb $0x3, %r12b
setne %cl
orb %al, %cl
jne 0x96e4d
incl (%rbx)
movq %r12, %rdi
leaq 0x7e302(%rip), %rsi     # 0x115159
movq %r14, %rdx
callq 0x14ab5
movq -0x30(%rbp), %r15
movq -0x38(%rbp), %rbx
movq %r15, (%rbx)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataUnitRepr_MakeOfTagzy
static struct std_maybe_Maybe_1 mw_mirth_c99_C99DataUnitRepr_MakeOfTagzy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Tag_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct std_maybe_Maybe_1 v6 = mw_mirth_data_Tag_physicalzebitszy(in_zaMirth_1, in_Tag_2, &v5);
	bool v7 = mw_std_maybe_Maybe_1_has_1_sp1(v6);
	struct mirth_mirth_zaMirth* branch_zaMirth_8;
	struct std_maybe_Maybe_1 branch_Maybe_9;
	if (v7) {
		struct mirth_mirth_zaMirth* v10;
		bool v11 = mw_mirth_data_Tag_onlyzetagzy(v5, in_Tag_2, &v10);
		uint64_t branch_Tag_12;
		struct mirth_mirth_zaMirth* branch_zaMirth_13;
		STR* branch_Str_14;
		if (v11) {
			struct mirth_mirth_zaMirth* v15;
			uint64_t v16 = mw_mirth_data_Tag_data(v10, in_Tag_2, &v15);
			struct mirth_mirth_zaMirth* v17;
			STR* v18 = mw_mirth_data_Data_cname(v15, v16, &v17);
			branch_Str_14 = v18;
			branch_zaMirth_13 = v17;
			branch_Tag_12 = in_Tag_2;
		} else {
			struct mirth_mirth_zaMirth* v19;
			STR* v20 = mw_mirth_data_Tag_cname(v10, in_Tag_2, &v19);
			branch_Str_14 = v20;
			branch_zaMirth_13 = v19;
			branch_Tag_12 = in_Tag_2;
		}
		struct mirth_c99_C99DataUnitRepr* v21 = mtw_mirth_c99_C99DataUnitRepr_C99DataUnitRepr(branch_Tag_12, branch_Str_14);
		struct std_maybe_Maybe_1 v22 = mtw_std_maybe_Maybe_1_Some(MK_mirth_c99_C99DataUnitRepr(v21));
		branch_Maybe_9 = v22;
		branch_zaMirth_8 = branch_zaMirth_13;
	} else {
		struct std_maybe_Maybe_1 v23 = { .tag=std_maybe_Maybe_1_None };
		branch_Maybe_9 = v23;
		branch_zaMirth_8 = v5;
	}
	*out_zaMirth_3 = branch_zaMirth_8;
	return branch_Maybe_9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x30(%rbp), %rdx
callq 0x8f4fe
movl %eax, %edi
movq %rdx, %rsi
callq 0x8ec6c
testb %al, %al
je 0x9e0fa
movq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rdx
movq %r14, %rsi
callq 0x9e189
testb %al, %al
je 0x9e104
movq -0x28(%rbp), %r15
leaq 0x107ab0a(%rip), %rdi   # 0x1118be0
movq %r14, %rsi
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
leaq -0x38(%rbp), %r12
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x9e227
jmp 0x9e117
xorl %eax, %eax
movq -0x30(%rbp), %r12
xorl %edx, %edx
jmp 0x9e154
movq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %r12
movq %r14, %rsi
movq %r12, %rdx
callq 0x9e2ec
movq %rax, %r15
movq (%r12), %r12
movl $0x1, %edi
movl $0x18, %esi
callq 0x50c0
testq %rax, %rax
je 0x9e164
movl $0x1, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x8(%rax)
leaq 0x78c7a(%rip), %rsi     # 0x116dc1
movq %rax, %rdi
callq 0x95f6
movl $0x1, %eax
movq %r12, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5ec80(%rip), %rsi     # 0xfcdeb
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_Tag_onlyzetagzy
static bool mw_mirth_data_Tag_onlyzetagzy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Tag_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	uint64_t v6 = mw_mirth_data_Tag_data(in_zaMirth_1, in_Tag_2, &v5);
	struct mirth_mirth_zaMirth* v7;
	struct std_list_List_1 v8 = mw_mirth_data_Data_tags(v5, v6, &v7);
	struct std_maybe_Maybe_1 v9 = mw_std_list_List_1_singlezy(v8);
	int64_t v10 = (v9).tag;
	decref(MK_std_maybe_Maybe_1(v9));
	INT v11 = WRAP_I63(0LL);
	INT v12 = v11;
	INT v13 = i64_to_int(v10);
	bool v14 = int_eq(v13, v12);
	bool v15 = !v14;
	*out_zaMirth_3 = v7;
	return v15;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x107aa3f(%rip), %rdi   # 0x1118be0
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
leaq -0x18(%rbp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x52d67
movl %eax, %edi
movq %rdx, %rsi
callq 0xf770
movl %eax, %r14d
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x9e200
decl (%rax)
jne 0x9e200
movq %r14, %rdi
shlq $0x30, %rdi
orq %rdx, %rdi
leaq 0x770c6(%rip), %rsi     # 0x1152c1
callq 0xd4e3
leaq 0x1(,%r14,2), %rdi
movl $0x1, %esi
callq 0xec04
testl %eax, %eax
setne %al
movq -0x18(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_Data_cname
static STR* mw_mirth_data_Data_cname (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Data_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_data_Data_cname, in_Data_2);
	bool v6 = mut_is_set(v5);
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	STR* branch_Str_8;
	if (v6) {
		VAL v9 = mut_get(v5);
		branch_Str_8 = value_str(v9);
		branch_zaMirth_7 = in_zaMirth_1;
	} else {
		struct mirth_mirth_zaMirth* v10;
		struct mirth_name_QName* v11 = mw_mirth_data_Data_qnamezehard(in_zaMirth_1, in_Data_2, &v10);
		struct mirth_mirth_zaMirth* v12;
		STR* v13 = mw_mirth_name_QName_mangled(v10, v11, &v12);
		incref(MKSTR(v13));
		mut_set(MKSTR(v13), v5);
		branch_Str_8 = v13;
		branch_zaMirth_7 = v12;
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_Str_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x107c95a(%rip), %rdi   # 0x111aba0
callq 0x13ff0
movq %rax, %r14
movq %rax, %rdi
callq 0x153b0
testb %al, %al
je 0x9e272
movq %r14, %rdi
callq 0x140f0
movq %rax, %rdi
movq %rdx, %rsi
callq 0x942c
movq %rax, %r12
jmp 0x9e2d9
leaq 0x107a907(%rip), %rdi   # 0x1118b80
movq %r12, %rsi
callq 0x13ff0
leaq -0x28(%rbp), %r12
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1a972
movq (%r12), %rdi
leaq -0x28(%rbp), %rdx
movq %rax, %rsi
callq 0x96562
movq %rax, %r12
leaq 0x76eac(%rip), %rsi     # 0x115159
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r12, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x9e2ca
incl (%rax)
movq %r12, %rdi
movq %r14, %rdx
callq 0x14ab5
movq -0x28(%rbp), %r15
movq %r15, (%rbx)
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_Tag_cname
static STR* mw_mirth_data_Tag_cname (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Tag_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_data_Tag_cname, in_Tag_2);
	bool v6 = mut_is_set(v5);
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	STR* branch_Str_8;
	if (v6) {
		VAL v9 = mut_get(v5);
		branch_Str_8 = value_str(v9);
		branch_zaMirth_7 = in_zaMirth_1;
	} else {
		struct mirth_mirth_zaMirth* v10;
		struct mirth_name_QName* v11 = mw_mirth_data_Tag_qname(in_zaMirth_1, in_Tag_2, &v10);
		struct mirth_mirth_zaMirth* v12;
		STR* v13 = mw_mirth_name_QName_mangled(v10, v11, &v12);
		incref(MKSTR(v13));
		mut_set(MKSTR(v13), v5);
		branch_Str_8 = v13;
		branch_zaMirth_7 = v12;
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_Str_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x107c8a3(%rip), %rdi   # 0x111abb0
callq 0x13ff0
movq %rax, %r14
movq %rax, %rdi
callq 0x153b0
testb %al, %al
je 0x9e339
movq %r14, %rdi
callq 0x140f0
movq %rax, %rdi
movq %rdx, %rsi
callq 0x942c
movq %rax, %r12
jmp 0x9e391
leaq -0x38(%rbp), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1523d
movq (%r13), %rdi
leaq -0x30(%rbp), %rdx
movq %rax, %rsi
callq 0x96562
movq %rax, %r12
leaq 0x76df4(%rip), %rsi     # 0x115159
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r12, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x9e382
incl (%rax)
movq %r12, %rdi
movq %r14, %rdx
callq 0x14ab5
movq -0x30(%rbp), %r15
movq %r15, (%rbx)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_c99_C99DataUnitRepr_free
static void mirth_c99_C99DataUnitRepr_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_c99_C99DataUnitRepr);
	struct mirth_c99_C99DataUnitRepr* self = vself.data.ptr;
	decref(MKSTR(self->mcname));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x78a0e(%rip), %rax     # 0x116dc1
cmpq %rsi, %rax
jne 0x9e3f8
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x9e3ea
decl (%rax)
jne 0x9e3ea
leaq 0x76d74(%rip), %rsi     # 0x115159
callq 0xd4e3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
leaq 0x5ea2e(%rip), %rsi     # 0xfce2d
movl $0x59, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_c99_C99DataRepr_free
void mirth_c99_C99DataRepr_free (VAL v) {
	struct mirth_c99_C99DataRepr self = V_mirth_c99_C99DataRepr(v);
	switch (self.tag) {
		case mirth_c99_C99DataRepr_Unit: {
			decref(MK_mirth_c99_C99DataUnitRepr(self.ptr.Unit->mC99DataUnitRepr));
			free(self.ptr.Unit);
		} break;
		case mirth_c99_C99DataRepr_Enum: {
			free(self.ptr.Enum);
		} break;
		case mirth_c99_C99DataRepr_Trans: {
			decref(MK_mirth_c99_C99DataTransRepr(self.ptr.Trans->mC99DataTransRepr));
			free(self.ptr.Trans);
		} break;
		case mirth_c99_C99DataRepr_Struct: {
			decref(MK_mirth_c99_C99DataStructRepr(self.ptr.Struct->mC99DataStructRepr));
			free(self.ptr.Struct);
		} break;
		case mirth_c99_C99DataRepr_Sum: {
			decref(MK_mirth_c99_C99DataSumRepr(self.ptr.Sum->mC99DataSumRepr));
			free(self.ptr.Sum);
		} break;
	}
}

// Assembly:
movq %rdi, %rcx
shrq $0x30, %rcx
cmpw $0x4, %cx
ja 0x9e53a
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rax, %rbx
leaq 0x454f8(%rip), %rdx     # 0xe3990
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x9e52c
decl (%rax)
jne 0x9e52c
leaq 0x78900(%rip), %rsi     # 0x116dc1
jmp 0x9e527
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x9e52c
decl (%rax)
jne 0x9e52c
leaq 0x789fe(%rip), %rsi     # 0x116ee1
jmp 0x9e527
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x9e52c
decl (%rax)
jne 0x9e52c
leaq 0x7894c(%rip), %rsi     # 0x116e51
jmp 0x9e527
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x9e52c
decl (%rax)
jne 0x9e52c
leaq 0x78972(%rip), %rsi     # 0x116e99
callq 0xd4e3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_c99_C99DataTransRepr_free
static void mirth_c99_C99DataTransRepr_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_c99_C99DataTransRepr);
	struct mirth_c99_C99DataTransRepr* self = vself.data.ptr;
	decref(MK_mirth_type_StackTypePart(self->minput));
	decref(MK_mirth_tycon_Tycon(self->minputzetycon));
	decref(MK_mirth_c99_C99ReprType(self->mc99zerepr));
	decref(MKSTR(self->mcname));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x788bb(%rip), %rax     # 0x116e51
cmpq %rsi, %rax
jne 0x9e674
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
movq 0x18(%rdi), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x9e5de
decl (%rax)
jne 0x9e5de
leaq 0x77713(%rip), %rsi     # 0x115ce1
movl 0x10(%rbx), %edi
shlq $0x30, %rdi
orq 0x18(%rbx), %rdi
callq 0xd4e3
movq 0x28(%rbx), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x9e610
decl (%rax)
jne 0x9e610
leaq 0x77381(%rip), %rsi     # 0x115981
movl 0x20(%rbx), %edi
shlq $0x30, %rdi
orq 0x28(%rbx), %rdi
callq 0xd4e3
movq 0x38(%rbx), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x9e642
decl (%rax)
jne 0x9e642
leaq 0x788f7(%rip), %rsi     # 0x116f29
movl 0x30(%rbx), %edi
shlq $0x30, %rdi
orq 0x38(%rbx), %rdi
callq 0xd4e3
movq 0x40(%rbx), %rdi
andq %rdi, %r14
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x9e668
decl (%r14)
jne 0x9e668
leaq 0x76af6(%rip), %rsi     # 0x115159
callq 0xd4e3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0x5e86d(%rip), %rsi     # 0xfcee8
movl $0x5a, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_c99_C99DataStructRepr_free
static void mirth_c99_C99DataStructRepr_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_c99_C99DataStructRepr);
	struct mirth_c99_C99DataStructRepr* self = vself.data.ptr;
	decref(MKSTR(self->mcname));
	decref(MK_std_list_List_1(self->mfields));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x78733(%rip), %rax     # 0x116e99
cmpq %rsi, %rax
jne 0x9e7db
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
movq 0x10(%rdi), %rdi
movq %rdi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x9e7a0
decl (%rax)
jne 0x9e7a0
leaq 0x769be(%rip), %rsi     # 0x115159
callq 0xd4e3
movq 0x20(%rbx), %rax
andq %rax, %r14
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x9e7cf
decl (%r14)
jne 0x9e7cf
leaq 0x76aba(%rip), %rsi     # 0x115279
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
callq 0xd4e3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0x5e7a0(%rip), %rsi     # 0xfcf82
movl $0x5b, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_c99_C99DataSumRepr_free
static void mirth_c99_C99DataSumRepr_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_c99_C99DataSumRepr);
	struct mirth_c99_C99DataSumRepr* self = vself.data.ptr;
	decref(MK_std_list_List_1(self->mtags));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x78687(%rip), %rax     # 0x116ee1
cmpq %rsi, %rax
jne 0x9e8a9
movq %rdi, %rbx
movq 0x18(%rdi), %rcx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rcx, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x9e89b
decl (%rax)
jne 0x9e89b
leaq 0x769ee(%rip), %rsi     # 0x115279
movl 0x10(%rbx), %edi
shlq $0x30, %rdi
orq 0x18(%rbx), %rdi
callq 0xd4e3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
leaq 0x5e751(%rip), %rsi     # 0xfd001
movl $0x58, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_c99_C99ReprType_Table
static struct mirth_c99_C99ReprType mtw_mirth_c99_C99ReprType_Table (uint64_t in_Table_1) {
	struct mirth_c99_C99ReprType_Table* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mTable = in_Table_1;
	struct mirth_c99_C99ReprType v4 = { .tag=mirth_c99_C99ReprType_Table, .ptr.Table=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x9eeee
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5e1b6(%rip), %rsi     # 0xfd0ab
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_c99_C99ReprType_Data
static struct mirth_c99_C99ReprType mtw_mirth_c99_C99ReprType_Data (uint64_t in_Data_1) {
	struct mirth_c99_C99ReprType_Data* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mData = in_Data_1;
	struct mirth_c99_C99ReprType v4 = { .tag=mirth_c99_C99ReprType_Data, .ptr.Data=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x9ef41
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5e195(%rip), %rsi     # 0xfd0dd
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_maybe_Maybe_1_ifzy_2_sp6
static STR* mw_std_maybe_Maybe_1_ifzy_2_sp6 (INT in_Int_1, struct mirth_mirth_zaMirth* in_zaMirth_2, struct std_maybe_Maybe_1 in_Maybe_3, INT *out_Int_4, struct mirth_mirth_zaMirth* *out_zaMirth_5) {
	INT branch_Int_7;
	struct mirth_mirth_zaMirth* branch_zaMirth_8;
	STR* branch_Str_9;
	switch ((in_Maybe_3).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v10 = mtp_std_maybe_Maybe_1_Some(in_Maybe_3);
			struct mirth_mirth_zaMirth* v11;
			uint64_t v12 = mw_mirth_tycon_Tycon_name(in_zaMirth_2, V_mirth_tycon_Tycon(v10), &v11);
			struct mirth_mirth_zaMirth* v13;
			STR* v14 = mw_mirth_name_Name_mangled(v11, v12, &v13);
			branch_Str_9 = v14;
			branch_zaMirth_8 = v13;
			branch_Int_7 = in_Int_1;
		} break;
		case std_maybe_Maybe_1_None: {
			incref(MKINT(in_Int_1));
			STR* v15 = int_to_str(in_Int_1);
			INT v16 = WRAP_I63(1LL);
			INT v17 = v16;
			INT v18 = int_add(in_Int_1, v17);
			branch_Str_9 = v15;
			branch_zaMirth_8 = in_zaMirth_2;
			branch_Int_7 = v18;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_5 = branch_zaMirth_8;
	*out_Int_4 = branch_Int_7;
	return branch_Str_9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rsi, %r12
movq %rdi, %r15
testl %edx, %edx
je 0x9f73b
cmpl $0x1, %edx
jne 0x9f78b
movq %rcx, %rdi
callq 0xdaeb
movabsq $0xfffffffffffc, %rdx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdx
movq %rax, %rsi
shrq $0x30, %rsi
leaq -0x38(%rbp), %r13
movq %r12, %rdi
movq %r13, %rcx
callq 0x2fdc6
movq (%r13), %rdi
leaq -0x30(%rbp), %r12
movq %rax, %rsi
movq %r12, %rdx
callq 0x95264
movq %rax, %r13
movq (%r12), %r12
jmp 0x9f773
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r15, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x9f758
incl (%rax)
movq %r15, %rdi
callq 0x102c9
movq %rax, %r13
movl $0x3, %esi
movq %r15, %rdi
callq 0xe8e2
movq %rax, %r15
movq %r12, (%r14)
movq %r15, (%rbx)
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0x44fa9(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0x44fae(%rip), %xmm0    # 0xe475d
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x95a5
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_c99_C99DataStructField_free
static void mirth_c99_C99DataStructField_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_c99_C99DataStructField);
	struct mirth_c99_C99DataStructField* self = vself.data.ptr;
	decref(MK_mirth_type_StackTypePart(self->minput));
	decref(MK_mirth_c99_C99ReprType(self->mc99zerepr));
	decref(MKSTR(self->mcname));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x777a8(%rip), %rax     # 0x116f71
cmpq %rsi, %rax
jne 0x9f875
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
movq 0x10(%rdi), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x9f811
decl (%rax)
jne 0x9f811
leaq 0x764e0(%rip), %rsi     # 0x115ce1
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
callq 0xd4e3
movq 0x20(%rbx), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x9f843
decl (%rax)
jne 0x9f843
leaq 0x776f6(%rip), %rsi     # 0x116f29
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
callq 0xd4e3
movq 0x28(%rbx), %rdi
andq %rdi, %r14
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x9f869
decl (%r14)
jne 0x9f869
leaq 0x758f5(%rip), %rsi     # 0x115159
callq 0xd4e3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0x5d93c(%rip), %rsi     # 0xfd1b8
movl $0x5c, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_c99_C99DataSumTagRepr_free
void mirth_c99_C99DataSumTagRepr_free (VAL v) {
	struct mirth_c99_C99DataSumTagRepr self = V_mirth_c99_C99DataSumTagRepr(v);
	switch (self.tag) {
		case mirth_c99_C99DataSumTagRepr_Unit: {
			decref(MK_mirth_c99_C99DataUnitRepr(self.ptr.Unit->mC99DataUnitRepr));
			free(self.ptr.Unit);
		} break;
		case mirth_c99_C99DataSumTagRepr_Struct: {
			decref(MK_mirth_c99_C99DataStructRepr(self.ptr.Struct->mC99DataStructRepr));
			free(self.ptr.Struct);
		} break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movq %rdi, %rcx
shrq $0x30, %rcx
andq %rax, %rbx
cmpq $0x1, %rcx
je 0x9f930
testl %ecx, %ecx
jne 0x9f963
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x9f955
decl (%rax)
jne 0x9f955
leaq 0x77493(%rip), %rsi     # 0x116dc1
jmp 0x9f950
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x9f955
decl (%rax)
jne 0x9f955
leaq 0x77549(%rip), %rsi     # 0x116e99
callq 0xd4e3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_C99DataRepr_Unit
static struct mirth_c99_C99DataUnitRepr* mtp_mirth_c99_C99DataRepr_Unit (struct mirth_c99_C99DataRepr in_C99DataRepr_1) {
	struct mirth_c99_C99DataRepr_Unit v3 = *in_C99DataRepr_1.ptr.Unit;
	if (!--(in_C99DataRepr_1.ptr.Unit->refs)) {
		free(in_C99DataRepr_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 0x9f9e3
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x9f9e8
incl (%rax)
jmp 0x9f9e8
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_C99DataRepr_Trans
static struct mirth_c99_C99DataTransRepr* mtp_mirth_c99_C99DataRepr_Trans (struct mirth_c99_C99DataRepr in_C99DataRepr_1) {
	struct mirth_c99_C99DataRepr_Trans v3 = *in_C99DataRepr_1.ptr.Trans;
	if (!--(in_C99DataRepr_1.ptr.Trans->refs)) {
		free(in_C99DataRepr_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 0x9fa1e
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x9fa23
incl (%rax)
jmp 0x9fa23
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_C99DataRepr_Struct
static struct mirth_c99_C99DataStructRepr* mtp_mirth_c99_C99DataRepr_Struct (struct mirth_c99_C99DataRepr in_C99DataRepr_1) {
	struct mirth_c99_C99DataRepr_Struct v3 = *in_C99DataRepr_1.ptr.Struct;
	if (!--(in_C99DataRepr_1.ptr.Struct->refs)) {
		free(in_C99DataRepr_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 0x9fa59
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x9fa5e
incl (%rax)
jmp 0x9fa5e
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_C99DataRepr_Sum
static struct mirth_c99_C99DataSumRepr* mtp_mirth_c99_C99DataRepr_Sum (struct mirth_c99_C99DataRepr in_C99DataRepr_1) {
	struct mirth_c99_C99DataRepr_Sum v3 = *in_C99DataRepr_1.ptr.Sum;
	if (!--(in_C99DataRepr_1.ptr.Sum->refs)) {
		free(in_C99DataRepr_1.ptr.Sum);
	} else {
		incref(MK_mirth_c99_C99DataSumRepr(v3.mC99DataSumRepr));
	}
	return v3.mC99DataSumRepr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0x9fa94
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x9fa99
incl (%rax)
jmp 0x9fa99
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataUnitRepr_stride
static VAL mw_mirth_c99_C99DataUnitRepr_stride (struct mirth_c99_C99DataUnitRepr* in_C99DataUnitRepr_1) {
	decref(MK_mirth_c99_C99DataUnitRepr(in_C99DataUnitRepr_1));
	STR* v3;
	STRLIT(v3, "STRIDE_UNIT", 11);
	return MKSTR(v3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movq %rdi, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xa22a8
decl (%rax)
jne 0xa22a8
leaq 0x74b1e(%rip), %rsi     # 0x116dc1
callq 0xd4e3
cmpq $0x0, 0x1078990(%rip)   # 0x111ac40
jne 0xa22e0
movl $0xb, %edi
callq 0xf9f7
movq $0xb, 0x10(%rax)
movabsq $0x555f454449525453, %rcx # imm = 0x555F454449525453
movq %rcx, 0x18(%rax)
movl $0x54494e55, 0x1f(%rax) # imm = 0x54494E55
movq %rax, 0x1078960(%rip)   # 0x111ac40
movq 0x1078959(%rip), %rax   # 0x111ac40
andq %rax, %rbx
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0xa22f8
incl (%rbx)
leaq 0x72e5a(%rip), %rdx     # 0x115159
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99_c99zeline_1_sp130
static void mw_mirth_c99_zaC99_c99zeline_1_sp130 (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) {
	struct mirth_mirth_zaMirth* v5;
	struct mirth_c99_zaC99* v6;
	mw_mirth_c99_zaC99_indent(in_zaMirth_1, in_zaC99_2, &v5, &v6);
	STR* v7;
	STRLIT(v7, "};", 2);
	struct mirth_mirth_zaMirth* v8;
	struct mirth_c99_zaC99* v9;
	mw_mirth_c99_zaC99_put(v5, v6, v7, &v8, &v9);
	struct mirth_mirth_zaMirth* v10;
	struct mirth_c99_zaC99* v11;
	mw_mirth_c99_zaC99_line(v8, v9, &v10, &v11);
	*out_zaC99_4 = v11;
	*out_zaMirth_3 = v10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %rbx
leaq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x95d84
cmpq $0x0, 0x10785e5(%rip)   # 0x111ad08
jne 0xa2744
movl $0x2, %edi
callq 0xf9f7
movq $0x2, 0x10(%rax)
movw $0x3b7d, 0x18(%rax)     # imm = 0x3B7D
movq %rax, 0x10785c4(%rip)   # 0x111ad08
movq 0x10785bd(%rip), %rdx   # 0x111ad08
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0xa2769
incl (%rax)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %r15
leaq -0x40(%rbp), %r12
movq %r15, %rcx
movq %r12, %r8
callq 0x94972
movq (%r15), %r13
movq (%r12), %r12
cmpb $0x1, 0x18(%r12)
jne 0xa27b1
movq 0x28(%r12), %rsi
leaq -0x50(%rbp), %r15
movl $0xa, %edi
movq %r15, %rdx
callq 0x95160
movq (%r15), %rax
movq %rax, 0x28(%r12)
movq %r12, (%r14)
movq %r13, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataTransRepr_needszerefcountingzy
static bool mw_mirth_c99_C99DataTransRepr_needszerefcountingzy (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataTransRepr* in_C99DataTransRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_c99_C99ReprType v5 = in_C99DataTransRepr_2->mc99zerepr;
	incref(MK_mirth_c99_C99ReprType(v5));
	decref(MK_mirth_c99_C99DataTransRepr(in_C99DataTransRepr_2));
	struct mirth_mirth_zaMirth* v6;
	bool v7 = mw_mirth_c99_C99ReprType_needszerefcountingzy(in_zaMirth_1, v5, &v6);
	*out_zaMirth_3 = v6;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movl 0x30(%rsi), %r15d
movq 0x38(%rsi), %r12
movq %r12, %rcx
andq %rax, %rcx
sete %dl
testb $0x3, %r12b
setne %dil
orb %dl, %dil
jne 0xa2af5
incl (%rcx)
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa2b1c
decl (%rax)
jne 0xa2b1c
leaq 0x74340(%rip), %rax     # 0x116e51
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd4e3
leaq -0x30(%rbp), %r13
movq %r14, %rdi
movl %r15d, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0xa325e
movq (%r13), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataStructRepr_needszerefcountingzy
static bool mw_mirth_c99_C99DataStructRepr_needszerefcountingzy (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataStructRepr* in_C99DataStructRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	uint64_t v5 = in_C99DataStructRepr_2->mtag;
	decref(MK_mirth_c99_C99DataStructRepr(in_C99DataStructRepr_2));
	struct mirth_mirth_zaMirth* v6;
	bool v7 = mw_mirth_data_Tag_outputszeresourcezy(in_zaMirth_1, v5, &v6);
	bool v8 = !v7;
	*out_zaMirth_3 = v6;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %r14
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa3404
decl (%rax)
jne 0xa3404
leaq 0x73aa0(%rip), %rax     # 0x116e99
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd4e3
leaq -0x28(%rbp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x75867
xorb $0x1, %al
movq (%r12), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataSumRepr_needszerefcountingzy
static bool mw_mirth_c99_C99DataSumRepr_needszerefcountingzy (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataSumRepr* in_C99DataSumRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	uint64_t v5 = in_C99DataSumRepr_2->mdata;
	decref(MK_mirth_c99_C99DataSumRepr(in_C99DataSumRepr_2));
	struct mirth_mirth_zaMirth* v6;
	bool v7 = mw_mirth_data_Data_iszeresourcezy(in_zaMirth_1, v5, &v6);
	bool v8 = !v7;
	*out_zaMirth_3 = v6;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %r14
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa3476
decl (%rax)
jne 0xa3476
leaq 0x73a76(%rip), %rax     # 0x116ee1
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd4e3
leaq -0x28(%rbp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x20d1b
xorb $0x1, %al
movq (%r12), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataStructRepr_stride
static VAL mw_mirth_c99_C99DataStructRepr_stride (struct mirth_c99_C99DataStructRepr* in_C99DataStructRepr_1) {
	decref(MK_mirth_c99_C99DataStructRepr(in_C99DataStructRepr_1));
	STR* v3;
	STRLIT(v3, "sizeof(void*)", 13);
	return MKSTR(v3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movq %rdi, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xa34d2
decl (%rax)
jne 0xa34d2
leaq 0x739cc(%rip), %rsi     # 0x116e99
callq 0xd4e3
cmpq $0x0, 0x1077956(%rip)   # 0x111ae30
jne 0xa3511
movl $0xd, %edi
callq 0xf9f7
movq $0xd, 0x10(%rax)
movabsq $0x7628666f657a6973, %rcx # imm = 0x7628666F657A6973
movq %rcx, 0x18(%rax)
movabsq $0x292a64696f762866, %rcx # imm = 0x292A64696F762866
movq %rcx, 0x1d(%rax)
movq %rax, 0x107791f(%rip)   # 0x111ae30
movq 0x1077918(%rip), %rax   # 0x111ae30
andq %rax, %rbx
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0xa3529
incl (%rbx)
leaq 0x71c29(%rip), %rdx     # 0x115159
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataSumRepr_stride
static VAL mw_mirth_c99_C99DataSumRepr_stride (struct mirth_c99_C99DataSumRepr* in_C99DataSumRepr_1) {
	decref(MK_mirth_c99_C99DataSumRepr(in_C99DataSumRepr_1));
	STR* v3;
	STRLIT(v3, "8", 1);
	return MKSTR(v3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movq %rdi, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xa356b
decl (%rax)
jne 0xa356b
leaq 0x7397b(%rip), %rsi     # 0x116ee1
callq 0xd4e3
cmpq $0x0, 0x10778c5(%rip)   # 0x111ae38
jne 0xa3592
movl $0x1, %edi
callq 0xf9f7
movq $0x1, 0x10(%rax)
movb $0x38, 0x18(%rax)
movq %rax, 0x10778a6(%rip)   # 0x111ae38
movq 0x107789f(%rip), %rax   # 0x111ae38
andq %rax, %rbx
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0xa35aa
incl (%rbx)
leaq 0x71ba8(%rip), %rdx     # 0x115159
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataStructRepr_data
static uint64_t mw_mirth_c99_C99DataStructRepr_data (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataStructRepr* in_C99DataStructRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	uint64_t v5 = in_C99DataStructRepr_2->mtag;
	decref(MK_mirth_c99_C99DataStructRepr(in_C99DataStructRepr_2));
	struct mirth_mirth_zaMirth* v6;
	uint64_t v7 = mw_mirth_data_Tag_data(in_zaMirth_1, v5, &v6);
	*out_zaMirth_3 = v6;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %r15
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa35fd
decl (%rax)
jne 0xa35fd
leaq 0x738a7(%rip), %rax     # 0x116e99
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd4e3
leaq 0x10755dc(%rip), %rdi   # 0x1118be0
movq %r15, %rsi
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataSumRepr_enumzecname
static STR* mw_mirth_c99_C99DataSumRepr_enumzecname (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataSumRepr* in_C99DataSumRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	STR* v6 = mw_mirth_c99_C99DataSumRepr_cname(in_zaMirth_1, in_C99DataSumRepr_2, &v5);
	STR* v7;
	STRLIT(v7, "", 0);
	STR* v8;
	STRLIT(v8, "enum ", 5);
	STR* v9;
	mw_std_str_zaStr_pushzestrzx(v8, v7, &v9);
	STR* v10;
	mw_std_str_zaStr_pushzestrzx(v6, v9, &v10);
	STR* v11;
	STRLIT(v11, "_tag", 4);
	STR* v12;
	mw_std_str_zaStr_pushzestrzx(v11, v10, &v12);
	*out_zaMirth_3 = v5;
	return v12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x28(%rbp), %rdx
callq 0xa394d
movq %rax, %r14
cmpq $0x0, 0x1077a00(%rip)   # 0x111b048
jne 0xa3660
xorl %edi, %edi
callq 0xf9f7
movq $0x0, 0x10(%rax)
movq %rax, 0x10779e8(%rip)   # 0x111b048
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movq 0x10779d7(%rip), %r15   # 0x111b048
movq %r15, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0xa3687
incl (%rax)
cmpq $0x0, 0x10779c1(%rip)   # 0x111b050
jne 0xa36b5
movl $0x5, %edi
callq 0xf9f7
movq $0x5, 0x10(%rax)
movl $0x6d756e65, 0x18(%rax) # imm = 0x6D756E65
movb $0x20, 0x1c(%rax)
movq %rax, 0x107799b(%rip)   # 0x111b050
movq 0x1077994(%rip), %rsi   # 0x111b050
movq %rsi, %rax
andq %r12, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa36d2
incl (%rax)
movq %r15, %rdi
callq 0xe43c
movq %rax, %rdi
movq %r14, %rsi
callq 0xe43c
movq %rax, %r14
cmpq $0x0, 0x1077968(%rip)   # 0x111b058
jne 0xa3712
movl $0x4, %edi
callq 0xf9f7
movq $0x4, 0x10(%rax)
movl $0x6761745f, 0x18(%rax) # imm = 0x6761745F
movq %rax, 0x1077946(%rip)   # 0x111b058
movq 0x107793f(%rip), %rsi   # 0x111b058
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xa372e
incl (%r12)
movq %r14, %rdi
callq 0xe43c
movq -0x28(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataSumRepr_unionzecname
static STR* mw_mirth_c99_C99DataSumRepr_unionzecname (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataSumRepr* in_C99DataSumRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	STR* v6 = mw_mirth_c99_C99DataSumRepr_cname(in_zaMirth_1, in_C99DataSumRepr_2, &v5);
	STR* v7;
	STRLIT(v7, "", 0);
	STR* v8;
	STRLIT(v8, "union ", 6);
	STR* v9;
	mw_std_str_zaStr_pushzestrzx(v8, v7, &v9);
	STR* v10;
	mw_std_str_zaStr_pushzestrzx(v6, v9, &v10);
	STR* v11;
	STRLIT(v11, "_ptr", 4);
	STR* v12;
	mw_std_str_zaStr_pushzestrzx(v11, v10, &v12);
	*out_zaMirth_3 = v5;
	return v12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x28(%rbp), %rdx
callq 0xa394d
movq %rax, %r14
cmpq $0x0, 0x10778f0(%rip)   # 0x111b060
jne 0xa3788
xorl %edi, %edi
callq 0xf9f7
movq $0x0, 0x10(%rax)
movq %rax, 0x10778d8(%rip)   # 0x111b060
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movq 0x10778c7(%rip), %r15   # 0x111b060
movq %r15, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0xa37af
incl (%rax)
cmpq $0x0, 0x10778b1(%rip)   # 0x111b068
jne 0xa37df
movl $0x6, %edi
callq 0xf9f7
movq $0x6, 0x10(%rax)
movl $0x6f696e75, 0x18(%rax) # imm = 0x6F696E75
movw $0x206e, 0x1c(%rax)     # imm = 0x206E
movq %rax, 0x1077889(%rip)   # 0x111b068
movq 0x1077882(%rip), %rsi   # 0x111b068
movq %rsi, %rax
andq %r12, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa37fc
incl (%rax)
movq %r15, %rdi
callq 0xe43c
movq %rax, %rdi
movq %r14, %rsi
callq 0xe43c
movq %rax, %r14
cmpq $0x0, 0x1077856(%rip)   # 0x111b070
jne 0xa383c
movl $0x4, %edi
callq 0xf9f7
movq $0x4, 0x10(%rax)
movl $0x7274705f, 0x18(%rax) # imm = 0x7274705F
movq %rax, 0x1077834(%rip)   # 0x111b070
movq 0x107782d(%rip), %rsi   # 0x111b070
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xa3858
incl (%r12)
movq %r14, %rdi
callq 0xe43c
movq -0x28(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataSumRepr_structzecname
static STR* mw_mirth_c99_C99DataSumRepr_structzecname (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataSumRepr* in_C99DataSumRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	STR* v6 = mw_mirth_c99_C99DataSumRepr_cname(in_zaMirth_1, in_C99DataSumRepr_2, &v5);
	STR* v7;
	STRLIT(v7, "", 0);
	STR* v8;
	STRLIT(v8, "struct ", 7);
	STR* v9;
	mw_std_str_zaStr_pushzestrzx(v8, v7, &v9);
	STR* v10;
	mw_std_str_zaStr_pushzestrzx(v6, v9, &v10);
	*out_zaMirth_3 = v5;
	return v10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x28(%rbp), %rdx
callq 0xa394d
movq %rax, %r14
cmpq $0x0, 0x10777de(%rip)   # 0x111b078
jne 0xa38b2
xorl %edi, %edi
callq 0xf9f7
movq $0x0, 0x10(%rax)
movq %rax, 0x10777c6(%rip)   # 0x111b078
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movq 0x10777b5(%rip), %r15   # 0x111b078
movq %r15, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0xa38d9
incl (%rax)
cmpq $0x0, 0x107779f(%rip)   # 0x111b080
jne 0xa390a
movl $0x7, %edi
callq 0xf9f7
movq $0x7, 0x10(%rax)
movl $0x75727473, 0x18(%rax) # imm = 0x75727473
movl $0x20746375, 0x1b(%rax) # imm = 0x20746375
movq %rax, 0x1077776(%rip)   # 0x111b080
movq 0x107776f(%rip), %rsi   # 0x111b080
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xa3926
incl (%r12)
movq %r15, %rdi
callq 0xe43c
movq %rax, %rdi
movq %r14, %rsi
callq 0xe43c
movq -0x28(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataSumRepr_cname
static STR* mw_mirth_c99_C99DataSumRepr_cname (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataSumRepr* in_C99DataSumRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	uint64_t v5 = in_C99DataSumRepr_2->mdata;
	decref(MK_mirth_c99_C99DataSumRepr(in_C99DataSumRepr_2));
	struct mirth_mirth_zaMirth* v6;
	STR* v7 = mw_mirth_data_Data_cname(in_zaMirth_1, v5, &v6);
	*out_zaMirth_3 = v6;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %r14
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa3997
decl (%rax)
jne 0xa3997
leaq 0x73555(%rip), %rax     # 0x116ee1
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd4e3
leaq -0x28(%rbp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x9e227
movq (%r12), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq