LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataTransRepr_mkzemacro
static STR* mw_mirth_c99_C99DataTransRepr_mkzemacro (struct mirth_mirth_zaMirth* in_zaMirth_1, STR* in_Str_2, struct mirth_c99_C99DataTransRepr* in_C99DataTransRepr_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	struct mirth_c99_C99ReprType v6 = in_C99DataTransRepr_3->mc99zerepr;
	incref(MK_mirth_c99_C99ReprType(v6));
	decref(MK_mirth_c99_C99DataTransRepr(in_C99DataTransRepr_3));
	struct mirth_mirth_zaMirth* v7;
	STR* v8 = mw_mirth_c99_C99ReprType_mkzemacro(in_zaMirth_1, in_Str_2, v6, &v7);
	*out_zaMirth_4 = v7;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %r13
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movl 0x30(%rdx), %r15d
movq 0x38(%rdx), %r12
movq %r12, %rcx
andq %rax, %rcx
sete %sil
testb $0x3, %r12b
setne %dil
orb %sil, %dil
jne 0xa7702
incl (%rcx)
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0xa7727
decl (%rax)
jne 0xa7727
leaq 0x6b732(%rip), %rsi     # 0x112e51
movq %rdx, %rdi
callq 0xd13d
leaq -0x38(%rbp), %rbx
movq %r13, %rdi
movq %r14, %rsi
movl %r15d, %edx
movq %r12, %rcx
movq %rbx, %r8
callq 0xa5fe9
movq (%rbx), %rcx
movq -0x30(%rbp), %rdx
movq %rcx, (%rdx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataStructRepr_mkzemacro
static STR* mw_mirth_c99_C99DataStructRepr_mkzemacro (struct mirth_mirth_zaMirth* in_zaMirth_1, STR* in_Str_2, struct mirth_c99_C99DataStructRepr* in_C99DataStructRepr_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	STR* v6;
	STRLIT(v6, "", 0);
	STR* v7;
	STRLIT(v7, "MK_", 3);
	STR* v8;
	mw_std_str_zaStr_pushzestrzx(v7, v6, &v8);
	STR* v9 = in_C99DataStructRepr_3->mcname;
	incref(MKSTR(v9));
	decref(MK_mirth_c99_C99DataStructRepr(in_C99DataStructRepr_3));
	STR* v10;
	mw_std_str_zaStr_pushzestrzx(v9, v8, &v10);
	STR* v11;
	STRLIT(v11, "(", 1);
	STR* v12;
	mw_std_str_zaStr_pushzestrzx(v11, v10, &v12);
	STR* v13;
	mw_std_str_zaStr_pushzestrzx(in_Str_2, v12, &v13);
	STR* v14;
	STRLIT(v14, ")", 1);
	STR* v15;
	mw_std_str_zaStr_pushzestrzx(v14, v13, &v15);
	*out_zaMirth_4 = in_zaMirth_1;
	return v15;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x38(%rbp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
movq 0x107003a(%rip), %r13   # 0x11177b8
testq %r13, %r13
jne 0xa779c
xorl %edi, %edi
callq 0xf5e4
movq %rax, %r13
movq $0x0, 0x10(%rax)
movq %rax, 0x107001c(%rip)   # 0x11177b8
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
movq %r13, %rax
andq %r14, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0xa77bc
incl (%rax)
movq 0x106fffd(%rip), %rsi   # 0x11177c0
testq %rsi, %rsi
jne 0xa77ee
movl $0x3, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x3, 0x10(%rax)
movw $0x4b4d, 0x18(%rax)     # imm = 0x4B4D
movb $0x5f, 0x1a(%rax)
movq %rax, 0x106ffd2(%rip)   # 0x11177c0
movq %rsi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa7804
incl (%rax)
movq %r13, %rdi
callq 0xe069
movq %rax, %r13
movq 0x10(%r12), %rbx
movq %rbx, %rax
andq %r14, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xa7829
incl (%rax)
movq %r12, %rax
andq %r14, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0xa7850
decl (%rax)
jne 0xa7850
leaq 0x6b651(%rip), %rsi     # 0x112e99
movq %r12, %rdi
callq 0xd13d
movq %r13, %rdi
movq %rbx, %rsi
callq 0xe069
movq %rax, %rbx
movq 0x106ff63(%rip), %rsi   # 0x11177c8
testq %rsi, %rsi
jne 0xa788a
movl $0x1, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x1, 0x10(%rax)
movb $0x28, 0x18(%rax)
movq %rax, 0x106ff3e(%rip)   # 0x11177c8
movq %rsi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa78a0
incl (%rax)
movq %rbx, %rdi
callq 0xe069
movq %rax, %rdi
movq %r15, %rsi
callq 0xe069
movq %rax, %rbx
movq 0x106ff13(%rip), %rsi   # 0x11177d0
testq %rsi, %rsi
jne 0xa78e2
movl $0x1, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x1, 0x10(%rax)
movb $0x29, 0x18(%rax)
movq %rax, 0x106feee(%rip)   # 0x11177d0
andq %rsi, %r14
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xa78f6
incl (%r14)
movq %rbx, %rdi
callq 0xe069
movq -0x38(%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_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataSumRepr_mkzemacro
static STR* mw_mirth_c99_C99DataSumRepr_mkzemacro (STR* in_Str_1, struct mirth_mirth_zaMirth* in_zaMirth_2, struct mirth_c99_C99DataSumRepr* in_C99DataSumRepr_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	struct mirth_mirth_zaMirth* v6;
	STR* v7 = mw_mirth_c99_C99DataSumRepr_cname(in_zaMirth_2, in_C99DataSumRepr_3, &v6);
	STR* v8 = mw_std_prim_Str_Str_1_sp24(in_Str_1, v7);
	*out_zaMirth_4 = v6;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %r15
movq %rsi, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq 0xa0ea2
movq %r14, %rdi
movq %rax, %rsi
callq 0xa7956
movq (%r15), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_prim_Str_Str_1_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 0x106fe2a(%rip), %r15   # 0x1117798
testq %r15, %r15
jne 0xa798c
xorl %edi, %edi
callq 0xf5e4
movq %rax, %r15
movq $0x0, 0x10(%rax)
movq %rax, 0x106fe0c(%rip)   # 0x1117798
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movq %r15, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0xa79ac
incl (%rax)
movq 0x106fded(%rip), %rsi   # 0x11177a0
testq %rsi, %rsi
jne 0xa79de
movl $0x3, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x3, 0x10(%rax)
movw $0x4b4d, 0x18(%rax)     # imm = 0x4B4D
movb $0x5f, 0x1a(%rax)
movq %rax, 0x106fdc2(%rip)   # 0x11177a0
movq %rsi, %rax
andq %r12, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa79f4
incl (%rax)
movq %r15, %rdi
callq 0xe069
movq %rax, %rdi
movq %r14, %rsi
callq 0xe069
movq %rax, %r14
movq 0x106fd97(%rip), %rsi   # 0x11177a8
testq %rsi, %rsi
jne 0xa7a36
movl $0x1, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x1, 0x10(%rax)
movb $0x28, 0x18(%rax)
movq %rax, 0x106fd72(%rip)   # 0x11177a8
movq %rsi, %rax
andq %r12, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa7a4c
incl (%rax)
movq %r14, %rdi
callq 0xe069
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe069
movq %rax, %rbx
movq 0x106fd47(%rip), %rsi   # 0x11177b0
testq %rsi, %rsi
jne 0xa7a8e
movl $0x1, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x1, 0x10(%rax)
movb $0x29, 0x18(%rax)
movq %rax, 0x106fd22(%rip)   # 0x11177b0
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xa7aa3
incl (%r12)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xe069
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_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 0xa7b00
testl %esi, %esi
jne 0xa7b4b
movq %rdx, %rdi
callq 0xa7d69
movq 0x8(%rax), %r15
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0xa7b3a
decl (%rcx)
jne 0xa7b3a
leaq 0x6b2c3(%rip), %rsi     # 0x112dc1
jmp 0xa7b32
movq %rdx, %rdi
callq 0xa7da4
movq 0x8(%rax), %r15
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0xa7b3a
decl (%rcx)
jne 0xa7b3a
leaq 0x6b367(%rip), %rsi     # 0x112e99
movq %rax, %rdi
callq 0xd13d
movq %r14, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x38b69(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x38b6e(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl %esi, %r14d
movq %rdi, %r15
cmpl $0x1, %esi
je 0xa7bdb
testl %r14d, %r14d
jne 0xa7c64
movq %rdx, %rdi
callq 0xa7d69
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0xa7bd7
decl (%rcx)
jne 0xa7bd7
leaq 0x6b1f2(%rip), %rsi     # 0x112dc1
movq %rax, %rdi
callq 0xd13d
xorl %edx, %edx
jmp 0xa7c51
movq %rdx, %rdi
callq 0xa7da4
movq 0x8(%rax), %r12
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0xa7c15
decl (%rcx)
jne 0xa7c15
leaq 0x6b28c(%rip), %rsi     # 0x112e99
movq %rax, %rdi
callq 0xd13d
leaq 0x106cfd4(%rip), %rdi   # 0x1114bf0
movq %r12, %rsi
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
leaq -0x28(%rbp), %r12
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x92b17
leaq 0x69514(%rip), %rsi     # 0x111159
movq %rax, %rdi
callq 0x9353
movq (%r12), %r15
movq %r15, (%rbx)
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x38a50(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x38a55(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %rbx
leaq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x93675
movq 0x106fbd9(%rip), %rdx   # 0x1117898
testq %rdx, %rdx
jne 0xa7cee
movl $0x8, %edi
callq 0xf5e4
movq %rax, %rdx
movq $0x8, 0x10(%rax)
movabsq $0x3b6b61657262207d, %rax # imm = 0x3B6B61657262207D
movq %rax, 0x18(%rdx)
movq %rdx, 0x106fbaa(%rip)   # 0x1117898
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0xa7d0c
incl (%rax)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %r15
leaq -0x40(%rbp), %r12
movq %r15, %rcx
movq %r12, %r8
callq 0x9221b
movq (%r15), %r13
movq (%r12), %r12
cmpb $0x1, 0x18(%r12)
jne 0xa7d54
movq 0x28(%r12), %rsi
leaq -0x50(%rbp), %r15
movl $0xa, %edi
movq %r15, %rdx
callq 0x92a13
movq (%r15), %rax
movq %rax, 0x28(%r12)
movq %r12, (%r14)
movq %r13, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa7d95
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xa7d9a
incl (%rax)
jmp 0xa7d9a
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_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 0xa7dd0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xa7dd5
incl (%rax)
jmp 0xa7dd5
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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
movq %rdi, %r15
leaq 0x106cde4(%rip), %rdi   # 0x1114be0
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
leaq -0x20(%rbp), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x77e36
movl %eax, %r15d
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0xa7e51
decl (%rax)
jne 0xa7e51
movq %r15, %rdi
shlq $0x30, %rdi
orq %rdx, %rdi
leaq 0x69475(%rip), %rsi     # 0x1112c1
callq 0xd13d
leaq 0x1(,%r15,2), %rdi
movl $0x1, %esi
callq 0xe83a
testl %eax, %eax
je 0xa7e6f
movb $0x1, %al
movq -0x20(%rbp), %rcx
jmp 0xa7e97
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x75654
movl $0x1, %esi
movq %rax, %rdi
callq 0xe83a
testl %eax, %eax
sete %al
movq (%r15), %rcx
movq %rcx, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_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, -0x30(%rbp)
movq %rdi, %r15
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
leaq -0x50(%rbp), %rax
leaq -0x48(%rbp), %rcx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x93675
movq %r15, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0xa80f8
incl (%rax)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x40(%rbp), %rcx
leaq -0x38(%rbp), %r8
movq %r15, %rdx
callq 0xad524
movq 0x106f8b1(%rip), %rdx   # 0x11179c8
testq %rdx, %rdx
jne 0xa813e
movl $0x2, %edi
callq 0xf5e4
movq %rax, %rdx
movq $0x2, 0x10(%rax)
movw $0x7b20, 0x18(%rax)     # imm = 0x7B20
movq %rax, 0x106f88a(%rip)   # 0x11179c8
andq %rdx, %r12
sete %al
testb $0x3, %dl
setne %cl
orb %al, %cl
jne 0xa8152
incl (%r12)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x60(%rbp), %r12
leaq -0x58(%rbp), %r13
movq %r12, %rcx
movq %r13, %r8
callq 0x9221b
movq (%r12), %rbx
movq (%r13), %r13
cmpb $0x1, 0x18(%r13)
jne 0xa8199
movq 0x28(%r13), %rsi
leaq -0x68(%rbp), %r12
movl $0xa, %edi
movq %r12, %rdx
callq 0x92a13
movq (%r12), %rax
movq %rax, 0x28(%r13)
movq %r13, (%r14)
movq -0x30(%rbp), %rax
movq %rbx, (%rax)
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_O3/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 0xab744
addq $0x20, %rsp
movq %rdx, %rcx
xorl %edi, %edi
xorl %esi, %esi
movl %eax, %edx
callq 0xd01b
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_O3/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 0xac915
addl $0x2, (%rax)
movl $0x3, %esi
movq %rbx, %rdi
callq 0xe50f
movq %rax, %r14
movq 0x10(%r12), %rdi
andq %rdi, %r15
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0xac94c
decl (%r15)
jne 0xac94c
leaq 0x647ca(%rip), %rsi     # 0x111111
callq 0xd13d
movq %r14, 0x10(%r12)
movq %rbx, %rdi
callq 0xfea8
movq %r13, %rdi
movq %rax, %rsi
callq 0xe069
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_O3/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 0x92b17
movq %rax, %r14
movq 0x106b01a(%rip), %rsi   # 0x11179c0
testq %rsi, %rsi
jne 0xac9cb
movl $0x1, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x1, 0x10(%rax)
movb $0x5f, 0x18(%rax)
movq %rax, 0x106aff5(%rip)   # 0x11179c0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xac9e8
incl (%rax)
movq %r14, %rdi
callq 0xe069
movq -0x18(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x66683(%rip), %rax     # 0x113091
cmpq %rsi, %rax
jne 0xacaba
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 0xaca56
decl (%rax)
jne 0xaca56
leaq 0x66693(%rip), %rsi     # 0x1130d9
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
callq 0xd13d
movq 0x20(%rbx), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0xaca88
decl (%rax)
jne 0xaca88
leaq 0x664b1(%rip), %rsi     # 0x112f29
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
callq 0xd13d
movq 0x28(%rbx), %rdi
andq %rdi, %r14
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0xacaae
decl (%r14)
jne 0xacaae
leaq 0x646b0(%rip), %rsi     # 0x111159
callq 0xd13d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0x4ccbc(%rip), %rsi     # 0xf977d
movl $0x53, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0xacb52
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdi
popq %rbp
jmp 0x5030
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xacbdf
incl (%rcx)
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xacc06
decl (%rax)
jne 0xacc06
leaq 0x66496(%rip), %rax     # 0x113091
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd13d
leaq -0x30(%rbp), %r13
movq %r14, %rdi
movl %r15d, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0xa717f
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_O3/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 0x2d45d
testl %eax, %eax
je 0xad225
cmpl $0x1, %eax
jne 0xad239
movq %rdx, %rdi
callq 0xd745
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 0xacf0b
movq (%r15), %rcx
jmp 0xad22b
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movq %rcx, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x3347b(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x33480(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0x64f18(%rip), %rax     # 0x113001
cmpq %rsi, %rax
jne 0xae221
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 0xae127
decl (%rax)
jne 0xae127
leaq 0x63037(%rip), %rsi     # 0x111159
callq 0xd13d
movq 0x10(%rbx), %rdi
movq %rdi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xae14f
decl (%rax)
jne 0xae14f
leaq 0x63a2f(%rip), %rsi     # 0x111b79
callq 0xd13d
movq 0x20(%rbx), %rcx
leaq 0x6311f(%rip), %r14     # 0x111279
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0xae184
decl (%rax)
jne 0xae184
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xd13d
movq 0x30(%rbx), %rcx
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0xae1b2
decl (%rax)
jne 0xae1b2
movl 0x28(%rbx), %edi
shlq $0x30, %rdi
orq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0xd13d
movq 0x40(%rbx), %rcx
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0xae1e4
decl (%rax)
jne 0xae1e4
leaq 0x630ed(%rip), %rsi     # 0x1112c1
movl 0x38(%rbx), %edi
shlq $0x30, %rdi
orq 0x40(%rbx), %rdi
callq 0xd13d
movq 0x50(%rbx), %rax
andq %rax, %r15
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0xae20f
decl (%r15)
jne 0xae20f
movl 0x48(%rbx), %edi
shlq $0x30, %rdi
orq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0xd13d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
leaq 0x4b681(%rip), %rsi     # 0xf98a9
movl $0x50, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_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 $0x38, %rsp
movq %r9, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %rsi, %r12
movq %rdi, %r14
leaq -0x58(%rbp), %r15
leaq -0x48(%rbp), %r13
leaq -0x40(%rbp), %rbx
cmpl $0x1, %edx
jne 0xae2f3
movq %rcx, %rdi
movq %r15, %rsi
callq 0xd0aa
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r13, %rcx
movq %rbx, %r8
callq 0xae3cd
movl -0x58(%rbp), %edx
movq -0x50(%rbp), %rcx
movq -0x40(%rbp), %r12
movq -0x48(%rbp), %r14
jmp 0xae2be
testl %edx, %edx
jne 0xae314
movq -0x30(%rbp), %rax
movq %r12, (%rax)
movq -0x38(%rbp), %rax
movq %r14, (%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x323a0(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x323a5(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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
movl $0x1, %edi
movl $0x30, %esi
callq 0x50c0
testq %rax, %rax
je 0xae3a8
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 0x4b554(%rip), %rsi     # 0xf9903
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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
movl $0x1, %edi
movl $0x18, %esi
callq 0x50c0
testq %rax, %rax
je 0xae625
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 0x4b309(%rip), %rsi     # 0xf9935
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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
movl $0x1, %edi
movl $0x18, %esi
callq 0x50c0
testq %rax, %rax
je 0xae693
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 0x4b2cd(%rip), %rsi     # 0xf9967
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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
movl $0x1, %edi
movl $0x20, %esi
callq 0x50c0
testq %rax, %rax
je 0xae711
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 0x4b281(%rip), %rsi     # 0xf9999
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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
movl $0x1, %edi
movl $0x18, %esi
callq 0x50c0
testq %rax, %rax
je 0xae778
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 0x4b24c(%rip), %rsi     # 0xf99cb
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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
movl $0x1, %edi
movl $0x18, %esi
callq 0x50c0
testq %rax, %rax
je 0xae7e6
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 0x4b210(%rip), %rsi     # 0xf99fd
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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
movl $0x1, %edi
movl $0x20, %esi
callq 0x50c0
testq %rax, %rax
je 0xae864
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 0x4b1c4(%rip), %rsi     # 0xf9a2f
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99ValuezfResource_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 $0x18, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rsi, %r12
movq %rdi, %r15
cmpl $0x1, %edx
je 0xaedeb
testl %edx, %edx
jne 0xaee2f
movq (%rcx), %r13
movq %rcx, %rdi
callq 0x5030
movl 0x8(%r12), %edi
movq 0x10(%r12), %rsi
leaq -0x38(%rbp), %rcx
movq %r13, %rdx
movq %rcx, %r13
callq 0xae64a
jmp 0xaee0f
movq (%rcx), %r13
movq %rcx, %rdi
callq 0x5030
movl 0x8(%r12), %edi
movq 0x10(%r12), %rsi
leaq -0x38(%rbp), %rcx
movq %r13, %rdx
movq %rcx, %r13
callq 0xae79d
movups (%r13), %xmm0
movups %xmm0, 0x8(%r12)
movq %r12, (%r14)
movq %r15, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x31885(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x3188a(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0xaef6a
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rax, %rbx
leaq 0x3105b(%rip), %rdx     # 0xdfee8
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 0xaef5c
decl (%rax)
jne 0xaef5c
leaq 0x63f03(%rip), %rsi     # 0x112dc1
jmp 0xaef57
movq 0x10(%rbx), %rcx
andq %rcx, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0xaef5c
decl (%rax)
jne 0xaef5c
leaq 0x640d3(%rip), %rsi     # 0x112fb9
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
jmp 0xaef57
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xaef5c
decl (%rax)
jne 0xaef5c
leaq 0x63f3e(%rip), %rsi     # 0x112e51
jmp 0xaef57
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xaef5c
decl (%rax)
jne 0xaef5c
leaq 0x63f64(%rip), %rsi     # 0x112e99
jmp 0xaef57
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xaef5c
decl (%rax)
jne 0xaef5c
leaq 0x64212(%rip), %rsi     # 0x113169
callq 0xd13d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
retq