LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x28(%rbp), %rdx
callq 0x3176f
cmpl $0x1, %eax
jne 0x7bdf9
movq %rdx, %rdi
callq 0xdaeb
movq %rax, %r15
movq %rdx, %r14
testb $0x1, %r14b
je 0x7bdcb
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r15, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x7bdcb
incl (%rax)
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rdx
movq %r15, %rsi
callq 0x1f0c1
movl %eax, %eax
leaq 0x1(,%rax,2), %r12
movq %r12, %rdi
callq 0xe818
movzbl %al, %eax
cmpl $0x61, %eax
jae 0x7be01
xorl %eax, %eax
jmp 0x7be12
xorl %eax, %eax
movq -0x28(%rbp), %r12
jmp 0x7be61
movq %r12, %rdi
callq 0xe818
movzbl %al, %eax
cmpl $0x7b, %eax
setb %al
movq -0x30(%rbp), %r12
testb %al, %al
je 0x7be2c
movq %r15, %rdi
movq %r14, %rsi
callq 0x95f6
movl $0x1, %eax
jmp 0x7be63
testb $0x1, %r14b
je 0x7be5f
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
movq %r15, %rax
andq %rcx, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x7be5f
decl (%rax)
jne 0x7be5f
movq %r15, %rdi
movq %r14, %rsi
callq 0xd4e3
xorl %eax, %eax
xorl %edx, %edx
movq %r12, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 $0x28, %rsp
movq %r8, %r14
movq %rcx, -0x30(%rbp)
movq %rdx, %r15
movq %rdi, %r12
leaq -0x50(%rbp), %r13
movq %rsi, %rdi
movq %r13, %rsi
callq 0x44725
leaq -0x38(%rbp), %rbx
movq %r12, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1b861
movq (%rbx), %rdi
leaq -0x40(%rbp), %rbx
movq %rax, %rsi
movq %r15, %rdx
movl $0x2, %ecx
movq %rbx, %r8
callq 0x1bf3a
movq (%rbx), %rdi
movq (%r13), %rsi
leaq -0x38(%rbp), %r15
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
movq %r15, %r9
callq 0x44c4f
movq (%r15), %rdi
leaq -0x48(%rbp), %r15
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x557e2
movq (%r15), %rax
movq %rax, (%r14)
movq (%rbx), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
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_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
cmpq $0x0, 0x109adb2(%rip)   # 0x111a7e0
jne 0x7fa4d
movl $0x1, %edi
callq 0xf9f7
movq $0x1, 0x10(%rax)
movb $0xa, 0x18(%rax)
movq %rax, 0x109ad93(%rip)   # 0x111a7e0
movq 0x109ad8c(%rip), %rsi   # 0x111a7e0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x7fa71
incl (%rax)
movq %rbx, %rdi
callq 0xe43c
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x947d
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x1095872(%rip)   # 0x111a520
jne 0x84ccd
movl $0x1, %edi
callq 0xf9f7
movq $0x1, 0x10(%rax)
movb $0x2f, 0x18(%rax)
movq %rax, 0x1095853(%rip)   # 0x111a520
movq 0x109584c(%rip), %rcx   # 0x111a520
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rcx, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x84cf0
incl (%rax)
leaq 0x90462(%rip), %rsi     # 0x115159
movq 0x1095822(%rip), %rdi   # 0x111a520
callq 0x942c
movq %r14, %rdi
movq %rax, %rsi
callq 0xe43c
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xe43c
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %ecx
xorl %edi, %edi
xorl %esi, %esi
callq 0x157ee
leaq -0x20(%rbp), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x1973b
testl %eax, %eax
je 0x84d7d
cmpl $0x1, %eax
jne 0x84d92
movq %rdx, %rdi
callq 0xdaeb
movabsq $0xfffffffffffc, %rsi   # imm = 0xFFFFFFFFFFFC
andq %rax, %rsi
movq %rax, %rdi
shrq $0x30, %rdi
callq 0x309af
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
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0x5f9a2(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0x5f9a7(%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_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 0x109326c(%rip), %r14   # 0x1118498
incq %r14
movq %r14, 0x1093262(%rip)   # 0x1118498
leaq 0x10932a3(%rip), %rdi   # 0x11184e0
movq %r14, %rsi
callq 0x13ff0
leaq 0x904ac(%rip), %rsi     # 0x1156f8
movq %rbx, %rdi
movq %rax, %rdx
callq 0x14ab5
leaq 0x1093292(%rip), %rdi   # 0x11184f0
movq %r14, %rsi
callq 0x13ff0
shlq $0x30, %r12
orq %r13, %r12
leaq 0x9004d(%rip), %rsi     # 0x1152c1
movq %r12, %rdi
movq %rax, %rdx
callq 0x14ab5
movq %r14, %rdi
callq 0x137c4
leaq -0x38(%rbp), %rbx
movq %r15, %rdi
movl $0x2, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x13817
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_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %eax
leaq 0x1(,%rax,2), %rdi
callq 0xe818
movq %rax, %r14
shrb $0x4, %al
cmpb $-0x60, %r14b
movl $0x37, %r12d
movl $0x30, %r13d
movl $0x30, %ecx
cmovael %r12d, %ecx
addb %al, %cl
movzbl %cl, %edi
callq 0xe7a9
movq %rax, %rdi
callq 0xe818
movq %rax, %r15
andb $0xf, %r14b
cmpb $0xa, %r14b
cmovael %r12d, %r13d
addb %r14b, %r13b
movzbl %r13b, %edi
callq 0xe7a9
movq %rax, %rdi
callq 0xe818
movl %eax, (%rbx)
movl %r15d, %eax
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: 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 0x858f1
incl (%rax)
callq 0xe740
movq %rax, %rdi
callq 0xe7a9
movq 0x50(%r14), %rsi
andq %rsi, %r15
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x85916
incl (%r15)
movq %rax, %rdi
callq 0xec04
testl %eax, %eax
setle %al
movq %r14, (%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_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 0x85964
incl (%rcx)
movq 0x48(%r14), %rsi
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x8597b
incl (%rax)
callq 0xea6e
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_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 0x8fa78(%rip), %r15     # 0x115429
movq %rdi, %rax
andq %r13, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x859d1
decl (%rax)
jne 0x859d1
movq %r15, %rsi
callq 0xd4e3
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 0x859f3
incl (%rax)
movl $0x3, %esi
callq 0xe8e2
movq %rax, %r12
movq 0x8(%r14), %rdi
andq %rdi, %r13
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x85a23
decl (%r13)
jne 0x85a23
movq %r15, %rsi
callq 0xd4e3
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_O1/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 0x85a71
incl (%rax)
leaq 0x8f9b1(%rip), %r15     # 0x115429
movl $0x3, %esi
callq 0xe8e2
movq %rax, %r12
movq 0x50(%r14), %rdi
movq %rdi, %rax
andq %r13, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x85aa9
decl (%rax)
jne 0x85aa9
movq %r15, %rsi
callq 0xd4e3
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 0x85ac7
incl (%rax)
movl $0x3, %esi
callq 0xe8e2
movq %rax, %r12
movq 0x10(%r14), %rdi
andq %rdi, %r13
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x85af7
decl (%r13)
jne 0x85af7
movq %r15, %rsi
callq 0xd4e3
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_O1/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 0x28356
testb %al, %al
je 0x85e08
movq -0x30(%rbp), %rax
jmp 0x85e2a
movq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %r12
leaq -0x38(%rbp), %r13
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x85b0d
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_O1/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 0x88e9b
testb %al, %al
je 0x85e70
movq -0x30(%rbp), %rax
jmp 0x85e92
movq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %r12
leaq -0x38(%rbp), %r13
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x85b0d
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_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x1090535(%rip), %rdi   # 0x11193e8
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
movabsq $-0x1000000000000, %r15 # imm = 0xFFFF000000000000
andq %rax, %r15
movabsq $0x5000000000000, %r12  # imm = 0x5000000000000
cmpq %r12, %r15
je 0x88f02
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
je 0x88f02
decl (%rcx)
jne 0x88f02
andq $-0x4, %rax
leaq 0x8cfdf(%rip), %rsi     # 0x115ed9
movq %rax, %rdi
callq 0xd4e3
cmpq %r12, %r15
sete %al
movq %r14, (%rbx)
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_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 0x88f56
incl (%rax)
movq 0x10(%r15), %r9
movq %r9, %rax
andq %r13, %rax
sete %sil
testb $0x3, %r9b
setne %r10b
orb %sil, %r10b
jne 0x88f73
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 0x88f99
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 0x5618f
movq %rax, %r12
movq 0x20(%r15), %rax
andq %rax, %r13
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0x88ff1
movl 0x18(%r15), %edi
decl (%r13)
jne 0x88ff1
leaq 0x8c2dc(%rip), %rsi     # 0x1152c1
shlq $0x30, %rdi
orq %rax, %rdi
callq 0xd4e3
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_O1/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 0x8905a
incl (%rax)
leaq 0x28(%r14), %r13
leaq -0x40(%rbp), %rdx
callq 0x115ef
movl %eax, %r15d
movq %rdx, %r12
movq 0x30(%r14), %rax
andq %rax, %rbx
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0x8909b
movl 0x28(%r14), %edi
decl (%rbx)
jne 0x8909b
leaq 0x8c1ea(%rip), %rsi     # 0x115279
shlq $0x30, %rdi
orq %rax, %rdi
callq 0xd4e3
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
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_lexer_zaLexer_stackzepushzx
static void mw_mirth_lexer_zaLexer_stackzepushzx (struct mirth_lexer_zaLexer* in_zaLexer_1, uint64_t in_Token_2, struct mirth_lexer_zaLexer* *out_zaLexer_3) {
	struct std_list_List_1 v4 = in_zaLexer_1->mlexerzestack;
	incref(MK_std_list_List_1(v4));
	struct std_list_List_1 v5 = mw_std_list_List_1_cons(MK_mirth_token_Token(in_Token_2), v4);
	struct std_list_List_1 v6 = in_zaLexer_1->mlexerzestack;
	decref(MK_std_list_List_1(v6));
	in_zaLexer_1->mlexerzestack = v5;
	*out_zaLexer_3 = in_zaLexer_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
movl 0x28(%rdi), %edx
movq 0x30(%rdi), %rcx
movq %rcx, %rsi
andq %r12, %rsi
sete %dil
testb $0x3, %cl
setne %r8b
orb %dil, %r8b
jne 0x890fd
incl (%rsi)
leaq 0x8ccb4(%rip), %rsi     # 0x115db8
movq %rax, %rdi
callq 0xd592
movq %rdx, %r15
movq 0x30(%r14), %rax
andq %rax, %r12
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0x8913f
movl 0x28(%r14), %edi
decl (%r12)
jne 0x8913f
leaq 0x8c146(%rip), %rsi     # 0x115279
shlq $0x30, %rdi
orq %rax, %rdi
callq 0xd4e3
movl $0x1, 0x28(%r14)
movq %r15, 0x30(%r14)
movq %r14, (%rbx)
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_lexer_zaLexer_lexerzelocation
static struct mirth_location_Location* mw_mirth_lexer_zaLexer_lexerzelocation (struct mirth_lexer_zaLexer* in_zaLexer_1, struct mirth_lexer_zaLexer* *out_zaLexer_2) {
	uint64_t v4 = in_zaLexer_1->mlexerzemodule;
	INT v5 = in_zaLexer_1->mlexerzerow;
	incref(MKINT(v5));
	INT v6 = in_zaLexer_1->mlexerzecol;
	incref(MKINT(v6));
	struct mirth_location_Location* v7 = mtw_mirth_location_Location_Location(v4, v5, v6);
	*out_zaLexer_2 = in_zaLexer_1;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movq (%rdi), %rdi
movq 0x8(%r14), %rsi
movq %rsi, %rcx
andq %rax, %rcx
sete %dl
testb $0x3, %sil
setne %r8b
orb %dl, %r8b
jne 0x8918d
incl (%rcx)
movq 0x10(%r14), %rdx
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %r8b
orb %cl, %r8b
jne 0x891a5
incl (%rax)
callq 0x1ba48
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_maybe_Maybe_1_map_1_sp20
static struct std_maybe_Maybe_1 mw_std_maybe_Maybe_1_map_1_sp20 (struct std_maybe_Maybe_1 in_Maybe_1) {
	struct std_maybe_Maybe_1 branch_Maybe_3;
	switch ((in_Maybe_1).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v4 = mtp_std_maybe_Maybe_1_Some(in_Maybe_1);
			struct std_result_Result_2 v5 = mtw_std_result_Result_2_Ok(v4);
			struct std_maybe_Maybe_1 v6 = mtw_std_maybe_Maybe_1_Some(MK_std_result_Result_2(v5));
			branch_Maybe_3 = v6;
		} break;
		case std_maybe_Maybe_1_None: {
			struct std_maybe_Maybe_1 v7 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_3 = v7;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	return branch_Maybe_3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %edi, %edi
je 0x891ec
cmpl $0x1, %ebx
jne 0x891f7
movq %rsi, %rdi
callq 0xdaeb
movq %rax, %rdi
movq %rdx, %rsi
callq 0x10b13
movq %rdx, %rdi
btsq $0x30, %rdi
leaq 0x8da74(%rip), %rsi     # 0x116c59
callq 0x95f6
jmp 0x891ee
xorl %edx, %edx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0x5b53d(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0x5b542(%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_std_str_zaStr_dropzeslice
static STR* mw_std_str_zaStr_dropzeslice (STR* in_zaStr_1, INT in_Offset_2, STR* *out_zaStr_3) {
	INT v7 = WRAP_I63(0LL);
	incref(MKINT(in_Offset_2));
	incref(MKINT(v7));
	bool v8 = int_lt(in_Offset_2, v7);
	INT branch_Offset_9;
	if (v8) {
		decref(MKINT(in_Offset_2));
		branch_Offset_9 = v7;
	} else {
		decref(MKINT(v7));
		branch_Offset_9 = in_Offset_2;
	}
	incref(MKSTR(in_zaStr_1));
	uint64_t v10 = str_size(in_zaStr_1);
	INT v11 = u64_to_int(v10);
	STR* v12;
	STR* v13 = mw_std_str_zaStr_slice(in_zaStr_1, branch_Offset_9, v11, &v12);
	*out_zaStr_3 = v12;
	return v13;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, %r12
movq %rdi, -0x30(%rbp)
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
movq %rsi, %rbx
andq %r13, %rbx
sete %al
testb $0x3, %r12b
setne %r14b
orb %al, %r14b
jne 0x898e6
incl (%rbx)
movl $0x1, %r15d
movl $0x1, %esi
movq %r12, %rdi
callq 0xec04
testl %eax, %eax
setns %al
cmovnsq %r12, %r15
orb %al, %r14b
jne 0x89920
decl (%rbx)
jne 0x8991a
leaq 0x8bb17(%rip), %rsi     # 0x115429
movq %r12, %rdi
callq 0xd4e3
movl $0x1, %r15d
movq -0x30(%rbp), %rbx
andq %rbx, %r13
sete %al
testb $0x3, %bl
setne %cl
orb %al, %cl
jne 0x89938
incl (%r13)
movq %rbx, %rdi
callq 0xe740
movq %rax, %rdi
callq 0xe7a9
leaq -0x40(%rbp), %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r12, %rcx
callq 0xee48
movq (%r12), %rcx
movq -0x38(%rbp), %rdx
movq %rcx, (%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_lexer_zaLexer_intzesign
static INT mw_mirth_lexer_zaLexer_intzesign (STR* in_zaStr_1, struct mirth_lexer_zaLexer* in_zaLexer_2, STR* *out_zaStr_3, struct mirth_lexer_zaLexer* *out_zaLexer_4, INT *out_Int_6, INT *out_Offset_7) {
	INT v8 = WRAP_I63(0LL);
	STR* v9;
	enum std_byte_Byte v10 = mw_std_str_zaStr_bytezo(v8, in_zaStr_1, &v9);
	INT v11;
	INT v12;
	INT v13 = mw_mirth_lexer_zaLexer_bytezesignzevaluezeindex(v10, &v11, &v12);
	*out_Offset_7 = v12;
	*out_Int_6 = v11;
	*out_zaLexer_4 = in_zaLexer_2;
	*out_zaStr_3 = v9;
	return v13;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, -0x30(%rbp)
movq %rdi, %r13
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %r13b
setne %dl
orb %cl, %dl
jne 0x89a06
incl (%rax)
movl $0x1, %edi
movq %r13, %rsi
callq 0xea6e
cmpl $0x2d, %eax
je 0x89a29
cmpl $0x2b, %eax
jne 0x89a37
movl $0x3, %ecx
movl $0x3, %eax
jmp 0x89a41
movq $-0x1, %rax
movl $0x3, %ecx
jmp 0x89a41
movl $0x3, %eax
movl $0x1, %ecx
movq -0x30(%rbp), %rdx
movq %rcx, (%rbx)
movq $0x1, (%r12)
movq %rdx, (%r15)
movq %r13, (%r14)
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: mw_std_str_zaStr_lastzebyte
static enum std_byte_Byte mw_std_str_zaStr_lastzebyte (STR* in_zaStr_1, STR* *out_zaStr_3) {
	incref(MKSTR(in_zaStr_1));
	enum std_byte_Byte v4 = mw_std_prim_Str_lastzebyte(in_zaStr_1);
	*out_zaStr_3 = in_zaStr_1;
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x8a935
addl $0x2, (%rax)
movq %r14, %rdi
callq 0xe740
movq %rax, %rdi
callq 0xe7a9
movl $0x3, %esi
movq %rax, %rdi
callq 0xedca
movq %rax, %rdi
movq %r14, %rsi
callq 0xea6e
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_prelude_unsafe_1_sp17
static STR* mw_std_prelude_unsafe_1_sp17 (STR* in_zaStr_1, STR* *out_zaStr_2) {
	STR* v4;
	STR* v5 = mw_std_str_zaStr_dropzelastzebyte(in_zaStr_1, &v4);
	*out_zaStr_2 = v4;
	return v5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x8a992
incl (%rax)
movq %r14, %rdi
callq 0xe740
movq %rax, %rdi
callq 0xe7a9
movl $0x3, %esi
movq %rax, %rdi
callq 0xedca
leaq -0x20(%rbp), %r15
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xee48
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_modulezeimportzy
static bool mw_mirth_token_Token_modulezeimportzy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct mirth_token_TokenValue v6 = mw_mirth_token_Token_value(in_zaMirth_1, in_Token_2, &v5);
	struct mirth_mirth_zaMirth* v7;
	bool v8 = mw_mirth_token_TokenValue_modulezeimportzy(v5, v6, &v7);
	*out_zaMirth_3 = v7;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %r12   # imm = 0xFFFFFFFFFFFC
leaq 0x108e5e1(%rip), %rdi   # 0x11193e8
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
movq %rax, %rdi
shrq $0x30, %rdi
andq %r12, %rax
movq %rax, %rsi
callq 0x3196d
cmpl $0x1, %eax
jne 0x8aeb7
movq %rdx, %rdi
callq 0xdaeb
leaq 0x108d68a(%rip), %rdi   # 0x11184c8
movq %rax, %rsi
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
movq %rax, %rdi
movq %rdx, %rsi
callq 0x942c
movq %rax, %r15
cmpq $0x0, 0x108f8ec(%rip)   # 0x111a750
jne 0x8ae8c
movl $0x6, %edi
callq 0xf9f7
movq $0x6, 0x10(%rax)
movl $0x6f706d69, 0x18(%rax) # imm = 0x6F706D69
movw $0x7472, 0x1c(%rax)     # imm = 0x7472
movq %rax, 0x108f8c4(%rip)   # 0x111a750
movq 0x108f8bd(%rip), %rsi   # 0x111a750
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x8aea8
incl (%r12)
movq %r15, %rdi
callq 0xe2eb
testl %eax, %eax
sete %al
jmp 0x8aeb9
xorl %eax, %eax
movq %r14, (%rbx)
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_std_maybe_Maybe_1_map_1_sp19
static STR* mw_std_maybe_Maybe_1_map_1_sp19 (STR* in_Str_1, struct std_maybe_Maybe_1 in_Maybe_2, struct std_maybe_Maybe_1 *out_Maybe_4) {
	STR* branch_Str_5;
	struct std_maybe_Maybe_1 branch_Maybe_6;
	switch ((in_Maybe_2).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v7 = mtp_std_maybe_Maybe_1_Some(in_Maybe_2);
			incref(v7);
			incref(MKSTR(in_Str_1));
			INT v8 = WRAP_I63(1LL);
			INT v9 = v8;
			INT v10 = int_add(value_int(v7), v9);
			STR* v11 = mw_std_prim_Str_dropzeslice(v10, in_Str_1);
			STR* v12 = mw_std_prim_Str_takezeslice(value_int(v7), in_Str_1);
			struct std_maybe_Maybe_1 v13 = mtw_std_maybe_Maybe_1_Some(MKSTR(v11));
			branch_Maybe_6 = v13;
			branch_Str_5 = v12;
		} break;
		case std_maybe_Maybe_1_None: {
			struct std_maybe_Maybe_1 v14 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_6 = v14;
			branch_Str_5 = in_Str_1;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_Maybe_4 = branch_Maybe_6;
	return branch_Str_5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %esi, %r13d
movq %rdi, %r15
testl %esi, %esi
je 0x8b7c4
cmpl $0x1, %r13d
jne 0x8b7e6
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
movq %rdx, %rdi
callq 0xdaeb
movq %rax, %r12
testb $0x1, %dl
je 0x8b6f0
movq %r12, %rax
andq %r14, %rax
sete %cl
testb $0x3, %r12b
setne %sil
orb %cl, %sil
jne 0x8b6f0
incl (%rax)
movl %r13d, -0x2c(%rbp)
movq %r15, %rax
andq %r14, %rax
sete %cl
testb $0x3, %r15b
setne %sil
orb %cl, %sil
jne 0x8b70c
incl (%rax)
movq %r12, %rdi
movq %rdx, -0x40(%rbp)
movq %rdx, %rsi
callq 0x10db8
movl $0x3, %esi
movq %r12, %rdi
callq 0xe8e2
leaq -0x48(%rbp), %r13
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x898a8
movq %rax, -0x38(%rbp)
movq (%r13), %rdi
movq %rdi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x8b766
decl (%rax)
jne 0x8b766
leaq 0x899f8(%rip), %rsi     # 0x115159
callq 0xd4e3
movq %r12, %rdi
movq -0x40(%rbp), %rsi
callq 0x10db8
movl $0x1, %esi
movq %r15, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0xee48
movq %rax, %r15
movq (%r13), %rdi
andq %rdi, %r14
sete %al
testb $0x3, %dil
setne %cl
orb %al, %cl
jne 0x8b7ae
decl (%r14)
jne 0x8b7ae
leaq 0x899b0(%rip), %rsi     # 0x115159
callq 0xd4e3
movq -0x38(%rbp), %rdi
leaq 0x899a0(%rip), %rsi     # 0x115159
callq 0x95f6
movl -0x2c(%rbp), %r13d
jmp 0x8b7c6
xorl %edx, %edx
movl %r13d, (%rbx)
movl $0x0, 0x4(%rbx)
movq %rdx, 0x8(%rbx)
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0x58f4e(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0x58f53(%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: mirth_arrow_Atom_set_op
static struct mirth_arrow_Atom* mirth_arrow_Atom_set_op(struct mirth_arrow_Atom* self, struct mirth_arrow_Op x) {
	if (self->refs > 1) {
		struct mirth_arrow_Atom* self2 = calloc(1, sizeof * self2);
		ASSERT(self2); memcpy(self2, self, sizeof * self2);
		incref(MK_mirth_arrow_Home(self2->mhome));
		incref(MK_std_list_List_1(self2->mctx));
		self2->mop = x;
		incref(MK_std_list_List_1(self2->margs));
		incref(MK_mirth_type_StackType(self2->mdom));
		incref(MK_mirth_type_StackType(self2->mcod));
		incref(MK_std_list_List_1(self2->msubst));
		self->refs--;
		return self2;
	}
	decref(MK_mirth_arrow_Op(self->mop));
	self->mop = x;
	return self;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0x2, (%rdi)
jb 0x8d4d7
movl $0x1, %edi
movl $0x80, %esi
callq 0x50c0
testq %rax, %rax
je 0x8d526
movabsq $0xfffffffffffc, %rdx   # imm = 0xFFFFFFFFFFFC
movl $0x10, %ecx
movq %rax, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x10(%rax), %rsi
movq %rsi, %rcx
andq %rdx, %rcx
sete %dil
testb $0x3, %sil
setne %sil
orb %dil, %sil
jne 0x8d43c
incl (%rcx)
movq 0x28(%rax), %rsi
movq %rsi, %rcx
andq %rdx, %rcx
sete %dil
testb $0x3, %sil
setne %sil
orb %dil, %sil
jne 0x8d459
incl (%rcx)
movl %r15d, 0x30(%rax)
movq %r14, 0x38(%rax)
movq 0x48(%rax), %rsi
movq %rsi, %rcx
andq %rdx, %rcx
sete %dil
testb $0x3, %sil
setne %sil
orb %dil, %sil
jne 0x8d47e
incl (%rcx)
movq 0x58(%rax), %rsi
movq %rsi, %rcx
andq %rdx, %rcx
sete %dil
testb $0x3, %sil
setne %sil
orb %dil, %sil
jne 0x8d49b
incl (%rcx)
movq 0x68(%rax), %rsi
movq %rsi, %rcx
andq %rdx, %rcx
sete %dil
testb $0x3, %sil
setne %sil
orb %dil, %sil
jne 0x8d4b8
incl (%rcx)
movq 0x78(%rax), %rcx
andq %rcx, %rdx
sete %sil
testb $0x3, %cl
setne %cl
orb %sil, %cl
jne 0x8d4d0
incl (%rdx)
decl (%rbx)
movq %rax, %rbx
jmp 0x8d518
movq 0x38(%rbx), %rcx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rcx, %rax
sete %dl
testb $0x3, %cl
setne %cl
orb %dl, %cl
jne 0x8d510
decl (%rax)
jne 0x8d510
leaq 0x89249(%rip), %rsi     # 0x116749
movl 0x30(%rbx), %edi
shlq $0x30, %rdi
orq 0x38(%rbx), %rdi
callq 0xd4e3
movl %r15d, 0x30(%rbx)
movq %r14, 0x38(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5fce6(%rip), %rsi     # 0xed213
movl $0x33, %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_specializzer_zaSPCheck_pushzecheckzeblockzx
static void mw_mirth_specializzer_zaSPCheck_pushzecheckzeblockzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct std_list_List_1 in_zaSPCheck_2, uint64_t in_Block_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct std_list_List_1 *out_zaSPCheck_5) {
	struct mirth_specializzer_SPCheckItem v6 = mtw_mirth_specializzer_SPCheckItem_Block(in_Block_3);
	struct mirth_mirth_zaMirth* v7;
	struct std_list_List_1 v8;
	mw_mirth_specializzer_zaSPCheck_pushzecheckzeitemzx(in_zaMirth_1, in_zaSPCheck_2, v6, &v7, &v8);
	*out_zaSPCheck_5 = v8;
	*out_zaMirth_4 = v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x8d5d7
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
leaq -0x50(%rbp), %r14
movq %r14, (%rsp)
leaq -0x40(%rbp), %rbx
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl $0x1, %ecx
movq %rax, %r8
movq %rbx, %r9
callq 0x8d803
movups (%r14), %xmm0
movq -0x30(%rbp), %rax
movups %xmm0, (%rax)
movq (%rbx), %rax
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5fc9d(%rip), %rsi     # 0xed27b
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_list_List_1_for_1_sp91
static void mw_std_list_List_1_for_1_sp91 (struct mirth_mirth_zaMirth* in_zaMirth_1, struct std_list_List_1 in_zaSPCheck_2, struct std_list_List_1 in_List_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct std_list_List_1 *out_zaSPCheck_5) {
	bool v6 = true;
	struct mirth_mirth_zaMirth* r7 = in_zaMirth_1;
	struct std_list_List_1 r8 = in_zaSPCheck_2;
	struct std_list_List_1 v9 = in_List_3;
	bool v10 = v6;
	bool v11 = v6;
	while (v11) {
		struct mirth_mirth_zaMirth* r12 = r7;
		struct std_list_List_1 r13 = r8;
		struct std_list_List_1 v14 = v9;
		bool v15 = v10;
		struct mirth_mirth_zaMirth* branch_zaMirth_16;
		struct std_list_List_1 branch_zaSPCheck_17;
		struct std_list_List_1 branch_List_18;
		bool branch_Bool_19;
		switch ((v14).tag) {
			case std_list_List_1_Cons: {
				struct std_list_List_1 v20;
				VAL v21 = mtp_std_list_List_1_Cons(v14, &v20);
				struct mirth_mirth_zaMirth* v22;
				struct std_list_List_1 v23;
				mw_mirth_specializzer_zaSPCheck_checkzeargzx(r12, r13, V_mirth_arrow_Block(v21), &v22, &v23);
				bool v24 = true;
				branch_Bool_19 = v24;
				branch_List_18 = v20;
				branch_zaSPCheck_17 = v23;
				branch_zaMirth_16 = v22;
			} break;
			case std_list_List_1_Nil: {
				struct std_list_List_1 v25 = { .tag=std_list_List_1_Nil };
				bool v26 = false;
				branch_Bool_19 = v26;
				branch_List_18 = v25;
				branch_zaSPCheck_17 = r13;
				branch_zaMirth_16 = r12;
			} break;
			default: {
				do_panic(str_make("unexpected fallthrough in match\n", 32));
			}
		}
		v11 = branch_Bool_19;
		v10 = branch_Bool_19;
		v9 = branch_List_18;
		r8 = branch_zaSPCheck_17;
		r7 = branch_zaMirth_16;
	}
	decref(MK_std_list_List_1(v9));
	*out_zaSPCheck_5 = r8;
	*out_zaMirth_4 = r7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, -0x30(%rbp)
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
leaq -0x40(%rbp), %r13
testl %ecx, %ecx
je 0x8d669
cmpl $0x1, %ecx
jne 0x8d6cd
movq %r8, %rdi
leaq -0x58(%rbp), %rsi
callq 0xd450
movq %r12, %rdi
movl %r15d, %esi
movq %r14, %rdx
movq %rax, %rcx
leaq -0x48(%rbp), %r8
movq %r13, %r9
callq 0x8d54b
movl -0x40(%rbp), %r15d
movl -0x3c(%rbp), %ebx
movq -0x38(%rbp), %r14
movq -0x48(%rbp), %r12
movl -0x58(%rbp), %ecx
movq -0x50(%rbp), %r8
movb $0x1, %al
jmp 0x8d66e
xorl %eax, %eax
xorl %r8d, %r8d
testb %al, %al
jne 0x8d61e
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r8, %rax
sete %dl
testb $0x3, %r8b
setne %sil
orb %dl, %sil
jne 0x8d6a9
decl (%rax)
jne 0x8d6a9
shlq $0x30, %rcx
orq %r8, %rcx
leaq 0x87bd8(%rip), %rsi     # 0x115279
movq %rcx, %rdi
callq 0xd4e3
movq 0x10(%rbp), %rax
movl %r15d, (%rax)
movl %ebx, 0x4(%rax)
movq %r14, 0x8(%rax)
movq -0x30(%rbp), %rax
movq %r12, (%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0x57067(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0x5706c(%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_specializzer_zaSPCheck_pushzecheckzewordzx
static void mw_mirth_specializzer_zaSPCheck_pushzecheckzewordzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct std_list_List_1 in_zaSPCheck_2, uint64_t in_Word_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct std_list_List_1 *out_zaSPCheck_5) {
	struct mirth_specializzer_SPCheckItem v6 = mtw_mirth_specializzer_SPCheckItem_Word(in_Word_3);
	struct mirth_mirth_zaMirth* v7;
	struct std_list_List_1 v8;
	mw_mirth_specializzer_zaSPCheck_pushzecheckzeitemzx(in_zaMirth_1, in_zaSPCheck_2, v6, &v7, &v8);
	*out_zaSPCheck_5 = v8;
	*out_zaMirth_4 = v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x8d786
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
leaq -0x50(%rbp), %r14
movq %r14, (%rsp)
leaq -0x40(%rbp), %rbx
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
xorl %ecx, %ecx
movq %rax, %r8
movq %rbx, %r9
callq 0x8d803
movups (%r14), %xmm0
movq -0x30(%rbp), %rax
movups %xmm0, (%rax)
movq (%rbx), %rax
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5f8cd(%rip), %rsi     # 0xed05a
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_mirth_var_Var_iszephysicalzy
static bool mw_mirth_var_Var_iszephysicalzy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Var_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct mirth_type_Type v6 = mw_mirth_var_Var_type(in_zaMirth_1, in_Var_2, &v5);
	struct mirth_mirth_zaMirth* v7;
	bool v8 = mw_mirth_type_Type_iszephysicalzy(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 0x108b82e(%rip), %rdi   # 0x1118ff0
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
movabsq $0xfffffffffffc, %rdx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdx
movq %rax, %rsi
shrq $0x30, %rsi
leaq -0x20(%rbp), %r15
movq %r14, %rdi
movq %r15, %rcx
callq 0x8e763
movq (%r15), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq