LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x31c59
incl (%rax)
movl 0x28(%r14), %r15d
movq 0x30(%r14), %r12
andq %r12, %rcx
sete %sil
testb $0x3, %r12b
setne %dil
orb %sil, %dil
jne 0x31c77
incl (%rcx)
testb %dl, %dl
je 0x31c8e
decl (%rax)
jne 0x31c8e
leaq 0xd771b(%rip), %rsi     # 0x1093a1
movq %r14, %rdi
callq 0xce94
movq %r14, %rdi
callq 0x37b22
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_O2/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
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x31d00
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 0xa702e(%rip), %rsi     # 0xd8d35
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x20(%rbp), %r14
movq %r14, %rdx
callq 0x252f3
movq (%r14), %r14
movl %eax, %edi
movq %rdx, %rsi
callq 0x2e190
cmpl $0x1, %eax
jne 0x32286
movq %rdx, %rdi
callq 0xd491
leaq -0x18(%rbp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x1c901
movq %rax, %r14
movq 0x10da790(%rip), %rsi   # 0x110c9c8
testq %rsi, %rsi
jne 0x32256
leaq 0xa7566(%rip), %rdi     # 0xd97aa
pushq $0x2
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x10da772(%rip)   # 0x110c9c8
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x32273
incl (%rax)
movq %r14, %rdi
callq 0xd769
testl %eax, %eax
sete %al
movq -0x18(%rbp), %r14
jmp 0x32288
xorl %eax, %eax
movq %r14, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq -0x20(%rbp), %r14
movq %r14, %rdx
callq 0x252f3
movq (%r14), %r14
movl %eax, %edi
movq %rdx, %rsi
callq 0x2e190
cmpl $0x1, %eax
jne 0x3232f
movq %rdx, %rdi
callq 0xd491
leaq -0x18(%rbp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x1c901
movq %rax, %r14
movq 0x10da6ef(%rip), %rsi   # 0x110c9d0
testq %rsi, %rsi
jne 0x322ff
leaq 0xa3b14(%rip), %rdi     # 0xd5e01
pushq $0x2
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x10da6d1(%rip)   # 0x110c9d0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x3231c
incl (%rax)
movq %r14, %rdi
callq 0xd769
testl %eax, %eax
sete %al
movq -0x18(%rbp), %r14
jmp 0x32331
xorl %eax, %eax
movq %r14, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x3236d
movq %rax, %rdx
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
pushq $0xa
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xa6a29(%rip), %rsi     # 0xd8d9d
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_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 0x3abf1
movq (%rbx), %rdi
leaq -0x48(%rbp), %rbx
leaq -0x40(%rbp), %r14
testb $0x1, %al
jne 0x3240c
movq %r13, %rsi
leaq -0x50(%rbp), %rdx
movq %rbx, %rcx
callq 0x3ac59
movq %rdx, %rcx
movl %r12d, %edi
movq %r15, %rsi
movl %eax, %edx
callq 0x328f2
movl %eax, %r12d
movq %rdx, %r15
movq -0x48(%rbp), %r13
movq 0x10(%r13), %rsi
movq -0x50(%rbp), %rdi
movq %r14, %rdx
callq 0x3abf1
movq -0x40(%rbp), %rdi
jmp 0x323c9
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_O2/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 $0x28, %rsp
movq %rdx, %rbx
leaq -0x40(%rbp), %r14
movq %r14, %rdx
callq 0x252f3
movq (%r14), %r12
movl %eax, %edi
movq %rdx, %rsi
callq 0x2e190
cmpl $0x1, %eax
jne 0x3255d
movq %rbx, -0x30(%rbp)
movq %rdx, %rdi
callq 0xd491
movq %rax, %r15
movq %rdx, %r14
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
testb $0x1, %r14b
je 0x3249d
movq %r15, %rax
andq %rcx, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x3249d
incl (%rax)
leaq -0x48(%rbp), %rbx
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1c899
movl %eax, %edi
callq 0xd86d
movq %rax, %rdi
callq 0xdc43
movq %rax, %r13
movq (%rbx), %rdi
leaq -0x38(%rbp), %rdx
movq %r15, %rsi
callq 0x1c8cd
movl %eax, %r12d
movq %r12, %rdi
callq 0xd86d
movq %rax, %rdi
callq 0xdc43
movzbl %al, %eax
cmpl $0x61, %eax
jae 0x324ef
xorl %eax, %eax
jmp 0x32508
movq %r12, %rdi
callq 0xd86d
movq %rax, %rdi
callq 0xdc43
movzbl %al, %eax
cmpl $0x7b, %eax
setb %al
movq -0x38(%rbp), %r12
cmpb $0x2a, %r13b
movq -0x30(%rbp), %rbx
jne 0x3252a
testb %al, %al
je 0x3252a
movq %r15, %rdi
movq %r14, %rsi
callq 0x8d0c
pushq $0x1
popq %rax
jmp 0x32561
testb $0x1, %r14b
je 0x3255d
movq %r15, %rax
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rcx, %rax
sete %cl
testb $0x3, %r15b
setne %dl
orb %cl, %dl
jne 0x3255d
decl (%rax)
jne 0x3255d
movq %r15, %rdi
movq %r14, %rsi
callq 0xce94
xorl %eax, %eax
xorl %edx, %edx
movq %r12, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x2, %esi
je 0x328a5
cmpl $0x4, %esi
jne 0x328a9
movq %rdx, %rdi
callq 0x36dc8
leaq -0x20(%rbp), %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x36f87
movq (%r15), %r14
jmp 0x328e4
movb $0x1, %al
jmp 0x328e4
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %dil
orb %cl, %dil
jne 0x328e2
decl (%rax)
jne 0x328e2
shlq $0x30, %rsi
orq %rdx, %rsi
leaq 0xd6a3a(%rip), %rax     # 0x109311
movq %rsi, %rdi
movq %rax, %rsi
callq 0xce94
xorl %eax, %eax
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 0x329ab
movq %rsi, %rbx
movl %edi, %r14d
movl %edx, %eax
leaq 0x9ff30(%rip), %rdx     # 0xd2844
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq %rcx, %rdi
callq 0x3aac9
movq %rdx, %rcx
movl %r14d, %edi
movq %rbx, %rsi
movl %eax, %edx
callq 0x1e310
pushq $0x5
jmp 0x3299f
movq %rcx, %rdi
callq 0x3ab5d
movq %rdx, %rcx
movl %r14d, %edi
movq %rbx, %rsi
movl %eax, %edx
callq 0x1e82b
pushq $0x7
jmp 0x3299f
leaq -0x20(%rbp), %r15
movq %rcx, %rdi
movq %r15, %rsi
callq 0x3ab9d
movq %rdx, %rcx
movq (%r15), %r8
movl %r14d, %edi
movq %rbx, %rsi
movl %eax, %edx
callq 0x39a7a
pushq $0x8
jmp 0x3299f
leaq -0x20(%rbp), %r15
movq %rcx, %rdi
movq %r15, %rsi
callq 0x3ab09
movq %rdx, %rcx
movq (%r15), %r8
movl %r14d, %edi
movq %rbx, %rsi
movl %eax, %edx
callq 0x393fa
pushq $0x6
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa1e5b(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x32ca6
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xa67aa(%rip), %rsi     # 0xd9457
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_var_Var_type
static struct mirth_type_Type mw_mirth_var_Var_type (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Var_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_var_Var_type, in_Var_2);
	VAL v6 = mut_get(v5);
	*out_zaMirth_3 = in_zaMirth_1;
	return V_mirth_type_Type(v6);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10d9138(%rip), %rdi   # 0x110bff0
callq 0x12f88
movq %rax, %rdi
callq 0x1307d
movq %r14, (%rbx)
movabsq $0xfffffffffffc, %rdx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdx
shrq $0x30, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_mirth_zaMirth_errorzx
static void mw_mirth_mirth_zaMirth_errorzx (struct mirth_mirth_zaMirth* in_zaMirth_1, STR* in_Str_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v4;
	struct mirth_location_Location* v5 = mw_mirth_mirth_zaMirth_errorzelocation(in_zaMirth_1, &v4);
	struct mirth_mirth_zaMirth* v6;
	mw_mirth_mirth_zaMirth_emitzeerrorzeatzx(v4, v5, in_Str_2, &v6);
	*out_zaMirth_3 = v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x28(%rbp), %r15
movq %r15, %rsi
callq 0x196e5
movq (%r15), %rdi
leaq -0x20(%rbp), %r15
movq %rax, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x19808
movq (%r15), %rax
movq %rax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_var_Var_name
static uint64_t mw_mirth_var_Var_name (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Var_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_var_Var_name, in_Var_2);
	VAL v6 = mut_get(v5);
	*out_zaMirth_3 = in_zaMirth_1;
	return V_mirth_name_Name(v6);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10d801f(%rip), %rdi   # 0x110bfe0
callq 0x12f88
movq %rax, %rdi
callq 0x1307d
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 0x10d828e(%rip), %r14   # 0x110c780
testq %r14, %r14
jne 0x3450f
leaq 0xa81f7(%rip), %rdi     # 0xdc6f5
xorl %esi, %esi
callq 0x8a21
movq %rax, %r14
movq %rax, 0x10d8271(%rip)   # 0x110c780
movabsq $0xfffffffffffc, %r15   # imm = 0xFFFFFFFFFFFC
movq %r14, %rax
andq %r15, %rax
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x3452f
incl (%rax)
movq %r13, %rdi
callq 0x351c6
pushq $0x4
popq %rdx
leaq -0x58(%rbp), %r8
leaq -0x50(%rbp), %r9
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq 0x3520f
movq 0x10d8231(%rip), %rsi   # 0x110c788
testq %rsi, %rsi
jne 0x34575
leaq 0xa499f(%rip), %rdi     # 0xd8f02
pushq $0x3
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x10d8213(%rip)   # 0x110c788
movq %rsi, %rax
andq %r15, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
movl -0x2c(%rbp), %r13d
jne 0x3458f
incl (%rax)
movq -0x50(%rbp), %rdi
callq 0xd8b0
movq %rbx, %rcx
andq %r15, %rcx
sete %dl
testb $0x3, %bl
setne %sil
orb %dl, %sil
jne 0x345af
incl (%rcx)
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %r8
leaq -0x40(%rbp), %r9
movq %rax, %rsi
movl %r13d, %edx
movq %rbx, %rcx
callq 0x3520f
movq 0x10d81c0(%rip), %rsi   # 0x110c790
testq %rsi, %rsi
jne 0x345ee
leaq 0xa140a(%rip), %rdi     # 0xd59e6
pushq $0x1
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x10d81a2(%rip)   # 0x110c790
andq %rsi, %r15
sete %al
testb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x34602
incl (%r15)
movq -0x40(%rbp), %rdi
callq 0xd8b0
movq %rax, %r14
movq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %r12
movq %r12, %rsi
callq 0x196e5
movq (%r12), %rdi
leaq -0x68(%rbp), %r12
movq %rax, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
movq %r12, %r8
callq 0x199e6
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_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
leaq -0x28(%rbp), %rdx
callq 0x2aadc
testl %eax, %eax
je 0x346b1
cmpl $0x1, %eax
jne 0x346f1
movq %rdx, %rdi
callq 0xd491
movq -0x28(%rbp), %rdi
movabsq $0xfffffffffffc, %rdx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rdx
movq %rax, %rsi
shrq $0x30, %rsi
leaq -0x30(%rbp), %r15
movq %r15, %rcx
callq 0x33fd6
movl %eax, %r14d
movq (%r15), %rax
jmp 0x346de
leaq 0xd4431(%rip), %rsi     # 0x108ae9
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x8d0c
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %r12
movq %rdx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x2ab8f
movq (%r12), %rax
xorl %edx, %edx
movq %rax, (%rbx)
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa0115(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 %rbx
pushq %rax
cmpl $0x3, %esi
ja 0x34ab0
movq %rcx, %rbx
movq %rdi, %r14
movl %esi, %eax
leaq 0x9df5e(%rip), %rcx     # 0xd2960
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rdx, %rdi
callq 0x2af3e
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x34a9e
decl (%rcx)
jne 0x34a9e
leaq 0xd39f0(%rip), %rsi     # 0x108429
jmp 0x34a69
movq %rdx, %rdi
callq 0x2afa0
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x34a9e
decl (%rcx)
jne 0x34a9e
leaq 0xd36f0(%rip), %rsi     # 0x108159
movq %rax, %rdi
callq 0xce94
jmp 0x34a9e
movq %rdx, %rdi
callq 0x2afdb
leaq -0x20(%rbp), %r15
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r15, %r8
callq 0x37895
movq (%r15), %r14
jmp 0x34aa2
movq %rdx, %rdi
callq 0x2af79
xorl %eax, %eax
xorl %edx, %edx
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9fd56(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x34afd
movq %rax, %rdx
movl $0x1, (%rax)
movl %r14d, 0x8(%rax)
movq %rbx, 0x10(%rax)
pushq $0xd
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xa45f5(%rip), %rsi     # 0xd90f9
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_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 %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x4, %esi
jne 0x34e10
movq %rdx, %rdi
callq 0x34e20
leaq -0x20(%rbp), %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x2ae07
movl %eax, %edi
movq %rdx, %rsi
callq 0x34e3d
movq (%r15), %r14
jmp 0x34e12
movl %esi, %eax
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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
cmpl $0x9, %edi
ja 0x34e94
movl %edi, %eax
movl %edi, %ecx
leaq 0x9db43(%rip), %rdx     # 0xd2994
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorl %edx, %edx
jmp 0x34e92
movq %rsi, %rdi
callq 0x2acc0
jmp 0x34e92
movq %rsi, %rdi
callq 0x2aabf
movq %rax, %rdi
callq 0x35177
pushq $0x4
jmp 0x34e91
movq %rsi, %rdi
callq 0x2abf3
movq %rax, %rdi
callq 0x32c7c
movq %rax, %rdx
pushq $0x3
popq %rax
popq %rbp
retq
movq 0x10d78dd(%rip), %rdi   # 0x110c778
testq %rdi, %rdi
jne 0x34eb9
leaq 0xa3f8e(%rip), %rdi     # 0xd8e35
pushq $0x32
popq %rsi
callq 0x8a21
movq %rax, %rdi
movq %rax, 0x10d78bf(%rip)   # 0x110c778
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdi, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x34ed6
incl (%rax)
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/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 0x34f57
movabsq $0xfffffffffffc, %rdi   # imm = 0xFFFFFFFFFFFC
movq %r15, %rcx
andq %rdi, %rcx
sete %dl
testb $0x3, %r15b
setne %sil
orb %dl, %sil
jne 0x34f42
incl (%rcx)
andq %r14, %rdi
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x34f62
incl (%rdi)
jmp 0x34f62
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_O2/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 0x34fde
movabsq $0xfffffffffffc, %rdi   # imm = 0xFFFFFFFFFFFC
movq %r15, %rcx
andq %rdi, %rcx
sete %dl
testb $0x3, %r15b
setne %sil
orb %dl, %sil
jne 0x34fc9
incl (%rcx)
andq %r14, %rdi
sete %cl
testb $0x3, %r14b
setne %dl
orb %cl, %dl
jne 0x34fe9
incl (%rdi)
jmp 0x34fe9
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_O2/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 0x35098
movabsq $0xfffffffffffc, %rdi   # imm = 0xFFFFFFFFFFFC
movq %r15, %rcx
andq %rdi, %rcx
sete %r8b
testb $0x3, %r15b
setne %sil
orb %r8b, %sil
jne 0x35081
incl (%rcx)
andq %r12, %rdi
sete %cl
testb $0x3, %r12b
setne %sil
orb %cl, %sil
jne 0x350b3
incl (%rdi)
jmp 0x350b3
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_O2/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 0x3513c
movabsq $0xfffffffffffc, %rdi   # imm = 0xFFFFFFFFFFFC
movq %r15, %rcx
andq %rdi, %rcx
sete %r8b
testb $0x3, %r15b
setne %sil
orb %r8b, %sil
jne 0x35125
incl (%rcx)
andq %r12, %rdi
sete %cl
testb $0x3, %r12b
setne %sil
orb %cl, %sil
jne 0x35157
incl (%rdi)
jmp 0x35157
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_O2/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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x351a7
movq %rax, %rdx
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
pushq $0x4
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xa3cba(%rip), %rsi     # 0xd8e68
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x351f0
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xa3d0f(%rip), %rsi     # 0xd8f06
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_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 0x2aadc
cmpl $0x1, %eax
je 0x35e3a
testl %eax, %eax
jne 0x35e8d
movq 0x10d6a0d(%rip), %rsi   # 0x110c7e0
testq %rsi, %rsi
jne 0x35df1
leaq 0xa1812(%rip), %rdi     # 0xd75f1
pushq $0x1
popq %rsi
callq 0x8a21
movq %rax, %rsi
movq %rax, 0x10d69ef(%rip)   # 0x110c7e0
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0x35e0e
incl (%rax)
movq %r15, %rdi
callq 0xd8b0
movq %rax, %r15
movq %r12, %rdi
callq 0xdbc8
movq %rax, %rdi
callq 0xf51c
movq %r15, %rdi
movq %rax, %rsi
callq 0xd8b0
movq -0x30(%rbp), %rcx
jmp 0x35e78
movq %rdx, %rdi
callq 0xd491
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 0x3520f
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
leaq 0x9e979(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_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 %rbx
pushq %rax
cmpl $0x3, %esi
ja 0x36afd
movq %rcx, %rbx
movq %rdi, %r14
movl %esi, %eax
leaq 0x9c007(%rip), %rcx     # 0xd2a2c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rdx, %rdi
callq 0x2af3e
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x36a64
decl (%rcx)
jne 0x36a64
leaq 0xd19cd(%rip), %rsi     # 0x108429
movq %rax, %rdi
callq 0xce94
pushq $0x2
popq %r15
callq 0x3707e
jmp 0x36aec
movq %rdx, %rdi
callq 0x2afa0
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %dl
testb $0x3, %al
setne %sil
orb %dl, %sil
jne 0x36aa5
decl (%rcx)
jne 0x36aa5
leaq 0xd16bc(%rip), %rsi     # 0x108159
movq %rax, %rdi
callq 0xce94
pushq $0x2
popq %r15
callq 0x3709c
jmp 0x36aec
movq %rdx, %rdi
callq 0x2afdb
leaq -0x20(%rbp), %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x370ab
movq %rax, %rdi
callq 0x3233d
movq (%r15), %r14
pushq $0xa
popq %r15
jmp 0x36aec
movq %rdx, %rdi
callq 0x2af79
pushq $0x2
popq %r15
callq 0x3708d
movq %r14, (%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9dd09(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_type_Resource_typezj
static void mw_mirth_type_Resource_typezj (struct mirth_mirth_zaMirth* in_zaMirth_1, STR* in_zaStr_2, struct mirth_type_Type in_Resource_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, STR* *out_zaStr_5) {
	struct mirth_type_Type v6 = mw_mirth_type_Resource_zgType(in_Resource_3);
	struct mirth_mirth_zaMirth* v7;
	STR* v8;
	mw_mirth_type_Type_typezj(in_zaMirth_1, in_zaStr_2, v6, &v7, &v8);
	*out_zaStr_5 = v8;
	*out_zaMirth_4 = v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %rbx
movq %r8, %r14
leaq -0x30(%rbp), %r15
leaq -0x28(%rbp), %r12
movq %r15, %r8
movq %r12, %r9
callq 0x3520f
movq (%r12), %rax
movq %rax, (%rbx)
movq (%r15), %rax
movq %rax, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_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 0x36ba3
testl %ebx, %ebx
jne 0x36bbf
movq %rsi, %rdi
callq 0x1e79d
testb $0x1, %dl
je 0x36b9f
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %sil
testb $0x3, %al
setne %dil
orb %sil, %dil
jne 0x36b9f
decl (%rcx)
jne 0x36b9f
movq %rax, %rdi
movq %rdx, %rsi
callq 0xce94
xorl %edx, %edx
jmp 0x36bb6
movq %rsi, %rdi
callq 0x1e7e4
movq %rax, %rdi
movq %rdx, %rsi
callq 0x8d0c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x9dc47(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: 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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x36c00
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xa2354(%rip), %rsi     # 0xd8f5b
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x50c0
testq %rax, %rax
je 0x36c49
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xa233d(%rip), %rsi     # 0xd8f8d
pushq $0x2
popq %rdi
pushq $0x31
popq %rdx
callq 0x5060
callq 0x52ae
pushq $0x1
popq %rdi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O2/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_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 0x36c8d
testl %edi, %edi
jne 0x36ccb
movq %rsi, %rdi
callq 0x1e79d
movq %rax, %rdi
movq %rdx, %rsi
callq 0x8d0c
pushq $0x1
popq %rax
jmp 0x36cc9
movq %rsi, %rdi
callq 0x1e7e4
testb $0x1, %dl
je 0x36cc5
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq %rax, %rcx
sete %sil
testb $0x3, %al
setne %dil
orb %sil, %dil
jne 0x36cc5
decl (%rcx)
jne 0x36cc5
movq %rax, %rdi
movq %rdx, %rsi
callq 0xce94
xorl %eax, %eax
xorl %edx, %edx
popq %rbp
retq
leaq 0x9db3b(%rip), %rdi     # 0xd480d
pushq $0x20
popq %rsi
callq 0x8a21
movq %rax, %rdi
callq 0x8cc6