LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x10b24fe(%rip), %r15   # 0x1115fc8
incq %r15
movq %r15, 0x10b24f4(%rip)   # 0x1115fc8
leaq 0x10b24cd(%rip), %rdi   # 0x1115fa8
movq %r15, %rsi
callq 0x13c85
shlq $0x30, %r14
orq %rbx, %r14
leaq 0xad7d0(%rip), %rsi     # 0x1112c1
movq %r14, %rdi
movq %rax, %rdx
callq 0x14766
leaq 0x10b12dd(%rip), %rdi   # 0x1114de0
movq %r15, %rsi
callq 0x13c85
leaq 0xae2a6(%rip), %rsi     # 0x111db8
movq %r13, %rdi
movq %rax, %rdx
callq 0x14766
leaq 0x10b2494(%rip), %rdi   # 0x1115fb8
movq %r15, %rsi
callq 0x13c85
leaq 0xad8f6(%rip), %rsi     # 0x111429
movq %r12, %rdi
movq %rax, %rdx
callq 0x14766
leaq 0x10b13d3(%rip), %rdi   # 0x1114f18
movq %r15, %rsi
callq 0x13c85
leaq 0xadba4(%rip), %rsi     # 0x1116f8
movq -0x30(%rbp), %rdi
movq %rax, %rdx
callq 0x14766
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_O3/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 0x63bab
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x83539(%rip), %rsi     # 0xe70eb
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_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 0x63bfe
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x83518(%rip), %rsi     # 0xe711d
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_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 0x63c79
decl (%rax)
jne 0x63c79
movq %rbx, %rdi
shlq $0x30, %rdi
orq %rcx, %rdi
leaq 0xad64d(%rip), %rsi     # 0x1112c1
callq 0xd13d
leaq 0x1(,%rbx,2), %rdi
movl $0x1, %esi
callq 0xe83a
testl %eax, %eax
je 0x63ca9
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 0x10b22e8(%rip), %rdx   # 0x1115f98
testq %rdx, %rdx
jne 0x63cea
movl $0x15, %edi
callq 0xf5e4
movq %rax, %rdx
movq $0x15, 0x10(%rax)
movabsq $0x2e656d616e207265, %rax # imm = 0x2E656D616E207265
movq %rax, 0x25(%rdx)
movups 0x833e0(%rip), %xmm0    # 0xe70bf
movups %xmm0, 0x18(%rdx)
movq %rdx, 0x10b22ae(%rip)   # 0x1115f98
andq %rdx, %r13
sete %al
testb $0x3, %dl
setne %cl
orb %al, %cl
jne 0x63cfe
incl (%r13)
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x27183
// File: /workspace/github_c_makefile_star2_O3/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 0x10b16ca(%rip), %rdi   # 0x11153e8
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
movabsq $0xfffffffffffc, %rdi   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdi
movq %rax, %rcx
shrq $0x30, %rcx
cmpl $0xe, %ecx
jne 0x63d5f
callq 0x5185b
leaq 0xad6d9(%rip), %rsi     # 0x111429
movq %rax, %rdi
callq 0x9353
movl $0x1, %eax
jmp 0x63d7f
testq %rdi, %rdi
je 0x63d7b
decl (%rdi)
jne 0x63d7b
andq $-0x4, %rax
leaq 0xae166(%rip), %rsi     # 0x111ed9
movq %rax, %rdi
callq 0xd13d
xorl %eax, %eax
xorl %edx, %edx
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_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 0x63dbb
movq %r9, %r12
movq %r8, %r15
movq %rcx, %rdi
callq 0xd745
movq %rbx, (%r12)
movq %r14, (%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x10b21de(%rip), %rdx   # 0x1115fa0
testq %rdx, %rdx
jne 0x63dfc
movl $0x15, %edi
callq 0xf5e4
movq %rax, %rdx
movq $0x15, 0x10(%rax)
movabsq $0x2e657a6973207265, %rax # imm = 0x2E657A6973207265
movq %rax, 0x25(%rdx)
movups 0x832e4(%rip), %xmm0    # 0xe70d5
movups %xmm0, 0x18(%rdx)
movq %rdx, 0x10b21a4(%rip)   # 0x1115fa0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x63e1a
incl (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27183
// File: /workspace/github_c_makefile_star2_O3/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 0x66242
decl (%rax)
jne 0x66242
movq %rbx, %rdi
shlq $0x30, %rdi
orq %rcx, %rdi
leaq 0xab084(%rip), %rsi     # 0x1112c1
callq 0xd13d
leaq 0x1(,%rbx,2), %rdi
movl $0x1, %esi
callq 0xe83a
testl %eax, %eax
je 0x66272
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 0x10afd67(%rip), %rdx   # 0x1115fe0
testq %rdx, %rdx
jne 0x662ab
movl $0x12, %edi
callq 0xf5e4
movq %rax, %rdx
movq $0x12, 0x10(%rax)
movups 0x80eef(%rip), %xmm0    # 0xe7189
movups %xmm0, 0x18(%rax)
movw $0x656d, 0x28(%rax)     # imm = 0x656D
movq %rax, 0x10afd35(%rip)   # 0x1115fe0
andq %rdx, %r13
sete %al
testb $0x3, %dl
setne %cl
orb %al, %cl
jne 0x662bf
incl (%r13)
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x27183
// File: /workspace/github_c_makefile_star2_O3/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 0xac6ff(%rip), %rax     # 0x112a61
cmpq %rsi, %rax
jne 0x663e6
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x10(%rdi), %rcx
leaq 0xaaf42(%rip), %r14     # 0x1112c1
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x663a9
decl (%rax)
jne 0x663a9
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xd13d
movq 0x38(%rbx), %rax
andq %rax, %r15
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x663d4
decl (%r15)
jne 0x663d4
movl 0x30(%rbx), %edi
shlq $0x30, %rdi
orq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0xd13d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
leaq 0x80e7b(%rip), %rsi     # 0xe7268
movl $0x5c, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0xd699
movq %rax, %r14
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rbx
shrq $0x30, %r14
callq 0xd6f2
leaq -0x20(%rbp), %r15
movq %rax, %rdi
movl %r14d, %esi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x6c087
movl %eax, %ebx
movq %rdx, %r14
movq (%r15), %rdi
leaq 0xab44c(%rip), %rsi     # 0x1118f0
callq 0x8e6d
shlq $0x30, %rbx
orq %r14, %rbx
leaq 0xac5f2(%rip), %rsi     # 0x112aa9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd34b
// File: /workspace/github_c_makefile_star2_O3/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 0x12e7f
movq %rax, %r12
movq %r15, %rdi
callq 0x2cf65
movl $0x1, %edi
movq %rax, %rsi
callq 0x1947e
movl $0x1, %ecx
movl $0x3, %edi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1549b
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_O3/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 0xe0e7
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
movq %rax, %rdx
andq %rcx, %rdx
movw $0x2, 0x6(%rdx)
movq %r12, 0x18(%rdx)
leaq 0xabbeb(%rip), %rsi     # 0x112160
movq %rsi, 0x20(%rdx)
movq %r13, 0x8(%rdx)
leaq 0xabb04(%rip), %rsi     # 0x112088
movq %rsi, 0x10(%rdx)
movq 0x48(%r14), %rdi
andq %rdi, %rcx
sete %dl
testb $0x3, %dil
setne %sil
orb %dl, %sil
jne 0x665a1
incl (%rcx)
leaq 0xaadf1(%rip), %rdx     # 0x111399
leaq 0x5fdb(%rip), %rcx      # 0x6c58a
movq %rax, %rsi
callq 0x27765
movl $0x9, %edi
movq %r15, %rsi
movl $0x1, %edx
movq %rax, %rcx
callq 0x1f63a
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_O3/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 0xd699
movq %rax, %r14
callq 0xd6f2
movq %rax, %rbx
movq %r14, %rdi
callq 0x3ded5
movl $0x2, %edi
xorl %esi, %esi
movl $0x6, %edx
movq %rax, %rcx
callq 0x205af
movq %rdx, %rcx
movl $0x2, %edi
xorl %esi, %esi
movl $0x5, %edx
callq 0x20b5f
movq %rax, %r14
movl $0x2, %edi
callq 0xe0e7
movq %rax, %r15
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r15, %rax
movw $0x2, 0x6(%rax)
leaq 0xab527(%rip), %rcx     # 0x111b79
movq %r14, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0xaac18(%rip), %rcx     # 0x111279
movq $0x0, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0xab27c(%rip), %rsi     # 0x1118f0
movq %rbx, %rdi
callq 0x8e6d
leaq 0xaad16(%rip), %rsi     # 0x111399
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd34b
// File: /workspace/github_c_makefile_star2_O3/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 0xe0e7
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
movq %rax, %rdx
andq %rcx, %rdx
movw $0x2, 0x6(%rdx)
movq %r12, 0x18(%rdx)
leaq 0xaba80(%rip), %rsi     # 0x112160
movq %rsi, 0x20(%rdx)
shlq $0x30, %rbx
orq %r13, %rbx
leaq 0xaab87(%rip), %rsi     # 0x111279
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 0x66713
incl (%rcx)
leaq 0xaac7f(%rip), %rdx     # 0x111399
leaq 0x5fb7(%rip), %rcx      # 0x6c6d8
movq %rax, %rsi
callq 0x27765
movl $0xb, %edi
movq %r15, %rsi
movl $0x1, %edx
movq %rax, %rcx
callq 0x1f63a
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_O3/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 0xd699
movq %rax, %r14
callq 0xd6f2
movq %rax, %rbx
leaq 0x10af1e3(%rip), %r12   # 0x1116010
movq %r12, %rdi
movq %r14, %rsi
callq 0x13c85
leaq -0x30(%rbp), %r13
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x1a6db
movq (%r13), %rdi
movq %rax, %rsi
shrq $0x30, %rsi
andq %r15, %rax
leaq -0x40(%rbp), %r13
movq %rax, %rdx
movq %r13, %rcx
callq 0x6cb06
movl %eax, %ebx
movq %rdx, -0x38(%rbp)
movq (%r13), %r13
movq %r12, %rdi
movq %r14, %rsi
callq 0x13c85
leaq -0x30(%rbp), %r12
movq %r13, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1a6db
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 0x5cc27
movl %eax, %r12d
movq %rdx, %r13
movq %rdx, %rax
andq %r15, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0x66ecb
incl (%rax)
movq %r14, %rdi
callq 0x3ded5
movl %r12d, %edi
movq %r13, %rsi
movl $0x6, %edx
movq %rax, %rcx
callq 0x205af
movq %rdx, %rcx
movl %r12d, %edi
movq %r13, %rsi
movl $0x5, %edx
callq 0x20b5f
movq %rax, %r14
movl $0x2, %edi
callq 0xe0e7
movq %rax, %r12
andq %rax, %r15
movw $0x2, 0x6(%r15)
leaq 0xaac5f(%rip), %rax     # 0x111b79
movq %r14, 0x18(%r15)
movq %rax, 0x20(%r15)
shlq $0x30, %rbx
orq -0x38(%rbp), %rbx
leaq 0xaa348(%rip), %rax     # 0x111279
movq %rbx, 0x8(%r15)
movq %rax, 0x10(%r15)
movq -0x30(%rbp), %rdi
leaq 0xaa9ac(%rip), %rsi     # 0x1118f0
callq 0x8e6d
leaq 0xaa449(%rip), %rsi     # 0x111399
movq %r12, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd34b
// File: /workspace/github_c_makefile_star2_O3/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 0xd699
movq %rax, %r14
callq 0xd6f2
movq %rax, %rbx
movq %r14, %rdi
callq 0x3ded5
movl $0x2, %edi
xorl %esi, %esi
movl $0x6, %edx
movq %rax, %rcx
callq 0x205af
movq %rdx, %r14
movl $0xa, %edi
callq 0x1eb4d
movq %rdx, %rcx
movl $0x2, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x205af
movq %rdx, %rcx
movl $0x5, %edi
movq %r14, %rsi
movl $0x5, %edx
callq 0x20b5f
movq %rax, %r14
movl $0x2, %edi
callq 0xe0e7
movq %rax, %r15
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r15, %rax
movw $0x2, 0x6(%rax)
leaq 0xa96d4(%rip), %rcx     # 0x111b79
movq %r14, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0xa8dc5(%rip), %rcx     # 0x111279
movq $0x0, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0xa9429(%rip), %rsi     # 0x1118f0
movq %rbx, %rdi
callq 0x8e6d
leaq 0xa8ec3(%rip), %rsi     # 0x111399
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd34b
// File: /workspace/github_c_makefile_star2_O3/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 0xd699
movq %rax, %r14
callq 0xd6f2
movq %rax, %rbx
movq %r14, %rdi
callq 0x3ded5
movq %rax, %r14
andq %r12, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x68b46
incl (%rax)
movl $0x2, %edi
xorl %esi, %esi
movl $0x6, %edx
movq %r14, %rcx
callq 0x205af
movl $0x5, %edi
movq %rdx, %rsi
movl $0x6, %edx
movq %r14, %rcx
callq 0x205af
movq %rdx, %r14
movl $0x4, %edi
callq 0x1eb4d
movq %rdx, %rcx
movl $0x2, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x205af
movq %rdx, %rcx
movl $0x5, %edi
movq %r14, %rsi
movl $0x5, %edx
callq 0x20b5f
movq %rax, %r14
movl $0x2, %edi
callq 0xe0e7
movq %rax, %r15
andq %rax, %r12
movw $0x2, 0x6(%r12)
leaq 0xa8fb2(%rip), %rax     # 0x111b79
movq %r14, 0x18(%r12)
movq %rax, 0x20(%r12)
leaq 0xa86a1(%rip), %rax     # 0x111279
movq $0x0, 0x8(%r12)
movq %rax, 0x10(%r12)
leaq 0xa8d03(%rip), %rsi     # 0x1118f0
movq %rbx, %rdi
callq 0x8e6d
leaq 0xa879d(%rip), %rsi     # 0x111399
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd34b
// File: /workspace/github_c_makefile_star2_O3/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 0xd699
movq %rax, %r14
callq 0xd6f2
movq %rax, %rbx
movl $0xa, %edi
callq 0x1eb4d
movq %rdx, %rcx
movl $0x2, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x205af
movq %rdx, %r15
movq %r14, %rdi
callq 0x3ded5
movl $0x2, %edi
xorl %esi, %esi
movl $0x6, %edx
movq %rax, %rcx
callq 0x205af
movq %rdx, %rcx
movl $0x5, %edi
movq %r15, %rsi
movl $0x5, %edx
callq 0x20b5f
movq %rax, %r14
movl $0x2, %edi
callq 0xe0e7
movq %rax, %r15
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r15, %rax
movw $0x2, 0x6(%rax)
leaq 0xa86ee(%rip), %rcx     # 0x111b79
movq %r14, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0xa7ddf(%rip), %rcx     # 0x111279
movq $0x0, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0xa8443(%rip), %rsi     # 0x1118f0
movq %rbx, %rdi
callq 0x8e6d
leaq 0xa7edd(%rip), %rsi     # 0x111399
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd34b
// File: /workspace/github_c_makefile_star2_O3/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 0x6a56c
incl (%rax)
leaq 0xa7b15(%rip), %rdx     # 0x112088
leaq 0x2eda(%rip), %rcx      # 0x6d454
callq 0x27765
movl $0xa, %edi
movq %r15, %rsi
movl $0x1, %edx
movq %rax, %rcx
callq 0x1f63a
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_table_StateOwner_free
void mirth_table_StateOwner_free (VAL v) {
	struct mirth_table_StateOwner self = V_mirth_table_StateOwner(v);
	switch (self.tag) {
		case mirth_table_StateOwner_Error: break;
		case mirth_table_StateOwner_Default: break;
		case mirth_table_StateOwner_Resource: {
			decref(MK_std_list_List_1(self.ptr.Resource->mCtx));
			decref(MK_mirth_type_Type(self.ptr.Resource->mResource));
			free(self.ptr.Resource);
		} break;
	}
}

// Assembly:
movq %rdi, %rax
shrq $0x30, %rax
cmpl $0x2, %eax
jne 0x6c53c
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
andq %r14, %rbx
movq 0x10(%rbx), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x6c501
decl (%rax)
jne 0x6c501
leaq 0xa4d88(%rip), %rsi     # 0x111279
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
callq 0xd13d
movq 0x20(%rbx), %rax
andq %rax, %r14
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x6c530
decl (%r14)
jne 0x6c530
leaq 0xa55c9(%rip), %rsi     # 0x111ae9
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
callq 0xd13d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mb_mirth_mirth_PropLabel_prop_1_sp29_0
static void mb_mirth_mirth_PropLabel_prop_1_sp29_0 (void) {
	PTUP v0 = value_tup(pop_value());
	struct mirth_mirth_zaMirth* r1 = V_mirth_mirth_zaMirth(pop_resource());
	VAL v2 = ((TUP*)PTRPTR(v0))->cells[0];
	VAL v3 = ((TUP*)PTRPTR(v0))->cells[1];
	tup_decref_outer(v0);
	incref(v2);
	struct mirth_tycon_Tycon v4 = mtw_mirth_tycon_Tycon_Table(V_mirth_table_Table(v2));
	struct mirth_name_Namespace v5 = mtw_mirth_name_Namespace_Tycon(v4);
	decref(v2);
	incref(v3);
	struct mirth_mirth_zaMirth* v6;
	INT v7 = mw_mirth_word_Word_arity(r1, V_mirth_word_Word(v3), &v6);
	INT v8 = v7;
	struct mirth_mirth_zaMirth* v9;
	uint64_t v10 = mw_mirth_word_Word_name(v6, V_mirth_word_Word(v3), &v9);
	struct mirth_name_QName* v11 = mtw_mirth_name_QName_QName(v5, v10, v8);
	push_resource(MK_mirth_mirth_zaMirth(v9));
	push_value(MK_mirth_name_QName(v11));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
callq 0xd699
movq %rax, %r15
movq %rax, %rdi
movq %rdx, %rsi
callq 0x90ba
callq 0xd6f2
movq %rax, -0x38(%rbp)
movq %r15, %rax
andq %rbx, %rax
movq 0x8(%rax), %r12
movq 0x10(%rax), %r13
movq 0x18(%rax), %r14
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq %r15, %rdi
callq 0x910b
testb $0x1, %r13b
je 0x6c5ff
movq %r12, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x6c5ff
incl (%rax)
movq %r12, %rdi
callq 0x2cf65
movl $0x1, %edi
movq %rax, %rsi
callq 0x1947e
movq %rax, %r15
testb $0x1, %r13b
je 0x6c640
movq %r12, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x6c640
decl (%rax)
jne 0x6c640
movq %r12, %rdi
movq %r13, %rsi
callq 0xd13d
testb $0x1, -0x30(%rbp)
je 0x6c659
andq %r14, %rbx
sete %al
testb $0x3, %r14b
setne %cl
orb %al, %cl
jne 0x6c659
incl (%rbx)
leaq 0x10a9030(%rip), %rdi   # 0x1115690
movq %r14, %rsi
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
movq %rax, %r12
movq %rax, %rdi
movq %rdx, %rsi
callq 0x324c1
leaq 0x10a88e3(%rip), %rdi   # 0x1114f68
movq %r14, %rsi
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
movl $0x3, %edi
movq %r15, %rsi
movq %rax, %rdx
movq %r12, %rcx
callq 0x1549b
movq %rax, %r14
leaq 0xa523e(%rip), %rsi     # 0x1118f0
movq -0x38(%rbp), %rdi
callq 0x8e6d
leaq 0xa507f(%rip), %rsi     # 0x111741
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd34b
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_arrow_Op_TableFromIndex
static struct mirth_arrow_Op mtw_mirth_arrow_Op_TableFromIndex (uint64_t in_Table_1) {
	struct mirth_arrow_Op_TableFromIndex* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mTable = in_Table_1;
	struct mirth_arrow_Op v4 = { .tag=mirth_arrow_Op_TableFromIndex, .ptr.TableFromIndex=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 0x6cae1
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x7ac14(%rip), %rsi     # 0xe76fc
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_table_StateOwner_ctx
static struct std_list_List_1 mw_mirth_table_StateOwner_ctx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_table_StateOwner in_StateOwner_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* branch_zaMirth_5;
	struct std_list_List_1 branch_Ctx_6;
	switch ((in_StateOwner_2).tag) {
		case mirth_table_StateOwner_Error: {
			struct std_list_List_1 v7 = mw_mirth_var_Ctx_L0();
			branch_Ctx_6 = v7;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case mirth_table_StateOwner_Default: {
			struct std_list_List_1 v8 = mw_mirth_var_Ctx_L0();
			branch_Ctx_6 = v8;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case mirth_table_StateOwner_Resource: {
			struct mirth_type_Type v9;
			struct std_list_List_1 v10 = mtp_mirth_table_StateOwner_Resource(in_StateOwner_2, &v9);
			decref(MK_mirth_type_Type(v9));
			branch_Ctx_6 = v10;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_3 = branch_zaMirth_5;
	return branch_Ctx_6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x2, %esi
jae 0x6cb40
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %r14, (%rbx)
movl %r15d, %eax
movq %r12, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jne 0x6cb92
leaq -0x38(%rbp), %r13
movq %rdx, %rdi
movq %r13, %rsi
callq 0x5cd39
movl %eax, %r15d
movq %rdx, %r12
movq 0x8(%r13), %rax
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x6cb28
movl -0x38(%rbp), %edi
decl (%rcx)
jne 0x6cb28
shlq $0x30, %rdi
orq %rax, %rdi
leaq 0xa4f5e(%rip), %rsi     # 0x111ae9
callq 0xd13d
jmp 0x6cb28
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x73b22(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x73b27(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_table_Table_inlinezefields
static struct std_list_List_1 mw_mirth_table_Table_inlinezefields (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_inlinezefields, in_Table_2);
	bool v6 = mut_is_set(v5);
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	struct std_list_List_1 branch_List_8;
	if (v6) {
		VAL v9 = mut_get(v5);
		branch_List_8 = V_std_list_List_1(v9);
		branch_zaMirth_7 = in_zaMirth_1;
	} else {
		struct std_list_List_1 v10 = { .tag=std_list_List_1_Nil };
		incref(MK_std_list_List_1(v10));
		mut_set(MK_std_list_List_1(v10), v5);
		branch_List_8 = v10;
		branch_zaMirth_7 = in_zaMirth_1;
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_List_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10a9381(%rip), %rdi   # 0x1116128
callq 0x13c85
movq %rax, %r15
movq %rax, %rdi
callq 0x1505d
testb %al, %al
je 0x6cdd9
movq %r15, %rdi
callq 0x13d82
movq %rax, %r12
movabsq $0xfffffffffffc, %rdx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdx
shrq $0x30, %r12
jmp 0x6cdef
leaq 0xa4499(%rip), %rsi     # 0x111279
xorl %r12d, %r12d
xorl %edi, %edi
movq %r15, %rdx
callq 0x14766
xorl %edx, %edx
movq %r14, (%rbx)
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_table_Field_iszerawzy
static bool mw_mirth_table_Field_iszerawzy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Field_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	uint64_t v6 = mw_mirth_table_Field_name(in_zaMirth_1, in_Field_2, &v5);
	struct mirth_mirth_zaMirth* v7;
	bool v8 = mw_mirth_name_Name_couldzebezerawzefieldzenamezy(v5, v6, &v7);
	*out_zaMirth_3 = v7;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10a8163(%rip), %rdi   # 0x1114f78
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
leaq -0x20(%rbp), %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1ec3f
movl %eax, %eax
leaq 0x1(,%rax,2), %rdi
callq 0xe445
cmpb $0x7e, %al
sete %al
movq (%r15), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_elab_zaAB_abzeargzeblockzx_1_sp16
static uint64_t mw_mirth_elab_zaAB_abzeargzeblockzx_1_sp16 (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_type_ArrowType* in_ArrowType_2, struct mirth_arrow_Arrow* in_zaAB_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_arrow_Arrow* *out_zaAB_5) {
	struct mirth_arrow_Arrow* v7;
	struct std_list_List_1 v8 = mw_mirth_elab_zaAB_abzectxzo(in_zaAB_3, &v7);
	struct mirth_arrow_Arrow* v9;
	uint64_t v10 = mw_mirth_elab_zaAB_abzetokenzo(v7, &v9);
	struct mirth_arrow_Arrow* v11;
	struct mirth_arrow_Home v12 = mw_mirth_elab_zaAB_abzehomezo(v9, &v11);
	struct mirth_type_StackType v13;
	struct mirth_type_StackType v14;
	mtp_mirth_type_ArrowType_ArrowType(in_ArrowType_2, &v13, &v14);
	incref(MK_mirth_type_StackType(v13));
	struct std_list_List_1 v15 = { .tag=std_list_List_1_Nil };
	struct mirth_arrow_Arrow* v16 = mtw_mirth_arrow_Arrow_Arrow(v12, v10, v10, v8, v13, v13, v15);
	struct mirth_mirth_zaMirth* v17;
	struct mirth_arrow_Arrow* v18;
	mw_mirth_elab_zaAB_abzeunifyzetypezx(in_zaMirth_1, v16, v14, &v17, &v18);
	struct mirth_mirth_zaMirth* v19;
	uint64_t v20 = mw_mirth_arrow_Block_Newzx(v17, v18, &v19);
	*out_zaAB_5 = v11;
	*out_zaMirth_4 = v19;
	return v20;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r8, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq %rsi, %r12
movq %rdi, -0x40(%rbp)
leaq -0xa0(%rbp), %rbx
movq %rdx, %rdi
movq %rbx, %rsi
callq 0x43317
movl %eax, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movq (%rbx), %rdi
leaq -0x98(%rbp), %r14
movq %r14, %rsi
callq 0x432bd
movq %rax, %rbx
movq (%r14), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4371e
movl %eax, %r14d
movq %rdx, %r15
leaq -0x90(%rbp), %r13
leaq -0x68(%rbp), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x3a145
movq 0x8(%r13), %rcx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rcx, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x6d3c2
incl (%rax)
xorps %xmm0, %xmm0
movaps %xmm0, -0xb0(%rbp)
movups %xmm0, 0x20(%rsp)
movups -0x90(%rbp), %xmm0
movups %xmm0, 0x10(%rsp)
movups %xmm0, (%rsp)
movl %r14d, %edi
movq %r15, %rsi
movq %rbx, %rdx
movq %rbx, %rcx
movl -0x2c(%rbp), %r8d
movq -0x38(%rbp), %r9
callq 0x42f0b
movl -0x68(%rbp), %edx
movq -0x60(%rbp), %rcx
leaq -0x80(%rbp), %rbx
leaq -0x78(%rbp), %r14
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq %rbx, %r8
movq %r14, %r9
callq 0x4379b
movq (%rbx), %rdi
movq (%r14), %rsi
leaq -0x70(%rbp), %rbx
movq %rbx, %rdx
callq 0x55941
movq -0x58(%rbp), %rcx
movq -0x48(%rbp), %rdx
movq %rcx, (%rdx)
movq (%rbx), %rcx
movq -0x50(%rbp), %rdx
movq %rcx, (%rdx)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_maybe_Maybe_1_unwrap_1_sp62
static VAL mw_std_maybe_Maybe_1_unwrap_1_sp62 (struct std_maybe_Maybe_1 in_Maybe_1) {
	VAL branch_zux1_3;
	switch ((in_Maybe_1).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v4 = mtp_std_maybe_Maybe_1_Some(in_Maybe_1);
			branch_zux1_3 = v4;
		} break;
		case std_maybe_Maybe_1_None: {
			STR* v5;
			STRLIT(v5, "unexpected number of params", 27);
			do_panic(v5);
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	return branch_zux1_3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1, %edi
jne 0x6dc56
movq %rsi, %rdi
popq %rbp
jmp 0xd745
testl %edi, %edi
jne 0x6dcba
movq 0x10a84ef(%rip), %rdi   # 0x1116150
testq %rdi, %rdi
jne 0x6dc98
movl $0x1b, %edi
callq 0xf5e4
movq %rax, %rdi
movq $0x1b, 0x10(%rax)
movups 0x79ade(%rip), %xmm0    # 0xe7760
movups %xmm0, 0x18(%rax)
movups 0x79ade(%rip), %xmm0    # 0xe776b
movups %xmm0, 0x23(%rax)
movq %rax, 0x10a84b8(%rip)   # 0x1116150
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x6dcb5
incl (%rax)
callq 0x9302
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0x729fa(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0x729ff(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_table_Field_Makezx
static uint64_t mw_mirth_table_Field_Makezx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct std_maybe_Maybe_1 in_Maybe_2, uint64_t in_Token_3, struct std_maybe_Maybe_1 in_Maybe_4, uint64_t in_Name_5, struct mirth_mirth_zaMirth* *out_zaMirth_6) {
	struct mirth_mirth_zaMirth* v8;
	uint64_t v9 = mw_mirth_table_Field_Alloczx(in_zaMirth_1, &v8);
	void* v10 = field_mut(&mfld_mirth_table_Field_doc, v9);
	mut_set(MK_std_maybe_Maybe_1(in_Maybe_2), v10);
	void* v11 = field_mut(&mfld_mirth_table_Field_head, v9);
	mut_set(MK_mirth_token_Token(in_Token_3), v11);
	void* v12 = field_mut(&mfld_mirth_table_Field_default, v9);
	mut_set(MK_std_maybe_Maybe_1(in_Maybe_4), v12);
	void* v13 = field_mut(&mfld_mirth_table_Field_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)
movl %r8d, %r12d
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %r13d
movq %rdi, -0x38(%rbp)
movq 0x10a7d50(%rip), %r14   # 0x1116168
incq %r14
movq %r14, 0x10a7d46(%rip)   # 0x1116168
leaq 0x10a7d2f(%rip), %rdi   # 0x1116158
movq %r14, %rsi
callq 0x13c85
shlq $0x30, %r13
orq %rbx, %r13
leaq 0xa2e82(%rip), %rbx     # 0x1112c1
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x14766
leaq 0x10a699c(%rip), %rdi   # 0x1114df0
movq %r14, %rsi
callq 0x13c85
leaq 0xa3955(%rip), %rsi     # 0x111db8
movq %r15, %rdi
movq %rax, %rdx
callq 0x14766
leaq 0x10a7cc3(%rip), %rdi   # 0x1116138
movq %r14, %rsi
callq 0x13c85
shlq $0x30, %r12
orq -0x30(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x14766
leaq 0x10a6ade(%rip), %rdi   # 0x1114f78
movq %r14, %rsi
callq 0x13c85
leaq 0xa324f(%rip), %rsi     # 0x1116f8
movq 0x10(%rbp), %rdi
movq %rax, %rdx
callq 0x14766
movq -0x38(%rbp), %rax
movq 0x18(%rbp), %rcx
movq %rax, (%rcx)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_mirth_PropLabel_FieldQName
static struct mirth_mirth_PropLabel mtw_mirth_mirth_PropLabel_FieldQName (uint64_t in_Field_1) {
	struct mirth_mirth_PropLabel_FieldQName* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mField = in_Field_1;
	struct mirth_mirth_PropLabel v4 = { .tag=mirth_mirth_PropLabel_FieldQName, .ptr.FieldQName=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 0x6e500
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x79275(%rip), %rsi     # 0xe777c
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_mirth_PropLabel_FieldIndexType
static struct mirth_mirth_PropLabel mtw_mirth_mirth_PropLabel_FieldIndexType (uint64_t in_Field_1) {
	struct mirth_mirth_PropLabel_FieldIndexType* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mField = in_Field_1;
	struct mirth_mirth_PropLabel v4 = { .tag=mirth_mirth_PropLabel_FieldIndexType, .ptr.FieldIndexType=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 0x6e553
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x79254(%rip), %rsi     # 0xe77ae
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_mirth_PropLabel_FieldValueType
static struct mirth_mirth_PropLabel mtw_mirth_mirth_PropLabel_FieldValueType (uint64_t in_Field_1) {
	struct mirth_mirth_PropLabel_FieldValueType* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mField = in_Field_1;
	struct mirth_mirth_PropLabel v4 = { .tag=mirth_mirth_PropLabel_FieldValueType, .ptr.FieldValueType=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 0x6e5a6
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x79233(%rip), %rsi     # 0xe77e0
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130