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_argsza
static struct std_list_Nest_1* mw_mirth_token_Token_argsza (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_list_List_1 v6 = mw_mirth_token_Token_args(in_zaMirth_1, in_Token_2, &v5);
	struct std_maybe_Maybe_1 v7 = mw_std_list_List_1_zgNestzy(v6);
	struct mirth_mirth_zaMirth* branch_zaMirth_8;
	uint64_t branch_Token_9;
	VAL branch_zux1_10;
	switch ((v7).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v11 = mtp_std_maybe_Maybe_1_Some(v7);
			branch_zux1_10 = v11;
			branch_Token_9 = in_Token_2;
			branch_zaMirth_8 = v5;
		} break;
		case std_maybe_Maybe_1_None: {
			STR* v12;
			STRLIT(v12, "expected 1 or more args, got none", 33);
			mw_mirth_mirth_zaMirth_emitzefatalzeerrorzx(v5, in_Token_2, v12);
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_3 = branch_zaMirth_8;
	return V_std_list_Nest_1(branch_zux1_10);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
leaq -0x18(%rbp), %rdx
callq 0x330da
movl %eax, %edi
movq %rdx, %rsi
callq 0x2d76b
cmpl $0x1, %eax
jne 0x34f8c
movq %rdx, %rdi
callq 0xdaeb
movq -0x18(%rbp), %rcx
movq %rcx, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
testl %eax, %eax
jne 0x34ffe
cmpq $0x0, 0x10e4768(%rip)   # 0x1119700
jne 0x34fcd
movl $0x21, %edi
callq 0xf9f7
movq $0x21, 0x10(%rax)
movups 0xb3c23(%rip), %xmm0    # 0xe8bd6
movups %xmm0, 0x18(%rax)
movups 0xb3c28(%rip), %xmm0    # 0xe8be6
movups %xmm0, 0x28(%rax)
movb $0x65, 0x38(%rax)
movq %rax, 0x10e4733(%rip)   # 0x1119700
movq 0x10e472c(%rip), %rdx   # 0x1119700
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0x34ff2
incl (%rax)
movq -0x18(%rbp), %rdi
movq %rbx, %rsi
callq 0x2778c
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0xaf736(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0xaf73b(%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_maybe_Maybe_1_unwrap_1_sp3
static VAL mw_std_maybe_Maybe_1_unwrap_1_sp3 (struct std_maybe_Maybe_1 in_Maybe_1) {
	VAL branch_zux1_3;
	switch ((in_Maybe_1).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v4 = mtp_std_maybe_Maybe_1_Some(in_Maybe_1);
			branch_zux1_3 = v4;
		} break;
		case std_maybe_Maybe_1_None: {
			mw_std_prelude_impossiblezx();
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	return branch_zux1_3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1, %edi
jne 0x35040
movq %rsi, %rdi
popq %rbp
jmp 0xdaeb
testl %edi, %edi
jne 0x35049
callq 0x30531
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0xaf6eb(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0xaf6f0(%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_token_Token_runzetokens
static struct std_list_List_1 mw_mirth_token_Token_runzetokens (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct std_list_List_1 v5 = { .tag=std_list_List_1_Nil };
	struct std_list_List_1 v6;
	mw_std_list_List_1_buildzx(v5, &v6);
	struct mirth_mirth_zaMirth* v7;
	bool v8 = mw_mirth_token_Token_runzeendzy(in_zaMirth_1, in_Token_2, &v7);
	bool v9 = !v8;
	uint64_t v10 = in_Token_2;
	struct mirth_mirth_zaMirth* r11 = v7;
	struct std_list_List_1 r12 = v6;
	bool v13 = v9;
	while (v13) {
		uint64_t v14 = v10;
		struct mirth_mirth_zaMirth* r15 = r11;
		struct std_list_List_1 r16 = r12;
		struct mirth_mirth_zaMirth* v17;
		uint64_t v18 = mw_mirth_token_Token_next(r15, v14, &v17);
		struct std_list_List_1 v19;
		mw_std_list_zaLister_1_pushzx(MK_mirth_token_Token(v14), r16, &v19);
		struct mirth_mirth_zaMirth* v20;
		bool v21 = mw_mirth_token_Token_runzeendzy(v17, v18, &v20);
		bool v22 = !v21;
		v13 = v22;
		r12 = v19;
		r11 = v20;
		v10 = v18;
	}
	struct std_list_List_1 v23 = mw_std_list_zaLister_1_donezx(r12);
	*out_zaMirth_3 = r11;
	return v23;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r13
movq %rdi, %rbx
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xd37c
movl %eax, %r14d
movq %rdx, %r15
leaq -0x58(%rbp), %r12
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x3540e
movq (%r12), %rbx
testb %al, %al
jne 0x35310
movq %rbx, %rdi
movq %r13, %rsi
leaq -0x40(%rbp), %rdx
callq 0x28928
movq %rax, %r12
movq %r13, %rdi
leaq 0xe0ad8(%rip), %rsi     # 0x115db8
movl %r14d, %edx
movq %r15, %rcx
leaq -0x50(%rbp), %r8
callq 0x9741
movq -0x40(%rbp), %rdi
movq %r12, %rsi
leaq -0x38(%rbp), %rdx
callq 0x3540e
movl -0x50(%rbp), %r14d
movq -0x48(%rbp), %r15
movq -0x38(%rbp), %rbx
movq %r12, %r13
jmp 0x352c0
xorl %edi, %edi
xorl %esi, %esi
movl %r14d, %edx
movq %r15, %rcx
callq 0xd37c
movq -0x30(%rbp), %rcx
movq %rbx, (%rcx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_token_Token_arrowzy
static bool mw_mirth_token_Token_arrowzy (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_arrowzy(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 0x10e4091(%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 0x35400
movq %rdx, %rdi
callq 0xdaeb
leaq 0x10e313a(%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, 0x10e4354(%rip)   # 0x1119708
jne 0x353d5
movl $0x2, %edi
callq 0xf9f7
movq $0x2, 0x10(%rax)
movw $0x3e2d, 0x18(%rax)     # imm = 0x3E2D
movq %rax, 0x10e4333(%rip)   # 0x1119708
movq 0x10e432c(%rip), %rsi   # 0x1119708
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x353f1
incl (%r12)
movq %r15, %rdi
callq 0xe2eb
testl %eax, %eax
sete %al
jmp 0x35402
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_mirth_elab_zaTypeElab_rdrop
static void mw_mirth_elab_zaTypeElab_rdrop (struct mirth_elab_zaTypeElab* in_zaTypeElab_1) {
	struct std_list_List_1 v2;
	uint64_t v3;
	bool v4;
	bool v5;
	mtp_mirth_elab_zaTypeElab_zaTypeElab(in_zaTypeElab_1, &v2, &v3, &v4, &v5);
	decref(MK_std_list_List_1(v2));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %r14
movl (%rdi), %ebx
callq 0x5030
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r14, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x3594d
decl (%rax)
je 0x35952
popq %rbx
popq %r14
popq %rbp
retq
shlq $0x30, %rbx
orq %r14, %rbx
leaq 0xdf919(%rip), %rsi     # 0x115279
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xd4e3
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_arrow_Arrow_ctxzetype
static struct std_list_List_1 mw_mirth_arrow_Arrow_ctxzetype (struct mirth_arrow_Arrow* in_Arrow_1, struct mirth_type_ArrowType* *out_ArrowType_3) {
	incref(MK_mirth_arrow_Arrow(in_Arrow_1));
	struct std_list_List_1 v4 = in_Arrow_1->mctx;
	incref(MK_std_list_List_1(v4));
	decref(MK_mirth_arrow_Arrow(in_Arrow_1));
	struct mirth_type_ArrowType* v5 = mw_mirth_arrow_Arrow_type(in_Arrow_1);
	*out_ArrowType_3 = v5;
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
movq %rdi, %rax
andq %rcx, %rax
setne %sil
testb $0x3, %r14b
sete %dl
andb %sil, %dl
cmpb $0x1, %dl
jne 0x359a2
incl (%rax)
movl 0x28(%r14), %r15d
movq 0x30(%r14), %r12
andq %r12, %rcx
sete %sil
testb $0x3, %r12b
setne %dil
orb %sil, %dil
jne 0x359c0
incl (%rcx)
testb %dl, %dl
je 0x359d7
decl (%rax)
jne 0x359d7
leaq 0xe09d2(%rip), %rsi     # 0x1163a1
movq %r14, %rdi
callq 0xd4e3
movq %r14, %rdi
callq 0x3c0f7
movq %rax, (%rbx)
movl %r15d, %eax
movq %r12, %rdx
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: mtw_mirth_elab_zaTypeElab_zaTypeElab
static void mtw_mirth_elab_zaTypeElab_zaTypeElab (struct std_list_List_1 in_Ctx_1, uint64_t in_Token_2, bool in_Bool_3, bool in_Bool_4, struct mirth_elab_zaTypeElab* *out_zaTypeElab_5) {
	struct mirth_elab_zaTypeElab* v6 = calloc(1, sizeof *v6);
	ASSERT(v6);
	v6->mallowzeimplicitzetypezevars = in_Bool_4;
	v6->mallowzetypezeholes = in_Bool_3;
	v6->mtoken = in_Token_2;
	v6->mctx = in_Ctx_1;
	*out_zaTypeElab_5 = v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, -0x30(%rbp)
movl %r8d, %r13d
movl %ecx, %r12d
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebx
movl $0x1, %edi
movl $0x20, %esi
callq 0x50c0
testq %rax, %rax
je 0x35a4d
movb %r13b, 0x19(%rax)
movb %r12b, 0x18(%rax)
movq %r15, 0x10(%rax)
movl %ebx, (%rax)
movq %r14, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb326c(%rip), %rsi     # 0xe8cc0
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_token_Token_vdashzy
static bool mw_mirth_token_Token_vdashzy (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_vdashzy(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 0x10e3404(%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 0x3608d
movq %rdx, %rdi
callq 0xdaeb
leaq 0x10e24ad(%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, 0x10e3987(%rip)   # 0x11199c8
jne 0x36062
movl $0x2, %edi
callq 0xf9f7
movq $0x2, 0x10(%rax)
movw $0x2d7c, 0x18(%rax)     # imm = 0x2D7C
movq %rax, 0x10e3966(%rip)   # 0x11199c8
movq 0x10e395f(%rip), %rsi   # 0x11199c8
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x3607e
incl (%r12)
movq %r15, %rdi
callq 0xe2eb
testl %eax, %eax
sete %al
jmp 0x3608f
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_mirth_token_Token_sigzedasheszy
static bool mw_mirth_token_Token_sigzedasheszy (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_sigzedasheszy(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 0x10e332b(%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 0x36166
movq %rdx, %rdi
callq 0xdaeb
leaq 0x10e23d4(%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, 0x10e38b6(%rip)   # 0x11199d0
jne 0x3613b
movl $0x2, %edi
callq 0xf9f7
movq $0x2, 0x10(%rax)
movw $0x2d2d, 0x18(%rax)     # imm = 0x2D2D
movq %rax, 0x10e3895(%rip)   # 0x11199d0
movq 0x10e388e(%rip), %rsi   # 0x11199d0
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x36157
incl (%r12)
movq %r15, %rdi
callq 0xe2eb
testl %eax, %eax
sete %al
jmp 0x36168
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: mtw_mirth_type_Type_Arrow
static struct mirth_type_Type mtw_mirth_type_Type_Arrow (struct mirth_type_ArrowType* in_ArrowType_1) {
	struct mirth_type_Type_Arrow* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mArrowType = in_ArrowType_1;
	struct mirth_type_Type v4 = { .tag=mirth_type_Type_Arrow, .ptr.Arrow=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x361aa
movq %rax, %rdx
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
movl $0xa, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xb2b77(%rip), %rsi     # 0xe8d28
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_elab_zaTypeElab_elabzestackzetypezepartszx
static struct mirth_type_StackType mw_mirth_elab_zaTypeElab_elabzestackzetypezepartszx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_elab_zaTypeElab* in_zaTypeElab_2, struct mirth_type_StackType in_StackType_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_elab_zaTypeElab* *out_zaTypeElab_5) {
	uint64_t v7 = in_zaTypeElab_2->mtoken;
	struct mirth_mirth_zaMirth* v8;
	bool v9 = mw_mirth_token_Token_sigzestackzeendzy(in_zaMirth_1, v7, &v8);
	bool v10 = !v9;
	struct mirth_type_StackType v11 = in_StackType_3;
	struct mirth_mirth_zaMirth* r12 = v8;
	struct mirth_elab_zaTypeElab* r13 = in_zaTypeElab_2;
	bool v14 = v10;
	while (v14) {
		struct mirth_type_StackType v15 = v11;
		struct mirth_mirth_zaMirth* r16 = r12;
		struct mirth_elab_zaTypeElab* r17 = r13;
		struct mirth_mirth_zaMirth* v18;
		struct mirth_elab_zaTypeElab* v19;
		struct mirth_type_StackTypePart v20 = mw_mirth_elab_zaTypeElab_elabzestackzetypezepartzx(r16, r17, &v18, &v19);
		struct mirth_type_StackType v21 = mw_mirth_type_StackTypePart_cons(v15, v20);
		uint64_t v22 = v19->mtoken;
		struct mirth_mirth_zaMirth* v23;
		bool v24 = mw_mirth_token_Token_sigzestackzeendzy(v18, v22, &v23);
		bool v25 = !v24;
		v14 = v25;
		r13 = v19;
		r12 = v23;
		v11 = v21;
	}
	*out_zaTypeElab_5 = r13;
	*out_zaMirth_4 = r12;
	return v11;
}

// 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, %r15
movl %edx, %r12d
movq %rsi, %r13
movq 0x10(%rsi), %rsi
leaq -0x58(%rbp), %rbx
movq %rbx, %rdx
callq 0x3f57b
movq (%rbx), %rdi
testb %al, %al
jne 0x36251
leaq -0x48(%rbp), %r14
leaq -0x40(%rbp), %rbx
movq %r13, %rsi
leaq -0x50(%rbp), %rdx
movq %r14, %rcx
callq 0x3f5e3
movq %rdx, %rcx
movl %r12d, %edi
movq %r15, %rsi
movl %eax, %edx
callq 0x36760
movl %eax, %r12d
movq %rdx, %r15
movq -0x48(%rbp), %r13
movq 0x10(%r13), %rsi
movq -0x50(%rbp), %rdi
movq %rbx, %rdx
callq 0x3f57b
movq -0x40(%rbp), %rdi
testb %al, %al
je 0x36210
movq -0x30(%rbp), %rax
movq %r13, (%rax)
movq -0x38(%rbp), %rax
movq %rdi, (%rax)
movl %r12d, %eax
movq %r15, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_token_Token_sigzestackzevarzy
static struct std_maybe_Maybe_1 mw_mirth_token_Token_sigzestackzevarzy (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;
	struct std_maybe_Maybe_1 v8 = mw_mirth_token_TokenValue_sigzestackzevarzy(v5, v6, &v7);
	*out_zaMirth_3 = v7;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movabsq $0xfffffffffffc, %r13   # imm = 0xFFFFFFFFFFFC
leaq 0x10e314c(%rip), %rdi   # 0x11193e8
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
movq %rax, %rdi
shrq $0x30, %rdi
andq %r13, %rax
movq %rax, %rsi
callq 0x3196d
cmpl $0x1, %eax
jne 0x363ab
movq %rbx, -0x30(%rbp)
movq %rdx, %rdi
callq 0xdaeb
movq %rax, %r12
movq %rdx, %r15
testb $0x1, %r15b
je 0x362f2
movq %r12, %rax
andq %r13, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x362f2
incl (%rax)
leaq -0x40(%rbp), %rbx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1f0c1
movl %eax, %eax
leaq 0x1(,%rax,2), %rdi
callq 0xe818
movq %rax, %r13
movq (%rbx), %rdi
leaq -0x38(%rbp), %rdx
movq %r12, %rsi
callq 0x1f102
movl %eax, %eax
leaq 0x1(,%rax,2), %r14
movq %r14, %rdi
callq 0xe818
movzbl %al, %eax
cmpl $0x61, %eax
jae 0x36343
xorl %eax, %eax
jmp 0x36354
movq %r14, %rdi
callq 0xe818
movzbl %al, %eax
cmpl $0x7b, %eax
setb %al
movq -0x38(%rbp), %r14
cmpb $0x2a, %r13b
movq -0x30(%rbp), %rbx
jne 0x36378
testb %al, %al
je 0x36378
movq %r12, %rdi
movq %r15, %rsi
callq 0x95f6
movl $0x1, %eax
jmp 0x363af
testb $0x1, %r15b
je 0x363ab
movq %r12, %rax
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rcx, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x363ab
decl (%rax)
jne 0x363ab
movq %r12, %rdi
movq %r15, %rsi
callq 0xd4e3
xorl %eax, %eax
xorl %edx, %edx
movq %r14, (%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_type_StackTypeBase_unitzy
static bool mw_mirth_type_StackTypeBase_unitzy (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_type_StackTypeBase in_StackTypeBase_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* branch_zaMirth_5;
	bool branch_Bool_6;
	switch ((in_StackTypeBase_2).tag) {
		case mirth_type_StackTypeBase_Unit: {
			bool v7 = true;
			branch_Bool_6 = v7;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case mirth_type_StackTypeBase_Meta: {
			uint64_t v8 = mtp_mirth_type_StackTypeBase_Meta(in_StackTypeBase_2);
			struct mirth_mirth_zaMirth* v9;
			bool v10 = mw_mirth_type_MetaVar_unitzestackzy(in_zaMirth_1, v8, &v9);
			branch_Bool_6 = v10;
			branch_zaMirth_5 = v9;
		} break;
		default: {
			decref(MK_mirth_type_StackTypeBase(in_StackTypeBase_2));
			bool v11 = false;
			branch_Bool_6 = v11;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
	}
	*out_zaMirth_3 = branch_zaMirth_5;
	return branch_Bool_6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x2, %esi
je 0x36711
cmpl $0x4, %esi
jne 0x36715
movq 0x8(%rdx), %r15
decl (%rdx)
jne 0x366f9
movq %rdx, %rdi
callq 0x5030
leaq -0x28(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3b5c8
movq (%r12), %r14
jmp 0x36750
movb $0x1, %al
jmp 0x36750
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %dil
orb %cl, %dil
jne 0x3674e
decl (%rax)
jne 0x3674e
shlq $0x30, %rsi
orq %rdx, %rsi
leaq 0xdfbce(%rip), %rax     # 0x116311
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd4e3
xorl %eax, %eax
movq %r14, (%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_type_StackTypePart_cons
static struct mirth_type_StackType mw_mirth_type_StackTypePart_cons (struct mirth_type_StackType in_StackType_1, struct mirth_type_StackTypePart in_StackTypePart_2) {
	struct mirth_type_StackType branch_StackType_4;
	switch ((in_StackTypePart_2).tag) {
		case mirth_type_StackTypePart_Cons: {
			struct mirth_type_Type v5 = mtp_mirth_type_StackTypePart_Cons(in_StackTypePart_2);
			struct mirth_type_StackType v6 = mtw_mirth_type_StackType_Cons(in_StackType_1, v5);
			branch_StackType_4 = v6;
		} break;
		case mirth_type_StackTypePart_ConsLabel: {
			uint64_t v7;
			struct mirth_type_Type v8 = mtp_mirth_type_StackTypePart_ConsLabel(in_StackTypePart_2, &v7);
			struct mirth_type_StackType v9 = mtw_mirth_type_StackType_ConsLabel(in_StackType_1, v8, v7);
			branch_StackType_4 = v9;
		} break;
		case mirth_type_StackTypePart_With: {
			struct mirth_type_Type v10 = mtp_mirth_type_StackTypePart_With(in_StackTypePart_2);
			struct mirth_type_StackType v11 = mtw_mirth_type_StackType_With(in_StackType_1, v10);
			branch_StackType_4 = v11;
		} break;
		case mirth_type_StackTypePart_WithLabel: {
			uint64_t v12;
			struct mirth_type_Type v13 = mtp_mirth_type_StackTypePart_WithLabel(in_StackTypePart_2, &v12);
			struct mirth_type_StackType v14 = mtw_mirth_type_StackType_WithLabel(in_StackType_1, v13, v12);
			branch_StackType_4 = v14;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	return branch_StackType_4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x3, %edx
ja 0x36824
movq %rsi, %rbx
movl %edi, %r14d
movl %edx, %eax
leaq 0xac0ae(%rip), %rdx     # 0xe2830
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq %rcx, %rdi
callq 0x3f453
movq %rdx, %rcx
movl %r14d, %edi
movq %rbx, %rsi
movl %eax, %edx
callq 0x20b1a
movl $0x5, %eax
jmp 0x36819
movq %rcx, %rdi
callq 0x3f4e7
movq %rdx, %rcx
movl %r14d, %edi
movq %rbx, %rsi
movl %eax, %edx
callq 0x21053
movl $0x7, %eax
jmp 0x36819
leaq -0x20(%rbp), %r15
movq %rcx, %rdi
movq %r15, %rsi
callq 0x3f527
movq %rdx, %rcx
movq (%r15), %r8
movl %r14d, %edi
movq %rbx, %rsi
movl %eax, %edx
callq 0x3e2fd
movl $0x8, %eax
jmp 0x36819
leaq -0x20(%rbp), %r15
movq %rcx, %rdi
movq %r15, %rsi
callq 0x3f493
movq %rdx, %rcx
movq (%r15), %r8
movl %r14d, %edi
movq %rbx, %rsi
movl %eax, %edx
callq 0x3dc1a
movl $0x6, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0xadf10(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0xadf15(%rip), %xmm0    # 0xe475d
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x95a5
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_type_StackType_Var
static struct mirth_type_StackType mtw_mirth_type_StackType_Var (uint64_t in_Var_1) {
	struct mirth_type_StackType_Var* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mVar = in_Var_1;
	struct mirth_type_StackType v4 = { .tag=mirth_type_StackType_Var, .ptr.Var=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x36b9c
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xb2836(%rip), %rsi     # 0xe93d9
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_type_typezeholezeunifyzx
static struct mirth_type_Type mw_mirth_type_typezeholezeunifyzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_type_Type in_Type_2, uint64_t in_Name_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	STR* v6;
	STRLIT(v6, "", 0);
	struct mirth_type_Type v7 = mtw_mirth_type_Type_Hole(in_Name_3);
	struct mirth_mirth_zaMirth* v8;
	STR* v9;
	mw_mirth_type_Type_typezj(in_zaMirth_1, v6, v7, &v8, &v9);
	STR* v10;
	STRLIT(v10, " ~ ", 3);
	STR* v11;
	mw_std_str_zaStr_pushzestrzx(v10, v9, &v11);
	incref(MK_mirth_type_Type(in_Type_2));
	struct mirth_mirth_zaMirth* v12;
	STR* v13;
	mw_mirth_type_Type_typezj(v8, v11, in_Type_2, &v12, &v13);
	STR* v14;
	STRLIT(v14, "\n", 1);
	STR* v15;
	mw_std_str_zaStr_pushzestrzx(v14, v13, &v15);
	struct mirth_mirth_zaMirth* v16;
	mw_mirth_mirth_zaMirth_infozx(v12, v15, &v16);
	*out_zaMirth_4 = v16;
	return in_Type_2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, -0x38(%rbp)
movq %rcx, %r13
movq %rdx, %rbx
movl %esi, -0x2c(%rbp)
movq %rdi, %r12
cmpq $0x0, 0x10e1075(%rip)   # 0x1119780
jne 0x38723
xorl %edi, %edi
callq 0xf9f7
movq $0x0, 0x10(%rax)
movq %rax, 0x10e105d(%rip)   # 0x1119780
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq 0x10e104c(%rip), %r14   # 0x1119780
movq %r14, %rax
andq %r15, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x3874a
incl (%rax)
movq %r13, %rdi
callq 0x39570
leaq -0x58(%rbp), %r8
leaq -0x50(%rbp), %r9
movq %r12, %rdi
movq %r14, %rsi
movl $0x4, %edx
movq %rax, %rcx
callq 0x395c3
cmpq $0x0, 0x10e1013(%rip)   # 0x1119788
jne 0x3879a
movl $0x3, %edi
callq 0xf9f7
movq $0x3, 0x10(%rax)
movw $0x7e20, 0x18(%rax)     # imm = 0x7E20
movb $0x20, 0x1a(%rax)
movq %rax, 0x10e0fee(%rip)   # 0x1119788
movq 0x10e0fe7(%rip), %rsi   # 0x1119788
movq %rsi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
movl -0x2c(%rbp), %r13d
jne 0x387bb
incl (%rax)
movq -0x50(%rbp), %rdi
callq 0xe43c
movq %rbx, %rcx
andq %r15, %rcx
sete %dl
testb $0x3, %bl
setne %sil
orb %dl, %sil
jne 0x387db
incl (%rcx)
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %r8
leaq -0x40(%rbp), %r9
movq %rax, %rsi
movl %r13d, %edx
movq %rbx, %rcx
callq 0x395c3
cmpq $0x0, 0x10e0f93(%rip)   # 0x1119790
jne 0x3881c
movl $0x1, %edi
callq 0xf9f7
movq $0x1, 0x10(%rax)
movb $0xa, 0x18(%rax)
movq %rax, 0x10e0f74(%rip)   # 0x1119790
movq 0x10e0f6d(%rip), %rsi   # 0x1119790
andq %rsi, %r15
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x38837
incl (%r15)
movq -0x40(%rbp), %rdi
callq 0xe43c
movq %rax, %r14
movq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %r12
movq %r12, %rsi
callq 0x1bc22
movq (%r12), %rdi
leaq -0x68(%rbp), %r12
movq %rax, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
movq %r12, %r8
callq 0x1bf3a
movq (%r12), %rax
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movl %r13d, %eax
movq %rbx, %rdx
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_type_MetaVar_unifyzeerrorzx
static struct mirth_type_Type mw_mirth_type_MetaVar_unifyzeerrorzx (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_MetaVar_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct std_maybe_Maybe_1 v6 = mw_mirth_type_MetaVar_typezy(in_zaMirth_1, in_MetaVar_2, &v5);
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	struct mirth_type_Type branch_Type_8;
	switch ((v6).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v9 = mtp_std_maybe_Maybe_1_Some(v6);
			struct mirth_mirth_zaMirth* v10;
			struct mirth_type_Type v11 = mw_mirth_type_Type_unifyzeerrorzx(v5, V_mirth_type_Type(v9), &v10);
			branch_Type_8 = v11;
			branch_zaMirth_7 = v10;
		} break;
		case std_maybe_Maybe_1_None: {
			struct mirth_type_Type v12 = { .tag=mirth_type_Type_Error };
			struct std_maybe_Maybe_1 v13 = mtw_std_maybe_Maybe_1_Some(MK_mirth_type_Type(v12));
			struct mirth_mirth_zaMirth* v14;
			mw_mirth_type_MetaVar_typezyzx(v5, v13, in_MetaVar_2, &v14);
			struct mirth_type_Type v15 = { .tag=mirth_type_Type_Error };
			branch_Type_8 = v15;
			branch_zaMirth_7 = v14;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_Type_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
leaq -0x30(%rbp), %rdx
callq 0x2e11b
testl %eax, %eax
je 0x388ec
cmpl $0x1, %eax
jne 0x3894a
movq %rdx, %rdi
callq 0xdaeb
movq -0x30(%rbp), %rdi
movabsq $0xfffffffffffc, %rdx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdx
movq %rax, %rsi
shrq $0x30, %rsi
leaq -0x38(%rbp), %r15
movq %r15, %rcx
callq 0x381c3
movl %eax, %r14d
movq (%r15), %r13
jmp 0x38935
leaq 0xdd1f6(%rip), %rsi     # 0x115ae9
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x95f6
movq %rdx, %r12
movq -0x30(%rbp), %r13
leaq 0x10e0b1d(%rip), %rdi   # 0x1119428
movq %r15, %rsi
callq 0x13ff0
movabsq $0xfffffffffffc, %rdi   # imm = 0xFFFFFFFFFFFC
addq $0x4, %rdi
orq %r12, %rdi
leaq 0xdc996(%rip), %rsi     # 0x1152c1
movq %rax, %rdx
callq 0x14ab5
xorl %edx, %edx
movq %r13, (%rbx)
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0xabdea(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0xabdef(%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_type_Value_unifyzeerrorzx
static struct mirth_type_Type mw_mirth_type_Value_unifyzeerrorzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_type_Value in_Value_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* branch_zaMirth_5;
	struct mirth_type_Type branch_Type_6;
	switch ((in_Value_2).tag) {
		case mirth_type_Value_Int: {
			INT v7 = mtp_mirth_type_Value_Int(in_Value_2);
			decref(MKINT(v7));
			struct mirth_type_Type v8 = { .tag=mirth_type_Type_Error };
			branch_Type_6 = v8;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case mirth_type_Value_Str: {
			STR* v9 = mtp_mirth_type_Value_Str(in_Value_2);
			decref(MKSTR(v9));
			struct mirth_type_Type v10 = { .tag=mirth_type_Type_Error };
			branch_Type_6 = v10;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case mirth_type_Value_F64: {
			double v11 = mtp_mirth_type_Value_F64(in_Value_2);
			struct mirth_type_Type v12 = { .tag=mirth_type_Type_Error };
			branch_Type_6 = v12;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case mirth_type_Value_Block: {
			uint64_t v13 = mtp_mirth_type_Value_Block(in_Value_2);
			struct mirth_type_Type v14 = { .tag=mirth_type_Type_Error };
			struct mirth_mirth_zaMirth* v15;
			struct mirth_type_Type v16 = mw_mirth_type_Type_unifyzeblockzx(in_zaMirth_1, v13, v14, &v15);
			branch_Type_6 = v16;
			branch_zaMirth_5 = v15;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_3 = branch_zaMirth_5;
	return branch_Type_6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl $0x3, %esi
ja 0x38de0
movq %rcx, %rbx
movq %rdi, %r14
movl %esi, %eax
leaq 0xa9c29(%rip), %rcx     # 0xe294c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rdx, %rdi
callq 0x2e51d
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x38dcc
decl (%rcx)
jne 0x38dcc
leaq 0xdc6cf(%rip), %rsi     # 0x115429
jmp 0x38d8a
movq %rdx, %rdi
callq 0x2e558
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x38dcc
decl (%rcx)
jne 0x38dcc
leaq 0xdc3cf(%rip), %rsi     # 0x115159
movq %rax, %rdi
callq 0xd4e3
jmp 0x38dcc
movq 0x8(%rdx), %r15
decl (%rdx)
jne 0x38da4
movq %rdx, %rdi
callq 0x5030
leaq -0x28(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r12, %r8
callq 0x3bed8
movq (%r12), %r14
jmp 0x38dd0
decl (%rdx)
jne 0x38dcc
movq %rdx, %rdi
callq 0x5030
xorl %eax, %eax
xorl %edx, %edx
movq %r14, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0xab954(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0xab959(%rip), %xmm0    # 0xe475d
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x95a5
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_type_Type_Value
static struct mirth_type_Type mtw_mirth_type_Type_Value (struct mirth_type_Value in_Value_1) {
	struct mirth_type_Type_Value* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mValue = in_Value_1;
	struct mirth_type_Type v4 = { .tag=mirth_type_Type_Value, .ptr.Value=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
movl $0x1, %edi
movl $0x18, %esi
callq 0x50c0
testq %rax, %rax
je 0x38e4c
movq %rax, %rdx
movl $0x1, (%rax)
movl %r14d, 0x8(%rax)
movq %rbx, 0x10(%rax)
movl $0xd, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xb0228(%rip), %rsi     # 0xe907b
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_type_StackType_expand
static struct mirth_type_StackType mw_mirth_type_StackType_expand (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_type_StackType in_StackType_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* branch_zaMirth_5;
	struct mirth_type_StackType branch_StackType_6;
	switch ((in_StackType_2).tag) {
		case mirth_type_StackType_Meta: {
			uint64_t v7 = mtp_mirth_type_StackType_Meta(in_StackType_2);
			struct mirth_mirth_zaMirth* v8;
			struct mirth_type_Type v9 = mw_mirth_type_MetaVar_expand(in_zaMirth_1, v7, &v8);
			struct mirth_type_StackType v10 = mw_mirth_type_Type_zgStackType(v9);
			branch_StackType_6 = v10;
			branch_zaMirth_5 = v8;
		} break;
		default: {
			branch_StackType_6 = in_StackType_2;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
	}
	*out_zaMirth_3 = branch_zaMirth_5;
	return branch_StackType_6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x4, %esi
jne 0x391c7
movq 0x8(%rdx), %r15
decl (%rdx)
jne 0x391a5
movq %rdx, %rdi
callq 0x5030
leaq -0x28(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2e39b
movl %eax, %edi
movq %rdx, %rsi
callq 0x391d9
movq (%r12), %r14
jmp 0x391c9
movl %esi, %eax
movq %r14, (%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_type_Type_zgStackType
static struct mirth_type_StackType mw_mirth_type_Type_zgStackType (struct mirth_type_Type in_Type_1) {
	struct mirth_type_StackType branch_StackType_3;
	switch ((in_Type_1).tag) {
		case mirth_type_Type_Error: {
			struct mirth_type_StackType v4 = { .tag=mirth_type_StackType_Error };
			branch_StackType_3 = v4;
		} break;
		case mirth_type_Type_Ignore: {
			struct mirth_type_StackType v5 = { .tag=mirth_type_StackType_Ignore };
			branch_StackType_3 = v5;
		} break;
		case mirth_type_Type_Var: {
			uint64_t v6 = mtp_mirth_type_Type_Var(in_Type_1);
			struct mirth_type_StackType v7 = mtw_mirth_type_StackType_Var(v6);
			branch_StackType_3 = v7;
		} break;
		case mirth_type_Type_Meta: {
			uint64_t v8 = mtp_mirth_type_Type_Meta(in_Type_1);
			struct mirth_type_StackType v9 = mtw_mirth_type_StackType_Meta(v8);
			branch_StackType_3 = v9;
		} break;
		case mirth_type_Type_Stack: {
			struct mirth_type_StackType v10 = mtp_mirth_type_Type_Stack(in_Type_1);
			branch_StackType_3 = v10;
		} break;
		default: {
			STR* v11;
			STRLIT(v11, "kind error! expected stack type, got regular type.", 50);
			do_panic(v11);
		} break;
	}
	return branch_StackType_3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x9, %edi
ja 0x3924c
movl %edi, %eax
movl %edi, %ecx
leaq 0xa9791(%rip), %rdx     # 0xe2980
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorl %edx, %edx
jmp 0x39245
movq %rsi, %rdi
callq 0x2e254
jmp 0x39245
movq 0x8(%rsi), %rbx
decl (%rsi)
jne 0x39216
movq %rsi, %rdi
callq 0x5030
movq %rbx, %rdi
callq 0x39515
movl $0x4, %eax
jmp 0x39245
movq 0x8(%rsi), %rbx
decl (%rsi)
jne 0x39235
movq %rsi, %rdi
callq 0x5030
movq %rbx, %rdi
callq 0x36b6e
movq %rax, %rdx
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpq $0x0, 0x10e0524(%rip)   # 0x1119778
jne 0x39296
movl $0x32, %edi
callq 0xf9f7
movq $0x32, 0x10(%rax)
movups 0xafb51(%rip), %xmm0    # 0xe8dc0
movups %xmm0, 0x18(%rax)
movups 0xafb56(%rip), %xmm0    # 0xe8dd0
movups %xmm0, 0x28(%rax)
movups 0xafb5b(%rip), %xmm0    # 0xe8de0
movups %xmm0, 0x38(%rax)
movw $0x2e65, 0x48(%rax)     # imm = 0x2E65
movq %rax, 0x10e04e2(%rip)   # 0x1119778
movq 0x10e04db(%rip), %rdi   # 0x1119778
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x392ba
incl (%rax)
callq 0x95a5
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_type_StackType_Cons
static struct mirth_type_StackType mtp_mirth_type_StackType_Cons (struct mirth_type_StackType in_StackType_1, struct mirth_type_Type *out_Type_3) {
	struct mirth_type_StackType_Cons v4 = *in_StackType_1.ptr.Cons;
	if (!--(in_StackType_1.ptr.Cons->refs)) {
		free(in_StackType_1.ptr.Cons);
	} else {
		incref(MK_mirth_type_StackType(v4.mStackType));
		incref(MK_mirth_type_Type(v4.mType));
	}
	*out_Type_3 = v4.mType;
	return v4.mStackType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %eax
movq 0x10(%rdi), %r15
movl 0x18(%rdi), %r12d
movl 0x1c(%rdi), %r13d
movq 0x20(%rdi), %r14
decl (%rdi)
je 0x3931e
movabsq $0xfffffffffffc, %rdi   # imm = 0xFFFFFFFFFFFC
movq %r15, %rcx
andq %rdi, %rcx
sete %dl
testb $0x3, %r15b
setne %sil
orb %dl, %sil
jne 0x39309
incl (%rcx)
andq %r14, %rdi
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x39329
incl (%rdi)
jmp 0x39329
movl %eax, -0x2c(%rbp)
callq 0x5030
movl -0x2c(%rbp), %eax
movl %r12d, (%rbx)
movl %r13d, 0x4(%rbx)
movq %r14, 0x8(%rbx)
movq %r15, %rdx
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: mtp_mirth_type_StackType_With
static struct mirth_type_StackType mtp_mirth_type_StackType_With (struct mirth_type_StackType in_StackType_1, struct mirth_type_Type *out_Resource_3) {
	struct mirth_type_StackType_With v4 = *in_StackType_1.ptr.With;
	if (!--(in_StackType_1.ptr.With->refs)) {
		free(in_StackType_1.ptr.With);
	} else {
		incref(MK_mirth_type_StackType(v4.mStackType));
		incref(MK_mirth_type_Type(v4.mResource));
	}
	*out_Resource_3 = v4.mResource;
	return v4.mStackType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %eax
movq 0x10(%rdi), %r15
movl 0x18(%rdi), %r12d
movl 0x1c(%rdi), %r13d
movq 0x20(%rdi), %r14
decl (%rdi)
je 0x393a5
movabsq $0xfffffffffffc, %rdi   # imm = 0xFFFFFFFFFFFC
movq %r15, %rcx
andq %rdi, %rcx
sete %dl
testb $0x3, %r15b
setne %sil
orb %dl, %sil
jne 0x39390
incl (%rcx)
andq %r14, %rdi
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x393b0
incl (%rdi)
jmp 0x393b0
movl %eax, -0x2c(%rbp)
callq 0x5030
movl -0x2c(%rbp), %eax
movl %r12d, (%rbx)
movl %r13d, 0x4(%rbx)
movq %r14, 0x8(%rbx)
movq %r15, %rdx
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: mtp_mirth_type_StackType_ConsLabel
static struct mirth_type_StackType mtp_mirth_type_StackType_ConsLabel (struct mirth_type_StackType in_StackType_1, struct mirth_type_Type *out_Type_3, uint64_t *out_Label_4) {
	struct mirth_type_StackType_ConsLabel v5 = *in_StackType_1.ptr.ConsLabel;
	if (!--(in_StackType_1.ptr.ConsLabel->refs)) {
		free(in_StackType_1.ptr.ConsLabel);
	} else {
		incref(MK_mirth_type_StackType(v5.mStackType));
		incref(MK_mirth_type_Type(v5.mType));
	}
	*out_Label_4 = v5.mLabel;
	*out_Type_3 = v5.mType;
	return v5.mStackType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x8(%rdi), %eax
movq 0x10(%rdi), %r15
movl 0x18(%rdi), %r13d
movl 0x1c(%rdi), %r9d
movq 0x20(%rdi), %r12
movq 0x28(%rdi), %r14
decl (%rdi)
je 0x39436
movabsq $0xfffffffffffc, %rdi   # imm = 0xFFFFFFFFFFFC
movq %r15, %rcx
andq %rdi, %rcx
sete %r8b
testb $0x3, %r15b
setne %sil
orb %r8b, %sil
jne 0x3941f
incl (%rcx)
andq %r12, %rdi
sete %cl
testb $0x3, %r12b
setne %sil
orb %cl, %sil
jne 0x39451
incl (%rdi)
jmp 0x39451
movl %eax, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movl %r9d, -0x2c(%rbp)
callq 0x5030
movl -0x2c(%rbp), %r9d
movq -0x38(%rbp), %rdx
movl -0x30(%rbp), %eax
movq %r14, (%rdx)
movl %r13d, (%rbx)
movl %r9d, 0x4(%rbx)
movq %r12, 0x8(%rbx)
movq %r15, %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: mtp_mirth_type_StackType_WithLabel
static struct mirth_type_StackType mtp_mirth_type_StackType_WithLabel (struct mirth_type_StackType in_StackType_1, struct mirth_type_Type *out_Resource_3, uint64_t *out_Label_4) {
	struct mirth_type_StackType_WithLabel v5 = *in_StackType_1.ptr.WithLabel;
	if (!--(in_StackType_1.ptr.WithLabel->refs)) {
		free(in_StackType_1.ptr.WithLabel);
	} else {
		incref(MK_mirth_type_StackType(v5.mStackType));
		incref(MK_mirth_type_Type(v5.mResource));
	}
	*out_Label_4 = v5.mLabel;
	*out_Resource_3 = v5.mResource;
	return v5.mStackType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x8(%rdi), %eax
movq 0x10(%rdi), %r15
movl 0x18(%rdi), %r13d
movl 0x1c(%rdi), %r9d
movq 0x20(%rdi), %r12
movq 0x28(%rdi), %r14
decl (%rdi)
je 0x394da
movabsq $0xfffffffffffc, %rdi   # imm = 0xFFFFFFFFFFFC
movq %r15, %rcx
andq %rdi, %rcx
sete %r8b
testb $0x3, %r15b
setne %sil
orb %r8b, %sil
jne 0x394c3
incl (%rcx)
andq %r12, %rdi
sete %cl
testb $0x3, %r12b
setne %sil
orb %cl, %sil
jne 0x394f5
incl (%rdi)
jmp 0x394f5
movl %eax, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movl %r9d, -0x2c(%rbp)
callq 0x5030
movl -0x2c(%rbp), %r9d
movq -0x38(%rbp), %rdx
movl -0x30(%rbp), %eax
movq %r14, (%rdx)
movl %r13d, (%rbx)
movl %r9d, 0x4(%rbx)
movq %r12, 0x8(%rbx)
movq %r15, %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: mtw_mirth_type_StackType_Meta
static struct mirth_type_StackType mtw_mirth_type_StackType_Meta (uint64_t in_MetaVar_1) {
	struct mirth_type_StackType_Meta* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mMetaVar = in_MetaVar_1;
	struct mirth_type_StackType v4 = { .tag=mirth_type_StackType_Meta, .ptr.Meta=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x3954b
movq %rax, %rdx
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
movl $0x4, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xaf8a1(%rip), %rsi     # 0xe8df3
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_type_Type_Hole
static struct mirth_type_Type mtw_mirth_type_Type_Hole (uint64_t in_Name_1) {
	struct mirth_type_Type_Hole* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mName = in_Name_1;
	struct mirth_type_Type v4 = { .tag=mirth_type_Type_Hole, .ptr.Hole=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
testq %rax, %rax
je 0x3959e
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xaf8ec(%rip), %rsi     # 0xe8e91
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_typezj
static void mw_mirth_var_Var_typezj (struct mirth_mirth_zaMirth* in_zaMirth_1, STR* in_zaStr_2, uint64_t in_Var_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, STR* *out_zaStr_5) {
	struct mirth_mirth_zaMirth* v6;
	STR* v7;
	mw_mirth_var_Var_namezj(in_zaMirth_1, in_zaStr_2, in_Var_3, &v6, &v7);
	*out_zaStr_5 = v7;
	*out_zaMirth_4 = v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, -0x30(%rbp)
movq %rsi, %r15
movq %rdi, %r12
leaq 0x10ded0c(%rip), %rdi   # 0x1118fe0
movq %rdx, %rsi
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
leaq -0x40(%rbp), %r13
leaq -0x38(%rbp), %rbx
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r13, %rcx
movq %rbx, %r8
callq 0x1a389
movq (%rbx), %rax
movq (%r13), %rcx
movq %rax, (%r14)
movq -0x30(%rbp), %rax
movq %rcx, (%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_mirth_type_MetaVar_typezj
static void mw_mirth_type_MetaVar_typezj (struct mirth_mirth_zaMirth* in_zaMirth_1, STR* in_zaStr_2, uint64_t in_MetaVar_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, STR* *out_zaStr_5) {
	struct mirth_mirth_zaMirth* v6;
	struct std_maybe_Maybe_1 v7 = mw_mirth_type_MetaVar_typezy(in_zaMirth_1, in_MetaVar_3, &v6);
	struct mirth_mirth_zaMirth* branch_zaMirth_8;
	STR* branch_zaStr_9;
	switch ((v7).tag) {
		case std_maybe_Maybe_1_None: {
			STR* v10;
			STRLIT(v10, "?", 1);
			STR* v11;
			mw_std_str_zaStr_pushzestrzx(v10, in_zaStr_2, &v11);
			uint64_t v12 = in_MetaVar_3;
			INT v13 = u64_to_int(v12);
			INT v14 = v13;
			INT v15 = v14;
			STR* v16 = int_to_str(v15);
			STR* v17;
			mw_std_str_zaStr_pushzestrzx(v16, v11, &v17);
			branch_zaStr_9 = v17;
			branch_zaMirth_8 = v6;
		} break;
		case std_maybe_Maybe_1_Some: {
			VAL v18 = mtp_std_maybe_Maybe_1_Some(v7);
			struct mirth_mirth_zaMirth* v19;
			STR* v20;
			mw_mirth_type_Type_typezj(v6, in_zaStr_2, V_mirth_type_Type(v18), &v19, &v20);
			branch_zaStr_9 = v20;
			branch_zaMirth_8 = v19;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaStr_5 = branch_zaStr_9;
	*out_zaMirth_4 = branch_zaMirth_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
leaq -0x30(%rbp), %rdx
movq %r12, %rsi
callq 0x2e11b
cmpl $0x1, %eax
je 0x3a3cd
testl %eax, %eax
jne 0x3a420
cmpq $0x0, 0x10df482(%rip)   # 0x11197e0
jne 0x3a37d
movl $0x1, %edi
callq 0xf9f7
movq $0x1, 0x10(%rax)
movb $0x3f, 0x18(%rax)
movq %rax, 0x10df463(%rip)   # 0x11197e0
movq 0x10df45c(%rip), %rsi   # 0x11197e0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x3a3a1
incl (%rax)
movq %r15, %rdi
callq 0xe43c
movq %rax, %r15
movq %r12, %rdi
callq 0xe7a9
movq %rax, %rdi
callq 0x102c9
movq %r15, %rdi
movq %rax, %rsi
callq 0xe43c
movq -0x30(%rbp), %rcx
jmp 0x3a40b
movq %rdx, %rdi
callq 0xdaeb
movq -0x30(%rbp), %rdi
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
movq %rax, %rdx
shrq $0x30, %rdx
leaq -0x40(%rbp), %r12
leaq -0x38(%rbp), %r13
movq %r15, %rsi
movq %r12, %r8
movq %r13, %r9
callq 0x395c3
movq (%r13), %rax
movq (%r12), %rcx
movq %rax, (%r14)
movq %rcx, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0xaa314(%rip), %xmm0    # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0xaa319(%rip), %xmm0    # 0xe475d
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x95a5