LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2
popq %rdi
callq 0xd928
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
movq %rax, %rdx
andq %rcx, %rdx
movw $0x2, 0x6(%rdx)
movq %r12, 0x18(%rdx)
leaq 0xa812d(%rip), %rsi     # 0x109160
movq %rsi, 0x20(%rdx)
movq %r13, 0x8(%rdx)
leaq 0xa8046(%rip), %rsi     # 0x109088
movq %rsi, 0x10(%rdx)
movq 0x48(%r14), %rdi
andq %rdi, %rcx
sete %dl
testb $0x3, %dil
setne %sil
orb %dl, %sil
jne 0x6105f
incl (%rcx)
leaq 0xa7333(%rip), %rdx     # 0x108399
leaq 0x57d0(%rip), %rcx      # 0x6683d
movq %rax, %rsi
callq 0x24c61
pushq $0x9
popq %rdi
pushq $0x1
popq %rdx
movq %r15, %rsi
movq %rax, %rcx
callq 0x1d29f
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_O2/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 0xd3d6
movq %rax, %r14
callq 0xd429
movq %rax, %rbx
movq %r14, %rdi
callq 0x3a8aa
pushq $0x6
popq %rdi
movq %rax, %rsi
callq 0x57b81
pushq $0x2
popq %r14
pushq $0x5
popq %rdx
movl %r14d, %edi
xorl %esi, %esi
movq %rax, %rcx
callq 0x1e896
movq %rax, %r15
movl %r14d, %edi
callq 0xd928
movq %rax, %r14
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r14, %rax
movw $0x2, 0x6(%rax)
leaq 0xa7a78(%rip), %rcx     # 0x108b79
movq %r15, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0xa7169(%rip), %rcx     # 0x108279
andq $0x0, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0xa77d0(%rip), %rsi     # 0x1088f0
movq %rbx, %rdi
callq 0x883c
leaq 0xa726a(%rip), %rsi     # 0x108399
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd08e
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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
pushq $0x2
popq %rdi
callq 0xd928
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
movq %rax, %rdx
andq %rcx, %rdx
movw $0x2, 0x6(%rdx)
movq %r12, 0x18(%rdx)
leaq 0xa7fd6(%rip), %rsi     # 0x109160
movq %rsi, 0x20(%rdx)
shlq $0x30, %rbx
orq %r13, %rbx
leaq 0xa70dd(%rip), %rsi     # 0x108279
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 0x611bd
incl (%rcx)
leaq 0xa71d5(%rip), %rdx     # 0x108399
leaq 0x57a9(%rip), %rcx      # 0x66974
movq %rax, %rsi
callq 0x24c61
pushq $0xb
popq %rdi
pushq $0x1
popq %rdx
movq %r15, %rsi
movq %rax, %rcx
callq 0x1d29f
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_O2/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 $0x28, %rsp
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
callq 0xd3d6
movq %rax, %r15
callq 0xd429
leaq -0x50(%rbp), %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x66d79
movq (%rbx), %rdi
leaq -0x48(%rbp), %r12
movl %eax, %esi
movq %r12, %rcx
callq 0x66dc9
movl %eax, %ebx
movq %rdx, -0x30(%rbp)
movq (%r12), %rdi
leaq -0x40(%rbp), %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x66d79
movq %rdx, %r8
movq (%r12), %rdi
pushq $0x2
popq %rsi
leaq -0x38(%rbp), %r9
xorl %edx, %edx
movl %eax, %ecx
callq 0x57ef2
movl %eax, %r12d
movq %rdx, %r13
movq %rdx, %rax
andq %r14, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0x618ac
incl (%rax)
movq %r15, %rdi
callq 0x3a8aa
pushq $0x6
popq %rdx
movl %r12d, %edi
movq %r13, %rsi
movq %rax, %rcx
callq 0x1e310
movq %rdx, %rcx
pushq $0x5
popq %rdx
movl %r12d, %edi
movq %r13, %rsi
callq 0x1e896
movq %rax, %r15
pushq $0x2
popq %rdi
callq 0xd928
movq %rax, %r12
andq %rax, %r14
movw $0x2, 0x6(%r14)
leaq 0xa7284(%rip), %rax     # 0x108b79
movq %r15, 0x18(%r14)
movq %rax, 0x20(%r14)
shlq $0x30, %rbx
orq -0x30(%rbp), %rbx
leaq 0xa696d(%rip), %rax     # 0x108279
movq %rbx, 0x8(%r14)
movq %rax, 0x10(%r14)
movq -0x38(%rbp), %rdi
leaq 0xa6fd1(%rip), %rsi     # 0x1088f0
callq 0x883c
leaq 0xa6a6e(%rip), %rsi     # 0x108399
movq %r12, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd08e
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0xd3d6
movq %rax, %r14
callq 0xd429
movq %rax, %rbx
movq %r14, %rdi
callq 0x3a8aa
pushq $0x6
popq %rdi
movq %rax, %rsi
callq 0x57b81
movq %rax, %r14
callq 0x1ea5d
pushq $0x2
popq %r15
movl %r15d, %edi
movq %rdx, %rsi
callq 0x57b81
pushq $0x5
popq %rdi
movq %r14, %rsi
movl %edi, %edx
movq %rax, %rcx
callq 0x1e896
movq %rax, %r14
movl %r15d, %edi
callq 0xd928
movq %rax, %r15
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r15, %rax
movw $0x2, 0x6(%rax)
leaq 0xa5f41(%rip), %rcx     # 0x108b79
movq %r14, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0xa5632(%rip), %rcx     # 0x108279
andq $0x0, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0xa5c99(%rip), %rsi     # 0x1088f0
movq %rbx, %rdi
callq 0x883c
leaq 0xa5733(%rip), %rsi     # 0x108399
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd08e
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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 0xd3d6
movq %rax, %r14
callq 0xd429
movq %rax, %rbx
movq %r14, %rdi
callq 0x3a8aa
movq %rax, %rcx
andq %r12, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x632af
incl (%rcx)
pushq $0x6
popq %rdi
movq %rax, %rsi
movl %edi, %edx
movq %rax, %rcx
callq 0x57b99
movq %rax, %r14
callq 0x57cd2
pushq $0x2
popq %r15
movl %r15d, %edi
movq %rax, %rsi
callq 0x57b81
pushq $0x5
popq %rdi
movq %r14, %rsi
movl %edi, %edx
movq %rax, %rcx
callq 0x1e896
movq %rax, %r14
movl %r15d, %edi
callq 0xd928
movq %rax, %r15
andq %rax, %r12
movw $0x2, 0x6(%r12)
leaq 0xa5873(%rip), %rax     # 0x108b79
movq %r14, 0x18(%r12)
movq %rax, 0x20(%r12)
leaq 0xa4f62(%rip), %rax     # 0x108279
andq $0x0, 0x8(%r12)
movq %rax, 0x10(%r12)
leaq 0xa55c7(%rip), %rsi     # 0x1088f0
movq %rbx, %rdi
callq 0x883c
leaq 0xa5061(%rip), %rsi     # 0x108399
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd08e
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
callq 0xd3d6
movq %rax, %r14
callq 0xd429
movq %rax, %rbx
callq 0x1ea5d
pushq $0x2
popq %r15
movl %r15d, %edi
movq %rdx, %rsi
callq 0x57b81
movq %rax, %r12
movq %r14, %rdi
callq 0x3a8aa
pushq $0x6
popq %rdi
movq %rax, %rsi
callq 0x57b81
pushq $0x5
popq %rdi
movq %r12, %rsi
movl %edi, %edx
movq %rax, %rcx
callq 0x1e896
movq %rax, %r14
movl %r15d, %edi
callq 0xd928
movq %rax, %r15
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r15, %rax
movw $0x2, 0x6(%rax)
leaq 0xa501b(%rip), %rcx     # 0x108b79
movq %r14, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0xa470c(%rip), %rcx     # 0x108279
andq $0x0, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0xa4d73(%rip), %rsi     # 0x1088f0
movq %rbx, %rdi
callq 0x883c
leaq 0xa480d(%rip), %rsi     # 0x108399
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd08e
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mb_mirth_mirth_PropLabel_prop_1_sp33_0
static void mb_mirth_mirth_PropLabel_prop_1_sp33_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 = mw_mirth_type_Type_U64();
	struct mirth_type_StackType v12 = mw_mirth_type_Tzm(v10, v11);
	struct mirth_type_Type v13 = mtw_mirth_type_Type_Table(v0);
	struct mirth_type_StackType v14 = mw_mirth_type_Tzm(v10, v13);
	struct mirth_type_ArrowType* v15 = mw_mirth_type_Tzezg(v12, v14);
	PTUP r16 = PTRMK(0,tup_new(2),0);
	((TUP*)PTRPTR(r16))->size = 2;
	((TUP*)PTRPTR(r16))->cells[1] = MK_mirth_type_ArrowType(v15);
	((TUP*)PTRPTR(r16))->cells[0] = MK_std_list_List_1(v5);
	push_resource(MK_mirth_mirth_zaMirth(v9));
	push_value(MKTUP(r16));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
callq 0xd3d6
movq %rax, %r15
callq 0xd429
leaq -0x58(%rbp), %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x66d79
movq (%rbx), %rdi
leaq -0x50(%rbp), %r14
movl %eax, %esi
movq %r14, %rcx
callq 0x66dc9
movl %eax, %ebx
movq %rdx, -0x38(%rbp)
movq (%r14), %rdi
leaq -0x48(%rbp), %r14
movq %r15, -0x30(%rbp)
movq %r15, %rsi
movq %r14, %rdx
callq 0x66d79
movq %rdx, %r8
movq (%r14), %rdi
pushq $0x2
popq %rsi
leaq -0x40(%rbp), %r9
xorl %edx, %edx
movl %eax, %ecx
callq 0x57ef2
movl %eax, %r15d
movq %rdx, %r13
movq %rdx, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0x641fa
incl (%rax)
callq 0x1ea5d
movq %rdx, %rcx
pushq $0x2
popq %rdx
movl %r15d, %edi
movq %r13, %rsi
callq 0x1e310
movq %rdx, %r14
movq -0x30(%rbp), %rdi
callq 0x3a8aa
pushq $0x6
popq %rdx
movl %r15d, %edi
movq %r13, %rsi
movq %rax, %rcx
callq 0x1e310
movq %rdx, %rcx
pushq $0x5
popq %rdi
movq %r14, %rsi
movl %edi, %edx
callq 0x1e896
movq %rax, %r14
pushq $0x2
popq %rdi
callq 0xd928
movq %rax, %r15
andq %rax, %r12
movw $0x2, 0x6(%r12)
leaq 0xa491c(%rip), %rax     # 0x108b79
movq %r14, 0x18(%r12)
movq %rax, 0x20(%r12)
shlq $0x30, %rbx
orq -0x38(%rbp), %rbx
leaq 0xa4003(%rip), %rax     # 0x108279
movq %rbx, 0x8(%r12)
movq %rax, 0x10(%r12)
movq -0x40(%rbp), %rdi
leaq 0xa4665(%rip), %rsi     # 0x1088f0
callq 0x883c
leaq 0xa4102(%rip), %rsi     # 0x108399
movq %r15, %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd08e
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 0x64a88
incl (%rax)
leaq 0xa45f9(%rip), %rdx     # 0x109088
leaq 0x2c95(%rip), %rcx      # 0x6772b
callq 0x24c61
pushq $0xa
popq %rdi
pushq $0x1
popq %rdx
movq %r15, %rsi
movq %rax, %rcx
callq 0x1d29f
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_Data_singlezetagzy
static struct std_maybe_Maybe_1 mw_mirth_data_Data_singlezetagzy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Data_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct std_list_List_1 v6 = mw_mirth_data_Data_tags(in_zaMirth_1, in_Data_2, &v5);
	struct std_maybe_Maybe_1 v7 = mw_std_list_List_1_singlezy(v6);
	*out_zaMirth_3 = v5;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x18(%rbp), %r14
