LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_data_SyntaxDataTag_free
static void mirth_data_SyntaxDataTag_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_data_SyntaxDataTag);
	struct mirth_data_SyntaxDataTag* self = vself.data.ptr;
	decref(MK_std_maybe_Maybe_1(self->mdoc));
	decref(MK_std_maybe_Maybe_1(self->mvaluezy));
	decref(MK_std_maybe_Maybe_1(self->msigzy));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xa1625(%rip), %rax     # 0x116af1
cmpq %rsi, %rax
jne 0x75582
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x10(%rdi), %rcx
leaq 0x9fdd4(%rip), %r14     # 0x1152c1
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x75517
decl (%rax)
jne 0x75517
movl 0x8(%rbx), %edi
shlq $0x30, %rdi
orq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xd4e3
movq 0x28(%rbx), %rcx
movq %rcx, %rax
andq %r15, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x75545
decl (%rax)
jne 0x75545
movl 0x20(%rbx), %edi
shlq $0x30, %rdi
orq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0xd4e3
movq 0x40(%rbx), %rax
andq %rax, %r15
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x75570
decl (%r15)
jne 0x75570
movl 0x38(%rbx), %edi
shlq $0x30, %rdi
orq 0x40(%rbx), %rdi
movq %r14, %rsi
callq 0xd4e3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5030
leaq 0x765ad(%rip), %rsi     # 0xebb36
movl $0x57, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_Tag_outputszeresourcezy
static bool mw_mirth_data_Tag_outputszeresourcezy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Tag_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	uint64_t v6 = mw_mirth_data_Tag_data(in_zaMirth_1, in_Tag_2, &v5);
	struct mirth_mirth_zaMirth* v7;
	bool v8 = mw_mirth_data_Data_iszeresourcezy(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 0x10a3362(%rip), %rdi   # 0x1118be0
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
leaq -0x20(%rbp), %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x20d1b
movq (%r15), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_token_Token_sigzestackzetokens
static struct std_list_List_1 mw_mirth_token_Token_sigzestackzetokens (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct std_list_List_1 v5 = { .tag=std_list_List_1_Nil };
	struct std_list_List_1 v6;
	mw_std_list_List_1_buildzx(v5, &v6);
	struct mirth_mirth_zaMirth* v7;
	bool v8 = mw_mirth_token_Token_sigzestackzeendzy(in_zaMirth_1, in_Token_2, &v7);
	bool v9 = !v8;
	uint64_t v10 = in_Token_2;
	struct mirth_mirth_zaMirth* r11 = v7;
	struct std_list_List_1 r12 = v6;
	bool v13 = v9;
	while (v13) {
		uint64_t v14 = v10;
		struct mirth_mirth_zaMirth* r15 = r11;
		struct std_list_List_1 r16 = r12;
		struct mirth_mirth_zaMirth* v17;
		uint64_t v18 = mw_mirth_token_Token_next(r15, v14, &v17);
		struct std_list_List_1 v19;
		mw_std_list_zaLister_1_pushzx(MK_mirth_token_Token(v14), r16, &v19);
		struct mirth_mirth_zaMirth* v20;
		bool v21 = mw_mirth_token_Token_sigzestackzeendzy(v17, v18, &v20);
		bool v22 = !v21;
		v13 = v22;
		r12 = v19;
		r11 = v20;
		v10 = v18;
	}
	struct std_list_List_1 v23 = mw_std_list_zaLister_1_donezx(r12);
	*out_zaMirth_3 = r11;
	return v23;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r13
movq %rdi, %rbx
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xd37c
movl %eax, %r14d
movq %rdx, %r15
leaq -0x58(%rbp), %r12
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x3f57b
movq (%r12), %rbx
testb %al, %al
jne 0x75942
movq %rbx, %rdi
movq %r13, %rsi
leaq -0x40(%rbp), %rdx
callq 0x28928
movq %rax, %r12
movq %r13, %rdi
leaq 0xa04a6(%rip), %rsi     # 0x115db8
movl %r14d, %edx
movq %r15, %rcx
leaq -0x50(%rbp), %r8
callq 0x9741
movq -0x40(%rbp), %rdi
movq %r12, %rsi
leaq -0x38(%rbp), %rdx
callq 0x3f57b
movl -0x50(%rbp), %r14d
movq -0x48(%rbp), %r15
movq -0x38(%rbp), %rbx
movq %r12, %r13
jmp 0x758f2
xorl %edi, %edi
xorl %esi, %esi
movl %r14d, %edx
movq %r15, %rcx
callq 0xd37c
movq -0x30(%rbp), %rcx
movq %rbx, (%rcx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mb_mirth_mirth_PropLabel_prop_1_sp5_0
static void mb_mirth_mirth_PropLabel_prop_1_sp5_0 (void) {
	uint64_t v0 = V_mirth_data_Tag(pop_value());
	struct mirth_mirth_zaMirth* r1 = V_mirth_mirth_zaMirth(pop_resource());
	struct mirth_mirth_zaMirth* v2;
	struct mirth_type_ArrowType* v3;
	struct std_list_List_1 v4 = mw_mirth_data_Tag_ctxzetype(r1, v0, &v2, &v3);
	struct mirth_type_ArrowType* v5 = mw_mirth_type_ArrowType_invert(v3);
	PTUP r6 = PTRMK(0,tup_new(2),0);
	((TUP*)PTRPTR(r6))->size = 2;
	((TUP*)PTRPTR(r6))->cells[1] = MK_mirth_type_ArrowType(v5);
	((TUP*)PTRPTR(r6))->cells[0] = MK_std_list_List_1(v4);
	push_resource(MK_mirth_mirth_zaMirth(v2));
	push_value(MKTUP(r6));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0xda3f
movq %rax, %r14
callq 0xda98
leaq -0x38(%rbp), %rbx
leaq -0x30(%rbp), %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x5135a
movl %eax, %r14d
movq %rdx, %r12
movq (%r15), %rdi
callq 0x77e7a
movq %rax, %r15
movl $0x2, %edi
callq 0xe4ba
movq %rax, %r13
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r13, %rax
movw $0x2, 0x6(%rax)
leaq 0x9fc41(%rip), %rcx     # 0x115b79
movq %r15, 0x18(%rax)
movq %rcx, 0x20(%rax)
shlq $0x30, %r14
orq %r12, %r14
leaq 0x9f32b(%rip), %rcx     # 0x115279
movq %r14, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq (%rbx), %rdi
leaq 0x9f990(%rip), %rsi     # 0x1158f0
callq 0x9116
leaq 0x9f42d(%rip), %rsi     # 0x115399
movq %r13, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd6f1
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_Data_iszeunitzy
static bool mw_mirth_data_Data_iszeunitzy (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_maybe_Maybe_1 v6 = mw_mirth_data_Data_unitzy(in_zaMirth_1, in_Data_2, &v5);
	int64_t v7 = (v6).tag;
	decref(MK_std_maybe_Maybe_1(v6));
	INT v8 = WRAP_I63(0LL);
	INT v9 = v8;
	INT v10 = i64_to_int(v7);
	bool v11 = int_eq(v10, v9);
	bool v12 = !v11;
	*out_zaMirth_3 = v5;
	return v12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
leaq 0x10a3043(%rip), %rdi   # 0x111a2a0
callq 0x13ff0
movq %rax, %r14
movq %rax, %rdi
callq 0x153b0
testb %al, %al
movq %rbx, -0x38(%rbp)
je 0x7728f
movq %r14, %rdi
callq 0x140f0
movq %rax, %r12
movq %rax, %rbx
shrq $0x30, %rbx
andq %r13, %r12
jmp 0x77385
leaq -0x30(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x52d67
movl %eax, %edi
movq %rdx, %rsi
callq 0xf770
testl %eax, %eax
je 0x77334
cmpl $0x1, %eax
jne 0x773e1
movq %rdx, %rdi
callq 0xdaeb
movq %rax, %r12
movq %rdx, %r15
testb $0x1, %r15b
je 0x772e3
movq %r12, %rax
andq %r13, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x772e3
incl (%rax)
movq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rdx
movq %r12, %rsi
callq 0x77411
movl $0x1, %esi
movq %rax, %rdi
callq 0xec04
testl %eax, %eax
je 0x7733f
testb $0x1, %r15b
je 0x7732d
movq %r12, %rax
andq %r13, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x7732d
decl (%rax)
jne 0x7732d
movq %r12, %rdi
movq %r15, %rsi
callq 0xd4e3
xorl %ebx, %ebx
xorl %r12d, %r12d
jmp 0x77352
xorl %ebx, %ebx
movq -0x30(%rbp), %r15
xorl %r12d, %r12d
jmp 0x77356
movq %r12, %rdi
movq %r15, %rsi
callq 0x95f6
movq %rdx, %r12
movl $0x1, %ebx
movq -0x40(%rbp), %r15
movq %rbx, %rdi
shlq $0x30, %rdi
orq %r12, %rdi
leaq 0x9df5a(%rip), %rsi     # 0x1152c1
movq %r12, %rax
andq %r13, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x7737d
incl (%rax)
movq %r14, %rdx
callq 0x14ab5
movl %ebx, %ebx
andq %r12, %r13
sete %al
testb $0x3, %r12b
setne %cl
orb %al, %cl
jne 0x773b4
decl (%r13)
jne 0x773b4
movq %rbx, %rdi
shlq $0x30, %rdi
orq %r12, %rdi
leaq 0x9df12(%rip), %rsi     # 0x1152c1
callq 0xd4e3
leaq 0x1(,%rbx,2), %rdi
movl $0x1, %esi
callq 0xec04
testl %eax, %eax
setne %al
movq -0x38(%rbp), %rcx
movq %r15, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0x6d353(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0x6d358(%rip), %xmm0    # 0xe475d
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x95a5
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_Tag_labelzeinputs
static struct std_list_List_1 mw_mirth_data_Tag_labelzeinputs (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Tag_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_data_Tag_labelzeinputs, in_Tag_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 mirth_mirth_zaMirth* v10;
		struct std_list_List_1 v11 = mw_mirth_data_Tag_labelzeinputszefromzesig(in_zaMirth_1, in_Tag_2, &v10);
		incref(MK_std_list_List_1(v11));
		mut_set(MK_std_list_List_1(v11), v5);
		branch_List_8 = v11;
		branch_zaMirth_7 = v10;
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_List_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r12
movq %rdi, %r15
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
leaq 0x10a1b41(%rip), %rdi   # 0x11192c8
callq 0x13ff0
movq %rax, %r14
movq %rax, %rdi
callq 0x153b0
testb %al, %al
je 0x777b2
movq %r14, %rdi
callq 0x140f0
movq %rax, %r12
andq %rax, %rbx
shrq $0x30, %r12
movq %rbx, %r13
jmp 0x777f7
leaq -0x38(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x77813
movl %eax, %r12d
movq %rdx, %r13
movq %r12, %rdi
shlq $0x30, %rdi
orq %rdx, %rdi
leaq 0x9daa1(%rip), %rsi     # 0x115279
andq %rdx, %rbx
sete %al
testb $0x3, %r13b
setne %cl
orb %al, %cl
jne 0x777eb
incl (%rbx)
movq %r14, %rdx
callq 0x14ab5
movq -0x38(%rbp), %r15
movq -0x30(%rbp), %rax
movq %r15, (%rax)
movl %r12d, %eax
movq %r13, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_label_Label_zgStr
static STR* mw_mirth_label_Label_zgStr (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Label_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	uint64_t v6 = mw_mirth_label_Label_name(in_zaMirth_1, in_Label_2, &v5);
	struct mirth_mirth_zaMirth* v7;
	STR* v8 = mw_mirth_name_Name_zgStr(v5, v6, &v7);
	*out_zaMirth_3 = v7;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10a197a(%rip), %rdi   # 0x1119840
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
leaq 0x10a05ee(%rip), %rdi   # 0x11184c8
movq %rax, %rsi
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
movq %rax, %rdi
movq %rdx, %rsi
callq 0x942c
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mb_mirth_mirth_PropLabel_prop_1_sp12_0
static void mb_mirth_mirth_PropLabel_prop_1_sp12_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 std_list_List_1 v5 = mw_mirth_data_Tag_ctx(r1, V_mirth_data_Tag(v2), &v4);
	struct mirth_mirth_zaMirth* v6;
	struct std_maybe_Maybe_1 v7 = mw_mirth_data_Tag_projectzetagzefield(v4, V_mirth_label_Label(v3), V_mirth_data_Tag(v2), &v6);
	struct mirth_mirth_zaMirth* v8;
	VAL v9 = mw_std_maybe_Maybe_1_unwrap_1_sp53(v6, v7, &v8);
	struct mirth_mirth_zaMirth* v10;
	struct mirth_type_ArrowType* v11 = mw_mirth_data_datazegetzelabelzetype(v8, V_mirth_data_TagField(v9), &v10);
	PTUP r12 = PTRMK(0,tup_new(2),0);
	((TUP*)PTRPTR(r12))->size = 2;
	((TUP*)PTRPTR(r12))->cells[1] = MK_mirth_type_ArrowType(v11);
	((TUP*)PTRPTR(r12))->cells[0] = MK_std_list_List_1(v5);
	push_resource(MK_mirth_mirth_zaMirth(v10));
	push_value(MKTUP(r12));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
callq 0xda3f
movq %rax, %r14
movq %rax, %rdi
movq %rdx, %rsi
callq 0x9363
callq 0xda98
movq %rax, %rbx
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movq %r14, %rax
andq %r12, %rax
movq 0x8(%rax), %r15
movq 0x18(%rax), %rcx
movq %rcx, -0x30(%rbp)
movb 0x10(%rax), %r13b
movq %r14, %rdi
callq 0x93b4
testb $0x1, %r13b
je 0x77f6d
movq %r15, %rax
andq %r12, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x77f6d
incl (%rax)
leaq -0x58(%rbp), %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x7966b
movl %eax, %ebx
movq %rdx, -0x38(%rbp)
movq (%r13), %rdi
leaq -0x50(%rbp), %r13
movq -0x30(%rbp), %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x796dc
movq (%r13), %rdi
leaq -0x48(%rbp), %r15
movl %eax, %esi
movq %r15, %rcx
callq 0x797d4
movq (%r15), %rdi
leaq -0x40(%rbp), %r15
movq %rax, %rsi
movq %r15, %rdx
callq 0x5972e
movq %rax, %r14
movl $0x2, %edi
callq 0xe4ba
movq %rax, %r13
andq %rax, %r12
movw $0x2, 0x6(%r12)
leaq 0x9db97(%rip), %rax     # 0x115b79
movq %r14, 0x18(%r12)
movq %rax, 0x20(%r12)
shlq $0x30, %rbx
orq -0x38(%rbp), %rbx
leaq 0x9d27e(%rip), %rax     # 0x115279
movq %rbx, 0x8(%r12)
movq %rax, 0x10(%r12)
movq (%r15), %rdi
leaq 0x9d8e1(%rip), %rsi     # 0x1158f0
callq 0x9116
leaq 0x9d37e(%rip), %rsi     # 0x115399
movq %r13, %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd6f1
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_Tag_ctx
static struct std_list_List_1 mw_mirth_data_Tag_ctx (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Tag_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct mirth_type_ArrowType* v6;
	struct std_list_List_1 v7 = mw_mirth_data_Tag_ctxzetype(in_zaMirth_1, in_Tag_2, &v5, &v6);
	decref(MK_mirth_type_ArrowType(v6));
	*out_zaMirth_3 = v5;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %r12
movq %r12, %rcx
callq 0x5135a
movl %eax, %r14d
movq %rdx, %r15
movq (%r12), %rdi
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x796c2
decl (%rax)
jne 0x796c2
leaq 0x9c4bc(%rip), %rsi     # 0x115b79
callq 0xd4e3
movq -0x28(%rbp), %rax
movq %rax, (%rbx)
movl %r14d, %eax
movq %r15, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_Tag_projectzetagzefield
static struct std_maybe_Maybe_1 mw_mirth_data_Tag_projectzetagzefield (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Label_2, uint64_t in_Tag_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	struct mirth_mirth_zaMirth* v6;
	struct std_maybe_Maybe_1 v7 = mw_mirth_data_Tag_projectzeinputzelabel(in_zaMirth_1, in_Label_2, in_Tag_3, &v6);
	struct std_maybe_Maybe_1 branch_Maybe_8;
	switch ((v7).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v9 = mtp_std_maybe_Maybe_1_Some(v7);
			struct mirth_data_TagField* v10 = mtw_mirth_data_TagField_TagField(in_Tag_3, in_Label_2, V_std_either_Either_2(v9));
			struct std_maybe_Maybe_1 v11 = mtw_std_maybe_Maybe_1_Some(MK_mirth_data_TagField(v10));
			branch_Maybe_8 = v11;
		} break;
		case std_maybe_Maybe_1_None: {
			struct std_maybe_Maybe_1 v12 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_8 = v12;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_4 = v6;
	return branch_Maybe_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
leaq -0x30(%rbp), %rcx
callq 0x79896
movl %eax, %r14d
testl %eax, %eax
je 0x79764
cmpl $0x1, %r14d
jne 0x7977f
movq %rdx, %rdi
callq 0xdaeb
movq %rax, %r13
movl $0x1, %edi
movl $0x28, %esi
callq 0x50c0
testq %rax, %rax
je 0x797af
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %r13, %rcx
shrq $0x30, %r13
movl $0x1, (%rax)
movl %r13d, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %r12, 0x10(%rax)
movq %r15, 0x8(%rax)
leaq 0x9d07f(%rip), %rsi     # 0x1167d9
movq %rax, %rdi
callq 0x95f6
jmp 0x79766
xorl %edx, %edx
movq -0x30(%rbp), %rax
movq %rax, (%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0x6afb5(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0x6afba(%rip), %xmm0    # 0xe475d
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x95a5
leaq 0x725c6(%rip), %rsi     # 0xebd7c
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_maybe_Maybe_1_unwrap_1_sp53
static VAL mw_std_maybe_Maybe_1_unwrap_1_sp53 (struct mirth_mirth_zaMirth* in_zaMirth_1, struct std_maybe_Maybe_1 in_Maybe_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* branch_zaMirth_5;
	VAL branch_zux1_6;
	switch ((in_Maybe_2).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v7 = mtp_std_maybe_Maybe_1_Some(in_Maybe_2);
			branch_zux1_6 = v7;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case std_maybe_Maybe_1_None: {
			STR* v8;
			STRLIT(v8, "logic error: expected field in tag.", 35);
			mw_mirth_mirth_zaMirth_fatalzeerrorzx(in_zaMirth_1, v8);
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_3 = branch_zaMirth_5;
	return branch_zux1_6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, %esi
jne 0x797f6
movq %rcx, %r14
movq %rdx, %rdi
callq 0xdaeb
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
testl %esi, %esi
jne 0x79866
cmpq $0x0, 0x10a0ade(%rip)   # 0x111a2e0
jne 0x7983a
movl $0x23, %edi
callq 0xf9f7
movq $0x23, 0x10(%rax)
movups 0x72591(%rip), %xmm0    # 0xebdae
movups %xmm0, 0x18(%rax)
movups 0x72596(%rip), %xmm0    # 0xebdbe
movups %xmm0, 0x28(%rax)
movl $0x2e676174, 0x37(%rax) # imm = 0x2E676174
movq %rax, 0x10a0aa6(%rip)   # 0x111a2e0
movq 0x10a0a9f(%rip), %rsi   # 0x111a2e0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x7985e
incl (%rax)
movq %rbx, %rdi
callq 0x15000
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0x6aece(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0x6aed3(%rip), %xmm0    # 0xe475d
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x95a5
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_Tag_projectzeinputzelabel
static struct std_maybe_Maybe_1 mw_mirth_data_Tag_projectzeinputzelabel (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Label_2, uint64_t in_Tag_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	struct mirth_mirth_zaMirth* v6;
	struct mirth_type_ArrowType* v7 = mw_mirth_data_Tag_type(in_zaMirth_1, in_Tag_3, &v6);
	struct mirth_type_StackType v8 = v7->mdom;
	incref(MK_mirth_type_StackType(v8));
	decref(MK_mirth_type_ArrowType(v7));
	struct mirth_mirth_zaMirth* v9;
	struct std_maybe_Maybe_1 v10 = mw_mirth_type_StackType_labelzetopzy(v6, in_Label_2, v8, &v9);
	*out_zaMirth_4 = v9;
	return v10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
leaq -0x30(%rbp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x5117e
movq %rax, %rdi
movl 0x8(%rax), %r15d
movq 0x10(%rax), %r12
movq %r12, %rcx
andq %r13, %rcx
sete %dl
testb $0x3, %r12b
setne %sil
orb %dl, %sil
jne 0x798e9
incl (%rcx)
andq %r13, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x7990a
decl (%rax)
jne 0x7990a
leaq 0x9c274(%rip), %rsi     # 0x115b79
callq 0xd4e3
movq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %r13
movq %r14, %rsi
movl %r15d, %edx
movq %r12, %rcx
movq %r13, %r8
callq 0x79939
movq (%r13), %rcx
movq %rcx, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_maybe_Maybe_1_unwrap_1_sp52
static VAL mw_std_maybe_Maybe_1_unwrap_1_sp52 (struct mirth_mirth_zaMirth* in_zaMirth_1, VAL in_zux1_2, struct std_maybe_Maybe_1 in_Maybe_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, VAL *out_zux1_5) {
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	VAL branch_zux1_8;
	VAL branch_zux2_9;
	switch ((in_Maybe_3).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v10 = mtp_std_maybe_Maybe_1_Some(in_Maybe_3);
			branch_zux2_9 = v10;
			branch_zux1_8 = in_zux1_2;
			branch_zaMirth_7 = in_zaMirth_1;
		} break;
		case std_maybe_Maybe_1_None: {
			STR* v11;
			STRLIT(v11, "logic error: expected field in tag.", 35);
			mw_mirth_mirth_zaMirth_fatalzeerrorzx(in_zaMirth_1, v11);
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zux1_5 = branch_zux1_8;
	*out_zaMirth_4 = branch_zaMirth_7;
	return branch_zux2_9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, %ecx
jne 0x79c4b
movq %r9, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x10(%rbp), %r13
movq %r8, %rdi
callq 0xdaeb
movq %r12, (%r13)
movq %r15, 0x8(%r13)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ecx, %ecx
jne 0x79cbb
cmpq $0x0, 0x10a0691(%rip)   # 0x111a2e8
jne 0x79c8f
movl $0x23, %edi
callq 0xf9f7
movq $0x23, 0x10(%rax)
movups 0x7213c(%rip), %xmm0    # 0xebdae
movups %xmm0, 0x18(%rax)
movups 0x72141(%rip), %xmm0    # 0xebdbe
movups %xmm0, 0x28(%rax)
movl $0x2e676174, 0x37(%rax) # imm = 0x2E676174
movq %rax, 0x10a0659(%rip)   # 0x111a2e8
movq 0x10a0652(%rip), %rsi   # 0x111a2e8
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x79cb3
incl (%rax)
movq %rbx, %rdi
callq 0x15000
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0x6aa79(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0x6aa7e(%rip), %xmm0    # 0xe475d
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x95a5
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_Tag_inputs
static struct std_list_List_1 mw_mirth_data_Tag_inputs (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Tag_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_data_Tag_inputs, in_Tag_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 mirth_mirth_zaMirth* v10;
		struct mirth_type_ArrowType* v11 = mw_mirth_data_Tag_type(in_zaMirth_1, in_Tag_2, &v10);
		struct mirth_type_StackType v12 = v11->mdom;
		incref(MK_mirth_type_StackType(v12));
		decref(MK_mirth_type_ArrowType(v11));
		struct mirth_mirth_zaMirth* v13;
		struct std_list_List_1 v14;
		struct mirth_type_StackTypeBase v15 = mw_mirth_type_StackType_splitzeparts(v10, v12, &v13, &v14);
		decref(MK_mirth_type_StackTypeBase(v15));
		incref(MK_std_list_List_1(v14));
		mut_set(MK_std_list_List_1(v14), v5);
		branch_List_8 = v14;
		branch_zaMirth_7 = v13;
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_List_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r12
movq %rdi, %r15
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
leaq 0x109f2c6(%rip), %rdi   # 0x1119298
callq 0x13ff0
movq %rax, %r14
movq %rax, %rdi
callq 0x153b0
testb %al, %al
je 0x7a000
movq %r14, %rdi
callq 0x140f0
movq %rax, %r12
andq %rax, %rbx
shrq $0x30, %r12
movq %rbx, %r13
jmp 0x7a0d2
leaq -0x40(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5117e
movq %rax, %rdi
movl 0x8(%rax), %r15d
movq 0x10(%rax), %r12
movq %r12, %rcx
andq %rbx, %rcx
sete %dl
testb $0x3, %r12b
setne %sil
orb %dl, %sil
jne 0x7a032
incl (%rcx)
andq %rbx, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x7a053
decl (%rax)
jne 0x7a053
leaq 0x9bb2b(%rip), %rsi     # 0x115b79
callq 0xd4e3
movq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rcx
leaq -0x50(%rbp), %r8
movl %r15d, %esi
movq %r12, %rdx
callq 0x363c1
movq %rdx, %rcx
andq %rbx, %rcx
sete %sil
testb $0x3, %dl
setne %dil
orb %sil, %dil
jne 0x7a09a
decl (%rcx)
jne 0x7a09a
shlq $0x30, %rax
orq %rdx, %rax
leaq 0x9c27f(%rip), %rsi     # 0x116311
movq %rax, %rdi
callq 0xd4e3
movl -0x50(%rbp), %r12d
movq -0x48(%rbp), %r13
movq %r12, %rdi
shlq $0x30, %rdi
orq %r13, %rdi
leaq 0x9b1c6(%rip), %rsi     # 0x115279
andq %r13, %rbx
sete %al
testb $0x3, %r13b
setne %cl
orb %al, %cl
jne 0x7a0c6
incl (%rbx)
movq %r14, %rdx
callq 0x14ab5
movq -0x38(%rbp), %r15
movq -0x30(%rbp), %rax
movq %r15, (%rax)
movl %r12d, %eax
movq %r13, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_type_StackTypePart_typezfresource
static struct std_either_Either_2 mw_mirth_type_StackTypePart_typezfresource (struct mirth_type_StackTypePart in_StackTypePart_1) {
	struct std_either_Either_2 branch_Either_3;
	switch ((in_StackTypePart_1).tag) {
		case mirth_type_StackTypePart_Cons: {
			struct mirth_type_Type v4 = mtp_mirth_type_StackTypePart_Cons(in_StackTypePart_1);
			struct std_either_Either_2 v5 = mtw_std_either_Either_2_Left(MK_mirth_type_Type(v4));
			branch_Either_3 = v5;
		} break;
		case mirth_type_StackTypePart_With: {
			struct mirth_type_Type v6 = mtp_mirth_type_StackTypePart_With(in_StackTypePart_1);
			struct std_either_Either_2 v7 = mtw_std_either_Either_2_Right(MK_mirth_type_Type(v6));
			branch_Either_3 = v7;
		} break;
		case mirth_type_StackTypePart_ConsLabel: {
			uint64_t v8;
			struct mirth_type_Type v9 = mtp_mirth_type_StackTypePart_ConsLabel(in_StackTypePart_1, &v8);
			struct std_either_Either_2 v10 = mtw_std_either_Either_2_Left(MK_mirth_type_Type(v9));
			branch_Either_3 = v10;
		} break;
		case mirth_type_StackTypePart_WithLabel: {
			uint64_t v11;
			struct mirth_type_Type v12 = mtp_mirth_type_StackTypePart_WithLabel(in_StackTypePart_1, &v11);
			struct std_either_Either_2 v13 = mtw_std_either_Either_2_Right(MK_mirth_type_Type(v12));
			branch_Either_3 = v13;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	return branch_Either_3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x3, %edi
ja 0x7a17a
movl %edi, %eax
leaq 0x69348(%rip), %rcx     # 0xe344c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rsi, %rdi
callq 0x3f453
jmp 0x7a15c
movq %rsi, %rdi
callq 0x3f4e7
jmp 0x7a130
leaq -0x8(%rbp), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x3f527
shlq $0x30, %rax
orq %rdx, %rax
leaq 0x9b9ab(%rip), %rsi     # 0x115ae9
movq %rax, %rdi
callq 0x20c67
movl $0x1, %eax
jmp 0x7a174
leaq -0x8(%rbp), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x3f493
shlq $0x30, %rax
orq %rdx, %rax
leaq 0x9b97f(%rip), %rsi     # 0x115ae9
movq %rax, %rdi
callq 0x20c09
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0x6a5ba(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0x6a5bf(%rip), %xmm0    # 0xe475d
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x95a5
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_data_SemiTransparentData_SemiTransparentData
static struct mirth_data_SemiTransparentData* mtw_mirth_data_SemiTransparentData_SemiTransparentData (uint64_t in_Tag_1, struct mirth_type_StackTypePart in_StackTypePart_2, struct mirth_tycon_Tycon in_Tycon_3) {
	struct mirth_data_SemiTransparentData* v5 = calloc(1, sizeof *v5);
	ASSERT(v5);
	v5->refs = 1;
	v5->minputzetycon = in_Tycon_3;
	v5->minput = in_StackTypePart_2;
	v5->mtag = in_Tag_1;
	return v5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %ecx, %r13d
movq %rdx, %rbx
movl %esi, %r12d
movq %rdi, %r15
movl $0x1, %edi
movl $0x30, %esi
callq 0x50c0
testq %rax, %rax
je 0x7a204
movl $0x1, (%rax)
movl %r13d, 0x20(%rax)
movq %r14, 0x28(%rax)
movl %r12d, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %r15, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x71ca2(%rip), %rsi     # 0xebead
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_data_SemiTransparentData_free
static void mirth_data_SemiTransparentData_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_data_SemiTransparentData);
	struct mirth_data_SemiTransparentData* self = vself.data.ptr;
	decref(MK_mirth_type_StackTypePart(self->minput));
	decref(MK_mirth_tycon_Tycon(self->minputzetycon));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x9c902(%rip), %rax     # 0x116b39
cmpq %rsi, %rax
jne 0x7a2b6
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
movq 0x18(%rdi), %rcx
movq %rcx, %rax
andq %r14, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x7a27b
decl (%rax)
jne 0x7a27b
leaq 0x9ba76(%rip), %rsi     # 0x115ce1
movl 0x10(%rbx), %edi
shlq $0x30, %rdi
orq 0x18(%rbx), %rdi
callq 0xd4e3
movq 0x28(%rbx), %rax
andq %rax, %r14
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x7a2aa
decl (%r14)
jne 0x7a2aa
leaq 0x9b6e7(%rip), %rsi     # 0x115981
movl 0x20(%rbx), %edi
shlq $0x30, %rdi
orq 0x28(%rbx), %rdi
callq 0xd4e3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0x71c36(%rip), %rsi     # 0xebef3
movl $0x5d, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_file_zaFile_closezefilezx
static struct std_maybe_Maybe_1 mw_std_file_zaFile_closezefilezx (struct std_file_zaFile* in_zaFile_1) {
	int64_t v5;
	bool v6;
	mtp_std_file_zaFile_zaFile(in_zaFile_1, &v5, &v6);
	struct std_maybe_Maybe_1 branch_Maybe_7;
	if (v6) {
		int64_t v8 = mext_std_prim_zaWorld_rawzeposixzeclosezx(v5);
		INT v9 = WRAP_I63(0LL);
		INT v10 = v9;
		INT v11 = i64_to_int(v8);
		bool v12 = int_lt(v11, v10);
		struct std_maybe_Maybe_1 branch_Maybe_13;
		if (v12) {
			int64_t v14 = mw_std_prelude_unsafe_1_sp1();
			struct std_file_IOError v15 = mtw_std_file_IOError_CloseFailed(v14);
			struct std_maybe_Maybe_1 v16 = mtw_std_maybe_Maybe_1_Some(MK_std_file_IOError(v15));
			branch_Maybe_13 = v16;
		} else {
			struct std_maybe_Maybe_1 v17 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_13 = v17;
		}
		branch_Maybe_7 = branch_Maybe_13;
	} else {
		struct std_maybe_Maybe_1 v18 = { .tag=std_maybe_Maybe_1_None };
		branch_Maybe_7 = v18;
	}
	return branch_Maybe_7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rbx
movb 0x8(%rdi), %r14b
callq 0x5030
testb $0x1, %r14b
je 0x7af65
movl %ebx, %edi
callq 0x5090
cltq
leaq 0x1(,%rax,2), %rdi
movl $0x1, %esi
callq 0xec04
testl %eax, %eax
js 0x7af6e
xorl %eax, %eax
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
retq
callq 0x5040
movslq (%rax), %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x7afb4
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
movabsq $0x3000000000000, %rdi  # imm = 0x3000000000000
orq %rax, %rdi
leaq 0x9bc21(%rip), %rsi     # 0x116bc9
callq 0x95f6
movl $0x1, %eax
jmp 0x7af69
leaq 0x712e8(%rip), %rsi     # 0xec2a3
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_std_maybe_zaMaybe_1_zaSome
static void mtw_std_maybe_zaMaybe_1_zaSome (VAL in_zat_1, struct std_maybe_zaMaybe_1 *out_zaMaybe_2) {
	struct std_maybe_zaMaybe_1_zaSome* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->m0 = in_zat_1;
	struct std_maybe_zaMaybe_1 v4 = { .tag=std_maybe_zaMaybe_1_zaSome, .ptr.zaSome=v3 };
	*out_zaMaybe_2 = v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x7b01c
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x70fe5(%rip), %rsi     # 0xec008
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_std_file_zaFile_zaFile
static void mtw_std_file_zaFile_zaFile (int64_t in_zaFileDescriptor_1, bool in_Bool_2, struct std_file_zaFile* *out_zaFile_3) {
	struct std_file_zaFile* v4 = calloc(1, sizeof *v4);
	ASSERT(v4);
	v4->mowned = in_Bool_2;
	v4->mzafd = in_zaFileDescriptor_1;
	*out_zaFile_3 = v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x7b07d
movb %r15b, 0x8(%rax)
movq %r14, (%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x70fb6(%rip), %rsi     # 0xec03a
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_std_result_zaResult_2_zaOk
static void mtw_std_result_zaResult_2_zaOk (VAL in_zat_1, struct std_result_zaResult_2 *out_zaResult_2) {
	struct std_result_zaResult_2_zaOk* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->m0 = in_zat_1;
	struct std_result_zaResult_2 v4 = { .tag=std_result_zaResult_2_zaOk, .ptr.zaOk=v3 };
	*out_zaResult_2 = v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x7b131
movq %r14, (%rax)
leaq 0x9ba62(%rip), %rcx     # 0x116b80
movq %rcx, 0x8(%rax)
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x70f6b(%rip), %rsi     # 0xec0a3
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_std_result_zaResult_2_zaErr
static void mtw_std_result_zaResult_2_zaErr (VAL in_e_1, struct std_result_zaResult_2 *out_zaResult_2) {
	struct std_result_zaResult_2_zaErr* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->m0 = in_e_1;
	struct std_result_zaResult_2 v4 = { .tag=std_result_zaResult_2_zaErr, .ptr.zaErr=v3 };
	*out_zaResult_2 = v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x7b199
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movl $0x0, (%rbx)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x70f75(%rip), %rsi     # 0xec115
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: std_file_IOError_free
void std_file_IOError_free (VAL v) {
	struct std_file_IOError self = V_std_file_IOError(v);
	switch (self.tag) {
		case std_file_IOError_OpenFailed: {
			decref(MKSTR(self.ptr.OpenFailed->mPath));
			free(self.ptr.OpenFailed);
		} break;
		case std_file_IOError_CreateFailed: {
			decref(MKSTR(self.ptr.CreateFailed->mPath));
			free(self.ptr.CreateFailed);
		} break;
		case std_file_IOError_CreateUnsupported: {
			decref(MKSTR(self.ptr.CreateUnsupported->mPath));
			free(self.ptr.CreateUnsupported);
		} break;
		case std_file_IOError_CloseFailed: {
			free(self.ptr.CloseFailed);
		} break;
		case std_file_IOError_ReadFailed: {
			free(self.ptr.ReadFailed);
		} break;
		case std_file_IOError_WriteFailed: {
			decref(MKINT(self.ptr.WriteFailed->mSizze));
			free(self.ptr.WriteFailed);
		} break;
	}
}

// Assembly:
movq %rdi, %rcx
shrq $0x30, %rcx
cmpw $0x5, %cx
ja 0x7b293
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rax, %rbx
leaq 0x6823f(%rip), %rdx     # 0xe3474
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x7b285
decl (%rax)
jne 0x7b285
leaq 0x99efb(%rip), %rsi     # 0x115159
jmp 0x7b280
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x7b285
decl (%rax)
jne 0x7b285
leaq 0x9a1a9(%rip), %rsi     # 0x115429
callq 0xd4e3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_input_zaInputOpenState_endzx
static void mw_std_input_zaInputOpenState_endzx (struct std_input_zaInputOpenState* in_zaInputOpenState_1, struct std_file_zaFile* *out_zaFile_2) {
	INT v3;
	INT v4;
	struct std_file_zaFile* v5;
	ARR* v6;
	mtp_std_input_zaInputOpenState_zaInputOpenState(in_zaInputOpenState_1, &v3, &v4, &v5, &v6);
	decref(MKINT(v3));
	decref(MKINT(v4));
	mw_std_buffer_zaBuffer_rdrop(v6);
	*out_zaFile_2 = v5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, -0x30(%rbp)
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movq (%rdi), %r13
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
movq 0x18(%rdi), %r14
callq 0x5030
leaq 0x99e05(%rip), %rsi     # 0x115429
movq %r13, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0x7b64a
decl (%rax)
jne 0x7b64a
movq %r13, %rdi
movq %rsi, %r13
callq 0xd4e3
movq %r13, %rsi
andq %r15, %rbx
sete %al
testb $0x3, %r15b
setne %cl
orb %al, %cl
jne 0x7b667
decl (%rbx)
jne 0x7b667
movq %r15, %rdi
callq 0xd4e3
movq %r14, %rdi
callq 0x12e09
movq -0x30(%rbp), %rax
movq %r12, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_std_input_zaInput_Done
static void mtw_std_input_zaInput_Done (struct std_file_zaFile* in_zaFile_1, struct std_input_zaInput *out_zaInput_2) {
	struct std_input_zaInput_Done* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->mzaFile = in_zaFile_1;
	struct std_input_zaInput v4 = { .tag=std_input_zaInput_Done, .ptr.Done=v3 };
	*out_zaInput_2 = v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x8, %esi
callq 0x50c0
testq %rax, %rax
je 0x7b6b8
movq %r14, (%rax)
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x70bb2(%rip), %rsi     # 0xec271
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_maybe_Maybe_1_elsezy_1_sp8
static uint64_t mw_std_maybe_Maybe_1_elsezy_1_sp8 (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, VAL *out_zux1_6) {
	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 a revision number.", 27);
			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_zux1_6 = branch_zux1_9;
	*out_zaMirth_4 = branch_zaMirth_7;
	return branch_Token_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, %edx
jne 0x7b719
movq %r9, %r12
movq %r8, %r15
movq %rcx, %rdi
callq 0xdaeb
movq %rax, (%r12)
movq %rdx, 0x8(%r12)
movq %r14, (%r15)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x109ecaf(%rip)   # 0x111a3d0
jne 0x7b752
movl $0x1b, %edi
callq 0xf9f7
movq $0x1b, 0x10(%rax)
movups 0x70b99(%rip), %xmm0    # 0xec2d5
movups %xmm0, 0x18(%rax)
movups 0x70b99(%rip), %xmm0    # 0xec2e0
movups %xmm0, 0x23(%rax)
movq %rax, 0x109ec7e(%rip)   # 0x111a3d0
movq 0x109ec77(%rip), %rdx   # 0x111a3d0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x7b777
incl (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2778c
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_elab_skipzedeclzeblockzx
static uint64_t mw_mirth_elab_skipzedeclzeblockzx (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 std_maybe_Maybe_1 v6 = mw_mirth_token_Token_lcurlyzy(in_zaMirth_1, in_Token_2, &v5);
	struct mirth_mirth_zaMirth* v7;
	uint64_t v8 = mw_std_maybe_Maybe_1_else_1_sp3(v5, in_Token_2, v6, &v7);
	struct mirth_mirth_zaMirth* v9;
	uint64_t v10 = mw_mirth_token_Token_next(v7, v8, &v9);
	*out_zaMirth_3 = v9;
	return v10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x30(%rbp), %r15
movq %r15, %rdx
callq 0x310fd
movq %rdx, %rcx
movq (%r15), %rdi
leaq -0x28(%rbp), %r15
movq %r14, %rsi
movl %eax, %edx
movq %r15, %r8
callq 0x3118b
movq (%r15), %rdi
leaq -0x20(%rbp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x28928
movq (%r15), %rcx
movq %rcx, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_name_Namespace_enclosingzetyconzy
static struct std_maybe_Maybe_1 mw_mirth_name_Namespace_enclosingzetyconzy (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_name_Namespace in_Namespace_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* branch_zaMirth_5;
	struct std_maybe_Maybe_1 branch_Maybe_6;
	switch ((in_Namespace_2).tag) {
		case mirth_name_Namespace_Root: {
			struct std_maybe_Maybe_1 v7 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_6 = v7;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case mirth_name_Namespace_Package: {
			uint64_t v8 = mtp_mirth_name_Namespace_Package(in_Namespace_2);
			struct std_maybe_Maybe_1 v9 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_6 = v9;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case mirth_name_Namespace_Module: {
			uint64_t v10 = mtp_mirth_name_Namespace_Module(in_Namespace_2);
			struct std_maybe_Maybe_1 v11 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_6 = v11;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case mirth_name_Namespace_Tycon: {
			struct mirth_tycon_Tycon v12 = mtp_mirth_name_Namespace_Tycon(in_Namespace_2);
			struct std_maybe_Maybe_1 v13 = mtw_std_maybe_Maybe_1_Some(MK_mirth_tycon_Tycon(v12));
			branch_Maybe_6 = v13;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case mirth_name_Namespace_Word: {
			uint64_t v14 = mtp_mirth_name_Namespace_Word(in_Namespace_2);
			struct mirth_mirth_zaMirth* v15;
			struct mirth_name_Namespace v16 = mw_mirth_word_Word_namespacezehard(in_zaMirth_1, v14, &v15);
			struct mirth_mirth_zaMirth* v17;
			struct std_maybe_Maybe_1 v18 = mw_mirth_name_Namespace_enclosingzetyconzy(v15, v16, &v17);
			branch_Maybe_6 = v18;
			branch_zaMirth_5 = v17;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_3 = branch_zaMirth_5;
	return branch_Maybe_6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl $0x4, %esi
ja 0x7bd4a
movq %rcx, %rbx
movl %esi, %eax
movq %rdi, %r14
movl %esi, %ecx
leaq 0x677c9(%rip), %rsi     # 0xe348c
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
decl (%rdx)
jne 0x7bcd8
movq %rdx, %rdi
callq 0x5030
xorl %eax, %eax
xorl %edx, %edx
jmp 0x7bd3a
movq 0x8(%rdx), %r15
decl (%rdx)
jne 0x7bcee
movq %rdx, %rdi
callq 0x5030
leaq -0x30(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4ae5e
movq (%r12), %rdi
leaq -0x28(%rbp), %r14
movl %eax, %esi
movq %r14, %rcx
callq 0x7bc9a
movq (%r14), %r14
jmp 0x7bd3a
movq %rdx, %rdi
callq 0x19ee8
shlq $0x30, %rax
orq %rdx, %rax
leaq 0x99c54(%rip), %rsi     # 0x115981
movq %rax, %rdi
callq 0x95f6
movl $0x1, %eax
movq %r14, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0x689ea(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0x689ef(%rip), %xmm0    # 0xe475d
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x95a5