LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_c99_C99DataRepr_free
void mirth_c99_C99DataRepr_free (VAL v) {
	struct mirth_c99_C99DataRepr self = V_mirth_c99_C99DataRepr(v);
	switch (self.tag) {
		case mirth_c99_C99DataRepr_Unit: {
			decref(MK_mirth_c99_C99DataUnitRepr(self.ptr.Unit->mC99DataUnitRepr));
			free(self.ptr.Unit);
		} break;
		case mirth_c99_C99DataRepr_Enum: {
			free(self.ptr.Enum);
		} break;
		case mirth_c99_C99DataRepr_Trans: {
			decref(MK_mirth_c99_C99DataTransRepr(self.ptr.Trans->mC99DataTransRepr));
			free(self.ptr.Trans);
		} break;
		case mirth_c99_C99DataRepr_Struct: {
			decref(MK_mirth_c99_C99DataStructRepr(self.ptr.Struct->mC99DataStructRepr));
			free(self.ptr.Struct);
		} break;
		case mirth_c99_C99DataRepr_Sum: {
			decref(MK_mirth_c99_C99DataSumRepr(self.ptr.Sum->mC99DataSumRepr));
			free(self.ptr.Sum);
		} break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rcx
shrq $0x30, %rcx
cmpw $0x4, %cx
ja 0x9bac4
movq %rdi, %rbx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rax, %rbx
leaq 0x43fb6(%rip), %rdx     # 0xdf9d8
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 0x9bab6
decl (%rax)
jne 0x9bab6
leaq 0x77376(%rip), %rsi     # 0x112dc1
jmp 0x9bab1
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x9bab6
decl (%rax)
jne 0x9bab6
leaq 0x77474(%rip), %rsi     # 0x112ee1
jmp 0x9bab1
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x9bab6
decl (%rax)
jne 0x9bab6
leaq 0x773c2(%rip), %rsi     # 0x112e51
jmp 0x9bab1
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x9bab6
decl (%rax)
jne 0x9bab6
leaq 0x773e8(%rip), %rsi     # 0x112e99
callq 0xd13d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_c99_C99DataTransRepr_free
static void mirth_c99_C99DataTransRepr_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_c99_C99DataTransRepr);
	struct mirth_c99_C99DataTransRepr* self = vself.data.ptr;
	decref(MK_mirth_type_StackTypePart(self->minput));
	decref(MK_mirth_tycon_Tycon(self->minputzetycon));
	decref(MK_mirth_c99_C99ReprType(self->mc99zerepr));
	decref(MKSTR(self->mcname));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x7732b(%rip), %rax     # 0x112e51
cmpq %rsi, %rax
jne 0x9bc04
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
movq 0x18(%rdi), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x9bb6e
decl (%rax)
jne 0x9bb6e
leaq 0x76183(%rip), %rsi     # 0x111ce1
movl 0x10(%rbx), %edi
shlq $0x30, %rdi
orq 0x18(%rbx), %rdi
callq 0xd13d
movq 0x28(%rbx), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x9bba0
decl (%rax)
jne 0x9bba0
leaq 0x75df1(%rip), %rsi     # 0x111981
movl 0x20(%rbx), %edi
shlq $0x30, %rdi
orq 0x28(%rbx), %rdi
callq 0xd13d
movq 0x38(%rbx), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x9bbd2
decl (%rax)
jne 0x9bbd2
leaq 0x77367(%rip), %rsi     # 0x112f29
movl 0x30(%rbx), %edi
shlq $0x30, %rdi
orq 0x38(%rbx), %rdi
callq 0xd13d
movq 0x40(%rbx), %rdi
andq %rdi, %r14
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x9bbf8
decl (%r14)
jne 0x9bbf8
leaq 0x75566(%rip), %rsi     # 0x111159
callq 0xd13d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0x5d1ac(%rip), %rsi     # 0xf8db7
movl $0x5a, %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_C99DataStructRepr_free
static void mirth_c99_C99DataStructRepr_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_c99_C99DataStructRepr);
	struct mirth_c99_C99DataStructRepr* self = vself.data.ptr;
	decref(MKSTR(self->mcname));
	decref(MK_std_list_List_1(self->mfields));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x771a3(%rip), %rax     # 0x112e99
cmpq %rsi, %rax
jne 0x9bd6b
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
movq 0x10(%rdi), %rdi
movq %rdi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x9bd30
decl (%rax)
jne 0x9bd30
leaq 0x7542e(%rip), %rsi     # 0x111159
callq 0xd13d
movq 0x20(%rbx), %rax
andq %rax, %r14
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x9bd5f
decl (%r14)
jne 0x9bd5f
leaq 0x7552a(%rip), %rsi     # 0x111279
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
callq 0xd13d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0x5d0df(%rip), %rsi     # 0xf8e51
movl $0x5b, %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_C99DataSumRepr_free
static void mirth_c99_C99DataSumRepr_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_c99_C99DataSumRepr);
	struct mirth_c99_C99DataSumRepr* self = vself.data.ptr;
	decref(MK_std_list_List_1(self->mtags));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x770f7(%rip), %rax     # 0x112ee1
cmpq %rsi, %rax
jne 0x9be39
movq %rdi, %rbx
movq 0x18(%rdi), %rcx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rcx, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x9be2b
decl (%rax)
jne 0x9be2b
leaq 0x7545e(%rip), %rsi     # 0x111279
movl 0x10(%rbx), %edi
shlq $0x30, %rdi
orq 0x18(%rbx), %rdi
callq 0xd13d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
leaq 0x5d090(%rip), %rsi     # 0xf8ed0
movl $0x58, %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_C99ReprType_Data
static struct mirth_c99_C99ReprType mtw_mirth_c99_C99ReprType_Data (uint64_t in_Data_1) {
	struct mirth_c99_C99ReprType_Data* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mData = in_Data_1;
	struct mirth_c99_C99ReprType v4 = { .tag=mirth_c99_C99ReprType_Data, .ptr.Data=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x9c4f9
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5caac(%rip), %rsi     # 0xf8fac
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_std_maybe_Maybe_1_ifzy_2_sp6
static STR* mw_std_maybe_Maybe_1_ifzy_2_sp6 (INT in_Int_1, struct mirth_mirth_zaMirth* in_zaMirth_2, struct std_maybe_Maybe_1 in_Maybe_3, INT *out_Int_4, struct mirth_mirth_zaMirth* *out_zaMirth_5) {
	INT branch_Int_7;
	struct mirth_mirth_zaMirth* branch_zaMirth_8;
	STR* branch_Str_9;
	switch ((in_Maybe_3).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v10 = mtp_std_maybe_Maybe_1_Some(in_Maybe_3);
			struct mirth_mirth_zaMirth* v11;
			uint64_t v12 = mw_mirth_tycon_Tycon_name(in_zaMirth_2, V_mirth_tycon_Tycon(v10), &v11);
			struct mirth_mirth_zaMirth* v13;
			STR* v14 = mw_mirth_name_Name_mangled(v11, v12, &v13);
			branch_Str_9 = v14;
			branch_zaMirth_8 = v13;
			branch_Int_7 = in_Int_1;
		} break;
		case std_maybe_Maybe_1_None: {
			incref(MKINT(in_Int_1));
			STR* v15 = int_to_str(in_Int_1);
			INT v16 = WRAP_I63(1LL);
			INT v17 = v16;
			INT v18 = int_add(in_Int_1, v17);
			branch_Str_9 = v15;
			branch_zaMirth_8 = in_zaMirth_2;
			branch_Int_7 = v18;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_5 = branch_zaMirth_8;
	*out_Int_4 = branch_Int_7;
	return branch_Str_9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rsi, %r12
movq %rdi, %r15
testl %edx, %edx
je 0x9cc85
cmpl $0x1, %edx
jne 0x9ccd5
movq %rcx, %rdi
callq 0xd745
movabsq $0xfffffffffffc, %rdx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdx
movq %rax, %rsi
shrq $0x30, %rsi
leaq -0x38(%rbp), %r13
movq %r12, %rdi
movq %r13, %rcx
callq 0x2ef05
movq (%r13), %rdi
leaq -0x30(%rbp), %r12
movq %rax, %rsi
movq %r12, %rdx
callq 0x92b17
movq %rax, %r13
movq (%r12), %r12
jmp 0x9ccbd
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r15, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x9cca2
incl (%rax)
movq %r15, %rdi
callq 0xfea8
movq %rax, %r13
movl $0x3, %esi
movq %r15, %rdi
callq 0xe50f
movq %rax, %r15
movq %r12, (%r14)
movq %r15, (%rbx)
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x439df(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x439e4(%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_C99DataStructField_free
static void mirth_c99_C99DataStructField_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_c99_C99DataStructField);
	struct mirth_c99_C99DataStructField* self = vself.data.ptr;
	decref(MK_mirth_type_StackTypePart(self->minput));
	decref(MK_mirth_c99_C99ReprType(self->mc99zerepr));
	decref(MKSTR(self->mcname));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x7625e(%rip), %rax     # 0x112f71
cmpq %rsi, %rax
jne 0x9cdbf
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 0x9cd5b
decl (%rax)
jne 0x9cd5b
leaq 0x74f96(%rip), %rsi     # 0x111ce1
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 0x9cd8d
decl (%rax)
jne 0x9cd8d
leaq 0x761ac(%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 0x9cdb3
decl (%r14)
jne 0x9cdb3
leaq 0x743ab(%rip), %rsi     # 0x111159
callq 0xd13d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0x5c2c1(%rip), %rsi     # 0xf9087
movl $0x5c, %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_C99DataSumTagRepr_free
void mirth_c99_C99DataSumTagRepr_free (VAL v) {
	struct mirth_c99_C99DataSumTagRepr self = V_mirth_c99_C99DataSumTagRepr(v);
	switch (self.tag) {
		case mirth_c99_C99DataSumTagRepr_Unit: {
			decref(MK_mirth_c99_C99DataUnitRepr(self.ptr.Unit->mC99DataUnitRepr));
			free(self.ptr.Unit);
		} break;
		case mirth_c99_C99DataSumTagRepr_Struct: {
			decref(MK_mirth_c99_C99DataStructRepr(self.ptr.Struct->mC99DataStructRepr));
			free(self.ptr.Struct);
		} break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movq %rdi, %rcx
shrq $0x30, %rcx
andq %rax, %rbx
cmpq $0x1, %rcx
je 0x9ce7a
testl %ecx, %ecx
jne 0x9cead
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x9ce9f
decl (%rax)
jne 0x9ce9f
leaq 0x75f49(%rip), %rsi     # 0x112dc1
jmp 0x9ce9a
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x9ce9f
decl (%rax)
jne 0x9ce9f
leaq 0x75fff(%rip), %rsi     # 0x112e99
callq 0xd13d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_C99DataRepr_Unit
static struct mirth_c99_C99DataUnitRepr* mtp_mirth_c99_C99DataRepr_Unit (struct mirth_c99_C99DataRepr in_C99DataRepr_1) {
	struct mirth_c99_C99DataRepr_Unit v3 = *in_C99DataRepr_1.ptr.Unit;
	if (!--(in_C99DataRepr_1.ptr.Unit->refs)) {
		free(in_C99DataRepr_1.ptr.Unit);
	} else {
		incref(MK_mirth_c99_C99DataUnitRepr(v3.mC99DataUnitRepr));
	}
	return v3.mC99DataUnitRepr;
}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0x9cfa3
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x9cfa8
incl (%rax)
jmp 0x9cfa8
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_C99DataRepr_Sum
static struct mirth_c99_C99DataSumRepr* mtp_mirth_c99_C99DataRepr_Sum (struct mirth_c99_C99DataRepr in_C99DataRepr_1) {
	struct mirth_c99_C99DataRepr_Sum v3 = *in_C99DataRepr_1.ptr.Sum;
	if (!--(in_C99DataRepr_1.ptr.Sum->refs)) {
		free(in_C99DataRepr_1.ptr.Sum);
	} else {
		incref(MK_mirth_c99_C99DataSumRepr(v3.mC99DataSumRepr));
	}
	return v3.mC99DataSumRepr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0x9cfde
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x9cfe3
incl (%rax)
jmp 0x9cfe3
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_c99_C99DataUnitRepr_stride
static VAL mw_mirth_c99_C99DataUnitRepr_stride (struct mirth_c99_C99DataUnitRepr* in_C99DataUnitRepr_1) {
	decref(MK_mirth_c99_C99DataUnitRepr(in_C99DataUnitRepr_1));
	STR* v3;
	STRLIT(v3, "STRIDE_UNIT", 11);
	return MKSTR(v3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movq %rdi, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x9f828
decl (%rax)
jne 0x9f828
leaq 0x7359e(%rip), %rsi     # 0x112dc1
callq 0xd13d
movq 0x1077411(%rip), %rax   # 0x1116c40
testq %rax, %rax
jne 0x9f862
movl $0xb, %edi
callq 0xf5e4
movq $0xb, 0x10(%rax)
movabsq $0x555f454449525453, %rcx # imm = 0x555F454449525453
movq %rcx, 0x18(%rax)
movl $0x54494e55, 0x1f(%rax) # imm = 0x54494E55
movq %rax, 0x10773de(%rip)   # 0x1116c40
andq %rax, %rbx
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0x9f873
incl (%rbx)
leaq 0x718df(%rip), %rdx     # 0x111159
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_c99_zaC99_c99zeline_1_sp130
static void mw_mirth_c99_zaC99_c99zeline_1_sp130 (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99* in_zaC99_2, struct mirth_mirth_zaMirth* *out_zaMirth_3, struct mirth_c99_zaC99* *out_zaC99_4) {
	struct mirth_mirth_zaMirth* v5;
	struct mirth_c99_zaC99* v6;
	mw_mirth_c99_zaC99_indent(in_zaMirth_1, in_zaC99_2, &v5, &v6);
	STR* v7;
	STRLIT(v7, "};", 2);
	struct mirth_mirth_zaMirth* v8;
	struct mirth_c99_zaC99* v9;
	mw_mirth_c99_zaC99_put(v5, v6, v7, &v8, &v9);
	struct mirth_mirth_zaMirth* v10;
	struct mirth_c99_zaC99* v11;
	mw_mirth_c99_zaC99_line(v8, v9, &v10, &v11);
	*out_zaC99_4 = v11;
	*out_zaMirth_3 = v10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %rbx
leaq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x93675
movq 0x1077070(%rip), %rdx   # 0x1116d08
testq %rdx, %rdx
jne 0x9fcbf
movl $0x2, %edi
callq 0xf5e4
movq %rax, %rdx
movq $0x2, 0x10(%rax)
movw $0x3b7d, 0x18(%rax)     # imm = 0x3B7D
movq %rax, 0x1077049(%rip)   # 0x1116d08
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x9fcdd
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 0x9fd25
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: mw_mirth_c99_C99DataTransRepr_needszerefcountingzy
static bool mw_mirth_c99_C99DataTransRepr_needszerefcountingzy (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataTransRepr* in_C99DataTransRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_c99_C99ReprType v5 = in_C99DataTransRepr_2->mc99zerepr;
	incref(MK_mirth_c99_C99ReprType(v5));
	decref(MK_mirth_c99_C99DataTransRepr(in_C99DataTransRepr_2));
	struct mirth_mirth_zaMirth* v6;
	bool v7 = mw_mirth_c99_C99ReprType_needszerefcountingzy(in_zaMirth_1, v5, &v6);
	*out_zaMirth_3 = v6;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movl 0x30(%rsi), %r15d
movq 0x38(%rsi), %r12
movq %r12, %rcx
andq %rax, %rcx
sete %dl
testb $0x3, %r12b
setne %dil
orb %dl, %dil
jne 0xa0078
incl (%rcx)
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa009f
decl (%rax)
jne 0xa009f
leaq 0x72dbd(%rip), %rax     # 0x112e51
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 0xa07cd
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_c99_C99DataStructRepr_needszerefcountingzy
static bool mw_mirth_c99_C99DataStructRepr_needszerefcountingzy (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataStructRepr* in_C99DataStructRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	uint64_t v5 = in_C99DataStructRepr_2->mtag;
	decref(MK_mirth_c99_C99DataStructRepr(in_C99DataStructRepr_2));
	struct mirth_mirth_zaMirth* v6;
	bool v7 = mw_mirth_data_Tag_outputszeresourcezy(in_zaMirth_1, v5, &v6);
	bool v8 = !v7;
	*out_zaMirth_3 = v6;
	return v8;
}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movq %rdi, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xa0a41
decl (%rax)
jne 0xa0a41
leaq 0x7245d(%rip), %rsi     # 0x112e99
callq 0xd13d
movq 0x10763e8(%rip), %rax   # 0x1116e30
testq %rax, %rax
jne 0xa0a82
movl $0xd, %edi
callq 0xf5e4
movq $0xd, 0x10(%rax)
movabsq $0x7628666f657a6973, %rcx # imm = 0x7628666F657A6973
movq %rcx, 0x18(%rax)
movabsq $0x292a64696f762866, %rcx # imm = 0x292A64696F762866
movq %rcx, 0x1d(%rax)
movq %rax, 0x10763ae(%rip)   # 0x1116e30
andq %rax, %rbx
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0xa0a93
incl (%rbx)
leaq 0x706bf(%rip), %rdx     # 0x111159
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_c99_C99DataSumRepr_stride
static VAL mw_mirth_c99_C99DataSumRepr_stride (struct mirth_c99_C99DataSumRepr* in_C99DataSumRepr_1) {
	decref(MK_mirth_c99_C99DataSumRepr(in_C99DataSumRepr_1));
	STR* v3;
	STRLIT(v3, "8", 1);
	return MKSTR(v3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movq %rdi, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xa0ad5
decl (%rax)
jne 0xa0ad5
leaq 0x72411(%rip), %rsi     # 0x112ee1
callq 0xd13d
movq 0x107635c(%rip), %rax   # 0x1116e38
testq %rax, %rax
jne 0xa0afe
movl $0x1, %edi
callq 0xf5e4
movq $0x1, 0x10(%rax)
movb $0x38, 0x18(%rax)
movq %rax, 0x107633a(%rip)   # 0x1116e38
andq %rax, %rbx
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0xa0b0f
incl (%rbx)
leaq 0x70643(%rip), %rdx     # 0x111159
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_c99_C99DataStructRepr_data
static uint64_t mw_mirth_c99_C99DataStructRepr_data (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataStructRepr* in_C99DataStructRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	uint64_t v5 = in_C99DataStructRepr_2->mtag;
	decref(MK_mirth_c99_C99DataStructRepr(in_C99DataStructRepr_2));
	struct mirth_mirth_zaMirth* v6;
	uint64_t v7 = mw_mirth_data_Tag_data(in_zaMirth_1, v5, &v6);
	*out_zaMirth_3 = v6;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %r15
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa0b62
decl (%rax)
jne 0xa0b62
leaq 0x72342(%rip), %rax     # 0x112e99
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd13d
leaq 0x1074077(%rip), %rdi   # 0x1114be0
movq %r15, %rsi
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
movq %r14, (%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_mirth_c99_C99DataSumRepr_enumzecname
static STR* mw_mirth_c99_C99DataSumRepr_enumzecname (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataSumRepr* in_C99DataSumRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	STR* v6 = mw_mirth_c99_C99DataSumRepr_cname(in_zaMirth_1, in_C99DataSumRepr_2, &v5);
	STR* v7;
	STRLIT(v7, "", 0);
	STR* v8;
	STRLIT(v8, "enum ", 5);
	STR* v9;
	mw_std_str_zaStr_pushzestrzx(v8, v7, &v9);
	STR* v10;
	mw_std_str_zaStr_pushzestrzx(v6, v9, &v10);
	STR* v11;
	STRLIT(v11, "_tag", 4);
	STR* v12;
	mw_std_str_zaStr_pushzestrzx(v11, v10, &v12);
	*out_zaMirth_3 = v5;
	return v12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x28(%rbp), %rdx
callq 0xa0ea2
movq %rax, %r14
movq 0x107649c(%rip), %r15   # 0x1117048
testq %r15, %r15
jne 0xa0bca
xorl %edi, %edi
callq 0xf5e4
movq %rax, %r15
movq $0x0, 0x10(%rax)
movq %rax, 0x107647e(%rip)   # 0x1117048
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movq %r15, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0xa0bea
incl (%rax)
movq 0x107645f(%rip), %rsi   # 0x1117050
testq %rsi, %rsi
jne 0xa0c1d
movl $0x5, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x5, 0x10(%rax)
movl $0x6d756e65, 0x18(%rax) # imm = 0x6D756E65
movb $0x20, 0x1c(%rax)
movq %rax, 0x1076433(%rip)   # 0x1117050
movq %rsi, %rax
andq %r12, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa0c33
incl (%rax)
movq %r15, %rdi
callq 0xe069
movq %rax, %rdi
movq %r14, %rsi
callq 0xe069
movq %rax, %r14
movq 0x1076408(%rip), %rsi   # 0x1117058
testq %rsi, %rsi
jne 0xa0c78
movl $0x4, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x4, 0x10(%rax)
movl $0x6761745f, 0x18(%rax) # imm = 0x6761745F
movq %rax, 0x10763e0(%rip)   # 0x1117058
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xa0c8d
incl (%r12)
movq %r14, %rdi
callq 0xe069
movq -0x28(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataSumRepr_unionzecname
static STR* mw_mirth_c99_C99DataSumRepr_unionzecname (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataSumRepr* in_C99DataSumRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	STR* v6 = mw_mirth_c99_C99DataSumRepr_cname(in_zaMirth_1, in_C99DataSumRepr_2, &v5);
	STR* v7;
	STRLIT(v7, "", 0);
	STR* v8;
	STRLIT(v8, "union ", 6);
	STR* v9;
	mw_std_str_zaStr_pushzestrzx(v8, v7, &v9);
	STR* v10;
	mw_std_str_zaStr_pushzestrzx(v6, v9, &v10);
	STR* v11;
	STRLIT(v11, "_ptr", 4);
	STR* v12;
	mw_std_str_zaStr_pushzestrzx(v11, v10, &v12);
	*out_zaMirth_3 = v5;
	return v12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x28(%rbp), %rdx
callq 0xa0ea2
movq %rax, %r14
movq 0x1076392(%rip), %r15   # 0x1117060
testq %r15, %r15
jne 0xa0cec
xorl %edi, %edi
callq 0xf5e4
movq %rax, %r15
movq $0x0, 0x10(%rax)
movq %rax, 0x1076374(%rip)   # 0x1117060
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movq %r15, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0xa0d0c
incl (%rax)
movq 0x1076355(%rip), %rsi   # 0x1117068
testq %rsi, %rsi
jne 0xa0d41
movl $0x6, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x6, 0x10(%rax)
movl $0x6f696e75, 0x18(%rax) # imm = 0x6F696E75
movw $0x206e, 0x1c(%rax)     # imm = 0x206E
movq %rax, 0x1076327(%rip)   # 0x1117068
movq %rsi, %rax
andq %r12, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa0d57
incl (%rax)
movq %r15, %rdi
callq 0xe069
movq %rax, %rdi
movq %r14, %rsi
callq 0xe069
movq %rax, %r14
movq 0x10762fc(%rip), %rsi   # 0x1117070
testq %rsi, %rsi
jne 0xa0d9c
movl $0x4, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x4, 0x10(%rax)
movl $0x7274705f, 0x18(%rax) # imm = 0x7274705F
movq %rax, 0x10762d4(%rip)   # 0x1117070
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xa0db1
incl (%r12)
movq %r14, %rdi
callq 0xe069
movq -0x28(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataSumRepr_structzecname
static STR* mw_mirth_c99_C99DataSumRepr_structzecname (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataSumRepr* in_C99DataSumRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	STR* v6 = mw_mirth_c99_C99DataSumRepr_cname(in_zaMirth_1, in_C99DataSumRepr_2, &v5);
	STR* v7;
	STRLIT(v7, "", 0);
	STR* v8;
	STRLIT(v8, "struct ", 7);
	STR* v9;
	mw_std_str_zaStr_pushzestrzx(v8, v7, &v9);
	STR* v10;
	mw_std_str_zaStr_pushzestrzx(v6, v9, &v10);
	*out_zaMirth_3 = v5;
	return v10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x28(%rbp), %rdx
callq 0xa0ea2
movq %rax, %r14
movq 0x1076286(%rip), %r15   # 0x1117078
testq %r15, %r15
jne 0xa0e10
xorl %edi, %edi
callq 0xf5e4
movq %rax, %r15
movq $0x0, 0x10(%rax)
movq %rax, 0x1076268(%rip)   # 0x1117078
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movq %r15, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0xa0e30
incl (%rax)
movq 0x1076249(%rip), %rsi   # 0x1117080
testq %rsi, %rsi
jne 0xa0e66
movl $0x7, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x7, 0x10(%rax)
movl $0x75727473, 0x18(%rax) # imm = 0x75727473
movl $0x20746375, 0x1b(%rax) # imm = 0x20746375
movq %rax, 0x107621a(%rip)   # 0x1117080
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xa0e7b
incl (%r12)
movq %r15, %rdi
callq 0xe069
movq %rax, %rdi
movq %r14, %rsi
callq 0xe069
movq -0x28(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataSumRepr_cname
static STR* mw_mirth_c99_C99DataSumRepr_cname (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataSumRepr* in_C99DataSumRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	uint64_t v5 = in_C99DataSumRepr_2->mdata;
	decref(MK_mirth_c99_C99DataSumRepr(in_C99DataSumRepr_2));
	struct mirth_mirth_zaMirth* v6;
	STR* v7 = mw_mirth_data_Data_cname(in_zaMirth_1, v5, &v6);
	*out_zaMirth_3 = v6;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %r14
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa0eec
decl (%rax)
jne 0xa0eec
leaq 0x72000(%rip), %rax     # 0x112ee1
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd13d
leaq -0x28(%rbp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x9b7b1
movq (%r12), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataStructRepr_underlyingzec99zetype
static STR* mw_mirth_c99_C99DataStructRepr_underlyingzec99zetype (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_C99DataStructRepr* in_C99DataStructRepr_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	STR* v5;
	STRLIT(v5, "", 0);
	STR* v6;
	STRLIT(v6, "struct ", 7);
	STR* v7;
	mw_std_str_zaStr_pushzestrzx(v6, v5, &v7);
	STR* v8 = in_C99DataStructRepr_2->mcname;
	incref(MKSTR(v8));
	decref(MK_mirth_c99_C99DataStructRepr(in_C99DataStructRepr_2));
	STR* v9;
	mw_std_str_zaStr_pushzestrzx(v8, v7, &v9);
	STR* v10;
	STRLIT(v10, "*", 1);
	STR* v11;
	mw_std_str_zaStr_pushzestrzx(v10, v9, &v11);
	*out_zaMirth_3 = in_zaMirth_1;
	return v11;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movq %rdi, %r14
movq 0x10722d9(%rip), %r12   # 0x11174a8
testq %r12, %r12
jne 0xa51ed
xorl %edi, %edi
callq 0xf5e4
movq %rax, %r12
movq $0x0, 0x10(%rax)
movq %rax, 0x10722bb(%rip)   # 0x11174a8
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movq %r12, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0xa520d
incl (%rax)
movq 0x107229c(%rip), %rsi   # 0x11174b0
testq %rsi, %rsi
jne 0xa5243
movl $0x7, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x7, 0x10(%rax)
movl $0x75727473, 0x18(%rax) # imm = 0x75727473
movl $0x20746375, 0x1b(%rax) # imm = 0x20746375
movq %rax, 0x107226d(%rip)   # 0x11174b0
movq %rsi, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa5259
incl (%rax)
movq %r12, %rdi
callq 0xe069
movq %rax, %r12
movq 0x10(%r15), %r13
movq %r13, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0xa527e
incl (%rax)
movq %r15, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0xa52a5
decl (%rax)
jne 0xa52a5
leaq 0x6dbfc(%rip), %rsi     # 0x112e99
movq %r15, %rdi
callq 0xd13d
movq %r12, %rdi
movq %r13, %rsi
callq 0xe069
movq %rax, %r15
movq 0x10721fe(%rip), %rsi   # 0x11174b8
testq %rsi, %rsi
jne 0xa52df
movl $0x1, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x1, 0x10(%rax)
movb $0x2a, 0x18(%rax)
movq %rax, 0x10721d9(%rip)   # 0x11174b8
andq %rsi, %rbx
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xa52f2
incl (%rbx)
movq %r15, %rdi
callq 0xe069
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_O3/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 0xa597f
incl (%rcx)
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa59a6
decl (%rax)
jne 0xa59a6
leaq 0x6d5d6(%rip), %rax     # 0x112f71
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_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 0xa71d6
cmpl $0x15, %esi
jne 0xa71db
movq 0x8(%rdx), %r15
decl (%rdx)
jne 0xa71ad
movq %rdx, %rdi
callq 0x5030
leaq -0x28(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x8c80a
movl %eax, %edi
movq %rdx, %rsi
callq 0x8c66d
movl %eax, %r15d
xorb $0x1, %r15b
movq (%r12), %r14
jmp 0xa7217
xorl %r15d, %r15d
jmp 0xa7217
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %dil
movb $0x1, %r15b
orb %cl, %dil
jne 0xa7217
decl (%rax)
jne 0xa7217
shlq $0x30, %rsi
orq %rdx, %rsi
leaq 0x6bd1d(%rip), %rax     # 0x112f29
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd13d
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_O3/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 0xa725e
decl (%rax)
jne 0xa725e
leaq 0x6bb68(%rip), %rsi     # 0x112dc1
callq 0xd13d
movq 0x1070333(%rip), %rax   # 0x1117598
testq %rax, %rax
jne 0xa728a
movl $0x4, %edi
callq 0xf5e4
movq $0x4, 0x10(%rax)
movl $0x64696f76, 0x18(%rax) # imm = 0x64696F76
movq %rax, 0x107030e(%rip)   # 0x1117598
andq %rax, %rbx
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0xa729b
incl (%rbx)
leaq 0x69eb7(%rip), %rdx     # 0x111159
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_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 0x9b7b1
movq %rax, %r14
movq (%r15), %r12
movq 0x10702cd(%rip), %r15   # 0x11175a0
testq %r15, %r15
jne 0xa72f1
xorl %edi, %edi
callq 0xf5e4
movq %rax, %r15
movq $0x0, 0x10(%rax)
movq %rax, 0x10702af(%rip)   # 0x11175a0
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
movq %r15, %rax
andq %r13, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0xa7311
incl (%rax)
movq 0x1070290(%rip), %rsi   # 0x11175a8
testq %rsi, %rsi
jne 0xa7344
movl $0x5, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x5, 0x10(%rax)
movl $0x6d756e65, 0x18(%rax) # imm = 0x6D756E65
movb $0x20, 0x1c(%rax)
movq %rax, 0x1070264(%rip)   # 0x11175a8
andq %rsi, %r13
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xa7359
incl (%r13)
movq %r15, %rdi
callq 0xe069
movq %rax, %rdi
movq %r14, %rsi
callq 0xe069
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_O3/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 0xa73bc
incl (%rcx)
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa73e3
decl (%rax)
jne 0xa73e3
leaq 0x6ba79(%rip), %rax     # 0x112e51
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 0xa59d1
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_std_prim_Str_Str_1_sp8
static STR* mw_std_prim_Str_Str_1_sp8 (STR* in_Str_1) {
	STR* v3;
	STRLIT(v3, "", 0);
	STR* v4;
	STRLIT(v4, "MKI64(", 6);
	STR* v5;
	mw_std_str_zaStr_pushzestrzx(v4, v3, &v5);
	STR* v6;
	mw_std_str_zaStr_pushzestrzx(in_Str_1, v5, &v6);
	STR* v7;
	STRLIT(v7, ")", 1);
	STR* v8;
	mw_std_str_zaStr_pushzestrzx(v7, v6, &v8);
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1070346(%rip), %r14   # 0x1117768
testq %r14, %r14
jne 0xa7440
xorl %edi, %edi
callq 0xf5e4
movq %rax, %r14
movq $0x0, 0x10(%rax)
movq %rax, 0x1070328(%rip)   # 0x1117768
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq %r14, %rax
andq %r15, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0xa7460
incl (%rax)
movq 0x1070309(%rip), %rsi   # 0x1117770
testq %rsi, %rsi
jne 0xa7495
movl $0x6, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x6, 0x10(%rax)
movl $0x36494b4d, 0x18(%rax) # imm = 0x36494B4D
movw $0x2834, 0x1c(%rax)     # imm = 0x2834
movq %rax, 0x10702db(%rip)   # 0x1117770
movq %rsi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa74ab
incl (%rax)
movq %r14, %rdi
callq 0xe069
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe069
movq %rax, %rbx
movq 0x10702b0(%rip), %rsi   # 0x1117778
testq %rsi, %rsi
jne 0xa74ed
movl $0x1, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x1, 0x10(%rax)
movb $0x29, 0x18(%rax)
movq %rax, 0x107028b(%rip)   # 0x1117778
andq %rsi, %r15
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xa7501
incl (%r15)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
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_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 0xa754d
movq %rdi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xa754d
decl (%rax)
jne 0xa754d
callq 0xd13d
movq 0x10(%r14), %rbx
movq %rbx, %rax
andq %r15, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xa7566
incl (%rax)
movq %r14, %rax
andq %r15, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0xa758d
decl (%rax)
jne 0xa758d
leaq 0x6b83c(%rip), %rsi     # 0x112dc1
movq %r14, %rdi
callq 0xd13d
movq 0x10701ec(%rip), %r14   # 0x1117780
testq %r14, %r14
jne 0xa75b2
xorl %edi, %edi
callq 0xf5e4
movq %rax, %r14
movq $0x0, 0x10(%rax)
movq %rax, 0x10701ce(%rip)   # 0x1117780
movq %r14, %rax
andq %r15, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0xa75c8
incl (%rax)
movq 0x10701b9(%rip), %rsi   # 0x1117788
testq %rsi, %rsi
jne 0xa75fa
movl $0x3, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x3, 0x10(%rax)
movw $0x4b4d, 0x18(%rax)     # imm = 0x4B4D
movb $0x5f, 0x1a(%rax)
movq %rax, 0x107018e(%rip)   # 0x1117788
movq %rsi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xa7610
incl (%rax)
movq %r14, %rdi
callq 0xe069
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe069
movq %rax, %rbx
movq 0x1070163(%rip), %rsi   # 0x1117790
testq %rsi, %rsi
jne 0xa7658
movl $0x3, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x3, 0x10(%rax)
movw $0x3028, 0x18(%rax)     # imm = 0x3028
movb $0x29, 0x1a(%rax)
movq %rax, 0x1070138(%rip)   # 0x1117790
andq %rsi, %r15
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0xa766c
incl (%r15)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
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_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 0x9b7b1
movq (%r15), %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0xa7956
movq %r15, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq