LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x107a7e8(%rip), %rdi   # 0x110dba8
callq 0x12f88
movq %rax, %r14
movq %rax, %rdi
callq 0x142de
testb %al, %al
je 0x933ec
movq %r14, %rdi
callq 0x1307d
movq %rax, %rdi
movq %rdx, %rsi
callq 0x8b55
movq %rax, %r12
jmp 0x93444
leaq -0x38(%rbp), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x17fea
movq (%r13), %rdi
leaq -0x30(%rbp), %rdx
movq %rax, %rsi
callq 0x8c364
movq %rax, %r12
leaq 0x74d41(%rip), %rsi     # 0x108159
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r12, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x93435
incl (%rax)
movq %r12, %rdi
movq %r14, %rdx
callq 0x1393b
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_O2/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 0x107a73e(%rip), %rdi   # 0x110dbb8
callq 0x12f88
movq %rax, %r14
movq %rax, %rdi
callq 0x142de
testb %al, %al
je 0x934a6
movq %r14, %rdi
callq 0x1307d
movq %rax, %rdi
movq %rdx, %rsi
callq 0x8b55
movq %rax, %r12
jmp 0x934fe
leaq -0x38(%rbp), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1415b
movq (%r13), %rdi
leaq -0x30(%rbp), %rdx
movq %rax, %rsi
callq 0x8c364
movq %rax, %r12
leaq 0x74c87(%rip), %rsi     # 0x108159
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r12, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x934ef
incl (%rax)
movq %r12, %rdi
movq %r14, %rdx
callq 0x1393b
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_O2/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 0x768a1(%rip), %rax     # 0x109dc1
cmpq %rsi, %rax
jne 0x93565
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 0x93557
decl (%rax)
jne 0x93557
leaq 0x74c07(%rip), %rsi     # 0x108159
callq 0xce94
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
leaq 0x59a2b(%rip), %rsi     # 0xecf97
pushq $0x2
popq %rdi
pushq $0x59
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rcx
shrq $0x30, %rcx
cmpw $0x4, %cx
ja 0x936a3
movq %rdi, %rbx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rax, %rbx
leaq 0x403f7(%rip), %rdx     # 0xd39f8
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 0x93695
decl (%rax)
jne 0x93695
leaq 0x76797(%rip), %rsi     # 0x109dc1
jmp 0x93690
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x93695
decl (%rax)
jne 0x93695
leaq 0x76895(%rip), %rsi     # 0x109ee1
jmp 0x93690
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x93695
decl (%rax)
jne 0x93695
leaq 0x767e3(%rip), %rsi     # 0x109e51
jmp 0x93690
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x93695
decl (%rax)
jne 0x93695
leaq 0x76809(%rip), %rsi     # 0x109e99
callq 0xce94
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_O2/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 0x7674a(%rip), %rax     # 0x109e51
cmpq %rsi, %rax
jne 0x937e5
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 0x9374f
decl (%rax)
jne 0x9374f
leaq 0x755a2(%rip), %rsi     # 0x108ce1
movl 0x10(%rbx), %edi
shlq $0x30, %rdi
orq 0x18(%rbx), %rdi
callq 0xce94
movq 0x28(%rbx), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x93781
decl (%rax)
jne 0x93781
leaq 0x75210(%rip), %rsi     # 0x108981
movl 0x20(%rbx), %edi
shlq $0x30, %rdi
orq 0x28(%rbx), %rdi
callq 0xce94
movq 0x38(%rbx), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x937b3
decl (%rax)
jne 0x937b3
leaq 0x76786(%rip), %rsi     # 0x109f29
movl 0x30(%rbx), %edi
shlq $0x30, %rdi
orq 0x38(%rbx), %rdi
callq 0xce94
movq 0x40(%rbx), %rdi
andq %rdi, %r14
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x937d9
decl (%r14)
jne 0x937d9
leaq 0x74985(%rip), %rsi     # 0x108159
callq 0xce94
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0x59866(%rip), %rsi     # 0xed052
pushq $0x2
popq %rdi
pushq $0x5a
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/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 0x765c4(%rip), %rax     # 0x109e99
cmpq %rsi, %rax
jne 0x9394a
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 0x9390f
decl (%rax)
jne 0x9390f
leaq 0x7484f(%rip), %rsi     # 0x108159
callq 0xce94
movq 0x20(%rbx), %rax
andq %rax, %r14
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x9393e
decl (%r14)
jne 0x9393e
leaq 0x7494b(%rip), %rsi     # 0x108279
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
callq 0xce94
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0x5979b(%rip), %rsi     # 0xed0ec
pushq $0x2
popq %rdi
pushq $0x5b
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/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 0x7651c(%rip), %rax     # 0x109ee1
cmpq %rsi, %rax
jne 0x93a14
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 0x93a06
decl (%rax)
jne 0x93a06
leaq 0x74883(%rip), %rsi     # 0x108279
movl 0x10(%rbx), %edi
shlq $0x30, %rdi
orq 0x18(%rbx), %rdi
callq 0xce94
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
leaq 0x59750(%rip), %rsi     # 0xed16b
pushq $0x2
popq %rdi
pushq $0x58
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x93fd1
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5923d(%rip), %rsi     # 0xed215
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x9401a
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x59226(%rip), %rsi     # 0xed247
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/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 0x947f3
cmpl $0x1, %edx
jne 0x94841
movq %rcx, %rdi
callq 0xd491
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 0x2c76b
movq (%r13), %rdi
leaq -0x30(%rbp), %r12
movq %rax, %rsi
movq %r12, %rdx
callq 0x8b231
movq %rax, %r13
movq (%r12), %r12
jmp 0x94829
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r15, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x94810
incl (%rax)
movq %r15, %rdi
callq 0xf51c
movq %rax, %r13
pushq $0x3
popq %rsi
movq %r15, %rdi
callq 0xdd03
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
leaq 0x3ffc5(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/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 0x7570b(%rip), %rax     # 0x109f71
cmpq %rsi, %rax
jne 0x94912
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 0x948ae
decl (%rax)
jne 0x948ae
leaq 0x74443(%rip), %rsi     # 0x108ce1
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
callq 0xce94
movq 0x20(%rbx), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x948e0
decl (%rax)
jne 0x948e0
leaq 0x75659(%rip), %rsi     # 0x109f29
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
callq 0xce94
movq 0x28(%rbx), %rdi
andq %rdi, %r14
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x94906
decl (%r14)
jne 0x94906
leaq 0x73858(%rip), %rsi     # 0x108159
callq 0xce94
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0x58a09(%rip), %rsi     # 0xed322
pushq $0x2
popq %rdi
pushq $0x5c
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/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 0x949c9
testl %ecx, %ecx
jne 0x949fc
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x949ee
decl (%rax)
jne 0x949ee
leaq 0x753fa(%rip), %rsi     # 0x109dc1
jmp 0x949e9
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x949ee
decl (%rax)
jne 0x949ee
leaq 0x754b0(%rip), %rsi     # 0x109e99
callq 0xce94
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_O2/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 0x94a7e
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x94a83
incl (%rax)
jmp 0x94a83
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_C99DataRepr_Enum
static uint64_t mtp_mirth_c99_C99DataRepr_Enum (struct mirth_c99_C99DataRepr in_C99DataRepr_1) {
	struct mirth_c99_C99DataRepr_Enum v3 = *in_C99DataRepr_1.ptr.Enum;
	if (!--(in_C99DataRepr_1.ptr.Enum->refs)) {
		free(in_C99DataRepr_1.ptr.Enum);
	} else {
	}
	return v3.mC99DataEnumRepr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x94aa0
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x94ad6
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x94adb
incl (%rax)
jmp 0x94adb
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x94b11
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x94b16
incl (%rax)
jmp 0x94b16
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x94b4c
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x94b51
incl (%rax)
jmp 0x94b51
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rdx, %rbx
leaq -0x30(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x8bc28
movq 0x10769a2(%rip), %rdx   # 0x110dd10
testq %rdx, %rdx
jne 0x9738c
leaq 0x5628d(%rip), %rdi     # 0xed607
pushq $0x2
popq %rsi
callq 0x8a21
movq %rax, %rdx
movq %rax, 0x1076984(%rip)   # 0x110dd10
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x973aa
incl (%rax)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x50(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %r15, %rcx
movq %r12, %r8
callq 0x8a8a9
movq (%r15), %rdi
movq (%r12), %rsi
leaq -0x40(%rbp), %r15
leaq -0x38(%rbp), %r12
movq %r15, %rdx
movq %r12, %rcx
callq 0x8a92c
movq (%r12), %rax
movq %rax, (%r14)
movq (%r15), %rax
movq %rax, (%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x97714
incl (%rcx)
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x9773b
decl (%rax)
jne 0x9773b
leaq 0x72721(%rip), %rax     # 0x109e51
movq %rsi, %rdi
movq %rax, %rsi
callq 0xce94
leaq -0x30(%rbp), %r13
movq %r14, %rdi
movl %r15d, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0x97ccc
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_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_C99ReprType_Table
static uint64_t mtp_mirth_c99_C99ReprType_Table (struct mirth_c99_C99ReprType in_C99ReprType_1) {
	struct mirth_c99_C99ReprType_Table v3 = *in_C99ReprType_1.ptr.Table;
	if (!--(in_C99ReprType_1.ptr.Table->refs)) {
		free(in_C99ReprType_1.ptr.Table);
	} else {
	}
	return v3.mTable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x97e1a
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_C99ReprType_Data
static uint64_t mtp_mirth_c99_C99ReprType_Data (struct mirth_c99_C99ReprType in_C99ReprType_1) {
	struct mirth_c99_C99ReprType_Data v3 = *in_C99ReprType_1.ptr.Data;
	if (!--(in_C99ReprType_1.ptr.Data->refs)) {
		free(in_C99ReprType_1.ptr.Data);
	} else {
	}
	return v3.mData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x97e37
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x97e8b
decl (%rax)
jne 0x97e8b
leaq 0x72019(%rip), %rax     # 0x109e99
movq %rsi, %rdi
movq %rax, %rsi
callq 0xce94
leaq -0x28(%rbp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6d38a
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_O2/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 0x97efd
decl (%rax)
jne 0x97efd
leaq 0x71fef(%rip), %rax     # 0x109ee1
movq %rsi, %rdi
movq %rax, %rsi
callq 0xce94
leaq -0x28(%rbp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1e4f2
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_O2/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 %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 0x98059
decl (%rax)
jne 0x98059
leaq 0x71e4b(%rip), %rax     # 0x109e99
movq %rsi, %rdi
movq %rax, %rsi
callq 0xce94
leaq -0x28(%rbp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x172b6
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_O2/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 0x98354
movq %rax, %r14
movq 0x1075fac(%rip), %r15   # 0x110e050
testq %r15, %r15
jne 0x980c1
leaq 0x44645(%rip), %rdi     # 0xdc6f5
xorl %esi, %esi
callq 0x8a21
movq %rax, %r15
movq %rax, 0x1075f8f(%rip)   # 0x110e050
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movq %r15, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x980e1
incl (%rax)
movq 0x1075f70(%rip), %rsi   # 0x110e058
testq %rsi, %rsi
jne 0x98106
leaq 0x55412(%rip), %rdi     # 0xed506
pushq $0x5
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x1075f52(%rip)   # 0x110e058
movq %rsi, %rax
andq %r12, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x9811c
incl (%rax)
movq %r15, %rdi
callq 0xd8b0
movq %rax, %rdi
movq %r14, %rsi
callq 0xd8b0
movq %rax, %r14
movq 0x1075f27(%rip), %rsi   # 0x110e060
testq %rsi, %rsi
jne 0x98157
leaq 0x5551c(%rip), %rdi     # 0xed661
pushq $0x4
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x1075f09(%rip)   # 0x110e060
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x9816c
incl (%r12)
movq %r14, %rdi
callq 0xd8b0
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_O2/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 0x98354
movq %rax, %r14
movq 0x1075ebb(%rip), %r15   # 0x110e068
testq %r15, %r15
jne 0x981ca
leaq 0x4453c(%rip), %rdi     # 0xdc6f5
xorl %esi, %esi
callq 0x8a21
movq %rax, %r15
movq %rax, 0x1075e9e(%rip)   # 0x110e068
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movq %r15, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x981ea
incl (%rax)
movq 0x1075e7f(%rip), %rsi   # 0x110e070
testq %rsi, %rsi
jne 0x9820f
leaq 0x55469(%rip), %rdi     # 0xed666
pushq $0x6
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x1075e61(%rip)   # 0x110e070
movq %rsi, %rax
andq %r12, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x98225
incl (%rax)
movq %r15, %rdi
callq 0xd8b0
movq %rax, %rdi
movq %r14, %rsi
callq 0xd8b0
movq %rax, %r14
movq 0x1075e36(%rip), %rsi   # 0x110e078
testq %rsi, %rsi
jne 0x98260
leaq 0x5541f(%rip), %rdi     # 0xed66d
pushq $0x4
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x1075e18(%rip)   # 0x110e078
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x98275
incl (%r12)
movq %r14, %rdi
callq 0xd8b0
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_O2/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 0x98354
movq %rax, %r14
movq 0x1075dca(%rip), %r15   # 0x110e080
testq %r15, %r15
jne 0x982d3
leaq 0x44433(%rip), %rdi     # 0xdc6f5
xorl %esi, %esi
callq 0x8a21
movq %rax, %r15
movq %rax, 0x1075dad(%rip)   # 0x110e080
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movq %r15, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x982f3
incl (%rax)
movq 0x1075d8e(%rip), %rsi   # 0x110e088
testq %rsi, %rsi
jne 0x98318
leaq 0x55260(%rip), %rdi     # 0xed566
pushq $0x7
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x1075d70(%rip)   # 0x110e088
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x9832d
incl (%r12)
movq %r15, %rdi
callq 0xd8b0
movq %rax, %rdi
movq %r14, %rsi
callq 0xd8b0
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_O2/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 0x9839e
decl (%rax)
jne 0x9839e
leaq 0x71b4e(%rip), %rax     # 0x109ee1
movq %rsi, %rdi
movq %rax, %rsi
callq 0xce94
leaq -0x28(%rbp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x9339f
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_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataStructRepr_underlyingzec99zetype
static STR* mw_mirth_c99_C99DataStructRepr_underlyingzec99zetype (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataStructRepr* in_C99DataStructRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	STR* v5;
	STRLIT(v5, "", 0);
	STR* v6;
	STRLIT(v6, "struct ", 7);
	STR* v7;
	mw_std_str_zaStr_pushzestrzx(v6, v5, &v7);
	STR* v8 = in_C99DataStructRepr_2->mcname;
	incref(MKSTR(v8));
	decref(MK_mirth_c99_C99DataStructRepr(in_C99DataStructRepr_2));
	STR* v9;
	mw_std_str_zaStr_pushzestrzx(v8, v7, &v9);
	STR* v10;
	STRLIT(v10, "*", 1);
	STR* v11;
	mw_std_str_zaStr_pushzestrzx(v10, v9, &v11);
	*out_zaMirth_3 = in_zaMirth_1;
	return v11;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movq %rdi, %r14
movq 0x107246f(%rip), %r12   # 0x110e4b0
testq %r12, %r12
jne 0x9c05e
leaq 0x406a8(%rip), %rdi     # 0xdc6f5
xorl %esi, %esi
callq 0x8a21
movq %rax, %r12
movq %rax, 0x1072452(%rip)   # 0x110e4b0
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movq %r12, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x9c07e
incl (%rax)
movq 0x1072433(%rip), %rsi   # 0x110e4b8
testq %rsi, %rsi
jne 0x9c0a3
leaq 0x514d5(%rip), %rdi     # 0xed566
pushq $0x7
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x1072415(%rip)   # 0x110e4b8
movq %rsi, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x9c0b9
incl (%rax)
movq %r12, %rdi
callq 0xd8b0
movq %rax, %r12
movq 0x10(%r15), %r13
movq %r13, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0x9c0de
incl (%rax)
movq %r15, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x9c105
decl (%rax)
jne 0x9c105
leaq 0x6dd9c(%rip), %rsi     # 0x109e99
movq %r15, %rdi
callq 0xce94
movq %r12, %rdi
movq %r13, %rsi
callq 0xd8b0
movq %rax, %r15
movq 0x10723a6(%rip), %rsi   # 0x110e4c0
testq %rsi, %rsi
jne 0x9c138
leaq 0x5206f(%rip), %rdi     # 0xee195
pushq $0x1
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x1072388(%rip)   # 0x110e4c0
andq %rsi, %rbx
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x9c14b
incl (%rbx)
movq %r15, %rdi
callq 0xd8b0
movq -0x30(%rbp), %rcx
movq %r14, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataStructField_iszephysicalzy
static bool mw_mirth_c99_C99DataStructField_iszephysicalzy (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataStructField* in_C99DataStructField_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_c99_C99ReprType v5 = in_C99DataStructField_2->mc99zerepr;
	incref(MK_mirth_c99_C99ReprType(v5));
	decref(MK_mirth_c99_C99DataStructField(in_C99DataStructField_2));
	struct mirth_mirth_zaMirth* v6;
	bool v7 = mw_mirth_c99_C99ReprType_iszephysicalzy(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 0x18(%rsi), %r15d
movq 0x20(%rsi), %r12
movq %r12, %rcx
andq %rax, %rcx
sete %dl
testb $0x3, %r12b
setne %dil
orb %dl, %dil
jne 0x9c76c
incl (%rcx)
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x9c793
decl (%rax)
jne 0x9c793
leaq 0x6d7e9(%rip), %rax     # 0x109f71
movq %rsi, %rdi
movq %rax, %rsi
callq 0xce94
leaq -0x30(%rbp), %r13
movq %r14, %rdi
movl %r15d, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0x9e05c
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_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99ReprType_iszephysicalzy
static bool mw_mirth_c99_C99ReprType_iszephysicalzy (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99ReprType in_C99ReprType_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* branch_zaMirth_5;
	bool branch_Bool_6;
	switch ((in_C99ReprType_2).tag) {
		case mirth_c99_C99ReprType_Void: {
			bool v7 = false;
			branch_Bool_6 = v7;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case mirth_c99_C99ReprType_Data: {
			uint64_t v8 = mtp_mirth_c99_C99ReprType_Data(in_C99ReprType_2);
			struct mirth_mirth_zaMirth* v9;
			bool v10 = mw_mirth_data_Data_iszephysicalzy(in_zaMirth_1, v8, &v9);
			branch_Bool_6 = v10;
			branch_zaMirth_5 = v9;
		} break;
		default: {
			decref(MK_mirth_c99_C99ReprType(in_C99ReprType_2));
			bool v11 = true;
			branch_Bool_6 = v11;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
	}
	*out_zaMirth_3 = branch_zaMirth_5;
	return branch_Bool_6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdi, %r14
testl %esi, %esi
je 0x9e0ab
cmpl $0x15, %esi
jne 0x9e0b0
movq %rdx, %rdi
callq 0x97e24
leaq -0x28(%rbp), %r12
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x85216
movl %eax, %edi
movq %rdx, %rsi
callq 0x850d1
movl %eax, %r15d
xorb $0x1, %r15b
movq (%r12), %r14
jmp 0x9e0ec
xorl %r15d, %r15d
jmp 0x9e0ec
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %dil
movb $0x1, %r15b
orb %cl, %dil
jne 0x9e0ec
decl (%rax)
jne 0x9e0ec
shlq $0x30, %rsi
orq %rdx, %rsi
leaq 0x6be48(%rip), %rax     # 0x109f29
movq %rsi, %rdi
movq %rax, %rsi
callq 0xce94
movq %r14, (%rbx)
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_prim_Str_Str_1_sp8
static STR* mw_std_prim_Str_Str_1_sp8 (STR* in_Str_1) {
	STR* v3;
	STRLIT(v3, "", 0);
	STR* v4;
	STRLIT(v4, "MKI64(", 6);
	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 0x107065d(%rip), %r14   # 0x110e770
testq %r14, %r14
jne 0x9e130
leaq 0x3e5d6(%rip), %rdi     # 0xdc6f5
xorl %esi, %esi
callq 0x8a21
movq %rax, %r14
movq %rax, 0x1070640(%rip)   # 0x110e770
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq %r14, %rax
andq %r15, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x9e150
incl (%rax)
movq 0x1070621(%rip), %rsi   # 0x110e778
testq %rsi, %rsi
jne 0x9e175
leaq 0x4f845(%rip), %rdi     # 0xed9a8
pushq $0x6
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x1070603(%rip)   # 0x110e778
movq %rsi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x9e18b
incl (%rax)
movq %r14, %rdi
callq 0xd8b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd8b0
movq %rax, %rbx
movq 0x10705d8(%rip), %rsi   # 0x110e780
testq %rsi, %rsi
jne 0x9e1c6
leaq 0x4ff49(%rip), %rdi     # 0xee0fd
pushq $0x1
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x10705ba(%rip)   # 0x110e780
andq %rsi, %r15
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x9e1da
incl (%r15)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd8b0
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_prim_Str_Str_1_sp24
static STR* mw_std_prim_Str_Str_1_sp24 (STR* in_Str_1, STR* in_Str_2) {
	STR* v4;
	STRLIT(v4, "", 0);
	STR* v5;
	STRLIT(v5, "MK_", 3);
	STR* v6;
	mw_std_str_zaStr_pushzestrzx(v5, v4, &v6);
	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);
	STR* v10;
	mw_std_str_zaStr_pushzestrzx(in_Str_1, v9, &v10);
	STR* v11;
	STRLIT(v11, ")", 1);
	STR* v12;
	mw_std_str_zaStr_pushzestrzx(v11, v10, &v12);
	return v12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x107059c(%rip), %r15   # 0x110e7a0
testq %r15, %r15
jne 0x9e221
leaq 0x3e4e5(%rip), %rdi     # 0xdc6f5
xorl %esi, %esi
callq 0x8a21
movq %rax, %r15
movq %rax, 0x107057f(%rip)   # 0x110e7a0
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movq %r15, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x9e241
incl (%rax)
movq 0x1070560(%rip), %rsi   # 0x110e7a8
testq %rsi, %rsi
jne 0x9e266
leaq 0x4f3c1(%rip), %rdi     # 0xed615
pushq $0x3
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x1070542(%rip)   # 0x110e7a8
movq %rsi, %rax
andq %r12, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x9e27c
incl (%rax)
movq %r15, %rdi
callq 0xd8b0
movq %rax, %rdi
movq %r14, %rsi
callq 0xd8b0
movq %rax, %r14
movq 0x1070517(%rip), %rsi   # 0x110e7b0
testq %rsi, %rsi
jne 0x9e2b7
leaq 0x4ffd1(%rip), %rdi     # 0xee276
pushq $0x1
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x10704f9(%rip)   # 0x110e7b0
movq %rsi, %rax
andq %r12, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x9e2cd
incl (%rax)
movq %r14, %rdi
callq 0xd8b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd8b0
movq %rax, %rbx
movq 0x10704ce(%rip), %rsi   # 0x110e7b8
testq %rsi, %rsi
jne 0x9e308
leaq 0x4fe07(%rip), %rdi     # 0xee0fd
pushq $0x1
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x10704b0(%rip)   # 0x110e7b8
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x9e31d
incl (%r12)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd8b0
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataSumTagRepr_tag
static uint64_t mw_mirth_c99_C99DataSumTagRepr_tag (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataSumTagRepr in_C99DataSumTagRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* branch_zaMirth_5;
	uint64_t branch_Tag_6;
	switch ((in_C99DataSumTagRepr_2).tag) {
		case mirth_c99_C99DataSumTagRepr_Unit: {
			struct mirth_c99_C99DataUnitRepr* v7 = mtp_mirth_c99_C99DataSumTagRepr_Unit(in_C99DataSumTagRepr_2);
			uint64_t v8 = v7->mtag;
			decref(MK_mirth_c99_C99DataUnitRepr(v7));
			branch_Tag_6 = v8;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case mirth_c99_C99DataSumTagRepr_Struct: {
			struct mirth_c99_C99DataStructRepr* v9 = mtp_mirth_c99_C99DataSumTagRepr_Struct(in_C99DataSumTagRepr_2);
			uint64_t v10 = v9->mtag;
			decref(MK_mirth_c99_C99DataStructRepr(v9));
			branch_Tag_6 = v10;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_3 = branch_zaMirth_5;
	return branch_Tag_6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x1, %esi
je 0x9e37a
testl %esi, %esi
jne 0x9e3c5
movq %rdx, %rdi
callq 0x9e58f
movq 0x8(%rax), %r15
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x9e3b4
decl (%rcx)
jne 0x9e3b4
leaq 0x6ba49(%rip), %rsi     # 0x109dc1
jmp 0x9e3ac
movq %rdx, %rdi
callq 0x9e5ca
movq 0x8(%rax), %r15
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x9e3b4
decl (%rcx)
jne 0x9e3b4
leaq 0x6baed(%rip), %rsi     # 0x109e99
movq %rax, %rdi
callq 0xce94
movq %r14, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x36441(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6