LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x71a50
movl %edi, %eax
leaq 0x61ab8(%rip), %rcx     # 0xd3494
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rsi, %rdi
callq 0x3aac9
jmp 0x71a32
movq %rsi, %rdi
callq 0x3ab5d
jmp 0x71a08
leaq -0x8(%rbp), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x3ab9d
shlq $0x30, %rax
orq %rdx, %rax
leaq 0x970d3(%rip), %rsi     # 0x108ae9
movq %rax, %rdi
callq 0x1e454
pushq $0x1
popq %rax
jmp 0x71a4a
leaq -0x8(%rbp), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x3ab09
shlq $0x30, %rax
orq %rdx, %rax
leaq 0x970a9(%rip), %rsi     # 0x108ae9
movq %rax, %rdi
callq 0x1e400
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
leaq 0x62db6(%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: 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 0x980c4(%rip), %rax     # 0x109b39
cmpq %rsi, %rax
jne 0x71af4
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 0x71ab9
decl (%rax)
jne 0x71ab9
leaq 0x97238(%rip), %rsi     # 0x108ce1
movl 0x10(%rbx), %edi
shlq $0x30, %rdi
orq 0x18(%rbx), %rdi
callq 0xce94
movq 0x28(%rbx), %rax
andq %rax, %r14
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x71ae8
decl (%r14)
jne 0x71ae8
leaq 0x96ea9(%rip), %rsi     # 0x108981
movl 0x20(%rbx), %edi
shlq $0x30, %rdi
orq 0x28(%rbx), %rdi
callq 0xce94
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0x6a4c5(%rip), %rsi     # 0xdbfc0
pushq $0x2
popq %rdi
pushq $0x5d
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_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 0x72676
movl %ebx, %edi
callq 0x5090
movslq %eax, %rdi
callq 0xd86d
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x89cc
testb %al, %al
je 0x72676
callq 0x728d6
movq %rax, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x7267f
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
movabsq $0x3000000000000, %rdi  # imm = 0x3000000000000
orq %rax, %rdi
leaq 0x9755d(%rip), %rsi     # 0x109bc9
callq 0x8d0c
pushq $0x1
popq %rax
jmp 0x7267a
xorl %eax, %eax
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x69cea(%rip), %rsi     # 0xdc370
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_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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x726ec
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 0x699e2(%rip), %rsi     # 0xdc0d5
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_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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x72769
movb %r15b, 0x8(%rax)
movq %r14, (%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x69997(%rip), %rsi     # 0xdc107
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_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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x7280d
movq %r14, (%rax)
leaq 0x97386(%rip), %rcx     # 0x109b80
movq %rcx, 0x8(%rax)
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6995c(%rip), %rsi     # 0xdc170
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_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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x72868
movq %r15, (%rax)
movq %r14, 0x8(%rax)
andl $0x0, (%rbx)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x69973(%rip), %rsi     # 0xdc1e2
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: 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:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rcx
shrq $0x30, %rcx
cmpw $0x5, %cx
ja 0x7296c
movq %rdi, %rbx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rax, %rbx
leaq 0x60bae(%rip), %rdx     # 0xd34bc
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 0x7295e
decl (%rax)
jne 0x7295e
leaq 0x95822(%rip), %rsi     # 0x108159
jmp 0x72959
movq 0x8(%rbx), %rdi
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x7295e
decl (%rax)
jne 0x7295e
leaq 0x95ad0(%rip), %rsi     # 0x108429
callq 0xce94
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5030
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_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 0x95708(%rip), %rsi     # 0x108429
movq %r13, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0x72d47
decl (%rax)
jne 0x72d47
movq %r13, %rdi
movq %rsi, %r13
callq 0xce94
movq %r13, %rsi
andq %r15, %rbx
sete %al
testb $0x3, %r15b
setne %cl
orb %al, %cl
jne 0x72d64
decl (%rbx)
jne 0x72d64
movq %r15, %rdi
callq 0xce94
movq %r14, %rdi
callq 0x11e41
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_O2/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
pushq $0x1
popq %rdi
pushq $0x8
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x72db1
movq %r14, (%rax)
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x69586(%rip), %rsi     # 0xdc33e
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_maybe_Maybe_1_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 0x72e0c
movq %r9, %r12
movq %r8, %r15
movq %rcx, %rdi
callq 0xd491
movq %rax, (%r12)
movq %rdx, 0x8(%r12)
movq %r14, (%r15)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x109a5bd(%rip), %rdx   # 0x110d3d0
testq %rdx, %rdx
jne 0x72e31
leaq 0x69583(%rip), %rdi     # 0xdc3a2
pushq $0x1b
popq %rsi
callq 0x8a21
movq %rax, %rdx
movq %rax, 0x109a59f(%rip)   # 0x110d3d0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x72e4f
incl (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x246fe
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_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 0x2d978
movq %rdx, %rcx
movq (%r15), %rdi
leaq -0x28(%rbp), %r15
movq %r14, %rsi
movl %eax, %edx
movq %r15, %r8
callq 0x2d9f4
movq (%r15), %rdi
leaq -0x20(%rbp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x2598b
movq (%r15), %rcx
movq %rcx, (%rbx)
addq $0x18, %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_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 %rbx
subq $0x18, %rsp
cmpl $0x4, %esi
ja 0x732e5
movq %rcx, %rbx
movl %esi, %eax
movq %rdi, %r14
movl %esi, %ecx
leaq 0x6026f(%rip), %rsi     # 0xd34d4
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
movq %rdx, %rdi
callq 0x17b11
jmp 0x732b0
movq %rdx, %rdi
callq 0x17c77
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x455b7
movq (%r15), %rdi
leaq -0x20(%rbp), %r14
movl %eax, %esi
movq %r14, %rcx
callq 0x7323e
movq (%r14), %r14
jmp 0x732d7
movq %rdx, %rdi
callq 0x17b2e
xorl %eax, %eax
xorl %edx, %edx
jmp 0x732d7
movq %rdx, %rdi
callq 0x17b4b
shlq $0x30, %rax
orq %rdx, %rax
leaq 0x956b5(%rip), %rsi     # 0x108981
movq %rax, %rdi
callq 0x8d0c
pushq $0x1
popq %rax
movq %r14, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x61521(%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_token_Token_patternzevarzy
static struct std_maybe_Maybe_1 mw_mirth_token_Token_patternzevarzy (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_namezy(in_zaMirth_1, in_Token_2, &v5);
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	struct std_maybe_Maybe_1 branch_Maybe_8;
	switch ((v6).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v9 = mtp_std_maybe_Maybe_1_Some(v6);
			incref(v9);
			struct mirth_mirth_zaMirth* v10;
			bool v11 = mw_mirth_name_Name_couldzebezepatternzevarzy(v5, V_mirth_name_Name(v9), &v10);
			struct mirth_mirth_zaMirth* branch_zaMirth_12;
			struct std_maybe_Maybe_1 branch_Maybe_13;
			if (v11) {
				struct std_maybe_Maybe_1 v14 = mtw_std_maybe_Maybe_1_Some(v9);
				branch_Maybe_13 = v14;
				branch_zaMirth_12 = v10;
			} else {
				decref(v9);
				struct std_maybe_Maybe_1 v15 = { .tag=std_maybe_Maybe_1_None };
				branch_Maybe_13 = v15;
				branch_zaMirth_12 = v10;
			}
			branch_Maybe_8 = branch_Maybe_13;
			branch_zaMirth_7 = branch_zaMirth_12;
		} break;
		case std_maybe_Maybe_1_None: {
			struct std_maybe_Maybe_1 v16 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_8 = v16;
			branch_zaMirth_7 = v5;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_Maybe_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
leaq -0x30(%rbp), %rdx
callq 0x2df97
cmpl $0x1, %eax
jne 0x73383
movq %rdx, %rdi
callq 0xd491
movq %rax, %r15
movq %rdx, %r14
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
testb $0x1, %r14b
je 0x73352
movq %r15, %rax
andq %r13, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x73352
incl (%rax)
movq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rdx
movq %r15, %rsi
callq 0x1c899
movl %eax, %r12d
movq %r12, %rdi
callq 0xd86d
movq %rax, %rdi
callq 0xdc43
movzbl %al, %eax
cmpl $0x60, %eax
ja 0x7338b
movq -0x38(%rbp), %r12
jmp 0x733b7
xorl %eax, %eax
movq -0x30(%rbp), %r12
jmp 0x733e2
movq %r12, %rdi
callq 0xd86d
movq %rax, %rdi
callq 0xdc43
movzbl %al, %eax
movq -0x38(%rbp), %r12
cmpl $0x7a, %eax
ja 0x733b7
movq %r15, %rdi
movq %r14, %rsi
callq 0x8d0c
pushq $0x1
popq %rax
jmp 0x733e4
testb $0x1, %r14b
je 0x733e0
movq %r15, %rax
andq %r13, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x733e0
decl (%rax)
jne 0x733e0
movq %r15, %rdi
movq %r14, %rsi
callq 0xce94
xorl %eax, %eax
xorl %edx, %edx
movq %r12, (%rbx)
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: mw_mirth_elab_zaAB_abzeerrorzx
static void mw_mirth_elab_zaAB_abzeerrorzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_arrow_Arrow* in_zaAB_2, STR* in_Str_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_arrow_Arrow* *out_zaAB_5) {
	struct mirth_arrow_Arrow* v6;
	uint64_t v7 = mw_mirth_elab_zaAB_abzetokenzo(in_zaAB_2, &v6);
	struct mirth_mirth_zaMirth* v8;
	mw_mirth_mirth_zaMirth_emitzeerrorzx(in_zaMirth_1, v7, in_Str_3, &v8);
	struct mirth_type_StackType v9 = { .tag=mirth_type_StackType_Error };
	struct mirth_mirth_zaMirth* v10;
	struct mirth_arrow_Arrow* v11;
	mw_mirth_elab_zaAB_abzeunifyzetypezx(v8, v6, v9, &v10, &v11);
	struct mirth_type_StackType v12 = { .tag=mirth_type_StackType_Error };
	struct mirth_arrow_Arrow* v13;
	mw_mirth_elab_zaAB_abzetypezx(v11, v12, &v13);
	*out_zaAB_5 = v13;
	*out_zaMirth_4 = v10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movq %rcx, -0x30(%rbp)
movq %rdx, %r15
movq %rdi, %r12
leaq -0x58(%rbp), %r13
movq %rsi, %rdi
movq %r13, %rsi
callq 0x3f5b0
leaq -0x50(%rbp), %rbx
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2ceb4
movq (%rbx), %rdi
movq (%r13), %rsi
leaq -0x48(%rbp), %rbx
leaq -0x40(%rbp), %r15
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
movq %r15, %r9
callq 0x3faad
movq (%r15), %rdi
leaq -0x38(%rbp), %r15
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x4f845
movq (%r15), %rax
movq %rax, (%r14)
movq (%rbx), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
addq $0x38, %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_mirth_mirth_zaMirth_tracezediagnosticszx
static void mw_mirth_mirth_zaMirth_tracezediagnosticszx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_mirth_zaMirth* *out_zaMirth_2) {
	struct mirth_mirth_zaMirth* v5;
	struct std_list_List_1 v6 = mw_mirth_mirth_zaMirth_popzediagnosticszx(in_zaMirth_1, &v5);
	bool v7 = true;
	struct mirth_mirth_zaMirth* r8 = v5;
	struct std_list_List_1 v9 = v6;
	bool v10 = v7;
	bool v11 = v7;
	while (v11) {
		struct mirth_mirth_zaMirth* r12 = r8;
		struct std_list_List_1 v13 = v9;
		bool v14 = v10;
		struct mirth_mirth_zaMirth* branch_zaMirth_15;
		struct std_list_List_1 branch_List_16;
		bool branch_Bool_17;
		switch ((v13).tag) {
			case std_list_List_1_Cons: {
				struct std_list_List_1 v18;
				VAL v19 = mtp_std_list_List_1_Cons(v13, &v18);
				STR* v20;
				STRLIT(v20, "", 0);
				struct mirth_mirth_zaMirth* v21;
				STR* v22;
				mw_mirth_mirth_Diagnostic_diagnosticzj(r12, v20, V_mirth_mirth_Diagnostic(v19), &v21, &v22);
				mw_std_prim_zaWorld_trace(v22);
				bool v23 = true;
				branch_Bool_17 = v23;
				branch_List_16 = v18;
				branch_zaMirth_15 = v21;
			} break;
			case std_list_List_1_Nil: {
				struct std_list_List_1 v24 = { .tag=std_list_List_1_Nil };
				bool v25 = false;
				branch_Bool_17 = v25;
				branch_List_16 = v24;
				branch_zaMirth_15 = r12;
			} break;
			default: {
				do_panic(str_make("unexpected fallthrough in match\n", 32));
			}
		}
		v11 = branch_Bool_17;
		v10 = branch_Bool_17;
		v9 = branch_List_16;
		r8 = branch_zaMirth_15;
	}
	decref(MK_std_list_List_1(v9));
	*out_zaMirth_2 = r8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq -0x50(%rbp), %r14
movq %r14, %rsi
callq 0x19d15
movq (%r14), %r13
leaq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %r15
leaq -0x30(%rbp), %r12
movb $0x1, %cl
movq %rdx, %rdi
testb $0x1, %cl
je 0x768ee
xorl %ecx, %ecx
movl $0x0, %edx
testl %eax, %eax
je 0x76854
cmpl $0x1, %eax
jne 0x76935
callq 0xce01
movq %rax, %r14
movq 0x1096f5d(%rip), %rsi   # 0x110d7e0
testq %rsi, %rsi
jne 0x768a0
leaq 0x65e66(%rip), %rdi     # 0xdc6f5
xorl %esi, %esi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x1096f40(%rip)   # 0x110d7e0
movq %rsi, %rax
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rcx, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x768c0
incl (%rax)
movq %r13, %rdi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x19da1
movq -0x30(%rbp), %rdi
callq 0x7694c
movl -0x48(%rbp), %eax
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %r13
leaq -0x48(%rbp), %rsi
jmp 0x76852
movabsq $0xfffffffffffc, %rsi   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rsi
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x76923
decl (%rsi)
jne 0x76923
shlq $0x30, %rax
orq %rdi, %rax
leaq 0x9195e(%rip), %rsi     # 0x108279
movq %rax, %rdi
callq 0xce94
movq %r13, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5ded1(%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_std_prim_zaWorld_trace
static void mw_std_prim_zaWorld_trace (STR* in_Str_1) {
	STR* v4;
	STRLIT(v4, "\n", 1);
	STR* v5 = str_cat(in_Str_1, v4);
	mw_std_prim_zaWorld_traceze(v5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1096e8c(%rip), %rsi   # 0x110d7e8
testq %rsi, %rsi
jne 0x7697a
leaq 0x5f07e(%rip), %rdi     # 0xd59e6
pushq $0x1
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x1096e6e(%rip)   # 0x110d7e8
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x76997
incl (%rax)
movq %rbx, %rdi
callq 0xd8b0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8ba0
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_path_Path_join
static STR* mw_std_path_Path_join (STR* in_Path_1, STR* in_Path_2) {
	int64_t v6 = RUNNING_OS;
	enum std_prelude_OS v7 = mw_std_prim_I64_zgOS(v6);
	VAL v8 = mw_std_prelude_OS_pathzeseparator(v7);
	STR* v9 = mw_std_path_Path_joinzewith(in_Path_1, value_str(v8), in_Path_2);
	return v9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
callq 0x7b582
movl %eax, %edi
callq 0xd86d
pushq $0x3
popq %rsi
movq %rax, %rdi
callq 0xd759
testb %al, %al
je 0x7b51d
movq 0x1092034(%rip), %rdi   # 0x110d520
testq %rdi, %rdi
jne 0x7b50a
leaq 0x611f8(%rip), %rdi     # 0xdc6f0
pushq $0x1
popq %rsi
callq 0x8a21
movq %rax, %rdi
movq %rax, 0x1092016(%rip)   # 0x110d520
andq %rdi, %r15
setne %al
testb $0x3, %dil
sete %cl
testb %cl, %al
jne 0x7b553
jmp 0x7b556
movq 0x1092004(%rip), %rdi   # 0x110d528
testq %rdi, %rdi
jne 0x7b542
leaq 0x72ca3(%rip), %rdi     # 0xee1d3
pushq $0x1
popq %rsi
callq 0x8a21
movq %rax, %rdi
movq %rax, 0x1091fe6(%rip)   # 0x110d528
andq %rdi, %r15
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x7b556
incl (%r15)
leaq 0x8cbfc(%rip), %rsi     # 0x108159
callq 0x8b55
movq %r14, %rdi
movq %rax, %rsi
callq 0xd8b0
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd8b0
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_package_Package_Findzy
static struct std_maybe_Maybe_1 mw_mirth_package_Package_Findzy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Name_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_name_Namespace v5 = { .tag=mirth_name_Namespace_Root };
	INT v6 = WRAP_I63(0LL);
	struct mirth_name_QName* v7 = mw_mirth_name_QName_Mk(v5, in_Name_2, v6);
	struct mirth_mirth_zaMirth* v8;
	struct std_maybe_Maybe_1 v9 = mw_mirth_name_QName_defzesoftzy(in_zaMirth_1, v7, &v8);
	struct std_maybe_Maybe_1 branch_Maybe_10;
	switch ((v9).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v11 = mtp_std_maybe_Maybe_1_Some(v9);
			struct std_maybe_Maybe_1 v12 = mw_mirth_def_Def_packagezy(V_mirth_def_Def(v11));
			branch_Maybe_10 = v12;
		} break;
		case std_maybe_Maybe_1_None: {
			struct std_maybe_Maybe_1 v13 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_10 = v13;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_3 = v8;
	return branch_Maybe_10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r15
xorl %r14d, %r14d
pushq $0x1
popq %rcx
xorl %edi, %edi
xorl %esi, %esi
callq 0x1473b
leaq -0x20(%rbp), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x173a0
testl %eax, %eax
je 0x7b609
cmpl $0x1, %eax
jne 0x7b61e
movq %rdx, %rdi
callq 0xd491
movabsq $0xfffffffffffc, %rsi   # imm = 0xFFFFFFFFFFFC
andq %rax, %rsi
movq %rax, %rdi
shrq $0x30, %rdi
callq 0x2d22e
movq %rdx, %r14
movq -0x20(%rbp), %rcx
movq %rcx, (%rbx)
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x591e8(%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_package_Package_Newzx
static uint64_t mw_mirth_package_Package_Newzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct std_maybe_Maybe_1 in_Maybe_2, uint64_t in_Name_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	struct mirth_mirth_zaMirth* v6;
	uint64_t v7 = mw_mirth_package_Package_Makezx(in_zaMirth_1, in_Name_3, in_Maybe_2, &v6);
	struct mirth_def_Def v8 = mtw_mirth_def_Def_Package(v7);
	struct mirth_mirth_zaMirth* v9;
	mw_mirth_def_Def_register(v6, v8, &v9);
	*out_zaMirth_4 = v9;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x30(%rbp)
movq %rcx, %rbx
movq %rdx, %r13
movl %esi, %r12d
movq %rdi, %r15
movq 0x108facd(%rip), %r14   # 0x110b498
incq %r14
movq %r14, 0x108fac3(%rip)   # 0x110b498
leaq 0x108fb04(%rip), %rdi   # 0x110b4e0
movq %r14, %rsi
callq 0x12f88
leaq 0x8cd0d(%rip), %rsi     # 0x1086f8
movq %rbx, %rdi
movq %rax, %rdx
callq 0x1393b
leaq 0x108faf3(%rip), %rdi   # 0x110b4f0
movq %r14, %rsi
callq 0x12f88
shlq $0x30, %r12
orq %r13, %r12
leaq 0x8c8ae(%rip), %rsi     # 0x1082c1
movq %r12, %rdi
movq %rax, %rdx
callq 0x1393b
movq %r14, %rdi
callq 0x127b4
pushq $0x2
popq %rsi
leaq -0x38(%rbp), %rbx
movq %r15, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x127fd
movq (%rbx), %rax
movq -0x30(%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: mw_mirth_package_Package_path
static struct std_maybe_Maybe_1 mw_mirth_package_Package_path (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Package_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_package_Package_path, in_Package_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 0x108fa85(%rip), %rdi   # 0x110b4f0
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_std_byte_Byte_tozehexdigits
static enum std_byte_Byte mw_std_byte_Byte_tozehexdigits (enum std_byte_Byte in_Byte_1, enum std_byte_Byte *out_Byte_3) {
	int64_t v4 = in_Byte_1;
	INT v5 = i64_to_int(v4);
	uint64_t v6 = int_to_u64(v5);
	uint8_t v7 = (uint8_t)(v6);
	uint8_t v8 = 4;
	uint64_t v9 = (uint64_t)(v7);
	uint64_t v10 = (uint64_t)(v8);
	uint64_t v11 = u64_shr(v9, v10);
	uint8_t v12 = (uint8_t)(v11);
	enum std_byte_Byte v13 = mw_std_byte_Byte_OneHexDigit(v12);
	uint8_t v14 = 15;
	uint64_t v15 = (uint64_t)(v7);
	uint64_t v16 = (uint64_t)(v14);
	uint64_t v17 = (v15 & v16);
	uint8_t v18 = (uint8_t)(v17);
	enum std_byte_Byte v19 = mw_std_byte_Byte_OneHexDigit(v18);
	*out_Byte_3 = v19;
	return v13;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %edi
callq 0xd86d
movq %rax, %rdi
callq 0xdc43
movq %rax, %r14
shrb $0x4, %al
movzbl %al, %edi
callq 0x7c00e
movl %eax, %r15d
andl $0xf, %r14d
movl %r14d, %edi
callq 0x7c00e
movl %eax, (%rbx)
movl %r15d, %eax
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_lexer_zaLexer_donezy
static bool mw_mirth_lexer_zaLexer_donezy (struct mirth_lexer_zaLexer* in_zaLexer_1, struct mirth_lexer_zaLexer* *out_zaLexer_2) {
	STR* v4 = in_zaLexer_1->mlexerzesource;
	incref(MKSTR(v4));
	uint64_t v5 = str_size(v4);
	INT v6 = u64_to_int(v5);
	INT v7 = in_zaLexer_1->mlexerzeoffset;
	incref(MKINT(v7));
	bool v8 = int_le(v6, v7);
	*out_zaLexer_2 = in_zaLexer_1;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x48(%rdi), %rdi
movq %rdi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x7c067
incl (%rax)
callq 0xdb65
movq %rax, %rdi
callq 0xdbc8
movq 0x50(%r14), %rsi
andq %rsi, %r15
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x7c08c
incl (%r15)
movq %rax, %rdi
callq 0xdfd4
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_lexer_zaLexer_peek
static enum std_byte_Byte mw_mirth_lexer_zaLexer_peek (struct mirth_lexer_zaLexer* in_zaLexer_1, struct mirth_lexer_zaLexer* *out_zaLexer_2) {
	INT v4 = in_zaLexer_1->mlexerzeoffset;
	incref(MKINT(v4));
	STR* v5 = in_zaLexer_1->mlexerzesource;
	incref(MKSTR(v5));
	enum std_byte_Byte v6 = mw_std_prim_Str_bytezo(v4, v5);
	*out_zaLexer_2 = in_zaLexer_1;
	return v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movq 0x50(%rdi), %rdi
movq %rdi, %rcx
andq %rax, %rcx
sete %dl
testb $0x3, %dil
setne %sil
orb %dl, %sil
jne 0x7c0d5
incl (%rcx)
movq 0x48(%r14), %rsi
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x7c0ec
incl (%rax)
callq 0xde3b
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: mw_mirth_lexer_zaLexer_newlinezx
static void mw_mirth_lexer_zaLexer_newlinezx (struct mirth_lexer_zaLexer* in_zaLexer_1, struct mirth_lexer_zaLexer* *out_zaLexer_2) {
	INT v3 = WRAP_I63(0LL);
	INT v4 = in_zaLexer_1->mlexerzecol;
	decref(MKINT(v4));
	in_zaLexer_1->mlexerzecol = v3;
	INT v5 = in_zaLexer_1->mlexerzerow;
	incref(MKINT(v5));
	INT v6 = WRAP_I63(1LL);
	INT v7 = mw_mirth_location_Row_natza(v6, v5);
	INT v8 = in_zaLexer_1->mlexerzerow;
	decref(MKINT(v8));
	in_zaLexer_1->mlexerzerow = v7;
	*out_zaLexer_2 = in_zaLexer_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
movq 0x10(%rdi), %rdi
leaq 0x8c307(%rip), %r15     # 0x108429
movq %rdi, %rax
andq %r13, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x7c142
decl (%rax)
jne 0x7c142
movq %r15, %rsi
callq 0xce94
movq $0x1, 0x10(%r14)
movq 0x8(%r14), %rdi
movq %rdi, %rax
andq %r13, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x7c164
incl (%rax)
pushq $0x3
popq %rsi
callq 0xdd03
movq %rax, %r12
movq 0x8(%r14), %rdi
andq %rdi, %r13
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x7c192
decl (%r13)
jne 0x7c192
movq %r15, %rsi
callq 0xce94
movq %r12, 0x8(%r14)
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: mw_mirth_lexer_zaLexer_movezx
static void mw_mirth_lexer_zaLexer_movezx (struct mirth_lexer_zaLexer* in_zaLexer_1, struct mirth_lexer_zaLexer* *out_zaLexer_2) {
	INT v3 = in_zaLexer_1->mlexerzeoffset;
	incref(MKINT(v3));
	INT v4 = WRAP_I63(1LL);
	INT v5 = v4;
	INT v6 = int_add(v3, v5);
	INT v7 = in_zaLexer_1->mlexerzeoffset;
	decref(MKINT(v7));
	in_zaLexer_1->mlexerzeoffset = v6;
	INT v8 = in_zaLexer_1->mlexerzecol;
	incref(MKINT(v8));
	INT v9 = WRAP_I63(1LL);
	INT v10 = mw_mirth_location_Col_natza(v9, v8);
	INT v11 = in_zaLexer_1->mlexerzecol;
	decref(MKINT(v11));
	in_zaLexer_1->mlexerzecol = v10;
	*out_zaLexer_2 = in_zaLexer_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
movq 0x50(%rdi), %rdi
movq %rdi, %rax
andq %r13, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x7c1e0
incl (%rax)
leaq 0x8c242(%rip), %r15     # 0x108429
pushq $0x3
popq %rsi
callq 0xdd03
movq %rax, %r12
movq 0x50(%r14), %rdi
movq %rdi, %rax
andq %r13, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x7c216
decl (%rax)
jne 0x7c216
movq %r15, %rsi
callq 0xce94
movq %r12, 0x50(%r14)
movq 0x10(%r14), %rdi
movq %rdi, %rax
andq %r13, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x7c234
incl (%rax)
pushq $0x3
popq %rsi
callq 0xdd03
movq %rax, %r12
movq 0x10(%r14), %rdi
andq %rdi, %r13
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x7c262
decl (%r13)
jne 0x7c262
movq %r15, %rsi
callq 0xce94
movq %r12, 0x10(%r14)
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: mw_mirth_lexer_zaLexer_emitzx
static void mw_mirth_lexer_zaLexer_emitzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_lexer_zaLexer* in_zaLexer_2, struct mirth_token_TokenValue in_TokenValue_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_lexer_zaLexer* *out_zaLexer_5) {
	struct mirth_mirth_zaMirth* v6;
	struct mirth_lexer_zaLexer* v7;
	uint64_t v8 = mw_mirth_lexer_zaLexer_makezx(in_zaMirth_1, in_zaLexer_2, in_TokenValue_3, &v6, &v7);
	*out_zaLexer_5 = v7;
	*out_zaMirth_4 = v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rcx, %r14
leaq -0x30(%rbp), %r15
leaq -0x28(%rbp), %r12
xorl %ecx, %ecx
movq %r15, %r8
movq %r12, %r9
callq 0x7de31
movq (%r12), %rax
movq %rax, (%rbx)
movq (%r15), %rax
movq %rax, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_lexer_zaLexer_preparezeforzeargszx
static void mw_mirth_lexer_zaLexer_preparezeforzeargszx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_lexer_zaLexer* in_zaLexer_2, struct mirth_mirth_zaMirth* *out_zaMirth_3, struct mirth_lexer_zaLexer* *out_zaLexer_4) {
	uint64_t v5 = in_zaLexer_2->mlexerzelastzetoken;
	struct mirth_mirth_zaMirth* v6;
	bool v7 = mw_mirth_token_Token_canzetakezeargszy(in_zaMirth_1, v5, &v6);
	struct mirth_lexer_zaLexer* branch_zaLexer_8;
	struct mirth_mirth_zaMirth* branch_zaMirth_9;
	if (v7) {
		branch_zaMirth_9 = v6;
		branch_zaLexer_8 = in_zaLexer_2;
	} else {
		struct mirth_mirth_zaMirth* v10;
		struct mirth_lexer_zaLexer* v11;
		mw_mirth_lexer_zaLexer_closezecolonszx(v6, in_zaLexer_2, &v10, &v11);
		branch_zaMirth_9 = v10;
		branch_zaLexer_8 = v11;
	}
	*out_zaLexer_4 = branch_zaLexer_8;
	*out_zaMirth_3 = branch_zaMirth_9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq 0x40(%rsi), %rsi
leaq -0x30(%rbp), %rdx
callq 0x25235
testb %al, %al
je 0x7c52c
movq -0x30(%rbp), %rax
jmp 0x7c54e
movq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %r12
leaq -0x38(%rbp), %r13
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x7c278
movq (%r12), %rax
movq (%r13), %r15
movq %r15, (%r14)
movq %rax, (%rbx)
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: mw_mirth_lexer_zaLexer_preparezeforzeatomzx
static void mw_mirth_lexer_zaLexer_preparezeforzeatomzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_lexer_zaLexer* in_zaLexer_2, struct mirth_mirth_zaMirth* *out_zaMirth_3, struct mirth_lexer_zaLexer* *out_zaLexer_4) {
	uint64_t v5 = in_zaLexer_2->mlexerzelastzetoken;
	struct mirth_mirth_zaMirth* v6;
	bool v7 = mw_mirth_token_Token_lcolonzeopenzy(in_zaMirth_1, v5, &v6);
	struct mirth_lexer_zaLexer* branch_zaLexer_8;
	struct mirth_mirth_zaMirth* branch_zaMirth_9;
	if (v7) {
		branch_zaMirth_9 = v6;
		branch_zaLexer_8 = in_zaLexer_2;
	} else {
		struct mirth_mirth_zaMirth* v10;
		struct mirth_lexer_zaLexer* v11;
		mw_mirth_lexer_zaLexer_closezecolonszx(v6, in_zaLexer_2, &v10, &v11);
		branch_zaMirth_9 = v10;
		branch_zaLexer_8 = v11;
	}
	*out_zaLexer_4 = branch_zaLexer_8;
	*out_zaMirth_3 = branch_zaMirth_9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq 0x40(%rsi), %rsi
leaq -0x30(%rbp), %rdx
callq 0x7ddc5
testb %al, %al
je 0x7c594
movq -0x30(%rbp), %rax
jmp 0x7c5b6
movq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %r12
leaq -0x38(%rbp), %r13
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x7c278
movq (%r12), %rax
movq (%r13), %r15
movq %r15, (%r14)
movq %rax, (%rbx)
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: mw_mirth_token_Token_lcolonzeopenzy
static bool mw_mirth_token_Token_lcolonzeopenzy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct mirth_token_TokenValue v6 = mw_mirth_token_Token_value(in_zaMirth_1, in_Token_2, &v5);
	bool v7 = mw_mirth_token_TokenValue_lcolonzeopenzy(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), %rdx
callq 0x252f3
movl %eax, %r14d
cmpl $0x5, %eax
je 0x7de1a
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x7de1a
decl (%rax)
jne 0x7de1a
movq %r14, %rdi
shlq $0x30, %rdi
orq %rdx, %rdi
leaq 0x8b0c4(%rip), %rsi     # 0x108ed9
callq 0xce94
cmpl $0x5, %r14d
sete %al
movq -0x18(%rbp), %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_lexer_zaLexer_makezx
static uint64_t mw_mirth_lexer_zaLexer_makezx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_lexer_zaLexer* in_zaLexer_2, struct mirth_token_TokenValue in_TokenValue_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_lexer_zaLexer* *out_zaLexer_5) {
	INT v7 = in_zaLexer_2->mlexerzerow;
	incref(MKINT(v7));
	INT v8 = in_zaLexer_2->mlexerzecol;
	incref(MKINT(v8));
	struct std_maybe_Maybe_1 v9 = in_zaLexer_2->mlexerzedoc;
	incref(MK_std_maybe_Maybe_1(v9));
	uint64_t v10 = in_zaLexer_2->mlexerzemodule;
	struct mirth_mirth_zaMirth* v11;
	uint64_t v12 = mw_mirth_token_Token_Makezx(in_zaMirth_1, in_TokenValue_3, v10, v7, v8, v9, &v11);
	struct std_maybe_Maybe_1 v13 = { .tag=std_maybe_Maybe_1_None };
	struct std_maybe_Maybe_1 v14 = in_zaLexer_2->mlexerzedoc;
	decref(MK_std_maybe_Maybe_1(v14));
	in_zaLexer_2->mlexerzedoc = v13;
	in_zaLexer_2->mlexerzelastzetoken = v12;
	*out_zaLexer_5 = in_zaLexer_2;
	*out_zaMirth_4 = v11;
	return v12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r14
movq %r8, -0x30(%rbp)
movq %rsi, %r15
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
movq 0x8(%rsi), %r8
movq %r8, %rax
andq %r13, %rax
sete %sil
testb $0x3, %r8b
setne %r9b
orb %sil, %r9b
jne 0x7de73
incl (%rax)
movq 0x10(%r15), %r9
movq %r9, %rax
andq %r13, %rax
sete %sil
testb $0x3, %r9b
setne %r10b
orb %sil, %r10b
jne 0x7de90
incl (%rax)
movups 0x18(%r15), %xmm0
movaps %xmm0, -0x50(%rbp)
movq -0x48(%rbp), %rsi
movq %rsi, %rax
andq %r13, %rax
sete %r10b
testb $0x3, %sil
setne %sil
orb %r10b, %sil
jne 0x7deb6
incl (%rax)
leaq 0x18(%r15), %rbx
movq (%r15), %rax
movaps -0x50(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq -0x38(%rbp), %rsi
movq %rsi, 0x10(%rsp)
movl %edx, %esi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x5035d
movq %rax, %r12
movq 0x20(%r15), %rax
andq %rax, %r13
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0x7df0e
movl 0x18(%r15), %edi
decl (%r13)
jne 0x7df0e
leaq 0x8a3bf(%rip), %rsi     # 0x1082c1
shlq $0x30, %rdi
orq %rax, %rdi
callq 0xce94
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %r12, 0x40(%r15)
movq %r15, (%r14)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
movq %r12, %rax
addq $0x48, %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_mirth_lexer_zaLexer_stackzepopzx
static struct std_maybe_Maybe_1 mw_mirth_lexer_zaLexer_stackzepopzx (struct mirth_lexer_zaLexer* in_zaLexer_1, struct mirth_lexer_zaLexer* *out_zaLexer_2) {
	struct std_list_List_1 v4 = in_zaLexer_1->mlexerzestack;
	incref(MK_std_list_List_1(v4));
	struct std_list_List_1 v5;
	struct std_maybe_Maybe_1 v6 = mw_std_list_List_1_uncons(v4, &v5);
	struct std_list_List_1 v7 = in_zaLexer_1->mlexerzestack;
	decref(MK_std_list_List_1(v7));
	in_zaLexer_1->mlexerzestack = v5;
	*out_zaLexer_2 = in_zaLexer_1;
	return v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movl 0x28(%rdi), %edi
movq 0x30(%r14), %rsi
movq %rsi, %rax
andq %rbx, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x7df77
incl (%rax)
leaq 0x28(%r14), %r13
leaq -0x40(%rbp), %rdx
callq 0x1075d
movl %eax, %r15d
movq %rdx, %r12
movq 0x30(%r14), %rax
andq %rax, %rbx
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0x7dfb8
movl 0x28(%r14), %edi
decl (%rbx)
jne 0x7dfb8
leaq 0x8a2cd(%rip), %rsi     # 0x108279
shlq $0x30, %rdi
orq %rax, %rdi
callq 0xce94
movups -0x40(%rbp), %xmm0
movups %xmm0, (%r13)
movq -0x30(%rbp), %rax
movq %r14, (%rax)
movl %r15d, %eax
movq %r12, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq