LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_lexer_zaLexer_stackzepushzx
static void mw_mirth_lexer_zaLexer_stackzepushzx (struct mirth_lexer_zaLexer* in_zaLexer_1, uint64_t in_Token_2, struct mirth_lexer_zaLexer* *out_zaLexer_3) {
	struct std_list_List_1 v4 = in_zaLexer_1->mlexerzestack;
	incref(MK_std_list_List_1(v4));
	struct std_list_List_1 v5 = mw_std_list_List_1_cons(MK_mirth_token_Token(in_Token_2), v4);
	struct std_list_List_1 v6 = in_zaLexer_1->mlexerzestack;
	decref(MK_std_list_List_1(v6));
	in_zaLexer_1->mlexerzestack = v5;
	*out_zaLexer_3 = in_zaLexer_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movl 0x28(%rdi), %edx
movq 0x30(%rdi), %rcx
movq %rcx, %rsi
andq %r12, %rsi
sete %dil
testb $0x3, %cl
setne %r8b
orb %dil, %r8b
jne 0x7e01a
incl (%rsi)
leaq 0x8ad97(%rip), %rsi     # 0x108db8
movq %rax, %rdi
callq 0xcf39
movq %rdx, %r15
movq 0x30(%r14), %rax
andq %rax, %r12
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0x7e05c
movl 0x28(%r14), %edi
decl (%r12)
jne 0x7e05c
leaq 0x8a229(%rip), %rsi     # 0x108279
shlq $0x30, %rdi
orq %rax, %rdi
callq 0xce94
movl $0x1, 0x28(%r14)
movq %r15, 0x30(%r14)
movq %r14, (%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_lexer_zaLexer_lexerzelocation
static struct mirth_location_Location* mw_mirth_lexer_zaLexer_lexerzelocation (struct mirth_lexer_zaLexer* in_zaLexer_1, struct mirth_lexer_zaLexer* *out_zaLexer_2) {
	uint64_t v4 = in_zaLexer_1->mlexerzemodule;
	INT v5 = in_zaLexer_1->mlexerzerow;
	incref(MKINT(v5));
	INT v6 = in_zaLexer_1->mlexerzecol;
	incref(MKINT(v6));
	struct mirth_location_Location* v7 = mtw_mirth_location_Location_Location(v4, v5, v6);
	*out_zaLexer_2 = in_zaLexer_1;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movq (%rdi), %rdi
movq 0x8(%r14), %rsi
movq %rsi, %rcx
andq %rax, %rcx
sete %dl
testb $0x3, %sil
setne %r8b
orb %dl, %r8b
jne 0x7e0aa
incl (%rcx)
movq 0x10(%r14), %rdx
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %r8b
orb %cl, %r8b
jne 0x7e0c2
incl (%rax)
callq 0x194c3
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_maybe_Maybe_1_map_1_sp20
static struct std_maybe_Maybe_1 mw_std_maybe_Maybe_1_map_1_sp20 (struct std_maybe_Maybe_1 in_Maybe_1) {
	struct std_maybe_Maybe_1 branch_Maybe_3;
	switch ((in_Maybe_1).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v4 = mtp_std_maybe_Maybe_1_Some(in_Maybe_1);
			struct std_result_Result_2 v5 = mtw_std_result_Result_2_Ok(v4);
			struct std_maybe_Maybe_1 v6 = mtw_std_maybe_Maybe_1_Some(MK_std_result_Result_2(v5));
			branch_Maybe_3 = v6;
		} break;
		case std_maybe_Maybe_1_None: {
			struct std_maybe_Maybe_1 v7 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_3 = v7;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	return branch_Maybe_3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %edi, %edi
je 0x7e109
cmpl $0x1, %ebx
jne 0x7e114
movq %rsi, %rdi
callq 0xd491
movq %rax, %rdi
movq %rdx, %rsi
callq 0xfce4
movq %rdx, %rdi
btsq $0x30, %rdi
leaq 0x8bb57(%rip), %rsi     # 0x109c59
callq 0x8d0c
jmp 0x7e10b
xorl %edx, %edx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x566f2(%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_std_str_zaStr_dropzeslice
static STR* mw_std_str_zaStr_dropzeslice (STR* in_zaStr_1, INT in_Offset_2, STR* *out_zaStr_3) {
	INT v7 = WRAP_I63(0LL);
	incref(MKINT(in_Offset_2));
	incref(MKINT(v7));
	bool v8 = int_lt(in_Offset_2, v7);
	INT branch_Offset_9;
	if (v8) {
		decref(MKINT(in_Offset_2));
		branch_Offset_9 = v7;
	} else {
		decref(MKINT(v7));
		branch_Offset_9 = in_Offset_2;
	}
	incref(MKSTR(in_zaStr_1));
	uint64_t v10 = str_size(in_zaStr_1);
	INT v11 = u64_to_int(v10);
	STR* v12;
	STR* v13 = mw_std_str_zaStr_slice(in_zaStr_1, branch_Offset_9, v11, &v12);
	*out_zaStr_3 = v12;
	return v13;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movq %rsi, %r13
andq %rbx, %r13
setne %al
testb $0x3, %r15b
sete %r14b
andb %al, %r14b
cmpb $0x1, %r14b
jne 0x8005a
incl (%r13)
pushq $0x1
popq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x89cc
movq %r12, %rcx
andb %al, %r14b
testb %al, %al
movq %r15, %r12
cmovneq %rcx, %r12
cmpb $0x1, %r14b
movq -0x30(%rbp), %r14
jne 0x8009f
decl (%r13)
je 0x8008d
movq %rcx, %r12
jmp 0x8009f
movq %rcx, %r12
leaq 0x88392(%rip), %rsi     # 0x108429
movq %r15, %rdi
callq 0xce94
andq %r14, %rbx
sete %al
testb $0x3, %r14b
setne %cl
orb %al, %cl
jne 0x800b2
incl (%rbx)
movq %r14, %rdi
callq 0xdb65
movq %rax, %rdi
callq 0xdbc8
leaq -0x40(%rbp), %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0xe1e1
movq (%r15), %rcx
movq -0x38(%rbp), %rdx
movq %rcx, (%rdx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_lexer_zaLexer_intzesign
static INT mw_mirth_lexer_zaLexer_intzesign (STR* in_zaStr_1, struct mirth_lexer_zaLexer* in_zaLexer_2, STR* *out_zaStr_3, struct mirth_lexer_zaLexer* *out_zaLexer_4, INT *out_Int_6, INT *out_Offset_7) {
	INT v8 = WRAP_I63(0LL);
	STR* v9;
	enum std_byte_Byte v10 = mw_std_str_zaStr_bytezo(v8, in_zaStr_1, &v9);
	INT v11;
	INT v12;
	INT v13 = mw_mirth_lexer_zaLexer_bytezesignzevaluezeindex(v10, &v11, &v12);
	*out_Offset_7 = v12;
	*out_Int_6 = v11;
	*out_zaLexer_4 = in_zaLexer_2;
	*out_zaStr_3 = v9;
	return v13;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r13
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, -0x30(%rbp)
movq %rdi, %rsi
pushq $0x1
popq %rbx
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0xdc09
cmpl $0x2d, %eax
je 0x80188
cmpl $0x2b, %eax
jne 0x80190
pushq $0x3
popq %rbx
movq %rbx, %rax
jmp 0x80193
pushq $-0x1
popq %rax
pushq $0x3
popq %rbx
jmp 0x80193
pushq $0x3
popq %rax
movq -0x30(%rbp), %rcx
movq %rbx, (%r13)
movq $0x1, (%r12)
movq %rcx, (%r15)
movq -0x38(%rbp), %rcx
movq %rcx, (%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: mw_std_str_zaStr_firstzebyte
static enum std_byte_Byte mw_std_str_zaStr_firstzebyte (STR* in_zaStr_1, STR* *out_zaStr_2) {
	INT v4 = WRAP_I63(0LL);
	STR* v5;
	enum std_byte_Byte v6 = mw_std_str_zaStr_bytezo(v4, in_zaStr_1, &v5);
	*out_zaStr_2 = v5;
	return v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
pushq $0x1
popq %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rdx
callq 0xdc09
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_std_str_zaStr_secondzebyte
static enum std_byte_Byte mw_std_str_zaStr_secondzebyte (STR* in_zaStr_1, STR* *out_zaStr_2) {
	INT v4 = WRAP_I63(1LL);
	STR* v5;
	enum std_byte_Byte v6 = mw_std_str_zaStr_bytezo(v4, in_zaStr_1, &v5);
	*out_zaStr_2 = v5;
	return v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
pushq $0x3
popq %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rdx
callq 0xdc09
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_std_prelude_unsafe_1_sp16
static STR* mw_std_prelude_unsafe_1_sp16 (STR* in_zaStr_1, STR* *out_zaStr_2) {
	STR* v4;
	STR* v5 = mw_std_str_zaStr_dropzefirstzebyte(in_zaStr_1, &v4);
	*out_zaStr_2 = v4;
	return v5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
pushq $0x3
popq %rsi
leaq -0x18(%rbp), %r14
movq %r14, %rdx
callq 0x80016
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_std_str_zaStr_thirdzebyte
static enum std_byte_Byte mw_std_str_zaStr_thirdzebyte (STR* in_zaStr_1, STR* *out_zaStr_2) {
	INT v4 = WRAP_I63(2LL);
	STR* v5;
	enum std_byte_Byte v6 = mw_std_str_zaStr_bytezo(v4, in_zaStr_1, &v5);
	*out_zaStr_2 = v5;
	return v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
pushq $0x5
popq %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rdx
callq 0xdc09
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_std_str_zaStr_takezeslice
static STR* mw_std_str_zaStr_takezeslice (STR* in_zaStr_1, INT in_Sizze_2, STR* *out_zaStr_3) {
	INT v7 = WRAP_I63(0LL);
	STR* v8;
	STR* v9 = mw_std_str_zaStr_slice(in_zaStr_1, v7, in_Sizze_2, &v8);
	*out_zaStr_3 = v8;
	return v9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
pushq $0x1
popq %rsi
leaq -0x18(%rbp), %r14
movq %r14, %rcx
callq 0xe1e1
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_std_str_zaStr_lastzebyte
static enum std_byte_Byte mw_std_str_zaStr_lastzebyte (STR* in_zaStr_1, STR* *out_zaStr_3) {
	incref(MKSTR(in_zaStr_1));
	enum std_byte_Byte v4 = mw_std_prim_Str_lastzebyte(in_zaStr_1);
	*out_zaStr_3 = in_zaStr_1;
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x80f37
addl $0x2, (%rax)
movq %r14, %rdi
callq 0xdb65
movq %rax, %rdi
callq 0xdbc8
pushq $0x3
popq %rsi
movq %rax, %rdi
callq 0xe191
movq %rax, %rdi
movq %r14, %rsi
callq 0xde3b
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_prelude_unsafe_1_sp17
static STR* mw_std_prelude_unsafe_1_sp17 (STR* in_zaStr_1, STR* *out_zaStr_2) {
	STR* v4;
	STR* v5 = mw_std_str_zaStr_dropzelastzebyte(in_zaStr_1, &v4);
	*out_zaStr_2 = v4;
	return v5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x80f92
incl (%rax)
movq %r14, %rdi
callq 0xdb65
movq %rax, %rdi
callq 0xdbc8
pushq $0x3
popq %rsi
movq %rax, %rdi
callq 0xe191
leaq -0x20(%rbp), %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x80edd
movq (%r15), %rcx
movq %rcx, (%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_module_Module_start
static uint64_t mw_mirth_module_Module_start (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Module_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_module_Module_start, in_Module_2);
	VAL v6 = mut_get(v5);
	*out_zaMirth_3 = in_zaMirth_1;
	return V_mirth_token_Token(v6);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x108c71c(%rip), %rdi   # 0x110d700
callq 0x12f88
movq %rax, %rdi
callq 0x1307d
movq %r14, (%rbx)
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_modulezeimportzy
static bool mw_mirth_token_Token_modulezeimportzy (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 mirth_mirth_zaMirth* v7;
	bool v8 = mw_mirth_token_TokenValue_modulezeimportzy(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 0x252f3
movq (%r14), %r14
movl %eax, %edi
movq %rdx, %rsi
callq 0x2e190
cmpl $0x1, %eax
jne 0x81402
movq %rdx, %rdi
callq 0xd491
leaq -0x18(%rbp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x1c901
movq %rax, %r14
movq 0x108c3a4(%rip), %rsi   # 0x110d758
testq %rsi, %rsi
jne 0x813d2
leaq 0x56beb(%rip), %rdi     # 0xd7fab
pushq $0x6
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x108c386(%rip)   # 0x110d758
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x813ef
incl (%rax)
movq %r14, %rdi
callq 0xd769
testl %eax, %eax
sete %al
movq -0x18(%rbp), %r14
jmp 0x81404
xorl %eax, %eax
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_maybe_Maybe_1_map_1_sp19
static STR* mw_std_maybe_Maybe_1_map_1_sp19 (STR* in_Str_1, struct std_maybe_Maybe_1 in_Maybe_2, struct std_maybe_Maybe_1 *out_Maybe_4) {
	STR* branch_Str_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);
			incref(MKSTR(in_Str_1));
			INT v8 = WRAP_I63(1LL);
			INT v9 = v8;
			INT v10 = int_add(value_int(v7), v9);
			STR* v11 = mw_std_prim_Str_dropzeslice(v10, in_Str_1);
			STR* v12 = mw_std_prim_Str_takezeslice(value_int(v7), in_Str_1);
			struct std_maybe_Maybe_1 v13 = mtw_std_maybe_Maybe_1_Some(MKSTR(v11));
			branch_Maybe_6 = v13;
			branch_Str_5 = v12;
		} break;
		case std_maybe_Maybe_1_None: {
			struct std_maybe_Maybe_1 v14 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_6 = v14;
			branch_Str_5 = in_Str_1;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_Maybe_4 = branch_Maybe_6;
	return branch_Str_5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %esi, %r13d
movq %rdi, %r15
testl %esi, %esi
je 0x81caa
cmpl $0x1, %r13d
jne 0x81cc9
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
movq %rdx, %rdi
callq 0xd491
movq %rax, %r12
testb $0x1, %dl
je 0x81bdd
movq %r12, %rax
andq %r14, %rax
sete %cl
testb $0x3, %r12b
setne %sil
orb %cl, %sil
jne 0x81bdd
incl (%rax)
movl %r13d, -0x2c(%rbp)
movq %r15, %rax
andq %r14, %rax
sete %cl
testb $0x3, %r15b
setne %sil
orb %cl, %sil
jne 0x81bf9
incl (%rax)
movq %r12, %rdi
movq %rdx, -0x40(%rbp)
movq %rdx, %rsi
callq 0xff62
pushq $0x3
popq %rsi
movq %r12, %rdi
callq 0xdd03
leaq -0x48(%rbp), %r13
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x80016
movq %rax, -0x38(%rbp)
movq (%r13), %rdi
movq %rdi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x81c51
decl (%rax)
jne 0x81c51
leaq 0x8650d(%rip), %rsi     # 0x108159
callq 0xce94
movq %r12, %rdi
movq -0x40(%rbp), %rsi
callq 0xff62
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x80edd
movq %rax, %r15
movq (%r13), %rdi
andq %rdi, %r14
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x81c94
decl (%r14)
jne 0x81c94
leaq 0x864ca(%rip), %rsi     # 0x108159
callq 0xce94
movq -0x38(%rbp), %rdi
leaq 0x864ba(%rip), %rsi     # 0x108159
callq 0x8d0c
movl -0x2c(%rbp), %r13d
jmp 0x81cac
xorl %edx, %edx
movl %r13d, (%rbx)
andl $0x0, 0x4(%rbx)
movq %rdx, 0x8(%rbx)
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x52b3d(%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: mirth_arrow_Atom_set_op
static struct mirth_arrow_Atom* mirth_arrow_Atom_set_op(struct mirth_arrow_Atom* self, struct mirth_arrow_Op x) {
	if (self->refs > 1) {
		struct mirth_arrow_Atom* self2 = calloc(1, sizeof * self2);
		ASSERT(self2); memcpy(self2, self, sizeof * self2);
		incref(MK_mirth_arrow_Home(self2->mhome));
		incref(MK_std_list_List_1(self2->mctx));
		self2->mop = x;
		incref(MK_std_list_List_1(self2->margs));
		incref(MK_mirth_type_StackType(self2->mdom));
		incref(MK_mirth_type_StackType(self2->mcod));
		incref(MK_std_list_List_1(self2->msubst));
		self->refs--;
		return self2;
	}
	decref(MK_mirth_arrow_Op(self->mop));
	self->mop = x;
	return self;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0x2, (%rdi)
jb 0x839c3
pushq $0x1
popq %rdi
movl $0x80, %esi
callq 0x50c0
testq %rax, %rax
je 0x83a12
movabsq $0xfffffffffffc, %rdx   # imm = 0xFFFFFFFFFFFC
pushq $0x10
popq %rcx
movq %rax, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x10(%rax), %rsi
movq %rsi, %rcx
andq %rdx, %rcx
sete %dil
testb $0x3, %sil
setne %sil
orb %dil, %sil
jne 0x83928
incl (%rcx)
movq 0x28(%rax), %rsi
movq %rsi, %rcx
andq %rdx, %rcx
sete %dil
testb $0x3, %sil
setne %sil
orb %dil, %sil
jne 0x83945
incl (%rcx)
movl %r15d, 0x30(%rax)
movq %r14, 0x38(%rax)
movq 0x48(%rax), %rsi
movq %rsi, %rcx
andq %rdx, %rcx
sete %dil
testb $0x3, %sil
setne %sil
orb %dil, %sil
jne 0x8396a
incl (%rcx)
movq 0x58(%rax), %rsi
movq %rsi, %rcx
andq %rdx, %rcx
sete %dil
testb $0x3, %sil
setne %sil
orb %dil, %sil
jne 0x83987
incl (%rcx)
movq 0x68(%rax), %rsi
movq %rsi, %rcx
andq %rdx, %rcx
sete %dil
testb $0x3, %sil
setne %sil
orb %dil, %sil
jne 0x839a4
incl (%rcx)
movq 0x78(%rax), %rcx
andq %rcx, %rdx
sete %sil
testb $0x3, %cl
setne %cl
orb %sil, %cl
jne 0x839bc
incl (%rdx)
decl (%rbx)
movq %rax, %rbx
jmp 0x83a04
movq 0x38(%rbx), %rcx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rcx, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x839fc
decl (%rax)
jne 0x839fc
leaq 0x85d5d(%rip), %rsi     # 0x109749
movl 0x30(%rbx), %edi
shlq $0x30, %rdi
orq 0x38(%rbx), %rdi
callq 0xce94
movl %r15d, 0x30(%rbx)
movq %r14, 0x38(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x598d4(%rip), %rsi     # 0xdd2ed
pushq $0x2
popq %rdi
pushq $0x33
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_specializzer_zaSPCheck_pushzecheckzeblockzx
static void mw_mirth_specializzer_zaSPCheck_pushzecheckzeblockzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct std_list_List_1 in_zaSPCheck_2, uint64_t in_Block_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct std_list_List_1 *out_zaSPCheck_5) {
	struct mirth_specializzer_SPCheckItem v6 = mtw_mirth_specializzer_SPCheckItem_Block(in_Block_3);
	struct mirth_mirth_zaMirth* v7;
	struct std_list_List_1 v8;
	mw_mirth_specializzer_zaSPCheck_pushzecheckzeitemzx(in_zaMirth_1, in_zaSPCheck_2, v6, &v7, &v8);
	*out_zaSPCheck_5 = v8;
	*out_zaMirth_4 = v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x83ab7
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
leaq -0x50(%rbp), %r14
movq %r14, (%rsp)
pushq $0x1
popq %rcx
leaq -0x40(%rbp), %rbx
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movq %rax, %r8
movq %rbx, %r9
callq 0x83d13
movups (%r14), %xmm0
movq -0x30(%rbp), %rax
movups %xmm0, (%rax)
movq (%rbx), %rax
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x59897(%rip), %rsi     # 0xdd355
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_list_List_1_for_1_sp91
static void mw_std_list_List_1_for_1_sp91 (struct mirth_mirth_zaMirth* in_zaMirth_1, struct std_list_List_1 in_zaSPCheck_2, struct std_list_List_1 in_List_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct std_list_List_1 *out_zaSPCheck_5) {
	bool v6 = true;
	struct mirth_mirth_zaMirth* r7 = in_zaMirth_1;
	struct std_list_List_1 r8 = in_zaSPCheck_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 std_list_List_1 r13 = r8;
		struct std_list_List_1 v14 = v9;
		bool v15 = v10;
		struct mirth_mirth_zaMirth* branch_zaMirth_16;
		struct std_list_List_1 branch_zaSPCheck_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 std_list_List_1 v23;
				mw_mirth_specializzer_zaSPCheck_checkzeargzx(r12, r13, V_mirth_arrow_Block(v21), &v22, &v23);
				bool v24 = true;
				branch_Bool_19 = v24;
				branch_List_18 = v20;
				branch_zaSPCheck_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_zaSPCheck_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_zaSPCheck_17;
		r7 = branch_zaMirth_16;
	}
	decref(MK_std_list_List_1(v9));
	*out_zaSPCheck_5 = r8;
	*out_zaMirth_4 = r7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, -0x30(%rbp)
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
movq 0x10(%rbp), %r13
leaq -0x58(%rbp), %rdx
movb $0x1, %al
movq %r8, %rdi
testb $0x1, %al
je 0x83b59
xorl %eax, %eax
movl $0x0, %r8d
testl %ecx, %ecx
je 0x83afe
cmpl $0x1, %ecx
jne 0x83bb2
movq %rdx, %rbx
movq %rdx, %rsi
callq 0xce01
movq %r12, %rdi
movl %r15d, %esi
movq %r14, %rdx
movq %rax, %rcx
leaq -0x48(%rbp), %r8
leaq -0x40(%rbp), %r9
callq 0x83bc9
movq %rbx, %rdx
movl -0x58(%rbp), %ecx
movq -0x50(%rbp), %r8
movl -0x40(%rbp), %r15d
movl -0x3c(%rbp), %ebx
movq -0x38(%rbp), %r14
movq -0x48(%rbp), %r12
jmp 0x83afc
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %dl
testb $0x3, %dil
setne %sil
orb %dl, %sil
jne 0x83b90
decl (%rax)
jne 0x83b90
shlq $0x30, %rcx
orq %rdi, %rcx
leaq 0x846f1(%rip), %rsi     # 0x108279
movq %rcx, %rdi
callq 0xce94
movl %r15d, (%r13)
movl %ebx, 0x4(%r13)
movq %r14, 0x8(%r13)
movq -0x30(%rbp), %rax
movq %r12, (%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x50c54(%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_specializzer_zaSPCheck_checkzeargzx
static void mw_mirth_specializzer_zaSPCheck_checkzeargzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct std_list_List_1 in_zaSPCheck_2, uint64_t in_Arg_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct std_list_List_1 *out_zaSPCheck_5) {
	struct mirth_mirth_zaMirth* v6;
	struct std_list_List_1 v7;
	mw_mirth_specializzer_zaSPCheck_pushzecheckzeblockzx(in_zaMirth_1, in_zaSPCheck_2, in_Arg_3, &v6, &v7);
	*out_zaSPCheck_5 = v7;
	*out_zaMirth_4 = v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r9, %rbx
movq %r8, %r14
leaq -0x28(%rbp), %r15
leaq -0x38(%rbp), %r12
movq %r15, %r8
movq %r12, %r9
callq 0x83a31
movups (%r12), %xmm0
movups %xmm0, (%rbx)
movq (%r15), %rax
movq %rax, (%r14)
addq $0x20, %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_specializzer_zaSPCheck_pushzecheckzewordzx
static void mw_mirth_specializzer_zaSPCheck_pushzecheckzewordzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct std_list_List_1 in_zaSPCheck_2, uint64_t in_Word_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct std_list_List_1 *out_zaSPCheck_5) {
	struct mirth_specializzer_SPCheckItem v6 = mtw_mirth_specializzer_SPCheckItem_Word(in_Word_3);
	struct mirth_mirth_zaMirth* v7;
	struct std_list_List_1 v8;
	mw_mirth_specializzer_zaSPCheck_pushzecheckzeitemzx(in_zaMirth_1, in_zaSPCheck_2, v6, &v7, &v8);
	*out_zaSPCheck_5 = v8;
	*out_zaMirth_4 = v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x83c91
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
leaq -0x50(%rbp), %r14
movq %r14, (%rsp)
leaq -0x40(%rbp), %rbx
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
xorl %ecx, %ecx
movq %rax, %r8
movq %rbx, %r9
callq 0x83d13
movups (%r14), %xmm0
movq -0x30(%rbp), %rax
movups %xmm0, (%rax)
movq (%rbx), %rax
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x59499(%rip), %rsi     # 0xdd131
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_var_Var_iszephysicalzy
static bool mw_mirth_var_Var_iszephysicalzy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Var_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct mirth_type_Type v6 = mw_mirth_var_Var_type(in_zaMirth_1, in_Var_2, &v5);
	struct mirth_mirth_zaMirth* v7;
	bool v8 = mw_mirth_type_Type_iszephysicalzy(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 0x32ea4
movq (%r14), %rdi
leaq -0x18(%rbp), %r14
movl %eax, %esi
movq %r14, %rcx
callq 0x84ca7
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_specializzer_zaSPCheck_pushzecheckzeitemzx
static void mw_mirth_specializzer_zaSPCheck_pushzecheckzeitemzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct std_list_List_1 in_zaSPCheck_2, struct mirth_specializzer_SPCheckItem in_SPCheckItem_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct std_list_List_1 *out_zaSPCheck_5) {
	incref(MK_mirth_specializzer_SPCheckItem(in_SPCheckItem_3));
	struct mirth_mirth_zaMirth* v6;
	struct std_list_List_1 v7;
	bool v8 = mw_mirth_specializzer_zaSPCheck_checkedzx(in_zaMirth_1, in_zaSPCheck_2, in_SPCheckItem_3, &v6, &v7);
	struct mirth_mirth_zaMirth* branch_zaMirth_9;
	struct std_list_List_1 branch_zaSPCheck_10;
	if (v8) {
		decref(MK_mirth_specializzer_SPCheckItem(in_SPCheckItem_3));
		branch_zaSPCheck_10 = v7;
		branch_zaMirth_9 = v6;
	} else {
		incref(MK_std_list_List_1(v7));
		struct std_list_List_1 v11 = mw_std_list_List_1_cons(MK_mirth_specializzer_SPCheckItem(in_SPCheckItem_3), v7);
		decref(MK_std_list_List_1(v7));
		branch_zaSPCheck_10 = v11;
		branch_zaMirth_9 = v6;
	}
	*out_zaSPCheck_5 = branch_zaSPCheck_10;
	*out_zaMirth_4 = branch_zaMirth_9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, -0x48(%rbp)
movq %r8, %rbx
movq %rdx, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdi, -0x40(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movl %ecx, %r13d
movq %r8, %r12
andq %rax, %r12
setne %al
testb $0x3, %bl
sete %r15b
andb %al, %r15b
cmpb $0x1, %r15b
jne 0x83d61
incl (%r12)
shlq $0x30, %r13
movq %rbx, %rdi
testl %ecx, %ecx
je 0x83d7a
callq 0x83f1f
leaq 0x1089a88(%rip), %rdi   # 0x110d800
jmp 0x83d86
callq 0x83f02
leaq 0x1089a6a(%rip), %rdi   # 0x110d7f0
movq %rax, %rsi
callq 0x12f88
movq %rax, %r14
orq %rbx, %r13
movq %rax, %rdi
callq 0x141e4
cmpl $0x1, %eax
jne 0x83df0
movq %rdx, %rdi
callq 0xd491
movq %rax, %rdi
movq %rdx, %rsi
callq 0x1e591
movl %eax, %ebx
leaq 0x84f6b(%rip), %rsi     # 0x108d28
pushq $0x1
popq %rdi
movq %r14, %rdx
callq 0x1393b
testb %bl, %bl
movq -0x38(%rbp), %rbx
je 0x83e06
testb %r15b, %r15b
je 0x83dea
decl (%r12)
jne 0x83dea
movq %r13, %rdi
leaq 0x85f04(%rip), %rsi     # 0x109ce9
callq 0xce94
movq -0x30(%rbp), %rax
jmp 0x83e6d
leaq 0x84f31(%rip), %rsi     # 0x108d28
pushq $0x1
popq %rdi
movq %r14, %rdx
callq 0x1393b
movq -0x38(%rbp), %rbx
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
andq %rbx, %r14
setne %al
testb $0x3, %bl
sete %r15b
andb %al, %r15b
cmpb $0x1, %r15b
jne 0x83e29
incl (%r14)
movq %r13, %rdi
leaq 0x85eb6(%rip), %rsi     # 0x109ce9
movq -0x30(%rbp), %r12
movl %r12d, %edx
movq %rbx, %rcx
callq 0xcf39
movq %rdx, %rbx
pushq $0x1
popq %r13
testb %r15b, %r15b
je 0x83e6a
decl (%r14)
jne 0x83e6a
shlq $0x30, %r12
orq -0x38(%rbp), %r12
leaq 0x84417(%rip), %rsi     # 0x108279
movq %r12, %rdi
callq 0xce94
movl %r13d, %eax
movq 0x10(%rbp), %rcx
movl %eax, (%rcx)
movq %rbx, 0x8(%rcx)
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%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: mtp_mirth_specializzer_SPCheckItem_Word
static uint64_t mtp_mirth_specializzer_SPCheckItem_Word (struct mirth_specializzer_SPCheckItem in_SPCheckItem_1) {
	struct mirth_specializzer_SPCheckItem_Word v3 = *in_SPCheckItem_1.ptr.Word;
	if (!--(in_SPCheckItem_1.ptr.Word->refs)) {
		free(in_SPCheckItem_1.ptr.Word);
	} else {
	}
	return v3.mWord;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x83f15
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_specializzer_SPCheckItem_Block
static uint64_t mtp_mirth_specializzer_SPCheckItem_Block (struct mirth_specializzer_SPCheckItem in_SPCheckItem_1) {
	struct mirth_specializzer_SPCheckItem_Block v3 = *in_SPCheckItem_1.ptr.Block;
	if (!--(in_SPCheckItem_1.ptr.Block->refs)) {
		free(in_SPCheckItem_1.ptr.Block);
	} else {
	}
	return v3.mBlock;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x83f32
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: mw_mirth_arrow_Block_freezevars
static struct std_list_List_1 mw_mirth_arrow_Block_freezevars (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Block_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_arrow_Block_freezevars, in_Block_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_arrow_Arrow* v11 = mw_mirth_arrow_Block_arrow(in_zaMirth_1, in_Block_2, &v10);
		struct mirth_mirth_zaMirth* v12;
		struct std_list_List_1 v13 = mw_mirth_arrow_Arrow_freezevars(v10, v11, &v12);
		incref(MK_std_list_List_1(v13));
		mut_set(MK_std_list_List_1(v13), v5);
		branch_List_8 = v13;
		branch_zaMirth_7 = v12;
	}
	*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, %r15
movq %rdi, %r12
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
leaq 0x10898a8(%rip), %rdi   # 0x110d810
callq 0x12f88
movq %rax, %r14
cmpq $0x0, 0x8(%rax)
je 0x83f8e
movq %r14, %rdi
callq 0x1307d
movq %rax, %r15
andq %rax, %rbx
shrq $0x30, %r15
movq %rbx, %r13
jmp 0x83fe6
leaq -0x40(%rbp), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x37ae3
movq (%r13), %rdi
leaq -0x38(%rbp), %rdx
movq %rax, %rsi
callq 0x84002
movl %eax, %r15d
movq %rdx, %r13
movq %r15, %rdi
shlq $0x30, %rdi
orq %rdx, %rdi
leaq 0x842b2(%rip), %rsi     # 0x108279
andq %rdx, %rbx
sete %al
testb $0x3, %r13b
setne %cl
orb %al, %cl
jne 0x83fda
incl (%rbx)
movq %r14, %rdx
callq 0x1393b
movq -0x38(%rbp), %r12
movq -0x30(%rbp), %rax
movq %r12, (%rax)
movl %r15d, %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_std_list_List_1_union_sp1
static struct std_list_List_1 mw_std_list_List_1_union_sp1 (struct std_list_List_1 in_List_1, struct std_list_List_1 in_List_2) {
	incref(MK_std_list_List_1(in_List_1));
	struct std_list_List_1 v4 = mw_std_list_List_1_difference_sp1(in_List_2, in_List_1);
	struct std_list_List_1 v5 = mw_std_list_List_1_cat(in_List_1, v4);
	return v5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %sil
testb $0x3, %bl
setne %dil
orb %sil, %dil
jne 0x84888
incl (%rax)
movl %edx, %edi
movq %rcx, %rsi
movl %r14d, %edx
movq %rbx, %rcx
callq 0x848ac
movq %rdx, %rcx
movl %r14d, %edi
movq %rbx, %rsi
movl %eax, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x26383
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_maybe_Maybe_1_has_1_sp1
static bool mw_std_maybe_Maybe_1_has_1_sp1 (struct std_maybe_Maybe_1 in_Maybe_1) {
	bool branch_Bool_3;
	switch ((in_Maybe_1).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v4 = mtp_std_maybe_Maybe_1_Some(in_Maybe_1);
			INT v5 = WRAP_I63(0LL);
			INT v6 = v5;
			INT v7 = value_nat(v4);
			bool v8 = int_eq(v7, v6);
			branch_Bool_3 = v8;
		} break;
		case std_maybe_Maybe_1_None: {
			bool v9 = false;
			branch_Bool_3 = v9;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	return branch_Bool_3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %edi, %edi
je 0x85107
cmpl $0x1, %edi
jne 0x85110
movq %rsi, %rdi
callq 0xd491
movq %rax, %rbx
movq %rax, %rdi
movq %rdx, %rsi
callq 0x2fb0c
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd759
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4f6f6(%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_type_MetaVar_expandzeif_2_sp4
static struct std_maybe_Maybe_1 mw_mirth_type_MetaVar_expandzeif_2_sp4 (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_MetaVar_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct std_maybe_Maybe_1 v6 = mw_mirth_type_MetaVar_typezy(in_zaMirth_1, in_MetaVar_2, &v5);
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	struct std_maybe_Maybe_1 branch_Maybe_8;
	switch ((v6).tag) {
		case std_maybe_Maybe_1_None: {
			struct std_maybe_Maybe_1 v9 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_8 = v9;
			branch_zaMirth_7 = v5;
		} break;
		case std_maybe_Maybe_1_Some: {
			VAL v10 = mtp_std_maybe_Maybe_1_Some(v6);
			struct mirth_mirth_zaMirth* v11;
			struct mirth_type_Type v12 = mw_mirth_type_Type_expand(v5, V_mirth_type_Type(v10), &v11);
			incref(MK_mirth_type_Type(v12));
			struct std_maybe_Maybe_1 v13 = mtw_std_maybe_Maybe_1_Some(MK_mirth_type_Type(v12));
			struct mirth_mirth_zaMirth* v14;
			mw_mirth_type_MetaVar_typezyzx(v11, v13, in_MetaVar_2, &v14);
			struct mirth_mirth_zaMirth* v15;
			struct std_maybe_Maybe_1 v16 = mw_mirth_type_Type_physicalzebitszy(v14, v12, &v15);
			branch_Maybe_8 = v16;
			branch_zaMirth_7 = v15;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_Maybe_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, %r14
leaq -0x30(%rbp), %rdx
callq 0x2aadc
cmpl $0x1, %eax
je 0x85161
testl %eax, %eax
jne 0x851ff
xorl %eax, %eax
movq -0x30(%rbp), %rcx
xorl %edx, %edx
jmp 0x851ed
movq %rdx, %rdi
callq 0xd491
movq -0x30(%rbp), %rdi
movq %rax, %rsi
shrq $0x30, %rsi
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
andq %r13, %rax
leaq -0x38(%rbp), %rcx
movq %rax, %rdx
callq 0x2ab4b
movl %eax, %r12d
movq %rdx, %r15
movq %r12, %rdi
shlq $0x30, %rdi
orq %rdx, %rdi
leaq 0x83945(%rip), %rsi     # 0x108ae9
andq %rdx, %r13
sete %al
testb $0x3, %r15b
setne %cl
orb %al, %cl
jne 0x851b9
incl (%r13)
callq 0x8d0c
movq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %r13
movq %rdx, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x2ab8f
movq (%r13), %rdi
leaq -0x40(%rbp), %r14
movl %r12d, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x84e20
movq (%r14), %rcx
movq %rcx, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4f607(%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_physicalzebitszy
static struct std_maybe_Maybe_1 mw_mirth_data_Tag_physicalzebitszy (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_physicalzebitszy, in_Tag_2);
	bool v6 = mut_is_set(v5);
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	struct std_maybe_Maybe_1 branch_Maybe_8;
	if (v6) {
		VAL v9 = mut_get(v5);
		branch_Maybe_8 = V_std_maybe_Maybe_1(v9);
		branch_zaMirth_7 = in_zaMirth_1;
	} else {
		struct std_maybe_Maybe_1 v10 = { .tag=std_maybe_Maybe_1_None };
		struct mirth_mirth_zaMirth* v11;
		mw_mirth_data_Tag_physicalzebitszyzx(in_zaMirth_1, v10, in_Tag_2, &v11);
		struct mirth_mirth_zaMirth* v12;
		struct mirth_type_ArrowType* v13 = mw_mirth_data_Tag_type(v11, in_Tag_2, &v12);
		struct mirth_type_StackType v14 = v13->mdom;
		incref(MK_mirth_type_StackType(v14));
		decref(MK_mirth_type_ArrowType(v13));
		struct mirth_mirth_zaMirth* v15;
		struct std_maybe_Maybe_1 v16 = mw_mirth_type_StackType_physicalzebitszy(v12, v14, &v15);
		incref(MK_std_maybe_Maybe_1(v16));
		mut_set(MK_std_maybe_Maybe_1(v16), v5);
		branch_Maybe_8 = v16;
		branch_zaMirth_7 = v15;
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_Maybe_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, %r13
movq %rdi, %r12
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
leaq 0x1087fb8(%rip), %rdi   # 0x110d838
callq 0x12f88
movq %rax, %r14
movq %rax, %rdi
callq 0x142de
testb %al, %al
je 0x858ae
movq %r14, %rdi
callq 0x1307d
movq %rax, %r13
andq %rax, %rbx
shrq $0x30, %r13
movq %rbx, %r15
jmp 0x8596a
leaq 0x1087f83(%rip), %rdi   # 0x110d838
movq %r13, %rsi
callq 0x12f88
leaq 0x829fd(%rip), %rsi     # 0x1082c1
xorl %edi, %edi
movq %rax, %rdx
callq 0x1393b
leaq -0x40(%rbp), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x4b310
movq %rax, %rdi
movl 0x8(%rax), %r12d
movq 0x10(%rax), %r13
movq %r13, %rcx
andq %rbx, %rcx
sete %dl
testb $0x3, %r13b
setne %sil
orb %dl, %sil
jne 0x85900
incl (%rcx)
andq %rbx, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x85921
decl (%rax)
jne 0x85921
leaq 0x8325d(%rip), %rsi     # 0x108b79
callq 0xce94
movq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rcx
movl %r12d, %esi
movq %r13, %rdx
callq 0x856a4
movl %eax, %r13d
movq %rdx, %r15
movq %r13, %rdi
shlq $0x30, %rdi
orq %rdx, %rdi
andq %rdx, %rbx
sete %al
testb $0x3, %r15b
setne %cl
orb %al, %cl
jne 0x85957
incl (%rbx)
leaq 0x82963(%rip), %rsi     # 0x1082c1
movq %r14, %rdx
callq 0x1393b
movq -0x38(%rbp), %r12
movq -0x30(%rbp), %rax
movq %r12, (%rax)
movl %r13d, %eax
movq %r15, %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_std_maybe_Maybe_1_map2_1_sp1
static struct std_maybe_Maybe_1 mw_std_maybe_Maybe_1_map2_1_sp1 (struct std_maybe_Maybe_1 in_Maybe_1, struct std_maybe_Maybe_1 in_Maybe_2) {
	struct std_maybe_Maybe_1 branch_Maybe_4;
	switch ((in_Maybe_2).tag) {
		case std_maybe_Maybe_1_None: {
			decref(MK_std_maybe_Maybe_1(in_Maybe_1));
			struct std_maybe_Maybe_1 v5 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_4 = v5;
		} break;
		case std_maybe_Maybe_1_Some: {
			VAL v6 = mtp_std_maybe_Maybe_1_Some(in_Maybe_2);
			struct std_maybe_Maybe_1 branch_Maybe_7;
			switch ((in_Maybe_1).tag) {
				case std_maybe_Maybe_1_None: {
					decref(v6);
					struct std_maybe_Maybe_1 v8 = { .tag=std_maybe_Maybe_1_None };
					branch_Maybe_7 = v8;
				} break;
				case std_maybe_Maybe_1_Some: {
					VAL v9 = mtp_std_maybe_Maybe_1_Some(in_Maybe_1);
					INT v10 = value_nat(v9);
					INT v11 = value_nat(v6);
					INT v12 = int_add(v10, v11);
					INT v13 = v12;
					struct std_maybe_Maybe_1 v14 = mtw_std_maybe_Maybe_1_Some(MKNAT(v13));
					branch_Maybe_7 = v14;
				} break;
				default: {
					do_panic(str_make("unexpected fallthrough in match\n", 32));
				}
			}
			branch_Maybe_4 = branch_Maybe_7;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	return branch_Maybe_4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r12
movl %edi, %r15d
cmpl $0x1, %edx
je 0x859db
testl %edx, %edx
jne 0x85a73
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r12, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x85a1b
decl (%rax)
jne 0x85a1b
shlq $0x30, %r15
orq %r12, %r15
leaq 0x828f0(%rip), %rsi     # 0x1082c1
movq %r15, %rdi
callq 0xce94
jmp 0x85a1b
movq %rcx, %rdi
callq 0xd491
movq %rax, %rbx
movq %rdx, %r14
cmpl $0x1, %r15d
je 0x85a21
testl %r15d, %r15d
jne 0x85a73
testb $0x1, %r14b
je 0x85a1b
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
movq %rbx, %rax
andq %rcx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x85a1b
decl (%rax)
je 0x85a68
xorl %eax, %eax
xorl %edx, %edx
jmp 0x85a5f
movq %r12, %rdi
callq 0xd491
movq %rax, %r15
movq %rax, %rdi
movq %rdx, %rsi
callq 0x2fb0c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2fb0c
movq %r15, %rdi
movq %rbx, %rsi
callq 0xdd03
leaq 0x826bd(%rip), %rsi     # 0x108111
movq %rax, %rdi
callq 0x8d0c
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x859d4
leaq 0x4ed93(%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_word_Word_spzesynthed
static struct std_list_List_1 mw_mirth_word_Word_spzesynthed (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Word_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_word_Word_ztspzesynthed, in_Word_2);
	struct std_maybe_Maybe_1 v6 = mw_std_prelude_zozy(v5);
	struct std_list_List_1 branch_Map_7;
	switch ((v6).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v8 = mtp_std_maybe_Maybe_1_Some(v6);
			branch_Map_7 = V_std_list_List_1(v8);
		} break;
		case std_maybe_Maybe_1_None: {
			struct std_list_List_1 v9 = mw_std_map_Map_2_Nil();
			branch_Map_7 = v9;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_3 = in_zaMirth_1;
	return branch_Map_7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x1087da1(%rip), %rdi   # 0x110d868
callq 0x12f88
movq %rax, %rdi
callq 0x141e4
cmpl $0x1, %eax
jne 0x85af4
movq %rdx, %rdi
callq 0xd491
movabsq $0xfffffffffffc, %rdx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdx
shrq $0x30, %rax
jmp 0x85af8
xorl %eax, %eax
xorl %edx, %edx
movq %r14, (%rbx)
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_sp1_0
static void mb_mirth_mirth_PropLabel_prop_1_sp1_0 (void) {
	uint64_t v0 = V_mirth_word_Word(pop_value());
	struct mirth_mirth_zaMirth* r1 = V_mirth_mirth_zaMirth(pop_resource());
	struct mirth_mirth_zaMirth* v2;
	struct mirth_arrow_Arrow* v3 = mw_mirth_word_Word_arrow(r1, v0, &v2);
	struct mirth_type_ArrowType* v4;
	struct std_list_List_1 v5 = mw_mirth_arrow_Arrow_ctxzetype(v3, &v4);
	PTUP r6 = PTRMK(0,tup_new(2),0);
	((TUP*)PTRPTR(r6))->size = 2;
	((TUP*)PTRPTR(r6))->cells[1] = MK_mirth_type_ArrowType(v4);
	((TUP*)PTRPTR(r6))->cells[0] = MK_std_list_List_1(v5);
	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
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x31be4
leaq -0x30(%rbp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x31c23
movl %eax, %r15d
movq %rdx, %r12
pushq $0x2
popq %rdi
callq 0xd928
movq %rax, %r13
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r13, %rax
movw $0x2, 0x6(%rax)
movq (%r14), %rcx
leaq 0x8300c(%rip), %rdx     # 0x108b79
movq %rcx, 0x18(%rax)
movq %rdx, 0x20(%rax)
shlq $0x30, %r15
orq %r12, %r15
leaq 0x826f6(%rip), %rcx     # 0x108279
movq %r15, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq (%rbx), %rdi
leaq 0x82d5b(%rip), %rsi     # 0x1088f0
callq 0x883c
leaq 0x827f8(%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_arrow_Arg_similar
static bool mw_mirth_arrow_Arg_similar (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Arg_2, uint64_t in_Arg_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	struct mirth_mirth_zaMirth* v6;
	bool v7 = mw_mirth_arrow_Block_similar(in_zaMirth_1, in_Arg_2, in_Arg_3, &v6);
	*out_zaMirth_4 = v6;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
leaq -0x18(%rbp), %r14
movq %r14, %rcx
callq 0x8668c
movq (%r14), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq