LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_TagField_similar
static bool mw_mirth_data_TagField_similar (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_data_TagField* in_TagField_2, struct mirth_data_TagField* in_TagField_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	uint64_t v6;
	uint64_t v7;
	struct std_either_Either_2 v8;
	mtp_mirth_data_TagField_TagField(in_TagField_3, &v6, &v7, &v8);
	uint64_t v9;
	uint64_t v10;
	struct std_either_Either_2 v11;
	mtp_mirth_data_TagField_TagField(in_TagField_2, &v9, &v10, &v11);
	uint64_t v12 = v7;
	uint64_t v13 = v10;
	bool v14 = (v12 == v13);
	uint64_t v15 = v6;
	uint64_t v16 = v9;
	bool v17 = (v15 == v16);
	bool v18 = (v14 && v17);
	decref(MK_std_either_Either_2(v8));
	decref(MK_std_either_Either_2(v11));
	*out_zaMirth_4 = in_zaMirth_1;
	return v18;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, -0x38(%rbp)
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
leaq -0x40(%rbp), %rsi
leaq -0x78(%rbp), %r13
leaq -0x60(%rbp), %rcx
movq %rdx, %rdi
movq %r13, %rdx
callq 0x5d03c
leaq -0x70(%rbp), %r14
leaq -0x68(%rbp), %rbx
leaq -0x50(%rbp), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5d03c
movq (%r13), %r13
movq (%rbx), %r15
leaq -0x40(%rbp), %rax
movq (%rax), %rbx
movq (%r14), %r14
leaq -0x60(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0x82c1b(%rip), %rsi     # 0x111f21
movq %rax, %rcx
andq %r12, %rcx
sete %dl
testb $0x3, %al
setne %dil
orb %dl, %dil
jne 0x8f334
movl -0x60(%rbp), %edi
decl (%rcx)
jne 0x8f334
shlq $0x30, %rdi
orq %rax, %rdi
callq 0xd13d
leaq 0x82bed(%rip), %rsi     # 0x111f21
movq -0x48(%rbp), %rax
andq %rax, %r12
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0x8f35c
movl -0x50(%rbp), %edi
decl (%r12)
jne 0x8f35c
shlq $0x30, %rdi
orq %rax, %rdi
callq 0xd13d
xorq %r15, %r13
xorq %r14, %rbx
orq %r13, %rbx
sete %al
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rdx
movq %rdx, (%rcx)
addq $0x58, %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: mtw_mirth_specializzer_zaSPSynth_zaSPSynth
static void mtw_mirth_specializzer_zaSPSynth_zaSPSynth (struct std_list_Nest_1* in_SPKey_1, uint64_t in_Word_2, struct std_list_List_1 in_Map_3, struct mirth_arrow_Arrow* in_zaAB_4, struct mirth_specializzer_zaSPSynth* *out_zaSPSynth_5) {
	struct mirth_specializzer_zaSPSynth* v6 = calloc(1, sizeof *v6);
	ASSERT(v6);
	v6->mzaAB = in_zaAB_4;
	v6->mspmap = in_Map_3;
	v6->mspword = in_Word_2;
	v6->mspkey = in_SPKey_1;
	*out_zaSPSynth_5 = v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, -0x30(%rbp)
movq %r8, %r13
movq %rcx, %r14
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r15
movl $0x1, %edi
movl $0x28, %esi
callq 0x50c0
testq %rax, %rax
je 0x8f3de
movq %r13, 0x20(%rax)
movl %ebx, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %r12, 0x8(%rax)
movq %r15, (%rax)
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x59c2f(%rip), %rsi     # 0xe9014
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_specializzer_zaSPSynth_synthzerunzx
static void mw_mirth_specializzer_zaSPSynth_synthzerunzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_specializzer_zaSPSynth* in_zaSPSynth_2, uint64_t in_Block_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_specializzer_zaSPSynth* *out_zaSPSynth_5) {
	struct mirth_mirth_zaMirth* v6;
	struct mirth_arrow_Arrow* v7 = mw_mirth_arrow_Block_arrow(in_zaMirth_1, in_Block_3, &v6);
	struct mirth_mirth_zaMirth* v8;
	struct mirth_specializzer_zaSPSynth* v9;
	mw_mirth_specializzer_zaSPSynth_synthzearrowzx(v6, in_zaSPSynth_2, v7, &v8, &v9);
	*out_zaSPSynth_5 = v9;
	*out_zaMirth_4 = v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x1084e86(%rip), %rdi   # 0x11158b8
movq %rdx, %rsi
callq 0x13c85
leaq -0x30(%rbp), %r13
movq %r12, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x1a6db
movq (%r13), %rdi
leaq -0x30(%rbp), %r12
leaq -0x38(%rbp), %r13
movq %r15, %rsi
movq %rax, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0x8f403
movq (%r13), %rax
movq %rax, (%r14)
movq (%r12), %rax
movq %rax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_c99_C99zuOptions_free
static void mirth_c99_C99zuOptions_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_c99_C99zuOptions);
	struct mirth_c99_C99zuOptions* self = vself.data.ptr;
	decref(MKSTR(self->moutputzepath));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x8229e(%rip), %rax     # 0x112d31
cmpq %rsi, %rax
jne 0x90ad8
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x90aca
decl (%rax)
jne 0x90aca
leaq 0x80694(%rip), %rsi     # 0x111159
callq 0xd13d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
leaq 0x58702(%rip), %rsi     # 0xe91e1
movl $0x56, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_need_zaNeeds_runzewordzx
static void mw_mirth_need_zaNeeds_runzewordzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_need_zaNeeds* in_zaNeeds_2, uint64_t in_Word_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_need_zaNeeds* *out_zaNeeds_5) {
	struct mirth_mirth_zaMirth* v6;
	struct mirth_arrow_Arrow* v7 = mw_mirth_word_Word_arrow(in_zaMirth_1, in_Word_3, &v6);
	struct mirth_mirth_zaMirth* v8;
	struct mirth_need_zaNeeds* v9;
	mw_mirth_need_zaNeeds_runzearrowzx(v6, in_zaNeeds_2, v7, &v8, &v9);
	*out_zaNeeds_5 = v9;
	*out_zaMirth_4 = v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x10841e8(%rip), %rdi   # 0x11156d0
movq %rdx, %rsi
callq 0x13c85
leaq -0x30(%rbp), %r13
movq %r12, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x1a6db
movq (%r13), %rdi
leaq -0x30(%rbp), %r12
leaq -0x38(%rbp), %r13
movq %r15, %rsi
movq %rax, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0x90b4a
movq (%r13), %rax
movq %rax, (%r14)
movq (%r12), %rax
movq %rax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_need_zaNeeds_pushzeargszx
static void mw_mirth_need_zaNeeds_pushzeargszx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_need_zaNeeds* in_zaNeeds_2, struct std_list_List_1 in_List_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_need_zaNeeds* *out_zaNeeds_5) {
	bool v6 = true;
	struct mirth_mirth_zaMirth* r7 = in_zaMirth_1;
	struct mirth_need_zaNeeds* r8 = in_zaNeeds_2;
	struct std_list_List_1 v9 = in_List_3;
	bool v10 = v6;
	bool v11 = v6;
	while (v11) {
		struct mirth_mirth_zaMirth* r12 = r7;
		struct mirth_need_zaNeeds* r13 = r8;
		struct std_list_List_1 v14 = v9;
		bool v15 = v10;
		struct mirth_mirth_zaMirth* branch_zaMirth_16;
		struct mirth_need_zaNeeds* branch_zaNeeds_17;
		struct std_list_List_1 branch_List_18;
		bool branch_Bool_19;
		switch ((v14).tag) {
			case std_list_List_1_Cons: {
				struct std_list_List_1 v20;
				VAL v21 = mtp_std_list_List_1_Cons(v14, &v20);
				struct mirth_mirth_zaMirth* v22;
				struct mirth_need_zaNeeds* v23;
				mw_mirth_need_zaNeeds_pushzeargzx(r12, r13, V_mirth_arrow_Block(v21), &v22, &v23);
				bool v24 = true;
				branch_Bool_19 = v24;
				branch_List_18 = v20;
				branch_zaNeeds_17 = v23;
				branch_zaMirth_16 = v22;
			} break;
			case std_list_List_1_Nil: {
				struct std_list_List_1 v25 = { .tag=std_list_List_1_Nil };
				bool v26 = false;
				branch_Bool_19 = v26;
				branch_List_18 = v25;
				branch_zaNeeds_17 = r13;
				branch_zaMirth_16 = r12;
			} break;
			default: {
				do_panic(str_make("unexpected fallthrough in match\n", 32));
			}
		}
		v11 = branch_Bool_19;
		v10 = branch_Bool_19;
		v9 = branch_List_18;
		r8 = branch_zaNeeds_17;
		r7 = branch_zaMirth_16;
	}
	decref(MK_std_list_List_1(v9));
	*out_zaNeeds_5 = r8;
	*out_zaMirth_4 = r7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %rsi, %r15
movq %rdi, %r13
leaq -0x58(%rbp), %r12
leaq -0x48(%rbp), %rbx
leaq -0x40(%rbp), %r14
cmpl $0x1, %edx
jne 0x9159c
movq %rcx, %rdi
movq %r12, %rsi
callq 0xd0aa
movq %r13, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %rbx, %rcx
movq %r14, %r8
callq 0x915ed
movq -0x40(%rbp), %r15
movq -0x48(%rbp), %r13
movl -0x58(%rbp), %edx
movq -0x50(%rbp), %rcx
jmp 0x91567
testl %edx, %edx
jne 0x915bd
movq -0x30(%rbp), %rax
movq %r15, (%rax)
movq -0x38(%rbp), %rax
movq %r13, (%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x4f0f7(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x4f0fc(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_need_zaNeeds_pushzeblockzx
static void mw_mirth_need_zaNeeds_pushzeblockzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_need_zaNeeds* in_zaNeeds_2, uint64_t in_Block_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_need_zaNeeds* *out_zaNeeds_5) {
	struct mirth_mirth_zaMirth* v6;
	struct std_maybe_Maybe_1 v7 = mw_mirth_arrow_Block_tozerunzevar(in_zaMirth_1, in_Block_3, &v6);
	struct mirth_mirth_zaMirth* branch_zaMirth_8;
	struct mirth_need_zaNeeds* branch_zaNeeds_9;
	switch ((v7).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v10 = mtp_std_maybe_Maybe_1_Some(v7);
			decref(v10);
			branch_zaNeeds_9 = in_zaNeeds_2;
			branch_zaMirth_8 = v6;
		} break;
		case std_maybe_Maybe_1_None: {
			struct mirth_mirth_zaMirth* v11;
			struct mirth_need_zaNeeds* v12;
			mw_mirth_need_zaNeeds_needzeblockzx(v6, in_zaNeeds_2, in_Block_3, &v11, &v12);
			branch_zaNeeds_9 = v12;
			branch_zaMirth_8 = v11;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaNeeds_5 = branch_zaNeeds_9;
	*out_zaMirth_4 = branch_zaMirth_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
leaq -0x30(%rbp), %rdx
movq %r12, %rsi
callq 0x91f76
testl %eax, %eax
je 0x91661
cmpl $0x1, %eax
jne 0x916ab
movq %rdx, %rdi
callq 0xd745
testb $0x1, %dl
je 0x9165b
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %sil
testb $0x3, %al
setne %dil
orb %sil, %dil
jne 0x9165b
decl (%rcx)
jne 0x9165b
movq %rax, %rdi
movq %rdx, %rsi
callq 0xd13d
movq -0x30(%rbp), %rax
jmp 0x91696
movq -0x30(%rbp), %r13
movq %r12, %rdi
callq 0x92175
leaq -0x40(%rbp), %r8
leaq -0x38(%rbp), %r12
movq %r13, %rdi
movq %r15, %rsi
movl $0x1, %edx
movq %rax, %rcx
movq %r8, %r13
movq %r12, %r9
callq 0x917a6
movq (%r12), %r15
movq (%r13), %rax
movq %r15, (%r14)
movq %rax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x4f009(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x4f00e(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_need_Need_Word
static struct mirth_need_Need mtw_mirth_need_Need_Word (uint64_t in_Word_1) {
	struct mirth_need_Need_Word* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mWord = in_Word_1;
	struct mirth_need_Need v4 = { .tag=mirth_need_Need_Word, .ptr.Word=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 0x91781
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x57af0(%rip), %rsi     # 0xe9278
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_need_Need_neededzy
static bool mw_mirth_need_Need_neededzy (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_need_zaNeeds* in_zaNeeds_2, struct mirth_need_Need in_Need_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_need_zaNeeds* *out_zaNeeds_5) {
	struct mirth_mirth_zaMirth* v7;
	INT v8 = mw_mirth_need_Need_zgNat(in_zaMirth_1, in_Need_3, &v7);
	ARR* r9 = in_zaNeeds_2->mzaset;
	ARR* v10;
	bool v11 = mw_std_set_zaSet_memberzy(v8, r9, &v10);
	in_zaNeeds_2->mzaset = v10;
	*out_zaNeeds_5 = in_zaNeeds_2;
	*out_zaMirth_4 = v7;
	return v11;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %rsi, %r15
leaq -0x40(%rbp), %rax
movl %edx, %esi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x91a45
movq 0x10(%r15), %r13
leaq -0x48(%rbp), %r12
movl $0x11, %esi
movq %rax, %rdi
movq %r12, %rdx
callq 0x13e71
movq %rax, %rbx
movq (%r12), %rdi
callq 0xe445
movzbl %al, %edx
movl $0x1, %r14d
movl %eax, %ecx
shlq %cl, %r14
xorl %eax, %eax
cmpl $0x40, %edx
cmovael %eax, %r14d
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x91bbd
andb %r14b, %al
movzbl %al, %edi
callq 0xe3d6
movl $0x1, %esi
movq %rax, %rdi
callq 0xe83a
testl %eax, %eax
setne %al
movq (%r12), %rcx
movq %rcx, 0x10(%r15)
movq -0x30(%rbp), %rcx
movq %r15, (%rcx)
leaq -0x40(%rbp), %rcx
movq (%rcx), %rcx
movq -0x38(%rbp), %rdx
movq %rcx, (%rdx)
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_std_buffer_zaBuffer_u8zo
static uint8_t mw_std_buffer_zaBuffer_u8zo (ARR* in_zaBuffer_1, INT in_Offset_2, ARR* *out_zaBuffer_3) {
	INT v5 = WRAP_I63(1LL);
	ARR* v6;
	INT v7 = mw_std_buffer_zaBuffer_preparezespanzx(in_zaBuffer_1, in_Offset_2, v5, &v6);
	ARR* v8;
	void* v9 = mw_std_buffer_zaBuffer_base(v6, &v8);
	void* v10 = mw_std_prelude_unsafe_1_sp5(v7, v9);
	uint8_t v11 = *(uint8_t*)v10;
	*out_zaBuffer_3 = v8;
	return v11;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x30(%rbp), %r15
movl $0x3, %edx
movq %r15, %rcx
callq 0x11c46
movq (%r15), %rdi
leaq -0x28(%rbp), %r15
movq %r15, %rsi
callq 0x11814
movq %rax, %r12
movq %r14, %rdi
callq 0xe445
movb (%r12,%rax), %al
movq (%r15), %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: mtw_mirth_need_Need_TagWord
static struct mirth_need_Need mtw_mirth_need_Need_TagWord (uint64_t in_Tag_1) {
	struct mirth_need_Need_TagWord* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mTag = in_Tag_1;
	struct mirth_need_Need v4 = { .tag=mirth_need_Need_TagWord, .ptr.TagWord=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 0x91c42
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5766d(%rip), %rsi     # 0xe92b6
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_if_2_sp5
static void mw_std_maybe_Maybe_1_if_2_sp5 (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_need_zaNeeds* in_zaNeeds_2, struct std_list_List_1 in_List_3, struct std_maybe_Maybe_1 in_Maybe_4, struct mirth_mirth_zaMirth* *out_zaMirth_5, struct mirth_need_zaNeeds* *out_zaNeeds_6) {
	int64_t v7 = (in_Maybe_4).tag;
	decref(MK_std_maybe_Maybe_1(in_Maybe_4));
	INT v8 = WRAP_I63(0LL);
	INT v9 = v8;
	INT v10 = i64_to_int(v7);
	bool v11 = int_eq(v10, v9);
	bool v12 = !v11;
	struct mirth_mirth_zaMirth* branch_zaMirth_13;
	struct mirth_need_zaNeeds* branch_zaNeeds_14;
	if (v12) {
		struct mirth_mirth_zaMirth* v15;
		struct mirth_need_zaNeeds* v16;
		mw_mirth_need_zaNeeds_runzeargszx(in_zaMirth_1, in_zaNeeds_2, in_List_3, &v15, &v16);
		branch_zaNeeds_14 = v16;
		branch_zaMirth_13 = v15;
	} else {
		struct mirth_mirth_zaMirth* v17;
		struct mirth_need_zaNeeds* v18;
		mw_mirth_need_zaNeeds_pushzeargszx(in_zaMirth_1, in_zaNeeds_2, in_List_3, &v17, &v18);
		branch_zaNeeds_14 = v18;
		branch_zaMirth_13 = v17;
	}
	*out_zaNeeds_6 = branch_zaNeeds_14;
	*out_zaMirth_5 = branch_zaMirth_13;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movl %r8d, %r13d
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r9, %rax
sete %cl
testb $0x3, %r9b
setne %dl
orb %cl, %dl
jne 0x91cbc
decl (%rax)
jne 0x91cbc
movq %r13, %rdi
shlq $0x30, %rdi
orq %r9, %rdi
leaq 0x7f60a(%rip), %rsi     # 0x1112c1
callq 0xd13d
leaq 0x1(,%r13,2), %rdi
movl $0x1, %esi
callq 0xe83a
testl %eax, %eax
je 0x91d44
leaq -0x48(%rbp), %r13
cmpl $0x1, %r12d
jne 0x91d0f
movq %r15, %rdi
leaq -0x40(%rbp), %rsi
callq 0xd0aa
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
leaq -0x30(%rbp), %rcx
movq %r13, %r8
callq 0x916db
movq -0x48(%rbp), %rbx
movq -0x30(%rbp), %r14
movl -0x40(%rbp), %r12d
movq -0x38(%rbp), %r15
jmp 0x91cd6
testl %r12d, %r12d
je 0x91d6d
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x4e9a0(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x4e9a5(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
leaq -0x40(%rbp), %rax
leaq -0x30(%rbp), %r13
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
movq %r15, %rcx
movq %rax, %r14
movq %rax, %r8
movq %r13, %r9
callq 0x9153c
movq (%r13), %rbx
movq (%r14), %r14
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rcx
movq %rbx, (%rax)
movq %r14, (%rcx)
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: mtw_mirth_need_Need_TagPattern
static struct mirth_need_Need mtw_mirth_need_Need_TagPattern (uint64_t in_Tag_1) {
	struct mirth_need_Need_TagPattern* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mTag = in_Tag_1;
	struct mirth_need_Need v4 = { .tag=mirth_need_Need_TagPattern, .ptr.TagPattern=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 0x91f51
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x57390(%rip), %rsi     # 0xe92e8
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_arrow_Block_tozerunzevar
static struct std_maybe_Maybe_1 mw_mirth_arrow_Block_tozerunzevar (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Block_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct mirth_arrow_Arrow* v6 = mw_mirth_arrow_Block_arrow(in_zaMirth_1, in_Block_2, &v5);
	struct mirth_mirth_zaMirth* v7;
	struct std_maybe_Maybe_1 v8 = mw_mirth_arrow_Arrow_tozerunzevar(v5, v6, &v7);
	*out_zaMirth_3 = v7;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
leaq 0x108391a(%rip), %rdi   # 0x11158b8
callq 0x13c85
leaq -0x40(%rbp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x1a6db
movq %rax, %rdi
movl 0x58(%rax), %r14d
movq 0x60(%rax), %r15
movq %r15, %rcx
andq %r13, %rcx
sete %dl
testb $0x3, %r15b
setne %sil
orb %dl, %sil
jne 0x91fd5
incl (%rcx)
movq -0x40(%rbp), %r12
andq %r13, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x91ffa
decl (%rax)
jne 0x91ffa
leaq 0x803ac(%rip), %rsi     # 0x1123a1
callq 0xd13d
movl %r14d, %edi
movq %r15, %rsi
callq 0xf35d
testl %eax, %eax
je 0x92131
movq %r12, -0x38(%rbp)
movq %rbx, -0x30(%rbp)
cmpl $0x1, %eax
jne 0x92145
movq %rdx, %rdi
callq 0xd745
movq %rax, %rdi
movl 0x30(%rax), %r15d
movq 0x38(%rax), %rbx
movq %rbx, %r14
andq %r13, %r14
setne %cl
testb $0x3, %bl
sete %r12b
andb %cl, %r12b
cmpb $0x1, %r12b
jne 0x9204d
incl (%r14)
andq %r13, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x9206e
decl (%rax)
jne 0x9206e
leaq 0x80800(%rip), %rsi     # 0x112869
callq 0xd13d
cmpl $0x9, %r15d
jne 0x920f3
movq 0x8(%rbx), %r15
decl (%rbx)
jne 0x92084
movq %rbx, %rdi
callq 0x5030
leaq 0x1082f75(%rip), %rdi   # 0x1115000
movq %r15, %rsi
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
movq %rax, %r14
andq %rax, %r13
movq -0x38(%rbp), %r12
je 0x920c0
decl (%r13)
jne 0x920c0
movq %r14, %rdi
andq $-0x4, %rdi
leaq 0x7f206(%rip), %rsi     # 0x1112c1
callq 0xd13d
shrq $0x2f, %r14
orq $0x1, %r14
movl $0x1, %esi
movq %r14, %rdi
callq 0xe83a
testl %eax, %eax
movq -0x30(%rbp), %rbx
je 0x9212f
leaq 0x7f9bc(%rip), %rsi     # 0x111aa0
movq %r15, %rdi
callq 0x9353
movl $0x1, %eax
jmp 0x92133
testb %r12b, %r12b
je 0x92121
decl (%r14)
movq -0x38(%rbp), %r12
jne 0x92117
shlq $0x30, %r15
orq %rbx, %r15
leaq 0x8063a(%rip), %rsi     # 0x112749
movq %r15, %rdi
callq 0xd13d
xorl %eax, %eax
xorl %edx, %edx
movq -0x30(%rbp), %rbx
jmp 0x92133
xorl %eax, %eax
xorl %edx, %edx
movq -0x30(%rbp), %rbx
movq -0x38(%rbp), %r12
jmp 0x92133
xorl %eax, %eax
xorl %edx, %edx
movq %r12, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x4e56f(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x4e574(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_need_Need_Block
static struct mirth_need_Need mtw_mirth_need_Need_Block (uint64_t in_Block_1) {
	struct mirth_need_Need_Block* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mBlock = in_Block_1;
	struct mirth_need_Need v4 = { .tag=mirth_need_Need_Block, .ptr.Block=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 0x921a3
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x57170(%rip), %rsi     # 0xe931a
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_need_Need_Label
static struct mirth_need_Need mtw_mirth_need_Need_Label (uint64_t in_Label_1) {
	struct mirth_need_Need_Label* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mLabel = in_Label_1;
	struct mirth_need_Need v4 = { .tag=mirth_need_Need_Label, .ptr.Label=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 0x921f6
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5714f(%rip), %rsi     # 0xe934c
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99_put
static void mw_mirth_c99_zaC99_put (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) {
	bool v6 = in_zaC99_2->mputzeenabled;
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	struct mirth_c99_zaC99* branch_zaC99_8;
	if (v6) {
		struct std_output_zaOutput* r9 = in_zaC99_2->mzaoutput;
		struct std_output_zaOutput* v10;
		mw_std_output_zaOutput_put(in_Str_3, r9, &v10);
		in_zaC99_2->mzaoutput = v10;
		branch_zaC99_8 = in_zaC99_2;
		branch_zaMirth_7 = in_zaMirth_1;
	} else {
		decref(MKSTR(in_Str_3));
		branch_zaC99_8 = in_zaC99_2;
		branch_zaMirth_7 = in_zaMirth_1;
	}
	*out_zaC99_5 = branch_zaC99_8;
	*out_zaMirth_4 = branch_zaMirth_7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
movq %rsi, %r12
movq %rdi, %r15
cmpb $0x1, 0x18(%rsi)
jne 0x9225a
movq 0x28(%r12), %rsi
leaq -0x30(%rbp), %r13
movq %rdx, %rdi
movq %r13, %rdx
callq 0x9229e
movq (%r13), %rax
movq %rax, 0x28(%r12)
jmp 0x92289
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x92289
decl (%rax)
jne 0x92289
leaq 0x7eed8(%rip), %rsi     # 0x111159
movq %rdx, %rdi
callq 0xd13d
movq %r12, (%r14)
movq %r15, (%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_output_zaOutput_capacityzeremaining
static INT mw_std_output_zaOutput_capacityzeremaining (struct std_output_zaOutput* in_zaOutput_1, struct std_output_zaOutput* *out_zaOutput_3) {
	struct std_output_zaOutput* v4;
	INT v5 = mw_std_output_zaOutput_capacityzetotal(in_zaOutput_1, &v4);
	INT v6 = v4->msizze;
	incref(MKINT(v6));
	INT v7 = int_sub(v5, v6);
	*out_zaOutput_3 = v4;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
leaq -0x20(%rbp), %r15
movq %r15, %rsi
callq 0x126ce
movq (%r15), %rcx
movq %rcx, 0x10(%r14)
movq (%r14), %rsi
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rcx
sete %dl
testb $0x3, %sil
setne %dil
orb %dl, %dil
jne 0x925e1
incl (%rcx)
movq %rax, %rdi
callq 0xe9fc
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_std_output_zaOutput_flushzx
static void mw_std_output_zaOutput_flushzx (struct std_output_zaOutput* in_zaOutput_1, struct std_output_zaOutput* *out_zaOutput_2) {
	ARR* r3 = in_zaOutput_1->mzabuffer;
	ARR* v4;
	void* v5 = mw_std_buffer_zaBuffer_base(r3, &v4);
	in_zaOutput_1->mzabuffer = v4;
	INT v6 = in_zaOutput_1->msizze;
	incref(MKINT(v6));
	struct std_file_zaFile* r7 = in_zaOutput_1->mzafile;
	struct std_file_zaFile* v8;
	struct std_result_Result_2 v9 = mw_std_prelude_unsafe_1_sp2(r7, v5, v6, &v8);
	in_zaOutput_1->mzafile = v8;
	decref(MK_std_result_Result_2(v9));
	INT v10 = WRAP_I63(0LL);
	INT v11 = in_zaOutput_1->msizze;
	decref(MKINT(v11));
	in_zaOutput_1->msizze = v10;
	*out_zaOutput_2 = in_zaOutput_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movq 0x10(%rdi), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x11814
movq (%r15), %rcx
movq %rcx, 0x10(%r14)
movq (%r14), %rdx
movq %rdx, %rcx
andq %r12, %rcx
sete %sil
testb $0x3, %dl
setne %dil
orb %sil, %dil
jne 0x92648
incl (%rcx)
movq 0x8(%r14), %rdi
leaq -0x28(%rbp), %r15
movq %rax, %rsi
movq %r15, %rcx
callq 0x926cf
movq (%r15), %rcx
movq %rcx, 0x8(%r14)
movq %rdx, %rcx
andq %r12, %rcx
sete %sil
testb $0x3, %dl
setne %dil
orb %sil, %dil
jne 0x92692
decl (%rcx)
jne 0x92692
shlq $0x30, %rax
orq %rdx, %rax
leaq 0x805cf(%rip), %rsi     # 0x112c59
movq %rax, %rdi
callq 0xd13d
movq (%r14), %rdi
andq %rdi, %r12
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x926b8
decl (%r12)
jne 0x926b8
leaq 0x7ed76(%rip), %rsi     # 0x111429
callq 0xd13d
movq $0x1, (%r14)
movq %r14, (%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_std_output_zaOutput_putzebyte
static void mw_std_output_zaOutput_putzebyte (enum std_byte_Byte in_Byte_1, struct std_output_zaOutput* in_zaOutput_2, struct std_output_zaOutput* *out_zaOutput_3) {
	struct std_output_zaOutput* v4;
	bool v5 = mw_std_output_zaOutput_fullzy(in_zaOutput_2, &v4);
	struct std_output_zaOutput* branch_zaOutput_6;
	if (v5) {
		struct std_output_zaOutput* v7;
		mw_std_output_zaOutput_flushzx(v4, &v7);
		branch_zaOutput_6 = v7;
	} else {
		branch_zaOutput_6 = v4;
	}
	struct std_output_zaOutput* v8;
	INT v9 = mw_std_output_zaOutput_offset(branch_zaOutput_6, &v8);
	ARR* r10 = v8->mzabuffer;
	ARR* v11;
	mw_std_buffer_zaBuffer_bytezx(r10, in_Byte_1, v9, &v11);
	v8->mzabuffer = v11;
	INT v12 = v8->msizze;
	incref(MKINT(v12));
	INT v13 = WRAP_I63(1LL);
	INT v14 = v13;
	INT v15 = int_add(v12, v14);
	INT v16 = v8->msizze;
	decref(MKINT(v16));
	v8->msizze = v15;
	*out_zaOutput_3 = v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x38(%rbp)
movl %edi, %r15d
leaq -0x30(%rbp), %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x92598
movl $0x1, %esi
movq %rax, %rdi
callq 0xe83a
movq (%r14), %r14
testl %eax, %eax
jne 0x92a61
leaq -0x30(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x925f7
movq (%r12), %r14
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movq (%r14), %r12
movq %r12, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x92a84
incl (%rax)
movq 0x10(%r14), %r13
movl %r15d, %eax
leaq 0x1(,%rax,2), %rdi
callq 0xe445
movzbl %al, %esi
leaq -0x30(%rbp), %r15
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x117b0
movq (%r15), %rax
movq %rax, 0x10(%r14)
movq (%r14), %rdi
movq %rdi, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x92acd
incl (%rax)
movl $0x3, %esi
callq 0xe50f
movq %rax, %r15
movq (%r14), %rdi
andq %rdi, %rbx
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x92afe
decl (%rbx)
jne 0x92afe
leaq 0x7e930(%rip), %rsi     # 0x111429
callq 0xd13d
movq %r15, (%r14)
movq -0x38(%rbp), %rax
movq %r14, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_table_Table_cname
static STR* mw_mirth_table_Table_cname (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Table_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_table_Table_cname, in_Table_2);
	bool v6 = mut_is_set(v5);
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	STR* branch_Str_8;
	if (v6) {
		VAL v9 = mut_get(v5);
		branch_Str_8 = value_str(v9);
		branch_zaMirth_7 = in_zaMirth_1;
	} else {
		struct mirth_mirth_zaMirth* v10;
		struct mirth_name_QName* v11 = mw_mirth_table_Table_qnamezehard(in_zaMirth_1, in_Table_2, &v10);
		struct mirth_mirth_zaMirth* v12;
		STR* v13 = mw_mirth_name_QName_mangled(v10, v11, &v12);
		incref(MKSTR(v13));
		mut_set(MKSTR(v13), v5);
		branch_Str_8 = v13;
		branch_zaMirth_7 = v12;
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_Str_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x10832ba(%rip), %rdi   # 0x1116ae0
callq 0x13c85
movq %rax, %r14
movq %rax, %rdi
callq 0x1505d
testb %al, %al
je 0x93852
movq %r14, %rdi
callq 0x13d82
movq %rax, %rdi
movq %rdx, %rsi
callq 0x9189
movq %rax, %r12
jmp 0x938b9
leaq 0x1081337(%rip), %rdi   # 0x1114b90
movq %r12, %rsi
callq 0x13c85
leaq -0x28(%rbp), %r12
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1a6db
movq (%r12), %rdi
leaq -0x28(%rbp), %rdx
movq %rax, %rsi
callq 0x93e52
movq %rax, %r12
leaq 0x7d8cc(%rip), %rsi     # 0x111159
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r12, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x938aa
incl (%rax)
movq %r12, %rdi
movq %r14, %rdx
callq 0x14766
movq -0x28(%rbp), %r15
movq %r15, (%rbx)
movq %r12, %rax
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_zaC99_c99zeline_1_sp2
static void mw_mirth_c99_zaC99_c99zeline_1_sp2 (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, "}", 1);
	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 0x1082da6(%rip), %rdx   # 0x1116b58
testq %rdx, %rdx
jne 0x93dd7
movl $0x1, %edi
callq 0xf5e4
movq %rax, %rdx
movq $0x1, 0x10(%rax)
movb $0x7d, 0x18(%rax)
movq %rax, 0x1082d81(%rip)   # 0x1116b58
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x93df5
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 0x93e3d
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_name_QName_mangled
static STR* mw_mirth_name_QName_mangled (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_name_QName* in_QName_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	STR* v5;
	STRLIT(v5, "", 0);
	struct mirth_mirth_zaMirth* v6;
	STR* v7;
	mw_mirth_name_QName_mangledzj(in_zaMirth_1, v5, in_QName_2, &v6, &v7);
	*out_zaMirth_3 = v6;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1082c7d(%rip), %rsi   # 0x1116af0
testq %rsi, %rsi
jne 0x93e91
xorl %edi, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x0, 0x10(%rax)
movq %rax, 0x1082c5f(%rip)   # 0x1116af0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x93eae
incl (%rax)
leaq -0x38(%rbp), %r12
leaq -0x30(%rbp), %r13
movq %r15, %rdi
movq %r14, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0x93ee1
movq (%r12), %rax
movq %rax, (%rbx)
movq (%r13), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_table_Field_cname
static STR* mw_mirth_table_Field_cname (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Field_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_table_Field_cname, in_Field_2);
	bool v6 = mut_is_set(v5);
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	STR* branch_Str_8;
	if (v6) {
		VAL v9 = mut_get(v5);
		branch_Str_8 = value_str(v9);
		branch_zaMirth_7 = in_zaMirth_1;
	} else {
		STR* v10;
		STRLIT(v10, "", 0);
		STR* v11;
		STRLIT(v11, "mfld_", 5);
		STR* v12;
		mw_std_str_zaStr_pushzestrzx(v11, v10, &v12);
		struct mirth_mirth_zaMirth* v13;
		struct mirth_name_QName* v14 = mw_mirth_table_Field_qnamezehard(in_zaMirth_1, in_Field_2, &v13);
		struct mirth_mirth_zaMirth* v15;
		STR* v16;
		mw_mirth_name_QName_mangledzj(v13, v12, v14, &v15, &v16);
		incref(MKSTR(v16));
		mut_set(MKSTR(v16), v5);
		branch_Str_8 = v16;
		branch_zaMirth_7 = v15;
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_Str_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x10825ec(%rip), %rdi   # 0x1116b70
callq 0x13c85
movq %rax, %r14
movq %rax, %rdi
callq 0x1505d
testb %al, %al
je 0x945b3
movq %r14, %rdi
callq 0x13d82
movq %rax, %rdi
movq %rdx, %rsi
callq 0x9189
movq %rax, %r12
jmp 0x946bb
movq %rbx, -0x38(%rbp)
movq 0x10825c2(%rip), %r13   # 0x1116b80
testq %r13, %r13
jne 0x945dc
xorl %edi, %edi
callq 0xf5e4
movq %rax, %r13
movq $0x0, 0x10(%rax)
movq %rax, 0x10825a4(%rip)   # 0x1116b80
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movq %r13, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0x945fc
incl (%rax)
movq 0x1082585(%rip), %rsi   # 0x1116b88
testq %rsi, %rsi
jne 0x9462f
movl $0x5, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x5, 0x10(%rax)
movl $0x646c666d, 0x18(%rax) # imm = 0x646C666D
movb $0x5f, 0x1c(%rax)
movq %rax, 0x1082559(%rip)   # 0x1116b88
movq %rsi, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x94645
incl (%rax)
movq %r13, %rdi
callq 0xe069
movq %rax, %r13
leaq 0x1080579(%rip), %rdi   # 0x1114bd0
movq %r12, %rsi
callq 0x13c85
leaq -0x30(%rbp), %r12
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1a6db
movq (%r12), %rdi
leaq -0x30(%rbp), %rcx
leaq -0x40(%rbp), %r15
movq %r13, %rsi
movq %rax, %rdx
movq %r15, %r8
callq 0x93ee1
movq (%r15), %r12
andq %r12, %rbx
sete %al
testb $0x3, %r12b
setne %cl
orb %al, %cl
jne 0x946a1
incl (%rbx)
movq %r12, %rdi
leaq 0x7caae(%rip), %rsi     # 0x111159
movq %r14, %rdx
callq 0x14766
movq -0x30(%rbp), %r15
movq -0x38(%rbp), %rbx
movq %r15, (%rbx)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99DataUnitRepr_MakeOfTagzy
static struct std_maybe_Maybe_1 mw_mirth_c99_C99DataUnitRepr_MakeOfTagzy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Tag_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct std_maybe_Maybe_1 v6 = mw_mirth_data_Tag_physicalzebitszy(in_zaMirth_1, in_Tag_2, &v5);
	bool v7 = mw_std_maybe_Maybe_1_has_1_sp1(v6);
	struct mirth_mirth_zaMirth* branch_zaMirth_8;
	struct std_maybe_Maybe_1 branch_Maybe_9;
	if (v7) {
		struct mirth_mirth_zaMirth* v10;
		bool v11 = mw_mirth_data_Tag_onlyzetagzy(v5, in_Tag_2, &v10);
		uint64_t branch_Tag_12;
		struct mirth_mirth_zaMirth* branch_zaMirth_13;
		STR* branch_Str_14;
		if (v11) {
			struct mirth_mirth_zaMirth* v15;
			uint64_t v16 = mw_mirth_data_Tag_data(v10, in_Tag_2, &v15);
			struct mirth_mirth_zaMirth* v17;
			STR* v18 = mw_mirth_data_Data_cname(v15, v16, &v17);
			branch_Str_14 = v18;
			branch_zaMirth_13 = v17;
			branch_Tag_12 = in_Tag_2;
		} else {
			struct mirth_mirth_zaMirth* v19;
			STR* v20 = mw_mirth_data_Tag_cname(v10, in_Tag_2, &v19);
			branch_Str_14 = v20;
			branch_zaMirth_13 = v19;
			branch_Tag_12 = in_Tag_2;
		}
		struct mirth_c99_C99DataUnitRepr* v21 = mtw_mirth_c99_C99DataUnitRepr_C99DataUnitRepr(branch_Tag_12, branch_Str_14);
		struct std_maybe_Maybe_1 v22 = mtw_std_maybe_Maybe_1_Some(MK_mirth_c99_C99DataUnitRepr(v21));
		branch_Maybe_9 = v22;
		branch_zaMirth_8 = branch_zaMirth_13;
	} else {
		struct std_maybe_Maybe_1 v23 = { .tag=std_maybe_Maybe_1_None };
		branch_Maybe_9 = v23;
		branch_zaMirth_8 = v5;
	}
	*out_zaMirth_3 = branch_zaMirth_8;
	return branch_Maybe_9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x30(%rbp), %rdx
callq 0x8ceaa
movl %eax, %edi
movq %rdx, %rsi
callq 0x8c66d
testb %al, %al
je 0x9b684
movq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rdx
movq %r14, %rsi
callq 0x9b713
testb %al, %al
je 0x9b68e
movq -0x28(%rbp), %r15
leaq 0x1079580(%rip), %rdi   # 0x1114be0
movq %r14, %rsi
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
leaq -0x38(%rbp), %r12
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x9b7b1
jmp 0x9b6a1
xorl %eax, %eax
movq -0x30(%rbp), %r12
xorl %edx, %edx
jmp 0x9b6de
movq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %r12
movq %r14, %rsi
movq %r12, %rdx
callq 0x9b876
movq %rax, %r15
movq (%r12), %r12
movl $0x1, %edi
movl $0x18, %esi
callq 0x50c0
testq %rax, %rax
je 0x9b6ee
movl $0x1, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x8(%rax)
leaq 0x776f0(%rip), %rsi     # 0x112dc1
movq %rax, %rdi
callq 0x9353
movl $0x1, %eax
movq %r12, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5d5c5(%rip), %rsi     # 0xf8cba
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_Tag_onlyzetagzy
static bool mw_mirth_data_Tag_onlyzetagzy (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_list_List_1 v8 = mw_mirth_data_Data_tags(v5, v6, &v7);
	struct std_maybe_Maybe_1 v9 = mw_std_list_List_1_singlezy(v8);
	int64_t v10 = (v9).tag;
	decref(MK_std_maybe_Maybe_1(v9));
	INT v11 = WRAP_I63(0LL);
	INT v12 = v11;
	INT v13 = i64_to_int(v10);
	bool v14 = int_eq(v13, v12);
	bool v15 = !v14;
	*out_zaMirth_3 = v7;
	return v15;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10794b5(%rip), %rdi   # 0x1114be0
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
leaq -0x18(%rbp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x51551
movl %eax, %edi
movq %rdx, %rsi
callq 0xf35d
movl %eax, %r14d
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x9b78a
decl (%rax)
jne 0x9b78a
movq %r14, %rdi
shlq $0x30, %rdi
orq %rdx, %rdi
leaq 0x75b3c(%rip), %rsi     # 0x1112c1
callq 0xd13d
leaq 0x1(,%r14,2), %rdi
movl $0x1, %esi
callq 0xe83a
testl %eax, %eax
setne %al
movq -0x18(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_Data_cname
static STR* mw_mirth_data_Data_cname (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Data_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_data_Data_cname, in_Data_2);
	bool v6 = mut_is_set(v5);
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	STR* branch_Str_8;
	if (v6) {
		VAL v9 = mut_get(v5);
		branch_Str_8 = value_str(v9);
		branch_zaMirth_7 = in_zaMirth_1;
	} else {
		struct mirth_mirth_zaMirth* v10;
		struct mirth_name_QName* v11 = mw_mirth_data_Data_qnamezehard(in_zaMirth_1, in_Data_2, &v10);
		struct mirth_mirth_zaMirth* v12;
		STR* v13 = mw_mirth_name_QName_mangled(v10, v11, &v12);
		incref(MKSTR(v13));
		mut_set(MKSTR(v13), v5);
		branch_Str_8 = v13;
		branch_zaMirth_7 = v12;
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_Str_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x107b3d0(%rip), %rdi   # 0x1116ba0
callq 0x13c85
movq %rax, %r14
movq %rax, %rdi
callq 0x1505d
testb %al, %al
je 0x9b7fc
movq %r14, %rdi
callq 0x13d82
movq %rax, %rdi
movq %rdx, %rsi
callq 0x9189
movq %rax, %r12
jmp 0x9b863
leaq 0x107937d(%rip), %rdi   # 0x1114b80
movq %r12, %rsi
callq 0x13c85
leaq -0x28(%rbp), %r12
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1a6db
movq (%r12), %rdi
leaq -0x28(%rbp), %rdx
movq %rax, %rsi
callq 0x93e52
movq %rax, %r12
leaq 0x75922(%rip), %rsi     # 0x111159
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r12, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x9b854
incl (%rax)
movq %r12, %rdi
movq %r14, %rdx
callq 0x14766
movq -0x28(%rbp), %r15
movq %r15, (%rbx)
movq %r12, %rax
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_data_Tag_cname
static STR* mw_mirth_data_Tag_cname (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Tag_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_data_Tag_cname, in_Tag_2);
	bool v6 = mut_is_set(v5);
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	STR* branch_Str_8;
	if (v6) {
		VAL v9 = mut_get(v5);
		branch_Str_8 = value_str(v9);
		branch_zaMirth_7 = in_zaMirth_1;
	} else {
		struct mirth_mirth_zaMirth* v10;
		struct mirth_name_QName* v11 = mw_mirth_data_Tag_qname(in_zaMirth_1, in_Tag_2, &v10);
		struct mirth_mirth_zaMirth* v12;
		STR* v13 = mw_mirth_name_QName_mangled(v10, v11, &v12);
		incref(MKSTR(v13));
		mut_set(MKSTR(v13), v5);
		branch_Str_8 = v13;
		branch_zaMirth_7 = v12;
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_Str_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x107b319(%rip), %rdi   # 0x1116bb0
callq 0x13c85
movq %rax, %r14
movq %rax, %rdi
callq 0x1505d
testb %al, %al
je 0x9b8c3
movq %r14, %rdi
callq 0x13d82
movq %rax, %rdi
movq %rdx, %rsi
callq 0x9189
movq %rax, %r12
jmp 0x9b91b
leaq -0x38(%rbp), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x14eea
movq (%r13), %rdi
leaq -0x30(%rbp), %rdx
movq %rax, %rsi
callq 0x93e52
movq %rax, %r12
leaq 0x7586a(%rip), %rsi     # 0x111159
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r12, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x9b90c
incl (%rax)
movq %r12, %rdi
movq %r14, %rdx
callq 0x14766
movq -0x30(%rbp), %r15
movq %r15, (%rbx)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_c99_C99DataUnitRepr_free
static void mirth_c99_C99DataUnitRepr_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_c99_C99DataUnitRepr);
	struct mirth_c99_C99DataUnitRepr* self = vself.data.ptr;
	decref(MKSTR(self->mcname));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x77484(%rip), %rax     # 0x112dc1
cmpq %rsi, %rax
jne 0x9b982
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x9b974
decl (%rax)
jne 0x9b974
leaq 0x757ea(%rip), %rsi     # 0x111159
callq 0xd13d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
leaq 0x5d373(%rip), %rsi     # 0xf8cfc
movl $0x59, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130