LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x3480f
decl (%rax)
je 0x34814
popq %rbx
popq %r14
popq %rbp
retq
shlq $0x30, %rbx
orq %r14, %rbx
leaq 0xdca57(%rip), %rsi     # 0x111279
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xd13d
// File: /workspace/github_c_makefile_star2_O3/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 0x34864
incl (%rax)
movl 0x28(%r14), %r15d
movq 0x30(%r14), %r12
andq %r12, %rcx
sete %sil
testb $0x3, %r12b
setne %dil
orb %sil, %dil
jne 0x34882
incl (%rcx)
testb %dl, %dl
je 0x34899
decl (%rax)
jne 0x34899
leaq 0xddb10(%rip), %rsi     # 0x1123a1
movq %r14, %rdi
callq 0xd13d
movq %r14, %rdi
callq 0x3adac
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_O3/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 0x3490f
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 0xb0279(%rip), %rsi     # 0xe4b8f
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/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 0x10e05ba(%rip), %rdi   # 0x11153e8
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
movq %rax, %rdi
shrq $0x30, %rdi
andq %r12, %rax
movq %rax, %rsi
callq 0x30a3b
cmpl $0x1, %eax
jne 0x34ed1
movq %rdx, %rdi
callq 0xd745
leaq 0x10df667(%rip), %rdi   # 0x11144c8
movq %rax, %rsi
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
movq %rax, %rdi
movq %rdx, %rsi
callq 0x9189
movq %rax, %r15
movq 0x10e0b42(%rip), %rsi   # 0x11159c8
testq %rsi, %rsi
jne 0x34ead
movl $0x2, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x2, 0x10(%rax)
movw $0x2d7c, 0x18(%rax)     # imm = 0x2D7C
movq %rax, 0x10e0b1b(%rip)   # 0x11159c8
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x34ec2
incl (%r12)
movq %r15, %rdi
callq 0xdf18
testl %eax, %eax
sete %al
jmp 0x34ed3
xorl %eax, %eax
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10e04e7(%rip), %rdi   # 0x11153e8
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
movq %rax, %rdi
shrq $0x30, %rdi
andq %r12, %rax
movq %rax, %rsi
callq 0x30a3b
cmpl $0x1, %eax
jne 0x34fa4
movq %rdx, %rdi
callq 0xd745
leaq 0x10df594(%rip), %rdi   # 0x11144c8
movq %rax, %rsi
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
movq %rax, %rdi
movq %rdx, %rsi
callq 0x9189
movq %rax, %r15
movq 0x10e0a77(%rip), %rsi   # 0x11159d0
testq %rsi, %rsi
jne 0x34f80
movl $0x2, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x2, 0x10(%rax)
movw $0x2d2d, 0x18(%rax)     # imm = 0x2D2D
movq %rax, 0x10e0a50(%rip)   # 0x11159d0
andq %rsi, %r12
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x34f95
incl (%r12)
movq %r15, %rdi
callq 0xdf18
testl %eax, %eax
sete %al
jmp 0x34fa6
xorl %eax, %eax
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x34fe8
movq %rax, %rdx
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
movl $0xa, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xafc08(%rip), %rsi     # 0xe4bf7
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/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 0x3e234
movq (%rbx), %rdi
testb %al, %al
jne 0x3508f
leaq -0x48(%rbp), %r14
leaq -0x40(%rbp), %rbx
movq %r13, %rsi
leaq -0x50(%rbp), %rdx
movq %r14, %rcx
callq 0x3e29c
movq %rdx, %rcx
movl %r12d, %edi
movq %r15, %rsi
movl %eax, %edx
callq 0x355b1
movl %eax, %r12d
movq %rdx, %r15
movq -0x48(%rbp), %r13
movq 0x10(%r13), %rsi
movq -0x50(%rbp), %rdi
movq %rbx, %rdx
callq 0x3e234
movq -0x40(%rbp), %rdi
testb %al, %al
je 0x3504e
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_O3/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 0x10e030e(%rip), %rdi   # 0x11153e8
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
movq %rax, %rdi
shrq $0x30, %rdi
andq %r13, %rax
movq %rax, %rsi
callq 0x30a3b
cmpl $0x1, %eax
jne 0x351b8
movq %rbx, -0x30(%rbp)
movq %rdx, %rdi
callq 0xd745
movq %rax, %r12
movq %rdx, %r15
testb $0x1, %r15b
je 0x35130
movq %r12, %rax
andq %r13, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x35130
incl (%rax)
leaq -0x40(%rbp), %rbx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1ec3f
movl %eax, %eax
leaq 0x1(,%rax,2), %rdi
callq 0xe445
movq %rax, %r13
movq (%rbx), %rdi
leaq -0x38(%rbp), %rdx
movq %r12, %rsi
callq 0x1ec80
movl %eax, %eax
leaq 0x1(,%rax,2), %r14
movq %r14, %rdi
callq 0xe445
movzbl %al, %eax
cmpl $0x60, %eax
ja 0x351ce
movq -0x38(%rbp), %r14
movq -0x30(%rbp), %rbx
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
testb $0x1, %r15b
je 0x351b8
movq %r12, %rax
andq %rcx, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0x351b8
decl (%rax)
jne 0x351b8
movq %r12, %rdi
movq %r15, %rsi
callq 0xd13d
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
movq %r14, %rdi
callq 0xe445
movq -0x38(%rbp), %r14
cmpb $0x2a, %r13b
jne 0x35181
movzbl %al, %eax
cmpl $0x7a, %eax
movq -0x30(%rbp), %rbx
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
ja 0x3518f
movq %r12, %rdi
movq %r15, %rsi
callq 0x9353
movl $0x1, %eax
jmp 0x351bc
// File: /workspace/github_c_makefile_star2_O3/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 0x35562
cmpl $0x4, %esi
jne 0x35566
movq 0x8(%rdx), %r15
decl (%rdx)
jne 0x3554a
movq %rdx, %rdi
callq 0x5030
leaq -0x28(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3a287
movq (%r12), %r14
jmp 0x355a1
movb $0x1, %al
jmp 0x355a1
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %dil
orb %cl, %dil
jne 0x3559f
decl (%rax)
jne 0x3559f
shlq $0x30, %rsi
orq %rdx, %rsi
leaq 0xdcd7d(%rip), %rax     # 0x112311
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd13d
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_O3/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 0x35675
movq %rsi, %rbx
movl %edi, %r14d
movl %edx, %eax
leaq 0xa9271(%rip), %rdx     # 0xde844
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq %rcx, %rdi
callq 0x3e10c
movq %rdx, %rcx
movl %r14d, %edi
movq %rbx, %rsi
movl %eax, %edx
callq 0x205af
movl $0x5, %eax
jmp 0x3566a
movq %rcx, %rdi
callq 0x3e1a0
movq %rdx, %rcx
movl %r14d, %edi
movq %rbx, %rsi
movl %eax, %edx
callq 0x20ae8
movl $0x7, %eax
jmp 0x3566a
leaq -0x20(%rbp), %r15
movq %rcx, %rdi
movq %r15, %rsi
callq 0x3e1e0
movq %rdx, %rcx
movq (%r15), %r8
movl %r14d, %edi
movq %rbx, %rsi
movl %eax, %edx
callq 0x3cfb6
movl $0x8, %eax
jmp 0x3566a
leaq -0x20(%rbp), %r15
movq %rcx, %rdi
movq %r15, %rsi
callq 0x3e14c
movq %rdx, %rcx
movq (%r15), %r8
movl %r14d, %edi
movq %rbx, %rsi
movl %eax, %edx
callq 0x3c8d3
movl $0x6, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0xab03f(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0xab044(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/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 0x359eb
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xaf8b6(%rip), %rsi     # 0xe52a8
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x10de201(%rip), %r14   # 0x1115780
testq %r14, %r14
jne 0x3759d
xorl %edi, %edi
callq 0xf5e4
movq %rax, %r14
movq $0x0, 0x10(%rax)
movq %rax, 0x10de1e3(%rip)   # 0x1115780
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq %r14, %rax
andq %r15, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x375bd
incl (%rax)
movq %r13, %rdi
callq 0x383d6
leaq -0x58(%rbp), %r8
leaq -0x50(%rbp), %r9
movq %r12, %rdi
movq %r14, %rsi
movl $0x4, %edx
movq %rax, %rcx
callq 0x38429
movq 0x10de1a1(%rip), %rsi   # 0x1115788
testq %rsi, %rsi
jne 0x37612
movl $0x3, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x3, 0x10(%rax)
movw $0x7e20, 0x18(%rax)     # imm = 0x7E20
movb $0x20, 0x1a(%rax)
movq %rax, 0x10de176(%rip)   # 0x1115788
movq %rsi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
movl -0x2c(%rbp), %r13d
jne 0x3762c
incl (%rax)
movq -0x50(%rbp), %rdi
callq 0xe069
movq %rbx, %rcx
andq %r15, %rcx
sete %dl
testb $0x3, %bl
setne %sil
orb %dl, %sil
jne 0x3764c
incl (%rcx)
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %r8
leaq -0x40(%rbp), %r9
movq %rax, %rsi
movl %r13d, %edx
movq %rbx, %rcx
callq 0x38429
movq 0x10de123(%rip), %rsi   # 0x1115790
testq %rsi, %rsi
jne 0x37692
movl $0x1, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x1, 0x10(%rax)
movb $0xa, 0x18(%rax)
movq %rax, 0x10de0fe(%rip)   # 0x1115790
andq %rsi, %r15
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x376a6
incl (%r15)
movq -0x40(%rbp), %rdi
callq 0xe069
movq %rax, %r14
movq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %r12
movq %r12, %rsi
callq 0x1b95a
movq (%r12), %rdi
leaq -0x68(%rbp), %r12
movq %rax, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
movq %r12, %r8
callq 0x1bc32
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_O3/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 0x2d45d
testl %eax, %eax
je 0x3775b
cmpl $0x1, %eax
jne 0x377b9
movq %rdx, %rdi
callq 0xd745
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 0x36fe3
movl %eax, %r14d
movq (%r15), %r13
jmp 0x377a4
leaq 0xda387(%rip), %rsi     # 0x111ae9
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x9353
movq %rdx, %r12
movq -0x30(%rbp), %r13
leaq 0x10ddcae(%rip), %rdi   # 0x1115428
movq %r15, %rsi
callq 0x13c85
movabsq $0xfffffffffffc, %rdi   # imm = 0xFFFFFFFFFFFC
addq $0x4, %rdi
orq %r12, %rdi
leaq 0xd9b27(%rip), %rsi     # 0x1112c1
movq %rax, %rdx
callq 0x14766
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 0xf5e4
movq $0x20, 0x10(%rax)
movups 0xa8efb(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0xa8f00(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/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 0x37c48
movq %rcx, %rbx
movq %rdi, %r14
movl %esi, %eax
leaq 0xa6dd5(%rip), %rcx     # 0xde960
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rdx, %rdi
callq 0x2d85f
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x37c34
decl (%rcx)
jne 0x37c34
leaq 0xd9867(%rip), %rsi     # 0x111429
jmp 0x37bf2
movq %rdx, %rdi
callq 0x2d89a
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x37c34
decl (%rcx)
jne 0x37c34
leaq 0xd9567(%rip), %rsi     # 0x111159
movq %rax, %rdi
callq 0xd13d
jmp 0x37c34
movq 0x8(%rdx), %r15
decl (%rdx)
jne 0x37c0c
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 0x3ab8d
movq (%r12), %r14
jmp 0x37c38
decl (%rdx)
jne 0x37c34
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 0xf5e4
movq $0x20, 0x10(%rax)
movups 0xa8a6c(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0xa8a71(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/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 0x37cb4
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 0xad28f(%rip), %rsi     # 0xe4f4a
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/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 0x3802f
movq 0x8(%rdx), %r15
decl (%rdx)
jne 0x3800d
movq %rdx, %rdi
callq 0x5030
leaq -0x28(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2d6dd
movl %eax, %edi
movq %rdx, %rsi
callq 0x38041
movq (%r12), %r14
jmp 0x38031
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_O3/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 0x380b4
movl %edi, %eax
movl %edi, %ecx
leaq 0xa693d(%rip), %rdx     # 0xde994
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorl %edx, %edx
jmp 0x380ad
movq %rsi, %rdi
callq 0x2d596
jmp 0x380ad
movq 0x8(%rsi), %rbx
decl (%rsi)
jne 0x3807e
movq %rsi, %rdi
callq 0x5030
movq %rbx, %rdi
callq 0x3837b
movl $0x4, %eax
jmp 0x380ad
movq 0x8(%rsi), %rbx
decl (%rsi)
jne 0x3809d
movq %rsi, %rdi
callq 0x5030
movq %rbx, %rdi
callq 0x359bd
movq %rax, %rdx
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x10dd6bd(%rip), %rdi   # 0x1115778
testq %rdi, %rdi
jne 0x38103
movl $0x32, %edi
callq 0xf5e4
movq %rax, %rdi
movq $0x32, 0x10(%rax)
movups 0xacbb3(%rip), %xmm0    # 0xe4c8f
movups %xmm0, 0x18(%rax)
movups 0xacbb8(%rip), %xmm0    # 0xe4c9f
movups %xmm0, 0x28(%rax)
movups 0xacbbd(%rip), %xmm0    # 0xe4caf
movups %xmm0, 0x38(%rax)
movw $0x2e65, 0x48(%rax)     # imm = 0x2E65
movq %rax, 0x10dd675(%rip)   # 0x1115778
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x38120
incl (%rax)
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/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 0x38184
movabsq $0xfffffffffffc, %rdi   # imm = 0xFFFFFFFFFFFC
movq %r15, %rcx
andq %rdi, %rcx
sete %dl
testb $0x3, %r15b
setne %sil
orb %dl, %sil
jne 0x3816f
incl (%rcx)
andq %r14, %rdi
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x3818f
incl (%rdi)
jmp 0x3818f
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_O3/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 0x3820b
movabsq $0xfffffffffffc, %rdi   # imm = 0xFFFFFFFFFFFC
movq %r15, %rcx
andq %rdi, %rcx
sete %dl
testb $0x3, %r15b
setne %sil
orb %dl, %sil
jne 0x381f6
incl (%rcx)
andq %r14, %rdi
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x38216
incl (%rdi)
jmp 0x38216
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_O3/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 0x3829c
movabsq $0xfffffffffffc, %rdi   # imm = 0xFFFFFFFFFFFC
movq %r15, %rcx
andq %rdi, %rcx
sete %r8b
testb $0x3, %r15b
setne %sil
orb %r8b, %sil
jne 0x38285
incl (%rcx)
andq %r12, %rdi
sete %cl
testb $0x3, %r12b
setne %sil
orb %cl, %sil
jne 0x382b7
incl (%rdi)
jmp 0x382b7
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_O3/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 0x383b1
movq %rax, %rdx
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
movl $0x4, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xac90a(%rip), %rsi     # 0xe4cc2
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/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 0x38404
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xac955(%rip), %rsi     # 0xe4d60
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/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 0x10dbf60(%rip), %rdi   # 0x1114fe0
movq %rdx, %rsi
callq 0x13c85
movq %rax, %rdi
callq 0x13d82
leaq -0x40(%rbp), %r13
leaq -0x38(%rbp), %rbx
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r13, %rcx
movq %rbx, %r8
callq 0x1a0d2
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_O3/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 0x2d45d
cmpl $0x1, %eax
je 0x39177
testl %eax, %eax
jne 0x391ca
movq 0x10dc6d7(%rip), %rsi   # 0x11157e0
testq %rsi, %rsi
jne 0x3912e
movl $0x1, %edi
callq 0xf5e4
movq %rax, %rsi
movq $0x1, 0x10(%rax)
movb $0x3f, 0x18(%rax)
movq %rax, 0x10dc6b2(%rip)   # 0x11157e0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x3914b
incl (%rax)
movq %r15, %rdi
callq 0xe069
movq %rax, %r15
movq %r12, %rdi
callq 0xe3d6
movq %rax, %rdi
callq 0xfea8
movq %r15, %rdi
movq %rax, %rsi
callq 0xe069
movq -0x30(%rbp), %rcx
jmp 0x391b5
movq %rdx, %rdi
callq 0xd745
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 0x38429
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 0xf5e4
movq $0x20, 0x10(%rax)
movups 0xa74ea(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0xa74ef(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_type_Value_type
static struct mirth_type_Type mw_mirth_type_Value_type (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 = mw_mirth_type_Type_Int();
			branch_Type_6 = v8;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case mirth_type_Value_F64: {
			double v9 = mtp_mirth_type_Value_F64(in_Value_2);
			struct mirth_type_Type v10 = mw_mirth_type_Type_F64();
			branch_Type_6 = v10;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case mirth_type_Value_Str: {
			STR* v11 = mtp_mirth_type_Value_Str(in_Value_2);
			decref(MKSTR(v11));
			struct mirth_type_Type v12 = mw_mirth_type_Type_Str();
			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_mirth_zaMirth* v14;
			struct mirth_type_ArrowType* v15 = mw_mirth_arrow_Block_type(in_zaMirth_1, v13, &v14);
			struct mirth_type_Type v16 = mtw_mirth_type_Type_Arrow(v15);
			branch_Type_6 = v16;
			branch_zaMirth_5 = v14;
		} 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 0x39e05
movq %rcx, %rbx
movq %rdi, %r14
movl %esi, %eax
leaq 0xa4d0d(%rip), %rcx     # 0xdea2c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rdx, %rdi
callq 0x2d85f
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x39d5e
decl (%rcx)
jne 0x39d5e
leaq 0xd76d3(%rip), %rsi     # 0x111429
movq %rax, %rdi
callq 0xd13d
movl $0x5, %edi
jmp 0x39deb
movq %rdx, %rdi
callq 0x2d89a
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x39d9e
decl (%rcx)
jne 0x39d9e
leaq 0xd73c3(%rip), %rsi     # 0x111159
movq %rax, %rdi
callq 0xd13d
movl $0x12, %edi
jmp 0x39deb
movq 0x8(%rdx), %r15
decl (%rdx)
jne 0x39db5
movq %rdx, %rdi
callq 0x5030
leaq -0x28(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3a37e
movq %rax, %rdi
callq 0x34fb2
movq (%r12), %r14
movl $0xa, %eax
jmp 0x39df5
decl (%rdx)
jne 0x39de6
movq %rdx, %rdi
callq 0x5030
movl $0x10, %edi
callq 0x1eb4d
movl $0x2, %eax
movq %r14, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0xa68af(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0xa68b4(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_either_Either_2_rightzy
static struct std_maybe_Maybe_1 mw_std_either_Either_2_rightzy (struct std_either_Either_2 in_Either_1) {
	struct std_maybe_Maybe_1 branch_Maybe_3;
	switch ((in_Either_1).tag) {
		case std_either_Either_2_Left: {
			VAL v4 = mtp_std_either_Either_2_Left(in_Either_1);
			decref(v4);
			struct std_maybe_Maybe_1 v5 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_3 = v5;
		} break;
		case std_either_Either_2_Right: {
			VAL v6 = mtp_std_either_Either_2_Right(in_Either_1);
			struct std_maybe_Maybe_1 v7 = mtw_std_maybe_Maybe_1_Some(v6);
			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
cmpl $0x1, %edi
je 0x39e82
testl %ebx, %ebx
jne 0x39e9e
movq %rsi, %rdi
callq 0x20a5a
testb $0x1, %dl
je 0x39e7e
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %sil
testb $0x3, %al
setne %dil
orb %sil, %dil
jne 0x39e7e
decl (%rcx)
jne 0x39e7e
movq %rax, %rdi
movq %rdx, %rsi
callq 0xd13d
xorl %edx, %edx
jmp 0x39e95
movq %rsi, %rdi
callq 0x20aa1
movq %rax, %rdi
movq %rdx, %rsi
callq 0x9353
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0xa6816(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0xa681b(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_type_StackTypeBase_Var
static struct mirth_type_StackTypeBase mtw_mirth_type_StackTypeBase_Var (uint64_t in_Var_1) {
	struct mirth_type_StackTypeBase_Var* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mVar = in_Var_1;
	struct mirth_type_StackTypeBase v4 = { .tag=mirth_type_StackTypeBase_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 0x39efc
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xaaeb5(%rip), %rsi     # 0xe4db8
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_type_StackTypeBase_Meta
static struct mirth_type_StackTypeBase mtw_mirth_type_StackTypeBase_Meta (uint64_t in_MetaVar_1) {
	struct mirth_type_StackTypeBase_Meta* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mMetaVar = in_MetaVar_1;
	struct mirth_type_StackTypeBase v4 = { .tag=mirth_type_StackTypeBase_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 0x39f4f
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xaae94(%rip), %rsi     # 0xe4dea
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52b6
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O3/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_either_Either_2_leftzy
static struct std_maybe_Maybe_1 mw_std_either_Either_2_leftzy (struct std_either_Either_2 in_Either_1) {
	struct std_maybe_Maybe_1 branch_Maybe_3;
	switch ((in_Either_1).tag) {
		case std_either_Either_2_Left: {
			VAL v4 = mtp_std_either_Either_2_Left(in_Either_1);
			struct std_maybe_Maybe_1 v5 = mtw_std_maybe_Maybe_1_Some(v4);
			branch_Maybe_3 = v5;
		} break;
		case std_either_Either_2_Right: {
			VAL v6 = mtp_std_either_Either_2_Right(in_Either_1);
			decref(v6);
			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
cmpl $0x1, %edi
je 0x39f9b
testl %edi, %edi
jne 0x39fd9
movq %rsi, %rdi
callq 0x20a5a
movq %rax, %rdi
movq %rdx, %rsi
callq 0x9353
movl $0x1, %eax
jmp 0x39fd7
movq %rsi, %rdi
callq 0x20aa1
testb $0x1, %dl
je 0x39fd3
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %sil
testb $0x3, %al
setne %dil
orb %sil, %dil
jne 0x39fd3
decl (%rcx)
jne 0x39fd3
movq %rax, %rdi
movq %rdx, %rsi
callq 0xd13d
xorl %eax, %eax
xorl %edx, %edx
popq %rbp
retq
movl $0x20, %edi
callq 0xf5e4
movq $0x20, 0x10(%rax)
movups 0xa66db(%rip), %xmm0    # 0xe06cd
movups %xmm0, 0x18(%rax)
movups 0xa66e0(%rip), %xmm0    # 0xe06dd
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x9302