LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_std_list_List_1_Cons
static VAL mtp_std_list_List_1_Cons (struct std_list_List_1 in_List_1, struct std_list_List_1 *out_List_3) {
	struct std_list_List_1_Cons v4 = *in_List_1.ptr.Cons;
	if (!--(in_List_1.ptr.Cons->refs)) {
		free(in_List_1.ptr.Cons);
	} else {
		incref(v4.m0);
		incref(MK_std_list_List_1(v4.mList));
	}
	*out_List_3 = v4.mList;
	return v4.m0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0x28, %edx
callq 0x50e0
movq -0x18(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x12626
movq -0x18(%rbp), %rdi
callq 0x5030
jmp 0x12713
jmp 0x12628
movq -0x40(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1266d
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x48(%rbp), %rax
cmpq $0x0, %rax
je 0x1266d
movq -0x48(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x1266d
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x48(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x1266f
jmp 0x12671
movl -0x38(%rbp), %edi
movq -0x30(%rbp), %rsi
callq 0x12780
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x58(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1270f
movl -0x38(%rbp), %edi
movq -0x30(%rbp), %rsi
callq 0x12780
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x70(%rbp), %rax
cmpq $0x0, %rax
je 0x1270f
movl -0x38(%rbp), %edi
movq -0x30(%rbp), %rsi
callq 0x12780
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movq -0x80(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x1270f
movl -0x38(%rbp), %edi
movq -0x30(%rbp), %rsi
callq 0x12780
movq %rax, -0x90(%rbp)
movq %rdx, -0x88(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x90(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x12711
jmp 0x12713
movq -0x28(%rbp), %rax
movups -0x38(%rbp), %xmm0
movups %xmm0, (%rax)
movups -0x48(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: free_value
static void free_value(VAL v) {
    ASSERT(VTYPE(v));
    ASSERT1(VTYPE(v)->free,v);
    ASSERT1(HAS_REFS(v),v);
    ASSERT1(VREFS(v) == 0,v);
    VTYPE(v)->free(v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x8(%rbp), %rax
cmpq $0x0, %rax
jne 0x1280e
movl $0x2, %edi
leaq 0x341873(%rip), %rsi    # 0x354063
movl $0x35, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x12810
jmp 0x12812
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1285e
movl $0x2, %edi
leaq 0x341866(%rip), %rsi    # 0x354099
movl $0x3b, %edx
callq 0x5060
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x12cc0
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x12860
jmp 0x12862
movq -0x8(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x12892
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x12892
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0x128c9
movl $0x2, %edi
leaq 0x341837(%rip), %rsi    # 0x3540d5
movl $0x38, %edx
callq 0x5060
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x12cc0
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x128cb
jmp 0x128cd
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x12917
movl $0x2, %edi
leaq 0x341822(%rip), %rsi    # 0x35410e
movl $0x3a, %edx
callq 0x5060
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x12cc0
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x12919
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_std_list_List_1_Cons
static struct std_list_List_1 mtw_std_list_List_1_Cons (VAL in_t_1, struct std_list_List_1 in_List_2) {
	struct std_list_List_1_Cons* v4 = calloc(1, sizeof *v4);
	ASSERT(v4);
	v4->refs = 1;
	v4->mList = in_List_2;
	v4->m0 = in_t_1;
	struct std_list_List_1 v5 = { .tag=std_list_List_1_Cons, .ptr.Cons=v4 };
	return v5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x50c0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x1299b
movl $0x2, %edi
leaq 0x3416a8(%rip), %rsi    # 0x354025
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1299d
movq -0x38(%rbp), %rax
movl $0x1, (%rax)
movq -0x38(%rbp), %rax
movups -0x30(%rbp), %xmm0
movups %xmm0, 0x18(%rax)
movq -0x38(%rbp), %rax
movups -0x20(%rbp), %xmm0
movups %xmm0, 0x8(%rax)
movl $0x1, -0x10(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: std_list_List_1_free
void std_list_List_1_free (VAL v) {
	struct std_list_List_1 self = V_std_list_List_1(v);
	switch (self.tag) {
		case std_list_List_1_Nil: break;
		case std_list_List_1_Cons: {
			decref(self.ptr.Cons->m0);
			decref(MK_std_list_List_1(self.ptr.Cons->mList));
			free(self.ptr.Cons);
		} break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x12c80
movl %eax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x74(%rbp)
testl %eax, %eax
je 0x12a20
jmp 0x12a13
movl -0x74(%rbp), %eax
subl $0x1, %eax
je 0x12a25
jmp 0x12b78
jmp 0x12b78
jmp 0x12a27
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x12a94
movq -0x18(%rbp), %rcx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq 0x8(%rcx), %rax
cmpq $0x0, %rax
je 0x12a94
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x12a94
movq -0x18(%rbp), %rax
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq 0x8(%rax), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x12a92
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
callq 0x127c0
jmp 0x12a94
jmp 0x12a96
jmp 0x12a98
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edi
movq 0x20(%rax), %rsi
callq 0x12780
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x28(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x12b6d
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edi
movq 0x20(%rax), %rsi
callq 0x12780
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x40(%rbp), %rax
cmpq $0x0, %rax
je 0x12b6d
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edi
movq 0x20(%rax), %rsi
callq 0x12780
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x12b6d
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edi
movq 0x20(%rax), %rsi
callq 0x12780
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq -0x60(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x12b6b
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edi
movq 0x20(%rax), %rsi
callq 0x12780
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x127c0
jmp 0x12b6d
jmp 0x12b6f
movq -0x18(%rbp), %rdi
callq 0x5030
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: std_maybe_Maybe_1_free
void std_maybe_Maybe_1_free (VAL v) {
	struct std_maybe_Maybe_1 self = V_std_maybe_Maybe_1(v);
	switch (self.tag) {
		case std_maybe_Maybe_1_None: break;
		case std_maybe_Maybe_1_Some: {
			decref(self.ptr.Some->m0);
			free(self.ptr.Some);
		} break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x135d0
movl %eax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x1345a
jmp 0x13450
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x1345c
jmp 0x134d6
jmp 0x134d6
jmp 0x1345e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x134cb
movq -0x18(%rbp), %rcx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq 0x8(%rcx), %rax
cmpq $0x0, %rax
je 0x134cb
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x134cb
movq -0x18(%rbp), %rax
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq 0x8(%rax), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x134c9
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
callq 0x127c0
jmp 0x134cb
jmp 0x134cd
movq -0x18(%rbp), %rdi
callq 0x5030
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: argzeparser_types_ArgpOptionType_free
void argzeparser_types_ArgpOptionType_free (VAL v) {
	struct argzeparser_types_ArgpOptionType self = V_argzeparser_types_ArgpOptionType(v);
	switch (self.tag) {
		case argzeparser_types_ArgpOptionType_Short: {
			free(self.ptr.Short);
		} break;
		case argzeparser_types_ArgpOptionType_LongOnly: {
			decref(MKSTR(self.ptr.LongOnly->mStr));
			free(self.ptr.LongOnly);
		} break;
		case argzeparser_types_ArgpOptionType_Positional: break;
		case argzeparser_types_ArgpOptionType_End: break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x13860
movl %eax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x20(%rbp), %eax
movq %rax, -0x78(%rbp)
subq $0x3, %rax
ja 0x13765
movq -0x78(%rbp), %rax
leaq 0x33d9c5(%rip), %rcx    # 0x351018
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
callq 0x5030
jmp 0x13765
jmp 0x1366c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
leaq 0x37dad9(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x13754
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
leaq 0x37daac(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x38(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x40(%rbp), %rax
cmpq $0x0, %rax
je 0x13754
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
leaq 0x37da79(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x13754
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
leaq 0x37da50(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x58(%rbp)
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq -0x60(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x13752
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
leaq 0x37da1b(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x127c0
jmp 0x13754
jmp 0x13756
movq -0x18(%rbp), %rdi
callq 0x5030
jmp 0x13765
jmp 0x13765
jmp 0x13765
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_argzeparser_types_ArgpOptionType_Short
static enum std_byte_Byte mtp_argzeparser_types_ArgpOptionType_Short (struct argzeparser_types_ArgpOptionType in_ArgpOptionType_1) {
	struct argzeparser_types_ArgpOptionType_Short v3 = *in_ArgpOptionType_1.ptr.Short;
	if (!--(in_ArgpOptionType_1.ptr.Short->refs)) {
		free(in_ArgpOptionType_1.ptr.Short);
	} else {
	}
	return v3.mByte;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x17495
movq -0x8(%rbp), %rdi
callq 0x5030
jmp 0x17497
jmp 0x17497
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_std_maybe_Maybe_1_Some
static VAL mtp_std_maybe_Maybe_1_Some (struct std_maybe_Maybe_1 in_Maybe_1) {
	struct std_maybe_Maybe_1_Some v3 = *in_Maybe_1.ptr.Some;
	if (!--(in_Maybe_1.ptr.Some->refs)) {
		free(in_Maybe_1.ptr.Some);
	} else {
		incref(v3.m0);
	}
	return v3.m0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x174e5
movq -0x18(%rbp), %rdi
callq 0x5030
jmp 0x17530
jmp 0x174e7
movq -0x28(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1752c
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x30(%rbp), %rax
cmpq $0x0, %rax
je 0x1752c
movq -0x30(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x1752c
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x30(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x1752e
jmp 0x17530
movups -0x30(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_argzeparser_types_ArgpOptionType_LongOnly
static STR* mtp_argzeparser_types_ArgpOptionType_LongOnly (struct argzeparser_types_ArgpOptionType in_ArgpOptionType_1) {
	struct argzeparser_types_ArgpOptionType_LongOnly v3 = *in_ArgpOptionType_1.ptr.LongOnly;
	if (!--(in_ArgpOptionType_1.ptr.LongOnly->refs)) {
		free(in_ArgpOptionType_1.ptr.LongOnly);
	} else {
		incref(MKSTR(v3.mStr));
	}
	return v3.mStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x19a10
movq -0x8(%rbp), %rdi
callq 0x5030
jmp 0x19ab7
jmp 0x19a12
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x377737(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x19ab3
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x377712(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x38(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x40(%rbp), %rax
cmpq $0x0, %rax
je 0x19ab3
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x3776e7(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x19ab3
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x3776c2(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x58(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x60(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x19ab5
jmp 0x19ab7
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: i64_to_int
static INT i64_to_int(int64_t x) {
    if (FITS_I63(x)) {
        return WRAP_I63(x);
    } else {
        BIG* big = big_alloc(3);
        big->size = 2;
        uint64_t y = (uint64_t)x;
        big->radix[0] = LO_RADIX(y);
        big->radix[1] = HI_RADIX(y);
        return WRAP_BIG(big);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
cmpq -0x10(%rbp), %rax
jg 0x1a2cd
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rax, -0x10(%rbp)
jg 0x1a2cd
movq -0x10(%rbp), %rax
shlq %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1a315
movl $0x3, %edi
callq 0x5250
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x2, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rax
shrq $0x20, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_argzeparser_types_ArgumentParsingError_MissingArg
static struct argzeparser_types_ArgumentParsingError mtw_argzeparser_types_ArgumentParsingError_MissingArg (STR* in_Str_1) {
	struct argzeparser_types_ArgumentParsingError_MissingArg* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mStr = in_Str_1;
	struct argzeparser_types_ArgumentParsingError v4 = { .tag=argzeparser_types_ArgumentParsingError_MissingArg, .ptr.MissingArg=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1a370
movl $0x2, %edi
leaq 0x33aa17(%rip), %rsi    # 0x354d69
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1a372
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_prim_Str_splitzebyte
static struct std_list_Nest_1* mw_std_prim_Str_splitzebyte (enum std_byte_Byte in_Byte_1, STR* in_Str_2) {
	STR* v4;
	struct std_list_Nest_1* v5 = mw_std_str_zaStr_splitzebyte(in_Byte_1, in_Str_2, &v4);
	decref(MKSTR(v4));
	return v5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x1a870
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x376d76(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1a4a3
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x376d4d(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x38(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x40(%rbp), %rax
cmpq $0x0, %rax
je 0x1a4a3
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x376d22(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x1a4a3
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x376cfd(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x58(%rbp)
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq -0x60(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x1a4a1
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq 0x376ccc(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x127c0
jmp 0x1a4a3
jmp 0x1a4a5
movq -0x20(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: str_cat
static STR* str_cat (STR* s1, STR* s2) {
    EXPECT(s1 && s2, "invalid strings in prim-str-cat");
    STR* out = str_pushn(s1, s2->data, s2->size);
    decref(MKSTR(s2));
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1a69e
cmpq $0x0, -0x10(%rbp)
jne 0x1a6c8
movl $0x2, %edi
leaq 0x33a074(%rip), %rsi    # 0x35471e
movl $0x20, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1a6ca
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x1f4f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x376a62(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1a7b7
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x376a39(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x30(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x38(%rbp), %rax
cmpq $0x0, %rax
je 0x1a7b7
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x376a0e(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x1a7b7
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x3769e9(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x50(%rbp)
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq -0x58(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x1a7b5
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq 0x3769b8(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x127c0
jmp 0x1a7b7
jmp 0x1a7b9
movq -0x18(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: tup_new
static TUP* tup_new (TUPLEN cap_hint) {
    if (cap_hint < 3) cap_hint = 3;
    if (cap_hint > TUP_LEN_MAX) cap_hint = TUP_LEN_MAX;
    TUP *new_tup = calloc(1, sizeof(TUP) + sizeof(VAL)*(USIZE)cap_hint);
    ASSERT(new_tup);
    new_tup->refs = 1;
    new_tup->cap = cap_hint;
    return new_tup;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
cmpl $0x3, %eax
jge 0x1a7ee
movw $0x3, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jle 0x1a7ff
movw $0x3fff, -0x2(%rbp)     # imm = 0x3FFF
movzwl -0x2(%rbp), %eax
movl %eax, %esi
shlq $0x4, %rsi
addq $0x8, %rsi
movl $0x1, %edi
callq 0x50c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1a84c
movl $0x2, %edi
leaq 0x33a0ae(%rip), %rsi    # 0x3548dc
movl $0x34, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1a84e
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movw -0x2(%rbp), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: str_size
static uint64_t str_size (STR* s) {
    EXPECT(s, "invalid string for prim-str-size");
    uint64_t n = s->size;
    decref(MKSTR(s));
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1b42d
movl $0x2, %edi
leaq 0x338ff1(%rip), %rsi    # 0x354400
movl $0x21, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1b42f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x375d0e(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1b50b
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x375ce5(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x28(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x30(%rbp), %rax
cmpq $0x0, %rax
je 0x1b50b
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x375cba(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x1b50b
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x375c95(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x48(%rbp)
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq -0x50(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x1b509
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x375c64(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x127c0
jmp 0x1b50b
jmp 0x1b50d
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: u64_to_int
static INT u64_to_int(uint64_t x) {
    if (x <= (uint64_t)INT64_MAX) {
        return i64_to_int((int64_t)x);
    } else {
        BIG* big = big_alloc(4);
        big->size = 3;
        big->radix[0] = LO_RADIX(x);
        big->radix[1] = HI_RADIX(x);
        big->radix[2] = 0;
        return WRAP_BIG(big);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x10(%rbp)
ja 0x1b54b
movq -0x10(%rbp), %rdi
callq 0x1a290
movq %rax, -0x8(%rbp)
jmp 0x1b596
movl $0x4, %edi
callq 0x5250
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x3, 0x10(%rax)
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
shrq $0x20, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_str_zaStr_bytezo
static enum std_byte_Byte mw_std_str_zaStr_bytezo (INT in_Offset_1, STR* in_zaStr_2, STR* *out_zaStr_4) {
	incref(MKSTR(in_zaStr_2));
	enum std_byte_Byte v5 = mw_std_prim_Str_bytezo(in_Offset_1, in_zaStr_2);
	*out_zaStr_4 = in_zaStr_2;
	return v5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x375b95(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1b655
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x375b70(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x30(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x38(%rbp), %rax
cmpq $0x0, %rax
je 0x1b655
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x375b45(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x1b655
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x375b20(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x50(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x58(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x1b657
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x1b8e0
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x5c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: int_to_u64
static uint64_t int_to_u64(INT a) {
    if (IS_I63(a)) {
        return (uint64_t)GET_I63(a);
    } else {
        BIG* b = GET_BIG(a);
        ASSERT(b && b->size >= 2);
        uint64_t r = (uint64_t)(b->radix[0]) | ((uint64_t)(b->radix[1]) << 32);
        big_decref(b);
        return r;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1b6b2
movq -0x10(%rbp), %rax
subq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x8(%rbp)
jmp 0x1b722
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1b6cc
movq -0x18(%rbp), %rax
cmpq $0x2, 0x10(%rax)
jae 0x1b6f6
movl $0x2, %edi
leaq 0x338e0d(%rip), %rsi    # 0x3544e5
movl $0x3e, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1b6f8
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
movl 0x1c(%rcx), %ecx
shlq $0x20, %rcx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c3a0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_prelude_unsafe_1_sp19
static STR* mw_std_prelude_unsafe_1_sp19 (STR* in_zaStr_1, INT in_Offset_2, INT in_Offset_3, STR* *out_zaStr_4) {
	STR* v6;
	STR* v7 = mw_std_str_zaStr_offsetzeslice(in_zaStr_1, in_Offset_2, in_Offset_3, &v6);
	*out_zaStr_4 = v6;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x1c570
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: int_add
static INT int_add(INT a, INT b) {
    if (IS_I63(a)) {
        if (IS_I63(b)) {
            return i64_to_int(GET_I63(a) + GET_I63(b));
        } else {
            return big_i63_add(GET_BIG(b), GET_I63(a));
        }
    } else {
        if (IS_I63(b)) {
            return big_i63_add(GET_BIG(a), GET_I63(b));
        } else {
            return big_big_add(GET_BIG(a), GET_BIG(b));
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1b805
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1b7e1
movq -0x10(%rbp), %rax
subq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rdi
movq -0x18(%rbp), %rax
subq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
addq %rax, %rdi
callq 0x1a290
movq %rax, -0x8(%rbp)
jmp 0x1b848
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
subq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rsi
callq 0x1e780
movq %rax, -0x8(%rbp)
jmp 0x1b848
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1b837
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
subq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rsi
callq 0x1e780
movq %rax, -0x8(%rbp)
jmp 0x1b848
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e970
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: int_cmp
static int int_cmp(INT a, INT b) {
    if (IS_I63(a)) {
        if (IS_I63(b)) {
            int64_t ia = GET_I63(a);
            int64_t ib = GET_I63(b);
            if (ia < ib) return -1;
            if (ia > ib) return +1;
            return 0;
        } else {
            bool n = big_negative_(GET_BIG(b));
            big_decref(GET_BIG(b));
            return n ? 1 : -1;
        }
    } else {
        if (IS_I63(b)) {
            bool n = big_negative_(GET_BIG(a));
            big_decref(GET_BIG(a));
            return n ? -1 : 1;
        } else {
            int i = big_cmp_(GET_BIG(a), GET_BIG(b));
            big_decref(GET_BIG(a));
            big_decref(GET_BIG(b));
            return i;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1c2a3
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1c274
movq -0x10(%rbp), %rax
subq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x1c252
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1c308
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0x1c268
movl $0x1, -0x4(%rbp)
jmp 0x1c308
movl $0x0, -0x4(%rbp)
jmp 0x1c308
movq -0x18(%rbp), %rdi
callq 0x1c320
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c3a0
movb -0x29(%rbp), %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1c308
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1c2e0
movq -0x10(%rbp), %rdi
callq 0x1c320
andb $0x1, %al
movb %al, -0x2a(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c3a0
movb -0x2a(%rbp), %dl
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1c308
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c3d0
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c3a0
movq -0x18(%rbp), %rdi
callq 0x1c3a0
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: big_cmp_
static int big_cmp_(BIG* a, BIG* b) {
    ASSERT(a); ASSERT(b);
    bool an = big_negative_(a);
    bool bn = big_negative_(b);
    if (an && !bn) return -1;
    if (!an && bn) return  1;
    if (a->size != b->size) {
        int i = (a->size < b->size) ? -1 : +1;
        return an ? -i : i;
    }
    for (size_t i = a->size; i --> 0;) {
        int64_t ar = a->radix[i];
        int64_t br = b->radix[i];
        if (ar != br) {
            return (ar < br) ? -1 : +1;
            // negative doesn't matter here, since they are both either negative or positive.
            // think of comparing these as if adding a large constant to make them both non negative.
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c411
movl $0x2, %edi
leaq 0x338092(%rip), %rsi    # 0x354485
movl $0x2f, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1c413
jmp 0x1c415
cmpq $0x0, -0x18(%rbp)
jne 0x1c446
movl $0x2, %edi
leaq 0x33808d(%rip), %rsi    # 0x3544b5
movl $0x2f, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1c448
movq -0x10(%rbp), %rdi
callq 0x1c320
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c320
andb $0x1, %al
movb %al, -0x1a(%rbp)
testb $0x1, -0x19(%rbp)
je 0x1c47c
testb $0x1, -0x1a(%rbp)
jne 0x1c47c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1c558
testb $0x1, -0x19(%rbp)
jne 0x1c494
testb $0x1, -0x1a(%rbp)
je 0x1c494
movl $0x1, -0x4(%rbp)
jmp 0x1c558
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x1c4e7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovbl %ecx, %eax
movl %eax, -0x20(%rbp)
testb $0x1, -0x19(%rbp)
je 0x1c4d9
xorl %eax, %eax
subl -0x20(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x1c4df
movl -0x20(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c558
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x28(%rbp)
cmpq $0x0, %rax
jbe 0x1c551
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movl 0x18(%rax,%rcx,4), %eax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movl 0x18(%rax,%rcx,4), %eax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x1c54f
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovll %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1c558
jmp 0x1c4f3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_str_zaStr_offsetzeslice
static STR* mw_std_str_zaStr_offsetzeslice (STR* in_zaStr_1, INT in_Offset_2, INT in_Offset_3, STR* *out_zaStr_4) {
	incref(MKINT(in_Offset_2));
	INT v8 = int_sub(in_Offset_3, in_Offset_2);
	STR* v9;
	STR* v10 = mw_std_str_zaStr_slice(in_zaStr_1, in_Offset_2, v8, &v9);
	*out_zaStr_4 = v9;
	return v10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x374e8e(%rip), %rax    # 0x391428
orq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1c62c
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x374e69(%rip), %rax    # 0x391428
orq $0x1, %rax
movq %rax, -0x38(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x40(%rbp), %rax
cmpq $0x0, %rax
je 0x1c62c
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x374e3e(%rip), %rax    # 0x391428
orq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x1c62c
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x374e19(%rip), %rax    # 0x391428
orq $0x1, %rax
movq %rax, -0x58(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x60(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x1c62e
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1c670
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x70(%rbp), %rcx
callq 0x1c700
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: int_sub
static INT int_sub(INT a, INT b) {
    if (IS_I63(a) && IS_I63(b)) {
        return i64_to_int(GET_I63(a) - GET_I63(b));
    } else {
        return int_add(a, int_negate(b));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1c6d1
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1c6d1
movq -0x10(%rbp), %rax
subq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rdi
movq -0x18(%rbp), %rax
subq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
subq %rax, %rdi
callq 0x1a290
movq %rax, -0x8(%rbp)
jmp 0x1c6ef
movq -0x18(%rbp), %rdi
callq 0x1c7f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1b780
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_str_zaStr_slice
static STR* mw_std_str_zaStr_slice (STR* in_zaStr_1, INT in_Offset_2, INT in_Sizze_3, STR* *out_zaStr_4) {
	incref(MKSTR(in_zaStr_1));
	STR* v8 = mw_std_prim_Str_slice(in_Offset_2, in_Sizze_3, in_zaStr_1);
	*out_zaStr_4 = in_zaStr_1;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x374a31(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1c7b9
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x374a0c(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x38(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x40(%rbp), %rax
cmpq $0x0, %rax
je 0x1c7b9
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x3749e1(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x1c7b9
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x3749bc(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x58(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x60(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x1c7bb
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1cca0
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: int_negate
static INT int_negate(INT a) {
    if (IS_I63(a)) {
        return i64_to_int(-GET_I63(a));
    } else {
        return big_negate(GET_BIG(a));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1c82e
movq -0x10(%rbp), %rax
subq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
xorl %ecx, %ecx
movl %ecx, %edi
subq %rax, %rdi
callq 0x1a290
movq %rax, -0x8(%rbp)
jmp 0x1c83b
movq -0x10(%rbp), %rdi
callq 0x1c850
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: big_negate
static INT big_negate(BIG* a) {
    ASSERT(a);
    a = big_reserve(a, a->size+1);
    uint32_t an = NEXT_RADIX(a->radix[a->size-1]);
    uint32_t c = 1;
    for (size_t i=0; i < a->size; i++) {
        uint64_t r = (uint64_t)(~(uint32_t)(a->radix[i])) + (uint64_t)c;
        a->radix[i] = LO_RADIX(r);
        c = HI_RADIX(r);
    }
    a->radix[a->size++] = ~an + c;
    return big_normalize(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c88d
movl $0x2, %edi
leaq 0x337cb5(%rip), %rsi    # 0x354524
movl $0x2e, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1c88f
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x1, %rsi
callq 0x1c970
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
movl 0x18(%rax,%rcx,4), %edx
andl $0x80000000, %edx       # imm = 0x80000000
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1c935
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x18(%rax,%rcx,4), %eax
xorl $-0x1, %eax
movl %eax, %eax
movl -0x18(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl %edx, 0x18(%rax,%rcx,4)
movq -0x28(%rbp), %rax
shrq $0x20, %rax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1c8e1
movl -0x14(%rbp), %edx
xorl $-0x1, %edx
addl -0x18(%rbp), %edx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movq 0x10(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x10(%rsi)
movl %edx, 0x18(%rax,%rcx,4)
movq -0x10(%rbp), %rdi
callq 0x1cad0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: big_reserve
static BIG* big_reserve (BIG* a, size_t n) {
    ASSERT(a);
    if ((a->refs == 1) && (a->cap >= n))
        return a;
    if (n < a->cap*2) n = a->cap*2;
    if (a->refs == 1) {
        BIG* b = realloc(a, sizeof(*b) + n*sizeof(*b->radix) + 4);
        EXPECT(b, "Ran out of memory.");
        b->cap = n;
        return b;
    } else {
        BIG* b = big_alloc(n);
        b->size = a->size;
        memcpy(b->radix, a->radix, a->size*sizeof(a->radix[0]));
        big_decref(a);
        return b;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c9b1
movl $0x2, %edi
leaq 0x337bc0(%rip), %rsi    # 0x354553
movl $0x2e, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1c9b3
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x1c9d7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jb 0x1c9d7
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1cab8
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq %rcx
cmpq %rcx, %rax
jae 0x1c9fa
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x1ca69
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
shlq $0x2, %rsi
addq $0x18, %rsi
addq $0x4, %rsi
callq 0x50f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1ca51
movl $0x2, %edi
leaq 0x337387(%rip), %rsi    # 0x353dba
movl $0x13, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1ca53
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1cab8
movq -0x18(%rbp), %rdi
callq 0x5250
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
shlq $0x2, %rdx
callq 0x50e0
movq -0x10(%rbp), %rdi
callq 0x1c3a0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: big_normalize
static INT big_normalize (BIG* a) {
    ASSERT(a); ASSERT(a->refs == 1); ASSERT(a->size >= 1);
    while ((a->size > 2) && (NEXT_RADIX(a->radix[a->size-2]) == a->radix[a->size-1]))
        a->size--;
    if (a->size == 2) {
        uint64_t u = (uint64_t)(a->radix[0]) | ((uint64_t)(a->radix[1]) << 32);
        int64_t i = (int64_t)u;
        if (FITS_I63(i)) {
            free(a);
            return WRAP_I63(i);
        }
    }
    if (a->size == 1) {
        int64_t i = a->radix[0];
        free(a);
        return WRAP_I63(i);
    }
    return WRAP_BIG(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1cb0d
movl $0x2, %edi
leaq 0x337a93(%rip), %rsi    # 0x354582
movl $0x2e, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1cb0f
jmp 0x1cb11
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0x1cb44
movl $0x2, %edi
leaq 0x337a8b(%rip), %rsi    # 0x3545b1
movl $0x39, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1cb46
jmp 0x1cb48
movq -0x10(%rbp), %rax
cmpq $0x1, 0x10(%rax)
jae 0x1cb7d
movl $0x2, %edi
leaq 0x337a8c(%rip), %rsi    # 0x3545eb
movl $0x39, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1cb7f
jmp 0x1cb81
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x2, 0x10(%rcx)
movb %al, -0x29(%rbp)
jbe 0x1cbd2
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x2, %rcx
movl 0x18(%rax,%rcx,4), %edx
andl $0x80000000, %edx       # imm = 0x80000000
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovnel %ecx, %eax
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq 0x10(%rdx), %rdx
subq $0x1, %rdx
cmpl 0x18(%rcx,%rdx,4), %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x1cbdb
jmp 0x1cbed
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x1cb81
movq -0x10(%rbp), %rax
cmpq $0x2, 0x10(%rax)
jne 0x1cc55
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x1c(%rcx), %ecx
shlq $0x20, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
cmpq -0x20(%rbp), %rax
jg 0x1cc53
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rax, -0x20(%rbp)
jg 0x1cc53
movq -0x10(%rbp), %rdi
callq 0x5030
movq -0x20(%rbp), %rax
shlq %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1cc8d
jmp 0x1cc55
movq -0x10(%rbp), %rax
cmpq $0x1, 0x10(%rax)
jne 0x1cc85
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5030
movq -0x28(%rbp), %rax
shlq %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1cc8d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)