LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x12b14
movq 0x10(%rdi), %rbx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x12b16
decl (%rax)
jne 0x12b16
leaq 0x102b5c(%rip), %rsi    # 0x115669
callq 0xd4e3
jmp 0x12b16
xorl %ebx, %ebx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe7a9
// File: /workspace/github_c_makefile_star2_O1/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 0x12b9f
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x1, 0x20(%rdi)
je 0x12b8d
cmpq $0x0, 0x10(%rbx)
je 0x12b8d
xorl %r14d, %r14d
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12c73
testb $0x1, %dl
je 0x12b84
movq %rax, %rcx
andq %r15, %rcx
sete %sil
testb $0x3, %al
setne %dil
orb %sil, %dil
jne 0x12b84
decl (%rcx)
jne 0x12b84
movq %rax, %rdi
movq %rdx, %rsi
callq 0xd4e3
incq %r14
cmpq 0x10(%rbx), %r14
jb 0x12b50
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x12c1a
movq %rdi, %r15
leaq 0xea89a(%rip), %rsi     # 0xfd459
movl $0x2, %edx
movl %ebx, %edi
callq 0x5060
leaq 0xd6d8e(%rip), %r14     # 0xe9960
cmpq $0x0, 0x10(%r15)
je 0x12c21
xorl %r12d, %r12d
leaq 0xeb81f(%rip), %r13     # 0xfe402
testq %r12, %r12
je 0x12bf7
movl $0x1, %edx
movl %ebx, %edi
movq %r13, %rsi
callq 0x5060
movq %r15, %rdi
movq %r12, %rsi
callq 0x12c73
movq %rax, %rdi
movq %rdx, %rsi
movl %ebx, %edx
callq 0x916a
incq %r12
cmpq 0x10(%r15), %r12
jb 0x12be3
jmp 0x12c21
leaq 0xd2f95(%rip), %r14     # 0xe5bb6
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_O1/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 0x12cac
cmpq %rsi, 0x10(%rdi)
jbe 0x12cba
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq 0x20(%rdi), %rax
je 0x12c9e
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x12c9e
popq %rbp
jmpq *%rax
leaq 0xd2ed3(%rip), %rsi     # 0xe5b78
movl $0x3d, %edx
jmp 0x12cc6
leaq 0xd2e57(%rip), %rsi     # 0xe5b0a
movl $0x31, %edx
jmp 0x12cc6
leaq 0xd2e7b(%rip), %rsi     # 0xe5b3c
movl $0x3b, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/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 0x12d02
cmpq %rdx, 0x8(%rbx)
jae 0x12dcf
cmpq %rax, 0x20(%rbx)
jne 0x12de4
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 0x11e8f
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 0x12da8
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x12c73
testb $0x1, %dl
je 0x12da0
movq %rax, %rcx
andq %r12, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x12da0
incl (%rax)
incq %r15
cmpq %r15, %r13
jne 0x12d7b
andq %rbx, %r12
sete %al
testb $0x3, %bl
setne %cl
orb %al, %cl
jne 0x12dd2
decl (%r12)
jne 0x12dd2
leaq 0x1028a4(%rip), %rsi    # 0x115669
movq %rbx, %rdi
callq 0xd4e3
jmp 0x12dd2
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd2dce(%rip), %rsi     # 0xe5bb9
movl $0x3d, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/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, %r12d
movl %edi, %eax
leaq 0x1(,%rax,2), %r15
movq %r15, %rdi
callq 0xe818
movq %r15, %rdi
callq 0xe818
movq %rax, %r15
testb %r15b, %r15b
js 0x12e8d
movl %r12d, %edi
callq 0x11871
leaq 0x1022d9(%rip), %rsi    # 0x115159
movq %rax, %rdi
callq 0x95f6
movq %rdx, %rdi
jmp 0x12e8f
xorl %edi, %edi
testb %r15b, %r15b
js 0x12eb2
callq 0xdaeb
movq %rax, %rdi
movq %rdx, %rsi
callq 0x942c
movq %r14, %rdi
movq %rax, %rsi
callq 0xe43c
movq %rax, %r14
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x102362(%rip), %rax    # 0x115231
cmpq %rsi, %rax
jne 0x12fe2
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 0x12f0d
decl (%rax)
jne 0x12f0d
leaq 0x102251(%rip), %rsi    # 0x115159
callq 0xd4e3
movq 0x18(%rbx), %rcx
leaq 0x1023a9(%rip), %r14    # 0x1152c1
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x12f42
decl (%rax)
jne 0x12f42
movl 0x10(%rbx), %edi
shlq $0x30, %rdi
orq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xd4e3
movq 0x28(%rbx), %rcx
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x12f70
decl (%rax)
jne 0x12f70
movl 0x20(%rbx), %edi
shlq $0x30, %rdi
orq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0xd4e3
movq 0x38(%rbx), %rcx
leaq 0x1022fe(%rip), %r14    # 0x115279
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x12fa5
decl (%rax)
jne 0x12fa5
movl 0x30(%rbx), %edi
shlq $0x30, %rdi
orq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0xd4e3
movq 0x48(%rbx), %rax
andq %rax, %r15
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x12fd0
decl (%r15)
jne 0x12fd0
movl 0x40(%rbx), %edi
shlq $0x30, %rdi
orq 0x48(%rbx), %rdi
movq %r14, %rsi
callq 0xd4e3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
leaq 0xd2df4(%rip), %rsi     # 0xe5ddd
movl $0x54, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/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 0x1309e
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 0xd2d97(%rip), %rsi     # 0xe5e3c
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/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 0x13182
incl (%rcx)
cmpl $0x1, %eax
jne 0x1319a
callq 0xdaeb
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testl %eax, %eax
jne 0x13206
cmpq $0x0, 0x110531a(%rip)   # 0x11184c0
jne 0x131e6
movl $0x31, %edi
callq 0xf9f7
movq $0x31, 0x10(%rax)
movups 0xd2d7d(%rip), %xmm0    # 0xe5f3e
movups %xmm0, 0x18(%rax)
movups 0xd2d82(%rip), %xmm0    # 0xe5f4e
movups %xmm0, 0x28(%rax)
movups 0xd2d87(%rip), %xmm0    # 0xe5f5e
movups %xmm0, 0x38(%rax)
movb $0x2e, 0x48(%rax)
movq %rax, 0x11052da(%rip)   # 0x11184c0
movq 0x11052d3(%rip), %rdi   # 0x11184c0
andq %rdi, %r15
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x13201
incl (%r15)
callq 0x95a5
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0xd152e(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0xd1533(%rip), %xmm0    # 0xe475d
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x95a5
// File: /workspace/github_c_makefile_star2_O1/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 0x137f2
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xd2dff(%rip), %rsi     # 0xe65f8
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/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 0x13d04
cmpl $0x1, %eax
jne 0x13cdf
movq %rdx, %rdi
callq 0xdaeb
movq -0x30(%rbp), %rbx
leaq 0x1104835(%rip), %rdi   # 0x11184c8
movq %rax, %rsi
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
movq %rax, %rdi
movq %rdx, %rsi
callq 0x942c
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %r12, %rcx
sete %dl
testb $0x3, %r12b
setne %sil
orb %dl, %sil
jne 0x13ccd
incl (%rcx)
movq %rax, %rdi
movq %r12, %rsi
callq 0xe2eb
testl %eax, %eax
setne %al
jmp 0x13ce5
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_O1/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 0x140af
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %r12
shrq $0xa, %r12
movq (%rdi), %r13
cmpq %r13, %r12
jb 0x14063
leaq (%r12,%r13), %rax
movq 0x8(%r14), %rdi
leaq 0x20(,%rax,8), %rsi
callq 0x50f0
testq %rax, %rax
je 0x140bd
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 0x8(%r14), %r15
cmpq $0x0, (%r15,%r12,8)
jne 0x1408c
movl $0x400, %edi            # imm = 0x400
movl $0x10, %esi
callq 0x50c0
movq %rax, (%r15,%r12,8)
movq 0x8(%r14), %rax
cmpq $0x0, (%rax,%r12,8)
je 0x140cb
andl $0x3ff, %ebx            # imm = 0x3FF
movq 0x8(%r14), %rax
shll $0x4, %ebx
addq (%rax,%r12,8), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd1eba(%rip), %rsi     # 0xe5f70
movl $0x33, %edx
jmp 0x140d7
leaq 0xd1ee0(%rip), %rsi     # 0xe5fa4
movl $0x38, %edx
jmp 0x140d7
leaq 0xd1f0b(%rip), %rsi     # 0xe5fdd
movl $0x44, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/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 0x1412a
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x14138
movq (%rdi), %rax
testb $0x1, %dl
je 0x14128
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %sil
testb $0x3, %al
setne %dil
orb %sil, %dil
jne 0x14128
incl (%rcx)
popq %rbp
retq
leaq 0xd1ef1(%rip), %rsi     # 0xe6022
movl $0x20, %edx
jmp 0x14144
leaq 0xd1f04(%rip), %rsi     # 0xe6043
movl $0x22, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/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 0xe7a9
movq %rax, %r15
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
callq 0x12a76
leaq -0x28(%rbp), %r14
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x141df
movq (%r14), %r14
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x141ca
decl (%rcx)
jne 0x141ca
leaq 0x100f4f(%rip), %rsi    # 0x115111
movq %rax, %rdi
callq 0xd4e3
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_O1/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 0x14858
movq 0x10(%rsi), %r8
addq $0x18, %rsi
movq %rsi, %r9
jmp 0x14871
decq %rsi
sarq %rsi
js 0x1495a
leaq -0x30(%rbp), %r9
movq %rsi, (%r9)
movl $0x2, %r8d
testq %r8, %r8
je 0x148f2
movq 0x10(%rdi), %rsi
movl %edx, %edx
leaq (%rdi,%rcx,4), %r10
addq $0x1c, %r10
leaq 0x1(%rcx), %r11
xorl %eax, %eax
xorl %ebx, %ebx
leaq (%rcx,%rax), %r14
cmpq %rsi, %r14
jae 0x14935
leaq (%r11,%rax), %r15
cmpq %rsi, %r15
jae 0x148ac
movl (%r10,%rax,4), %r14d
shlq $0x20, %r14
jmp 0x148af
xorl %r14d, %r14d
movl (%r9,%rax,4), %r13d
imulq %rdx, %r13
addq %rbx, %r13
movl -0x4(%r10,%rax,4), %r12d
orq %r14, %r12
xorl %ebx, %ebx
subq %r13, %r12
setb %r13b
setae %r14b
movl %r12d, -0x4(%r10,%rax,4)
cmpq %rsi, %r15
jae 0x148e1
shrq $0x20, %r12
movl %r12d, (%r10,%rax,4)
movb %r13b, %bl
shlq $0x20, %rbx
incq %rax
cmpq %rax, %r8
jne 0x1488c
jmp 0x148f7
movb $0x1, %r14b
xorl %eax, %eax
testb %r14b, %r14b
jne 0x14926
leaq (%rcx,%rax), %rsi
incq %rsi
movq 0x10(%rdi), %rdx
cmpq %rsi, %rdx
jbe 0x14926
addq $-0x2, %rdx
addq %rcx, %rax
addl $-0x1, 0x1c(%rdi,%rax,4)
jb 0x14926
leaq 0x1(%rax), %rcx
cmpq %rax, %rdx
movq %rcx, %rax
jne 0x14913
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd19da(%rip), %rsi     # 0xe6316
movl $0x3f, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
leaq 0xd197f(%rip), %rsi     # 0xe62e0
movl $0x35, %edx
jmp 0x14941
// File: /workspace/github_c_makefile_star2_O1/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 0x1498b
movq 0x10(%rsi), %r8
addq $0x18, %rsi
movq %rsi, %rcx
jmp 0x149a4
decq %rsi
sarq %rsi
js 0x14a1b
leaq -0x8(%rbp), %rcx
movq %rsi, (%rcx)
movl $0x2, %r8d
movq 0x10(%rdi), %rdx
movq %rdx, %rax
cmpq %r8, %rax
jbe 0x149c2
cmpl $0x0, 0x14(%rdi,%rax,4)
leaq -0x1(%rax), %rax
je 0x149ab
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x14a15
movq %r8, %rax
movq %rax, %rsi
cmpq %rdx, %rax
jbe 0x149df
leaq -0x1(%rsi), %rax
cmpl $0x0, -0x4(%rcx,%rsi,4)
je 0x149c5
movl $0x1, %eax
jmp 0x149e4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rdx, %rsi
ja 0x14a15
cmpq %rdx, %r8
cmovbq %r8, %rdx
subq $0x1, %rdx
jb 0x14a13
movl 0x18(%rdi,%rdx,4), %esi
movl (%rcx,%rdx,4), %r8d
cmpl %r8d, %esi
je 0x14a0c
seta %al
movzbl %al, %eax
sbbl $0x0, %eax
cmpl %r8d, %esi
je 0x149f0
jmp 0x14a15
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
leaq 0xd1934(%rip), %rsi     # 0xe6356
movl $0x35, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/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 0x14af8
movq %rsi, %rax
movq %rdi, %rcx
movq (%rdx), %rdi
movq 0x8(%rdx), %rsi
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
testb $0x1, %sil
je 0x14af7
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x14af7
decl (%rax)
je 0xd4e3
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xd18fd(%rip), %rsi     # 0xe6400
movl $0x20, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/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 0x1973b
movl %eax, %r14d
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x14db4
decl (%rax)
jne 0x14db4
movq %r14, %rdi
shlq $0x30, %rdi
orq %rdx, %rdi
leaq 0x100512(%rip), %rsi    # 0x1152c1
callq 0xd4e3
leaq 0x1(,%r14,2), %rdi
movl $0x1, %esi
callq 0xec04
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_O1/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 0x1103f44(%rip), %rdi   # 0x1118f98
callq 0x13ff0
movq %rax, %r15
movq %rax, %rdi
callq 0x153b0
testb %al, %al
je 0x15086
movq %r15, %rdi
callq 0x140f0
movq %rax, %r12
movabsq $0xfffffffffffc, %rdx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdx
shrq $0x30, %r12
jmp 0x1509c
leaq 0x1001ec(%rip), %rsi    # 0x115279
xorl %r12d, %r12d
xorl %edi, %edi
movq %r15, %rdx
callq 0x14ab5
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_O1/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 0x11033af(%rip), %rdi   # 0x11184e0
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
movl $0x1, %ecx
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rdx
callq 0x157ee
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11033ae(%rip), %rdi   # 0x1118520
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
movq %rax, %rdi
callq 0x1585d
movq %rax, %r12
leaq 0x110339f(%rip), %rdi   # 0x1118530
movq %r15, %rsi
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
movl $0x1, %ecx
movl $0x1, %edi
movq %r12, %rsi
movq %rax, %rdx
callq 0x157ee
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x195e0
movq %rax, %rdi
callq 0x1963c
movq %rax, %r12
movq (%r15), %r15
leaq -0x30(%rbp), %r13
movl %r14d, %edi
movq %r13, %rsi
callq 0x15f0e
leaq -0x38(%rbp), %r14
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x13236
movq (%r13), %rcx
movl $0x2, %edi
movq %r12, %rsi
movq %rax, %rdx
callq 0x157ee
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_O1/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 0x1103988(%rip), %rdi   # 0x1118be0
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
movq %rax, %rdi
callq 0x1968f
xorl %edi, %edi
movq %rax, %rsi
callq 0x196e2
movq %rax, %r12
leaq 0x110396f(%rip), %rdi   # 0x1118bf0
movq %r15, %rsi
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
movl $0x1, %ecx
movl $0x3, %edi
movq %r12, %rsi
movq %rax, %rdx
callq 0x157ee
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x153b0
testb %al, %al
je 0x152de
movq %rbx, %rdi
callq 0x140f0
movq %rax, %rdi
movq %rdx, %rsi
callq 0x95f6
movl $0x1, %eax
jmp 0x152e2
xorl %eax, %eax
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15384
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 0xdaeb
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 0x15339
incl (%r15)
andq %r13, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x1535a
decl (%rax)
jne 0x1535a
leaq 0x10047c(%rip), %rsi    # 0x1157d1
callq 0xd4e3
testl %ebx, %ebx
je 0x15389
testb %r12b, %r12b
je 0x1537e
decl (%r15)
jne 0x1537e
shlq $0x30, %rbx
orq %r14, %rbx
leaq 0x1004a3(%rip), %rsi    # 0x115819
movq %rbx, %rdi
callq 0xd4e3
xorl %eax, %eax
xorl %edx, %edx
jmp 0x153a1
xorl %eax, %eax
xorl %edx, %edx
retq
movq %r14, %rdi
callq 0x157a7
movq %rax, %rdi
movq %rdx, %rsi
callq 0x95f6
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_O1/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 0x15447
testl %eax, %eax
jne 0x154da
testb $0x1, 0x10(%rbx)
je 0x154ce
leaq 0x8(%rbx), %rax
movq (%rax), %rcx
andq %rcx, %r14
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x154ce
decl (%r14)
jne 0x154ce
leaq 0x10(%rbx), %rcx
jmp 0x154c3
movq 0x8(%rbx), %rdi
movq %rdi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x1546f
decl (%rax)
jne 0x1546f
leaq 0x1003f7(%rip), %rsi    # 0x115861
callq 0xd4e3
testb $0x1, 0x18(%rbx)
je 0x1549d
movq 0x10(%rbx), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x1549d
decl (%rax)
jne 0x1549d
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0xd4e3
testb $0x1, 0x28(%rbx)
je 0x154ce
leaq 0x20(%rbx), %rax
movq (%rax), %rcx
andq %rcx, %r14
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x154ce
decl (%r14)
jne 0x154ce
leaq 0x28(%rbx), %rcx
movq (%rax), %rdi
movq (%rcx), %rsi
callq 0xd4e3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x100324(%rip), %rax    # 0x115861
cmpq %rsi, %rax
jne 0x155c1
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x10(%rdi), %rcx
leaq 0xffd67(%rip), %r14     # 0x1152c1
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x15584
decl (%rax)
jne 0x15584
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xd4e3
movq 0x20(%rbx), %rax
andq %rax, %r15
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x155af
decl (%r15)
jne 0x155af
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xd4e3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
leaq 0xd10b5(%rip), %rsi     # 0xe667d
movl $0x58, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/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 0x100190(%rip), %rax    # 0x1157d1
cmpq %rsi, %rax
jne 0x156c0
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 0x15685
decl (%rax)
jne 0x15685
leaq 0x100234(%rip), %rsi    # 0x1158a9
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
callq 0xd4e3
movq 0x20(%rbx), %rax
andq %rax, %r14
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x156b4
decl (%r14)
jne 0x156b4
leaq 0x100175(%rip), %rsi    # 0x115819
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
callq 0xd4e3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0xd102f(%rip), %rsi     # 0xe66f6
movl $0x52, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/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 0x157de
testb $0x1, %r14b
je 0x157e3
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x157e3
incl (%rax)
jmp 0x157e3
callq 0x5030
movq %rbx, %rax
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15838
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 0xd0f27(%rip), %rsi     # 0xe6766
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/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 0x1588b
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xd0f06(%rip), %rsi     # 0xe6798
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/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 0x15d48
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movq %r14, %rcx
andq %rax, %rcx
sete %dl
testb $0x3, %r14b
setne %sil
orb %dl, %sil
jne 0x15d0f
incl (%rcx)
testb $0x1, %r9b
je 0x15d2d
movq %r8, %rcx
andq %rax, %rcx
sete %dl
testb $0x3, %r8b
setne %sil
orb %dl, %sil
jne 0x15d2d
incl (%rcx)
testb $0x1, %r12b
je 0x15d5d
andq %r13, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0x15d5d
incl (%rax)
jmp 0x15d5d
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_O1/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 %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0x2, (%rdi)
jb 0x15df4
movl $0x1, %edi
movl $0x28, %esi
callq 0x50c0
testq %rax, %rax
je 0x15e43
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 0x15de5
incl (%rcx)
movl %r15d, 0x18(%rax)
movq %r14, 0x20(%rax)
decl (%rbx)
movq %rax, %rbx
jmp 0x15e35
movq 0x20(%rbx), %rcx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rcx, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x15e2d
decl (%rax)
jne 0x15e2d
leaq 0xff9fc(%rip), %rsi     # 0x115819
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
callq 0xd4e3
movl %r15d, 0x18(%rbx)
movq %r14, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd0980(%rip), %rsi     # 0xe67ca
movl $0x34, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/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 0x15e9c
movl $0x1, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xd096c(%rip), %rsi     # 0xe680f
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/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 0x13149
movq 0x10(%rax), %r14
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x19629
decl (%rcx)
jne 0x19629
leaq 0xfc090(%rip), %rsi     # 0x1156b1
movq %rax, %rdi
callq 0xd4e3
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_O1/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 0x1966a
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xcd1d0(%rip), %rsi     # 0xe6841
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130