LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x1276c
movq 0x10(%rdi), %rbx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x1276e
decl (%rax)
jne 0x1276e
leaq 0xfef04(%rip), %rsi     # 0x111669
callq 0xd13d
jmp 0x1276e
xorl %ebx, %ebx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe3d6
// File: /workspace/github_c_makefile_star2_O3/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 0x127f7
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x1, 0x20(%rdi)
je 0x127e5
cmpq $0x0, 0x10(%rbx)
je 0x127e5
xorl %r14d, %r14d
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq %rbx, %rdi
movq %r14, %rsi
callq 0x128cb
testb $0x1, %dl
je 0x127dc
movq %rax, %rcx
andq %r15, %rcx
sete %sil
testb $0x3, %al
setne %dil
orb %sil, %dil
jne 0x127dc
decl (%rcx)
jne 0x127dc
movq %rax, %rdi
movq %rdx, %rsi
callq 0xd13d
incq %r14
cmpq 0x10(%rbx), %r14
jb 0x127a8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x12872
movq %rdi, %r15
leaq 0xe6b11(%rip), %rsi     # 0xf9328
movl $0x2, %edx
movl %ebx, %edi
callq 0x5060
leaq 0xd3005(%rip), %r14     # 0xe582f
cmpq $0x0, 0x10(%r15)
je 0x12879
xorl %r12d, %r12d
leaq 0xe7a96(%rip), %r13     # 0xfa2d1
testq %r12, %r12
je 0x1284f
movl $0x1, %edx
movl %ebx, %edi
movq %r13, %rsi
callq 0x5060
movq %r15, %rdi
movq %r12, %rsi
callq 0x128cb
movq %rax, %rdi
movq %rdx, %rsi
movl %ebx, %edx
callq 0x8ec1
incq %r12
cmpq 0x10(%r15), %r12
jb 0x1283b
jmp 0x12879
leaq 0xcf284(%rip), %r14     # 0xe1afd
movl $0x2, %edx
movl %ebx, %edi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5060
// File: /workspace/github_c_makefile_star2_O3/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 0x12904
cmpq %rsi, 0x10(%rdi)
jbe 0x12912
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq 0x20(%rdi), %rax
je 0x128f6
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x128f6
popq %rbp
jmpq *%rax
leaq 0xcf1c2(%rip), %rsi     # 0xe1abf
movl $0x3d, %edx
jmp 0x1291e
leaq 0xcf146(%rip), %rsi     # 0xe1a51
movl $0x31, %edx
jmp 0x1291e
leaq 0xcf16a(%rip), %rsi     # 0xe1a83
movl $0x3b, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0x1295a
cmpq %rdx, 0x8(%rbx)
jae 0x12a27
cmpq %rax, 0x20(%rbx)
jne 0x12a3c
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 0x11a5b
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)
sete %al
testq %r13, %r13
sete %cl
orb %al, %cl
jne 0x12a00
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x128cb
testb $0x1, %dl
je 0x129f8
movq %rax, %rcx
andq %r12, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x129f8
incl (%rax)
incq %r15
cmpq %r15, %r13
jne 0x129d3
andq %rbx, %r12
sete %al
testb $0x3, %bl
setne %cl
orb %al, %cl
jne 0x12a2a
decl (%r12)
jne 0x12a2a
leaq 0xfec4c(%rip), %rsi     # 0x111669
movq %rbx, %rdi
callq 0xd13d
jmp 0x12a2a
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcf0bd(%rip), %rsi     # 0xe1b00
movl $0x3d, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_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, %eax
leaq 0x1(,%rax,2), %r12
movq %r12, %rdi
callq 0xe445
movq %r12, %rdi
callq 0xe445
testb %al, %al
js 0x12afd
movl %r15d, %edi
callq 0x1147d
leaq 0xfe685(%rip), %rsi     # 0x111159
movq %rax, %rdi
callq 0x9353
movq %rdx, %rdi
callq 0xd745
movq %rax, %rdi
movq %rdx, %rsi
callq 0x9189
movq %r14, %rdi
movq %rax, %rsi
callq 0xe069
movq %rax, %r14
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0xfe717(%rip), %rax     # 0x111231
cmpq %rsi, %rax
jne 0x12c2d
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 0x12b58
decl (%rax)
jne 0x12b58
leaq 0xfe606(%rip), %rsi     # 0x111159
callq 0xd13d
movq 0x18(%rbx), %rcx
leaq 0xfe75e(%rip), %r14     # 0x1112c1
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x12b8d
decl (%rax)
jne 0x12b8d
movl 0x10(%rbx), %edi
shlq $0x30, %rdi
orq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xd13d
movq 0x28(%rbx), %rcx
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x12bbb
decl (%rax)
jne 0x12bbb
movl 0x20(%rbx), %edi
shlq $0x30, %rdi
orq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0xd13d
movq 0x38(%rbx), %rcx
leaq 0xfe6b3(%rip), %r14     # 0x111279
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x12bf0
decl (%rax)
jne 0x12bf0
movl 0x30(%rbx), %edi
shlq $0x30, %rdi
orq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0xd13d
movq 0x48(%rbx), %rax
andq %rax, %r15
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x12c1b
decl (%r15)
jne 0x12c1b
movl 0x40(%rbx), %edi
shlq $0x30, %rdi
orq 0x48(%rbx), %rdi
movq %r14, %rsi
callq 0xd13d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
leaq 0xcf0f0(%rip), %rsi     # 0xe1d24
movl $0x54, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_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
movl $0x1, %edi
movl $0x28, %esi
callq 0x50c0
testq %rax, %rax
je 0x12ce9
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 0xcf093(%rip), %rsi     # 0xe1d83
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 0x12dcd
incl (%rcx)
cmpl $0x1, %eax
jne 0x12de5
callq 0xd745
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testl %eax, %eax
jne 0x12e4f
movq 0x11016d0(%rip), %rdi   # 0x11144c0
testq %rdi, %rdi
jne 0x12e36
movl $0x31, %edi
callq 0xf5e4
movq %rax, %rdi
movq $0x31, 0x10(%rax)
movups 0xcf074(%rip), %xmm0    # 0xe1e85
movups %xmm0, 0x18(%rax)
movups 0xcf079(%rip), %xmm0    # 0xe1e95
movups %xmm0, 0x28(%rax)
movups 0xcf07e(%rip), %xmm0    # 0xe1ea5
movups %xmm0, 0x38(%rax)
movb $0x2e, 0x48(%rax)
movq %rax, 0x110168a(%rip)   # 0x11144c0
andq %rdi, %r15
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x12e4a
incl (%r15)
callq 0x9302
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0xcd865(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0xcd86a(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_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
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x13449
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xcf0a9(%rip), %rsi     # 0xe24f9
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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, -0x38(%rbp)
movq %rdx, %r13
movq %rsi, %r12
leaq -0x30(%rbp), %rdx
movq %r13, %rsi
callq 0x13985
cmpl $0x1, %eax
jne 0x13960
movq %rdx, %rdi
callq 0xd745
movq -0x30(%rbp), %rbx
leaq 0x1100bb4(%rip), %rdi   # 0x11144c8
movq %rax, %rsi
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
movq %rax, %rdi
movq %rdx, %rsi
callq 0x9189
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %r12, %rcx
sete %dl
testb $0x3, %r12b
setne %sil
orb %dl, %sil
jne 0x1394e
incl (%rcx)
movq %rax, %rdi
movq %r12, %rsi
callq 0xdf18
testl %eax, %eax
setne %al
jmp 0x13966
movq -0x30(%rbp), %rbx
xorl %eax, %eax
movb %al, (%r15)
movq %r13, (%r14)
movq -0x38(%rbp), %rax
movq %rbx, (%rax)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0x13d41
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %r12
shrq $0xa, %r12
movq (%rdi), %r13
cmpq %r13, %r12
jae 0x13cb7
movq 0x8(%r14), %r15
jmp 0x13cfa
leaq (%r12,%r13), %rax
movq 0x8(%r14), %rdi
leaq 0x20(,%rax,8), %rsi
callq 0x50f0
testq %rax, %rax
je 0x13d4f
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 0x13d23
movl $0x400, %edi            # imm = 0x400
movl $0x10, %esi
callq 0x50c0
movq %rax, (%r15,%r12,8)
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0x13d5d
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 0xce16f(%rip), %rsi     # 0xe1eb7
movl $0x33, %edx
jmp 0x13d69
leaq 0xce195(%rip), %rsi     # 0xe1eeb
movl $0x38, %edx
jmp 0x13d69
leaq 0xce1c0(%rip), %rsi     # 0xe1f24
movl $0x44, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0x13dbc
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x13dca
movq (%rdi), %rax
testb $0x1, %dl
je 0x13dba
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %sil
testb $0x3, %al
setne %dil
orb %sil, %dil
jne 0x13dba
incl (%rcx)
popq %rbp
retq
leaq 0xce1a6(%rip), %rsi     # 0xe1f69
movl $0x20, %edx
jmp 0x13dd6
leaq 0xce1b9(%rip), %rsi     # 0xe1f8a
movl $0x22, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 0xe3d6
movq %rax, %r15
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
callq 0x126ce
leaq -0x28(%rbp), %r14
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x13e71
movq (%r14), %r14
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x13e5c
decl (%rcx)
jne 0x13e5c
leaq 0xfd2bd(%rip), %rsi     # 0x111111
movq %rax, %rdi
callq 0xd13d
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_O3/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
movq $0x0, -0x30(%rbp)
testb $0x1, %sil
jne 0x14535
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x145f2
addq $0x18, %rsi
movq %rsi, %r8
jmp 0x1454d
decq %rsi
sarq %rsi
js 0x14626
leaq -0x30(%rbp), %r8
movq %rsi, (%r8)
movl $0x2, %eax
movabsq $0x100000000, %rsi      # imm = 0x100000000
movq 0x10(%rdi), %r9
movl %edx, %edx
movq %rax, %r10
negq %r10
leaq (%rdi,%rcx,4), %r11
movl $0x6, %ebx
xorl %r15d, %r15d
movq %rcx, %r14
cmpq %r9, %r14
jae 0x14601
movl -0x18(%r8,%rbx,4), %r12d
imulq %rdx, %r12
addq %r15, %r12
incq %r14
cmpq %r9, %r14
jae 0x1459d
subq %r12, (%r11,%rbx,4)
movq %rsi, %r15
jb 0x145b3
xorl %r15d, %r15d
jmp 0x145b3
movl (%r11,%rbx,4), %r13d
movq %rsi, %r15
cmpq %r13, %r12
ja 0x145ac
xorl %r15d, %r15d
subl %r12d, %r13d
movl %r13d, (%r11,%rbx,4)
leaq (%r10,%rbx), %r12
incq %r12
incq %rbx
cmpq $0x6, %r12
jne 0x14572
testq %r15, %r15
je 0x145f2
leaq (%rcx,%rax), %rsi
incq %rsi
movq 0x10(%rdi), %rdx
cmpq %rsi, %rdx
jbe 0x145f2
addq $-0x2, %rdx
addq %rcx, %rax
addl $-0x1, 0x1c(%rdi,%rax,4)
jb 0x145f2
leaq 0x1(%rax), %rcx
cmpq %rax, %rdx
movq %rcx, %rax
jne 0x145df
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcdc0f(%rip), %rsi     # 0xe2217
movl $0x3f, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
leaq 0xcdbb4(%rip), %rsi     # 0xe21e1
movl $0x35, %edx
jmp 0x1460d
// File: /workspace/github_c_makefile_star2_O3/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
movq $0x0, -0x8(%rbp)
testb $0x1, %sil
jne 0x14657
movq 0x10(%rsi), %rdx
addq $0x18, %rsi
movq %rsi, %rax
jmp 0x1466b
decq %rsi
sarq %rsi
js 0x146cc
leaq -0x8(%rbp), %rax
movq %rsi, (%rax)
movl $0x2, %edx
movq 0x10(%rdi), %rcx
movq %rcx, %rsi
cmpq %rdx, %rsi
jbe 0x14689
cmpl $0x0, 0x14(%rdi,%rsi,4)
leaq -0x1(%rsi), %rsi
je 0x14672
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x146c6
movq %rdx, %rsi
cmpq %rcx, %rsi
jbe 0x146a3
cmpl $0x0, -0x4(%rax,%rsi,4)
leaq -0x1(%rsi), %rsi
je 0x1468c
movl $0x1, %eax
jmp 0x146c6
cmpq %rcx, %rdx
cmovbq %rdx, %rcx
subq $0x1, %rcx
jb 0x146c4
movl (%rax,%rcx,4), %edx
cmpl %edx, 0x18(%rdi,%rcx,4)
je 0x146aa
seta %al
movzbl %al, %eax
sbbl $0x0, %eax
jmp 0x146c6
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
leaq 0xcdb84(%rip), %rsi     # 0xe2257
movl $0x35, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0x147a9
movq %rsi, %rax
movq %rdi, %rcx
movq (%rdx), %rdi
movq 0x8(%rdx), %rsi
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
testb $0x1, %sil
je 0x147a8
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x147a8
decl (%rax)
je 0xd13d
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xcdb4d(%rip), %rsi     # 0xe2301
movl $0x20, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 0x194d7
movl %eax, %r14d
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x14a65
decl (%rax)
jne 0x14a65
movq %r14, %rdi
shlq $0x30, %rdi
orq %rdx, %rdi
leaq 0xfc861(%rip), %rsi     # 0x1112c1
callq 0xd13d
leaq 0x1(,%r14,2), %rdi
movl $0x1, %esi
callq 0xe83a
testl %eax, %eax
sete %al
movq -0x18(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 0x1100297(%rip), %rdi   # 0x1114f98
callq 0x13c85
movq %rax, %r15
movq %rax, %rdi
callq 0x1505d
testb %al, %al
je 0x14d33
movq %r15, %rdi
callq 0x13d82
movq %rax, %r12
movabsq $0xfffffffffffc, %rdx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdx
shrq $0x30, %r12
jmp 0x14d49
leaq 0xfc53f(%rip), %rsi     # 0x111279
xorl %r12d, %r12d
xorl %edi, %edi
movq %r15, %rdx
callq 0x14766
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_O3/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
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10ff702(%rip), %rdi   # 0x11144e0
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
movl $0x1, %ecx
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rdx
callq 0x1549b
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10ff701(%rip), %rdi   # 0x1114520
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
movq %rax, %rdi
callq 0x1550a
movq %rax, %r12
leaq 0x10ff6f2(%rip), %rdi   # 0x1114530
movq %r15, %rsi
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
movl $0x1, %ecx
movl $0x1, %edi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1549b
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 0x1937c
movq %rax, %rdi
callq 0x193d8
movq %rax, %r12
movq (%r15), %r15
leaq -0x30(%rbp), %r13
movl %r14d, %edi
movq %r13, %rsi
callq 0x15bd6
leaq -0x38(%rbp), %r14
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x12e7f
movq (%r13), %rcx
movl $0x2, %edi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1549b
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_O3/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
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10ffcdb(%rip), %rdi   # 0x1114be0
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
movq %rax, %rdi
callq 0x1942b
xorl %edi, %edi
movq %rax, %rsi
callq 0x1947e
movq %rax, %r12
leaq 0x10ffcc2(%rip), %rdi   # 0x1114bf0
movq %r15, %rsi
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
movl $0x1, %ecx
movl $0x3, %edi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1549b
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_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 0x1505d
testb %al, %al
je 0x14f8b
movq %rbx, %rdi
callq 0x13d82
movq %rax, %rdi
movq %rdx, %rsi
callq 0x9353
movl $0x1, %eax
jmp 0x14f8f
xorl %eax, %eax
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x15031
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 0xd745
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 0x14fe6
incl (%r15)
andq %r13, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x15007
decl (%rax)
jne 0x15007
leaq 0xfc7cf(%rip), %rsi     # 0x1117d1
callq 0xd13d
testl %ebx, %ebx
je 0x15036
testb %r12b, %r12b
je 0x1502b
decl (%r15)
jne 0x1502b
shlq $0x30, %rbx
orq %r14, %rbx
leaq 0xfc7f6(%rip), %rsi     # 0x111819
movq %rbx, %rdi
callq 0xd13d
xorl %eax, %eax
xorl %edx, %edx
jmp 0x1504e
xorl %eax, %eax
xorl %edx, %edx
retq
movq %r14, %rdi
callq 0x15454
movq %rax, %rdi
movq %rdx, %rsi
callq 0x9353
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0x150f4
testl %eax, %eax
jne 0x15187
testb $0x1, 0x10(%rbx)
je 0x1517b
leaq 0x8(%rbx), %rax
movq (%rax), %rcx
andq %rcx, %r14
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x1517b
decl (%r14)
jne 0x1517b
leaq 0x10(%rbx), %rcx
jmp 0x15170
movq 0x8(%rbx), %rdi
movq %rdi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x1511c
decl (%rax)
jne 0x1511c
leaq 0xfc74a(%rip), %rsi     # 0x111861
callq 0xd13d
testb $0x1, 0x18(%rbx)
je 0x1514a
movq 0x10(%rbx), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x1514a
decl (%rax)
jne 0x1514a
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0xd13d
testb $0x1, 0x28(%rbx)
je 0x1517b
leaq 0x20(%rbx), %rax
movq (%rax), %rcx
andq %rcx, %r14
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x1517b
decl (%r14)
jne 0x1517b
leaq 0x28(%rbx), %rcx
movq (%rax), %rdi
movq (%rcx), %rsi
callq 0xd13d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xfc677(%rip), %rax     # 0x111861
cmpq %rsi, %rax
jne 0x1526e
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x10(%rdi), %rcx
leaq 0xfc0ba(%rip), %r14     # 0x1112c1
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x15231
decl (%rax)
jne 0x15231
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xd13d
movq 0x20(%rbx), %rax
andq %rax, %r15
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x1525c
decl (%r15)
jne 0x1525c
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xd13d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
leaq 0xcd309(%rip), %rsi     # 0xe257e
movl $0x58, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0xfc4e3(%rip), %rax     # 0x1117d1
cmpq %rsi, %rax
jne 0x1536d
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 0x15332
decl (%rax)
jne 0x15332
leaq 0xfc587(%rip), %rsi     # 0x1118a9
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
callq 0xd13d
movq 0x20(%rbx), %rax
andq %rax, %r14
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x15361
decl (%r14)
jne 0x15361
leaq 0xfc4c8(%rip), %rsi     # 0x111819
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
callq 0xd13d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0xcd283(%rip), %rsi     # 0xe25f7
movl $0x52, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0x1548b
testb $0x1, %r14b
je 0x15490
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x15490
incl (%rax)
jmp 0x15490
callq 0x5030
movq %rbx, %rax
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_name_QName_QName
static struct mirth_name_QName* mtw_mirth_name_QName_QName (struct mirth_name_Namespace in_Namespace_1, uint64_t in_Name_2, INT in_Int_3) {
	struct mirth_name_QName* v5 = calloc(1, sizeof *v5);
	ASSERT(v5);
	v5->refs = 1;
	v5->marity = in_Int_3;
	v5->mname = in_Name_2;
	v5->mnamespace = in_Namespace_1;
	return v5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %r12d
movl $0x1, %edi
movl $0x28, %esi
callq 0x50c0
testq %rax, %rax
je 0x154e5
movl $0x1, (%rax)
movq %r15, 0x20(%rax)
movq %r14, 0x18(%rax)
movl %r12d, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcd17b(%rip), %rsi     # 0xe2667
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_name_Namespace_Package
static struct mirth_name_Namespace mtw_mirth_name_Namespace_Package (uint64_t in_Package_1) {
	struct mirth_name_Namespace_Package* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mPackage = in_Package_1;
	struct mirth_name_Namespace v4 = { .tag=mirth_name_Namespace_Package, .ptr.Package=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x15538
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xcd15a(%rip), %rsi     # 0xe2699
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_mirth_PropState_1_Delay
static struct mirth_mirth_LexicalState* mtp_mirth_mirth_PropState_1_Delay (struct mirth_mirth_PropState_1 in_PropState_1, VAL *out_a_3, VAL *out__4) {
	struct mirth_mirth_PropState_1_Delay v5 = *in_PropState_1.ptr.Delay;
	if (!--(in_PropState_1.ptr.Delay->refs)) {
		free(in_PropState_1.ptr.Delay);
	} else {
		incref(MK_mirth_mirth_LexicalState(v5.mLexicalState));
		incref(v5.m1);
		incref(v5.m0);
	}
	*out__4 = v5.m0;
	*out_a_3 = v5.m1;
	return v5.mLexicalState;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r8
movq 0x18(%rdi), %r9
movq 0x20(%rdi), %r13
movq 0x28(%rdi), %r12
decl (%rdi)
je 0x15a06
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movq %r14, %rcx
andq %rax, %rcx
sete %dl
testb $0x3, %r14b
setne %sil
orb %dl, %sil
jne 0x159cd
incl (%rcx)
testb $0x1, %r9b
je 0x159eb
movq %r8, %rcx
andq %rax, %rcx
sete %dl
testb $0x3, %r8b
setne %sil
orb %dl, %sil
jne 0x159eb
incl (%rcx)
testb $0x1, %r12b
je 0x15a1b
andq %r13, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0x15a1b
incl (%rax)
jmp 0x15a1b
movq %r8, -0x38(%rbp)
movq %r9, -0x30(%rbp)
callq 0x5030
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %r8
movq %r13, (%r15)
movq %r12, 0x8(%r15)
movq %r8, (%rbx)
movq %r9, 0x8(%rbx)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_mirth_Prop_1_set_state
static struct mirth_mirth_Prop_1* mirth_mirth_Prop_1_set_state(struct mirth_mirth_Prop_1* self, struct mirth_mirth_PropState_1 x) {
	if (self->refs > 1) {
		struct mirth_mirth_Prop_1* self2 = calloc(1, sizeof * self2);
		ASSERT(self2); memcpy(self2, self, sizeof * self2);
		incref(MK_mirth_mirth_PropLabel(self2->mlabel));
		self2->mstate = x;
		self->refs--;
		return self2;
	}
	decref(MK_mirth_mirth_PropState_1(self->mstate));
	self->mstate = x;
	return self;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movl (%rdi), %r12d
cmpl $0x2, %r12d
jb 0x15abe
movl $0x1, %edi
movl $0x28, %esi
callq 0x50c0
testq %rax, %rax
je 0x15b0b
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x10(%rax)
movq 0x20(%rbx), %rcx
movq %rcx, 0x20(%rax)
movups %xmm0, (%rax)
movq 0x10(%rax), %rdx
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rcx
sete %sil
testb $0x3, %dl
setne %dl
orb %sil, %dl
jne 0x15aab
incl (%rcx)
movl (%rbx), %r12d
movl %r15d, 0x18(%rax)
movq %r14, 0x20(%rax)
decl %r12d
movl %r12d, (%rbx)
movq %rax, %rbx
jmp 0x15aff
movq 0x20(%rbx), %rcx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rcx, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x15af7
decl (%rax)
jne 0x15af7
leaq 0xfbd32(%rip), %rsi     # 0x111819
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
callq 0xd13d
movl %r15d, 0x18(%rbx)
movq %r14, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xccbb9(%rip), %rsi     # 0xe26cb
movl $0x34, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_mirth_PropState_1_Ready
static struct mirth_mirth_PropState_1 mtw_mirth_mirth_PropState_1_Ready (VAL in_b_1) {
	struct mirth_mirth_PropState_1_Ready* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->m0 = in_b_1;
	struct mirth_mirth_PropState_1 v4 = { .tag=mirth_mirth_PropState_1_Ready, .ptr.Ready=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x18, %esi
callq 0x50c0
testq %rax, %rax
je 0x15b64
movl $0x1, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xccba5(%rip), %rsi     # 0xe2710
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_module_Module_Prim
static uint64_t mw_mirth_module_Module_Prim (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_mirth_zaMirth* *out_zaMirth_2) {
	struct mirth_mirth_zaMirth* v4;
	struct mirth_mirth_Builtin* v5 = mw_mirth_mirth_zaMirth_builtin(in_zaMirth_1, &v4);
	uint64_t v6 = v5->mprim;
	decref(MK_mirth_mirth_Builtin(v5));
	*out_zaMirth_2 = v4;
	return v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq -0x18(%rbp), %rsi
callq 0x12d94
movq 0x10(%rax), %r14
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x193c5
decl (%rcx)
jne 0x193c5
leaq 0xf82f4(%rip), %rsi     # 0x1116b1
movq %rax, %rdi
callq 0xd13d
movq -0x18(%rbp), %rax
movq %rax, (%rbx)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_name_Namespace_Module
static struct mirth_name_Namespace mtw_mirth_name_Namespace_Module (uint64_t in_Module_1) {
	struct mirth_name_Namespace_Module* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mModule = in_Module_1;
	struct mirth_name_Namespace v4 = { .tag=mirth_name_Namespace_Module, .ptr.Module=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x19406
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xc9335(%rip), %rsi     # 0xe2742
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_tycon_Tycon_Data
static struct mirth_tycon_Tycon mtw_mirth_tycon_Tycon_Data (uint64_t in_Data_1) {
	struct mirth_tycon_Tycon_Data* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mData = in_Data_1;
	struct mirth_tycon_Tycon v4 = { .tag=mirth_tycon_Tycon_Data, .ptr.Data=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x19459
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xc9dd0(%rip), %rsi     # 0xe3230
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130