LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_external_ExternalDeclPart_free
void mirth_external_ExternalDeclPart_free (VAL v) {
	struct mirth_external_ExternalDeclPart self = V_mirth_external_ExternalDeclPart(v);
	switch (self.tag) {
		case mirth_external_ExternalDeclPart_EDPCode: {
			decref(MKSTR(self.ptr.EDPCode->mcode));
			free(self.ptr.EDPCode);
		} break;
		case mirth_external_ExternalDeclPart_EDPDef: {
			decref(MK_std_maybe_Maybe_1(self.ptr.EDPDef->mdoc));
			decref(MK_std_maybe_Maybe_1(self.ptr.EDPDef->msymbol));
			free(self.ptr.EDPDef);
		} break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq %rdi, %rax
shrq $0x30, %rax
andq %r15, %rbx
cmpq $0x1, %rax
je 0x5bf06
testl %eax, %eax
jne 0x5bf78
movq 0x10(%rbx), %rdi
andq %rdi, %r15
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x5bf66
decl (%r15)
jne 0x5bf66
leaq 0xac255(%rip), %rsi     # 0x108159
jmp 0x5bf61
movq 0x10(%rbx), %rcx
leaq 0xac3b0(%rip), %r14     # 0x1082c1
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x5bf3b
decl (%rax)
jne 0x5bf3b
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xce94
movq 0x28(%rbx), %rax
andq %rax, %r15
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x5bf66
decl (%r15)
jne 0x5bf66
movl 0x20(%rbx), %edi
shlq $0x30, %rdi
orq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0xce94
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mb_mirth_mirth_PropLabel_prop_1_sp47_0
static void mb_mirth_mirth_PropLabel_prop_1_sp47_0 (void) {
	uint64_t v0 = V_mirth_external_External(pop_value());
	struct mirth_mirth_zaMirth* r1 = V_mirth_mirth_zaMirth(pop_resource());
	struct mirth_mirth_zaMirth* v2;
	uint64_t v3 = mw_mirth_external_External_sig(r1, v0, &v2);
	struct mirth_elab_zaTypeElab* v4;
	mw_mirth_elab_zaTypeElab_Startzx(v3, &v4);
	struct mirth_type_StackType v5 = mw_mirth_type_T0();
	struct mirth_mirth_zaMirth* v6;
	struct mirth_elab_zaTypeElab* v7;
	struct mirth_type_ArrowType* v8 = mw_mirth_elab_zaTypeElab_elabzetypezesigzx(v2, v4, v5, &v6, &v7);
	struct std_list_List_1 v9 = v7->mctx;
	incref(MK_std_list_List_1(v9));
	PTUP r10 = PTRMK(0,tup_new(2),0);
	((TUP*)PTRPTR(r10))->size = 2;
	((TUP*)PTRPTR(r10))->cells[1] = MK_mirth_type_ArrowType(v8);
	((TUP*)PTRPTR(r10))->cells[0] = MK_std_list_List_1(v9);
	mw_mirth_elab_zaTypeElab_rdrop(v7);
	push_resource(MK_mirth_mirth_zaMirth(v6));
	push_value(MKTUP(r10));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
callq 0xd3d6
movq %rax, %rbx
callq 0xd429
movq %rax, %r14
leaq 0x10b0e44(%rip), %rdi   # 0x110ce48
movq %rbx, %rsi
callq 0x12f88
movq %rax, %rdi
callq 0x1307d
leaq -0x40(%rbp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31750
movq (%rbx), %rsi
pushq $0x2
popq %rdx
leaq -0x30(%rbp), %r8
leaq -0x38(%rbp), %rbx
movq %r14, %rdi
xorl %ecx, %ecx
movq %rbx, %r9
callq 0x31786
movq %rax, %r14
movq (%rbx), %rbx
movl (%rbx), %r13d
movq 0x8(%rbx), %rax
movq %rax, %rcx
andq %r12, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x5c061
incl (%rcx)
shlq $0x30, %r13
orq %rax, %r13
pushq $0x2
popq %rdi
callq 0xd928
movq %rax, %r15
andq %rax, %r12
movw $0x2, 0x6(%r12)
leaq 0xacaf4(%rip), %rax     # 0x108b79
movq %r14, 0x18(%r12)
movq %rax, 0x20(%r12)
movq %r13, 0x8(%r12)
leaq 0xac1de(%rip), %rax     # 0x108279
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0x31b94
movq -0x30(%rbp), %rdi
leaq 0xac83d(%rip), %rsi     # 0x1088f0
callq 0x883c
leaq 0xac2da(%rip), %rsi     # 0x108399
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd08e
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_type_CTypeStackPart_labelzy
static struct std_maybe_Maybe_1 mw_mirth_type_CTypeStackPart_labelzy (struct mirth_type_CTypeStackPart in_CTypeStackPart_1) {
	struct std_maybe_Maybe_1 branch_Maybe_3;
	switch ((in_CTypeStackPart_1).tag) {
		case mirth_type_CTypeStackPart_Cons: {
			struct mirth_type_CType v4 = mtp_mirth_type_CTypeStackPart_Cons(in_CTypeStackPart_1);
			decref(MK_mirth_type_CType(v4));
			struct std_maybe_Maybe_1 v5 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_3 = v5;
		} break;
		case mirth_type_CTypeStackPart_ConsLabel: {
			uint64_t v6;
			struct mirth_type_CType v7 = mtp_mirth_type_CTypeStackPart_ConsLabel(in_CTypeStackPart_1, &v6);
			decref(MK_mirth_type_CType(v7));
			struct std_maybe_Maybe_1 v8 = mtw_std_maybe_Maybe_1_Some(MK_mirth_label_Label(v6));
			branch_Maybe_3 = v8;
		} break;
		case mirth_type_CTypeStackPart_With: {
			struct mirth_type_CType v9 = mtp_mirth_type_CTypeStackPart_With(in_CTypeStackPart_1);
			decref(MK_mirth_type_CType(v9));
			struct std_maybe_Maybe_1 v10 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_3 = v10;
		} break;
		case mirth_type_CTypeStackPart_WithLabel: {
			uint64_t v11;
			struct mirth_type_CType v12 = mtp_mirth_type_CTypeStackPart_WithLabel(in_CTypeStackPart_1, &v11);
			decref(MK_mirth_type_CType(v12));
			struct std_maybe_Maybe_1 v13 = mtw_std_maybe_Maybe_1_Some(MK_mirth_label_Label(v11));
			branch_Maybe_3 = v13;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	return branch_Maybe_3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x3, %edi
ja 0x5cdb7
movl %edi, %eax
leaq 0x766a1(%rip), %rcx     # 0xd3390
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rsi, %rdi
callq 0x5e52f
jmp 0x5cd0a
movq %rsi, %rdi
callq 0x5e5c3
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rcx
sete %sil
testb $0x3, %dl
setne %dil
orb %sil, %dil
jne 0x5cd41
decl (%rcx)
jne 0x5cd41
shlq $0x30, %rax
orq %rdx, %rax
leaq 0xac038(%rip), %rsi     # 0x108d71
movq %rax, %rdi
callq 0xce94
xorl %eax, %eax
xorl %edx, %edx
jmp 0x5cdb1
leaq -0x8(%rbp), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x5e603
jmp 0x5cd67
leaq -0x8(%rbp), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x5e56f
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rcx
sete %sil
testb $0x3, %dl
setne %dil
orb %sil, %dil
jne 0x5cd9e
decl (%rcx)
jne 0x5cd9e
shlq $0x30, %rax
orq %rdx, %rax
leaq 0xabfdb(%rip), %rsi     # 0x108d71
movq %rax, %rdi
callq 0xce94
movq -0x8(%rbp), %rdi
leaq 0xac51f(%rip), %rsi     # 0x1092c8
callq 0x8d0c
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbp
retq
leaq 0x77a4f(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_type_CTypeStackPart_ctype
static struct mirth_type_CType mw_mirth_type_CTypeStackPart_ctype (struct mirth_type_CTypeStackPart in_CTypeStackPart_1) {
	struct mirth_type_CType branch_CType_3;
	switch ((in_CTypeStackPart_1).tag) {
		case mirth_type_CTypeStackPart_Cons: {
			struct mirth_type_CType v4 = mtp_mirth_type_CTypeStackPart_Cons(in_CTypeStackPart_1);
			branch_CType_3 = v4;
		} break;
		case mirth_type_CTypeStackPart_ConsLabel: {
			uint64_t v5;
			struct mirth_type_CType v6 = mtp_mirth_type_CTypeStackPart_ConsLabel(in_CTypeStackPart_1, &v5);
			branch_CType_3 = v6;
		} break;
		case mirth_type_CTypeStackPart_With: {
			struct mirth_type_CType v7 = mtp_mirth_type_CTypeStackPart_With(in_CTypeStackPart_1);
			branch_CType_3 = v7;
		} break;
		case mirth_type_CTypeStackPart_WithLabel: {
			uint64_t v8;
			struct mirth_type_CType v9 = mtp_mirth_type_CTypeStackPart_WithLabel(in_CTypeStackPart_1, &v8);
			branch_CType_3 = v9;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	return branch_CType_3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x3, %edi
ja 0x5ce2d
movl %edi, %eax
leaq 0x765bc(%rip), %rcx     # 0xd33a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rsi, %rdi
addq $0x10, %rsp
popq %rbp
jmp 0x5e52f
movq %rsi, %rdi
addq $0x10, %rsp
popq %rbp
jmp 0x5e5c3
leaq -0x8(%rbp), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x5e603
jmp 0x5ce27
leaq -0x8(%rbp), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x5e56f
addq $0x10, %rsp
popq %rbp
retq
leaq 0x779d9(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_type_CType_phantomzy
static bool mw_mirth_type_CType_phantomzy (struct mirth_type_CType in_CType_1) {
	bool branch_Bool_3;
	switch ((in_CType_1).tag) {
		case mirth_type_CType_Void: {
			STR* v4 = mtp_mirth_type_CType_Void(in_CType_1);
			decref(MKSTR(v4));
			bool v5 = true;
			branch_Bool_3 = v5;
		} break;
		default: {
			decref(MK_mirth_type_CType(in_CType_1));
			bool v6 = false;
			branch_Bool_3 = v6;
		} break;
	}
	return branch_Bool_3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
cmpl $0x6, %edi
jne 0x5ce84
movq %rsi, %rdi
callq 0x5e0bb
andq %rax, %r14
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0x5ceb0
decl (%r14)
jne 0x5ceb0
leaq 0xab2da(%rip), %rsi     # 0x108159
movq %rax, %rdi
jmp 0x5ceab
andq %rsi, %r14
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x5ceb0
decl (%r14)
jne 0x5ceb0
movq %rbx, %rdi
shlq $0x30, %rdi
orq %rsi, %rdi
leaq 0xabec6(%rip), %rsi     # 0x108d71
callq 0xce94
cmpl $0x6, %ebx
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_list_List_1_filterzesome_1_sp6
static struct std_list_List_1 mw_std_list_List_1_filterzesome_1_sp6 (struct std_list_List_1 in_List_1) {
	struct std_list_List_1 v3 = { .tag=std_list_List_1_Nil };
	struct std_list_List_1 v4;
	mw_std_list_List_1_buildzx(v3, &v4);
	bool v5 = true;
	struct std_list_List_1 r6 = v4;
	struct std_list_List_1 v7 = in_List_1;
	bool v8 = v5;
	bool v9 = v5;
	while (v9) {
		struct std_list_List_1 r10 = r6;
		struct std_list_List_1 v11 = v7;
		bool v12 = v8;
		struct std_list_List_1 branch_zaLister_13;
		struct std_list_List_1 branch_List_14;
		bool branch_Bool_15;
		switch ((v11).tag) {
			case std_list_List_1_Cons: {
				struct std_list_List_1 v16;
				VAL v17 = mtp_std_list_List_1_Cons(v11, &v16);
				struct std_maybe_Maybe_1 v18 = mw_mirth_type_CTypeStackPart_labelzy(V_mirth_type_CTypeStackPart(v17));
				struct std_list_List_1 v19;
				mw_std_maybe_Maybe_1_for_1_sp2(r10, v18, &v19);
				bool v20 = true;
				branch_Bool_15 = v20;
				branch_List_14 = v16;
				branch_zaLister_13 = v19;
			} break;
			case std_list_List_1_Nil: {
				struct std_list_List_1 v21 = { .tag=std_list_List_1_Nil };
				bool v22 = false;
				branch_Bool_15 = v22;
				branch_List_14 = v21;
				branch_zaLister_13 = r10;
			} break;
			default: {
				do_panic(str_make("unexpected fallthrough in match\n", 32));
			}
		}
		v9 = branch_Bool_15;
		v8 = branch_Bool_15;
		v7 = branch_List_14;
		r6 = branch_zaLister_13;
	}
	decref(MK_std_list_List_1(v7));
	struct std_list_List_1 v23 = mw_std_list_zaLister_1_donezx(r6);
	return v23;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r12
movl %edi, %r15d
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
xorl %edi, %edi
xorl %esi, %esi
callq 0xcd32
movl %eax, %ebx
movq %rdx, %r14
leaq -0x48(%rbp), %rcx
movb $0x1, %al
movq %r12, %rdi
testb $0x1, %al
je 0x5cf52
xorl %eax, %eax
movl $0x0, %r12d
testl %r15d, %r15d
je 0x5cef0
cmpl $0x1, %r15d
jne 0x5cf97
movq %rcx, %r15
movq %rcx, %rsi
callq 0xce01
movq %rax, %rdi
shrq $0x30, %rdi
andq %r13, %rax
movq %rax, %rsi
callq 0x5ccd5
movq %rdx, %rcx
movl %ebx, %edi
movq %r14, %rsi
movl %eax, %edx
leaq -0x38(%rbp), %r8
callq 0x2cdac
movq %r15, %rcx
movl -0x48(%rbp), %r15d
movq -0x40(%rbp), %r12
movl -0x38(%rbp), %ebx
movq -0x30(%rbp), %r14
jmp 0x5ceee
andq %rdi, %r13
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x5cf7f
decl (%r13)
jne 0x5cf7f
shlq $0x30, %r15
orq %rdi, %r15
leaq 0xab302(%rip), %rsi     # 0x108279
movq %r15, %rdi
callq 0xce94
movl %ebx, %edi
movq %r14, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcd32
leaq 0x7786f(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_type_CType_FnPtr
static struct mirth_type_CType mtw_mirth_type_CType_FnPtr (STR* in_Str_1) {
	struct mirth_type_CType_FnPtr* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mStr = in_Str_1;
	struct mirth_type_CType v4 = { .tag=mirth_type_CType_FnPtr, .ptr.FnPtr=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x5dde9
movq %rax, %rdx
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
pushq $0x5
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x7d175(%rip), %rsi     # 0xdaf65
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_type_CType_Ptr
static struct mirth_type_CType mtw_mirth_type_CType_Ptr (STR* in_Str_1) {
	struct mirth_type_CType_Ptr* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mStr = in_Str_1;
	struct mirth_type_CType v4 = { .tag=mirth_type_CType_Ptr, .ptr.Ptr=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x5de38
movq %rax, %rdx
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
pushq $0x4
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x7d090(%rip), %rsi     # 0xdaecf
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_type_CType_F32
static struct mirth_type_CType mtw_mirth_type_CType_F32 (STR* in_Str_1) {
	struct mirth_type_CType_F32* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mStr = in_Str_1;
	struct mirth_type_CType v4 = { .tag=mirth_type_CType_F32, .ptr.F32=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x5de87
movq %rax, %rdx
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x7d073(%rip), %rsi     # 0xdaf01
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_type_CType_F64
static struct mirth_type_CType mtw_mirth_type_CType_F64 (STR* in_Str_1) {
	struct mirth_type_CType_F64* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mStr = in_Str_1;
	struct mirth_type_CType v4 = { .tag=mirth_type_CType_F64, .ptr.F64=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x5ded6
movq %rax, %rdx
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
pushq $0x3
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x7d056(%rip), %rsi     # 0xdaf33
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_type_CType_UInt
static STR* mtp_mirth_type_CType_UInt (struct mirth_type_CType in_CType_1) {
	struct mirth_type_CType_UInt v3 = *in_CType_1.ptr.UInt;
	if (!--(in_CType_1.ptr.UInt->refs)) {
		free(in_CType_1.ptr.UInt);
	} else {
		incref(MKSTR(v3.mStr));
	}
	return v3.mStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0x5df85
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x5df8a
incl (%rax)
jmp 0x5df8a
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_type_CType_Int
static STR* mtp_mirth_type_CType_Int (struct mirth_type_CType in_CType_1) {
	struct mirth_type_CType_Int v3 = *in_CType_1.ptr.Int;
	if (!--(in_CType_1.ptr.Int->refs)) {
		free(in_CType_1.ptr.Int);
	} else {
		incref(MKSTR(v3.mStr));
	}
	return v3.mStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0x5dfc0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x5dfc5
incl (%rax)
jmp 0x5dfc5
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_type_CType_F32
static STR* mtp_mirth_type_CType_F32 (struct mirth_type_CType in_CType_1) {
	struct mirth_type_CType_F32 v3 = *in_CType_1.ptr.F32;
	if (!--(in_CType_1.ptr.F32->refs)) {
		free(in_CType_1.ptr.F32);
	} else {
		incref(MKSTR(v3.mStr));
	}
	return v3.mStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0x5dffb
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x5e000
incl (%rax)
jmp 0x5e000
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_type_CType_F64
static STR* mtp_mirth_type_CType_F64 (struct mirth_type_CType in_CType_1) {
	struct mirth_type_CType_F64 v3 = *in_CType_1.ptr.F64;
	if (!--(in_CType_1.ptr.F64->refs)) {
		free(in_CType_1.ptr.F64);
	} else {
		incref(MKSTR(v3.mStr));
	}
	return v3.mStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0x5e036
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x5e03b
incl (%rax)
jmp 0x5e03b
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_type_CType_Ptr
static STR* mtp_mirth_type_CType_Ptr (struct mirth_type_CType in_CType_1) {
	struct mirth_type_CType_Ptr v3 = *in_CType_1.ptr.Ptr;
	if (!--(in_CType_1.ptr.Ptr->refs)) {
		free(in_CType_1.ptr.Ptr);
	} else {
		incref(MKSTR(v3.mStr));
	}
	return v3.mStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0x5e071
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x5e076
incl (%rax)
jmp 0x5e076
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_type_CType_FnPtr
static STR* mtp_mirth_type_CType_FnPtr (struct mirth_type_CType in_CType_1) {
	struct mirth_type_CType_FnPtr v3 = *in_CType_1.ptr.FnPtr;
	if (!--(in_CType_1.ptr.FnPtr->refs)) {
		free(in_CType_1.ptr.FnPtr);
	} else {
		incref(MKSTR(v3.mStr));
	}
	return v3.mStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0x5e0ac
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x5e0b1
incl (%rax)
jmp 0x5e0b1
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_type_CType_Void
static STR* mtp_mirth_type_CType_Void (struct mirth_type_CType in_CType_1) {
	struct mirth_type_CType_Void v3 = *in_CType_1.ptr.Void;
	if (!--(in_CType_1.ptr.Void->refs)) {
		free(in_CType_1.ptr.Void);
	} else {
		incref(MKSTR(v3.mStr));
	}
	return v3.mStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
decl (%rdi)
je 0x5e0e7
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x5e0ec
incl (%rax)
jmp 0x5e0ec
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_prim_Str_Str_1_sp104
static STR* mw_std_prim_Str_Str_1_sp104 (STR* in_Str_1, STR* in_Str_2) {
	STR* v4;
	STRLIT(v4, "", 0);
	STR* v5;
	mw_std_str_zaStr_pushzestrzx(in_Str_1, v4, &v5);
	STR* v6;
	STRLIT(v6, " ", 1);
	STR* v7;
	mw_std_str_zaStr_pushzestrzx(v6, v5, &v7);
	STR* v8;
	mw_std_str_zaStr_pushzestrzx(in_Str_2, v7, &v8);
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10aecf7(%rip), %rdi   # 0x110cf18
testq %rdi, %rdi
jne 0x5e23e
leaq 0x7e4c8(%rip), %rdi     # 0xdc6f5
xorl %esi, %esi
callq 0x8a21
movq %rax, %rdi
movq %rax, 0x10aecda(%rip)   # 0x110cf18
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq %rdi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x5e25e
incl (%rax)
movq %r14, %rsi
callq 0xd8b0
movq %rax, %r14
movq 0x10aecb0(%rip), %rsi   # 0x110cf20
testq %rsi, %rsi
jne 0x5e28e
leaq 0x77b8b(%rip), %rdi     # 0xd5e07
pushq $0x1
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x10aec92(%rip)   # 0x110cf20
andq %rsi, %r15
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x5e2a2
incl (%r15)
movq %r14, %rdi
callq 0xd8b0
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd8b0
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_prim_Str_Str_1_sp105
static STR* mw_std_prim_Str_Str_1_sp105 (STR* in_Str_1, STR* in_Str_2) {
	STR* v4;
	STRLIT(v4, "", 0);
	STR* v5;
	mw_std_str_zaStr_pushzestrzx(in_Str_2, v4, &v5);
	STR* v6;
	STRLIT(v6, " ", 1);
	STR* v7;
	mw_std_str_zaStr_pushzestrzx(v6, v5, &v7);
	STR* v8;
	mw_std_str_zaStr_pushzestrzx(in_Str_1, v7, &v8);
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10aec52(%rip), %rdi   # 0x110cf28
testq %rdi, %rdi
jne 0x5e2f3
leaq 0x7e413(%rip), %rdi     # 0xdc6f5
xorl %esi, %esi
callq 0x8a21
movq %rax, %rdi
movq %rax, 0x10aec35(%rip)   # 0x110cf28
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq %rdi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x5e313
incl (%rax)
movq %r14, %rsi
callq 0xd8b0
movq %rax, %r14
movq 0x10aec0b(%rip), %rsi   # 0x110cf30
testq %rsi, %rsi
jne 0x5e343
leaq 0x77ad6(%rip), %rdi     # 0xd5e07
pushq $0x1
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x10aebed(%rip)   # 0x110cf30
andq %rsi, %r15
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x5e357
incl (%r15)
movq %r14, %rdi
callq 0xd8b0
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd8b0
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_type_CTypeStackPart_free
void mirth_type_CTypeStackPart_free (VAL v) {
	struct mirth_type_CTypeStackPart self = V_mirth_type_CTypeStackPart(v);
	switch (self.tag) {
		case mirth_type_CTypeStackPart_Cons: {
			decref(MK_mirth_type_CType(self.ptr.Cons->mCType));
			free(self.ptr.Cons);
		} break;
		case mirth_type_CTypeStackPart_ConsLabel: {
			decref(MK_mirth_type_CType(self.ptr.ConsLabel->mCType));
			free(self.ptr.ConsLabel);
		} break;
		case mirth_type_CTypeStackPart_With: {
			decref(MK_mirth_type_CType(self.ptr.With->mCType));
			free(self.ptr.With);
		} break;
		case mirth_type_CTypeStackPart_WithLabel: {
			decref(MK_mirth_type_CType(self.ptr.WithLabel->mCType));
			free(self.ptr.WithLabel);
		} break;
	}
}

// Assembly:
movq %rdi, %rcx
shrq $0x30, %rcx
cmpw $0x3, %cx
ja 0x5e3e4
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rax, %rbx
leaq 0x750c6(%rip), %rdx     # 0xd3464
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x10(%rbx), %rcx
andq %rcx, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x5e3d6
decl (%rax)
jne 0x5e3d6
leaq 0xaa9ab(%rip), %rsi     # 0x108d71
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
callq 0xce94
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_type_CTypeStack_free
static void mirth_type_CTypeStack_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_type_CTypeStack);
	struct mirth_type_CTypeStack* self = vself.data.ptr;
	decref(MK_std_maybe_Maybe_1(self->mbasezy));
	decref(MK_std_list_List_1(self->mparts));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0xab547(%rip), %rax     # 0x109989
cmpq %rsi, %rax
jne 0x5e4c1
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 0x5e486
decl (%rax)
jne 0x5e486
leaq 0xa9e4b(%rip), %rsi     # 0x1082c1
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
callq 0xce94
movq 0x20(%rbx), %rax
andq %rax, %r14
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x5e4b5
decl (%r14)
jne 0x5e4b5
leaq 0xa9dd4(%rip), %rsi     # 0x108279
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
callq 0xce94
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0x7cc3e(%rip), %rsi     # 0xdb106
pushq $0x2
popq %rdi
pushq $0x54
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_type_CTypeStackPart_Cons
static struct mirth_type_CType mtp_mirth_type_CTypeStackPart_Cons (struct mirth_type_CTypeStackPart in_CTypeStackPart_1) {
	struct mirth_type_CTypeStackPart_Cons v3 = *in_CTypeStackPart_1.ptr.Cons;
	if (!--(in_CTypeStackPart_1.ptr.Cons->refs)) {
		free(in_CTypeStackPart_1.ptr.Cons);
	} else {
		incref(MK_mirth_type_CType(v3.mCType));
	}
	return v3.mCType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x8(%rdi), %ebx
movq 0x10(%rdi), %r14
decl (%rdi)
je 0x5e560
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r14, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x5e565
incl (%rax)
jmp 0x5e565
callq 0x5030
movl %ebx, %eax
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_type_CTypeStackPart_ConsLabel
static struct mirth_type_CType mtp_mirth_type_CTypeStackPart_ConsLabel (struct mirth_type_CTypeStackPart in_CTypeStackPart_1, uint64_t *out_Label_3) {
	struct mirth_type_CTypeStackPart_ConsLabel v4 = *in_CTypeStackPart_1.ptr.ConsLabel;
	if (!--(in_CTypeStackPart_1.ptr.ConsLabel->refs)) {
		free(in_CTypeStackPart_1.ptr.ConsLabel);
	} else {
		incref(MK_mirth_type_CType(v4.mCType));
	}
	*out_Label_3 = v4.mLabel;
	return v4.mCType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl 0x8(%rdi), %r14d
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %r12
decl (%rdi)
je 0x5e5ac
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r15, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x5e5b1
incl (%rax)
jmp 0x5e5b1
callq 0x5030
movq %r12, (%rbx)
movl %r14d, %eax
movq %r15, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_type_CTypeStackPart_With
static struct mirth_type_CType mtp_mirth_type_CTypeStackPart_With (struct mirth_type_CTypeStackPart in_CTypeStackPart_1) {
	struct mirth_type_CTypeStackPart_With v3 = *in_CTypeStackPart_1.ptr.With;
	if (!--(in_CTypeStackPart_1.ptr.With->refs)) {
		free(in_CTypeStackPart_1.ptr.With);
	} else {
		incref(MK_mirth_type_CType(v3.mCType));
	}
	return v3.mCType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x8(%rdi), %ebx
movq 0x10(%rdi), %r14
decl (%rdi)
je 0x5e5f4
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r14, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x5e5f9
incl (%rax)
jmp 0x5e5f9
callq 0x5030
movl %ebx, %eax
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_type_CTypeStackPart_WithLabel
static struct mirth_type_CType mtp_mirth_type_CTypeStackPart_WithLabel (struct mirth_type_CTypeStackPart in_CTypeStackPart_1, uint64_t *out_Label_3) {
	struct mirth_type_CTypeStackPart_WithLabel v4 = *in_CTypeStackPart_1.ptr.WithLabel;
	if (!--(in_CTypeStackPart_1.ptr.WithLabel->refs)) {
		free(in_CTypeStackPart_1.ptr.WithLabel);
	} else {
		incref(MK_mirth_type_CType(v4.mCType));
	}
	*out_Label_3 = v4.mLabel;
	return v4.mCType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl 0x8(%rdi), %r14d
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %r12
decl (%rdi)
je 0x5e640
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r15, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x5e645
incl (%rax)
jmp 0x5e645
callq 0x5030
movq %r12, (%rbx)
movl %r14d, %eax
movq %r15, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_type_CTypeArrow_free
static void mirth_type_CTypeArrow_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_type_CTypeArrow);
	struct mirth_type_CTypeArrow* self = vself.data.ptr;
	decref(MK_mirth_type_CTypeStack(self->mdom));
	decref(MK_mirth_type_CTypeStack(self->mcod));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xab2d9(%rip), %rax     # 0x109941
cmpq %rsi, %rax
jne 0x5e6d9
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
leaq 0xab308(%rip), %r14     # 0x109989
movq 0x8(%rdi), %rdi
movq %rdi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x5e6a5
decl (%rax)
jne 0x5e6a5
movq %r14, %rsi
callq 0xce94
movq 0x10(%rbx), %rdi
andq %rdi, %r15
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x5e6c7
decl (%r15)
jne 0x5e6c7
movq %r14, %rsi
callq 0xce94
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
leaq 0x7ca93(%rip), %rsi     # 0xdb173
pushq $0x2
popq %rdi
pushq $0x54
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_external_ExternalBlockPart_free
void mirth_external_ExternalBlockPart_free (VAL v) {
	struct mirth_external_ExternalBlockPart self = V_mirth_external_ExternalBlockPart(v);
	switch (self.tag) {
		case mirth_external_ExternalBlockPart_EBPCode: {
			decref(MKSTR(self.ptr.EBPCode->mStr));
			free(self.ptr.EBPCode);
		} break;
		case mirth_external_ExternalBlockPart_EBPDef: {
			free(self.ptr.EBPDef);
		} break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movq %rdi, %rcx
shrq $0x30, %rcx
andq %rax, %rbx
cmpq $0x1, %rcx
je 0x5e793
testl %ecx, %ecx
jne 0x5e7a1
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x5e793
decl (%rax)
jne 0x5e793
leaq 0xa99cb(%rip), %rsi     # 0x108159
callq 0xce94
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_buffer_Buffer_Makezx
static uint64_t mw_mirth_buffer_Buffer_Makezx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct std_maybe_Maybe_1 in_Maybe_2, uint64_t in_Token_3, INT in_Sizze_4, uint64_t in_Name_5, struct mirth_mirth_zaMirth* *out_zaMirth_6) {
	struct mirth_mirth_zaMirth* v8;
	uint64_t v9 = mw_mirth_buffer_Buffer_Alloczx(in_zaMirth_1, &v8);
	void* v10 = field_mut(&mfld_mirth_buffer_Buffer_doc, v9);
	mut_set(MK_std_maybe_Maybe_1(in_Maybe_2), v10);
	void* v11 = field_mut(&mfld_mirth_buffer_Buffer_head, v9);
	mut_set(MK_mirth_token_Token(in_Token_3), v11);
	void* v12 = field_mut(&mfld_mirth_buffer_Buffer_sizze, v9);
	mut_set(MKINT(in_Sizze_4), v12);
	void* v13 = field_mut(&mfld_mirth_buffer_Buffer_name, v9);
	mut_set(MK_mirth_name_Name(in_Name_5), v13);
	*out_zaMirth_6 = v8;
	return v9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, -0x30(%rbp)
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, -0x38(%rbp)
movq 0x10ae7a5(%rip), %r15   # 0x110cfc8
incq %r15
movq %r15, 0x10ae79b(%rip)   # 0x110cfc8
leaq 0x10ae774(%rip), %rdi   # 0x110cfa8
movq %r15, %rsi
callq 0x12f88
shlq $0x30, %r14
orq %rbx, %r14
leaq 0xa9a77(%rip), %rsi     # 0x1082c1
movq %r14, %rdi
movq %rax, %rdx
callq 0x1393b
leaq 0x10ad584(%rip), %rdi   # 0x110bde0
movq %r15, %rsi
callq 0x12f88
leaq 0xaa54d(%rip), %rsi     # 0x108db8
movq %r13, %rdi
movq %rax, %rdx
callq 0x1393b
leaq 0x10ae73b(%rip), %rdi   # 0x110cfb8
movq %r15, %rsi
callq 0x12f88
leaq 0xa9b9d(%rip), %rsi     # 0x108429
movq %r12, %rdi
movq %rax, %rdx
callq 0x1393b
leaq 0x10ad67a(%rip), %rdi   # 0x110bf18
movq %r15, %rsi
callq 0x12f88
leaq 0xa9e4b(%rip), %rsi     # 0x1086f8
movq -0x30(%rbp), %rdi
movq %rax, %rdx
callq 0x1393b
movq -0x38(%rbp), %rax
movq 0x10(%rbp), %rcx
movq %rax, (%rcx)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_mirth_PropLabel_BufferQName
static struct mirth_mirth_PropLabel mtw_mirth_mirth_PropLabel_BufferQName (uint64_t in_Buffer_1) {
	struct mirth_mirth_PropLabel_BufferQName* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mBuffer = in_Buffer_1;
	struct mirth_mirth_PropLabel v4 = { .tag=mirth_mirth_PropLabel_BufferQName, .ptr.BufferQName=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x5e900
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x7c9cd(%rip), %rsi     # 0xdb2d4
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_def_Def_Buffer
static struct mirth_def_Def mtw_mirth_def_Def_Buffer (uint64_t in_Buffer_1) {
	struct mirth_def_Def_Buffer* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mBuffer = in_Buffer_1;
	struct mirth_def_Def v4 = { .tag=mirth_def_Def_Buffer, .ptr.Buffer=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x5e949
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x7c9b6(%rip), %rsi     # 0xdb306
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_maybe_Maybe_1_else_1_sp14
static void mw_std_maybe_Maybe_1_else_1_sp14 (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct std_maybe_Maybe_1 in_Maybe_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, uint64_t *out_Token_5) {
	int64_t v6 = (in_Maybe_3).tag;
	decref(MK_std_maybe_Maybe_1(in_Maybe_3));
	INT v7 = WRAP_I63(0LL);
	INT v8 = v7;
	INT v9 = i64_to_int(v6);
	bool v10 = int_eq(v9, v8);
	bool v11 = !v10;
	struct mirth_mirth_zaMirth* branch_zaMirth_12;
	uint64_t branch_Token_13;
	if (v11) {
		branch_Token_13 = in_Token_2;
		branch_zaMirth_12 = in_zaMirth_1;
	} else {
		STR* v14;
		STRLIT(v14, "Expected buffer name.", 21);
		mw_mirth_mirth_zaMirth_emitzefatalzeerrorzx(in_zaMirth_1, in_Token_2, v14);
	}
	*out_Token_5 = branch_Token_13;
	*out_zaMirth_4 = branch_zaMirth_12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %r15
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movl %edx, %r13d
movq %rcx, %rax
andq %rbx, %rax
sete %dl
testb $0x3, %cl
setne %sil
orb %dl, %sil
jne 0x5e9bf
decl (%rax)
jne 0x5e9bf
movq %r13, %rdi
shlq $0x30, %rdi
orq %rcx, %rdi
leaq 0xa9907(%rip), %rsi     # 0x1082c1
callq 0xce94
movq %r13, %rdi
callq 0xd86d
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xd759
testb %al, %al
jne 0x5e9f0
movq -0x30(%rbp), %rax
movq %rax, (%r12)
movq %r14, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10ae5a1(%rip), %rdx   # 0x110cf98
testq %rdx, %rdx
jne 0x5ea15
leaq 0x7c8a5(%rip), %rdi     # 0xdb2a8
pushq $0x15
popq %rsi
callq 0x8a21
movq %rax, %rdx
movq %rax, 0x10ae583(%rip)   # 0x110cf98
andq %rdx, %rbx
sete %al
testb $0x3, %dl
setne %cl
orb %al, %cl
jne 0x5ea27
incl (%rbx)
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x246fe
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_token_Token_intzy
static struct std_maybe_Maybe_1 mw_mirth_token_Token_intzy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct mirth_token_TokenValue v6 = mw_mirth_token_Token_value(in_zaMirth_1, in_Token_2, &v5);
	struct std_maybe_Maybe_1 v7 = mw_mirth_token_TokenValue_intzy(v6);
	*out_zaMirth_3 = v5;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
leaq -0x10(%rbp), %rdx
callq 0x252f3
cmpl $0xe, %eax
jne 0x5ea66
movq %rdx, %rdi
callq 0x4d25d
leaq 0xa99d0(%rip), %rsi     # 0x108429
movq %rax, %rdi
callq 0x8d0c
pushq $0x1
popq %rax
jmp 0x5eaa1
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rcx
sete %sil
testb $0x3, %dl
setne %dil
orb %sil, %dil
jne 0x5ea9d
decl (%rcx)
jne 0x5ea9d
shlq $0x30, %rax
orq %rdx, %rax
leaq 0xaa444(%rip), %rsi     # 0x108ed9
movq %rax, %rdi
callq 0xce94
xorl %eax, %eax
xorl %edx, %edx
movq -0x10(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_maybe_Maybe_1_elsezy_1_sp10
static VAL mw_std_maybe_Maybe_1_elsezy_1_sp10 (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct std_maybe_Maybe_1 in_Maybe_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, uint64_t *out_Token_5) {
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	uint64_t branch_Token_8;
	VAL branch_zux1_9;
	switch ((in_Maybe_3).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v10 = mtp_std_maybe_Maybe_1_Some(in_Maybe_3);
			branch_zux1_9 = v10;
			branch_Token_8 = in_Token_2;
			branch_zaMirth_7 = in_zaMirth_1;
		} break;
		case std_maybe_Maybe_1_None: {
			STR* v11;
			STRLIT(v11, "Expected buffer size.", 21);
			mw_mirth_mirth_zaMirth_emitzefatalzeerrorzx(in_zaMirth_1, in_Token_2, v11);
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_Token_5 = branch_Token_8;
	*out_zaMirth_4 = branch_zaMirth_7;
	return branch_zux1_9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, %edx
jne 0x5eae3
movq %r9, %r12
movq %r8, %r15
movq %rcx, %rdi
callq 0xd491
movq %rbx, (%r12)
movq %r14, (%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x10ae4b6(%rip), %rdx   # 0x110cfa0
testq %rdx, %rdx
jne 0x5eb08
leaq 0x7c7c8(%rip), %rdi     # 0xdb2be
pushq $0x15
popq %rsi
callq 0x8a21
movq %rax, %rdx
movq %rax, 0x10ae498(%rip)   # 0x110cfa0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x5eb26
incl (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x246fe
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_maybe_Maybe_1_else_1_sp13
static void mw_std_maybe_Maybe_1_else_1_sp13 (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct std_maybe_Maybe_1 in_Maybe_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, uint64_t *out_Token_5) {
	int64_t v6 = (in_Maybe_3).tag;
	decref(MK_std_maybe_Maybe_1(in_Maybe_3));
	INT v7 = WRAP_I63(0LL);
	INT v8 = v7;
	INT v9 = i64_to_int(v6);
	bool v10 = int_eq(v9, v8);
	bool v11 = !v10;
	struct mirth_mirth_zaMirth* branch_zaMirth_12;
	uint64_t branch_Token_13;
	if (v11) {
		branch_Token_13 = in_Token_2;
		branch_zaMirth_12 = in_zaMirth_1;
	} else {
		STR* v14;
		STRLIT(v14, "expected type name", 18);
		mw_mirth_mirth_zaMirth_emitzefatalzeerrorzx(in_zaMirth_1, in_Token_2, v14);
	}
	*out_Token_5 = branch_Token_13;
	*out_zaMirth_4 = branch_zaMirth_12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %r15
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movl %edx, %r13d
movq %rcx, %rax
andq %rbx, %rax
sete %dl
testb $0x3, %cl
setne %sil
orb %dl, %sil
jne 0x60cc6
decl (%rax)
jne 0x60cc6
movq %r13, %rdi
shlq $0x30, %rdi
orq %rcx, %rdi
leaq 0xa7600(%rip), %rsi     # 0x1082c1
callq 0xce94
movq %r13, %rdi
callq 0xd86d
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xd759
testb %al, %al
jne 0x60cf7
movq -0x30(%rbp), %rax
movq %rax, (%r12)
movq %r14, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10ac2e2(%rip), %rdx   # 0x110cfe0
testq %rdx, %rdx
jne 0x60d1c
leaq 0x7a668(%rip), %rdi     # 0xdb372
pushq $0x12
popq %rsi
callq 0x8a21
movq %rax, %rdx
movq %rax, 0x10ac2c4(%rip)   # 0x110cfe0
andq %rdx, %rbx
sete %al
testb $0x3, %dl
setne %cl
orb %al, %cl
jne 0x60d2e
incl (%rbx)
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x246fe
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_name_Name_couldzebezerawzefieldzenamezy
static bool mw_mirth_name_Name_couldzebezerawzefieldzenamezy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Name_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	enum std_byte_Byte v6 = mw_mirth_name_Name_head(in_zaMirth_1, in_Name_2, &v5);
	enum std_byte_Byte v7 = std_byte_Byte_Bzqztzq;
	int64_t v8 = v6;
	INT v9 = i64_to_int(v8);
	uint64_t v10 = int_to_u64(v9);
	uint8_t v11 = (uint8_t)(v10);
	int64_t v12 = v7;
	INT v13 = i64_to_int(v12);
	uint64_t v14 = int_to_u64(v13);
	uint8_t v15 = (uint8_t)(v14);
	uint64_t v16 = (uint64_t)(v15);
	uint32_t v17 = (uint32_t)(v16);
	uint64_t v18 = (uint64_t)(v11);
	uint32_t v19 = (uint32_t)(v18);
	uint64_t v20 = (uint64_t)(v19);
	uint64_t v21 = (uint64_t)(v17);
	bool v22 = (v20 == v21);
	*out_zaMirth_3 = v5;
	return v22;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x18(%rbp), %r14
movq %r14, %rdx
callq 0x1c899
movl %eax, %edi
callq 0xd86d
movq %rax, %rdi
callq 0xdc43
cmpb $0x7e, %al
sete %al
movq (%r14), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_table_InlineFieldSyntax_free
static void mirth_table_InlineFieldSyntax_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_table_InlineFieldSyntax);
	struct mirth_table_InlineFieldSyntax* self = vself.data.ptr;
	decref(MK_std_maybe_Maybe_1(self->mdoc));
	decref(MK_std_maybe_Maybe_1(self->mdefault));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xa8c5e(%rip), %rax     # 0x109a61
cmpq %rsi, %rax
jne 0x60e87
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x10(%rdi), %rcx
leaq 0xa74a1(%rip), %r14     # 0x1082c1
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x60e4a
decl (%rax)
jne 0x60e4a
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xce94
movq 0x38(%rbx), %rax
andq %rax, %r15
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x60e75
decl (%r15)
jne 0x60e75
movl 0x30(%rbx), %edi
shlq $0x30, %rdi
orq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0xce94
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
leaq 0x7a5c3(%rip), %rsi     # 0xdb451
pushq $0x2
popq %rdi
pushq $0x5c
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mb_mirth_mirth_PropLabel_prop_1_sp26_0
static void mb_mirth_mirth_PropLabel_prop_1_sp26_0 (void) {
	struct std_maybe_Maybe_1 v0 = V_std_maybe_Maybe_1(pop_value());
	struct mirth_mirth_zaMirth* r1 = V_mirth_mirth_zaMirth(pop_resource());
	struct mirth_mirth_zaMirth* v2;
	struct mirth_table_StateOwner v3 = mw_mirth_mirth_zaMirth_resolvezeowner(r1, v0, &v2);
	push_resource(MK_mirth_mirth_zaMirth(v2));
	push_value(MK_mirth_table_StateOwner(v3));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0xd3d6
movq %rax, %r14
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rbx
shrq $0x30, %r14
callq 0xd429
leaq -0x20(%rbp), %r15
movq %rax, %rdi
movl %r14d, %esi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x6639e
movl %eax, %ebx
movq %rdx, %r14
movq (%r15), %rdi
leaq 0xa79af(%rip), %rsi     # 0x1088f0
callq 0x883c
shlq $0x30, %rbx
orq %r14, %rbx
leaq 0xa8b55(%rip), %rsi     # 0x109aa9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd08e
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_table_tablezeqname
static struct mirth_name_QName* mw_mirth_table_tablezeqname (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Table_2, STR* in_Str_3, INT in_Int_4, struct mirth_mirth_zaMirth* *out_zaMirth_5) {
	struct mirth_mirth_zaMirth* v7;
	uint64_t v8 = mw_mirth_name_Name_Name(in_zaMirth_1, in_Str_3, &v7);
	struct mirth_tycon_Tycon v9 = mtw_mirth_tycon_Tycon_Table(in_Table_2);
	struct mirth_name_Namespace v10 = mtw_mirth_name_Namespace_Tycon(v9);
	struct mirth_name_QName* v11 = mtw_mirth_name_QName_QName(v10, v8, in_Int_4);
	*out_zaMirth_5 = v7;
	return v11;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rsi, %r15
leaq -0x28(%rbp), %r14
movq %rdx, %rsi
movq %r14, %rdx
callq 0x12215
movq %rax, %r12
movq %r15, %rdi
callq 0x2a5d7
pushq $0x1
popq %rdi
movq %rax, %rsi
callq 0x17351
pushq $0x3
popq %rdi
pushq $0x1
popq %rcx
movq %rax, %rsi
movq %r12, %rdx
callq 0x1473b
movq (%r14), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_table_Table_numzebuffer
static uint64_t mw_mirth_table_Table_numzebuffer (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Table_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_table_Table_numzebuffer, in_Table_2);
	VAL v6 = mut_get(v5);
	*out_zaMirth_3 = in_zaMirth_1;
	return V_mirth_buffer_Buffer(v6);
}

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