LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataStructRepr_underlyingzec99zetype
static STR* mw_mirth_c99_C99DataStructRepr_underlyingzec99zetype (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataStructRepr* in_C99DataStructRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	STR* v5;
	STRLIT(v5, "", 0);
	STR* v6;
	STRLIT(v6, "struct ", 7);
	STR* v7;
	mw_std_str_zaStr_pushzestrzx(v6, v5, &v7);
	STR* v8 = in_C99DataStructRepr_2->mcname;
	incref(MKSTR(v8));
	decref(MK_mirth_c99_C99DataStructRepr(in_C99DataStructRepr_2));
	STR* v9;
	mw_std_str_zaStr_pushzestrzx(v8, v7, &v9);
	STR* v10;
	STRLIT(v10, "*", 1);
	STR* v11;
	mw_std_str_zaStr_pushzestrzx(v10, v9, &v11);
	*out_zaMirth_3 = in_zaMirth_1;
	return v11;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x107372a(%rip)   # 0x111b4a8
jne 0xa7d96
xorl %edi, %edi
callq 0xf9f7
movq $0x0, 0x10(%rax)
movq %rax, 0x1073712(%rip)   # 0x111b4a8
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movq 0x1073701(%rip), %r12   # 0x111b4a8
movq %r12, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0xa7dbd
incl (%rax)
cmpq $0x0, 0x10736eb(%rip)   # 0x111b4b0
jne 0xa7dee
movl $0x7, %edi
callq 0xf9f7
movq $0x7, 0x10(%rax)
movl $0x75727473, 0x18(%rax) # imm = 0x75727473
movl $0x20746375, 0x1b(%rax) # imm = 0x20746375
movq %rax, 0x10736c2(%rip)   # 0x111b4b0
movq 0x10736bb(%rip), %rsi   # 0x111b4b0
movq %rsi, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa7e0b
incl (%rax)
movq %r12, %rdi
callq 0xe43c
movq %rax, %r12
movq 0x10(%r15), %r13
movq %r13, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0xa7e30
incl (%rax)
movq %r15, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0xa7e57
decl (%rax)
jne 0xa7e57
leaq 0x6f04a(%rip), %rsi     # 0x116e99
movq %r15, %rdi
callq 0xd4e3
movq %r12, %rdi
movq %r13, %rsi
callq 0xe43c
movq %rax, %r15
cmpq $0x0, 0x107364b(%rip)   # 0x111b4b8
jne 0xa7e8c
movl $0x1, %edi
callq 0xf9f7
movq $0x1, 0x10(%rax)
movb $0x2a, 0x18(%rax)
movq %rax, 0x107362c(%rip)   # 0x111b4b8
movq 0x1073625(%rip), %rsi   # 0x111b4b8
andq %rsi, %rbx
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xa7ea6
incl (%rbx)
movq %r15, %rdi
callq 0xe43c
movq -0x30(%rbp), %rcx
movq %r14, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataStructField_iszephysicalzy
static bool mw_mirth_c99_C99DataStructField_iszephysicalzy (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataStructField* in_C99DataStructField_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_c99_C99ReprType v5 = in_C99DataStructField_2->mc99zerepr;
	incref(MK_mirth_c99_C99ReprType(v5));
	decref(MK_mirth_c99_C99DataStructField(in_C99DataStructField_2));
	struct mirth_mirth_zaMirth* v6;
	bool v7 = mw_mirth_c99_C99ReprType_iszephysicalzy(in_zaMirth_1, v5, &v6);
	*out_zaMirth_3 = v6;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movl 0x18(%rsi), %r15d
movq 0x20(%rsi), %r12
movq %r12, %rcx
andq %rax, %rcx
sete %dl
testb $0x3, %r12b
setne %dil
orb %dl, %dil
jne 0xa859b
incl (%rcx)
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa85c2
decl (%rax)
jne 0xa85c2
leaq 0x6e9ba(%rip), %rax     # 0x116f71
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd4e3
leaq -0x30(%rbp), %r13
movq %r14, %rdi
movl %r15d, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0xa9de0
movq (%r13), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99ReprType_iszephysicalzy
static bool mw_mirth_c99_C99ReprType_iszephysicalzy (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99ReprType in_C99ReprType_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* branch_zaMirth_5;
	bool branch_Bool_6;
	switch ((in_C99ReprType_2).tag) {
		case mirth_c99_C99ReprType_Void: {
			bool v7 = false;
			branch_Bool_6 = v7;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case mirth_c99_C99ReprType_Data: {
			uint64_t v8 = mtp_mirth_c99_C99ReprType_Data(in_C99ReprType_2);
			struct mirth_mirth_zaMirth* v9;
			bool v10 = mw_mirth_data_Data_iszephysicalzy(in_zaMirth_1, v8, &v9);
			branch_Bool_6 = v10;
			branch_zaMirth_5 = v9;
		} break;
		default: {
			decref(MK_mirth_c99_C99ReprType(in_C99ReprType_2));
			bool v11 = true;
			branch_Bool_6 = v11;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
	}
	*out_zaMirth_3 = branch_zaMirth_5;
	return branch_Bool_6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdi, %r14
testl %esi, %esi
je 0xa9e37
cmpl $0x15, %esi
jne 0xa9e3c
movq 0x8(%rdx), %r15
decl (%rdx)
jne 0xa9e0e
movq %rdx, %rdi
callq 0x5030
leaq -0x28(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x8ee09
movl %eax, %edi
movq %rdx, %rsi
callq 0x8ec6c
movl %eax, %r15d
xorb $0x1, %r15b
movq (%r12), %r14
jmp 0xa9e78
xorl %r15d, %r15d
jmp 0xa9e78
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %dil
movb $0x1, %r15b
orb %cl, %dil
jne 0xa9e78
decl (%rax)
jne 0xa9e78
shlq $0x30, %rsi
orq %rdx, %rsi
leaq 0x6d0bc(%rip), %rax     # 0x116f29
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd4e3
movq %r14, (%rbx)
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataUnitRepr_underlyingzec99zetype
static VAL mw_mirth_c99_C99DataUnitRepr_underlyingzec99zetype (struct mirth_c99_C99DataUnitRepr* in_C99DataUnitRepr_1) {
	decref(MK_mirth_c99_C99DataUnitRepr(in_C99DataUnitRepr_1));
	STR* v3;
	STRLIT(v3, "void", 4);
	return MKSTR(v3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movq %rdi, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xa9ebf
decl (%rax)
jne 0xa9ebf
leaq 0x6cf07(%rip), %rsi     # 0x116dc1
callq 0xd4e3
cmpq $0x0, 0x10716d1(%rip)   # 0x111b598
jne 0xa9ee9
movl $0x4, %edi
callq 0xf9f7
movq $0x4, 0x10(%rax)
movl $0x64696f76, 0x18(%rax) # imm = 0x64696F76
movq %rax, 0x10716af(%rip)   # 0x111b598
movq 0x10716a8(%rip), %rax   # 0x111b598
andq %rax, %rbx
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0xa9f01
incl (%rbx)
leaq 0x6b251(%rip), %rdx     # 0x115159
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataEnumRepr_underlyingzec99zetype
static STR* mw_mirth_c99_C99DataEnumRepr_underlyingzec99zetype (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_C99DataEnumRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	STR* v6 = mw_mirth_c99_C99DataEnumRepr_cname(in_zaMirth_1, in_C99DataEnumRepr_2, &v5);
	STR* v7;
	STRLIT(v7, "", 0);
	STR* v8;
	STRLIT(v8, "enum ", 5);
	STR* v9;
	mw_std_str_zaStr_pushzestrzx(v8, v7, &v9);
	STR* v10;
	mw_std_str_zaStr_pushzestrzx(v6, v9, &v10);
	*out_zaMirth_3 = v5;
	return v10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
leaq -0x30(%rbp), %r15
movq %r15, %rdx
callq 0x9e227
movq %rax, %r14
movq (%r15), %r12
cmpq $0x0, 0x1071666(%rip)   # 0x111b5a0
jne 0xa9f52
xorl %edi, %edi
callq 0xf9f7
movq $0x0, 0x10(%rax)
movq %rax, 0x107164e(%rip)   # 0x111b5a0
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
movq 0x107163d(%rip), %r15   # 0x111b5a0
movq %r15, %rax
andq %r13, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0xa9f79
incl (%rax)
cmpq $0x0, 0x1071627(%rip)   # 0x111b5a8
jne 0xa9fa7
movl $0x5, %edi
callq 0xf9f7
movq $0x5, 0x10(%rax)
movl $0x6d756e65, 0x18(%rax) # imm = 0x6D756E65
movb $0x20, 0x1c(%rax)
movq %rax, 0x1071601(%rip)   # 0x111b5a8
movq 0x10715fa(%rip), %rsi   # 0x111b5a8
andq %rsi, %r13
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xa9fc3
incl (%r13)
movq %r15, %rdi
callq 0xe43c
movq %rax, %rdi
movq %r14, %rsi
callq 0xe43c
movq %r12, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataTransRepr_underlyingzec99zetype
static STR* mw_mirth_c99_C99DataTransRepr_underlyingzec99zetype (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataTransRepr* in_C99DataTransRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_c99_C99ReprType v5 = in_C99DataTransRepr_2->mc99zerepr;
	incref(MK_mirth_c99_C99ReprType(v5));
	decref(MK_mirth_c99_C99DataTransRepr(in_C99DataTransRepr_2));
	struct mirth_mirth_zaMirth* v6;
	STR* v7 = mw_mirth_c99_C99ReprType_underlyingzec99zetype(in_zaMirth_1, v5, &v6);
	*out_zaMirth_3 = v6;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movl 0x30(%rsi), %r15d
movq 0x38(%rsi), %r12
movq %r12, %rcx
andq %rax, %rcx
sete %dl
testb $0x3, %r12b
setne %dil
orb %dl, %dil
jne 0xaa026
incl (%rcx)
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xaa04d
decl (%rax)
jne 0xaa04d
leaq 0x6ce0f(%rip), %rax     # 0x116e51
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd4e3
leaq -0x30(%rbp), %r13
movq %r14, %rdi
movl %r15d, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0xa85ed
movq (%r13), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_prim_Str_Str_1_sp8
static STR* mw_std_prim_Str_Str_1_sp8 (STR* in_Str_1) {
	STR* v3;
	STRLIT(v3, "", 0);
	STR* v4;
	STRLIT(v4, "MKI64(", 6);
	STR* v5;
	mw_std_str_zaStr_pushzestrzx(v4, v3, &v5);
	STR* v6;
	mw_std_str_zaStr_pushzestrzx(in_Str_1, v5, &v6);
	STR* v7;
	STRLIT(v7, ")", 1);
	STR* v8;
	mw_std_str_zaStr_pushzestrzx(v7, v6, &v8);
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10716db(%rip)   # 0x111b768
jne 0xaa0a5
xorl %edi, %edi
callq 0xf9f7
movq $0x0, 0x10(%rax)
movq %rax, 0x10716c3(%rip)   # 0x111b768
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x10716b2(%rip), %r14   # 0x111b768
movq %r14, %rax
andq %r15, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0xaa0cc
incl (%rax)
cmpq $0x0, 0x107169c(%rip)   # 0x111b770
jne 0xaa0fc
movl $0x6, %edi
callq 0xf9f7
movq $0x6, 0x10(%rax)
movl $0x36494b4d, 0x18(%rax) # imm = 0x36494B4D
movw $0x2834, 0x1c(%rax)     # imm = 0x2834
movq %rax, 0x1071674(%rip)   # 0x111b770
movq 0x107166d(%rip), %rsi   # 0x111b770
movq %rsi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xaa119
incl (%rax)
movq %r14, %rdi
callq 0xe43c
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe43c
movq %rax, %rbx
cmpq $0x0, 0x1071641(%rip)   # 0x111b778
jne 0xaa156
movl $0x1, %edi
callq 0xf9f7
movq $0x1, 0x10(%rax)
movb $0x29, 0x18(%rax)
movq %rax, 0x1071622(%rip)   # 0x111b778
movq 0x107161b(%rip), %rsi   # 0x111b778
andq %rsi, %r15
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xaa171
incl (%r15)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe43c
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataUnitRepr_mkzemacro
static STR* mw_mirth_c99_C99DataUnitRepr_mkzemacro (VAL in_zux1_1, struct mirth_c99_C99DataUnitRepr* in_C99DataUnitRepr_2) {
	decref(in_zux1_1);
	STR* v4 = in_C99DataUnitRepr_2->mcname;
	incref(MKSTR(v4));
	decref(MK_mirth_c99_C99DataUnitRepr(in_C99DataUnitRepr_2));
	STR* v5;
	STRLIT(v5, "", 0);
	STR* v6;
	STRLIT(v6, "MK_", 3);
	STR* v7;
	mw_std_str_zaStr_pushzestrzx(v6, v5, &v7);
	STR* v8;
	mw_std_str_zaStr_pushzestrzx(v4, v7, &v8);
	STR* v9;
	STRLIT(v9, "(0)", 3);
	STR* v10;
	mw_std_str_zaStr_pushzestrzx(v9, v8, &v10);
	return v10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
testb $0x1, %sil
je 0xaa1bd
movq %rdi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xaa1bd
decl (%rax)
jne 0xaa1bd
callq 0xd4e3
movq 0x10(%r14), %rbx
movq %rbx, %rax
andq %r15, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xaa1d6
incl (%rax)
movq %r14, %rax
andq %r15, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0xaa1fd
decl (%rax)
jne 0xaa1fd
leaq 0x6cbcc(%rip), %rsi     # 0x116dc1
movq %r14, %rdi
callq 0xd4e3
cmpq $0x0, 0x107157b(%rip)   # 0x111b780
jne 0xaa21d
xorl %edi, %edi
callq 0xf9f7
movq $0x0, 0x10(%rax)
movq %rax, 0x1071563(%rip)   # 0x111b780
movq 0x107155c(%rip), %r14   # 0x111b780
movq %r14, %rax
andq %r15, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0xaa23a
incl (%rax)
cmpq $0x0, 0x1071546(%rip)   # 0x111b788
jne 0xaa267
movl $0x3, %edi
callq 0xf9f7
movq $0x3, 0x10(%rax)
movw $0x4b4d, 0x18(%rax)     # imm = 0x4B4D
movb $0x5f, 0x1a(%rax)
movq %rax, 0x1071521(%rip)   # 0x111b788
movq 0x107151a(%rip), %rsi   # 0x111b788
movq %rsi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xaa284
incl (%rax)
movq %r14, %rdi
callq 0xe43c
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe43c
movq %rax, %rbx
cmpq $0x0, 0x10714ee(%rip)   # 0x111b790
jne 0xaa2c7
movl $0x3, %edi
callq 0xf9f7
movq $0x3, 0x10(%rax)
movw $0x3028, 0x18(%rax)     # imm = 0x3028
movb $0x29, 0x1a(%rax)
movq %rax, 0x10714c9(%rip)   # 0x111b790
movq 0x10714c2(%rip), %rsi   # 0x111b790
andq %rsi, %r15
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xaa2e2
incl (%r15)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe43c
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataEnumRepr_mkzemacro
static STR* mw_mirth_c99_C99DataEnumRepr_mkzemacro (STR* in_Str_1, struct mirth_mirth_zaMirth* in_zaMirth_2, uint64_t in_C99DataEnumRepr_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	struct mirth_mirth_zaMirth* v6;
	STR* v7 = mw_mirth_c99_C99DataEnumRepr_cname(in_zaMirth_2, in_C99DataEnumRepr_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 0x9e227
movq (%r15), %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0xaa5d4
movq %r15, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_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 0xaa378
incl (%rcx)
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0xaa39d
decl (%rax)
jne 0xaa39d
leaq 0x6cabc(%rip), %rsi     # 0x116e51
movq %rdx, %rdi
callq 0xd4e3
leaq -0x38(%rbp), %rbx
movq %r13, %rdi
movq %r14, %rsi
movl %r15d, %edx
movq %r12, %rcx
movq %rbx, %r8
callq 0xa8c22
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_O1/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)
cmpq $0x0, 0x10713c3(%rip)   # 0x111b7b8
jne 0xaa40d
xorl %edi, %edi
callq 0xf9f7
movq $0x0, 0x10(%rax)
movq %rax, 0x10713ab(%rip)   # 0x111b7b8
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
movq 0x107139a(%rip), %r13   # 0x111b7b8
movq %r13, %rax
andq %r14, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0xaa434
incl (%rax)
cmpq $0x0, 0x1071384(%rip)   # 0x111b7c0
jne 0xaa461
movl $0x3, %edi
callq 0xf9f7
movq $0x3, 0x10(%rax)
movw $0x4b4d, 0x18(%rax)     # imm = 0x4B4D
movb $0x5f, 0x1a(%rax)
movq %rax, 0x107135f(%rip)   # 0x111b7c0
movq 0x1071358(%rip), %rsi   # 0x111b7c0
movq %rsi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xaa47e
incl (%rax)
movq %r13, %rdi
callq 0xe43c
movq %rax, %r13
movq 0x10(%r12), %rbx
movq %rbx, %rax
andq %r14, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xaa4a3
incl (%rax)
movq %r12, %rax
andq %r14, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0xaa4ca
decl (%rax)
jne 0xaa4ca
leaq 0x6c9d7(%rip), %rsi     # 0x116e99
movq %r12, %rdi
callq 0xd4e3
movq %r13, %rdi
movq %rbx, %rsi
callq 0xe43c
movq %rax, %rbx
cmpq $0x0, 0x10712e8(%rip)   # 0x111b7c8
jne 0xaa4ff
movl $0x1, %edi
callq 0xf9f7
movq $0x1, 0x10(%rax)
movb $0x28, 0x18(%rax)
movq %rax, 0x10712c9(%rip)   # 0x111b7c8
movq 0x10712c2(%rip), %rsi   # 0x111b7c8
movq %rsi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xaa51c
incl (%rax)
movq %rbx, %rdi
callq 0xe43c
movq %rax, %rdi
movq %r15, %rsi
callq 0xe43c
movq %rax, %rbx
cmpq $0x0, 0x1071296(%rip)   # 0x111b7d0
jne 0xaa559
movl $0x1, %edi
callq 0xf9f7
movq $0x1, 0x10(%rax)
movb $0x29, 0x18(%rax)
movq %rax, 0x1071277(%rip)   # 0x111b7d0
movq 0x1071270(%rip), %rsi   # 0x111b7d0
andq %rsi, %r14
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xaa574
incl (%r14)
movq %rbx, %rdi
callq 0xe43c
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_O1/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 0xa394d
movq %r14, %rdi
movq %rax, %rsi
callq 0xaa5d4
movq (%r15), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_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
cmpq $0x0, 0x10711ab(%rip)   # 0x111b798
jne 0xaa605
xorl %edi, %edi
callq 0xf9f7
movq $0x0, 0x10(%rax)
movq %rax, 0x1071193(%rip)   # 0x111b798
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movq 0x1071182(%rip), %r15   # 0x111b798
movq %r15, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0xaa62c
incl (%rax)
cmpq $0x0, 0x107116c(%rip)   # 0x111b7a0
jne 0xaa659
movl $0x3, %edi
callq 0xf9f7
movq $0x3, 0x10(%rax)
movw $0x4b4d, 0x18(%rax)     # imm = 0x4B4D
movb $0x5f, 0x1a(%rax)
movq %rax, 0x1071147(%rip)   # 0x111b7a0
movq 0x1071140(%rip), %rsi   # 0x111b7a0
movq %rsi, %rax
andq %r12, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xaa676
incl (%rax)
movq %r15, %rdi
callq 0xe43c
movq %rax, %rdi
movq %r14, %rsi
callq 0xe43c
movq %rax, %r14
cmpq $0x0, 0x1071114(%rip)   # 0x111b7a8
jne 0xaa6b3
movl $0x1, %edi
callq 0xf9f7
movq $0x1, 0x10(%rax)
movb $0x28, 0x18(%rax)
movq %rax, 0x10710f5(%rip)   # 0x111b7a8
movq 0x10710ee(%rip), %rsi   # 0x111b7a8
movq %rsi, %rax
andq %r12, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xaa6d0
incl (%rax)
movq %r14, %rdi
callq 0xe43c
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe43c
movq %rax, %rbx
cmpq $0x0, 0x10710c2(%rip)   # 0x111b7b0
jne 0xaa70d
movl $0x1, %edi
callq 0xf9f7
movq $0x1, 0x10(%rax)
movb $0x29, 0x18(%rax)
movq %rax, 0x10710a3(%rip)   # 0x111b7b0
movq 0x107109c(%rip), %rsi   # 0x111b7b0
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xaa729
incl (%r12)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xe43c
// File: /workspace/github_c_makefile_star2_O1/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 0xaa786
testl %esi, %esi
jne 0xaa7d1
movq %rdx, %rdi
callq 0xaa9f1
movq 0x8(%rax), %r15
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0xaa7c0
decl (%rcx)
jne 0xaa7c0
leaq 0x6c63d(%rip), %rsi     # 0x116dc1
jmp 0xaa7b8
movq %rdx, %rdi
callq 0xaaa2c
movq 0x8(%rax), %r15
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0xaa7c0
decl (%rcx)
jne 0xaa7c0
leaq 0x6c6e1(%rip), %rsi     # 0x116e99
movq %rax, %rdi
callq 0xd4e3
movq %r14, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0x39f63(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0x39f68(%rip), %xmm0    # 0xe475d
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x95a5
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0xaa861
testl %r14d, %r14d
jne 0xaa8ea
movq %rdx, %rdi
callq 0xaa9f1
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0xaa85d
decl (%rcx)
jne 0xaa85d
leaq 0x6c56c(%rip), %rsi     # 0x116dc1
movq %rax, %rdi
callq 0xd4e3
xorl %edx, %edx
jmp 0xaa8d7
movq %rdx, %rdi
callq 0xaaa2c
movq 0x8(%rax), %r12
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0xaa89b
decl (%rcx)
jne 0xaa89b
leaq 0x6c606(%rip), %rsi     # 0x116e99
movq %rax, %rdi
callq 0xd4e3
leaq 0x106e34e(%rip), %rdi   # 0x1118bf0
movq %r12, %rsi
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
leaq -0x28(%rbp), %r12
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x95264
leaq 0x6a88e(%rip), %rsi     # 0x115159
movq %rax, %rdi
callq 0x95f6
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 0xf9f7
movq $0x20, 0x10(%rax)
movups 0x39e4a(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0x39e4f(%rip), %xmm0    # 0xe475d
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x95a5
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0x95d84
cmpq $0x0, 0x1070f52(%rip)   # 0x111b898
jne 0xaa96f
movl $0x8, %edi
callq 0xf9f7
movq $0x8, 0x10(%rax)
movabsq $0x3b6b61657262207d, %rcx # imm = 0x3B6B61657262207D
movq %rcx, 0x18(%rax)
movq %rax, 0x1070f29(%rip)   # 0x111b898
movq 0x1070f22(%rip), %rdx   # 0x111b898
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0xaa994
incl (%rax)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %r15
leaq -0x40(%rbp), %r12
movq %r15, %rcx
movq %r12, %r8
callq 0x94972
movq (%r15), %r13
movq (%r12), %r12
cmpb $0x1, 0x18(%r12)
jne 0xaa9dc
movq 0x28(%r12), %rsi
leaq -0x50(%rbp), %r15
movl $0xa, %edi
movq %r15, %rdx
callq 0x95160
movq (%r15), %rax
movq %rax, 0x28(%r12)
movq %r12, (%r14)
movq %r13, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0xaaa1d
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xaaa22
incl (%rax)
jmp 0xaaa22
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_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 0xaaa58
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xaaa5d
incl (%rax)
jmp 0xaaa5d
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 0x106e15c(%rip), %rdi   # 0x1118be0
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
leaq -0x20(%rbp), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x79ceb
movl %eax, %r15d
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0xaaad9
decl (%rax)
jne 0xaaad9
movq %r15, %rdi
shlq $0x30, %rdi
orq %rdx, %rdi
leaq 0x6a7ed(%rip), %rsi     # 0x1152c1
callq 0xd4e3
leaq 0x1(,%r15,2), %rdi
movl $0x1, %esi
callq 0xec04
testl %eax, %eax
je 0xaaaf7
movb $0x1, %al
movq -0x20(%rbp), %rcx
jmp 0xaab1f
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x77411
movl $0x1, %esi
movq %rax, %rdi
callq 0xec04
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_O1/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 0x95d84
movq %r15, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0xaad98
incl (%rax)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x40(%rbp), %rcx
leaq -0x38(%rbp), %r8
movq %r15, %rdx
callq 0xb01fd
cmpq $0x0, 0x1070c10(%rip)   # 0x111b9c8
jne 0xaadd9
movl $0x2, %edi
callq 0xf9f7
movq $0x2, 0x10(%rax)
movw $0x7b20, 0x18(%rax)     # imm = 0x7B20
movq %rax, 0x1070bef(%rip)   # 0x111b9c8
movq 0x1070be8(%rip), %rdx   # 0x111b9c8
andq %rdx, %r12
sete %al
testb $0x3, %dl
setne %cl
orb %al, %cl
jne 0xaadf4
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 0x94972
movq (%r12), %rbx
movq (%r13), %r13
cmpb $0x1, 0x18(%r13)
jne 0xaae3b
movq 0x28(%r13), %rsi
leaq -0x68(%rbp), %r12
movl $0xa, %edi
movq %r12, %rdx
callq 0x95160
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_O1/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 0xae3da
addq $0x20, %rsp
movq %rdx, %rcx
xorl %edi, %edi
xorl %esi, %esi
movl %eax, %edx
callq 0xd37c
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_O1/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 0xaf5ec
addl $0x2, (%rax)
movl $0x3, %esi
movq %rbx, %rdi
callq 0xe8e2
movq %rax, %r14
movq 0x10(%r12), %rdi
andq %rdi, %r15
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0xaf623
decl (%r15)
jne 0xaf623
leaq 0x65af3(%rip), %rsi     # 0x115111
callq 0xd4e3
movq %r14, 0x10(%r12)
movq %rbx, %rdi
callq 0x102c9
movq %r13, %rdi
movq %rax, %rsi
callq 0xe43c
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_O1/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 0x95264
movq %rax, %r14
cmpq $0x0, 0x106c342(%rip)   # 0x111b9c0
jne 0xaf69d
movl $0x1, %edi
callq 0xf9f7
movq $0x1, 0x10(%rax)
movb $0x5f, 0x18(%rax)
movq %rax, 0x106c323(%rip)   # 0x111b9c0
movq 0x106c31c(%rip), %rsi   # 0x111b9c0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xaf6c1
incl (%rax)
movq %r14, %rdi
callq 0xe43c
movq -0x18(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0x679aa(%rip), %rax     # 0x117091
cmpq %rsi, %rax
jne 0xaf793
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 0xaf72f
decl (%rax)
jne 0xaf72f
leaq 0x679ba(%rip), %rsi     # 0x1170d9
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
callq 0xd4e3
movq 0x20(%rbx), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0xaf761
decl (%rax)
jne 0xaf761
leaq 0x677d8(%rip), %rsi     # 0x116f29
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
callq 0xd4e3
movq 0x28(%rbx), %rdi
andq %rdi, %r14
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0xaf787
decl (%r14)
jne 0xaf787
leaq 0x659d7(%rip), %rsi     # 0x115159
callq 0xd4e3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0x4e114(%rip), %rsi     # 0xfd8ae
movl $0x53, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_c99_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 0xaf82b
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdi
popq %rbp
jmp 0x5030
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xaf8b8
incl (%rcx)
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xaf8df
decl (%rax)
jne 0xaf8df
leaq 0x677bd(%rip), %rax     # 0x117091
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd4e3
leaq -0x30(%rbp), %r13
movq %r14, %rdi
movl %r15d, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0xa9de0
movq (%r13), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 0x2e11b
testl %eax, %eax
je 0xafefe
cmpl $0x1, %eax
jne 0xaff12
movq %rdx, %rdi
callq 0xdaeb
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 0xafbe4
movq (%r15), %rcx
jmp 0xaff04
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 0xf9f7
movq $0x20, 0x10(%rax)
movups 0x34822(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0x34827(%rip), %xmm0    # 0xe475d
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x95a5
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_c99_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 0x6616e(%rip), %rax     # 0x117001
cmpq %rsi, %rax
jne 0xb0fcb
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 0xb0ed1
decl (%rax)
jne 0xb0ed1
leaq 0x6428d(%rip), %rsi     # 0x115159
callq 0xd4e3
movq 0x10(%rbx), %rdi
movq %rdi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xb0ef9
decl (%rax)
jne 0xb0ef9
leaq 0x64c85(%rip), %rsi     # 0x115b79
callq 0xd4e3
movq 0x20(%rbx), %rcx
leaq 0x64375(%rip), %r14     # 0x115279
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0xb0f2e
decl (%rax)
jne 0xb0f2e
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xd4e3
movq 0x30(%rbx), %rcx
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0xb0f5c
decl (%rax)
jne 0xb0f5c
movl 0x28(%rbx), %edi
shlq $0x30, %rdi
orq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0xd4e3
movq 0x40(%rbx), %rcx
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0xb0f8e
decl (%rax)
jne 0xb0f8e
leaq 0x64343(%rip), %rsi     # 0x1152c1
movl 0x38(%rbx), %edi
shlq $0x30, %rdi
orq 0x40(%rbx), %rdi
callq 0xd4e3
movq 0x50(%rbx), %rax
andq %rax, %r15
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0xb0fb9
decl (%r15)
jne 0xb0fb9
movl 0x48(%rbx), %edi
shlq $0x30, %rdi
orq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0xd4e3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
leaq 0x4ca08(%rip), %rsi     # 0xfd9da
movl $0x50, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130