LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataSumTagRepr_unionzememberzy
static struct std_maybe_Maybe_1 mw_mirth_c99_C99DataSumTagRepr_unionzememberzy (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;
	struct std_maybe_Maybe_1 branch_Maybe_6;
	switch ((in_C99DataSumTagRepr_2).tag) {
		case mirth_c99_C99DataSumTagRepr_Unit: {
			struct mirth_c99_C99DataUnitRepr* v7 = mtp_mirth_c99_C99DataSumTagRepr_Unit(in_C99DataSumTagRepr_2);
			decref(MK_mirth_c99_C99DataUnitRepr(v7));
			struct std_maybe_Maybe_1 v8 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_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));
			struct mirth_mirth_zaMirth* v11;
			uint64_t v12 = mw_mirth_data_Tag_name(in_zaMirth_1, v10, &v11);
			struct mirth_mirth_zaMirth* v13;
			STR* v14 = mw_mirth_name_Name_mangled(v11, v12, &v13);
			struct std_maybe_Maybe_1 v15 = mtw_std_maybe_Maybe_1_Some(MKSTR(v14));
			branch_Maybe_6 = v15;
			branch_zaMirth_5 = v13;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_3 = branch_zaMirth_5;
	return branch_Maybe_6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %esi, %r14d
movq %rdi, %r15
cmpl $0x1, %esi
je 0x9e43e
testl %r14d, %r14d
jne 0x9e4c4
movq %rdx, %rdi
callq 0x9e58f
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x9e43a
decl (%rcx)
jne 0x9e43a
leaq 0x6b98f(%rip), %rsi     # 0x109dc1
movq %rax, %rdi
callq 0xce94
xorl %edx, %edx
jmp 0x9e4af
movq %rdx, %rdi
callq 0x9e5ca
movq 0x8(%rax), %r12
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x9e478
decl (%rcx)
jne 0x9e478
leaq 0x6ba29(%rip), %rsi     # 0x109e99
movq %rax, %rdi
callq 0xce94
leaq -0x38(%rbp), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x172df
movq (%r13), %rdi
leaq -0x30(%rbp), %r15
movq %rax, %rsi
movq %r15, %rdx
callq 0x8b231
leaq 0x69cb5(%rip), %rsi     # 0x108159
movq %rax, %rdi
callq 0x8d0c
movq (%r15), %r15
movq %r15, (%rbx)
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x36342(%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: mw_mirth_c99_zaC99_c99zeline_1_sp30
static void mw_mirth_c99_zaC99_c99zeline_1_sp30 (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, "} break;", 8);
	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 0x107039c(%rip), %rdx   # 0x110e8a0
testq %rdx, %rdx
jne 0x9e522
leaq 0x4f4d7(%rip), %rdi     # 0xed9e7
pushq $0x8
popq %rsi
callq 0x8a21
movq %rax, %rdx
movq %rax, 0x107037e(%rip)   # 0x110e8a0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x9e540
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: mtp_mirth_c99_C99DataSumTagRepr_Unit
static struct mirth_c99_C99DataUnitRepr* mtp_mirth_c99_C99DataSumTagRepr_Unit (struct mirth_c99_C99DataSumTagRepr in_C99DataSumTagRepr_1) {
	struct mirth_c99_C99DataSumTagRepr_Unit v3 = *in_C99DataSumTagRepr_1.ptr.Unit;
	if (!--(in_C99DataSumTagRepr_1.ptr.Unit->refs)) {
		free(in_C99DataSumTagRepr_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 0x9e5bb
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x9e5c0
incl (%rax)
jmp 0x9e5c0
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_C99DataSumTagRepr_Struct
static struct mirth_c99_C99DataStructRepr* mtp_mirth_c99_C99DataSumTagRepr_Struct (struct mirth_c99_C99DataSumTagRepr in_C99DataSumTagRepr_1) {
	struct mirth_c99_C99DataSumTagRepr_Struct v3 = *in_C99DataSumTagRepr_1.ptr.Struct;
	if (!--(in_C99DataSumTagRepr_1.ptr.Struct->refs)) {
		free(in_C99DataSumTagRepr_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 0x9e5f6
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x9e5fb
incl (%rax)
jmp 0x9e5fb
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_data_Tag_preferzeinlinezy
static bool mw_mirth_data_Tag_preferzeinlinezy (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_maybe_Maybe_1 v8 = mw_mirth_data_Data_semizetransparentzy(v5, v6, &v7);
	int64_t v9 = (v8).tag;
	decref(MK_std_maybe_Maybe_1(v8));
	INT v10 = WRAP_I63(0LL);
	INT v11 = v10;
	INT v12 = i64_to_int(v9);
	bool v13 = int_eq(v12, v11);
	bool v14 = !v13;
	struct mirth_mirth_zaMirth* branch_zaMirth_15;
	uint64_t branch_Tag_16;
	bool branch_Bool_17;
	if (v14) {
		bool v18 = true;
		branch_Bool_17 = v18;
		branch_Tag_16 = in_Tag_2;
		branch_zaMirth_15 = v7;
	} else {
		struct mirth_mirth_zaMirth* v19;
		INT v20 = mw_mirth_data_Tag_numzetotalzeinputs(v7, in_Tag_2, &v19);
		INT v21 = WRAP_I63(0LL);
		INT v22 = v21;
		INT v23 = v20;
		bool v24 = int_eq(v23, v22);
		branch_Bool_17 = v24;
		branch_Tag_16 = in_Tag_2;
		branch_zaMirth_15 = v19;
	}
	*out_zaMirth_3 = branch_zaMirth_15;
	return branch_Bool_17;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x30(%rbp), %r15
movq %r15, %rdx
callq 0x172b6
movq (%r15), %rdi
leaq -0x20(%rbp), %rdx
movq %rax, %rsi
callq 0x71564
movl %eax, %r15d
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x9e66c
decl (%rax)
jne 0x9e66c
movq %r15, %rdi
shlq $0x30, %rdi
orq %rdx, %rdi
leaq 0x69c5a(%rip), %rsi     # 0x1082c1
callq 0xce94
movq %r15, %rdi
callq 0xd86d
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xd759
testb %al, %al
je 0x9e6a6
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x6ee9c
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xd759
movq (%r15), %rcx
jmp 0x9e6ac
movb $0x1, %al
movq -0x20(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x18, %rsp
popq %rbx
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_zaC99_c99zeline_1_sp105
static struct mirth_c99_C99API* mw_mirth_c99_zaC99_c99zeline_1_sp105 (struct mirth_c99_C99API* in_C99API_1, struct mirth_mirth_zaMirth* in_zaMirth_2, struct mirth_c99_zaC99* in_zaC99_3, struct mirth_mirth_zaMirth* *out_zaMirth_5, struct mirth_c99_zaC99* *out_zaC99_6) {
	struct mirth_mirth_zaMirth* v7;
	struct mirth_c99_zaC99* v8;
	mw_mirth_c99_zaC99_indent(in_zaMirth_2, in_zaC99_3, &v7, &v8);
	incref(MK_mirth_c99_C99API(in_C99API_1));
	struct mirth_mirth_zaMirth* v9;
	struct mirth_c99_zaC99* v10;
	mw_mirth_c99_zaC99_smartzesigzeput(v7, v8, in_C99API_1, &v9, &v10);
	STR* v11;
	STRLIT(v11, " {", 2);
	struct mirth_mirth_zaMirth* v12;
	struct mirth_c99_zaC99* v13;
	mw_mirth_c99_zaC99_put(v9, v10, v11, &v12, &v13);
	struct mirth_mirth_zaMirth* v14;
	struct mirth_c99_zaC99* v15;
	mw_mirth_c99_zaC99_line(v12, v13, &v14, &v15);
	*out_zaC99_6 = v15;
	*out_zaMirth_5 = v14;
	return in_C99API_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rdi, %r15
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
leaq -0x48(%rbp), %rax
leaq -0x40(%rbp), %rcx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x8bc28
movq %r15, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x9e901
incl (%rax)
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rcx
leaq -0x30(%rbp), %r8
movq %r15, %rdx
callq 0xa37da
movq 0x10700b0(%rip), %rdx   # 0x110e9d0
testq %rdx, %rdx
jne 0x9e93e
leaq 0x4f904(%rip), %rdi     # 0xee230
pushq $0x2
popq %rsi
callq 0x8a21
movq %rax, %rdx
movq %rax, 0x1070092(%rip)   # 0x110e9d0
andq %rdx, %r12
sete %al
testb $0x3, %dl
setne %cl
orb %al, %cl
jne 0x9e952
incl (%r12)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x68(%rbp), %r12
leaq -0x60(%rbp), %r13
movq %r12, %rcx
movq %r13, %r8
callq 0x8a8a9
movq (%r12), %rdi
movq (%r13), %rsi
leaq -0x58(%rbp), %r12
leaq -0x50(%rbp), %r13
movq %r12, %rdx
movq %r13, %rcx
callq 0x8a92c
movq (%r13), %rax
movq %rax, (%r14)
movq (%r12), %rax
movq %rax, (%rbx)
movq %r15, %rax
addq $0x48, %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_zaC99_stackzetypezetozec99zeapizeparams
static struct std_list_List_1 mw_mirth_c99_zaC99_stackzetypezetozec99zeapizeparams (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99* in_zaC99_2, struct mirth_type_StackType in_StackType_3, enum mirth_c99_C99APIArgMode in_C99APIArgMode_4, struct mirth_mirth_zaMirth* *out_zaMirth_5, struct mirth_c99_zaC99* *out_zaC99_6, bool *out_Bool_7) {
	struct mirth_mirth_zaMirth* v9;
	struct mirth_c99_zaC99* v10;
	enum mirth_c99_C99APIArgMode v11;
	bool v12;
	struct std_list_List_1 v13 = mw_mirth_c99_zaC99_stackzetypezetozec99zeapizeparamszeaux(in_zaMirth_1, in_zaC99_2, in_C99APIArgMode_4, in_StackType_3, &v9, &v10, &v11, &v12);
	struct std_list_List_1 v14 = mw_std_list_List_1_reverse(v13);
	*out_Bool_7 = v12;
	*out_zaC99_6 = v10;
	*out_zaMirth_5 = v9;
	return v14;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %rcx, %rax
movl %edx, %ecx
movq 0x18(%rbp), %r12
subq $0x8, %rsp
leaq -0x29(%rbp), %r13
leaq -0x30(%rbp), %r10
leaq -0x38(%rbp), %r15
leaq -0x40(%rbp), %r14
movl %r8d, %edx
movq %rax, %r8
movq %r14, %r9
pushq %r13
pushq %r10
pushq %r15
callq 0xa1c6b
addq $0x20, %rsp
movl %eax, %edi
movq %rdx, %rsi
callq 0xcd32
movb (%r13), %cl
movb %cl, (%r12)
movq (%r15), %rcx
movq 0x10(%rbp), %rsi
movq %rcx, (%rsi)
movq (%r14), %rcx
movq %rcx, (%rbx)
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_c99_zaC99_freshzenamezeonzx
static STR* mw_mirth_c99_zaC99_freshzenamezeonzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99* in_zaC99_2, STR* in_Str_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_c99_zaC99* *out_zaC99_5) {
	struct mirth_mirth_zaMirth* v7;
	struct mirth_c99_zaC99* v8;
	INT v9 = mw_mirth_c99_zaC99_freshzenatzx(in_zaMirth_1, in_zaC99_2, &v7, &v8);
	INT v10 = v9;
	STR* v11 = int_to_str(v10);
	STR* v12 = str_cat(in_Str_3, v11);
	*out_zaC99_5 = v8;
	*out_zaMirth_4 = v7;
	return v12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, -0x30(%rbp)
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x10(%rsi), %rbx
movq %rbx, %rax
andq %r15, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xa2c40
addl $0x2, (%rax)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xdd03
movq %rax, %r14
movq 0x10(%r12), %rdi
andq %rdi, %r15
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0xa2c75
decl (%r15)
jne 0xa2c75
leaq 0x654a1(%rip), %rsi     # 0x108111
callq 0xce94
movq %r14, 0x10(%r12)
movq %rbx, %rdi
callq 0xf51c
movq %r13, %rdi
movq %rax, %rsi
callq 0xd8b0
movq -0x38(%rbp), %rcx
movq %r12, (%rcx)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rdx
movq %rdx, (%rcx)
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_c99_namezeargzeprefix
static STR* mw_mirth_c99_namezeargzeprefix (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Name_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	STR* v6 = mw_mirth_name_Name_mangled(in_zaMirth_1, in_Name_2, &v5);
	STR* v7;
	STRLIT(v7, "_", 1);
	STR* v8 = str_cat(v6, v7);
	*out_zaMirth_3 = v5;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x18(%rbp), %rdx
callq 0x8b231
movq %rax, %r14
movq 0x106bcf9(%rip), %rsi   # 0x110e9c8
testq %rsi, %rsi
jne 0xa2ced
leaq 0x362f5(%rip), %rdi     # 0xd8fd0
pushq $0x1
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x106bcdb(%rip)   # 0x110e9c8
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa2d0a
incl (%rax)
movq %r14, %rdi
callq 0xd8b0
movq -0x18(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_c99_C99APIArg_free
static void mirth_c99_C99APIArg_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_c99_C99APIArg);
	struct mirth_c99_C99APIArg* self = vself.data.ptr;
	decref(MK_mirth_c99_C99APIArgSource(self->margzesource));
	decref(MK_mirth_c99_C99ReprType(self->margzerepr));
	decref(MKSTR(self->margzename));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x67361(%rip), %rax     # 0x10a091
cmpq %rsi, %rax
jne 0xa2ddc
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 0xa2d78
decl (%rax)
jne 0xa2d78
leaq 0x67371(%rip), %rsi     # 0x10a0d9
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 0xa2daa
decl (%rax)
jne 0xa2daa
leaq 0x6718f(%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 0xa2dd0
decl (%r14)
jne 0xa2dd0
leaq 0x6538e(%rip), %rsi     # 0x108159
callq 0xce94
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0x4acd7(%rip), %rsi     # 0xedaba
pushq $0x2
popq %rdi
pushq $0x53
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_C99APIArgSource_free
void mirth_c99_C99APIArgSource_free (VAL v) {
	struct mirth_c99_C99APIArgSource self = V_mirth_c99_C99APIArgSource(v);
	switch (self.tag) {
		case mirth_c99_C99APIArgSource_Value: break;
		case mirth_c99_C99APIArgSource_ValueLabel: {
			free(self.ptr.ValueLabel);
		} break;
		case mirth_c99_C99APIArgSource_Resource: break;
		case mirth_c99_C99APIArgSource_ResourceLabel: {
			free(self.ptr.ResourceLabel);
		} break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
shrq $0x30, %rax
orl $0x2, %eax
cmpl $0x3, %eax
jne 0xa2e70
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdi
popq %rbp
jmp 0x5030
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99APIArg_iszephysicalzy
static bool mw_mirth_c99_C99APIArg_iszephysicalzy (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99APIArg* in_C99APIArg_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_c99_C99ReprType v5 = in_C99APIArg_2->margzerepr;
	incref(MK_mirth_c99_C99ReprType(v5));
	decref(MK_mirth_c99_C99APIArg(in_C99APIArg_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 0xa2eff
incl (%rcx)
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa2f26
decl (%rax)
jne 0xa2f26
leaq 0x67176(%rip), %rax     # 0x10a091
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: mtp_mirth_c99_C99APIArgSource_ValueLabel
static uint64_t mtp_mirth_c99_C99APIArgSource_ValueLabel (struct mirth_c99_C99APIArgSource in_C99APIArgSource_1) {
	struct mirth_c99_C99APIArgSource_ValueLabel v3 = *in_C99APIArgSource_1.ptr.ValueLabel;
	if (!--(in_C99APIArgSource_1.ptr.ValueLabel->refs)) {
		free(in_C99APIArgSource_1.ptr.ValueLabel);
	} else {
	}
	return v3.mLabel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0xa2f64
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_type_MetaVar_haszevarzy
static bool mw_mirth_type_MetaVar_haszevarzy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Var_2, uint64_t in_MetaVar_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	struct mirth_mirth_zaMirth* v6;
	struct std_maybe_Maybe_1 v7 = mw_mirth_type_MetaVar_typezy(in_zaMirth_1, in_MetaVar_3, &v6);
	struct mirth_mirth_zaMirth* branch_zaMirth_8;
	bool branch_Bool_9;
	switch ((v7).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v10 = mtp_std_maybe_Maybe_1_Some(v7);
			struct mirth_mirth_zaMirth* v11;
			bool v12 = mw_mirth_type_Type_haszevarzy(v6, in_Var_2, V_mirth_type_Type(v10), &v11);
			branch_Bool_9 = v12;
			branch_zaMirth_8 = v11;
		} break;
		case std_maybe_Maybe_1_None: {
			bool v13 = false;
			branch_Bool_9 = v13;
			branch_zaMirth_8 = v6;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_4 = branch_zaMirth_8;
	return branch_Bool_9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rsi, %r14
leaq -0x20(%rbp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2aadc
testl %eax, %eax
je 0xa3510
cmpl $0x1, %eax
jne 0xa3524
movq %rdx, %rdi
callq 0xd491
movq -0x20(%rbp), %rdi
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
movq %rax, %rdx
shrq $0x30, %rdx
leaq -0x28(%rbp), %r15
movq %r14, %rsi
movq %r15, %r8
callq 0xa3203
movq (%r15), %rcx
jmp 0xa3516
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movq %rcx, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x312e2(%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: mw_mirth_type_Resource_haszevarzy
static bool mw_mirth_type_Resource_haszevarzy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Var_2, struct mirth_type_Type in_Resource_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	struct mirth_type_Type v6 = mw_mirth_type_Resource_zgType(in_Resource_3);
	struct mirth_mirth_zaMirth* v7;
	bool v8 = mw_mirth_type_Type_haszevarzy(in_zaMirth_1, in_Var_2, v6, &v7);
	*out_zaMirth_4 = v7;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
leaq -0x18(%rbp), %r14
movq %r14, %r8
callq 0xa3203
movq (%r14), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_c99_C99API_free
static void mirth_c99_C99API_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_c99_C99API);
	struct mirth_c99_C99API* self = vself.data.ptr;
	decref(MKSTR(self->mcname));
	decref(MK_mirth_type_ArrowType(self->mtype));
	decref(MK_std_list_List_1(self->minzeparams));
	decref(MK_std_list_List_1(self->moutzeparamsze1));
	decref(MK_std_maybe_Maybe_1(self->mreturnzeparam));
	decref(MK_std_list_List_1(self->moutzeparamsze2));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x65b87(%rip), %rax     # 0x10a001
cmpq %rsi, %rax
jne 0xa45b2
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x8(%rdi), %rdi
movq %rdi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xa44b8
decl (%rax)
jne 0xa44b8
leaq 0x63ca6(%rip), %rsi     # 0x108159
callq 0xce94
movq 0x10(%rbx), %rdi
movq %rdi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xa44e0
decl (%rax)
jne 0xa44e0
leaq 0x6469e(%rip), %rsi     # 0x108b79
callq 0xce94
movq 0x20(%rbx), %rcx
leaq 0x63d8e(%rip), %r14     # 0x108279
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0xa4515
decl (%rax)
jne 0xa4515
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xce94
movq 0x30(%rbx), %rcx
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0xa4543
decl (%rax)
jne 0xa4543
movl 0x28(%rbx), %edi
shlq $0x30, %rdi
orq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0xce94
movq 0x40(%rbx), %rcx
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0xa4575
decl (%rax)
jne 0xa4575
leaq 0x63d5c(%rip), %rsi     # 0x1082c1
movl 0x38(%rbx), %edi
shlq $0x30, %rdi
orq 0x40(%rbx), %rdi
callq 0xce94
movq 0x50(%rbx), %rax
andq %rax, %r15
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0xa45a0
decl (%r15)
jne 0xa45a0
movl 0x48(%rbx), %edi
shlq $0x30, %rdi
orq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0xce94
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
leaq 0x4962d(%rip), %rsi     # 0xedbe6
pushq $0x2
popq %rdi
pushq $0x50
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_mirth_c99_zaC99_startzebranchzx
static void mw_mirth_c99_zaC99_startzebranchzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99* in_zaC99_2, bool in_Bool_3, struct std_list_List_1 in_List_4, struct mirth_mirth_zaMirth* *out_zaMirth_5, struct mirth_c99_zaC99Branch* *out_zaC99Branch_6) {
	struct mirth_c99_zaC99Stack v7 = { .tag=mirth_c99_zaC99Stack_zaNil };
	struct mirth_c99_zaC99Branch* v8;
	mtw_mirth_c99_zaC99Branch_zaC99Branch(in_zaC99_2, v7, in_List_4, in_Bool_3, &v8);
	*out_zaC99Branch_6 = v8;
	*out_zaMirth_5 = in_zaMirth_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %rbx
movl %edx, %r9d
movq %rdi, %r14
movq 0x10(%rbp), %r15
leaq -0x28(%rbp), %r12
movq %r12, (%rsp)
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa4733
movq (%r12), %rax
movq %rax, (%r15)
movq %r14, (%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_std_list_List_1_for_1_sp23
static void mw_std_list_List_1_for_1_sp23 (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99Branch* in_zaC99Branch_2, struct std_list_List_1 in_List_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_c99_zaC99Branch* *out_zaC99Branch_5) {
	bool v6 = true;
	struct mirth_mirth_zaMirth* r7 = in_zaMirth_1;
	struct mirth_c99_zaC99Branch* r8 = in_zaC99Branch_2;
	struct std_list_List_1 v9 = in_List_3;
	bool v10 = v6;
	bool v11 = v6;
	while (v11) {
		struct mirth_mirth_zaMirth* r12 = r7;
		struct mirth_c99_zaC99Branch* r13 = r8;
		struct std_list_List_1 v14 = v9;
		bool v15 = v10;
		struct mirth_mirth_zaMirth* branch_zaMirth_16;
		struct mirth_c99_zaC99Branch* branch_zaC99Branch_17;
		struct std_list_List_1 branch_List_18;
		bool branch_Bool_19;
		switch ((v14).tag) {
			case std_list_List_1_Cons: {
				struct std_list_List_1 v20;
				VAL v21 = mtp_std_list_List_1_Cons(v14, &v20);
				struct mirth_mirth_zaMirth* v22;
				struct mirth_c99_zaC99Branch* v23;
				mw_mirth_c99_C99APIArg_pushzeapizeargzx(r12, r13, V_mirth_c99_C99APIArg(v21), &v22, &v23);
				bool v24 = true;
				branch_Bool_19 = v24;
				branch_List_18 = v20;
				branch_zaC99Branch_17 = v23;
				branch_zaMirth_16 = v22;
			} break;
			case std_list_List_1_Nil: {
				struct std_list_List_1 v25 = { .tag=std_list_List_1_Nil };
				bool v26 = false;
				branch_Bool_19 = v26;
				branch_List_18 = v25;
				branch_zaC99Branch_17 = r13;
				branch_zaMirth_16 = r12;
			} break;
			default: {
				do_panic(str_make("unexpected fallthrough in match\n", 32));
			}
		}
		v11 = branch_Bool_19;
		v10 = branch_Bool_19;
		v9 = branch_List_18;
		r8 = branch_zaC99Branch_17;
		r7 = branch_zaMirth_16;
	}
	decref(MK_std_list_List_1(v9));
	*out_zaC99Branch_5 = r8;
	*out_zaMirth_4 = r7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq -0x48(%rbp), %r13
movb $0x1, %al
movq %rcx, %rdi
testb $0x1, %al
je 0xa46d0
xorl %eax, %eax
movl $0x0, %ecx
testl %edx, %edx
je 0xa468a
cmpl $0x1, %edx
jne 0xa471c
movq %r13, %rsi
callq 0xce01
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
leaq -0x38(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0xa47b2
movl -0x48(%rbp), %edx
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %r15
movq -0x38(%rbp), %r12
jmp 0xa4688
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %sil
orb %cl, %sil
jne 0xa4707
decl (%rax)
jne 0xa4707
shlq $0x30, %rdx
orq %rdi, %rdx
leaq 0x63b7a(%rip), %rsi     # 0x108279
movq %rdx, %rdi
callq 0xce94
movq %r15, (%r14)
movq %r12, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x300ea(%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: mtw_mirth_c99_zaC99Branch_zaC99Branch
static void mtw_mirth_c99_zaC99Branch_zaC99Branch (struct mirth_c99_zaC99* in_zaC99_1, struct mirth_c99_zaC99Stack in_zaC99Stack_2, struct std_list_List_1 in_List_3, bool in_Bool_4, struct mirth_c99_zaC99Branch* *out_zaC99Branch_5) {
	struct mirth_c99_zaC99Branch* v6 = calloc(1, sizeof *v6);
	ASSERT(v6);
	v6->mreachable = in_Bool_4;
	v6->menv = in_List_3;
	v6->mzastack = in_zaC99Stack_2;
	v6->mzac99 = in_zaC99_1;
	*out_zaC99Branch_5 = v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r12d
movq %r8, %r14
movl %ecx, %ebx
movq %rdx, -0x30(%rbp)
movl %esi, %r13d
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0xa4793
movq 0x10(%rbp), %rcx
movb %r12b, 0x28(%rax)
movl %ebx, 0x18(%rax)
movq %r14, 0x20(%rax)
movl %r13d, 0x8(%rax)
movq -0x30(%rbp), %rdx
movq %rdx, 0x10(%rax)
movq %r15, (%rax)
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x494a6(%rip), %rsi     # 0xedc40
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_zaC99Value_zaC99Value
static void mtw_mirth_c99_zaC99Value_zaC99Value (struct mirth_c99_C99ReprType in_C99ReprType_1, STR* in_Str_2, struct mirth_c99_zaC99Value* *out_zaC99Value_3) {
	struct mirth_c99_zaC99Value* v4 = calloc(1, sizeof *v4);
	ASSERT(v4);
	v4->mvaluezename = in_Str_2;
	v4->mvaluezerepr = in_C99ReprType_1;
	*out_zaC99Value_3 = v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %r12d
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0xa49a9
movq %r15, 0x10(%rax)
movl %r12d, (%rax)
movq %r14, 0x8(%rax)
movq %rax, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x492c2(%rip), %rsi     # 0xedc72
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_mirth_c99_zaC99Value_pushzevaluezx
static void mw_mirth_c99_zaC99Value_pushzevaluezx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99Branch* in_zaC99Branch_2, struct mirth_c99_zaC99Value* in_zaC99Value_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_c99_zaC99Branch* *out_zaC99Branch_5) {
	struct mirth_c99_zaC99Stack r6 = in_zaC99Branch_2->mzastack;
	struct mirth_c99_zaC99Stack v7;
	mtw_mirth_c99_zaC99Stack_zaCons(r6, in_zaC99Value_3, &v7);
	in_zaC99Branch_2->mzastack = v7;
	*out_zaC99Branch_5 = in_zaC99Branch_2;
	*out_zaMirth_4 = in_zaMirth_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl 0x8(%rsi), %edi
movq 0x10(%rsi), %rsi
leaq -0x38(%rbp), %r13
movq %r13, %rcx
callq 0xa4b7d
movups (%r13), %xmm0
movups %xmm0, 0x8(%r15)
movq %r15, (%rbx)
movq %r12, (%r14)
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_c99_pushzevaluezelabelzx
static void mw_mirth_c99_pushzevaluezelabelzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99Branch* in_zaC99Branch_2, uint64_t in_Label_3, struct mirth_c99_zaC99Value* in_zaC99Value_4, struct mirth_mirth_zaMirth* *out_zaMirth_5, struct mirth_c99_zaC99Branch* *out_zaC99Branch_6) {
	struct mirth_c99_zaC99Stack r7 = in_zaC99Branch_2->mzastack;
	struct mirth_c99_zaC99Stack v8;
	mtw_mirth_c99_zaC99Stack_zaConsLabel(r7, in_zaC99Value_4, in_Label_3, &v8);
	in_zaC99Branch_2->mzastack = v8;
	*out_zaC99Branch_6 = in_zaC99Branch_2;
	*out_zaMirth_5 = in_zaMirth_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rdx, %rax
movq %rsi, %r15
movq %rdi, %r12
movl 0x8(%rsi), %edi
movq 0x10(%rsi), %rsi
leaq -0x38(%rbp), %r13
movq %rcx, %rdx
movq %rax, %rcx
movq %r13, %r8
callq 0xa4be1
movups (%r13), %xmm0
movups %xmm0, 0x8(%r15)
movq %r15, (%rbx)
movq %r12, (%r14)
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_c99_zaC99Value_turnzeintozeresourcezx
static void mw_mirth_c99_zaC99Value_turnzeintozeresourcezx (struct mirth_c99_zaC99Value* in_zaC99Value_1, struct mirth_c99_zaC99Resource* *out_zaC99Resource_2) {
	struct mirth_c99_C99ReprType v3;
	STR* v4;
	mtp_mirth_c99_zaC99Value_zaC99Value(in_zaC99Value_1, &v3, &v4);
	struct mirth_c99_zaC99Resource* v5;
	mtw_mirth_c99_zaC99Resource_zaC99Resource(v3, v4, &v5);
	*out_zaC99Resource_2 = v5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq -0x38(%rbp), %r14
leaq -0x28(%rbp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0xa4c55
movq (%r15), %rdx
movl (%r14), %edi
movq 0x8(%r14), %rsi
leaq -0x20(%rbp), %r14
movq %r14, %rcx
callq 0xa4c8e
movq (%r14), %rax
movq %rax, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_c99_zaC99Stack_zaCons
static void mtw_mirth_c99_zaC99Stack_zaCons (struct mirth_c99_zaC99Stack in_zaC99Stack_1, struct mirth_c99_zaC99Value* in_zaC99Value_2, struct mirth_c99_zaC99Stack *out_zaC99Stack_3) {
	struct mirth_c99_zaC99Stack_zaCons* v4 = calloc(1, sizeof *v4);
	ASSERT(v4);
	v4->mzaC99Value = in_zaC99Value_2;
	v4->mzaC99Stack = in_zaC99Stack_1;
	struct mirth_c99_zaC99Stack v5 = { .tag=mirth_c99_zaC99Stack_zaCons, .ptr.zaCons=v4 };
	*out_zaC99Stack_3 = v5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %r12d
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0xa4bc2
movq %r15, 0x10(%rax)
movl %r12d, (%rax)
movq %r14, 0x8(%rax)
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x490db(%rip), %rsi     # 0xedca4
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_zaC99Stack_zaConsLabel
static void mtw_mirth_c99_zaC99Stack_zaConsLabel (struct mirth_c99_zaC99Stack in_zaC99Stack_1, struct mirth_c99_zaC99Value* in_zaC99Value_2, uint64_t in_Label_3, struct mirth_c99_zaC99Stack *out_zaC99Stack_4) {
	struct mirth_c99_zaC99Stack_zaConsLabel* v5 = calloc(1, sizeof *v5);
	ASSERT(v5);
	v5->mLabel = in_Label_3;
	v5->mzaC99Value = in_zaC99Value_2;
	v5->mzaC99Stack = in_zaC99Stack_1;
	struct mirth_c99_zaC99Stack v6 = { .tag=mirth_c99_zaC99Stack_zaConsLabel, .ptr.zaConsLabel=v5 };
	*out_zaC99Stack_4 = v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %r13d
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0xa4c36
movq %r12, 0x18(%rax)
movq %r15, 0x10(%rax)
movl %r13d, (%rax)
movq %r14, 0x8(%rax)
movl $0x3, (%rbx)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x49099(%rip), %rsi     # 0xedcd6
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: mtp_mirth_c99_zaC99Value_zaC99Value
static void mtp_mirth_c99_zaC99Value_zaC99Value (struct mirth_c99_zaC99Value* in_zaC99Value_1, struct mirth_c99_C99ReprType *out_C99ReprType_2, STR* *out_Str_3) {
	struct mirth_c99_zaC99Value v4 = *in_zaC99Value_1;
	free(in_zaC99Value_1);
	*out_Str_3 = v4.mvaluezename;
	*out_C99ReprType_2 = v4.mvaluezerepr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movups (%rdi), %xmm0
movaps %xmm0, -0x30(%rbp)
movq 0x10(%rdi), %r15
callq 0x5030
movq %r15, (%rbx)
movaps -0x30(%rbp), %xmm0
movups %xmm0, (%r14)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_c99_zaC99Resource_zaC99Resource
static void mtw_mirth_c99_zaC99Resource_zaC99Resource (struct mirth_c99_C99ReprType in_C99ReprType_1, STR* in_Str_2, struct mirth_c99_zaC99Resource* *out_zaC99Resource_3) {
	struct mirth_c99_zaC99Resource* v4 = calloc(1, sizeof *v4);
	ASSERT(v4);
	v4->mresourcezename = in_Str_2;
	v4->mresourcezerepr = in_C99ReprType_1;
	*out_zaC99Resource_3 = v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %r12d
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0xa4ccc
movq %r15, 0x10(%rax)
movl %r12d, (%rax)
movq %r14, 0x8(%rax)
movq %rax, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x49035(%rip), %rsi     # 0xedd08
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_zaC99Stack_zaWith
static void mtw_mirth_c99_zaC99Stack_zaWith (struct mirth_c99_zaC99Stack in_zaC99Stack_1, struct mirth_c99_zaC99Resource* in_zaC99Resource_2, struct mirth_c99_zaC99Stack *out_zaC99Stack_3) {
	struct mirth_c99_zaC99Stack_zaWith* v4 = calloc(1, sizeof *v4);
	ASSERT(v4);
	v4->mzaC99Resource = in_zaC99Resource_2;
	v4->mzaC99Stack = in_zaC99Stack_1;
	struct mirth_c99_zaC99Stack v5 = { .tag=mirth_c99_zaC99Stack_zaWith, .ptr.zaWith=v4 };
	*out_zaC99Stack_3 = v5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %r12d
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0xa4d30
movq %r15, 0x10(%rax)
movl %r12d, (%rax)
movq %r14, 0x8(%rax)
movl $0x2, (%rbx)
movq %rax, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x49003(%rip), %rsi     # 0xedd3a
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_zaC99Stack_zaWithLabel
static void mtw_mirth_c99_zaC99Stack_zaWithLabel (struct mirth_c99_zaC99Stack in_zaC99Stack_1, struct mirth_c99_zaC99Resource* in_zaC99Resource_2, uint64_t in_Label_3, struct mirth_c99_zaC99Stack *out_zaC99Stack_4) {
	struct mirth_c99_zaC99Stack_zaWithLabel* v5 = calloc(1, sizeof *v5);
	ASSERT(v5);
	v5->mLabel = in_Label_3;
	v5->mzaC99Resource = in_zaC99Resource_2;
	v5->mzaC99Stack = in_zaC99Stack_1;
	struct mirth_c99_zaC99Stack v6 = { .tag=mirth_c99_zaC99Stack_zaWithLabel, .ptr.zaWithLabel=v5 };
	*out_zaC99Stack_4 = v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %r13d
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0xa4da4
movq %r12, 0x18(%rax)
movq %r15, 0x10(%rax)
movl %r13d, (%rax)
movq %r14, 0x8(%rax)
movl $0x4, (%rbx)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x48fc1(%rip), %rsi     # 0xedd6c
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_mirth_c99_zaC99ValuezfResource_pushzevaluezfresourcezx
static void mw_mirth_c99_zaC99ValuezfResource_pushzevaluezfresourcezx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99Branch* in_zaC99Branch_2, struct std_either_zaEither_2 in_zaC99ValuezfResource_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_c99_zaC99Branch* *out_zaC99Branch_5) {
	struct mirth_mirth_zaMirth* branch_zaMirth_6;
	struct mirth_c99_zaC99Branch* branch_zaC99Branch_7;
	switch ((in_zaC99ValuezfResource_3).tag) {
		case std_either_zaEither_2_zaLeft: {
			VAL v8;
			mtp_std_either_zaEither_2_zaLeft(in_zaC99ValuezfResource_3, &v8);
			struct mirth_mirth_zaMirth* v9;
			struct mirth_c99_zaC99Branch* v10;
			mw_mirth_c99_zaC99Value_pushzevaluezx(in_zaMirth_1, in_zaC99Branch_2, V_mirth_c99_zaC99Value(v8), &v9, &v10);
			branch_zaC99Branch_7 = v10;
			branch_zaMirth_6 = v9;
		} break;
		case std_either_zaEither_2_zaRight: {
			VAL v11;
			mtp_std_either_zaEither_2_zaRight(in_zaC99ValuezfResource_3, &v11);
			struct mirth_mirth_zaMirth* v12;
			struct mirth_c99_zaC99Branch* v13;
			mw_mirth_c99_zaC99Resource_pushzeresourcezx(in_zaMirth_1, in_zaC99Branch_2, V_mirth_c99_zaC99Resource(v11), &v12, &v13);
			branch_zaC99Branch_7 = v13;
			branch_zaMirth_6 = v12;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaC99Branch_5 = branch_zaC99Branch_7;
	*out_zaMirth_4 = branch_zaMirth_6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rsi, %r15
movq %rdi, %r12
cmpl $0x1, %edx
je 0xa5289
testl %edx, %edx
jne 0xa52d1
leaq -0x48(%rbp), %r13
movq %rcx, %rdi
movq %r13, %rsi
callq 0xa8b74
movq (%r13), %rdx
leaq -0x38(%rbp), %rcx
leaq -0x30(%rbp), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %rcx, %r15
movq %r13, %r8
callq 0xa49c8
jmp 0xa52b5
leaq -0x48(%rbp), %r13
movq %rcx, %rdi
movq %r13, %rsi
callq 0xa8c28
movq (%r13), %rdx
leaq -0x38(%rbp), %rcx
leaq -0x30(%rbp), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %rcx, %r15
movq %r13, %r8
callq 0xa4ab9
movq (%r13), %rax
movq (%r15), %rcx
movq %rax, (%r14)
movq %rcx, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f535(%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_C99DataTagRepr_free
void mirth_c99_C99DataTagRepr_free (VAL v) {
	struct mirth_c99_C99DataTagRepr self = V_mirth_c99_C99DataTagRepr(v);
	switch (self.tag) {
		case mirth_c99_C99DataTagRepr_Unit: {
			decref(MK_mirth_c99_C99DataUnitRepr(self.ptr.Unit->mC99DataUnitRepr));
			free(self.ptr.Unit);
		} break;
		case mirth_c99_C99DataTagRepr_Enum: {
			decref(MK_mirth_c99_C99DataEnumTagRepr(self.ptr.Enum->mC99DataEnumTagRepr));
			free(self.ptr.Enum);
		} break;
		case mirth_c99_C99DataTagRepr_Trans: {
			decref(MK_mirth_c99_C99DataTransRepr(self.ptr.Trans->mC99DataTransRepr));
			free(self.ptr.Trans);
		} break;
		case mirth_c99_C99DataTagRepr_Struct: {
			decref(MK_mirth_c99_C99DataStructRepr(self.ptr.Struct->mC99DataStructRepr));
			free(self.ptr.Struct);
		} break;
		case mirth_c99_C99DataTagRepr_Sum: {
			decref(MK_mirth_c99_C99DataSumTagRepr(self.ptr.Sum->mC99DataSumTagRepr));
			free(self.ptr.Sum);
		} break;
	}
}

// Assembly:
movq %rdi, %rcx
shrq $0x30, %rcx
cmpw $0x4, %cx
ja 0xa53f3
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rax, %rbx
leaq 0x2ebf2(%rip), %rdx     # 0xd3f08
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 0xa53e5
decl (%rax)
jne 0xa53e5
leaq 0x64a7a(%rip), %rsi     # 0x109dc1
jmp 0xa53e0
movq 0x10(%rbx), %rcx
andq %rcx, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0xa53e5
decl (%rax)
jne 0xa53e5
leaq 0x64c4a(%rip), %rsi     # 0x109fb9
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
jmp 0xa53e0
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xa53e5
decl (%rax)
jne 0xa53e5
leaq 0x64ab5(%rip), %rsi     # 0x109e51
jmp 0xa53e0
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xa53e5
decl (%rax)
jne 0xa53e5
leaq 0x64adb(%rip), %rsi     # 0x109e99
jmp 0xa53e0
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xa53e5
decl (%rax)
jne 0xa53e5
leaq 0x64d89(%rip), %rsi     # 0x10a169
callq 0xce94
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_C99DataTagRepr_Unit
static struct mirth_c99_C99DataUnitRepr* mtp_mirth_c99_C99DataTagRepr_Unit (struct mirth_c99_C99DataTagRepr in_C99DataTagRepr_1) {
	struct mirth_c99_C99DataTagRepr_Unit v3 = *in_C99DataTagRepr_1.ptr.Unit;
	if (!--(in_C99DataTagRepr_1.ptr.Unit->refs)) {
		free(in_C99DataTagRepr_1.ptr.Unit);
	} else {
		incref(MK_mirth_c99_C99DataUnitRepr(v3.mC99DataUnitRepr));
	}
	return v3.mC99DataUnitRepr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0xa54f1
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xa54f6
incl (%rax)
jmp 0xa54f6
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_C99DataTagRepr_Enum
static struct mirth_c99_C99DataEnumTagRepr* mtp_mirth_c99_C99DataTagRepr_Enum (struct mirth_c99_C99DataTagRepr in_C99DataTagRepr_1) {
	struct mirth_c99_C99DataTagRepr_Enum v3 = *in_C99DataTagRepr_1.ptr.Enum;
	if (!--(in_C99DataTagRepr_1.ptr.Enum->refs)) {
		free(in_C99DataTagRepr_1.ptr.Enum);
	} else {
		incref(MK_mirth_c99_C99DataEnumTagRepr(v3.mC99DataEnumTagRepr));
	}
	return v3.mC99DataEnumTagRepr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0xa552c
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xa5531
incl (%rax)
jmp 0xa5531
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_C99DataTagRepr_Trans
static struct mirth_c99_C99DataTransRepr* mtp_mirth_c99_C99DataTagRepr_Trans (struct mirth_c99_C99DataTagRepr in_C99DataTagRepr_1) {
	struct mirth_c99_C99DataTagRepr_Trans v3 = *in_C99DataTagRepr_1.ptr.Trans;
	if (!--(in_C99DataTagRepr_1.ptr.Trans->refs)) {
		free(in_C99DataTagRepr_1.ptr.Trans);
	} else {
		incref(MK_mirth_c99_C99DataTransRepr(v3.mC99DataTransRepr));
	}
	return v3.mC99DataTransRepr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0xa5567
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xa556c
incl (%rax)
jmp 0xa556c
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_C99DataTagRepr_Struct
static struct mirth_c99_C99DataStructRepr* mtp_mirth_c99_C99DataTagRepr_Struct (struct mirth_c99_C99DataTagRepr in_C99DataTagRepr_1) {
	struct mirth_c99_C99DataTagRepr_Struct v3 = *in_C99DataTagRepr_1.ptr.Struct;
	if (!--(in_C99DataTagRepr_1.ptr.Struct->refs)) {
		free(in_C99DataTagRepr_1.ptr.Struct);
	} else {
		incref(MK_mirth_c99_C99DataStructRepr(v3.mC99DataStructRepr));
	}
	return v3.mC99DataStructRepr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0xa55a2
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xa55a7
incl (%rax)
jmp 0xa55a7
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq