LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_prim_Array_1_len
static INT mw_std_prim_Array_1_len (ARR* in_Array_1) {
	uint64_t v3 = arr_len(in_Array_1);
	INT v4 = u64_to_int(v3);
	INT v5 = v4;
	return v5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x11b5b
movq 0x10(%rdi), %rbx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x11b5d
decl (%rax)
jne 0x11b5d
leaq 0xf6b15(%rip), %rsi     # 0x108669
callq 0xce94
jmp 0x11b5d
xorl %ebx, %ebx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xdbc8
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: arr_free
static void arr_free (VAL v) {
    ARR* arr = VARR(v);
    if (arr) {
        if (TAG_HAS_REFS(arr->tag)) {
            for (USIZE i = 0; i < arr->size; i++) {
                VAL v = val_peek_(arr,i);
                decref(v);
            }
        }
        free(arr);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x11b95
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x1, 0x20(%rdi)
jne 0x11b96
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
retq
xorl %r14d, %r14d
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
cmpq 0x10(%rbx), %r14
jae 0x11b83
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11ca8
testb $0x1, %dl
je 0x11bdd
movq %rax, %rcx
andq %r15, %rcx
sete %sil
testb $0x3, %al
setne %dil
orb %sil, %dil
jne 0x11bdd
decl (%rcx)
jne 0x11bdd
movq %rax, %rdi
movq %rdx, %rsi
callq 0xce94
incq %r14
jmp 0x11ba3
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: arr_trace_
static void arr_trace_(VAL v, int fd) {
    ARR* arr = VARR(v);
    if (!arr) {
        write(fd, "{}", 2);
    } else {
        USIZE n = arr->size;
        if (n > 16) n = 16;
        write(fd, "{ ", 2);
        for (size_t i = 0; i < arr->size; i++) {
            if (i > 0) write(fd, " ", 1);
            value_trace_(val_peek_(arr,i), fd);
        }
        write(fd, " }", 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
testq %rdi, %rdi
je 0x11c57
movq %rdi, %r14
leaq 0xdb9c7(%rip), %rsi     # 0xed5c8
pushq $0x2
popq %rdx
movl %ebx, %edi
callq 0x5060
xorl %r12d, %r12d
leaq 0xc41f2(%rip), %r13     # 0xd5e07
pushq $0x1
popq %r15
cmpq 0x10(%r14), %r12
jae 0x11c4e
testq %r12, %r12
je 0x11c31
movl %ebx, %edi
movq %r13, %rsi
movq %r15, %rdx
callq 0x5060
movq %r14, %rdi
movq %r12, %rsi
callq 0x11ca8
movq %rax, %rdi
movq %rdx, %rsi
movl %ebx, %edx
callq 0x888a
incq %r12
jmp 0x11c19
leaq 0xc7d8c(%rip), %rsi     # 0xd99e1
jmp 0x11c5e
leaq 0xc3fe0(%rip), %rsi     # 0xd5c3e
pushq $0x2
popq %rdx
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5060
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: val_peek_
static VAL val_peek_(ARR* arr, USIZE i) {
    ASSERT(arr);
    ASSERT(i < arr->size);
    const TYPE* ty = PTRPTR(arr->tag);
    ASSERT(ty && ty->peek_);
    return ty->peek_(arr, i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x11ce1
cmpq %rsi, 0x10(%rdi)
jbe 0x11cef
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq 0x20(%rdi), %rax
je 0x11cd3
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x11cd3
popq %rbp
jmpq *%rax
leaq 0xc3f26(%rip), %rsi     # 0xd5c00
pushq $0x2
popq %rdi
pushq $0x3d
jmp 0x11cfb
leaq 0xc3eaa(%rip), %rsi     # 0xd5b92
pushq $0x2
popq %rdi
pushq $0x31
jmp 0x11cfb
leaq 0xc3ece(%rip), %rsi     # 0xd5bc4
pushq $0x2
popq %rdi
pushq $0x3b
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: arr_reserve
static ARR* arr_reserve(ARR* arr, TAG tag, size_t need_cap) {
    if (!arr) { return arr_new_of(tag, need_cap); }
    if ((arr->refs == 1) && (arr->cap >= need_cap)) return arr;
    ASSERT(arr->tag == tag);
    USIZE size = arr->size;
    USIZE stride = arr->stride;
    if (need_cap < size) need_cap = arr->size;
    USIZE cap = need_cap*2 + 4;
    ARR* arr2 = arr_new_of(tag, cap);
    USIZE mbytes = ((stride == STRIDE_BOOL) ? size/8 : size*stride) + 4;
    arr2->size = size;
    memcpy(arr2->data.u8s, arr->data.u8s, mbytes);
    if (TAG_HAS_REFS(tag)) {
        for (USIZE i = 0; i < size; i++) {
            VAL u = val_peek_(arr2,i);
            incref(u);
        }
    }
    decref(MKARR(arr));
    return arr2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
cmpl $0x1, (%rdi)
jne 0x11d49
cmpq %rdx, 0x8(%rbx)
jae 0x11e0d
cmpq %rax, 0x20(%rbx)
jne 0x11e22
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movq 0x10(%rbx), %r13
movq 0x18(%rbx), %r15
cmpq %rdx, %r13
cmovaq %r13, %rdx
leaq 0x4(,%rdx,2), %rsi
movq %rax, %rdi
movq %rax, -0x30(%rbp)
callq 0x1100c
movq %rax, %r14
movq %r13, %rax
shrq $0x3, %rax
movq %r15, %rdx
imulq %r13, %rdx
cmpq $-0x1, %r15
cmoveq %rax, %rdx
addq $0x4, %rdx
movq %r13, 0x10(%r14)
leaq 0x28(%r14), %rdi
leaq 0x28(%rbx), %rsi
callq 0x50e0
testb $0x1, -0x30(%rbp)
jne 0x11ddb
andq %rbx, %r12
sete %al
testb $0x3, %bl
setne %cl
orb %al, %cl
jne 0x11e10
decl (%r12)
jne 0x11e10
leaq 0xf6898(%rip), %rsi     # 0x108669
movq %rbx, %rdi
callq 0xce94
jmp 0x11e10
xorl %r15d, %r15d
cmpq %r15, %r13
je 0x11db4
movq %r14, %rdi
movq %r15, %rsi
callq 0x11ca8
testb $0x1, %dl
je 0x11e08
movq %rax, %rcx
andq %r12, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x11e08
incl (%rax)
incq %r15
jmp 0x11dde
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc3e18(%rip), %rsi     # 0xd5c41
pushq $0x2
popq %rdi
pushq $0x3d
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_str_zaStr_pushzebytezeasciizx
static void mw_std_str_zaStr_pushzebytezeasciizx (enum std_byte_Byte in_Byte_1, STR* in_zaStr_2, STR* *out_zaStr_3) {
	struct std_maybe_Maybe_1 v4 = mw_std_byte_Byte_tozeasciizestr(in_Byte_1);
	STR* branch_zaStr_5;
	switch ((v4).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v6 = mtp_std_maybe_Maybe_1_Some(v4);
			STR* v7;
			mw_std_str_zaStr_pushzestrzx(value_str(v6), in_zaStr_2, &v7);
			branch_zaStr_5 = v7;
		} break;
		case std_maybe_Maybe_1_None: {
			branch_zaStr_5 = in_zaStr_2;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaStr_3 = branch_zaStr_5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
movl %edi, %r12d
movq %r12, %rdi
callq 0xd86d
movq %rax, %rdi
callq 0xdc43
movq %r12, %rdi
callq 0xd86d
movq %rax, %rdi
callq 0xdc43
testb %al, %al
js 0x11ee6
movl %r15d, %edi
callq 0x109de
leaq 0xf629c(%rip), %rsi     # 0x108159
movq %rax, %rdi
callq 0x8d0c
movq %rdx, %rdi
callq 0xd491
movq %rax, %rdi
movq %rdx, %rsi
callq 0x8b55
movq %r14, %rdi
movq %rax, %rsi
callq 0xd8b0
movq %rax, %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: mirth_options_Options_free
static void mirth_options_Options_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_options_Options);
	struct mirth_options_Options* self = vself.data.ptr;
	decref(MKSTR(self->minputzefile));
	decref(MK_std_maybe_Maybe_1(self->moutputzefile));
	decref(MK_std_maybe_Maybe_1(self->mentryzepoint));
	decref(MK_std_list_List_1(self->mpackages));
	decref(MK_std_list_List_1(self->mpackagezesearchzepaths));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xf632e(%rip), %rax     # 0x108231
cmpq %rsi, %rax
jne 0x12016
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x8(%rdi), %rdi
movq %rdi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x11f41
decl (%rax)
jne 0x11f41
leaq 0xf621d(%rip), %rsi     # 0x108159
callq 0xce94
movq 0x18(%rbx), %rcx
leaq 0xf6375(%rip), %r14     # 0x1082c1
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x11f76
decl (%rax)
jne 0x11f76
movl 0x10(%rbx), %edi
shlq $0x30, %rdi
orq 0x18(%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 0x11fa4
decl (%rax)
jne 0x11fa4
movl 0x20(%rbx), %edi
shlq $0x30, %rdi
orq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0xce94
movq 0x38(%rbx), %rcx
leaq 0xf62ca(%rip), %r14     # 0x108279
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x11fd9
decl (%rax)
jne 0x11fd9
movl 0x30(%rbx), %edi
shlq $0x30, %rdi
orq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0xce94
movq 0x48(%rbx), %rax
andq %rax, %r15
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x12004
decl (%r15)
jne 0x12004
movl 0x40(%rbx), %edi
shlq $0x30, %rdi
orq 0x48(%rbx), %rdi
movq %r14, %rsi
callq 0xce94
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
leaq 0xc3e50(%rip), %rsi     # 0xd5e6d
pushq $0x2
popq %rdi
pushq $0x54
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_mirth_LexicalState_LexicalState
static struct mirth_mirth_LexicalState* mtw_mirth_mirth_LexicalState_LexicalState (struct std_maybe_Maybe_1 in_Maybe_1, struct std_maybe_Maybe_1 in_Maybe_2) {
	struct mirth_mirth_LexicalState* v4 = calloc(1, sizeof *v4);
	ASSERT(v4);
	v4->refs = 1;
	v4->mdefiningzenamespace = in_Maybe_2;
	v4->merrorzetoken = in_Maybe_1;
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %r12d
movq %rsi, %rbx
movl %edi, %r15d
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x120ca
movl $0x1, (%rax)
movl %r12d, 0x18(%rax)
movq %r14, 0x20(%rax)
movl %r15d, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc3dfb(%rip), %rsi     # 0xd5ecc
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_mirth_zaMirth_builtin
static struct mirth_mirth_Builtin* mw_mirth_mirth_zaMirth_builtin (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_mirth_zaMirth* *out_zaMirth_2) {
	struct std_maybe_Maybe_1 v4 = in_zaMirth_1->mbuiltinzy;
	incref(MK_std_maybe_Maybe_1(v4));
	VAL branch_zux1_5;
	switch ((v4).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v6 = mtp_std_maybe_Maybe_1_Some(v4);
			branch_zux1_5 = v6;
		} break;
		case std_maybe_Maybe_1_None: {
			STR* v7;
			STRLIT(v7, "[compiler bug] Expected builtins to be available.", 49);
			do_panic(v7);
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_2 = in_zaMirth_1;
	return V_mirth_mirth_Builtin(branch_zux1_5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movl 0x10(%rdi), %eax
movq 0x18(%rdi), %rdi
movq %rdi, %rcx
andq %r15, %rcx
sete %dl
testb $0x3, %dil
setne %sil
orb %dl, %sil
jne 0x121a4
incl (%rcx)
cmpl $0x1, %eax
jne 0x121bc
callq 0xd491
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testl %eax, %eax
jne 0x121fe
movq 0x10f92f9(%rip), %rdi   # 0x110b4c0
testq %rdi, %rdi
jne 0x121e5
leaq 0xc3dfb(%rip), %rdi     # 0xd5fce
pushq $0x31
popq %rsi
callq 0x8a21
movq %rax, %rdi
movq %rax, 0x10f92db(%rip)   # 0x110b4c0
andq %rdi, %r15
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x121f9
incl (%r15)
callq 0x8cc6
leaq 0xc2608(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_def_Def_Package
static struct mirth_def_Def mtw_mirth_def_Def_Package (uint64_t in_Package_1) {
	struct mirth_def_Def_Package* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mPackage = in_Package_1;
	struct mirth_def_Def v4 = { .tag=mirth_def_Def_Package, .ptr.Package=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x127de
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xc3e5d(%rip), %rsi     # 0xd6642
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_name_Hash_keepzegoingzy
static STR* mw_mirth_name_Hash_keepzegoingzy (struct mirth_mirth_zaMirth* in_zaMirth_1, STR* in_Str_2, uint64_t in_Hash_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, uint64_t *out_Hash_6, bool *out_Bool_7) {
	struct mirth_mirth_zaMirth* v8;
	struct std_maybe_Maybe_1 v9 = mw_mirth_name_Hash_namezo(in_zaMirth_1, in_Hash_3, &v8);
	struct mirth_mirth_zaMirth* branch_zaMirth_10;
	STR* branch_Str_11;
	VAL branch_zux1_12;
	bool branch_Bool_13;
	switch ((v9).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v14 = mtp_std_maybe_Maybe_1_Some(v9);
			struct mirth_mirth_zaMirth* v15;
			STR* v16 = mw_mirth_name_Name_str(v8, V_mirth_name_Name(v14), &v15);
			incref(MKSTR(in_Str_2));
			bool v17 = (str_cmp(v16, in_Str_2) == 0);
			bool v18 = !v17;
			branch_Bool_13 = v18;
			branch_zux1_12 = MKU64(in_Hash_3);
			branch_Str_11 = in_Str_2;
			branch_zaMirth_10 = v15;
		} break;
		case std_maybe_Maybe_1_None: {
			bool v19 = false;
			branch_Bool_13 = v19;
			branch_zux1_12 = MKU64(in_Hash_3);
			branch_Str_11 = in_Str_2;
			branch_zaMirth_10 = v8;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_Bool_7 = branch_Bool_13;
	*out_Hash_6 = value_u64(branch_zux1_12);
	*out_zaMirth_4 = branch_zaMirth_10;
	return branch_Str_11;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r12
leaq -0x30(%rbp), %rdx
movq %r13, %rsi
callq 0x12c8d
cmpl $0x1, %eax
jne 0x12c6c
movq %rdx, %rdi
callq 0xd491
movq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rdx
movq %rax, %rsi
callq 0x12f0a
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %r12, %rcx
sete %dl
testb $0x3, %r12b
setne %sil
orb %dl, %sil
jne 0x12c56
incl (%rcx)
movq %rax, %rdi
movq %r12, %rsi
callq 0xd769
testl %eax, %eax
setne %cl
movq -0x38(%rbp), %rax
jmp 0x12c72
movq -0x30(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%r15)
movq %r13, (%r14)
movq %rax, (%rbx)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_prelude_unsafe_1_sp9
static enum std_byte_Byte mw_std_prelude_unsafe_1_sp9 (void* in_Ptr_1) {
	uint8_t v3 = *(uint8_t*)in_Ptr_1;
	uint64_t v4 = (uint64_t)(v3);
	INT v5 = u64_to_int(v4);
	int64_t v6 = int_to_i64(v5);
	return ((enum std_byte_Byte)v6);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl (%rdi), %edi
callq 0xdbc8
movq %rax, %rdi
popq %rbp
jmp 0xdc43
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_name_Name_str
static STR* mw_mirth_name_Name_str (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Name_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_name_Name_str, in_Name_2);
	VAL v6 = mut_get(v5);
	*out_zaMirth_3 = in_zaMirth_1;
	return value_str(v6);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10f85aa(%rip), %rdi   # 0x110b4c8
callq 0x12f88
movq %rax, %rdi
callq 0x1307d
movq %r14, (%rbx)
movq %rax, %rdi
movq %rdx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x8b55
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: field_mut
static VAL* field_mut(FIELD* field, uint64_t index) {
    ASSERT(field);
    size_t block_size = 1024;
    size_t block_i = index / block_size;
    size_t block_j = index % block_size;
    if (block_i >= field->num_blocks) {
        ASSERT(field->num_blocks <= SIZE_MAX - 4 - block_i);
        size_t new_num_blocks = field->num_blocks + block_i + 4;
        VAL** new_blocks = realloc(field->blocks, sizeof(VAL*) * new_num_blocks);
        ASSERT(new_blocks);
        memset(new_blocks + field->num_blocks, 0, sizeof(VAL*) * (new_num_blocks - field->num_blocks));
        field->blocks = new_blocks;
        field->num_blocks = new_num_blocks;
    }
    if(!field->blocks[block_i]) {
        field->blocks[block_i] = calloc(block_size, sizeof(VAL));
        ASSERT(field->blocks[block_i]);
    }
    return field->blocks[block_i] + block_j;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x13042
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %r12
shrq $0xa, %r12
movq (%rdi), %r13
cmpq %r13, %r12
jae 0x12fba
movq 0x8(%r14), %r15
jmp 0x12ffd
leaq (%r12,%r13), %rax
movq 0x8(%r14), %rdi
leaq 0x20(,%rax,8), %rsi
callq 0x50f0
testq %rax, %rax
je 0x13050
movq %rax, %r15
addq %r12, %r13
addq $0x4, %r13
movq (%r14), %rax
leaq (%r15,%rax,8), %rdi
movq %r13, %rdx
subq %rax, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x5080
movq %r15, 0x8(%r14)
movq %r13, (%r14)
movq (%r15,%r12,8), %rax
testq %rax, %rax
jne 0x13024
pushq $0x10
popq %rsi
movl $0x400, %edi            # imm = 0x400
callq 0x50c0
movq %rax, (%r15,%r12,8)
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0x1305e
andl $0x3ff, %ebx            # imm = 0x3FF
shll $0x4, %ebx
addq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc2fb7(%rip), %rsi     # 0xd6000
pushq $0x2
popq %rdi
pushq $0x33
jmp 0x1306a
leaq 0xc2fdd(%rip), %rsi     # 0xd6034
pushq $0x2
popq %rdi
pushq $0x38
jmp 0x1306a
leaq 0xc3008(%rip), %rsi     # 0xd606d
pushq $0x2
popq %rdi
pushq $0x44
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: mut_get
static VAL mut_get (void* mut) {
    EXPECT(mut, "invalid pointer in prim-mut-get");
    VAL v = *(VAL*)mut;
    EXPECT(v.tag, "tried to read uninitialized value");
    incref(v);
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x130b7
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x130c5
movq (%rdi), %rax
testb $0x1, %dl
je 0x130b5
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %sil
testb $0x3, %al
setne %dil
orb %sil, %dil
jne 0x130b5
incl (%rcx)
popq %rbp
retq
leaq 0xc2ff4(%rip), %rsi     # 0xd60b2
pushq $0x2
popq %rdi
pushq $0x20
jmp 0x130d1
leaq 0xc3007(%rip), %rsi     # 0xd60d3
pushq $0x2
popq %rdi
pushq $0x22
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_name_zaNameHashMap_hashmapzeindex
static INT mw_mirth_name_zaNameHashMap_hashmapzeindex (ARR* in_zaNameHashMap_1, uint64_t in_Hash_2, ARR* *out_zaNameHashMap_3) {
	INT v5 = u64_to_int(in_Hash_2);
	INT v6 = v5;
	ARR* v7;
	INT v8 = mw_std_array_zaArray_1_lenzo(in_zaNameHashMap_1, &v7);
	INT v9 = v6;
	INT v10 = v8;
	INT v11;
	INT v12 = int_divmod(v9, v10, &v11);
	INT v13 = v11;
	INT v14 = v12;
	decref(MKNAT(v14));
	*out_zaNameHashMap_3 = v7;
	return v13;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xdbc8
movq %rax, %r15
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
callq 0x11ace
leaq -0x28(%rbp), %r14
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x13166
movq (%r14), %r14
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x13151
decl (%rcx)
jne 0x13151
leaq 0xf4fc8(%rip), %rsi     # 0x108111
movq %rax, %rdi
callq 0xce94
movq -0x20(%rbp), %rax
movq %rax, (%rbx)
movq %r14, %rax
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: big_pos_u32_mul_sub_shift_accum_
static void big_pos_u32_mul_sub_shift_accum_(BIG* a, INT b, uint32_t scale, size_t shift) {
    size_t bsize;
    uint32_t *bradix;
    uint32_t bradix_temp[2] = {0};
    if (IS_I63(b)) {
        int64_t ib = GET_I63(b);
        ASSERT(ib >= 0);
        bsize = 2;
        bradix = bradix_temp;
        bradix_temp[0] = LO_RADIX(ib);
        bradix_temp[1] = HI_RADIX(ib);
    } else {
        BIG* bb = GET_BIG(b);
        bsize = bb->size;
        bradix = bb->radix;
    }

    uint64_t borrow = 0;
    size_t i = 0;
    for (; i < bsize; i++) {
        ASSERT(i+shift < a->size);
        uint64_t br = (uint64_t)scale * (uint64_t)bradix[i];
        ASSERT(borrow <= UINT64_MAX - br);
        br += borrow;
        uint64_t ahi = (i+shift+1 < a->size) ? a->radix[i+shift+1] : 0;
        uint64_t alo = a->radix[i+shift];
        uint64_t ar = (ahi << 32) | alo;
        borrow = (ar < br) ? (uint64_t)0x100000000 : (uint64_t)0;
        ar -= br;
        a->radix[i+shift] = LO_RADIX(ar);
        if (i+shift+1 < a->size) {
            a->radix[i+shift+1] = HI_RADIX(ar);
        }
    }
    if (borrow) {
        big_pred_at_accum_(a, i+shift+1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
andq $0x0, -0x30(%rbp)
testb $0x1, %sil
jne 0x13739
movq 0x10(%rsi), %rax
addq $0x18, %rsi
movq %rsi, %r8
jmp 0x1374f
decq %rsi
sarq %rsi
js 0x13810
leaq -0x30(%rbp), %r8
movq %rsi, (%r8)
pushq $0x2
popq %rax
movl %edx, %edx
movq %rax, %rsi
negq %rsi
leaq (%rdi,%rcx,4), %r9
pushq $0x7
popq %r10
xorl %ebx, %ebx
movq %rcx, %r11
leaq (%rsi,%r10), %r14
cmpq $0x7, %r14
je 0x137c7
movq 0x10(%rdi), %r14
cmpq %r14, %r11
jae 0x137f1
incq %r11
cmpq %r14, %r11
jae 0x13789
movl (%r9,%r10,4), %r12d
shlq $0x20, %r12
jmp 0x1378c
xorl %r12d, %r12d
movl -0x1c(%r8,%r10,4), %r13d
imulq %rdx, %r13
addq %rbx, %r13
movl -0x4(%r9,%r10,4), %r15d
orq %r12, %r15
xorl %ebx, %ebx
subq %r13, %r15
setb %r12b
movl %r15d, -0x4(%r9,%r10,4)
cmpq %r14, %r11
jae 0x137bb
shrq $0x20, %r15
movl %r15d, (%r9,%r10,4)
movb %r12b, %bl
shlq $0x20, %rbx
incq %r10
jmp 0x13764
testq %rbx, %rbx
je 0x137e2
addq %rcx, %rax
movq 0x10(%rdi), %rcx
incq %rax
cmpq %rcx, %rax
jae 0x137e2
subl $0x1, 0x18(%rdi,%rax,4)
jb 0x137d3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc2b68(%rip), %rsi     # 0xd6360
pushq $0x2
popq %rdi
pushq $0x3f
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
leaq 0xc2b13(%rip), %rsi     # 0xd632a
pushq $0x2
popq %rdi
pushq $0x35
jmp 0x137fd
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: big_pos_ucmp_
static int big_pos_ucmp_(BIG* a, INT b) {
    size_t bsize;
    uint32_t *bradix;
    uint32_t bradix_temp[2] = {0};
    if (IS_I63(b)) {
        int64_t ib = GET_I63(b);
        ASSERT(ib >= 0);
        bsize = 2;
        bradix = bradix_temp;
        bradix_temp[0] = LO_RADIX(ib);
        bradix_temp[1] = HI_RADIX(ib);
    } else {
        BIG* bb = GET_BIG(b);
        bsize = bb->size;
        bradix = bb->radix;
    }
    for(size_t i = a->size; i --> bsize;) {
        if (a->radix[i]) return -1;
    }
    for(size_t i = bsize; i --> a->size;) {
        if (bradix[i]) return 1;
    }
    for (size_t i = ((bsize < a->size) ? bsize : a->size); i --> 0;) {
        uint32_t ar = a->radix[i];
        uint32_t br = bradix[i];
        if (ar != br) {
            return (ar > br) - (ar < br);
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
andq $0x0, -0x8(%rbp)
testb $0x1, %sil
jne 0x1383e
movq 0x10(%rsi), %r8
addq $0x18, %rsi
movq %rsi, %rcx
jmp 0x13851
decq %rsi
sarq %rsi
js 0x138ae
leaq -0x8(%rbp), %rcx
movq %rsi, (%rcx)
pushq $0x2
popq %r8
movq 0x10(%rdi), %rdx
pushq $-0x1
popq %rax
movq %rdx, %rsi
cmpq %r8, %rsi
jbe 0x1386d
cmpl $0x0, 0x14(%rdi,%rsi,4)
leaq -0x1(%rsi), %rsi
je 0x1385b
jmp 0x138a8
pushq $0x1
popq %rax
movq %r8, %rsi
cmpq %rdx, %rsi
jbe 0x13885
cmpl $0x0, -0x4(%rcx,%rsi,4)
leaq -0x1(%rsi), %rsi
je 0x13873
jmp 0x138a8
cmpq %rdx, %r8
cmovbq %r8, %rdx
subq $0x1, %rdx
jb 0x138a6
movl (%rcx,%rdx,4), %eax
cmpl %eax, 0x18(%rdi,%rdx,4)
je 0x1388c
seta %al
movzbl %al, %eax
sbbl $0x0, %eax
jmp 0x138a8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
leaq 0xc2aeb(%rip), %rsi     # 0xd63a0
pushq $0x2
popq %rdi
pushq $0x35
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: mut_set
static void mut_set (VAL newval, void* mut) {
    EXPECT(mut, "invalid pointer in prim-mut-set");
    VAL oldval = *(VAL*)mut;
    *(VAL*)mut = newval;
    if (oldval.tag) {
        decref(oldval);
    }
}

// Assembly:
testq %rdx, %rdx
je 0x1397e
movq %rsi, %rax
movq %rdi, %rcx
movq (%rdx), %rdi
movq 0x8(%rdx), %rsi
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
testb $0x1, %sil
je 0x1397d
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x1397d
decl (%rax)
je 0xce94
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xc2ac1(%rip), %rsi     # 0xd644a
pushq $0x2
popq %rdi
pushq $0x20
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_name_QName_undefinedzesoftzy
static bool mw_mirth_name_QName_undefinedzesoftzy (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_name_QName* in_QName_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct std_maybe_Maybe_1 v6 = mw_mirth_name_QName_defzesoftzy(in_zaMirth_1, in_QName_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);
	*out_zaMirth_3 = v5;
	return v11;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x18(%rbp), %rdx
callq 0x173a0
movl %eax, %r14d
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x13ba5
decl (%rax)
jne 0x13ba5
movq %r14, %rdi
shlq $0x30, %rdi
orq %rdx, %rdi
leaq 0xf4721(%rip), %rsi     # 0x1082c1
callq 0xce94
movq %r14, %rdi
callq 0xd86d
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xd759
movq -0x18(%rbp), %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_name_Name_defs
static struct std_list_List_1 mw_mirth_name_Name_defs (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Name_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_name_Name_defs, in_Name_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 std_list_List_1 v10 = { .tag=std_list_List_1_Nil };
		incref(MK_std_list_List_1(v10));
		mut_set(MK_std_list_List_1(v10), v5);
		branch_List_8 = v10;
		branch_zaMirth_7 = in_zaMirth_1;
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_List_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10f816d(%rip), %rdi   # 0x110bf98
callq 0x12f88
movq %rax, %r15
movq %rax, %rdi
callq 0x142de
testb %al, %al
je 0x13e5d
movq %r15, %rdi
callq 0x1307d
movq %rax, %r12
movabsq $0xfffffffffffc, %rdx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdx
shrq $0x30, %r12
jmp 0x13e73
leaq 0xf4415(%rip), %rsi     # 0x108279
xorl %r12d, %r12d
xorl %edi, %edi
movq %r15, %rdx
callq 0x1393b
xorl %edx, %edx
movq %r14, (%rbx)
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_def_Def_Alias
static uint64_t mtp_mirth_def_Def_Alias (struct mirth_def_Def in_Def_1) {
	struct mirth_def_Def_Alias v3 = *in_Def_1.ptr.Alias;
	if (!--(in_Def_1.ptr.Alias->refs)) {
		free(in_Def_1.ptr.Alias);
	} else {
	}
	return v3.mAlias;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x13f09
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_def_Def_Package
static uint64_t mtp_mirth_def_Def_Package (struct mirth_def_Def in_Def_1) {
	struct mirth_def_Def_Package v3 = *in_Def_1.ptr.Package;
	if (!--(in_Def_1.ptr.Package->refs)) {
		free(in_Def_1.ptr.Package);
	} else {
	}
	return v3.mPackage;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x13f26
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_package_Package_qname
static struct mirth_name_QName* mw_mirth_package_Package_qname (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Package_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_name_Namespace v5 = { .tag=mirth_name_Namespace_Root };
	struct mirth_mirth_zaMirth* v6;
	uint64_t v7 = mw_mirth_package_Package_name(in_zaMirth_1, in_Package_2, &v6);
	INT v8 = WRAP_I63(0LL);
	struct mirth_name_QName* v9 = mw_mirth_name_QName_Mk(v5, v7, v8);
	*out_zaMirth_3 = v6;
	return v9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x18(%rbp), %r14
movq %r14, %rdx
callq 0x14712
pushq $0x1
popq %rcx
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rdx
callq 0x1473b
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: mtp_mirth_def_Def_Module
static uint64_t mtp_mirth_def_Def_Module (struct mirth_def_Def in_Def_1) {
	struct mirth_def_Def_Module v3 = *in_Def_1.ptr.Module;
	if (!--(in_Def_1.ptr.Module->refs)) {
		free(in_Def_1.ptr.Module);
	} else {
	}
	return v3.mModule;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x13f7b
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_module_Module_qname
static struct mirth_name_QName* mw_mirth_module_Module_qname (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Module_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	uint64_t v6 = mw_mirth_module_Module_package(in_zaMirth_1, in_Module_2, &v5);
	struct mirth_name_Namespace v7 = mtw_mirth_name_Namespace_Package(v6);
	struct mirth_mirth_zaMirth* v8;
	uint64_t v9 = mw_mirth_module_Module_name(v5, in_Module_2, &v8);
	INT v10 = WRAP_I63(0LL);
	struct mirth_name_QName* v11 = mw_mirth_name_QName_Mk(v7, v9, v10);
	*out_zaMirth_3 = v8;
	return v11;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x30(%rbp), %r15
movq %r15, %rdx
callq 0x147a0
movq %rax, %rdi
callq 0x147c9
movq %rax, %r12
movq (%r15), %rdi
leaq -0x28(%rbp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x14812
pushq $0x1
popq %rdi
pushq $0x1
popq %rcx
movq %r12, %rsi
movq %rax, %rdx
callq 0x1473b
movq (%r15), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_def_Def_Buffer
static uint64_t mtp_mirth_def_Def_Buffer (struct mirth_def_Def in_Def_1) {
	struct mirth_def_Def_Buffer v3 = *in_Def_1.ptr.Buffer;
	if (!--(in_Def_1.ptr.Buffer->refs)) {
		free(in_Def_1.ptr.Buffer);
	} else {
	}
	return v3.mBuffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x13ffa
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_def_Def_Prim
static enum mirth_prim_Prim mtp_mirth_def_Def_Prim (struct mirth_def_Def in_Def_1) {
	struct mirth_def_Def_Prim v3 = *in_Def_1.ptr.Prim;
	if (!--(in_Def_1.ptr.Prim->refs)) {
		free(in_Def_1.ptr.Prim);
	} else {
	}
	return v3.mPrim;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x4(%rdi), %ebx
decl (%rdi)
jne 0x14016
callq 0x5030
movl %ebx, %eax
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_prim_Prim_qname
static struct mirth_name_QName* mw_mirth_prim_Prim_qname (struct mirth_mirth_zaMirth* in_zaMirth_1, enum mirth_prim_Prim in_Prim_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct mirth_name_Namespace v6 = mw_mirth_prim_Prim_namespace(in_zaMirth_1, in_Prim_2, &v5);
	INT v7;
	STR* v8 = mw_mirth_prim_Prim_strzearity(in_Prim_2, &v7);
	struct mirth_mirth_zaMirth* v9;
	uint64_t v10 = mw_mirth_name_Name_Name(v5, v8, &v9);
	struct mirth_name_QName* v11 = mw_mirth_name_QName_Mk(v6, v10, v7);
	*out_zaMirth_3 = v9;
	return v11;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %r14d
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x171d7
movq %rax, %r12
movq (%r15), %r15
leaq -0x30(%rbp), %r13
movl %r14d, %edi
movq %r13, %rsi
callq 0x14e72
leaq -0x38(%rbp), %r14
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x12215
movq (%r13), %rcx
pushq $0x2
popq %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1473b
movq (%r14), %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: mtp_mirth_def_Def_Data
static uint64_t mtp_mirth_def_Def_Data (struct mirth_def_Def in_Def_1) {
	struct mirth_def_Def_Data v3 = *in_Def_1.ptr.Data;
	if (!--(in_Def_1.ptr.Data->refs)) {
		free(in_Def_1.ptr.Data);
	} else {
	}
	return v3.mData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x140a3
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_def_Def_Table
static uint64_t mtp_mirth_def_Def_Table (struct mirth_def_Def in_Def_1) {
	struct mirth_def_Def_Table v3 = *in_Def_1.ptr.Table;
	if (!--(in_Def_1.ptr.Table->refs)) {
		free(in_Def_1.ptr.Table);
	} else {
	}
	return v3.mTable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x140c0
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_def_Def_Type
static uint64_t mtp_mirth_def_Def_Type (struct mirth_def_Def in_Def_1) {
	struct mirth_def_Def_Type v3 = *in_Def_1.ptr.Type;
	if (!--(in_Def_1.ptr.Type->refs)) {
		free(in_Def_1.ptr.Type);
	} else {
	}
	return v3.mTypeDef;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x140dd
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_def_Def_Word
static uint64_t mtp_mirth_def_Def_Word (struct mirth_def_Def in_Def_1) {
	struct mirth_def_Def_Word v3 = *in_Def_1.ptr.Word;
	if (!--(in_Def_1.ptr.Word->refs)) {
		free(in_Def_1.ptr.Word);
	} else {
	}
	return v3.mWord;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x14117
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_def_Def_Field
static uint64_t mtp_mirth_def_Def_Field (struct mirth_def_Def in_Def_1) {
	struct mirth_def_Def_Field v3 = *in_Def_1.ptr.Field;
	if (!--(in_Def_1.ptr.Field->refs)) {
		free(in_Def_1.ptr.Field);
	} else {
	}
	return v3.mField;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x14134
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_def_Def_Tag
static uint64_t mtp_mirth_def_Def_Tag (struct mirth_def_Def in_Def_1) {
	struct mirth_def_Def_Tag v3 = *in_Def_1.ptr.Tag;
	if (!--(in_Def_1.ptr.Tag->refs)) {
		free(in_Def_1.ptr.Tag);
	} else {
	}
	return v3.mTag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x14151
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_data_Tag_qname
static struct mirth_name_QName* mw_mirth_data_Tag_qname (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_name_Namespace v7 = mw_mirth_data_Data_zgNamespace(v6);
	struct mirth_mirth_zaMirth* v8;
	uint64_t v9 = mw_mirth_data_Tag_name(v5, in_Tag_2, &v8);
	struct mirth_mirth_zaMirth* v10;
	INT v11 = mw_mirth_data_Tag_arity(v8, in_Tag_2, &v10);
	struct mirth_name_QName* v12 = mtw_mirth_name_QName_QName(v7, v9, v11);
	*out_zaMirth_3 = v10;
	return v12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x30(%rbp), %r15
movq %r15, %rdx
callq 0x172b6
movq %rax, %rdi
callq 0x17308
xorl %edi, %edi
movq %rax, %rsi
callq 0x17351
movq %rax, %r12
movq (%r15), %rdi
leaq -0x28(%rbp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x172df
movq (%r15), %r14
pushq $0x3
popq %rdi
pushq $0x1
popq %rcx
movq %r12, %rsi
movq %rax, %rdx
callq 0x1473b
movq %r14, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_def_Def_Macro
static uint64_t mtp_mirth_def_Def_Macro (struct mirth_def_Def in_Def_1) {
	struct mirth_def_Def_Macro v3 = *in_Def_1.ptr.Macro;
	if (!--(in_Def_1.ptr.Macro->refs)) {
		free(in_Def_1.ptr.Macro);
	} else {
	}
	return v3.mMacro;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
jne 0x141da
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_std_prelude_zozy
static struct std_maybe_Maybe_1 mw_std_prelude_zozy (void* in_Mutt_1) {
	bool v3 = mut_is_set(in_Mutt_1);
	struct std_maybe_Maybe_1 branch_Maybe_4;
	if (v3) {
		VAL v5 = mut_get(in_Mutt_1);
		struct std_maybe_Maybe_1 v6 = mtw_std_maybe_Maybe_1_Some(v5);
		branch_Maybe_4 = v6;
	} else {
		struct std_maybe_Maybe_1 v7 = { .tag=std_maybe_Maybe_1_None };
		branch_Maybe_4 = v7;
	}
	return branch_Maybe_4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x142de
testb %al, %al
je 0x1420e
movq %rbx, %rdi
callq 0x1307d
movq %rax, %rdi
movq %rdx, %rsi
callq 0x8d0c
pushq $0x1
popq %rax
jmp 0x14212
xorl %eax, %eax
xorl %edx, %edx
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_bind_1_sp8
static struct std_maybe_Maybe_1 mw_std_maybe_Maybe_1_bind_1_sp8 (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_maybe_Maybe_1 v5 = mw_mirth_mirth_Prop_1_readyzy(V_mirth_mirth_Prop_1(v4));
			branch_Maybe_3 = v5;
		} break;
		case std_maybe_Maybe_1_None: {
			struct std_maybe_Maybe_1 v6 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_3 = v6;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	return branch_Maybe_3;
}

// Assembly:
cmpl $0x1, %edi
jne 0x142b4
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
movq %rsi, %rdi
callq 0xd491
movq %rax, %rdi
movl 0x18(%rax), %ebx
movq 0x20(%rax), %r14
movq %r14, %r15
andq %r13, %r15
setne %cl
testb $0x3, %r14b
sete %r12b
andb %cl, %r12b
cmpb $0x1, %r12b
jne 0x14269
incl (%r15)
andq %r13, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x1428a
decl (%rax)
jne 0x1428a
leaq 0xf454c(%rip), %rsi     # 0x1087d1
callq 0xce94
testl %ebx, %ebx
je 0x142b9
testb %r12b, %r12b
je 0x142ae
decl (%r15)
jne 0x142ae
shlq $0x30, %rbx
orq %r14, %rbx
leaq 0xf4573(%rip), %rsi     # 0x108819
movq %rbx, %rdi
callq 0xce94
xorl %eax, %eax
xorl %edx, %edx
jmp 0x142cf
xorl %eax, %eax
xorl %edx, %edx
retq
movq %r14, %rdi
callq 0x146cb
movq %rax, %rdi
movq %rdx, %rsi
callq 0x8d0c
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_mirth_PropState_1_free
void mirth_mirth_PropState_1_free (VAL v) {
	struct mirth_mirth_PropState_1 self = V_mirth_mirth_PropState_1(v);
	switch (self.tag) {
		case mirth_mirth_PropState_1_Ready: {
			decref(self.ptr.Ready->m0);
			free(self.ptr.Ready);
		} break;
		case mirth_mirth_PropState_1_Delay: {
			decref(MK_mirth_mirth_LexicalState(self.ptr.Delay->mLexicalState));
			decref(self.ptr.Delay->m1);
			decref(self.ptr.Delay->m0);
			free(self.ptr.Delay);
		} break;
		case mirth_mirth_PropState_1_Computing: break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
movq %rdi, %rax
shrq $0x30, %rax
andq %r14, %rbx
cmpq $0x1, %rax
je 0x1436f
testl %eax, %eax
jne 0x14402
testb $0x1, 0x10(%rbx)
je 0x143f6
leaq 0x8(%rbx), %rax
movq (%rax), %rcx
andq %rcx, %r14
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x143f6
decl (%r14)
jne 0x143f6
leaq 0x10(%rbx), %rcx
jmp 0x143eb
movq 0x8(%rbx), %rdi
movq %rdi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x14397
decl (%rax)
jne 0x14397
leaq 0xf44cf(%rip), %rsi     # 0x108861
callq 0xce94
testb $0x1, 0x18(%rbx)
je 0x143c5
movq 0x10(%rbx), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x143c5
decl (%rax)
jne 0x143c5
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0xce94
testb $0x1, 0x28(%rbx)
je 0x143f6
leaq 0x20(%rbx), %rax
movq (%rax), %rcx
andq %rcx, %r14
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x143f6
decl (%r14)
jne 0x143f6
leaq 0x28(%rbx), %rcx
movq (%rax), %rdi
movq (%rcx), %rsi
callq 0xce94
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_mirth_LexicalState_free
static void mirth_mirth_LexicalState_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_mirth_LexicalState);
	struct mirth_mirth_LexicalState* self = vself.data.ptr;
	decref(MK_std_maybe_Maybe_1(self->merrorzetoken));
	decref(MK_std_maybe_Maybe_1(self->mdefiningzenamespace));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xf43fa(%rip), %rax     # 0x108861
cmpq %rsi, %rax
jne 0x144eb
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x10(%rdi), %rcx
leaq 0xf3e3d(%rip), %r14     # 0x1082c1
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x144ae
decl (%rax)
jne 0x144ae
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xce94
movq 0x20(%rbx), %rax
andq %rax, %r15
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x144d9
decl (%r15)
jne 0x144d9
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xce94
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
leaq 0xc21d5(%rip), %rsi     # 0xd66c7
pushq $0x2
popq %rdi
pushq $0x58
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_mirth_Prop_1_free
static void mirth_mirth_Prop_1_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_mirth_Prop_1);
	struct mirth_mirth_Prop_1* self = vself.data.ptr;
	decref(MK_mirth_mirth_PropLabel(self->mlabel));
	decref(MK_mirth_mirth_PropState_1(self->mstate));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0xf426a(%rip), %rax     # 0x1087d1
cmpq %rsi, %rax
jne 0x145e6
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
movq 0x10(%rdi), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x145ab
decl (%rax)
jne 0x145ab
leaq 0xf430e(%rip), %rsi     # 0x1088a9
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
callq 0xce94
movq 0x20(%rbx), %rax
andq %rax, %r14
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x145da
decl (%r14)
jne 0x145da
leaq 0xf424f(%rip), %rsi     # 0x108819
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
callq 0xce94
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0xc2153(%rip), %rsi     # 0xd6740
pushq $0x2
popq %rdi
pushq $0x52
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_mirth_PropState_1_Ready
static VAL mtp_mirth_mirth_PropState_1_Ready (struct mirth_mirth_PropState_1 in_PropState_1) {
	struct mirth_mirth_PropState_1_Ready v3 = *in_PropState_1.ptr.Ready;
	if (!--(in_PropState_1.ptr.Ready->refs)) {
		free(in_PropState_1.ptr.Ready);
	} else {
		incref(v3.m0);
	}
	return v3.m0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rbx
movq 0x10(%rdi), %r14
decl (%rdi)
je 0x14702
testb $0x1, %r14b
je 0x14707
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x14707
incl (%rax)
jmp 0x14707
callq 0x5030
movq %rbx, %rax
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_package_Package_name
static uint64_t mw_mirth_package_Package_name (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Package_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_package_Package_name, in_Package_2);
	VAL v6 = mut_get(v5);
	*out_zaMirth_3 = in_zaMirth_1;
	return V_mirth_name_Name(v6);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10f6dba(%rip), %rdi   # 0x110b4e0
callq 0x12f88
movq %rax, %rdi
callq 0x1307d
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq