LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_token_Token_lastzenamezy
static struct std_maybe_Maybe_1 mw_mirth_token_Token_lastzenamezy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct mirth_token_TokenValue v6 = mw_mirth_token_Token_value(in_zaMirth_1, in_Token_2, &v5);
	struct std_maybe_Maybe_1 v7 = mw_mirth_token_TokenValue_lastzenamezy(v6);
	*out_zaMirth_3 = v5;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
leaq -0x10(%rbp), %rdx
callq 0x252f3
cmpl $0x1c, %eax
je 0x6aabe
cmpl $0x1b, %eax
jne 0x6aae2
movq %rdx, %rdi
callq 0x253e2
jmp 0x6aace
movq %rdx, %rdi
callq 0x253ff
movq %rax, %rdi
callq 0x2a313
leaq 0x9dc23(%rip), %rsi     # 0x1086f8
movq %rax, %rdi
callq 0x8d0c
pushq $0x1
popq %rax
jmp 0x6ab1d
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rcx
sete %sil
testb $0x3, %dl
setne %dil
orb %sil, %dil
jne 0x6ab19
decl (%rcx)
jne 0x6ab19
shlq $0x30, %rax
orq %rdx, %rax
leaq 0x9e3c8(%rip), %rsi     # 0x108ed9
movq %rax, %rdi
callq 0xce94
xorl %eax, %eax
xorl %edx, %edx
movq -0x10(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mb_mirth_mirth_PropLabel_prop_1_sp16_0
static void mb_mirth_mirth_PropLabel_prop_1_sp16_0 (void) {
	uint64_t v0 = V_mirth_token_Token(pop_value());
	struct mirth_mirth_zaMirth* r1 = V_mirth_mirth_zaMirth(pop_resource());
	struct std_list_List_1 v2 = mw_mirth_var_Ctx_L0();
	struct mirth_mirth_zaMirth* v3;
	struct mirth_type_Type v4 = mw_mirth_elab_elabzesimplezetypezeatomzx(r1, v2, v0, &v3);
	push_resource(MK_mirth_mirth_zaMirth(v3));
	push_value(MK_mirth_type_Type(v4));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0xd3d6
movq %rax, %rbx
callq 0xd429
leaq -0x20(%rbp), %r14
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
movq %r14, %r8
callq 0x5b9de
movl %eax, %ebx
movq %rdx, %r15
movq (%r14), %rdi
leaq 0x9dd89(%rip), %rsi     # 0x1088f0
callq 0x883c
shlq $0x30, %rbx
orq %r15, %rbx
leaq 0x9df6f(%rip), %rsi     # 0x108ae9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd08e
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_parsezedatazeheader
static uint64_t mw_mirth_data_parsezedatazeheader (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct mirth_mirth_zaMirth* *out_zaMirth_3, uint64_t *out_SyntaxDataHeader_5) {
	struct mirth_mirth_zaMirth* v6;
	uint64_t v7 = mw_mirth_token_Token_next(in_zaMirth_1, in_Token_2, &v6);
	struct mirth_mirth_zaMirth* v8;
	struct std_maybe_Maybe_1 v9 = mw_mirth_token_Token_lastzenamezy(v6, in_Token_2, &v8);
	struct mirth_mirth_zaMirth* v10;
	bool v11 = mw_std_maybe_Maybe_1_has_1_sp15(v8, v9, &v10);
	struct mirth_mirth_zaMirth* branch_zaMirth_12;
	uint64_t branch_Token_13;
	if (v11) {
		branch_Token_13 = in_Token_2;
		branch_zaMirth_12 = v10;
	} else {
		STR* v14;
		STRLIT(v14, "Expected type name.", 19);
		mw_mirth_mirth_zaMirth_emitzefatalzeerrorzx(v10, in_Token_2, v14);
	}
	*out_SyntaxDataHeader_5 = branch_Token_13;
	*out_zaMirth_3 = branch_zaMirth_12;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
leaq -0x40(%rbp), %r13
movq %r13, %rdx
callq 0x2598b
movq %rax, %r12
movq (%r13), %rdi
leaq -0x38(%rbp), %r13
movq %rbx, %rsi
movq %r13, %rdx
callq 0x6aa98
movq (%r13), %rdi
leaq -0x30(%rbp), %rcx
movl %eax, %esi
callq 0x6ccff
testb %al, %al
je 0x6c4da
movq -0x30(%rbp), %rax
movq %rbx, (%r15)
movq %rax, (%r14)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10a0d07(%rip), %rdx   # 0x110d1e8
testq %rdx, %rdx
jne 0x6c4ff
leaq 0x6f69a(%rip), %rdi     # 0xdbb87
pushq $0x13
popq %rsi
callq 0x8a21
movq %rax, %rdx
movq %rax, 0x10a0ce9(%rip)   # 0x110d1e8
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x6c51d
incl (%rax)
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x246fe
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_parsezedatazedeclszx
static uint64_t mw_mirth_data_parsezedatazedeclszx (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct mirth_mirth_zaMirth* *out_zaMirth_3, struct std_maybe_Maybe_1 *out_Maybe_5) {
	struct mirth_mirth_zaMirth* v6;
	bool v7 = mw_mirth_token_Token_sigzedasheszy(in_zaMirth_1, in_Token_2, &v6);
	struct mirth_mirth_zaMirth* branch_zaMirth_8;
	uint64_t branch_Token_9;
	struct std_maybe_Maybe_1 branch_Maybe_10;
	if (v7) {
		struct mirth_mirth_zaMirth* v11;
		uint64_t v12 = mw_mirth_token_Token_succ(v6, in_Token_2, &v11);
		struct mirth_mirth_zaMirth* v13;
		bool v14 = mw_mirth_token_Token_argzeendzy(v11, v12, &v13);
		bool v15 = !v14;
		uint64_t v16 = v12;
		uint64_t v17 = v12;
		struct mirth_mirth_zaMirth* r18 = v13;
		bool v19 = v15;
		while (v19) {
			uint64_t v20 = v16;
			uint64_t v21 = v17;
			struct mirth_mirth_zaMirth* r22 = r18;
			struct mirth_mirth_zaMirth* v23;
			uint64_t v24 = mw_mirth_token_Token_next(r22, v21, &v23);
			struct mirth_mirth_zaMirth* v25;
			bool v26 = mw_mirth_token_Token_argzeendzy(v23, v24, &v25);
			bool v27 = !v26;
			v19 = v27;
			r18 = v25;
			v17 = v24;
			v16 = v20;
		}
		struct std_maybe_Maybe_1 v28 = mtw_std_maybe_Maybe_1_Some(MK_mirth_token_Token(v16));
		branch_Maybe_10 = v28;
		branch_Token_9 = v17;
		branch_zaMirth_8 = r18;
	} else {
		struct std_maybe_Maybe_1 v29 = { .tag=std_maybe_Maybe_1_None };
		branch_Maybe_10 = v29;
		branch_Token_9 = in_Token_2;
		branch_zaMirth_8 = v6;
	}
	*out_Maybe_5 = branch_Maybe_10;
	*out_zaMirth_3 = branch_zaMirth_8;
	return branch_Token_9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
leaq -0x58(%rbp), %rbx
movq %rbx, %rdx
callq 0x32294
movq (%rbx), %r12
testb %al, %al
je 0x6ca3b
movq %r13, -0x30(%rbp)
movq %r14, -0x38(%rbp)
xorl %r13d, %r13d
cmpq %r15, 0x109fa0f(%rip)   # 0x110c3f8
leaq 0x1(%r15), %rax
cmovaq %rax, %r13
leaq -0x50(%rbp), %rbx
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x258e2
movq (%rbx), %r12
leaq -0x48(%rbp), %rbx
leaq -0x40(%rbp), %r14
movq %r13, %r15
testb $0x1, %al
jne 0x6ca41
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2598b
movq %rax, %r15
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x258e2
movq -0x40(%rbp), %r12
jmp 0x6ca11
xorl %eax, %eax
xorl %edx, %edx
jmp 0x6ca5b
leaq 0x9c370(%rip), %rsi     # 0x108db8
movq %r13, %rdi
callq 0x8d0c
pushq $0x1
popq %rax
movq -0x38(%rbp), %r14
movq -0x30(%rbp), %r13
movl %eax, (%r13)
andl $0x0, 0x4(%r13)
movq %rdx, 0x8(%r13)
movq %r12, (%r14)
movq %r15, %rax
addq $0x38, %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_token_Token_rparenzy
static struct std_maybe_Maybe_1 mw_mirth_token_Token_rparenzy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct mirth_token_TokenValue v6 = mw_mirth_token_Token_value(in_zaMirth_1, in_Token_2, &v5);
	struct std_maybe_Maybe_1 v7 = mw_mirth_token_TokenValue_rparenzy(v6);
	*out_zaMirth_3 = v5;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
leaq -0x10(%rbp), %rdx
callq 0x252f3
cmpl $0x7, %eax
jne 0x6cab0
movq %rdx, %rdi
callq 0x2586e
leaq 0x9c315(%rip), %rsi     # 0x108db8
movq %rax, %rdi
callq 0x8d0c
pushq $0x1
popq %rax
jmp 0x6caeb
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rcx
sete %sil
testb $0x3, %dl
setne %dil
orb %sil, %dil
jne 0x6cae7
decl (%rcx)
jne 0x6cae7
shlq $0x30, %rax
orq %rdx, %rax
leaq 0x9c3fa(%rip), %rsi     # 0x108ed9
movq %rax, %rdi
callq 0xce94
xorl %eax, %eax
xorl %edx, %edx
movq -0x10(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_maybe_Maybe_1_else_1_sp6
static uint64_t mw_std_maybe_Maybe_1_else_1_sp6 (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct std_maybe_Maybe_1 in_Maybe_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	int64_t v6 = (in_Maybe_3).tag;
	decref(MK_std_maybe_Maybe_1(in_Maybe_3));
	INT v7 = WRAP_I63(0LL);
	INT v8 = v7;
	INT v9 = i64_to_int(v6);
	bool v10 = int_eq(v9, v8);
	bool v11 = !v10;
	struct mirth_mirth_zaMirth* branch_zaMirth_12;
	uint64_t branch_Token_13;
	if (v11) {
		branch_Token_13 = in_Token_2;
		branch_zaMirth_12 = in_zaMirth_1;
	} else {
		STR* v14;
		STRLIT(v14, "expected left curly brace '{'", 29);
		mw_mirth_mirth_zaMirth_emitzefatalzeerrorzx(in_zaMirth_1, in_Token_2, v14);
	}
	*out_zaMirth_4 = branch_zaMirth_12;
	return branch_Token_13;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
movl %edx, %r12d
movq %rcx, %rax
andq %r13, %rax
sete %dl
testb $0x3, %cl
setne %sil
orb %dl, %sil
jne 0x6cb4c
decl (%rax)
jne 0x6cb4c
movq %r12, %rdi
shlq $0x30, %rdi
orq %rcx, %rdi
leaq 0x9b77a(%rip), %rsi     # 0x1082c1
callq 0xce94
movq %r12, %rdi
callq 0xd86d
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xd759
testb %al, %al
jne 0x6cb78
movq %r14, (%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10a0689(%rip), %rdx   # 0x110d208
testq %rdx, %rdx
jne 0x6cb9d
leaq 0x6f0da(%rip), %rdi     # 0xdbc65
pushq $0x1d
popq %rsi
callq 0x8a21
movq %rax, %rdx
movq %rax, 0x10a066b(%rip)   # 0x110d208
andq %rdx, %r13
sete %al
testb $0x3, %dl
setne %cl
orb %al, %cl
jne 0x6cbb1
incl (%r13)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x246fe
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_maybe_Maybe_1_else_1_sp7
static uint64_t mw_std_maybe_Maybe_1_else_1_sp7 (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct std_maybe_Maybe_1 in_Maybe_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	int64_t v6 = (in_Maybe_3).tag;
	decref(MK_std_maybe_Maybe_1(in_Maybe_3));
	INT v7 = WRAP_I63(0LL);
	INT v8 = v7;
	INT v9 = i64_to_int(v6);
	bool v10 = int_eq(v9, v8);
	bool v11 = !v10;
	struct mirth_mirth_zaMirth* branch_zaMirth_12;
	uint64_t branch_Token_13;
	if (v11) {
		branch_Token_13 = in_Token_2;
		branch_zaMirth_12 = in_zaMirth_1;
	} else {
		STR* v14;
		STRLIT(v14, "expected right curly brace '}'", 30);
		mw_mirth_mirth_zaMirth_emitzefatalzeerrorzx(in_zaMirth_1, in_Token_2, v14);
	}
	*out_zaMirth_4 = branch_zaMirth_12;
	return branch_Token_13;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
movl %edx, %r12d
movq %rcx, %rax
andq %r13, %rax
sete %dl
testb $0x3, %cl
setne %sil
orb %dl, %sil
jne 0x6cc0f
decl (%rax)
jne 0x6cc0f
movq %r12, %rdi
shlq $0x30, %rdi
orq %rcx, %rdi
leaq 0x9b6b7(%rip), %rsi     # 0x1082c1
callq 0xce94
movq %r12, %rdi
callq 0xd86d
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xd759
testb %al, %al
jne 0x6cc3b
movq %r14, (%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10a05ce(%rip), %rdx   # 0x110d210
testq %rdx, %rdx
jne 0x6cc60
leaq 0x6f035(%rip), %rdi     # 0xdbc83
pushq $0x1e
popq %rsi
callq 0x8a21
movq %rax, %rdx
movq %rax, 0x10a05b0(%rip)   # 0x110d210
andq %rdx, %r13
sete %al
testb $0x3, %dl
setne %cl
orb %al, %cl
jne 0x6cc74
incl (%r13)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x246fe
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_data_SyntaxData_SyntaxData
static struct mirth_data_SyntaxData* mtw_mirth_data_SyntaxData_SyntaxData (struct std_maybe_Maybe_1 in_Maybe_1, uint64_t in_SyntaxDataHeader_2, struct std_list_List_1 in_List_3, struct std_maybe_Maybe_1 in_Maybe_4) {
	struct mirth_data_SyntaxData* v6 = calloc(1, sizeof *v6);
	ASSERT(v6);
	v6->refs = 1;
	v6->mdecls = in_Maybe_4;
	v6->mtags = in_List_3;
	v6->mheader = in_SyntaxDataHeader_2;
	v6->mdoc = in_Maybe_1;
	return v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %ecx, %r13d
movq %rdx, %r15
movq %rsi, %rbx
movl %edi, %r12d
pushq $0x1
popq %rdi
pushq $0x40
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x6cce0
leaq 0x10(%rbp), %rcx
movl $0x1, (%rax)
movups (%rcx), %xmm0
movups %xmm0, 0x30(%rax)
movl %r13d, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %r15, 0x18(%rax)
movl %r12d, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6efbb(%rip), %rsi     # 0xdbca2
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_has_1_sp15
static bool mw_std_maybe_Maybe_1_has_1_sp15 (struct mirth_mirth_zaMirth* in_zaMirth_1, struct std_maybe_Maybe_1 in_Maybe_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* branch_zaMirth_5;
	bool branch_Bool_6;
	switch ((in_Maybe_2).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v7 = mtp_std_maybe_Maybe_1_Some(in_Maybe_2);
			struct mirth_mirth_zaMirth* v8;
			bool v9 = mw_mirth_name_Name_couldzebezeconstructor(in_zaMirth_1, V_mirth_name_Name(v7), &v8);
			branch_Bool_6 = v9;
			branch_zaMirth_5 = v8;
		} break;
		case std_maybe_Maybe_1_None: {
			bool v10 = false;
			branch_Bool_6 = v10;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_3 = branch_zaMirth_5;
	return branch_Bool_6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x1, %esi
jne 0x6cd33
movq %rdx, %rdi
callq 0xd491
leaq -0x20(%rbp), %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x6cd43
movq (%r15), %r14
jmp 0x6cd35
xorl %eax, %eax
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_mirth_data_datazetagszeendzy
static bool mw_mirth_data_datazetagszeendzy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	bool v6 = mw_mirth_token_Token_argszeendzy(in_zaMirth_1, in_Token_2, &v5);
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	uint64_t branch_Token_8;
	bool branch_Bool_9;
	if (v6) {
		bool v10 = true;
		branch_Bool_9 = v10;
		branch_Token_8 = in_Token_2;
		branch_zaMirth_7 = v5;
	} else {
		struct mirth_mirth_zaMirth* v11;
		bool v12 = mw_mirth_token_Token_sigzedasheszy(v5, in_Token_2, &v11);
		branch_Bool_9 = v12;
		branch_Token_8 = in_Token_2;
		branch_zaMirth_7 = v11;
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_Bool_9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x20(%rbp), %rdx
callq 0x25100
testb %al, %al
je 0x6ce20
movb $0x1, %al
movq -0x20(%rbp), %rcx
jmp 0x6ce36
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x32294
movq (%r15), %rcx
movq %rcx, (%rbx)
addq $0x18, %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_maybe_Maybe_1_filter_1_sp21
static struct std_maybe_Maybe_1 mw_std_maybe_Maybe_1_filter_1_sp21 (struct mirth_mirth_zaMirth* in_zaMirth_1, struct std_maybe_Maybe_1 in_Maybe_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* branch_zaMirth_5;
	struct std_maybe_Maybe_1 branch_Maybe_6;
	switch ((in_Maybe_2).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v7 = mtp_std_maybe_Maybe_1_Some(in_Maybe_2);
			incref(v7);
			struct mirth_mirth_zaMirth* v8;
			bool v9 = mw_mirth_name_Name_couldzebezeconstructor(in_zaMirth_1, V_mirth_name_Name(v7), &v8);
			struct mirth_mirth_zaMirth* branch_zaMirth_10;
			struct std_maybe_Maybe_1 branch_Maybe_11;
			if (v9) {
				struct std_maybe_Maybe_1 v12 = mtw_std_maybe_Maybe_1_Some(v7);
				branch_Maybe_11 = v12;
				branch_zaMirth_10 = v8;
			} else {
				decref(v7);
				struct std_maybe_Maybe_1 v13 = { .tag=std_maybe_Maybe_1_None };
				branch_Maybe_11 = v13;
				branch_zaMirth_10 = v8;
			}
			branch_Maybe_6 = branch_Maybe_11;
			branch_zaMirth_5 = branch_zaMirth_10;
		} break;
		case std_maybe_Maybe_1_None: {
			struct std_maybe_Maybe_1 v14 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_6 = v14;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_3 = branch_zaMirth_5;
	return branch_Maybe_6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r12
cmpl $0x1, %esi
jne 0x6ceb4
movq %rdx, %rdi
callq 0xd491
movq %rax, %r15
movq %rdx, %r14
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
testb $0x1, %r14b
je 0x6ce91
movq %r15, %rax
andq %r13, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x6ce91
incl (%rax)
leaq -0x30(%rbp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x6cd43
testb %al, %al
je 0x6ceba
movq %r15, %rdi
movq %r14, %rsi
callq 0x8d0c
pushq $0x1
popq %rax
jmp 0x6cee7
xorl %eax, %eax
xorl %edx, %edx
jmp 0x6ceeb
testb $0x1, %r14b
je 0x6cee3
movq %r15, %rax
andq %r13, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x6cee3
decl (%rax)
jne 0x6cee3
movq %r15, %rdi
movq %r14, %rsi
callq 0xce94
xorl %edx, %edx
xorl %eax, %eax
movq -0x30(%rbp), %r12
movq %r12, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_token_Token_rsquarezy
static struct std_maybe_Maybe_1 mw_mirth_token_Token_rsquarezy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct mirth_token_TokenValue v6 = mw_mirth_token_Token_value(in_zaMirth_1, in_Token_2, &v5);
	struct std_maybe_Maybe_1 v7 = mw_mirth_token_TokenValue_rsquarezy(v6);
	*out_zaMirth_3 = v5;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
leaq -0x10(%rbp), %rdx
callq 0x252f3
cmpl $0x9, %eax
jne 0x6cf30
movq %rdx, %rdi
callq 0x2588b
leaq 0x9be95(%rip), %rsi     # 0x108db8
movq %rax, %rdi
callq 0x8d0c
pushq $0x1
popq %rax
jmp 0x6cf6b
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rcx
sete %sil
testb $0x3, %dl
setne %dil
orb %sil, %dil
jne 0x6cf67
decl (%rcx)
jne 0x6cf67
shlq $0x30, %rax
orq %rdx, %rax
leaq 0x9bf7a(%rip), %rsi     # 0x108ed9
movq %rax, %rdi
callq 0xce94
xorl %eax, %eax
xorl %edx, %edx
movq -0x10(%rbp), %rcx
movq %rcx, (%rbx)
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_data_SyntaxDataTag_SyntaxDataTag
static struct mirth_data_SyntaxDataTag* mtw_mirth_data_SyntaxDataTag_SyntaxDataTag (struct std_maybe_Maybe_1 in_Maybe_1, uint64_t in_Token_2, struct std_maybe_Maybe_1 in_Maybe_3, uint64_t in_Name_4, struct std_maybe_Maybe_1 in_Maybe_5) {
	struct mirth_data_SyntaxDataTag* v7 = calloc(1, sizeof *v7);
	ASSERT(v7);
	v7->refs = 1;
	v7->msigzy = in_Maybe_5;
	v7->mname = in_Name_4;
	v7->mvaluezy = in_Maybe_3;
	v7->mhead = in_Token_2;
	v7->mdoc = in_Maybe_1;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %r14
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, -0x30(%rbp)
movl %edi, %r13d
pushq $0x1
popq %rdi
pushq $0x48
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x6cfe4
leaq 0x10(%rbp), %rcx
movl $0x1, (%rax)
movups (%rcx), %xmm0
movups %xmm0, 0x38(%rax)
movq %r12, 0x30(%rax)
movl %ebx, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %r15, 0x18(%rax)
movl %r13d, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6ebd2(%rip), %rsi     # 0xdbbbd
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: mirth_data_SyntaxDataTag_free
static void mirth_data_SyntaxDataTag_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_data_SyntaxDataTag);
	struct mirth_data_SyntaxDataTag* self = vself.data.ptr;
	decref(MK_std_maybe_Maybe_1(self->mdoc));
	decref(MK_std_maybe_Maybe_1(self->mvaluezy));
	decref(MK_std_maybe_Maybe_1(self->msigzy));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x9cadd(%rip), %rax     # 0x109af1
cmpq %rsi, %rax
jne 0x6d0ca
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x10(%rdi), %rcx
leaq 0x9b28c(%rip), %r14     # 0x1082c1
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x6d05f
decl (%rax)
jne 0x6d05f
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xce94
movq 0x28(%rbx), %rcx
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x6d08d
decl (%rax)
jne 0x6d08d
movl 0x20(%rbx), %edi
shlq $0x30, %rdi
orq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0xce94
movq 0x40(%rbx), %rax
andq %rax, %r15
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x6d0b8
decl (%r15)
jne 0x6d0b8
movl 0x38(%rbx), %edi
shlq $0x30, %rdi
orq 0x40(%rbx), %rdi
movq %r14, %rsi
callq 0xce94
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
leaq 0x6eb2c(%rip), %rsi     # 0xdbbfd
pushq $0x2
popq %rdi
pushq $0x57
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_outputszeresourcezy
static bool mw_mirth_data_Tag_outputszeresourcezy (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;
	bool v8 = mw_mirth_data_Data_iszeresourcezy(v5, v6, &v7);
	*out_zaMirth_3 = v7;
	return v8;
}

// 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), %r14
movq %rax, %rsi
movq %r14, %rdx
callq 0x1e4f2
movq (%r14), %rcx
movq %rcx, (%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_mirth_token_Token_sigzestackzetokens
static struct std_list_List_1 mw_mirth_token_Token_sigzestackzetokens (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct std_list_List_1 v5 = { .tag=std_list_List_1_Nil };
	struct std_list_List_1 v6;
	mw_std_list_List_1_buildzx(v5, &v6);
	struct mirth_mirth_zaMirth* v7;
	bool v8 = mw_mirth_token_Token_sigzestackzeendzy(in_zaMirth_1, in_Token_2, &v7);
	bool v9 = !v8;
	uint64_t v10 = in_Token_2;
	struct mirth_mirth_zaMirth* r11 = v7;
	struct std_list_List_1 r12 = v6;
	bool v13 = v9;
	while (v13) {
		uint64_t v14 = v10;
		struct mirth_mirth_zaMirth* r15 = r11;
		struct std_list_List_1 r16 = r12;
		struct mirth_mirth_zaMirth* v17;
		uint64_t v18 = mw_mirth_token_Token_next(r15, v14, &v17);
		struct std_list_List_1 v19;
		mw_std_list_zaLister_1_pushzx(MK_mirth_token_Token(v14), r16, &v19);
		struct mirth_mirth_zaMirth* v20;
		bool v21 = mw_mirth_token_Token_sigzestackzeendzy(v17, v18, &v20);
		bool v22 = !v21;
		v13 = v22;
		r12 = v19;
		r11 = v20;
		v10 = v18;
	}
	struct std_list_List_1 v23 = mw_std_list_zaLister_1_donezx(r12);
	*out_zaMirth_3 = r11;
	return v23;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %rbx
movq %rdi, %r13
xorl %edi, %edi
xorl %esi, %esi
callq 0xcd32
movl %eax, %r14d
movq %rdx, %r15
leaq -0x58(%rbp), %r12
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3abf1
movq (%r12), %r12
testb $0x1, %al
jne 0x6d455
movq %r12, %rdi
movq %rbx, %rsi
leaq -0x40(%rbp), %rdx
callq 0x2598b
movq %rax, %r13
movq %rbx, %rdi
leaq 0x9b993(%rip), %rsi     # 0x108db8
movl %r14d, %edx
movq %r15, %rcx
leaq -0x50(%rbp), %r8
callq 0x8e35
movq -0x40(%rbp), %rdi
movq %r13, %rsi
leaq -0x38(%rbp), %rdx
callq 0x3abf1
movl -0x50(%rbp), %r14d
movq -0x48(%rbp), %r15
movq -0x38(%rbp), %r12
movq %r13, %rbx
jmp 0x6d405
movl %r14d, %edi
movq %r15, %rsi
callq 0xcd32
movq -0x30(%rbp), %rcx
movq %r12, (%rcx)
addq $0x38, %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_data_Tag_value
static INT mw_mirth_data_Tag_value (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_value, in_Tag_2);
	VAL v6 = mut_get(v5);
	*out_zaMirth_3 = in_zaMirth_1;
	return value_int(v6);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x109edee(%rip), %rdi   # 0x110c278
callq 0x12f88
movq %rax, %rdi
callq 0x1307d
movq %r14, (%rbx)
movq %rax, %rdi
movq %rdx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xff62
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mb_mirth_mirth_PropLabel_prop_1_sp5_0
static void mb_mirth_mirth_PropLabel_prop_1_sp5_0 (void) {
	uint64_t v0 = V_mirth_data_Tag(pop_value());
	struct mirth_mirth_zaMirth* r1 = V_mirth_mirth_zaMirth(pop_resource());
	struct mirth_mirth_zaMirth* v2;
	struct mirth_type_ArrowType* v3;
	struct std_list_List_1 v4 = mw_mirth_data_Tag_ctxzetype(r1, v0, &v2, &v3);
	struct mirth_type_ArrowType* v5 = mw_mirth_type_ArrowType_invert(v3);
	PTUP r6 = PTRMK(0,tup_new(2),0);
	((TUP*)PTRPTR(r6))->size = 2;
	((TUP*)PTRPTR(r6))->cells[1] = MK_mirth_type_ArrowType(v5);
	((TUP*)PTRPTR(r6))->cells[0] = MK_std_list_List_1(v4);
	push_resource(MK_mirth_mirth_zaMirth(v2));
	push_value(MKTUP(r6));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0xd3d6
movq %rax, %r14
callq 0xd429
leaq -0x38(%rbp), %rbx
leaq -0x30(%rbp), %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x4b4ec
movl %eax, %r14d
movq %rdx, %r12
movq (%r15), %rdi
callq 0x6f86c
movq %rax, %r15
pushq $0x2
popq %rdi
callq 0xd928
movq %rax, %r13
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r13, %rax
movw $0x2, 0x6(%rax)
leaq 0x9b13a(%rip), %rcx     # 0x108b79
movq %r15, 0x18(%rax)
movq %rcx, 0x20(%rax)
shlq $0x30, %r14
orq %r12, %r14
leaq 0x9a824(%rip), %rcx     # 0x108279
movq %r14, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq (%rbx), %rdi
leaq 0x9ae89(%rip), %rsi     # 0x1088f0
callq 0x883c
leaq 0x9a926(%rip), %rsi     # 0x108399
movq %r13, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd08e
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_mirth_zaMirth_datazeqname
static struct mirth_name_QName* mw_mirth_mirth_zaMirth_datazeqname (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Data_2, uint64_t in_Name_3, INT in_Int_4, struct mirth_mirth_zaMirth* *out_zaMirth_5) {
	struct mirth_tycon_Tycon v7 = mtw_mirth_tycon_Tycon_Data(in_Data_2);
	struct mirth_name_Namespace v8 = mtw_mirth_name_Namespace_Tycon(v7);
	struct mirth_name_QName* v9 = mtw_mirth_name_QName_QName(v8, in_Name_3, in_Int_4);
	*out_zaMirth_5 = in_zaMirth_1;
	return v9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0x17308
xorl %edi, %edi
movq %rax, %rsi
callq 0x17351
pushq $0x3
popq %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1473b
movq %r12, (%rbx)
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_data_Data_iszeunitzy
static bool mw_mirth_data_Data_iszeunitzy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Data_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct std_maybe_Maybe_1 v6 = mw_mirth_data_Data_unitzy(in_zaMirth_1, in_Data_2, &v5);
	int64_t v7 = (v6).tag;
	decref(MK_std_maybe_Maybe_1(v6));
	INT v8 = WRAP_I63(0LL);
	INT v9 = v8;
	INT v10 = i64_to_int(v7);
	bool v11 = int_eq(v10, v9);
	bool v12 = !v11;
	*out_zaMirth_3 = v5;
	return v12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r13
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
leaq 0x109e5ad(%rip), %rdi   # 0x110d2a0
callq 0x12f88
movq %rax, %r15
cmpq $0x0, 0x8(%rax)
je 0x6ed2d
movq %r13, -0x30(%rbp)
movq %r15, %rdi
callq 0x1307d
movq %rax, %r13
movq %rax, %r15
shrq $0x30, %r15
andq %rax, %r12
andq $-0x4, %r13
movb $0x1, %al
leaq 0x99599(%rip), %rbx     # 0x1082c1
jmp 0x6ee3d
leaq -0x38(%rbp), %rdx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4ce67
movl %eax, %edi
movq %rdx, %rsi
callq 0xea6b
testl %eax, %eax
movq %r14, -0x48(%rbp)
movq %r15, -0x40(%rbp)
je 0x6edb7
cmpl $0x1, %eax
jne 0x6ee85
movq %rdx, %rdi
callq 0xd491
movq %rax, %r13
movq %rdx, %rbx
testb $0x1, %bl
je 0x6ed84
movq %r13, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0x6ed84
incl (%rax)
movq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rdx
movq %r13, %rsi
callq 0x6ee9c
pushq $0x1
popq %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0xd759
testb %al, %al
je 0x6edc7
movq %r13, %rdi
movq %rbx, %rsi
callq 0x8d0c
movq %rdx, %r14
jmp 0x6edf5
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
xorl %r15d, %r15d
xorl %r14d, %r14d
jmp 0x6edfd
testb $0x1, %bl
je 0x6edef
movq %r13, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0x6edef
decl (%rax)
jne 0x6edef
movq %r13, %rdi
movq %rbx, %rsi
callq 0xce94
xorl %r15d, %r15d
xorl %r14d, %r14d
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %r15, %r13
shlq $0x30, %r13
orq %r14, %r13
leaq 0x994b3(%rip), %rbx     # 0x1082c1
andq %r14, %r12
sete %al
testb $0x3, %r14b
setne %cl
orb %al, %cl
jne 0x6ee23
incl (%r12)
movq %r13, %rdi
movq %rbx, %rsi
movq -0x40(%rbp), %rdx
callq 0x1393b
testb $0x3, %r14b
sete %al
movq -0x48(%rbp), %r14
testq %r12, %r12
sete %cl
xorb $0x1, %al
orb %cl, %al
jne 0x6ee5a
decl (%r12)
jne 0x6ee5a
movq %r13, %rdi
movq %rbx, %rsi
callq 0xce94
movq %r15, %rdi
callq 0xd86d
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xd759
xorb $0x1, %al
movq -0x30(%rbp), %rcx
movq %rcx, (%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x65981(%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_data_Tag_labelzeinputs
static struct std_list_List_1 mw_mirth_data_Tag_labelzeinputs (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_labelzeinputs, in_Tag_2);
	bool v6 = mut_is_set(v5);
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	struct std_list_List_1 branch_List_8;
	if (v6) {
		VAL v9 = mut_get(v5);
		branch_List_8 = V_std_list_List_1(v9);
		branch_zaMirth_7 = in_zaMirth_1;
	} else {
		struct mirth_mirth_zaMirth* v10;
		struct std_list_List_1 v11 = mw_mirth_data_Tag_labelzeinputszefromzesig(in_zaMirth_1, in_Tag_2, &v10);
		incref(MK_std_list_List_1(v11));
		mut_set(MK_std_list_List_1(v11), v5);
		branch_List_8 = v11;
		branch_zaMirth_7 = v10;
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_List_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r12
movq %rdi, %r15
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
leaq 0x109d0e9(%rip), %rdi   # 0x110c2c8
callq 0x12f88
movq %rax, %r14
movq %rax, %rdi
callq 0x142de
testb %al, %al
je 0x6f20a
movq %r14, %rdi
callq 0x1307d
movq %rax, %r12
andq %rax, %rbx
shrq $0x30, %r12
movq %rbx, %r13
jmp 0x6f24f
leaq -0x38(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x6f26b
movl %eax, %r12d
movq %rdx, %r13
movq %r12, %rdi
shlq $0x30, %rdi
orq %rdx, %rdi
leaq 0x99049(%rip), %rsi     # 0x108279
andq %rdx, %rbx
sete %al
testb $0x3, %r13b
setne %cl
orb %al, %cl
jne 0x6f243
incl (%rbx)
movq %r14, %rdx
callq 0x1393b
movq -0x38(%rbp), %r15
movq -0x30(%rbp), %rax
movq %r15, (%rax)
movl %r12d, %eax
movq %r13, %rdx
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_label_Label_zgStr
static STR* mw_mirth_label_Label_zgStr (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Label_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	uint64_t v6 = mw_mirth_label_Label_name(in_zaMirth_1, in_Label_2, &v5);
	struct mirth_mirth_zaMirth* v7;
	STR* v8 = mw_mirth_name_Name_zgStr(v5, v6, &v7);
	*out_zaMirth_3 = v7;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x20(%rbp), %r14
movq %r14, %rdx
callq 0x37055
movq (%r14), %rdi
leaq -0x18(%rbp), %r14
movq %rax, %rsi
movq %r14, %rdx
callq 0x1c901
movq (%r14), %rcx
movq %rcx, (%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: mb_mirth_mirth_PropLabel_prop_1_sp12_0
static void mb_mirth_mirth_PropLabel_prop_1_sp12_0 (void) {
	PTUP v0 = value_tup(pop_value());
	struct mirth_mirth_zaMirth* r1 = V_mirth_mirth_zaMirth(pop_resource());
	VAL v2 = ((TUP*)PTRPTR(v0))->cells[0];
	VAL v3 = ((TUP*)PTRPTR(v0))->cells[1];
	tup_decref_outer(v0);
	incref(v2);
	struct mirth_mirth_zaMirth* v4;
	struct std_list_List_1 v5 = mw_mirth_data_Tag_ctx(r1, V_mirth_data_Tag(v2), &v4);
	struct mirth_mirth_zaMirth* v6;
	struct std_maybe_Maybe_1 v7 = mw_mirth_data_Tag_projectzetagzefield(v4, V_mirth_label_Label(v3), V_mirth_data_Tag(v2), &v6);
	struct mirth_mirth_zaMirth* v8;
	VAL v9 = mw_std_maybe_Maybe_1_unwrap_1_sp53(v6, v7, &v8);
	struct mirth_mirth_zaMirth* v10;
	struct mirth_type_ArrowType* v11 = mw_mirth_data_datazegetzelabelzetype(v8, V_mirth_data_TagField(v9), &v10);
	PTUP r12 = PTRMK(0,tup_new(2),0);
	((TUP*)PTRPTR(r12))->size = 2;
	((TUP*)PTRPTR(r12))->cells[1] = MK_mirth_type_ArrowType(v11);
	((TUP*)PTRPTR(r12))->cells[0] = MK_std_list_List_1(v5);
	push_resource(MK_mirth_mirth_zaMirth(v10));
	push_value(MKTUP(r12));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
callq 0xd3d6
movq %rax, %r14
movq %rax, %rdi
movq %rdx, %rsi
callq 0x8a95
callq 0xd429
movq %rax, %rbx
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movq %r14, %rax
andq %r12, %rax
movq 0x8(%rax), %r15
movq 0x18(%rax), %rcx
movq %rcx, -0x30(%rbp)
movb 0x10(%rax), %r13b
movq %r14, %rdi
callq 0x8ae0
testb $0x1, %r13b
je 0x6f94f
movq %r15, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x6f94f
incl (%rax)
leaq -0x58(%rbp), %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x70f83
movl %eax, %ebx
movq %rdx, -0x38(%rbp)
movq (%r13), %rdi
leaq -0x50(%rbp), %r13
movq -0x30(%rbp), %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x70ff4
movq (%r13), %rdi
leaq -0x48(%rbp), %r15
movl %eax, %esi
movq %r15, %rcx
callq 0x710c5
movq (%r15), %rdi
leaq -0x40(%rbp), %r15
movq %rax, %rsi
movq %r15, %rdx
callq 0x537f2
movq %rax, %r14
pushq $0x2
popq %rdi
callq 0xd928
movq %rax, %r13
andq %rax, %r12
movw $0x2, 0x6(%r12)
leaq 0x991b7(%rip), %rax     # 0x108b79
movq %r14, 0x18(%r12)
movq %rax, 0x20(%r12)
shlq $0x30, %rbx
orq -0x38(%rbp), %rbx
leaq 0x9889e(%rip), %rax     # 0x108279
movq %rbx, 0x8(%r12)
movq %rax, 0x10(%r12)
movq (%r15), %rdi
leaq 0x98f01(%rip), %rsi     # 0x1088f0
callq 0x883c
leaq 0x9899e(%rip), %rsi     # 0x108399
movq %r13, %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd08e
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_Tag_ctx
static struct std_list_List_1 mw_mirth_data_Tag_ctx (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 mirth_type_ArrowType* v6;
	struct std_list_List_1 v7 = mw_mirth_data_Tag_ctxzetype(in_zaMirth_1, in_Tag_2, &v5, &v6);
	decref(MK_mirth_type_ArrowType(v6));
	*out_zaMirth_3 = v5;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %r12
movq %r12, %rcx
callq 0x4b4ec
movl %eax, %r14d
movq %rdx, %r15
movq (%r12), %rdi
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x70fda
decl (%rax)
jne 0x70fda
leaq 0x97ba4(%rip), %rsi     # 0x108b79
callq 0xce94
movq -0x28(%rbp), %rax
movq %rax, (%rbx)
movl %r14d, %eax
movq %r15, %rdx
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_mirth_data_Tag_projectzetagzefield
static struct std_maybe_Maybe_1 mw_mirth_data_Tag_projectzetagzefield (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Label_2, uint64_t in_Tag_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	struct mirth_mirth_zaMirth* v6;
	struct std_maybe_Maybe_1 v7 = mw_mirth_data_Tag_projectzeinputzelabel(in_zaMirth_1, in_Label_2, in_Tag_3, &v6);
	struct std_maybe_Maybe_1 branch_Maybe_8;
	switch ((v7).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v9 = mtp_std_maybe_Maybe_1_Some(v7);
			struct mirth_data_TagField* v10 = mtw_mirth_data_TagField_TagField(in_Tag_3, in_Label_2, V_std_either_Either_2(v9));
			struct std_maybe_Maybe_1 v11 = mtw_std_maybe_Maybe_1_Some(MK_mirth_data_TagField(v10));
			branch_Maybe_8 = v11;
		} break;
		case std_maybe_Maybe_1_None: {
			struct std_maybe_Maybe_1 v12 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_8 = v12;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_4 = v6;
	return branch_Maybe_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
leaq -0x30(%rbp), %rcx
callq 0x7114c
movl %eax, %r14d
testl %eax, %eax
je 0x71074
cmpl $0x1, %r14d
jne 0x7108f
movq %rdx, %rdi
callq 0xd491
movq %rax, %r13
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x710a6
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %r13, %rcx
shrq $0x30, %r13
movl $0x1, (%rax)
movl %r13d, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %r12, 0x10(%rax)
movq %r15, 0x8(%rax)
leaq 0x9876f(%rip), %rsi     # 0x1097d9
movq %rax, %rdi
callq 0x8d0c
jmp 0x71076
xorl %edx, %edx
movq -0x30(%rbp), %rax
movq %rax, (%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x63777(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
leaq 0x6ad96(%rip), %rsi     # 0xdbe43
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_unwrap_1_sp53
static VAL mw_std_maybe_Maybe_1_unwrap_1_sp53 (struct mirth_mirth_zaMirth* in_zaMirth_1, struct std_maybe_Maybe_1 in_Maybe_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* branch_zaMirth_5;
	VAL branch_zux1_6;
	switch ((in_Maybe_2).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v7 = mtp_std_maybe_Maybe_1_Some(in_Maybe_2);
			branch_zux1_6 = v7;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case std_maybe_Maybe_1_None: {
			STR* v8;
			STRLIT(v8, "logic error: expected field in tag.", 35);
			mw_mirth_mirth_zaMirth_fatalzeerrorzx(in_zaMirth_1, v8);
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_3 = branch_zaMirth_5;
	return branch_zux1_6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, %esi
jne 0x710e7
movq %rcx, %r14
movq %rdx, %rdi
callq 0xd491
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
testl %esi, %esi
jne 0x71135
movq 0x109c1ee(%rip), %rsi   # 0x110d2e0
testq %rsi, %rsi
jne 0x71110
leaq 0x6ad77(%rip), %rdi     # 0xdbe75
pushq $0x23
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x109c1d0(%rip)   # 0x110d2e0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x7112d
incl (%rax)
movq %rbx, %rdi
callq 0x13deb
leaq 0x636d1(%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_data_Tag_projectzeinputzelabel
static struct std_maybe_Maybe_1 mw_mirth_data_Tag_projectzeinputzelabel (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Label_2, uint64_t in_Tag_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	struct mirth_mirth_zaMirth* v6;
	struct mirth_type_ArrowType* v7 = mw_mirth_data_Tag_type(in_zaMirth_1, in_Tag_3, &v6);
	struct mirth_type_StackType v8 = v7->mdom;
	incref(MK_mirth_type_StackType(v8));
	decref(MK_mirth_type_ArrowType(v7));
	struct mirth_mirth_zaMirth* v9;
	struct std_maybe_Maybe_1 v10 = mw_mirth_type_StackType_labelzetopzy(v6, in_Label_2, v8, &v9);
	*out_zaMirth_4 = v9;
	return v10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
leaq -0x30(%rbp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x4b310
movq %rax, %rdi
movl 0x8(%rax), %r15d
movq 0x10(%rax), %r12
movq %r12, %rcx
andq %r13, %rcx
sete %dl
testb $0x3, %r12b
setne %sil
orb %dl, %sil
jne 0x7119f
incl (%rcx)
andq %r13, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x711c0
decl (%rax)
jne 0x711c0
leaq 0x979be(%rip), %rsi     # 0x108b79
callq 0xce94
movq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %r13
movq %r14, %rsi
movl %r15d, %edx
movq %r12, %rcx
movq %r13, %r8
callq 0x711ef
movq (%r13), %rcx
movq %rcx, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_maybe_Maybe_1_unwrap_1_sp52
static VAL mw_std_maybe_Maybe_1_unwrap_1_sp52 (struct mirth_mirth_zaMirth* in_zaMirth_1, VAL in_zux1_2, struct std_maybe_Maybe_1 in_Maybe_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, VAL *out_zux1_5) {
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	VAL branch_zux1_8;
	VAL branch_zux2_9;
	switch ((in_Maybe_3).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v10 = mtp_std_maybe_Maybe_1_Some(in_Maybe_3);
			branch_zux2_9 = v10;
			branch_zux1_8 = in_zux1_2;
			branch_zaMirth_7 = in_zaMirth_1;
		} break;
		case std_maybe_Maybe_1_None: {
			STR* v11;
			STRLIT(v11, "logic error: expected field in tag.", 35);
			mw_mirth_mirth_zaMirth_fatalzeerrorzx(in_zaMirth_1, v11);
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zux1_5 = branch_zux1_8;
	*out_zaMirth_4 = branch_zaMirth_7;
	return branch_zux2_9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, %ecx
jne 0x714ff
movq %r9, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x10(%rbp), %r13
movq %r8, %rdi
callq 0xd491
movq %r12, (%r13)
movq %r15, 0x8(%r13)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ecx, %ecx
jne 0x7154d
movq 0x109bdde(%rip), %rsi   # 0x110d2e8
testq %rsi, %rsi
jne 0x71528
leaq 0x6a95f(%rip), %rdi     # 0xdbe75
pushq $0x23
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x109bdc0(%rip)   # 0x110d2e8
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x71545
incl (%rax)
movq %rbx, %rdi
callq 0x13deb
leaq 0x632b9(%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_data_Tag_inputs
static struct std_list_List_1 mw_mirth_data_Tag_inputs (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_inputs, in_Tag_2);
	bool v6 = mut_is_set(v5);
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	struct std_list_List_1 branch_List_8;
	if (v6) {
		VAL v9 = mut_get(v5);
		branch_List_8 = V_std_list_List_1(v9);
		branch_zaMirth_7 = in_zaMirth_1;
	} else {
		struct mirth_mirth_zaMirth* v10;
		struct mirth_type_ArrowType* v11 = mw_mirth_data_Tag_type(in_zaMirth_1, in_Tag_2, &v10);
		struct mirth_type_StackType v12 = v11->mdom;
		incref(MK_mirth_type_StackType(v12));
		decref(MK_mirth_type_ArrowType(v11));
		struct mirth_mirth_zaMirth* v13;
		struct std_list_List_1 v14;
		struct mirth_type_StackTypeBase v15 = mw_mirth_type_StackType_splitzeparts(v10, v12, &v13, &v14);
		decref(MK_mirth_type_StackTypeBase(v15));
		incref(MK_std_list_List_1(v14));
		mut_set(MK_std_list_List_1(v14), v5);
		branch_List_8 = v14;
		branch_zaMirth_7 = v13;
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_List_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r12
movq %rdi, %r15
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
leaq 0x109a9ee(%rip), %rdi   # 0x110c298
callq 0x12f88
movq %rax, %r14
movq %rax, %rdi
callq 0x142de
testb %al, %al
je 0x718d8
movq %r14, %rdi
callq 0x1307d
movq %rax, %r12
andq %rax, %rbx
shrq $0x30, %r12
movq %rbx, %r13
jmp 0x719aa
leaq -0x40(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x4b310
movq %rax, %rdi
movl 0x8(%rax), %r15d
movq 0x10(%rax), %r12
movq %r12, %rcx
andq %rbx, %rcx
sete %dl
testb $0x3, %r12b
setne %sil
orb %dl, %sil
jne 0x7190a
incl (%rcx)
andq %rbx, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x7192b
decl (%rax)
jne 0x7192b
leaq 0x97253(%rip), %rsi     # 0x108b79
callq 0xce94
movq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rcx
leaq -0x50(%rbp), %r8
movl %r15d, %esi
movq %r12, %rdx
callq 0x32573
movq %rdx, %rcx
andq %rbx, %rcx
sete %sil
testb $0x3, %dl
setne %dil
orb %sil, %dil
jne 0x71972
decl (%rcx)
jne 0x71972
shlq $0x30, %rax
orq %rdx, %rax
leaq 0x979a7(%rip), %rsi     # 0x109311
movq %rax, %rdi
callq 0xce94
movl -0x50(%rbp), %r12d
movq -0x48(%rbp), %r13
movq %r12, %rdi
shlq $0x30, %rdi
orq %r13, %rdi
leaq 0x968ee(%rip), %rsi     # 0x108279
andq %r13, %rbx
sete %al
testb $0x3, %r13b
setne %cl
orb %al, %cl
jne 0x7199e
incl (%rbx)
movq %r14, %rdx
callq 0x1393b
movq -0x38(%rbp), %r15
movq -0x30(%rbp), %rax
movq %r15, (%rax)
movl %r12d, %eax
movq %r13, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq