LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99BranchSplit_endzebranchzesplitzx
static void mw_mirth_c99_zaC99BranchSplit_endzebranchzesplitzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99BranchSplit* in_zaC99BranchSplit_2, struct mirth_mirth_zaMirth* *out_zaMirth_3, struct mirth_c99_zaC99Branch* *out_zaC99Branch_4) {
	struct mirth_c99_zaC99* v5;
	struct mirth_c99_zaC99Stack v6;
	struct std_list_List_1 v7;
	struct std_list_List_1 v8;
	bool v9;
	bool v10;
	mtp_mirth_c99_zaC99BranchSplit_zaC99BranchSplit(in_zaC99BranchSplit_2, &v5, &v6, &v7, &v8, &v9, &v10);
	mw_mirth_c99_zaC99Stack_rdrop(v6);
	struct mirth_mirth_zaMirth* v11;
	struct mirth_c99_zaC99Branch* v12;
	mw_mirth_c99_zaC99_startzebranchzx(in_zaMirth_1, v5, v10, v7, &v11, &v12);
	struct mirth_mirth_zaMirth* v13;
	struct mirth_c99_zaC99Branch* v14;
	mw_std_list_List_1_for_1_sp23(v11, v12, v8, &v13, &v14);
	*out_zaC99Branch_4 = v14;
	*out_zaMirth_3 = v13;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
movq %rdi, -0x48(%rbp)
movq (%rsi), %rax
movq %rax, -0x38(%rbp)
movl 0x8(%rsi), %r14d
movq 0x10(%rsi), %r15
movl 0x18(%rsi), %r12d
movq 0x20(%rsi), %r13
movl 0x28(%rsi), %eax
movl %eax, -0x2c(%rbp)
movq 0x30(%rsi), %rax
movq %rax, -0x40(%rbp)
movzbl 0x39(%rsi), %ebx
movq %rsi, %rdi
callq 0x5030
movl %r14d, %edi
movq %r15, %rsi
callq 0xb890a
leaq -0x60(%rbp), %r14
movq %r14, (%rsp)
andl $0x1, %ebx
movq -0x38(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %r12d, %ecx
movq %r13, %r8
movl %ebx, %r9d
callq 0xb1133
movq (%r14), %rsi
leaq -0x60(%rbp), %rbx
leaq -0x68(%rbp), %r14
movq -0x48(%rbp), %rdi
movl -0x2c(%rbp), %edx
movq -0x40(%rbp), %rcx
movq %rbx, %r8
movq %r14, %r9
callq 0xb103d
movq (%r14), %rax
movq -0x50(%rbp), %rcx
movq %rax, (%rcx)
movq (%rbx), %rax
movq -0x58(%rbp), %rcx
movq %rax, (%rcx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99Branch_refreshzebranchzx
static void mw_mirth_c99_zaC99Branch_refreshzebranchzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99Branch* in_zaC99Branch_2, struct mirth_mirth_zaMirth* *out_zaMirth_3, struct mirth_c99_zaC99Branch* *out_zaC99Branch_4) {
	struct mirth_c99_zaC99* v5;
	struct mirth_c99_zaC99Stack v6;
	struct std_list_List_1 v7;
	bool v8;
	mtp_mirth_c99_zaC99Branch_zaC99Branch(in_zaC99Branch_2, &v5, &v6, &v7, &v8);
	struct mirth_mirth_zaMirth* v9;
	struct mirth_c99_zaC99Branch* v10;
	mw_mirth_c99_zaC99Stack_refreshzeallzx(in_zaMirth_1, v5, v6, v8, v7, &v9, &v10);
	*out_zaC99Branch_4 = v10;
	*out_zaMirth_3 = v9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rdi, %r15
movq (%rsi), %r12
movl 0x8(%rsi), %r13d
movq 0x10(%rsi), %rbx
movups 0x18(%rsi), %xmm0
movaps %xmm0, -0x50(%rbp)
movzbl 0x28(%rsi), %r14d
movq %rsi, %rdi
callq 0x5030
movaps -0x50(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq -0x40(%rbp), %rax
movq %rax, 0x10(%rsp)
andl $0x1, %r14d
leaq -0x58(%rbp), %rax
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
movq %rbx, %rcx
movl %r14d, %r8d
movq %rax, %rbx
movq %rax, %r9
callq 0xdd2b0
leaq -0x40(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
movq (%rbx), %rax
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99Value_rdup
static void mw_mirth_c99_zaC99Value_rdup (struct mirth_c99_zaC99Value* in_zaC99Value_1, struct mirth_c99_zaC99Value* *out_zaC99Value_2, struct mirth_c99_zaC99Value* *out_zaC99Value_3) {
	struct mirth_c99_C99ReprType v4 = in_zaC99Value_1->mvaluezerepr;
	incref(MK_mirth_c99_C99ReprType(v4));
	STR* v5 = in_zaC99Value_1->mvaluezename;
	incref(MKSTR(v5));
	struct mirth_c99_zaC99Value* v6;
	mtw_mirth_c99_zaC99Value_zaC99Value(v4, v5, &v6);
	*out_zaC99Value_3 = v6;
	*out_zaC99Value_2 = in_zaC99Value_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movl (%rdi), %edi
movq 0x8(%r15), %rsi
movq %rsi, %rcx
andq %rax, %rcx
sete %dl
testb $0x3, %sil
setne %r8b
orb %dl, %r8b
jne 0xdb315
incl (%rcx)
movq 0x10(%r15), %rdx
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %r8b
orb %cl, %r8b
jne 0xdb32d
incl (%rax)
leaq -0x28(%rbp), %r12
movq %r12, %rcx
callq 0xb13d2
movq (%r12), %rax
movq %rax, (%r14)
movq %r15, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99Resource_rdup
static void mw_mirth_c99_zaC99Resource_rdup (struct mirth_c99_zaC99Resource* in_zaC99Resource_1, struct mirth_c99_zaC99Resource* *out_zaC99Resource_2, struct mirth_c99_zaC99Resource* *out_zaC99Resource_3) {
	struct mirth_c99_C99ReprType v4 = in_zaC99Resource_1->mresourcezerepr;
	incref(MK_mirth_c99_C99ReprType(v4));
	STR* v5 = in_zaC99Resource_1->mresourcezename;
	incref(MKSTR(v5));
	struct mirth_c99_zaC99Resource* v6;
	mtw_mirth_c99_zaC99Resource_zaC99Resource(v4, v5, &v6);
	*out_zaC99Resource_3 = v6;
	*out_zaC99Resource_2 = in_zaC99Resource_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movl (%rdi), %edi
movq 0x8(%r15), %rsi
movq %rsi, %rcx
andq %rax, %rcx
sete %dl
testb $0x3, %sil
setne %r8b
orb %dl, %r8b
jne 0xdb545
incl (%rcx)
movq 0x10(%r15), %rdx
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %r8b
orb %cl, %r8b
jne 0xdb55d
incl (%rax)
leaq -0x28(%rbp), %r12
movq %r12, %rcx
callq 0xb1525
movq (%r12), %rax
movq %rax, (%r14)
movq %r15, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_c99zetupzepackzx
static void mw_mirth_c99_c99zetupzepackzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99Branch* in_zaC99Branch_2, INT in_Nat_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_c99_zaC99Branch* *out_zaC99Branch_5) {
	struct std_maybe_Maybe_1 v6 = { .tag=std_maybe_Maybe_1_None };
	struct std_list_List_1 v7 = mw_std_list_List_1_List_1_sp13(in_Nat_3);
	struct mirth_mirth_zaMirth* v8;
	struct mirth_c99_zaC99Branch* v9;
	struct mirth_c99_zaC99Resource* v10;
	mw_mirth_c99_c99zepackzetuplezx(in_zaMirth_1, in_zaC99Branch_2, v6, v7, &v8, &v9, &v10);
	struct mirth_c99_zaC99Value* v11;
	mw_mirth_c99_zaC99Resource_turnzeintozevaluezx(v10, &v11);
	struct mirth_mirth_zaMirth* v12;
	struct mirth_c99_zaC99Branch* v13;
	mw_mirth_c99_zaC99Value_pushzevaluezx(v8, v9, v11, &v12, &v13);
	*out_zaC99Branch_5 = v13;
	*out_zaMirth_4 = v12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rdi
callq 0xde2a1
movq %rdx, %rcx
leaq -0x48(%rbp), %rbx
movq %rbx, (%rsp)
leaq -0x50(%rbp), %r13
leaq -0x40(%rbp), %r9
movq %r12, %rdi
movq %r15, %rsi
movl %eax, %edx
movq %r13, %r8
callq 0xde3f6
movq (%rbx), %rdi
movl (%rdi), %r15d
movq 0x8(%rdi), %r12
movq 0x10(%rdi), %r14
callq 0x5030
leaq -0x60(%rbp), %rbx
movl %r15d, %edi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xb13d2
movq (%rbx), %rdx
movq (%r13), %r14
leaq -0x40(%rbp), %rax
movq (%rax), %r15
movl 0x8(%r15), %edi
movq 0x10(%r15), %rsi
movq %rbx, %rcx
callq 0xb1439
movups (%rbx), %xmm0
movups %xmm0, 0x8(%r15)
movq -0x30(%rbp), %rax
movq %r15, (%rax)
movq -0x38(%rbp), %rax
movq %r14, (%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_maybe_Maybe_1_unwrap_1_sp5
static VAL mw_std_maybe_Maybe_1_unwrap_1_sp5 (struct mirth_mirth_zaMirth* in_zaMirth_1, struct std_maybe_Maybe_1 in_Maybe_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* branch_zaMirth_5;
	VAL branch_zux1_6;
	switch ((in_Maybe_2).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v7 = mtp_std_maybe_Maybe_1_Some(in_Maybe_2);
			branch_zux1_6 = v7;
			branch_zaMirth_5 = in_zaMirth_1;
		} break;
		case std_maybe_Maybe_1_None: {
			STR* v8;
			STRLIT(v8, "c99 error: tried to pop from invalid stack type", 47);
			mw_mirth_mirth_zaMirth_fatalzeerrorzx(in_zaMirth_1, v8);
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_3 = branch_zaMirth_5;
	return branch_zux1_6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, %esi
jne 0xdd00b
movq %rcx, %r14
movq %rdx, %rdi
callq 0xdaeb
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
testl %esi, %esi
jne 0xdd07f
cmpq $0x0, 0x10402f9(%rip)   # 0x111d310
jne 0xdd053
movl $0x2f, %edi
callq 0xf9f7
movq $0x2f, 0x10(%rax)
movups 0x21622(%rip), %xmm0    # 0xfe654
movups %xmm0, 0x18(%rax)
movups 0x21627(%rip), %xmm0    # 0xfe664
movups %xmm0, 0x28(%rax)
movups 0x2162b(%rip), %xmm0    # 0xfe673
movups %xmm0, 0x37(%rax)
movq %rax, 0x10402bd(%rip)   # 0x111d310
movq 0x10402b6(%rip), %rsi   # 0x111d310
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rsi, %rax
sete %cl
testb $0x3, %sil
setne %dl
orb %cl, %dl
jne 0xdd077
incl (%rax)
movq %rbx, %rdi
callq 0x15000
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0x76b5(%rip), %xmm0     # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0x76ba(%rip), %xmm0     # 0xe475d
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x95a5
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_list_List_1_List_1_sp13
static struct std_list_List_1 mw_std_list_List_1_List_1_sp13 (INT in_Nat_1) {
	struct std_list_List_1 v3 = { .tag=std_list_List_1_Nil };
	struct std_list_List_1 v4;
	mw_std_list_List_1_buildzx(v3, &v4);
	incref(MKNAT(in_Nat_1));
	INT v5 = WRAP_I63(0LL);
	INT v6 = in_Nat_1;
	INT v7 = v5;
	bool v8 = int_lt(v7, v6);
	struct std_list_List_1 r9 = v4;
	INT v10 = in_Nat_1;
	bool v11 = v8;
	while (v11) {
		struct std_list_List_1 r12 = r9;
		INT v13 = v10;
		struct mirth_type_Type v14 = { .tag=mirth_type_Type_Ignore };
		struct mirth_type_StackTypePart v15 = mtw_mirth_type_StackTypePart_Cons(v14);
		struct std_list_List_1 v16;
		mw_std_list_zaLister_1_pushzx(MK_mirth_type_StackTypePart(v15), r12, &v16);
		INT v17 = WRAP_I63(1LL);
		INT v18 = v13;
		INT v19 = v17;
		INT v20 = int_sub(v18, v19);
		incref(MKINT(v20));
		INT v21 = WRAP_I63(0LL);
		INT v22 = v21;
		bool v23 = int_le(v22, v20);
		INT branch_Nat_24;
		if (v23) {
			INT v25 = v20;
			branch_Nat_24 = v25;
		} else {
			decref(MKINT(v20));
			INT v26 = WRAP_I63(0LL);
			branch_Nat_24 = v26;
		}
		incref(MKNAT(branch_Nat_24));
		INT v27 = WRAP_I63(0LL);
		INT v28 = branch_Nat_24;
		INT v29 = v27;
		bool v30 = int_lt(v29, v28);
		v11 = v30;
		v10 = branch_Nat_24;
		r9 = v16;
	}
	decref(MKNAT(v10));
	struct std_list_List_1 v31 = mw_std_list_zaLister_1_donezx(r9);
	return v31;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xd37c
movl %eax, %r13d
movq %rdx, %r15
movq %rbx, %rax
andq %r14, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xde2e7
incl (%rax)
movl $0x1, %edi
movq %rbx, %rsi
callq 0xec04
testl %eax, %eax
jns 0xde3b5
movl $0x1, %edi
xorl %esi, %esi
callq 0x206d0
movq %rdx, %rdi
leaq 0x379cf(%rip), %rsi     # 0x115ce1
movl %r13d, %edx
movq %r15, %rcx
leaq -0x38(%rbp), %r8
callq 0x9741
movl $0x3, %esi
movq %rbx, %rdi
callq 0xedca
movq %rax, %r15
movq %rax, %r13
andq %r14, %r13
sete %al
testb $0x3, %r15b
setne %r12b
orb %al, %r12b
jne 0xde34b
incl (%r13)
movl $0x1, %edi
movq %r15, %rsi
callq 0xec04
movq %r15, %rbx
testl %eax, %eax
setle %al
jle 0xde367
movl $0x1, %ebx
orb %al, %r12b
jne 0xde386
decl (%r13)
movl $0x1, %ebx
jne 0xde386
movq %r15, %rdi
leaq 0x370a8(%rip), %rsi     # 0x115429
callq 0xd4e3
movq %rbx, %rax
andq %r14, %rax
sete %cl
testb $0x3, %bl
setne %dl
orb %cl, %dl
jne 0xde39b
incl (%rax)
movl $0x1, %edi
movq %rbx, %rsi
callq 0xec04
movl -0x38(%rbp), %r13d
movq -0x30(%rbp), %r15
jmp 0xde2f4
andq %rbx, %r14
sete %al
testb $0x3, %bl
setne %cl
orb %al, %cl
jne 0xde3d9
decl (%r14)
jne 0xde3d9
leaq 0x36d40(%rip), %rsi     # 0x115111
movq %rbx, %rdi
callq 0xd4e3
xorl %edi, %edi
xorl %esi, %esi
movl %r13d, %edx
movq %r15, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd37c
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_C99ReprType_vzemacro_1_sp4
static void mw_mirth_c99_C99ReprType_vzemacro_1_sp4 (STR* in_Str_1, struct mirth_c99_C99ReprType in_C99ReprType_2, struct mirth_mirth_zaMirth* in_zaMirth_3, struct mirth_c99_zaC99* in_zaC99_4, struct mirth_mirth_zaMirth* *out_zaMirth_5, struct mirth_c99_zaC99* *out_zaC99_6) {
	struct mirth_mirth_zaMirth* v7;
	STR* v8;
	STR* v9 = mw_mirth_c99_C99ReprType_vzemacrozeprefixzesuffix(in_zaMirth_3, in_C99ReprType_2, &v7, &v8);
	struct mirth_mirth_zaMirth* v10;
	struct mirth_c99_zaC99* v11;
	mw_mirth_c99_zaC99_put(v7, in_zaC99_4, v9, &v10, &v11);
	struct mirth_mirth_zaMirth* v12;
	struct mirth_c99_zaC99* v13;
	mw_mirth_c99_zaC99_put(v10, v11, in_Str_1, &v12, &v13);
	struct mirth_mirth_zaMirth* v14;
	struct mirth_c99_zaC99* v15;
	mw_mirth_c99_zaC99_put(v12, v13, v8, &v14, &v15);
	*out_zaC99_6 = v15;
	*out_zaMirth_5 = v14;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, -0x30(%rbp)
movq %r8, %r12
movq %rdi, %r15
leaq -0x70(%rbp), %r13
leaq -0x68(%rbp), %r14
movq %rcx, %rdi
movq %r13, %rcx
movq %r14, %r8
callq 0xb403c
movq (%r13), %rdi
leaq -0x60(%rbp), %r13
leaq -0x58(%rbp), %rbx
movq %r12, %rsi
movq %rax, %rdx
movq %r13, %rcx
movq %rbx, %r8
callq 0x94972
movq (%r13), %rdi
movq (%rbx), %rsi
leaq -0x50(%rbp), %rbx
leaq -0x48(%rbp), %r12
movq %r15, %rdx
movq %rbx, %rcx
movq %r12, %r8
callq 0x94972
movq (%rbx), %rdi
movq (%r12), %rsi
movq (%r14), %rdx
leaq -0x40(%rbp), %rbx
leaq -0x38(%rbp), %r14
movq %rbx, %rcx
movq %r14, %r8
callq 0x94972
movq (%r14), %rax
movq 0x10(%rbp), %rcx
movq %rax, (%rcx)
movq (%rbx), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99ValuezfResource_rdup
static void mw_mirth_c99_zaC99ValuezfResource_rdup (struct std_either_zaEither_2 in_zaC99ValuezfResource_1, struct std_either_zaEither_2 *out_zaC99ValuezfResource_2, struct std_either_zaEither_2 *out_zaC99ValuezfResource_3) {
	struct std_either_zaEither_2 branch_zaEither_4;
	struct std_either_zaEither_2 branch_zaEither_5;
	switch ((in_zaC99ValuezfResource_1).tag) {
		case std_either_zaEither_2_zaLeft: {
			VAL v6;
			mtp_std_either_zaEither_2_zaLeft(in_zaC99ValuezfResource_1, &v6);
			struct mirth_c99_zaC99Value* v7;
			struct mirth_c99_zaC99Value* v8;
			mw_mirth_c99_zaC99Value_rdup(V_mirth_c99_zaC99Value(v6), &v7, &v8);
			struct std_either_zaEither_2 v9;
			mtw_std_either_zaEither_2_zaLeft(MK_mirth_c99_zaC99Value(v7), &v9);
			struct std_either_zaEither_2 v10;
			mtw_std_either_zaEither_2_zaLeft(MK_mirth_c99_zaC99Value(v8), &v10);
			branch_zaEither_5 = v10;
			branch_zaEither_4 = v9;
		} break;
		case std_either_zaEither_2_zaRight: {
			VAL v11;
			mtp_std_either_zaEither_2_zaRight(in_zaC99ValuezfResource_1, &v11);
			struct mirth_c99_zaC99Resource* v12;
			struct mirth_c99_zaC99Resource* v13;
			mw_mirth_c99_zaC99Resource_rdup(V_mirth_c99_zaC99Resource(v11), &v12, &v13);
			struct std_either_zaEither_2 v14;
			mtw_std_either_zaEither_2_zaRight(MK_mirth_c99_zaC99Resource(v12), &v14);
			struct std_either_zaEither_2 v15;
			mtw_std_either_zaEither_2_zaRight(MK_mirth_c99_zaC99Resource(v13), &v15);
			branch_zaEither_5 = v15;
			branch_zaEither_4 = v14;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaC99ValuezfResource_3 = branch_zaEither_5;
	*out_zaC99ValuezfResource_2 = branch_zaEither_4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %rbx
cmpl $0x1, %edi
je 0xdfbb8
testl %edi, %edi
jne 0xdfc11
movq (%rsi), %r15
movq %rsi, %rdi
callq 0x5030
leaq -0x38(%rbp), %r12
leaq -0x30(%rbp), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xdb2d5
movq (%r12), %rdi
leaq -0x58(%rbp), %rsi
callq 0xb5d67
movq (%r13), %rdi
leaq -0x48(%rbp), %rsi
callq 0xb5d67
jmp 0xdfbf3
movq (%rsi), %r15
movq %rsi, %rdi
callq 0x5030
leaq -0x38(%rbp), %r12
leaq -0x30(%rbp), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xdb505
movq (%r12), %rdi
leaq -0x58(%rbp), %rsi
callq 0xb58b7
movq (%r13), %rdi
leaq -0x48(%rbp), %rsi
callq 0xb58b7
movups -0x48(%rbp), %xmm0
movups %xmm0, (%r14)
movups -0x58(%rbp), %xmm0
movups %xmm0, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0x4b23(%rip), %xmm0     # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0x4b28(%rip), %xmm0     # 0xe475d
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x95a5
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99BranchSplit_c99zeline_1_sp3
static void mw_mirth_c99_zaC99BranchSplit_c99zeline_1_sp3 (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99BranchSplit* in_zaC99BranchSplit_2, struct mirth_mirth_zaMirth* *out_zaMirth_3, struct mirth_c99_zaC99BranchSplit* *out_zaC99BranchSplit_4) {
	bool v5 = in_zaC99BranchSplit_2->mreachablezein;
	struct mirth_c99_zaC99* r6 = in_zaC99BranchSplit_2->mzac99;
	bool v7 = r6->mputzeenabled;
	bool v8 = (v5 && v7);
	r6->mputzeenabled = v8;
	struct mirth_mirth_zaMirth* v9;
	struct mirth_c99_zaC99* v10;
	mw_mirth_c99_zaC99_indent(in_zaMirth_1, r6, &v9, &v10);
	STR* v11;
	STRLIT(v11, "default: {", 10);
	struct mirth_mirth_zaMirth* v12;
	struct mirth_c99_zaC99* v13;
	mw_mirth_c99_zaC99_put(v9, v10, v11, &v12, &v13);
	struct mirth_mirth_zaMirth* v14;
	struct mirth_c99_zaC99* v15;
	mw_mirth_c99_zaC99_line(v12, v13, &v14, &v15);
	v15->mputzeenabled = v7;
	in_zaC99BranchSplit_2->mzac99 = v15;
	*out_zaC99BranchSplit_4 = in_zaC99BranchSplit_2;
	*out_zaMirth_3 = v14;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rsi, %r15
movq (%rsi), %rsi
xorl %eax, %eax
cmpb $0x0, 0x38(%r15)
movl 0x18(%rsi), %ebx
cmovnel %ebx, %eax
movb %al, 0x18(%rsi)
leaq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x95d84
cmpq $0x0, 0x103d9b3(%rip)   # 0x111d638
jne 0xdfcb4
movl $0xa, %edi
callq 0xf9f7
movq $0xa, 0x10(%rax)
movabsq $0x3a746c7561666564, %rcx # imm = 0x3A746C7561666564
movq %rcx, 0x18(%rax)
movw $0x7b20, 0x20(%rax)     # imm = 0x7B20
movq %rax, 0x103d984(%rip)   # 0x111d638
movq 0x103d97d(%rip), %rdx   # 0x111d638
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %rdx, %rax
sete %cl
testb $0x3, %dl
setne %sil
orb %cl, %sil
jne 0xdfcd9
incl (%rax)
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x58(%rbp), %r12
leaq -0x50(%rbp), %r13
movq %r12, %rcx
movq %r13, %r8
callq 0x94972
movq (%r12), %r14
movq (%r13), %r13
cmpb $0x1, 0x18(%r13)
jne 0xdfd20
movq 0x28(%r13), %rsi
leaq -0x60(%rbp), %r12
movl $0xa, %edi
movq %r12, %rdx
callq 0x95160
movq (%r12), %rax
movq %rax, 0x28(%r13)
movb %bl, 0x18(%r13)
movq %r13, (%r15)
movq -0x30(%rbp), %rax
movq %r15, (%rax)
movq -0x38(%rbp), %rax
movq %r14, (%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_c99zereversezetagzx
static void mw_mirth_c99_c99zereversezetagzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99Branch* in_zaC99Branch_2, uint64_t in_Tag_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_c99_zaC99Branch* *out_zaC99Branch_5) {
	struct mirth_mirth_zaMirth* v6;
	bool v7 = mw_mirth_data_Tag_preferzeinlinezy(in_zaMirth_1, in_Tag_3, &v6);
	struct mirth_mirth_zaMirth* branch_zaMirth_8;
	struct mirth_c99_zaC99Branch* branch_zaC99Branch_9;
	if (v7) {
		struct mirth_mirth_zaMirth* v10;
		struct mirth_c99_zaC99Branch* v11;
		mw_mirth_c99_c99zereversezetagzebodyzx(v6, in_zaC99Branch_2, in_Tag_3, &v10, &v11);
		branch_zaC99Branch_9 = v11;
		branch_zaMirth_8 = v10;
	} else {
		struct std_list_List_1 v12 = { .tag=std_list_List_1_Nil };
		struct mirth_c99_zaC99* r13 = in_zaC99Branch_2->mzac99;
		struct mirth_mirth_zaMirth* v14;
		struct mirth_c99_zaC99* v15;
		struct mirth_c99_C99API* v16 = mw_mirth_data_Tag_patzec99zeapi(v6, r13, in_Tag_3, &v14, &v15);
		in_zaC99Branch_2->mzac99 = v15;
		struct mirth_mirth_zaMirth* v17;
		struct mirth_c99_zaC99Branch* v18;
		mw_mirth_c99_c99zesmartzecallzx(v14, in_zaC99Branch_2, v12, v16, &v17, &v18);
		branch_zaC99Branch_9 = v18;
		branch_zaMirth_8 = v17;
	}
	*out_zaC99Branch_5 = branch_zaC99Branch_9;
	*out_zaMirth_4 = branch_zaMirth_8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movq %rcx, -0x38(%rbp)
movq %rdx, %r12
movq %rsi, %r15
leaq -0x30(%rbp), %rdx
movq %r12, %rsi
callq 0xaaa67
testb %al, %al
je 0xdfd98
movq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %r13
leaq -0x40(%rbp), %rbx
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rbx, %r8
callq 0xad334
movq (%rbx), %rax
movq (%r13), %rcx
jmp 0xdfde4
movq (%r15), %rsi
movq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rbx
leaq -0x40(%rbp), %r13
movq %r12, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0xad112
movq (%r13), %rcx
movq %rcx, (%r15)
movq (%rbx), %rdi
leaq -0x50(%rbp), %r12
movq %r12, (%rsp)
leaq -0x58(%rbp), %rbx
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, %r8
movq %rbx, %r9
callq 0xd8353
movq (%r12), %rax
movq (%rbx), %rcx
movq %rax, (%r14)
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_Tag_valuezeshow
static STR* mw_mirth_data_Tag_valuezeshow (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Tag_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_data_Tag_ztvaluezeshow, in_Tag_2);
	bool v6 = mut_is_set(v5);
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	uint64_t branch_Tag_8;
	STR* branch_Str_9;
	if (v6) {
		VAL v10 = mut_get(v5);
		branch_Str_9 = value_str(v10);
		branch_Tag_8 = in_Tag_2;
		branch_zaMirth_7 = in_zaMirth_1;
	} else {
		struct mirth_mirth_zaMirth* v11;
		INT v12 = mw_mirth_data_Tag_value(in_zaMirth_1, in_Tag_2, &v11);
		STR* v13 = int_to_str(v12);
		incref(MKSTR(v13));
		mut_set(MKSTR(v13), v5);
		branch_Str_9 = v13;
		branch_Tag_8 = in_Tag_2;
		branch_zaMirth_7 = v11;
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_Str_9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
leaq 0x103d009(%rip), %rdi   # 0x111d5e8
callq 0x13ff0
movq %rax, %r15
movq %rax, %rdi
callq 0x153b0
testb %al, %al
je 0xe060b
movq %r15, %rdi
callq 0x140f0
movq %rax, %rdi
movq %rdx, %rsi
callq 0x942c
movq %rax, %r12
jmp 0xe066a
leaq 0x1038c66(%rip), %rdi   # 0x1119278
movq %r12, %rsi
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
movq %rax, %r12
movq %rax, %rdi
movq %rdx, %rsi
callq 0x10db8
movq %r12, %rdi
callq 0x102c9
movq %rax, %r12
leaq 0x34b17(%rip), %rsi     # 0x115159
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq %r12, %rax
sete %cl
testb $0x3, %r12b
setne %dl
orb %cl, %dl
jne 0xe065f
incl (%rax)
movq %r12, %rdi
movq %r15, %rdx
callq 0x14ab5
movq %r14, (%rbx)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99Value_pushzetozeenvzx
static void mw_mirth_c99_zaC99Value_pushzetozeenvzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99Branch* in_zaC99Branch_2, uint64_t in_Var_3, struct mirth_c99_zaC99Value* in_zaC99Value_4, struct mirth_mirth_zaMirth* *out_zaMirth_5, struct mirth_c99_zaC99Branch* *out_zaC99Branch_6) {
	struct mirth_c99_C99ReprType v7;
	STR* v8;
	mtp_mirth_c99_zaC99Value_zaC99Value(in_zaC99Value_4, &v7, &v8);
	struct mirth_c99_C99Var* v9 = mtw_mirth_c99_C99Var_C99Var(in_Var_3, v8, v7);
	struct std_list_List_1 v10 = in_zaC99Branch_2->menv;
	incref(MK_std_list_List_1(v10));
	struct std_list_List_1 v11 = mw_std_list_List_1_cons(MK_mirth_c99_C99Var(v9), v10);
	struct std_list_List_1 v12 = in_zaC99Branch_2->menv;
	decref(MK_std_list_List_1(v12));
	in_zaC99Branch_2->menv = v11;
	*out_zaC99Branch_6 = in_zaC99Branch_2;
	*out_zaMirth_5 = in_zaMirth_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, -0x40(%rbp)
movq %r8, -0x48(%rbp)
movq %rdx, -0x30(%rbp)
movq %rsi, %r12
movq %rdi, -0x38(%rbp)
movl (%rcx), %r14d
movq 0x8(%rcx), %r15
movq 0x10(%rcx), %r13
movq %rcx, %rdi
callq 0x5030
movl $0x1, %edi
movl $0x28, %esi
callq 0x50c0
testq %rax, %rax
je 0xe08cf
movabsq $0xfffffffffffc, %rbx   # imm = 0xFFFFFFFFFFFC
movl $0x1, (%rax)
movl %r14d, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %r13, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl 0x18(%r12), %edx
movq 0x20(%r12), %rcx
movq %rcx, %rsi
andq %rbx, %rsi
sete %dil
testb $0x3, %cl
setne %r8b
orb %dil, %r8b
jne 0xe085e
incl (%rsi)
leaq 0x36a6c(%rip), %rsi     # 0x1172d1
movq %rax, %rdi
callq 0xd592
movq %rdx, %r13
movq 0x20(%r12), %rax
andq %rax, %rbx
sete %cl
testb $0x3, %al
setne %dl
orb %cl, %dl
jne 0xe08a0
movl 0x18(%r12), %edi
decl (%rbx)
jne 0xe08a0
leaq 0x349e5(%rip), %rsi     # 0x115279
shlq $0x30, %rdi
orq %rax, %rdi
callq 0xd4e3
movl $0x1, 0x18(%r12)
movq %r13, 0x20(%r12)
movq -0x40(%rbp), %rax
movq %r12, (%rax)
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1dff2(%rip), %rsi     # 0xfe8c8
movl $0x31, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mirth_c99_C99Var_free
static void mirth_c99_C99Var_free (VAL vself) {
	ASSERT(vself.tag == TAG_mirth_c99_C99Var);
	struct mirth_c99_C99Var* self = vself.data.ptr;
	decref(MKSTR(self->mvaluezename));
	decref(MK_mirth_c99_C99ReprType(self->mvaluezerepr));
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x369cf(%rip), %rax     # 0x1172d1
cmpq %rsi, %rax
jne 0xe0977
movq %rdi, %rbx
movabsq $0xfffffffffffc, %r14   # imm = 0xFFFFFFFFFFFC
movq 0x10(%rdi), %rdi
movq %rdi, %rax
andq %r14, %rax
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0xe093c
decl (%rax)
jne 0xe093c
leaq 0x34822(%rip), %rsi     # 0x115159
callq 0xd4e3
movq 0x20(%rbx), %rax
andq %rax, %r14
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0xe096b
decl (%r14)
jne 0xe096b
leaq 0x365ce(%rip), %rsi     # 0x116f29
movl 0x18(%rbx), %edi
shlq $0x30, %rdi
orq 0x20(%rbx), %rdi
callq 0xd4e3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5030
leaq 0x1df83(%rip), %rsi     # 0xfe901
movl $0x50, %edx
movl $0x2, %edi
callq 0x5060
callq 0x52be
movl $0x1, %edi
callq 0x5130
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_C99Var_C99Var
static void mtp_mirth_c99_C99Var_C99Var (struct mirth_c99_C99Var* in_C99Var_1, uint64_t *out_Var_2, STR* *out_Str_3, struct mirth_c99_C99ReprType *out_C99ReprType_4) {
	struct mirth_c99_C99Var v5 = *in_C99Var_1;
	if (!--(in_C99Var_1->refs)) {
		free(in_C99Var_1);
	} else {
		incref(MKSTR(v5.mvaluezename));
		incref(MK_mirth_c99_C99ReprType(v5.mvaluezerepr));
	}
	*out_C99ReprType_4 = v5.mvaluezerepr;
	*out_Str_3 = v5.mvaluezename;
	*out_Var_2 = v5.mvarzevar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq 0x8(%rdi), %r9
movq 0x10(%rdi), %r13
movl 0x18(%rdi), %ebx
movl 0x1c(%rdi), %r14d
movq 0x20(%rdi), %r12
decl (%rdi)
je 0xe0a4e
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
movq %r13, %rcx
andq %rax, %rcx
sete %r8b
testb $0x3, %r13b
setne %dil
orb %r8b, %dil
jne 0xe0a37
incl (%rcx)
andq %r12, %rax
sete %cl
testb $0x3, %r12b
setne %dil
orb %cl, %dil
jne 0xe0a6b
incl (%rax)
jmp 0xe0a6b
movq %rsi, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq %r9, -0x30(%rbp)
callq 0x5030
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rsi
movl %ebx, (%r15)
movl %r14d, 0x4(%r15)
movq %r12, 0x8(%r15)
movq %r13, (%rdx)
movq %r9, (%rsi)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_c99zevarzepushzx
static void mw_mirth_c99_c99zevarzepushzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99Branch* in_zaC99Branch_2, uint64_t in_Var_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_c99_zaC99Branch* *out_zaC99Branch_5) {
	struct mirth_mirth_zaMirth* v6;
	struct mirth_c99_zaC99Branch* v7;
	struct mirth_c99_zaC99Value* v8;
	mw_mirth_c99_zaC99Branch_varzedupzx(in_zaMirth_1, in_zaC99Branch_2, in_Var_3, &v6, &v7, &v8);
	struct mirth_mirth_zaMirth* v9;
	struct mirth_c99_zaC99Branch* v10;
	mw_mirth_c99_zaC99Value_pushzevaluezx(v6, v7, v8, &v9, &v10);
	*out_zaC99Branch_5 = v10;
	*out_zaMirth_4 = v9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movq %rcx, -0x30(%rbp)
leaq -0x48(%rbp), %r15
leaq -0x40(%rbp), %r12
leaq -0x38(%rbp), %r13
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0xe0b01
movq (%r15), %rbx
movq (%r12), %r12
movq (%r13), %rdx
movl 0x8(%r12), %edi
movq 0x10(%r12), %rsi
leaq -0x58(%rbp), %r15
movq %r15, %rcx
callq 0xb1439
movups (%r15), %xmm0
movups %xmm0, 0x8(%r12)
movq %r12, (%r14)
movq -0x30(%rbp), %rax
movq %rbx, (%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99ValuezfResource_zafor_2_sp3
static void mw_mirth_c99_zaC99ValuezfResource_zafor_2_sp3 (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99Branch* in_zaC99Branch_2, struct std_either_zaEither_2 in_zaC99ValuezfResource_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_c99_zaC99Branch* *out_zaC99Branch_5) {
	struct mirth_mirth_zaMirth* branch_zaMirth_6;
	struct mirth_c99_zaC99Branch* branch_zaC99Branch_7;
	switch ((in_zaC99ValuezfResource_3).tag) {
		case std_either_zaEither_2_zaLeft: {
			VAL v8;
			mtp_std_either_zaEither_2_zaLeft(in_zaC99ValuezfResource_3, &v8);
			struct mirth_mirth_zaMirth* v9;
			struct mirth_c99_zaC99Branch* v10;
			mw_mirth_c99_zaC99Value_dropzevaluezx(in_zaMirth_1, in_zaC99Branch_2, V_mirth_c99_zaC99Value(v8), &v9, &v10);
			branch_zaC99Branch_7 = v10;
			branch_zaMirth_6 = v9;
		} break;
		case std_either_zaEither_2_zaRight: {
			VAL v11;
			mtp_std_either_zaEither_2_zaRight(in_zaC99ValuezfResource_3, &v11);
			struct mirth_mirth_zaMirth* v12;
			struct mirth_c99_zaC99Branch* v13;
			mw_mirth_c99_zaC99Resource_pushzeresourcezx(in_zaMirth_1, in_zaC99Branch_2, V_mirth_c99_zaC99Resource(v11), &v12, &v13);
			branch_zaC99Branch_7 = v13;
			branch_zaMirth_6 = v12;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaC99Branch_5 = branch_zaC99Branch_7;
	*out_zaMirth_4 = branch_zaMirth_6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rsi, %r15
movq %rdi, %r12
cmpl $0x1, %edx
je 0xe1030
testl %edx, %edx
jne 0xe1071
movq (%rcx), %r13
movq %rcx, %rdi
callq 0x5030
leaq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rax
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rcx, %r12
movq %rax, %r15
movq %rax, %r8
callq 0xd9cc4
movq (%r15), %r15
movq (%r12), %r12
jmp 0xe105c
movq (%rcx), %r13
movq %rcx, %rdi
callq 0x5030
movl 0x8(%r15), %edi
movq 0x10(%r15), %rsi
leaq -0x40(%rbp), %rcx
movq %r13, %rdx
movq %rcx, %r13
callq 0xb158c
movups (%r13), %xmm0
movups %xmm0, 0x8(%r15)
movq %r15, (%r14)
movq %r12, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf9f7
movq $0x20, 0x10(%rax)
movups 0x36c3(%rip), %xmm0     # 0xe474d
movups %xmm0, 0x18(%rax)
movups 0x36c8(%rip), %xmm0     # 0xe475d
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
callq 0x95a5
// File: /workspace/github_c_makefile_star2_O1/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_data_Tag_semizetransparentzy
static struct std_maybe_Maybe_1 mw_mirth_data_Tag_semizetransparentzy (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Tag_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	uint64_t v6 = mw_mirth_data_Tag_data(in_zaMirth_1, in_Tag_2, &v5);
	struct mirth_mirth_zaMirth* v7;
	struct std_maybe_Maybe_1 v8 = mw_mirth_data_Data_semizetransparentzy(v5, v6, &v7);
	*out_zaMirth_3 = v7;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x1037b28(%rip), %rdi   # 0x1118be0
callq 0x13ff0
movq %rax, %rdi
callq 0x140f0
leaq -0x20(%rbp), %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x79ceb
movq (%r15), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/utils/size/size.c
// Function: main
int
main(int argc,char **argv)
    {
    int argIndex = 1;

    FILE *in,*out;
    RRA *h;

    argIndex = processOptions(argc,argv);

    if (argc-argIndex == 0)
        {
        in = stdin;
        out = stdout;
        }
    else if (argc-argIndex == 1)
        {
        in = OpenFile(argv[argIndex],"r");
        out = stdout;
        }
    else if (argc-argIndex == 2)
        {
        in = OpenFile(argv[argIndex],"r");
        out = OpenFile(argv[argIndex+1],"w");
        }
    else
        {
        printf("usage: rrasize [<input rra file> [<output rra file>]]\n");
        exit(-1);
        }

    h = readRRA(in,0);

    writeRRA(out,h,"modifiedBy: rrasize",0,0);

    fclose(in);
    fclose(out);

    return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movl $0x1, %r12d
cmpl $0x2, %edi
jl 0x15e3
movl %r14d, %r13d
movl $0x1, %r12d
leaq 0x1a73(%rip), %r15      # 0x302e
movq (%rbx,%r12,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x15e3
cmpb $0x76, 0x1(%rsi)
je 0x1692
movq %r15, %rdi
xorl %eax, %eax
callq 0x16cc
incq %r12
cmpq %r12, %r13
jne 0x15bb
movl %r13d, %r12d
subl %r12d, %r14d
jne 0x15f4
movq 0x49e9(%rip), %rax      # 0x5fd8
movq (%rax), %r14
jmp 0x161a
cmpl $0x2, %r14d
je 0x1626
cmpl $0x1, %r14d
jne 0x16b5
movslq %r12d, %rax
movq (%rbx,%rax,8), %rdi
leaq 0x1efb(%rip), %rsi      # 0x350d
callq 0x1766
movq %rax, %r14
movq 0x49af(%rip), %rax      # 0x5fd0
movq (%rax), %rbx
jmp 0x1650
movslq %r12d, %r15
movq (%rbx,%r15,8), %rdi
leaq 0x1ed9(%rip), %rsi      # 0x350d
callq 0x1766
movq %rax, %r14
movq 0x8(%rbx,%r15,8), %rdi
leaq 0x19c1(%rip), %rsi      # 0x3009
callq 0x1766
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1cd2
leaq 0x19aa(%rip), %rdx      # 0x300b
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x27ad
movq %r14, %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1090
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x4a9f(%rip), %rsi      # 0x6138
movq 0x4aa0(%rip), %rdx      # 0x6140
leaq 0x1978(%rip), %rdi      # 0x301f
xorl %eax, %eax
callq 0x10b0
xorl %edi, %edi
callq 0x1200
leaq 0x198c(%rip), %rdi      # 0x3048
callq 0x1070
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1200
nop
// File: /workspace/github_c_makefile_star2_O1/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/SensorBase.cpp
// Function: SensorBase::~SensorBase()
SensorBase::~SensorBase()
{
	if (data_fd >= 0)
		close(data_fd);

	if (dev_fd >= 0)
		close(dev_fd);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x695f(%rip), %rax      # 0xbef8
addq $0x10, %rax
movq %rax, (%rdi)
movl 0x1020(%rdi), %edi
testl %edi, %edi
js 0x55af
callq 0x5400
movl 0x101c(%rbx), %edi
testl %edi, %edi
js 0x55be
callq 0x5400
popq %rbx
retq
movq %rax, %rdi
callq 0x5b43
// File: /workspace/github_c_makefile_star2_O1/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/SensorBase.cpp
// Function: SensorBase::close_device()
int SensorBase::close_device()
{
	if (dev_fd >= 0) {
		close(dev_fd);
		dev_fd = -1;
	}
	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x101c(%rdi), %edi
testl %edi, %edi
js 0x5611
callq 0x5400
movl $0xffffffff, 0x101c(%rbx) # imm = 0xFFFFFFFF
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/SensorBase.cpp
// Function: SensorBase::writeSysfsCommand(int, char const*, char const*, long)
int SensorBase::writeSysfsCommand(int32_t handle,
				  const char *sysfsFilename,
				  const char *dataFormat, int64_t param)
{
	int fd;
	int err;
	char buf[8];
	const char *className;

	char formatstring1[50] = "%s Set %s to ";
	char formatstring2[100] = "%s Failed to set %s: ";

	switch(handle) {
#if (SENSORS_ACCELEROMETER_ENABLE == 1)
	case SENSORS_ACCELEROMETER_HANDLE:
	case SENSORS_SIGNIFICANT_MOTION_HANDLE:
		strcpy(&sysfs_device_path[sysfs_device_path_len],
		       sysfsFilename);
		className = "AccelSensor::Command()";
		break;
#endif
	default:
		return -1;
	}

	fd = open(sysfs_device_path, O_RDWR);
	sprintf(buf, dataFormat, param);
	err = write(fd, buf, sizeof(buf));
	close(fd);


	strcat(formatstring1, dataFormat);
	strcat(formatstring2, dataFormat);
	strcat(formatstring2, " - %s");

	if(err > 0) {
		STLOGI(formatstring1, className, sysfsFilename, param);
	} else {
		STLOGE(formatstring2, className, sysfsFilename, param,
		       sysfs_device_path);
	}

        return err > 0 ? 0 : -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
cmpl $0xe, %esi
je 0x5aa4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x1, %esi
jne 0x5b04
leaq 0x18(%rdi), %r15
movslq 0x1018(%rdi), %rax
addq %rax, %rdi
addq $0x18, %rdi
movq %rdx, %rsi
callq 0x51e0
movq %r15, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x5170
movl %eax, %ebp
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x5090
movl $0x8, %edx
movl %ebp, %edi
movq %r15, %rsi
callq 0x50f0
movq %rax, %rbx
movl %ebp, %edi
callq 0x5400
xorl %eax, %eax
testl %ebx, %ebx
setle %al
negl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/sensors.cpp
// Function: sensors_poll_context_t::~sensors_poll_context_t()
sensors_poll_context_t::~sensors_poll_context_t()
{
	for (int i = 0; i < numSensorDrivers ; i++) {
		delete mSensors[i];
	}

#if (ANDROID_VERSION >= ANDROID_JBMR2)
	close(mPollFds[flushFD].fd);
	close(mWriteFlushPipe);
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x120(%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x5d43
movq (%rdi), %rax
callq *0x8(%rax)
incq %r14
cmpq $0x6, %r14
jne 0x5d30
movl 0x110(%rbx), %edi
callq 0x5400
movl 0x118(%rbx), %edi
callq 0x5400
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x5b43
// File: /workspace/github_c_makefile_star2_O1/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/sensors.cpp
// Function: sensors_poll_context_t::pollEvents(sensors_event_t*, int)
int sensors_poll_context_t::pollEvents(sensors_event_t* data, int count)
{
	int nbEvents = 0;
	int n = 0;

	do {
		if (count) {
			n = poll(mPollFds, numFds, nbEvents ? 0 : -1);
			if (n < 0) {
				STLOGE("poll() failed (%s)", strerror(errno));
				return -errno;
			}
		}
		for (int i=0 ; count && i<numSensorDrivers ; i++) {
			SensorBase* const sensor(mSensors[i]);
			if((mPollFds[i].revents & POLLIN) || (sensor->hasPendingEvents()))
			{
				int nb = sensor->readEvents(data, count);
				if (nb < count) {
					mPollFds[i].revents = 0;
				}
				count -= nb;
				nbEvents += nb;
				data += nb;
			}
		}
#if (ANDROID_VERSION >= ANDROID_JBMR2)
		if(mPollFds[flushFD].revents & POLLIN && count) {
			if (read(mPollFds[flushFD].fd, data, sizeof(struct sensors_event_t)) > 0) {
				count--;
				nbEvents++;
				data++;
			}
			mPollFds[flushFD].revents = 0;
		}
#endif
	} while (n && count);

	return nbEvents;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0xe0(%rdi), %rax
movq %rax, 0x10(%rsp)
xorl %ebx, %ebx
movl $0x0, 0xc(%rsp)
testl %ebp, %ebp
je 0x5e33
cmpl $0x1, %ebx
movl $0x0, %edx
sbbl %edx, %edx
movl $0x7, %esi
movq 0x10(%rsp), %rdi
callq 0x5360
movl %eax, 0xc(%rsp)
testl %eax, %eax
js 0x5eef
testl %ebp, %ebp
setne %al
je 0x5e9b
xorl %r13d, %r13d
movq 0x120(%r15,%r13,8), %r12
testb $0x1, 0xe6(%r15,%r13,8)
jne 0x5e5e
movq (%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
testb %al, %al
je 0x5e87
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq *0x10(%rax)
subl %eax, %ebp
jle 0x5e7c
movw $0x0, 0xe6(%r15,%r13,8)
addl %eax, %ebx
cltq
imulq $0x68, %rax, %rax
addq %rax, %r14
testl %ebp, %ebp
setne %al
je 0x5e9b
leaq 0x1(%r13), %rcx
cmpq $0x5, %r13
movq %rcx, %r13
jb 0x5e3d
testb %al, %al
je 0x5ede
movzwl 0x116(%r15), %eax
andl $0x1, %eax
je 0x5ede
movl 0x110(%r15), %edi
movl $0x68, %edx
movq %r14, %rsi
callq 0x5310
leaq 0x68(%r14), %rcx
xorl %edx, %edx
testq %rax, %rax
cmovgq %rcx, %r14
setg %dl
subl %edx, %ebp
addl %edx, %ebx
movw $0x0, 0x116(%r15)
cmpl $0x0, 0xc(%rsp)
je 0x5ef8
testl %ebp, %ebp
jne 0x5e0a
jmp 0x5ef8
callq 0x5070
xorl %ebx, %ebx
subl (%rax), %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/sensors.cpp
// Function: sensors_poll_context_t::flush(int)
int sensors_poll_context_t::flush(int sensor_handle)
{
	sensors_event_t flush_event;
	int err;

	flush_event.timestamp = 0;
	flush_event.meta_data.sensor = sensor_handle;
	flush_event.meta_data.what = META_DATA_FLUSH_COMPLETE;
	flush_event.type = SENSOR_TYPE_META_DATA;
	flush_event.version = META_DATA_VERSION;
	flush_event.sensor = 0;

	err = write(mWriteFlushPipe, &flush_event, sizeof(flush_event));
	if (err < 0) {
		ALOGE("Failed to write flush data. %d", err);
		return -EINVAL;
	}

	return 0;
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
xorl %ebx, %ebx
leaq 0x8(%rsp), %rax
movq %rbx, 0x10(%rax)
movl %esi, 0x1c(%rax)
movl $0x1, 0x18(%rax)
movl $0x0, 0x8(%rax)
movq %rbx, (%rax)
movl 0x118(%rdi), %edi
movl $0x68, %edx
movq %rax, %rsi
callq 0x50f0
testl %eax, %eax
js 0x5f7f
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
retq
movq 0x5ffa(%rip), %rcx      # 0xbf80
movq (%rcx), %rdi
leaq 0x2238(%rip), %rsi      # 0x81c8
leaq 0x2261(%rip), %rdx      # 0x81f8
movl $0x470, %ecx            # imm = 0x470
movl %eax, %r8d
xorl %eax, %eax
callq 0x5300
movl $0xffffffea, %ebx       # imm = 0xFFFFFFEA
jmp 0x5f77
// File: /workspace/github_c_makefile_star2_O1/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/sensors.cpp
// Function: open_sensors(hw_module_t const*, char const*, hw_device_t**)
static int open_sensors(const struct hw_module_t* module,
			const char __attribute__((unused))*id,
			struct hw_device_t** device)
{
	int status = -EINVAL;
	sensors_poll_context_t *dev = new sensors_poll_context_t();

	memset(&dev->device, 0, sizeof(SENSOR_POLL_DEVICE));

	dev->device.common.tag		= HARDWARE_DEVICE_TAG;

#if (ANDROID_VERSION > ANDROID_KK)
	dev->device.common.version	= SENSORS_DEVICE_API_VERSION_1_3;
#else
#if (ANDROID_VERSION > ANDROID_JBMR2)
	dev->device.common.version	= SENSORS_DEVICE_API_VERSION_1_1;
#else
#if (ANDROID_VERSION == ANDROID_JBMR2)
	dev->device.common.version	= SENSORS_DEVICE_API_VERSION_1_0;
#else
	dev->device.common.version	= 0;
#endif
#endif
#endif
	dev->device.common.module	= const_cast<hw_module_t*>(module);
	dev->device.common.close	= poll__close;
	dev->device.activate		= poll__activate;
	dev->device.setDelay		= poll__setDelay;
	dev->device.poll		= poll__poll;
#if (ANDROID_VERSION >= ANDROID_JBMR2)
	dev->device.batch		= poll__batch;
	dev->device.flush		= poll__flush;
#endif

	*device = &dev->device.common;
	status = 0;

	return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r15
movl $0x150, %edi            # imm = 0x150
callq 0x5200
movq %rax, %r14
movq %rax, %rdi
callq 0x53f0
movl $0xe0, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x5130
movabsq $0x103000148574454, %rax # imm = 0x103000148574454
movq %rax, (%r14)
movq %r15, 0x8(%r14)
leaq 0x65(%rip), %rax        # 0x6059
movq %rax, 0x70(%r14)
leaq 0x74(%rip), %rax        # 0x6073
movq %rax, 0x78(%r14)
leaq 0x9f(%rip), %rax        # 0x60a9
movq %rax, 0x80(%r14)
leaq 0xc7(%rip), %rax        # 0x60df
movq %rax, 0x88(%r14)
leaq 0xbe(%rip), %rax        # 0x60e4
movq %rax, 0x90(%r14)
leaq 0xe1(%rip), %rax        # 0x6115
movq %rax, 0x98(%r14)
movq %r14, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x51f0
movq %rbx, %rdi
callq 0x53c0