movq %r14, %rdx
callq 0x4ce67
movl %eax, %edi
movq %rdx, %rsi
callq 0xea6b
movq (%r14), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_table_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 0x667ed
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 0x667b2
decl (%rax)
jne 0x667b2
leaq 0xa1ad7(%rip), %rsi     # 0x108279
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
callq 0xce94
movq 0x20(%rbx), %rax
andq %rax, %r14
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x667e1
decl (%r14)
jne 0x667e1
leaq 0xa2318(%rip), %rsi     # 0x108ae9
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
callq 0xce94
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
callq 0xd3d6
movq %rax, %r15
movq %rax, %rdi
movq %rdx, %rsi
callq 0x8a95
callq 0xd429
movq %rax, -0x38(%rbp)
movq %r15, %rax
andq %r14, %rax
movq 0x8(%rax), %r12
movq 0x10(%rax), %r13
movq 0x18(%rax), %rbx
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq %r15, %rdi
callq 0x8ae0
testb $0x1, %r13b
je 0x668b2
movq %r12, %rax
andq %r14, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x668b2
incl (%rax)
movq %r12, %rdi
callq 0x2a5d7
pushq $0x1
popq %rdi
movq %rax, %rsi
callq 0x17351
movq %rax, %r15
testb $0x1, %r13b
je 0x668f1
movq %r12, %rax
andq %r14, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x668f1
decl (%rax)
jne 0x668f1
movq %r12, %rdi
movq %r13, %rsi
callq 0xce94
testb $0x1, -0x30(%rbp)
je 0x6690a
andq %rbx, %r14
sete %al
testb $0x3, %bl
setne %cl
orb %al, %cl
jne 0x6690a
incl (%r14)
leaq -0x48(%rbp), %r12
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2fadc
movq %rax, %r14
movq (%r12), %rdi
leaq -0x40(%rbp), %r12
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1a0e2
pushq $0x3
popq %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x1473b
movq %rax, %rbx
movq (%r12), %rdi
leaq 0xa1f9e(%rip), %rsi     # 0x1088f0
callq 0x883c
leaq 0xa1de3(%rip), %rsi     # 0x108741
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd08e
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x66d5a
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x74b8e(%rip), %rsi     # 0xdb8ef
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_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 0x66e03
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 0x66e55
leaq -0x38(%rbp), %r13
movq %rdx, %rdi
movq %r13, %rsi
callq 0x57fe9
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 0x66deb
movl -0x38(%rbp), %edi
decl (%rcx)
jne 0x66deb
shlq $0x30, %rdi
orq %rax, %rdi
leaq 0xa1c9b(%rip), %rsi     # 0x108ae9
callq 0xce94
jmp 0x66deb
leaq 0x6d9b1(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 0x10a6093(%rip), %rdi   # 0x110d128
callq 0x12f88
movq %rax, %r15
movq %rax, %rdi
callq 0x142de
testb %al, %al
je 0x670c7
movq %r15, %rdi
callq 0x1307d
movq %rax, %r12
movabsq $0xfffffffffffc, %rdx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdx
shrq $0x30, %r12
jmp 0x670dd
leaq 0xa11ab(%rip), %rsi     # 0x108279
xorl %r12d, %r12d
xorl %edi, %edi
movq %r15, %rdx
callq 0x1393b
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_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x20(%rbp), %r14
movq %r14, %rdx
callq 0x1a10b
movq (%r14), %rdi
leaq -0x18(%rbp), %r14
movq %rax, %rsi
movq %r14, %rdx
callq 0x60db5
movq (%r14), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_table_Field_default
static struct std_maybe_Maybe_1 mw_mirth_table_Field_default (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Field_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_table_Field_default, in_Field_2);
	VAL v6 = mut_get(v5);
	*out_zaMirth_3 = in_zaMirth_1;
	return V_std_maybe_Maybe_1(v6);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10a5ffd(%rip), %rdi   # 0x110d138
callq 0x12f88
movq %rax, %rdi
callq 0x1307d
movq %r14, (%rbx)
movabsq $0xfffffffffffc, %rdx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdx
shrq $0x30, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_table_Table_alloczeword
static uint64_t mw_mirth_table_Table_alloczeword (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_ztalloczeword, in_Table_2);
	VAL v6 = mut_get(v5);
	*out_zaMirth_3 = in_zaMirth_1;
	return V_mirth_word_Word(v6);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10a5ed3(%rip), %rdi   # 0x110d048
callq 0x12f88
movq %rax, %rdi
callq 0x1307d
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_arrow_Op_TableToIndex
static struct mirth_arrow_Op mtw_mirth_arrow_Op_TableToIndex (uint64_t in_Table_1) {
	struct mirth_arrow_Op_TableToIndex* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mTable = in_Table_1;
	struct mirth_arrow_Op v4 = { .tag=mirth_arrow_Op_TableToIndex, .ptr.TableToIndex=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x67378
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x745a2(%rip), %rsi     # 0xdb921
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_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 0x3f60a
movl %eax, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movq (%rbx), %rdi
leaq -0x98(%rbp), %r14
movq %r14, %rsi
callq 0x3f5b0
movq %rax, %rbx
movq (%r14), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3fa30
movl %eax, %r14d
movq %rdx, %r15
leaq -0x90(%rbp), %r13
leaq -0x68(%rbp), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x36e55
movq 0x8(%r13), %rcx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rcx, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x67699
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 0x3f209
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 0x3faad
movq (%rbx), %rdi
movq (%r14), %rsi
leaq -0x70(%rbp), %rbx
movq %rbx, %rdx
callq 0x5114e
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_O2/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 0x67e72
movq %rsi, %rdi
popq %rbp
jmp 0xd491
testl %edi, %edi
jne 0x67ebd
movq 0x10a52d3(%rip), %rdi   # 0x110d150
testq %rdi, %rdi
jne 0x67e9b
leaq 0x73aca(%rip), %rdi     # 0xdb953
pushq $0x1b
popq %rsi
callq 0x8a21
movq %rax, %rdi
movq %rax, 0x10a52b5(%rip)   # 0x110d150
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x67eb8
incl (%rax)
callq 0x8cc6
leaq 0x6c949(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 0x10a4c14(%rip), %r14   # 0x110d168
incq %r14
movq %r14, 0x10a4c0a(%rip)   # 0x110d168
leaq 0x10a4bf3(%rip), %rdi   # 0x110d158
movq %r14, %rsi
callq 0x12f88
shlq $0x30, %r13
orq %rbx, %r13
leaq 0x9fd46(%rip), %rbx     # 0x1082c1
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1393b
leaq 0x10a3860(%rip), %rdi   # 0x110bdf0
movq %r14, %rsi
callq 0x12f88
leaq 0xa0819(%rip), %rsi     # 0x108db8
movq %r15, %rdi
movq %rax, %rdx
callq 0x1393b
leaq 0x10a4b87(%rip), %rdi   # 0x110d138
movq %r14, %rsi
callq 0x12f88
shlq $0x30, %r12
orq -0x30(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1393b
leaq 0x10a39a2(%rip), %rdi   # 0x110bf78
movq %r14, %rsi
callq 0x12f88
leaq 0xa0113(%rip), %rsi     # 0x1086f8
movq 0x10(%rbp), %rdi
movq %rax, %rdx
callq 0x1393b
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_O2/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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x68638
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x73330(%rip), %rsi     # 0xdb96f
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x68681
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x73319(%rip), %rsi     # 0xdb9a1
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x686ca
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x73302(%rip), %rsi     # 0xdb9d3
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mb_mirth_mirth_PropLabel_prop_1_sp25_0
static void mb_mirth_mirth_PropLabel_prop_1_sp25_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);
	struct mirth_mirth_zaMirth* v4;
	struct mirth_table_StateOwner v5 = mw_mirth_table_Field_owner(r1, V_mirth_table_Field(v2), &v4);
	struct mirth_mirth_zaMirth* v6;
	struct std_list_List_1 v7 = mw_mirth_table_StateOwner_ctx(v4, v5, &v6);
	struct mirth_mirth_zaMirth* v8;
	struct mirth_type_Type v9 = mw_mirth_elab_elabzesimplezetypezeatomzx(v6, v7, V_mirth_token_Token(v3), &v8);
	push_resource(MK_mirth_mirth_zaMirth(v8));
	push_value(MK_mirth_type_Type(v9));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
callq 0xd3d6
movq %rax, %r14
movq %rax, %rdi
movq %rdx, %rsi
callq 0x8a95
callq 0xd429
movq %rax, %r15
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r14, %rax
movq 0x8(%rax), %r12
movq 0x18(%rax), %rbx
movq %r14, %rdi
callq 0x8ae0
leaq -0x38(%rbp), %r14
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x57ea2
movq (%r14), %rdi
leaq -0x30(%rbp), %r14
movl %eax, %esi
movq %r14, %rcx
callq 0x66dc9
movq (%r14), %rdi
leaq -0x28(%rbp), %r14
movl %eax, %esi
movq %rbx, %rcx
movq %r14, %r8
callq 0x5b9de
movl %eax, %ebx
movq %rdx, %r15
movq (%r14), %rdi
leaq 0xa017a(%rip), %rsi     # 0x1088f0
callq 0x883c
shlq $0x30, %rbx
orq %r15, %rbx
leaq 0xa0360(%rip), %rsi     # 0x108ae9
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd08e
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_mirth_PropLabel_FieldOwner
static struct mirth_mirth_PropLabel mtw_mirth_mirth_PropLabel_FieldOwner (uint64_t in_Field_1) {
	struct mirth_mirth_PropLabel_FieldOwner* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mField = in_Field_1;
	struct mirth_mirth_PropLabel v4 = { .tag=mirth_mirth_PropLabel_FieldOwner, .ptr.FieldOwner=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x687c7
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x73237(%rip), %rsi     # 0xdba05
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mb_mirth_mirth_PropLabel_prop_1_sp24_0
static void mb_mirth_mirth_PropLabel_prop_1_sp24_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);
	push_resource(MK_mirth_mirth_zaMirth(v2));
	push_value(MK_mirth_table_StateOwner(v3));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0xd3d6
movq %rax, %rbx
callq 0xd429
leaq -0x20(%rbp), %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x66d79
movl %eax, %ebx
movq %rdx, %r15
movq (%r14), %rdi
leaq 0xa00d2(%rip), %rsi     # 0x1088f0
callq 0x883c
shlq $0x30, %rbx
orq %r15, %rbx
leaq 0xa1278(%rip), %rsi     # 0x109aa9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd08e
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_mirth_PropLabel_prop2_1_sp7
static struct mirth_mirth_Prop_1* mw_mirth_mirth_PropLabel_prop2_1_sp7 (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Field_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_Field(in_Field_2);
	struct mirth_mirth_LexicalState* v8 = in_zaMirth_1->mlexicalzestate;
	incref(MK_mirth_mirth_LexicalState(v8));
	FNPTR v9 = &mb_mirth_mirth_PropLabel_prop_1_sp20_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
pushq $0x2
popq %rdi
callq 0xd928
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
movq %rax, %rdx
andq %rcx, %rdx
movw $0x2, 0x6(%rdx)
movq %r12, 0x18(%rdx)
leaq 0xa01f1(%rip), %rsi     # 0x109160
movq %rsi, 0x20(%rdx)
movq %r13, 0x8(%rdx)
leaq 0xa02ba(%rip), %rsi     # 0x109238
movq %rsi, 0x10(%rdx)
movq 0x48(%r14), %rdi
andq %rdi, %rcx
sete %dl
testb $0x3, %dil
setne %sil
orb %dl, %sil
jne 0x68f9b
incl (%rcx)
leaq 0x9f3f7(%rip), %rdx     # 0x108399
leaq 0xf47(%rip), %rcx       # 0x69ef0
movq %rax, %rsi
callq 0x24c61
pushq $0x9
popq %rdi
pushq $0x1
popq %rdx
movq %r15, %rsi
movq %rax, %rcx
callq 0x1d29f
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_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mb_mirth_mirth_PropLabel_prop_1_sp20_0
static void mb_mirth_mirth_PropLabel_prop_1_sp20_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_mirth_zaMirth* v4;
	struct mirth_name_Namespace v5 = mw_mirth_table_Field_namespace(r1, V_mirth_table_Field(v2), &v4);
	decref(v2);
	incref(v3);
	struct mirth_mirth_zaMirth* v6;
	INT v7 = mw_mirth_word_Word_arity(v4, 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 $0x38, %rsp
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
callq 0xd3d6
movq %rax, %r15
movq %rax, %rdi
movq %rdx, %rsi
callq 0x8a95
callq 0xd429
movq %rax, %r14
movq %r15, %rax
andq %r12, %rax
movq 0x8(%rax), %r13
movq 0x10(%rax), %rbx
movq 0x18(%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0x50(%rbp)
movq %r15, %rdi
callq 0x8ae0
movq %rbx, -0x38(%rbp)
testb $0x1, %bl
je 0x69f6b
movq %r13, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0x69f6b
incl (%rax)
leaq -0x40(%rbp), %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2b914
movl 0x8(%rax), %ecx
movl %ecx, -0x2c(%rbp)
movq 0x10(%rax), %r15
movq %r15, %rcx
andq %r12, %rcx
sete %dl
testb $0x3, %r15b
setne %sil
orb %dl, %sil
jne 0x69f9c
incl (%rcx)
leaq 0x9e79e(%rip), %rsi     # 0x108741
movq %rax, %rcx
andq %r12, %rcx
sete %dl
testb $0x3, %al
setne %dil
orb %dl, %dil
movq -0x48(%rbp), %rbx
jne 0x69fc7
decl (%rcx)
jne 0x69fc7
movq %rax, %rdi
callq 0xce94
movq -0x40(%rbp), %r14
testb $0x1, -0x38(%rbp)
je 0x69ff5
movq %r13, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0x69ff5
decl (%rax)
jne 0x69ff5
movq %r13, %rdi
movq -0x38(%rbp), %rsi
callq 0xce94
testb $0x1, -0x50(%rbp)
je 0x6a00f
andq %rbx, %r12
sete %al
testb $0x3, %bl
setne %cl
orb %al, %cl
jne 0x6a00f
incl (%r12)
leaq -0x40(%rbp), %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2fadc
movq %rax, %r14
movq (%r12), %rdi
leaq -0x58(%rbp), %r12
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1a0e2
movl -0x2c(%rbp), %edi
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x1473b
movq %rax, %rbx
movq (%r12), %rdi
leaq 0x9e89a(%rip), %rsi     # 0x1088f0
callq 0x883c
movq %rbx, %rdi
leaq 0x9e6dc(%rip), %rsi     # 0x108741
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd08e
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_mirth_PropLabel_prop_1_sp16
static struct mirth_mirth_Prop_1* mw_mirth_mirth_PropLabel_prop_1_sp16 (uint64_t in_Token_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_sp16_0;
	struct mirth_mirth_PropState_1 v8 = mtw_mirth_mirth_PropState_1_Delay(v6, MK_mirth_token_Token(in_Token_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 %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %r12d
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 0x6a8cc
incl (%rax)
leaq 0x9e4e5(%rip), %rdx     # 0x108db8
leaq 0x251(%rip), %rcx       # 0x6ab2b
callq 0x24c61
pushq $0x1
popq %rdx
movl %r12d, %edi
movq %r15, %rsi
movq %rax, %rcx
callq 0x1d29f
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq