LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x58345
leaq -0x70(%rbp), %r14
leaq -0x68(%rbp), %rbx
leaq -0x50(%rbp), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x58345
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 0x817ab(%rip), %rsi     # 0x108f21
movq %rax, %rcx
andq %r12, %rcx
sete %dl
testb $0x3, %al
setne %dil
orb %dl, %dil
jne 0x877a4
movl -0x60(%rbp), %edi
decl (%rcx)
jne 0x877a4
shlq $0x30, %rdi
orq %rax, %rdi
callq 0xce94
leaq 0x8177d(%rip), %rsi     # 0x108f21
movq -0x48(%rbp), %rax
andq %rax, %r12
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0x877cc
movl -0x50(%rbp), %edi
decl (%r12)
jne 0x877cc
shlq $0x30, %rdi
orq %rax, %rdi
callq 0xce94
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_O2/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
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x8784a
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 0x559ce(%rip), %rsi     # 0xdd21f
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_specializzer_zaSPSynth_zaSPSynth
static void mtp_mirth_specializzer_zaSPSynth_zaSPSynth (struct mirth_specializzer_zaSPSynth* in_zaSPSynth_1, struct std_list_Nest_1* *out_SPKey_2, uint64_t *out_Word_3, struct std_list_List_1 *out_Map_4, struct mirth_arrow_Arrow* *out_zaAB_5) {
	struct mirth_specializzer_zaSPSynth v6 = *in_zaSPSynth_1;
	free(in_zaSPSynth_1);
	*out_zaAB_5 = v6.mzaAB;
	*out_Map_4 = v6.mspmap;
	*out_Word_3 = v6.mspword;
	*out_SPKey_2 = v6.mspkey;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rsi, %r12
movq (%rdi), %r13
movq 0x8(%rdi), %r14
movups 0x10(%rdi), %xmm0
movaps %xmm0, -0x50(%rbp)
movq 0x20(%rdi), %r15
callq 0x5030
movq %r15, (%rbx)
movaps -0x50(%rbp), %xmm0
movq -0x30(%rbp), %rax
movups %xmm0, (%rax)
movq -0x38(%rbp), %rax
movq %r14, (%rax)
movq %r13, (%r12)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0x80cf2(%rip), %rax     # 0x109d31
cmpq %rsi, %rax
jne 0x89084
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 0x89076
decl (%rax)
jne 0x89076
leaq 0x7f0e8(%rip), %rsi     # 0x108159
callq 0xce94
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
leaq 0x54361(%rip), %rsi     # 0xdd3ec
pushq $0x2
popq %rdi
pushq $0x56
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 $0x28, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq -0x48(%rbp), %r13
movb $0x1, %al
movq %rcx, %rdi
testb $0x1, %al
je 0x89bf0
xorl %eax, %eax
movl $0x0, %ecx
testl %edx, %edx
je 0x89baa
cmpl $0x1, %edx
jne 0x89c3c
movq %r13, %rsi
callq 0xce01
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
leaq -0x38(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x89c53
movq -0x30(%rbp), %r15
movq -0x38(%rbp), %r12
movl -0x48(%rbp), %edx
movq -0x40(%rbp), %rcx
jmp 0x89ba8
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %sil
orb %cl, %sil
jne 0x89c27
decl (%rax)
jne 0x89c27
shlq $0x30, %rdx
orq %rdi, %rdx
leaq 0x7e65a(%rip), %rsi     # 0x108279
movq %rdx, %rdi
callq 0xce94
movq %r15, (%r14)
movq %r12, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4abca(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 0x8a650
testl %eax, %eax
je 0x89cc7
cmpl $0x1, %eax
jne 0x89d0f
movq %rdx, %rdi
callq 0xd491
testb $0x1, %dl
je 0x89cc1
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %sil
testb $0x3, %al
setne %dil
orb %sil, %dil
jne 0x89cc1
decl (%rcx)
jne 0x89cc1
movq %rax, %rdi
movq %rdx, %rsi
callq 0xce94
movq -0x30(%rbp), %rax
jmp 0x89cfa
movq -0x30(%rbp), %r13
movq %r12, %rdi
callq 0x8a817
pushq $0x1
popq %rdx
leaq -0x40(%rbp), %r8
leaq -0x38(%rbp), %r12
movq %r13, %rdi
movq %r15, %rsi
movq %rax, %rcx
movq %r8, %r13
movq %r12, %r9
callq 0x89e32
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
leaq 0x4aaf7(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_need_zaNeeds_needzelabelzx
static void mw_mirth_need_zaNeeds_needzelabelzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_need_zaNeeds* in_zaNeeds_2, uint64_t in_Label_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_need_zaNeeds* *out_zaNeeds_5) {
	struct mirth_need_Need v6 = mtw_mirth_need_Need_Label(in_Label_3);
	struct mirth_mirth_zaMirth* v7;
	struct mirth_need_zaNeeds* v8;
	mw_mirth_need_zaNeeds_needzx(in_zaMirth_1, in_zaNeeds_2, v6, &v7, &v8);
	*out_zaNeeds_5 = v8;
	*out_zaMirth_4 = v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rdi
callq 0x8a860
pushq $0x4
popq %rdx
leaq -0x38(%rbp), %r8
leaq -0x30(%rbp), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rcx
movq %r8, %r15
movq %r13, %r9
callq 0x89e32
movq (%r13), %rax
movq %rax, (%rbx)
movq (%r15), %rax
movq %rax, (%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x89e13
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x53669(%rip), %rsi     # 0xdd483
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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, %r14
movq %r8, %rbx
movq %rsi, %r15
leaq -0x38(%rbp), %rax
movl %edx, %esi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x8a060
movq 0x10(%r15), %rsi
leaq -0x29(%rbp), %r13
leaq -0x48(%rbp), %r12
movq %rax, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq 0x8a19e
movq (%r12), %rdi
leaq -0x40(%rbp), %r12
movq %rax, %rsi
movq %r12, %rdx
callq 0x8a1fb
andb (%r13), %al
movzbl %al, %edi
callq 0xdbc8
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xd759
xorb $0x1, %al
movq (%r12), %rcx
movq %rcx, 0x10(%r15)
movq %r15, (%r14)
leaq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_set_zaSet_offsetzemask
static INT mw_std_set_zaSet_offsetzemask (INT in_Nat_1, ARR* in_zaSet_2, uint8_t *out_U8_4, ARR* *out_zaSet_5) {
	INT v6 = WRAP_I63(8LL);
	INT v7 = in_Nat_1;
	INT v8 = v6;
	INT v9;
	INT v10 = int_divmod(v7, v8, &v9);
	INT v11 = v9;
	INT v12 = v10;
	INT v13 = v12;
	INT v14 = v11;
	uint64_t v15 = int_to_u64(v14);
	uint8_t v16 = (uint8_t)(v15);
	uint8_t v17 = 1;
	uint64_t v18 = (uint64_t)(v17);
	uint64_t v19 = (uint64_t)(v16);
	uint64_t v20 = u64_shl(v18, v19);
	uint8_t v21 = (uint8_t)(v20);
	*out_zaSet_5 = in_zaSet_2;
	*out_U8_4 = v21;
	return v13;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
pushq $0x11
popq %rsi
leaq -0x30(%rbp), %r12
movq %r12, %rdx
callq 0x13166
movq %rax, %r13
movq (%r12), %rdi
callq 0xdc43
movzbl %al, %edx
pushq $0x1
popq %rsi
movl %eax, %ecx
shlq %cl, %rsi
xorl %eax, %eax
cmpl $0x40, %edx
cmovael %eax, %esi
movq %r15, (%r14)
movb %sil, (%rbx)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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
pushq $0x3
popq %rdx
leaq -0x30(%rbp), %r15
movq %r15, %rcx
callq 0x111af
movq (%r15), %rdi
leaq -0x28(%rbp), %r15
movq %r15, %rsi
callq 0x10d9d
movq %rax, %r12
movq %r14, %rdi
callq 0xdc43
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_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_need_Need_Word
static uint64_t mtp_mirth_need_Need_Word (struct mirth_need_Need in_Need_1) {
	struct mirth_need_Need_Word v3 = *in_Need_1.ptr.Word;
	if (!--(in_Need_1.ptr.Word->refs)) {
		free(in_Need_1.ptr.Word);
	} else {
	}
	return v3.mWord;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x8a263
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_need_Need_Block
static uint64_t mtp_mirth_need_Need_Block (struct mirth_need_Need in_Need_1) {
	struct mirth_need_Need_Block v3 = *in_Need_1.ptr.Block;
	if (!--(in_Need_1.ptr.Block->refs)) {
		free(in_Need_1.ptr.Block);
	} else {
	}
	return v3.mBlock;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x8a280
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x8a30b
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x531af(%rip), %rsi     # 0xdd4c1
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_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, %r12
movl %edx, %r15d
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movl %r8d, %r13d
movq %r9, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r9b
setne %dl
orb %cl, %dl
jne 0x8a383
decl (%rax)
jne 0x8a383
movq %r13, %rdi
shlq $0x30, %rdi
orq %r9, %rdi
leaq 0x7df43(%rip), %rsi     # 0x1082c1
callq 0xce94
movq %r13, %rdi
callq 0xd86d
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xd759
testb %al, %al
je 0x8a3c6
leaq -0x48(%rbp), %rbx
leaq -0x38(%rbp), %r13
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movl %r15d, %edx
movq %r12, %rcx
movq %rbx, %r8
movq %r13, %r9
callq 0x89b87
movq (%r13), %rdx
movq (%rbx), %r14
jmp 0x8a457
leaq -0x48(%rbp), %rcx
leaq -0x50(%rbp), %r13
movb $0x1, %al
movq %r12, %rdi
testb $0x1, %al
je 0x8a428
xorl %eax, %eax
movl $0x0, %r12d
testl %r15d, %r15d
je 0x8a3d0
cmpl $0x1, %r15d
jne 0x8a474
movq %rcx, %r15
movq %rcx, %rsi
callq 0xce01
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
leaq -0x38(%rbp), %rcx
movq %r13, %r8
callq 0x89d26
movq %r15, %rcx
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %r14
movl -0x48(%rbp), %r15d
movq -0x40(%rbp), %r12
jmp 0x8a3ce
andq %rdi, %rbx
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x8a453
decl (%rbx)
jne 0x8a453
shlq $0x30, %r15
orq %rdi, %r15
leaq 0x7de2e(%rip), %rsi     # 0x108279
movq %r15, %rdi
callq 0xce94
movq -0x30(%rbp), %rdx
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rcx
movq %rdx, (%rax)
movq %r14, (%rcx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4a392(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x8a631
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x52ebb(%rip), %rsi     # 0xdd4f3
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 $0x28, %rsp
movq %rdx, %rbx
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
leaq -0x40(%rbp), %rdx
callq 0x37ae3
movq %rax, %rdi
movl 0x58(%rax), %r15d
movq 0x60(%rax), %r12
movq %r12, %rcx
andq %r13, %rcx
sete %dl
testb $0x3, %r12b
setne %sil
orb %dl, %sil
jne 0x8a69a
incl (%rcx)
movq -0x40(%rbp), %r14
andq %r13, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x8a6bf
decl (%rax)
jne 0x8a6bf
leaq 0x7ece7(%rip), %rsi     # 0x1093a1
callq 0xce94
movl %r15d, %edi
movq %r12, %rsi
callq 0xea6b
testl %eax, %eax
je 0x8a7a5
movq %r14, -0x30(%rbp)
movq %rbx, -0x38(%rbp)
cmpl $0x1, %eax
jne 0x8a800
movq %rdx, %rdi
callq 0xd491
movq %rax, %rdi
movl 0x30(%rax), %r15d
movq 0x38(%rax), %rbx
movq %rbx, %r12
andq %r13, %r12
setne %cl
testb $0x3, %bl
sete %r14b
andb %cl, %r14b
cmpb $0x1, %r14b
jne 0x8a713
incl (%r12)
andq %r13, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x8a734
decl (%rax)
jne 0x8a734
leaq 0x7f13a(%rip), %rsi     # 0x109869
callq 0xce94
cmpl $0x9, %r15d
jne 0x8a7a9
movq %rbx, %rdi
callq 0x5351a
movq %rax, %r15
leaq -0x48(%rbp), %rdx
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x5830b
movl %eax, %r14d
andq %rdx, %r13
sete %al
testb $0x3, %dl
setne %cl
orb %al, %cl
jne 0x8a784
decl (%r13)
jne 0x8a784
movq %r14, %rdi
shlq $0x30, %rdi
orq %rdx, %rdi
leaq 0x7db42(%rip), %rsi     # 0x1082c1
callq 0xce94
movq %r14, %rdi
callq 0xd86d
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xd759
testb %al, %al
movq -0x38(%rbp), %rbx
je 0x8a7d8
xorl %eax, %eax
xorl %edx, %edx
jmp 0x8a7ea
xorl %edx, %edx
jmp 0x8a7ee
testb %r14b, %r14b
je 0x8a7ca
decl (%r12)
jne 0x8a7ca
shlq $0x30, %r15
orq %rbx, %r15
leaq 0x7ef87(%rip), %rsi     # 0x109749
movq %r15, %rdi
callq 0xce94
xorl %eax, %eax
xorl %edx, %edx
movq -0x38(%rbp), %rbx
movq -0x30(%rbp), %r14
jmp 0x8a7ee
leaq 0x7e2c1(%rip), %rsi     # 0x108aa0
movq %r15, %rdi
callq 0x8d0c
pushq $0x1
popq %rax
movq -0x48(%rbp), %r14
movq %r14, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4a006(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x8a841
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x52cdd(%rip), %rsi     # 0xdd525
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x8a88a
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x52cc6(%rip), %rsi     # 0xdd557
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_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 0x8a8e8
movq 0x28(%r12), %rsi
leaq -0x30(%rbp), %r13
movq %rdx, %rdi
movq %r13, %rdx
callq 0x8a97e
movq (%r13), %rax
movq %rax, 0x28(%r12)
jmp 0x8a917
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x8a917
decl (%rax)
jne 0x8a917
leaq 0x7d84a(%rip), %rsi     # 0x108159
movq %rdx, %rdi
callq 0xce94
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_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99_line
static void mw_mirth_c99_zaC99_line (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) {
	bool v5 = in_zaC99_2->mputzeenabled;
	struct mirth_c99_zaC99* branch_zaC99_6;
	if (v5) {
		struct std_output_zaOutput* r7 = in_zaC99_2->mzaoutput;
		struct std_output_zaOutput* v8;
		mw_std_output_zaOutput_line(r7, &v8);
		in_zaC99_2->mzaoutput = v8;
		branch_zaC99_6 = in_zaC99_2;
	} else {
		branch_zaC99_6 = in_zaC99_2;
	}
	*out_zaC99_4 = branch_zaC99_6;
	*out_zaMirth_3 = in_zaMirth_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
cmpb $0x1, 0x18(%rsi)
jne 0x8a969
movq 0x28(%r12), %rsi
pushq $0xa
popq %rdi
leaq -0x30(%rbp), %r13
movq %r13, %rdx
callq 0x8b13d
movq (%r13), %rax
movq %rax, 0x28(%r12)
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_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq -0x18(%rbp), %r14
movq %r14, %rsi
callq 0x8ad8a
movq (%r14), %r14
movq (%r14), %rsi
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rcx
sete %dl
testb $0x3, %sil
setne %dil
orb %dl, %dil
jne 0x8ac9e
incl (%rcx)
movq %rax, %rdi
callq 0xe191
movq %r14, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0x10d9d
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 0x8ad03
incl (%rcx)
movq 0x8(%r14), %rdi
leaq -0x28(%rbp), %r15
movq %rax, %rsi
movq %r15, %rcx
callq 0x8adbf
movq (%r15), %rcx
movq %rcx, 0x8(%r14)
movq %rdx, %rcx
andq %r12, %rcx
sete %sil
testb $0x3, %dl
setne %dil
orb %sil, %dil
jne 0x8ad4d
decl (%rcx)
jne 0x8ad4d
shlq $0x30, %rax
orq %rdx, %rax
leaq 0x7ef14(%rip), %rsi     # 0x109c59
movq %rax, %rdi
callq 0xce94
movq (%r14), %rdi
andq %rdi, %r12
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x8ad73
decl (%r12)
jne 0x8ad73
leaq 0x7d6bb(%rip), %rsi     # 0x108429
callq 0xce94
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_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_output_zaOutput_capacityzetotal
static INT mw_std_output_zaOutput_capacityzetotal (struct std_output_zaOutput* in_zaOutput_1, struct std_output_zaOutput* *out_zaOutput_3) {
	ARR* r4 = in_zaOutput_1->mzabuffer;
	ARR* v5;
	INT v6 = mw_std_buffer_zaBuffer_sizze(r4, &v5);
	in_zaOutput_1->mzabuffer = v5;
	*out_zaOutput_3 = in_zaOutput_1;
	return v6;
}

// 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 0x10e41
movq (%r15), %rcx
movq %rcx, 0x10(%r14)
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_output_zaOutput_offset
static INT mw_std_output_zaOutput_offset (struct std_output_zaOutput* in_zaOutput_1, struct std_output_zaOutput* *out_zaOutput_2) {
	INT v4 = in_zaOutput_1->msizze;
	incref(MKINT(v4));
	*out_zaOutput_2 = in_zaOutput_1;
	return v4;
}

// Assembly:
movq (%rdi), %rax
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %r8b
orb %dl, %r8b
jne 0x8b139
pushq %rbp
movq %rsp, %rbp
incl (%rcx)
popq %rbp
movq %rdi, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14d
leaq -0x30(%rbp), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x8ac5f
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xd759
movq (%r15), %rdi
testb %al, %al
je 0x8b181
movq %r15, %rsi
callq 0x8acb2
movq (%r15), %rdi
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
leaq -0x40(%rbp), %r15
movq %r15, %rsi
callq 0x8b114
movq %rax, %r12
movq (%r15), %r13
movq 0x10(%r13), %r15
movl %r14d, %edi
callq 0xd86d
movq %rax, %rdi
callq 0xdc43
movzbl %al, %esi
leaq -0x30(%rbp), %r14
movq %r15, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x10d3b
movq (%r14), %rax
movq %rax, 0x10(%r13)
movq (%r13), %rdi
movq %rdi, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x8b1e7
incl (%rax)
pushq $0x3
popq %rsi
callq 0xdd03
movq %rax, %r14
movq (%r13), %rdi
andq %rdi, %rbx
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x8b217
decl (%rbx)
jne 0x8b217
leaq 0x7d217(%rip), %rsi     # 0x108429
callq 0xce94
movq %r14, (%r13)
movq -0x38(%rbp), %rax
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_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x1081d30(%rip), %rdi   # 0x110dae8
callq 0x12f88
movq %rax, %r14
movq %rax, %rdi
callq 0x142de
testb %al, %al
je 0x8bde4
movq %r14, %rdi
callq 0x1307d
movq %rax, %rdi
movq %rdx, %rsi
callq 0x8b55
movq %rax, %r12
jmp 0x8be3c
leaq -0x38(%rbp), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x18029
movq (%r13), %rdi
leaq -0x30(%rbp), %rdx
movq %rax, %rsi
callq 0x8c364
movq %rax, %r12
leaq 0x7c349(%rip), %rsi     # 0x108159
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r12, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x8be2d
incl (%rax)
movq %r12, %rdi
movq %r14, %rdx
callq 0x1393b
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_O2/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 %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rdx, %rbx
leaq -0x30(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x8bc28
movq 0x1081887(%rip), %rdx   # 0x110db60
testq %rdx, %rdx
jne 0x8c2f7
leaq 0x4d6fd(%rip), %rdi     # 0xd99e2
pushq $0x1
popq %rsi
callq 0x8a21
movq %rax, %rdx
movq %rax, 0x1081869(%rip)   # 0x110db60
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x8c315
incl (%rax)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x50(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %r15, %rcx
movq %r12, %r8
callq 0x8a8a9
movq (%r15), %rdi
movq (%r12), %rsi
leaq -0x40(%rbp), %r15
leaq -0x38(%rbp), %r12
movq %r15, %rdx
movq %r12, %rcx
callq 0x8a92c
movq (%r12), %rax
movq %rax, (%r14)
movq (%r15), %rax
movq %rax, (%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0x1081773(%rip), %rsi   # 0x110daf8
testq %rsi, %rsi
jne 0x8c3a2
leaq 0x50364(%rip), %rdi     # 0xdc6f5
xorl %esi, %esi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x1081756(%rip)   # 0x110daf8
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x8c3bf
incl (%rax)
leaq -0x38(%rbp), %r12
leaq -0x30(%rbp), %r13
movq %r15, %rdi
movq %r14, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0x8c3f2
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_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99_putzebyte
static void mw_mirth_c99_zaC99_putzebyte (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99* in_zaC99_2, enum std_byte_Byte in_Byte_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_putzebyte(in_Byte_3, r9, &v10);
		in_zaC99_2->mzaoutput = v10;
		branch_zaC99_8 = in_zaC99_2;
		branch_zaMirth_7 = in_zaMirth_1;
	} else {
		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 0x8c6fe
movq 0x28(%r12), %rsi
leaq -0x30(%rbp), %r13
movl %edx, %edi
movq %r13, %rdx
callq 0x8b13d
movq (%r13), %rax
movq %rax, 0x28(%r12)
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_O2/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 $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x1081103(%rip), %rdi   # 0x110db78
callq 0x12f88
movq %rax, %r14
movq %rax, %rdi
callq 0x142de
testb %al, %al
je 0x8caa4
movq %r14, %rdi
callq 0x1307d
movq %rax, %rdi
movq %rdx, %rsi
callq 0x8b55
movq %rax, %r12
jmp 0x8cb93
movq %r14, -0x30(%rbp)
movq 0x10810d9(%rip), %r13   # 0x110db88
testq %r13, %r13
jne 0x8cacc
leaq 0x4fc3a(%rip), %rdi     # 0xdc6f5
xorl %esi, %esi
callq 0x8a21
movq %rax, %r13
movq %rax, 0x10810bc(%rip)   # 0x110db88
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
movq %r13, %rax
andq %r14, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0x8caec
incl (%rax)
movq 0x108109d(%rip), %rsi   # 0x110db90
testq %rsi, %rsi
jne 0x8cb11
leaq 0x60450(%rip), %rdi     # 0xecf4f
pushq $0x5
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x108107f(%rip)   # 0x110db90
movq %rbx, -0x38(%rbp)
movq %rsi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x8cb2b
incl (%rax)
movq %r13, %rdi
callq 0xd8b0
movq %rax, %r13
leaq -0x50(%rbp), %rbx
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2b914
movq (%rbx), %rdi
leaq -0x40(%rbp), %rcx
leaq -0x48(%rbp), %rbx
movq %r13, %rsi
movq %rax, %rdx
movq %rbx, %r8
callq 0x8c3f2
movq (%rbx), %r12
andq %r12, %r14
sete %al
testb $0x3, %r12b
setne %cl
orb %al, %cl
jne 0x8cb78
incl (%r14)
movq %r12, %rdi
leaq 0x7b5d7(%rip), %rsi     # 0x108159
movq -0x30(%rbp), %rdx
callq 0x1393b
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %rbx
movq %r15, (%rbx)
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_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 0x85854
movl %eax, %edi
movq %rdx, %rsi
callq 0x850d1
testb %al, %al
je 0x9328b
movq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rdx
movq %r14, %rsi
callq 0x9330e
testb %al, %al
je 0x93295
movq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x172b6
movq (%r15), %rdi
leaq -0x40(%rbp), %r12
movq %rax, %rsi
movq %r12, %rdx
callq 0x9339f
jmp 0x932a8
xorl %eax, %eax
movq -0x30(%rbp), %r12
xorl %edx, %edx
jmp 0x932df
movq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %r12
movq %r14, %rsi
movq %r12, %rdx
callq 0x93459
movq %rax, %r15
movq (%r12), %r12
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x932ef
movl $0x1, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x8(%rax)
leaq 0x76aed(%rip), %rsi     # 0x109dc1
movq %rax, %rdi
callq 0x8d0c
pushq $0x1
popq %rax
movq %r12, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x59c5f(%rip), %rsi     # 0xecf55
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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
leaq -0x20(%rbp), %r14
movq %r14, %rdx
callq 0x172b6
movq (%r14), %rdi
leaq -0x18(%rbp), %rdx
movq %rax, %rsi
callq 0x4ce67
movl %eax, %edi
movq %rdx, %rsi
callq 0xea6b
movl %eax, %r14d
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x9337a
decl (%rax)
jne 0x9337a
movq %r14, %rdi
shlq $0x30, %rdi
orq %rdx, %rdi
leaq 0x74f4c(%rip), %rsi     # 0x1082c1
callq 0xce94
movq %r14, %rdi
callq 0xd86d
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xd759
xorb $0x1, %al
movq -0x18(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq