LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x64c8b
movq %rax, %rdx
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x861c9(%rip), %rsi     # 0xeae5b
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_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
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x64ce6
movq %rax, %rdx
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x861a0(%rip), %rsi     # 0xeae8d
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_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 0x64db4
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x64db9
incl (%rax)
jmp 0x64db9
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x64def
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x64df4
incl (%rax)
jmp 0x64df4
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x64e2a
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x64e2f
incl (%rax)
jmp 0x64e2f
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x64e65
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x64e6a
incl (%rax)
jmp 0x64e6a
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x64ea0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x64ea5
incl (%rax)
jmp 0x64ea5
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x64edb
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x64ee0
incl (%rax)
jmp 0x64ee0
callq 0x5030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x64f16
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rbx, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0x64f1b
incl (%rax)
jmp 0x64f1b
callq 0x5030
movq %rbx, %rax
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_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
cmpq $0x0, 0x10b4eae(%rip)   # 0x1119f18
jne 0x65082
xorl %edi, %edi
callq 0xf9f7
movq $0x0, 0x10(%rax)
movq %rax, 0x10b4e96(%rip)   # 0x1119f18
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x10b4e85(%rip), %rdi   # 0x1119f18
movq %rdi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x650a9
incl (%rax)
movq %r14, %rsi
callq 0xe43c
movq %rax, %r14
cmpq $0x0, 0x10b4e64(%rip)   # 0x1119f20
jne 0x650db
movl $0x1, %edi
callq 0xf9f7
movq $0x1, 0x10(%rax)
movb $0x20, 0x18(%rax)
movq %rax, 0x10b4e45(%rip)   # 0x1119f20
movq 0x10b4e3e(%rip), %rsi   # 0x1119f20
andq %rsi, %r15
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x650f6
incl (%r15)
movq %r14, %rdi
callq 0xe43c
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe43c
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x0, 0x10b4dfd(%rip)   # 0x1119f28
jne 0x65143
xorl %edi, %edi
callq 0xf9f7
movq $0x0, 0x10(%rax)
movq %rax, 0x10b4de5(%rip)   # 0x1119f28
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x10b4dd4(%rip), %rdi   # 0x1119f28
movq %rdi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x6516a
incl (%rax)
movq %r14, %rsi
callq 0xe43c
movq %rax, %r14
cmpq $0x0, 0x10b4db3(%rip)   # 0x1119f30
jne 0x6519c
movl $0x1, %edi
callq 0xf9f7
movq $0x1, 0x10(%rax)
movb $0x20, 0x18(%rax)
movq %rax, 0x10b4d94(%rip)   # 0x1119f30
movq 0x10b4d8d(%rip), %rsi   # 0x1119f30
andq %rsi, %r15
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x651b7
incl (%r15)
movq %r14, %rdi
callq 0xe43c
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe43c
// File: /workspace/github_c_makefile_star2_O1/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 0x65244
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rax, %rbx
leaq 0x7e21e(%rip), %rdx     # 0xe341c
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 0x65236
decl (%rax)
jne 0x65236
leaq 0xb0b4b(%rip), %rsi     # 0x115d71
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
callq 0xd4e3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb16e9(%rip), %rax     # 0x116989
cmpq %rsi, %rax
jne 0x6531f
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 0x652e4
decl (%rax)
jne 0x652e4
leaq 0xaffed(%rip), %rsi     # 0x1152c1
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 0x65313
decl (%r14)
jne 0x65313
leaq 0xaff76(%rip), %rsi     # 0x115279
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 0x85d28(%rip), %rsi     # 0xeb04e
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: 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 0x653c2
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r14, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x653c7
incl (%rax)
jmp 0x653c7
callq 0x5030
movl %ebx, %eax
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: 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 0x6540e
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r15, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x65413
incl (%rax)
jmp 0x65413
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_O1/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 0x65456
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r14, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x6545b
incl (%rax)
jmp 0x6545b
callq 0x5030
movl %ebx, %eax
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: 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 0x654a2
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r15, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x654a7
incl (%rax)
jmp 0x654a7
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_O1/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 0xb1477(%rip), %rax     # 0x116941
cmpq %rsi, %rax
jne 0x6553b
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
leaq 0xb14a6(%rip), %r14     # 0x116989
movq 0x8(%rdi), %rdi
movq %rdi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x65507
decl (%rax)
jne 0x65507
movq %r14, %rsi
callq 0xd4e3
movq 0x10(%rbx), %rdi
andq %rdi, %r15
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x65529
decl (%r15)
jne 0x65529
movq %r14, %rsi
callq 0xd4e3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
leaq 0x85b79(%rip), %rsi     # 0xeb0bb
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: 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 0x655f9
testl %ecx, %ecx
jne 0x65607
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x655f9
decl (%rax)
jne 0x655f9
leaq 0xafb65(%rip), %rsi     # 0x115159
callq 0xd4e3
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_O1/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 0x10b4941(%rip), %r15   # 0x1119fc8
incq %r15
movq %r15, 0x10b4937(%rip)   # 0x1119fc8
leaq 0x10b4910(%rip), %rdi   # 0x1119fa8
movq %r15, %rsi
callq 0x13ff0
shlq $0x30, %r14
orq %rbx, %r14
leaq 0xafc13(%rip), %rsi     # 0x1152c1
movq %r14, %rdi
movq %rax, %rdx
callq 0x14ab5
leaq 0x10b3720(%rip), %rdi   # 0x1118de0
movq %r15, %rsi
callq 0x13ff0
leaq 0xb06e9(%rip), %rsi     # 0x115db8
movq %r13, %rdi
movq %rax, %rdx
callq 0x14ab5
leaq 0x10b48d7(%rip), %rdi   # 0x1119fb8
movq %r15, %rsi
callq 0x13ff0
leaq 0xafd39(%rip), %rsi     # 0x115429
movq %r12, %rdi
movq %rax, %rdx
callq 0x14ab5
leaq 0x10b3816(%rip), %rdi   # 0x1118f18
movq %r15, %rsi
callq 0x13ff0
leaq 0xaffe7(%rip), %rsi     # 0x1156f8
movq -0x30(%rbp), %rdi
movq %rax, %rdx
callq 0x14ab5
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_O1/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
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x65768
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x85aad(%rip), %rsi     # 0xeb21c
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_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
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x657bb
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x85a8c(%rip), %rsi     # 0xeb24e
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_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, %r13   # imm = 0xFFFFFFFFFFFC
movl %edx, %ebx
movq %rcx, %rax
andq %r13, %rax
sete %dl
testb $0x3, %cl
setne %sil
orb %dl, %sil
jne 0x65836
decl (%rax)
jne 0x65836
movq %rbx, %rdi
shlq $0x30, %rdi
orq %rcx, %rdi
leaq 0xafa90(%rip), %rsi     # 0x1152c1
callq 0xd4e3
leaq 0x1(,%rbx,2), %rdi
movl $0x1, %esi
callq 0xec04
testl %eax, %eax
je 0x65866
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
cmpq $0x0, 0x10b472a(%rip)   # 0x1119f98
jne 0x658a2
movl $0x15, %edi
callq 0xf9f7
movq $0x15, 0x10(%rax)
movabsq $0x2e656d616e207265, %rcx # imm = 0x2E656D616E207265
movq %rcx, 0x25(%rax)
movups 0x85959(%rip), %xmm0    # 0xeb1f0
movups %xmm0, 0x18(%rax)
movq %rax, 0x10b46f6(%rip)   # 0x1119f98
movq 0x10b46ef(%rip), %rdx   # 0x1119f98
andq %rdx, %r13
sete %al
testb $0x3, %dl
setne %cl
orb %al, %cl
jne 0x658bd
incl (%r13)
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x2778c
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10b3b0b(%rip), %rdi   # 0x11193e8
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
movabsq $0xfffffffffffc, %rdi   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdi
movq %rax, %rcx
shrq $0x30, %rcx
cmpl $0xe, %ecx
jne 0x6591e
callq 0x53071
leaq 0xafb1a(%rip), %rsi     # 0x115429
movq %rax, %rdi
callq 0x95f6
movl $0x1, %eax
jmp 0x6593e
testq %rdi, %rdi
je 0x6593a
decl (%rdi)
jne 0x6593a
andq $-0x4, %rax
leaq 0xb05a7(%rip), %rsi     # 0x115ed9
movq %rax, %rdi
callq 0xd4e3
xorl %eax, %eax
xorl %edx, %edx
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_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 0x6597a
movq %r9, %r12
movq %r8, %r15
movq %rcx, %rdi
callq 0xdaeb
movq %rbx, (%r12)
movq %r14, (%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x10b461e(%rip)   # 0x1119fa0
jne 0x659b6
movl $0x15, %edi
callq 0xf9f7
movq $0x15, 0x10(%rax)
movabsq $0x2e657a6973207265, %rcx # imm = 0x2E657A6973207265
movq %rcx, 0x25(%rax)
movups 0x8585b(%rip), %xmm0    # 0xeb206
movups %xmm0, 0x18(%rax)
movq %rax, 0x10b45ea(%rip)   # 0x1119fa0
movq 0x10b45e3(%rip), %rdx   # 0x1119fa0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x659db
incl (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2778c
// File: /workspace/github_c_makefile_star2_O1/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, %r13   # imm = 0xFFFFFFFFFFFC
movl %edx, %ebx
movq %rcx, %rax
andq %r13, %rax
sete %dl
testb $0x3, %cl
setne %sil
orb %dl, %sil
jne 0x67ed8
decl (%rax)
jne 0x67ed8
movq %rbx, %rdi
shlq $0x30, %rdi
orq %rcx, %rdi
leaq 0xad3ee(%rip), %rsi     # 0x1152c1
callq 0xd4e3
leaq 0x1(,%rbx,2), %rdi
movl $0x1, %esi
callq 0xec04
testl %eax, %eax
je 0x67f08
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
cmpq $0x0, 0x10b20d0(%rip)   # 0x1119fe0
jne 0x67f3c
movl $0x12, %edi
callq 0xf9f7
movq $0x12, 0x10(%rax)
movups 0x8338f(%rip), %xmm0    # 0xeb2ba
movups %xmm0, 0x18(%rax)
movw $0x656d, 0x28(%rax)     # imm = 0x656D
movq %rax, 0x10b20a4(%rip)   # 0x1119fe0
movq 0x10b209d(%rip), %rdx   # 0x1119fe0
andq %rdx, %r13
sete %al
testb $0x3, %dl
setne %cl
orb %al, %cl
jne 0x67f57
incl (%r13)
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x2778c
// File: /workspace/github_c_makefile_star2_O1/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 0xaea67(%rip), %rax     # 0x116a61
cmpq %rsi, %rax
jne 0x6807e
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x10(%rdi), %rcx
leaq 0xad2aa(%rip), %r14     # 0x1152c1
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x68041
decl (%rax)
jne 0x68041
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xd4e3
movq 0x38(%rbx), %rax
andq %rax, %r15
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x6806c
decl (%r15)
jne 0x6806c
movl 0x30(%rbx), %edi
shlq $0x30, %rdi
orq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0xd4e3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
leaq 0x83314(%rip), %rsi     # 0xeb399
movl $0x5c, %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: 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 0xda3f
movq %rax, %r14
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rbx
shrq $0x30, %r14
callq 0xda98
leaq -0x20(%rbp), %r15
movq %rax, %rdi
movl %r14d, %esi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x6dc2e
movl %eax, %ebx
movq %rdx, %r14
movq (%r15), %rdi
leaq 0xad7b4(%rip), %rsi     # 0x1158f0
callq 0x9116
shlq $0x30, %rbx
orq %r14, %rbx
leaq 0xae95a(%rip), %rsi     # 0x116aa9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd6f1
// File: /workspace/github_c_makefile_star2_O1/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 0x13236
movq %rax, %r12
movq %r15, %rdi
callq 0x2dc23
movl $0x1, %edi
movq %rax, %rsi
callq 0x196e2
movl $0x1, %ecx
movl $0x3, %edi
movq %rax, %rsi
movq %r12, %rdx
callq 0x157ee
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_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_mirth_PropLabel_prop2_1_sp12
static struct mirth_mirth_Prop_1* mw_mirth_mirth_PropLabel_prop2_1_sp12 (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Table_2, uint64_t in_Word_3, struct mirth_mirth_PropLabel in_PropLabel_4, struct mirth_mirth_zaMirth* *out_zaMirth_5) {
	PTUP r7 = PTRMK(0,tup_new(2),0);
	((TUP*)PTRPTR(r7))->size = 2;
	((TUP*)PTRPTR(r7))->cells[1] = MK_mirth_word_Word(in_Word_3);
	((TUP*)PTRPTR(r7))->cells[0] = MK_mirth_table_Table(in_Table_2);
	struct mirth_mirth_LexicalState* v8 = in_zaMirth_1->mlexicalzestate;
	incref(MK_mirth_mirth_LexicalState(v8));
	FNPTR v9 = &mb_mirth_mirth_PropLabel_prop_1_sp29_0;
	struct mirth_mirth_PropState_1 v10 = mtw_mirth_mirth_PropState_1_Delay(v8, MKTUP(r7), MKFNPTR(v9));
	struct mirth_mirth_Prop_1* v11 = mtw_mirth_mirth_Prop_1_Prop(in_PropLabel_4, v10);
	*out_zaMirth_5 = in_zaMirth_1;
	return v11;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movl $0x2, %edi
callq 0xe4ba
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
movq %rax, %rdx
andq %rcx, %rdx
movw $0x2, 0x6(%rdx)
movq %r12, 0x18(%rdx)
leaq 0xadf53(%rip), %rsi     # 0x116160
movq %rsi, 0x20(%rdx)
movq %r13, 0x8(%rdx)
leaq 0xade6c(%rip), %rsi     # 0x116088
movq %rsi, 0x10(%rdx)
movq 0x48(%r14), %rdi
andq %rdi, %rcx
sete %dl
testb $0x3, %dil
setne %sil
orb %dl, %sil
jne 0x68239
incl (%rcx)
leaq 0xad159(%rip), %rdx     # 0x115399
leaq 0x5ee6(%rip), %rcx      # 0x6e12d
movq %rax, %rsi
callq 0x27d72
movl $0x9, %edi
movq %r15, %rsi
movl $0x1, %edx
movq %rax, %rcx
callq 0x1faa2
movq %r14, (%rbx)
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: mb_mirth_mirth_PropLabel_prop_1_sp45_0
static void mb_mirth_mirth_PropLabel_prop_1_sp45_0 (void) {
	uint64_t v0 = V_mirth_table_Table(pop_value());
	struct mirth_mirth_zaMirth* r1 = V_mirth_mirth_zaMirth(pop_resource());
	struct std_list_List_1 v2 = mw_mirth_var_Ctx_L0();
	struct mirth_type_StackType v3 = mw_mirth_type_T0();
	struct mirth_type_Type v4 = mtw_mirth_type_Type_Table(v0);
	struct mirth_type_StackType v5 = mw_mirth_type_T1(v4);
	struct mirth_type_ArrowType* v6 = mw_mirth_type_Tzezg(v3, v5);
	PTUP r7 = PTRMK(0,tup_new(2),0);
	((TUP*)PTRPTR(r7))->size = 2;
	((TUP*)PTRPTR(r7))->cells[1] = MK_mirth_type_ArrowType(v6);
	((TUP*)PTRPTR(r7))->cells[0] = MK_std_list_List_1(v2);
	push_resource(MK_mirth_mirth_zaMirth(r1));
	push_value(MKTUP(r7));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0xda3f
movq %rax, %r14
callq 0xda98
movq %rax, %rbx
movq %r14, %rdi
callq 0x3f21c
movl $0x2, %edi
xorl %esi, %esi
movl $0x6, %edx
movq %rax, %rcx
callq 0x20b1a
movq %rdx, %rcx
movl $0x2, %edi
xorl %esi, %esi
movl $0x5, %edx
callq 0x210ca
movq %rax, %r14
movl $0x2, %edi
callq 0xe4ba
movq %rax, %r15
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r15, %rax
movw $0x2, 0x6(%rax)
leaq 0xad88f(%rip), %rcx     # 0x115b79
movq %r14, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0xacf80(%rip), %rcx     # 0x115279
movq $0x0, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0xad5e4(%rip), %rsi     # 0x1158f0
movq %rbx, %rdi
callq 0x9116
leaq 0xad07e(%rip), %rsi     # 0x115399
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd6f1
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_mirth_PropLabel_prop2_1_sp8
static struct mirth_mirth_Prop_1* mw_mirth_mirth_PropLabel_prop2_1_sp8 (struct mirth_mirth_zaMirth* in_zaMirth_1, struct std_list_List_1 in_List_2, uint64_t in_Word_3, struct mirth_mirth_PropLabel in_PropLabel_4, struct mirth_mirth_zaMirth* *out_zaMirth_5) {
	PTUP r7 = PTRMK(0,tup_new(2),0);
	((TUP*)PTRPTR(r7))->size = 2;
	((TUP*)PTRPTR(r7))->cells[1] = MK_mirth_word_Word(in_Word_3);
	((TUP*)PTRPTR(r7))->cells[0] = MK_std_list_List_1(in_List_2);
	struct mirth_mirth_LexicalState* v8 = in_zaMirth_1->mlexicalzestate;
	incref(MK_mirth_mirth_LexicalState(v8));
	FNPTR v9 = &mb_mirth_mirth_PropLabel_prop_1_sp19_0;
	struct mirth_mirth_PropState_1 v10 = mtw_mirth_mirth_PropState_1_Delay(v8, MKTUP(r7), MKFNPTR(v9));
	struct mirth_mirth_Prop_1* v11 = mtw_mirth_mirth_Prop_1_Prop(in_PropLabel_4, v10);
	*out_zaMirth_5 = in_zaMirth_1;
	return v11;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, -0x30(%rbp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movl %esi, %ebx
movq %rdi, %r14
movl $0x2, %edi
callq 0xe4ba
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
movq %rax, %rdx
andq %rcx, %rdx
movw $0x2, 0x6(%rdx)
movq %r12, 0x18(%rdx)
leaq 0xadde8(%rip), %rsi     # 0x116160
movq %rsi, 0x20(%rdx)
shlq $0x30, %rbx
orq %r13, %rbx
leaq 0xaceef(%rip), %rsi     # 0x115279
movq %rbx, 0x8(%rdx)
movq %rsi, 0x10(%rdx)
movq 0x48(%r14), %rdi
andq %rdi, %rcx
sete %dl
testb $0x3, %dil
setne %sil
orb %dl, %sil
jne 0x683ab
incl (%rcx)
leaq 0xacfe7(%rip), %rdx     # 0x115399
leaq 0x5ec2(%rip), %rcx      # 0x6e27b
movq %rax, %rsi
callq 0x27d72
movl $0xb, %edi
movq %r15, %rsi
movl $0x1, %edx
movq %rax, %rcx
callq 0x1faa2
movq -0x30(%rbp), %rcx
movq %r14, (%rcx)
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: mb_mirth_mirth_PropLabel_prop_1_sp43_0
static void mb_mirth_mirth_PropLabel_prop_1_sp43_0 (void) {
	uint64_t v0 = V_mirth_table_Table(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_table_Table_owner(r1, v0, &v2);
	struct mirth_mirth_zaMirth* v4;
	struct std_list_List_1 v5 = mw_mirth_table_StateOwner_ctx(v2, v3, &v4);
	struct mirth_type_StackType v6 = mw_mirth_type_T0();
	struct mirth_mirth_zaMirth* v7;
	struct mirth_table_StateOwner v8 = mw_mirth_table_Table_owner(v4, v0, &v7);
	struct mirth_mirth_zaMirth* v9;
	struct mirth_type_StackType v10 = mw_mirth_table_StateOwner_push(v7, v6, v8, &v9);
	incref(MK_mirth_type_StackType(v10));
	struct mirth_type_Type v11 = mtw_mirth_type_Type_Table(v0);
	struct mirth_type_StackType v12 = mw_mirth_type_Tzm(v10, v11);
	struct mirth_type_ArrowType* v13 = mw_mirth_type_Tzezg(v10, v12);
	PTUP r14 = PTRMK(0,tup_new(2),0);
	((TUP*)PTRPTR(r14))->size = 2;
	((TUP*)PTRPTR(r14))->cells[1] = MK_mirth_type_ArrowType(v13);
	((TUP*)PTRPTR(r14))->cells[0] = MK_std_list_List_1(v5);
	push_resource(MK_mirth_mirth_zaMirth(v9));
	push_value(MKTUP(r14));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
callq 0xda3f
movq %rax, %r14
callq 0xda98
movq %rax, %rbx
leaq 0x10b158e(%rip), %r12   # 0x111a010
movq %r12, %rdi
movq %r14, %rsi
callq 0x13ff0
leaq -0x30(%rbp), %r13
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x1a972
movq (%r13), %rdi
movq %rax, %rsi
shrq $0x30, %rsi
andq %r15, %rax
leaq -0x40(%rbp), %r13
movq %rax, %rdx
movq %r13, %rcx
callq 0x6e6f5
movl %eax, %ebx
movq %rdx, -0x38(%rbp)
movq (%r13), %r13
movq %r12, %rdi
movq %r14, %rsi
callq 0x13ff0
leaq -0x30(%rbp), %r12
movq %r13, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1a972
movq (%r12), %rdi
movq %rax, %rcx
shrq $0x30, %rcx
andq %r15, %rax
leaq -0x30(%rbp), %r9
movl $0x2, %esi
xorl %edx, %edx
movq %rax, %r8
callq 0x5e45b
movl %eax, %r12d
movq %rdx, %r13
movq %rdx, %rax
andq %r15, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0x68b20
incl (%rax)
movq %r14, %rdi
callq 0x3f21c
movl %r12d, %edi
movq %r13, %rsi
movl $0x6, %edx
movq %rax, %rcx
callq 0x20b1a
movq %rdx, %rcx
movl %r12d, %edi
movq %r13, %rsi
movl $0x5, %edx
callq 0x210ca
movq %rax, %r14
movl $0x2, %edi
callq 0xe4ba
movq %rax, %r12
andq %rax, %r15
movw $0x2, 0x6(%r15)
leaq 0xad00a(%rip), %rax     # 0x115b79
movq %r14, 0x18(%r15)
movq %rax, 0x20(%r15)
shlq $0x30, %rbx
orq -0x38(%rbp), %rbx
leaq 0xac6f3(%rip), %rax     # 0x115279
movq %rbx, 0x8(%r15)
movq %rax, 0x10(%r15)
movq -0x30(%rbp), %rdi
leaq 0xacd57(%rip), %rsi     # 0x1158f0
callq 0x9116
leaq 0xac7f4(%rip), %rsi     # 0x115399
movq %r12, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd6f1
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mb_mirth_mirth_PropLabel_prop_1_sp39_0
static void mb_mirth_mirth_PropLabel_prop_1_sp39_0 (void) {
	uint64_t v0 = V_mirth_table_Table(pop_value());
	struct mirth_mirth_zaMirth* r1 = V_mirth_mirth_zaMirth(pop_resource());
	struct std_list_List_1 v2 = mw_mirth_var_Ctx_L0();
	struct mirth_type_Type v3 = mtw_mirth_type_Type_Table(v0);
	struct mirth_type_StackType v4 = mw_mirth_type_T1(v3);
	struct mirth_type_Type v5 = mw_mirth_type_Type_U64();
	struct mirth_type_StackType v6 = mw_mirth_type_T1(v5);
	struct mirth_type_ArrowType* v7 = mw_mirth_type_Tzezg(v4, v6);
	PTUP r8 = PTRMK(0,tup_new(2),0);
	((TUP*)PTRPTR(r8))->size = 2;
	((TUP*)PTRPTR(r8))->cells[1] = MK_mirth_type_ArrowType(v7);
	((TUP*)PTRPTR(r8))->cells[0] = MK_std_list_List_1(v2);
	push_resource(MK_mirth_mirth_zaMirth(r1));
	push_value(MKTUP(r8));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0xda3f
movq %rax, %r14
callq 0xda98
movq %rax, %rbx
movq %r14, %rdi
callq 0x3f21c
movl $0x2, %edi
xorl %esi, %esi
movl $0x6, %edx
movq %rax, %rcx
callq 0x20b1a
movq %rdx, %r14
movl $0xa, %edi
callq 0x1ef8a
movq %rdx, %rcx
movl $0x2, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x20b1a
movq %rdx, %rcx
movl $0x5, %edi
movq %r14, %rsi
movl $0x5, %edx
callq 0x210ca
movq %rax, %r14
movl $0x2, %edi
callq 0xe4ba
movq %rax, %r15
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r15, %rax
movw $0x2, 0x6(%rax)
leaq 0xaba9b(%rip), %rcx     # 0x115b79
movq %r14, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0xab18c(%rip), %rcx     # 0x115279
movq $0x0, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0xab7f0(%rip), %rsi     # 0x1158f0
movq %rbx, %rdi
callq 0x9116
leaq 0xab28a(%rip), %rsi     # 0x115399
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd6f1
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mb_mirth_mirth_PropLabel_prop_1_sp37_0
static void mb_mirth_mirth_PropLabel_prop_1_sp37_0 (void) {
	uint64_t v0 = V_mirth_table_Table(pop_value());
	struct mirth_mirth_zaMirth* r1 = V_mirth_mirth_zaMirth(pop_resource());
	struct std_list_List_1 v2 = mw_mirth_var_Ctx_L0();
	struct mirth_type_Type v3 = mtw_mirth_type_Type_Table(v0);
	incref(MK_mirth_type_Type(v3));
	struct mirth_type_StackType v4 = mw_mirth_type_T2(v3, v3);
	struct mirth_type_Type v5 = mw_mirth_type_Type_Bool();
	struct mirth_type_StackType v6 = mw_mirth_type_T1(v5);
	struct mirth_type_ArrowType* v7 = mw_mirth_type_Tzezg(v4, v6);
	PTUP r8 = PTRMK(0,tup_new(2),0);
	((TUP*)PTRPTR(r8))->size = 2;
	((TUP*)PTRPTR(r8))->cells[1] = MK_mirth_type_ArrowType(v7);
	((TUP*)PTRPTR(r8))->cells[0] = MK_std_list_List_1(v2);
	push_resource(MK_mirth_mirth_zaMirth(r1));
	push_value(MKTUP(r8));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
callq 0xda3f
movq %rax, %r14
callq 0xda98
movq %rax, %rbx
movq %r14, %rdi
callq 0x3f21c
movq %rax, %r14
andq %r12, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x6a76e
incl (%rax)
movl $0x2, %edi
xorl %esi, %esi
movl $0x6, %edx
movq %r14, %rcx
callq 0x20b1a
movl $0x5, %edi
movq %rdx, %rsi
movl $0x6, %edx
movq %r14, %rcx
callq 0x20b1a
movq %rdx, %r14
movl $0x4, %edi
callq 0x1ef8a
movq %rdx, %rcx
movl $0x2, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x20b1a
movq %rdx, %rcx
movl $0x5, %edi
movq %r14, %rsi
movl $0x5, %edx
callq 0x210ca
movq %rax, %r14
movl $0x2, %edi
callq 0xe4ba
movq %rax, %r15
andq %rax, %r12
movw $0x2, 0x6(%r12)
leaq 0xab38a(%rip), %rax     # 0x115b79
movq %r14, 0x18(%r12)
movq %rax, 0x20(%r12)
leaq 0xaaa79(%rip), %rax     # 0x115279
movq $0x0, 0x8(%r12)
movq %rax, 0x10(%r12)
leaq 0xab0db(%rip), %rsi     # 0x1158f0
movq %rbx, %rdi
callq 0x9116
leaq 0xaab75(%rip), %rsi     # 0x115399
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd6f1
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mb_mirth_mirth_PropLabel_prop_1_sp35_0
static void mb_mirth_mirth_PropLabel_prop_1_sp35_0 (void) {
	uint64_t v0 = V_mirth_table_Table(pop_value());
	struct mirth_mirth_zaMirth* r1 = V_mirth_mirth_zaMirth(pop_resource());
	struct std_list_List_1 v2 = mw_mirth_var_Ctx_L0();
	struct mirth_type_Type v3 = mw_mirth_type_Type_U64();
	struct mirth_type_StackType v4 = mw_mirth_type_T1(v3);
	struct mirth_type_Type v5 = mtw_mirth_type_Type_Table(v0);
	struct mirth_type_StackType v6 = mw_mirth_type_T1(v5);
	struct mirth_type_ArrowType* v7 = mw_mirth_type_Tzezg(v4, v6);
	PTUP r8 = PTRMK(0,tup_new(2),0);
	((TUP*)PTRPTR(r8))->size = 2;
	((TUP*)PTRPTR(r8))->cells[1] = MK_mirth_type_ArrowType(v7);
	((TUP*)PTRPTR(r8))->cells[0] = MK_std_list_List_1(v2);
	push_resource(MK_mirth_mirth_zaMirth(r1));
	push_value(MKTUP(r8));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0xda3f
movq %rax, %r14
callq 0xda98
movq %rax, %rbx
movl $0xa, %edi
callq 0x1ef8a
movq %rdx, %rcx
movl $0x2, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x20b1a
movq %rdx, %r15
movq %r14, %rdi
callq 0x3f21c
movl $0x2, %edi
xorl %esi, %esi
movl $0x6, %edx
movq %rax, %rcx
callq 0x20b1a
movq %rdx, %rcx
movl $0x5, %edi
movq %r15, %rsi
movl $0x5, %edx
callq 0x210ca
movq %rax, %r14
movl $0x2, %edi
callq 0xe4ba
movq %rax, %r15
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r15, %rax
movw $0x2, 0x6(%rax)
leaq 0xaaae8(%rip), %rcx     # 0x115b79
movq %r14, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0xaa1d9(%rip), %rcx     # 0x115279
movq $0x0, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0xaa83d(%rip), %rsi     # 0x1158f0
movq %rbx, %rdi
callq 0x9116
leaq 0xaa2d7(%rip), %rsi     # 0x115399
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd6f1
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_mirth_PropLabel_prop_1_sp30
static struct mirth_mirth_Prop_1* mw_mirth_mirth_PropLabel_prop_1_sp30 (uint64_t in_Table_1, struct mirth_mirth_zaMirth* in_zaMirth_2, struct mirth_mirth_PropLabel in_PropLabel_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	struct mirth_mirth_LexicalState* v6 = in_zaMirth_2->mlexicalzestate;
	incref(MK_mirth_mirth_LexicalState(v6));
	FNPTR v7 = &mb_mirth_mirth_PropLabel_prop_1_sp30_0;
	struct mirth_mirth_PropState_1 v8 = mtw_mirth_mirth_PropState_1_Delay(v6, MK_mirth_table_Table(in_Table_1), MKFNPTR(v7));
	struct mirth_mirth_Prop_1* v9 = mtw_mirth_mirth_Prop_1_Prop(in_PropLabel_3, v8);
	*out_zaMirth_4 = in_zaMirth_2;
	return v9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rsi
movq 0x48(%r14), %rdi
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x6c135
incl (%rax)
leaq 0xa9f4c(%rip), %rdx     # 0x116088
leaq 0x2f96(%rip), %rcx      # 0x6f0d9
callq 0x27d72
movl $0xa, %edi
movq %r15, %rsi
movl $0x1, %edx
movq %rax, %rcx
callq 0x1faa2
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq