LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: str_drop
static STR* str_drop (STR* in, size_t num_bytes) {
    ASSERT(in);
    if (num_bytes > in->size) {
        num_bytes = in->size;
    }
    size_t remaining = in->size - num_bytes;
    char* slice = in->data + num_bytes;

    if (in->refs == 1) {
        if (remaining > 0) memmove(in->data, slice, remaining);
        memset(in->data + remaining, 0, in->cap - remaining);
        in->size = remaining;
        return in;
    } else {
        STR* out = str_make(slice, remaining);
        decref(MKSTR(in));
        return out;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1d12b4
movl $0x2, %edi
leaq 0x18afa0(%rip), %rsi    # 0x35c236
movl $0x2f, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1d12b6
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x1d12d0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x1d134d
cmpq $0x0, -0x20(%rbp)
jbe 0x1d1315
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5100
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
addq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
subq -0x20(%rbp), %rdx
xorl %esi, %esi
callq 0x5080
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1d1438
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb6c0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x1bfdeb(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1d142e
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x1bfdc2(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x48(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x50(%rbp), %rax
cmpq $0x0, %rax
je 0x1d142e
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x1bfd97(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x1d142e
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq 0x1bfd72(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x68(%rbp)
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq -0x70(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x1d142c
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq 0x1bfd41(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x78(%rbp)
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x127c0
jmp 0x1d142e
jmp 0x1d1430
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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_result_Result_2_free
void std_result_Result_2_free (VAL v) {
	struct std_result_Result_2 self = V_std_result_Result_2(v);
	switch (self.tag) {
		case std_result_Result_2_Err: {
			decref(self.ptr.Err->m0);
			free(self.ptr.Err);
		} break;
		case std_result_Result_2_Ok: {
			decref(self.ptr.Ok->m0);
			free(self.ptr.Ok);
		} 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 0x1cf230
movl %eax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x1d15c1
jmp 0x1d15b0
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x1d163d
jmp 0x1d16b7
jmp 0x1d15c3
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1d1630
movq -0x18(%rbp), %rcx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq 0x8(%rcx), %rax
cmpq $0x0, %rax
je 0x1d1630
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x1d1630
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 0x1d162e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
callq 0x127c0
jmp 0x1d1630
jmp 0x1d1632
movq -0x18(%rbp), %rdi
callq 0x5030
jmp 0x1d16b7
jmp 0x1d163f
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1d16ac
movq -0x18(%rbp), %rcx
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq 0x8(%rcx), %rax
cmpq $0x0, %rax
je 0x1d16ac
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x1d16ac
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 0x1d16aa
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
callq 0x127c0
jmp 0x1d16ac
jmp 0x1d16ae
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: mw_mirth_lexer_zaLexer_intzesign
static INT mw_mirth_lexer_zaLexer_intzesign (STR* in_zaStr_1, struct mirth_lexer_zaLexer* in_zaLexer_2, STR* *out_zaStr_3, struct mirth_lexer_zaLexer* *out_zaLexer_4, INT *out_Int_6, INT *out_Offset_7) {
	INT v8 = WRAP_I63(0LL);
	STR* v9;
	enum std_byte_Byte v10 = mw_std_str_zaStr_bytezo(v8, in_zaStr_1, &v9);
	INT v11;
	INT v12;
	INT v13 = mw_mirth_lexer_zaLexer_bytezesignzevaluezeindex(v10, &v11, &v12);
	*out_Offset_7 = v12;
	*out_Int_6 = v11;
	*out_zaLexer_4 = in_zaLexer_2;
	*out_zaStr_3 = v9;
	return v13;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq 0x18f289(%rip), %rax    # 0x36ea50
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x1b5a0
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %edi
leaq -0x58(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x1dfba0
movq %rax, -0x8(%rbp)
movq -0x38(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_lexer_zaLexer_bytezesignzevaluezeindex
static INT mw_mirth_lexer_zaLexer_bytezesignzevaluezeindex (enum std_byte_Byte in_Byte_1, INT *out_Int_3, INT *out_Offset_4) {
	INT branch_Int_5;
	INT branch_Int_6;
	INT branch_Offset_7;
	switch (in_Byte_1) {
		case std_byte_Byte_Bzqzezq: {
			INT v8 = WRAP_I63(-1LL);
			INT v9 = WRAP_I63(0LL);
			INT v10 = WRAP_I63(1LL);
			branch_Offset_7 = v10;
			branch_Int_6 = v9;
			branch_Int_5 = v8;
		} break;
		case std_byte_Byte_Bzqzazq: {
			INT v11 = WRAP_I63(1LL);
			INT v12 = WRAP_I63(0LL);
			INT v13 = WRAP_I63(1LL);
			branch_Offset_7 = v13;
			branch_Int_6 = v12;
			branch_Int_5 = v11;
		} break;
		default: {
			INT v14 = WRAP_I63(1LL);
			INT v15 = WRAP_I63(0LL);
			INT v16 = WRAP_I63(0LL);
			branch_Offset_7 = v16;
			branch_Int_6 = v15;
			branch_Int_5 = v14;
		} break;
	}
	*out_Offset_4 = branch_Offset_7;
	*out_Int_3 = branch_Int_6;
	return branch_Int_5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x7c(%rbp)
subl $0x2b, %eax
je 0x1dfc01
jmp 0x1dfbbc
movl -0x7c(%rbp), %eax
subl $0x2d, %eax
jne 0x1dfc3c
jmp 0x1dfbc6
movq 0x18eea3(%rip), %rax    # 0x36ea70
movq %rax, -0x38(%rbp)
movq 0x18ee78(%rip), %rax    # 0x36ea50
movq %rax, -0x40(%rbp)
movq 0x18ee75(%rip), %rax    # 0x36ea58
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1dfc75
movq 0x18ee50(%rip), %rax    # 0x36ea58
movq %rax, -0x50(%rbp)
movq 0x18ee3d(%rip), %rax    # 0x36ea50
movq %rax, -0x58(%rbp)
movq 0x18ee3a(%rip), %rax    # 0x36ea58
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1dfc75
movq 0x18ee15(%rip), %rax    # 0x36ea58
movq %rax, -0x68(%rbp)
movq 0x18ee02(%rip), %rax    # 0x36ea50
movq %rax, -0x70(%rbp)
movq 0x18edf7(%rip), %rax    # 0x36ea50
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_token_TokenValue_Int
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_Int (INT in_Int_1) {
	struct mirth_token_TokenValue_Int* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mInt = in_Int_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_Int, .ptr.Int=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 0x1e4020
movl $0x2, %edi
leaq 0x1783f8(%rip), %rsi    # 0x35c3fa
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e4022
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0xe, -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: mtw_mirth_token_TokenValue_Nat
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_Nat (INT in_Nat_1) {
	struct mirth_token_TokenValue_Nat* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mNat = in_Nat_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_Nat, .ptr.Nat=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 0x1e40b0
movl $0x2, %edi
leaq 0x17839a(%rip), %rsi    # 0x35c42c
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e40b2
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0xf, -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: mtw_mirth_token_TokenValue_U8
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_U8 (uint8_t in_U8_1) {
	struct mirth_token_TokenValue_U8* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mU8 = in_U8_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_U8, .ptr.U8=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x11(%rbp)
movl $0x1, %edi
movl $0x8, %esi
callq 0x50c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1e4142
movl $0x2, %edi
leaq 0x17833a(%rip), %rsi    # 0x35c45e
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e4144
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x4(%rax)
movl $0x10, -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: mtw_mirth_token_TokenValue_U16
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_U16 (uint16_t in_U16_1) {
	struct mirth_token_TokenValue_U16* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mU16 = in_U16_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_U16, .ptr.U16=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x12(%rbp)
movl $0x1, %edi
movl $0x8, %esi
callq 0x50c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1e41d3
movl $0x2, %edi
leaq 0x1782db(%rip), %rsi    # 0x35c490
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e41d5
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movw -0x12(%rbp), %cx
movq -0x20(%rbp), %rax
movw %cx, 0x4(%rax)
movl $0x11, -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 (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_token_TokenValue_U32
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_U32 (uint32_t in_U32_1) {
	struct mirth_token_TokenValue_U32* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mU32 = in_U32_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_U32, .ptr.U32=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x14(%rbp)
movl $0x1, %edi
movl $0x8, %esi
callq 0x50c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1e425f
movl $0x2, %edi
leaq 0x178281(%rip), %rsi    # 0x35c4c2
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e4261
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x12, -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: mtw_mirth_token_TokenValue_U64
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_U64 (uint64_t in_U64_1) {
	struct mirth_token_TokenValue_U64* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mU64 = in_U64_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_U64, .ptr.U64=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 0x1e42f0
movl $0x2, %edi
leaq 0x178222(%rip), %rsi    # 0x35c4f4
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e42f2
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x13, -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: mtw_mirth_token_TokenValue_I8
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_I8 (int8_t in_I8_1) {
	struct mirth_token_TokenValue_I8* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mI8 = in_I8_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_I8, .ptr.I8=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x11(%rbp)
movl $0x1, %edi
movl $0x8, %esi
callq 0x50c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1e4382
movl $0x2, %edi
leaq 0x1781c2(%rip), %rsi    # 0x35c526
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e4384
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x4(%rax)
movl $0x14, -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: mtw_mirth_token_TokenValue_I16
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_I16 (int16_t in_I16_1) {
	struct mirth_token_TokenValue_I16* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mI16 = in_I16_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_I16, .ptr.I16=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x12(%rbp)
movl $0x1, %edi
movl $0x8, %esi
callq 0x50c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1e4413
movl $0x2, %edi
leaq 0x178163(%rip), %rsi    # 0x35c558
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e4415
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movw -0x12(%rbp), %cx
movq -0x20(%rbp), %rax
movw %cx, 0x4(%rax)
movl $0x15, -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 (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_token_TokenValue_I32
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_I32 (int32_t in_I32_1) {
	struct mirth_token_TokenValue_I32* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mI32 = in_I32_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_I32, .ptr.I32=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x14(%rbp)
movl $0x1, %edi
movl $0x8, %esi
callq 0x50c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1e449f
movl $0x2, %edi
leaq 0x178109(%rip), %rsi    # 0x35c58a
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e44a1
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x16, -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: mtw_mirth_token_TokenValue_I64
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_I64 (int64_t in_I64_1) {
	struct mirth_token_TokenValue_I64* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mI64 = in_I64_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_I64, .ptr.I64=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 0x1e4530
movl $0x2, %edi
leaq 0x1780aa(%rip), %rsi    # 0x35c5bc
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e4532
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x17, -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: mtw_mirth_name_DName_DName
static struct mirth_name_DName* mtw_mirth_name_DName_DName (struct std_maybe_Maybe_1 in_Maybe_1, struct std_list_Nest_1* in_Nest_2) {
	struct mirth_name_DName* v4 = calloc(1, sizeof *v4);
	ASSERT(v4);
	v4->refs = 1;
	v4->mNest = in_Nest_2;
	v4->mMaybe = in_Maybe_1;
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x50c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1e4b07
movl $0x2, %edi
leaq 0x177b05(%rip), %rsi    # 0x35c5ee
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e4b09
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%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: mtw_mirth_token_TokenValue_DName
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_DName (struct mirth_name_DName* in_DName_1) {
	struct mirth_token_TokenValue_DName* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mDName = in_DName_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_DName, .ptr.DName=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 0x1e4b90
movl $0x2, %edi
leaq 0x177aae(%rip), %rsi    # 0x35c620
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e4b92
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1c, -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_str_zaStr_firstzebyte
static enum std_byte_Byte mw_std_str_zaStr_firstzebyte (STR* in_zaStr_1, STR* *out_zaStr_2) {
	INT v4 = WRAP_I63(0LL);
	STR* v5;
	enum std_byte_Byte v6 = mw_std_str_zaStr_bytezo(v4, in_zaStr_1, &v5);
	*out_zaStr_2 = v5;
	return v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x187229(%rip), %rax    # 0x36ea50
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rdx
callq 0x1b5a0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%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: mw_std_str_zaStr_secondzebyte
static enum std_byte_Byte mw_std_str_zaStr_secondzebyte (STR* in_zaStr_1, STR* *out_zaStr_2) {
	INT v4 = WRAP_I63(1LL);
	STR* v5;
	enum std_byte_Byte v6 = mw_std_str_zaStr_bytezo(v4, in_zaStr_1, &v5);
	*out_zaStr_2 = v5;
	return v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x1871e1(%rip), %rax    # 0x36ea58
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rdx
callq 0x1b5a0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%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: mw_std_prelude_unsafe_1_sp16
static STR* mw_std_prelude_unsafe_1_sp16 (STR* in_zaStr_1, STR* *out_zaStr_2) {
	STR* v4;
	STR* v5 = mw_std_str_zaStr_dropzefirstzebyte(in_zaStr_1, &v4);
	*out_zaStr_2 = v4;
	return v5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1e7980
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%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: mtw_mirth_token_TokenValue_LabelPush
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_LabelPush (uint64_t in_Label_1) {
	struct mirth_token_TokenValue_LabelPush* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mLabel = in_Label_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_LabelPush, .ptr.LabelPush=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 0x1e7940
movl $0x2, %edi
leaq 0x174d30(%rip), %rsi    # 0x35c652
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e7942
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1e, -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_str_zaStr_dropzefirstzebyte
static STR* mw_std_str_zaStr_dropzefirstzebyte (STR* in_zaStr_1, STR* *out_zaStr_2) {
	INT v6 = WRAP_I63(1LL);
	STR* v7;
	STR* v8 = mw_std_str_zaStr_dropzeslice(in_zaStr_1, v6, &v7);
	*out_zaStr_2 = v7;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x1870c1(%rip), %rax    # 0x36ea58
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1df1b0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%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: mw_std_str_zaStr_firstzetwozebytes
static STR* mw_std_str_zaStr_firstzetwozebytes (STR* in_zaStr_1, STR* *out_zaStr_2) {
	INT v6 = WRAP_I63(2LL);
	STR* v7;
	STR* v8 = mw_std_str_zaStr_takezeslice(in_zaStr_1, v6, &v7);
	*out_zaStr_2 = v7;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x187079(%rip), %rax    # 0x36ea60
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1e7b00
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%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: mtw_mirth_token_TokenValue_LabelPushR
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_LabelPushR (uint64_t in_Label_1) {
	struct mirth_token_TokenValue_LabelPushR* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mLabel = in_Label_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_LabelPushR, .ptr.LabelPushR=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 0x1e7ac0
movl $0x2, %edi
leaq 0x174be5(%rip), %rsi    # 0x35c687
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e7ac2
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x20, -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_str_zaStr_takezeslice
static STR* mw_std_str_zaStr_takezeslice (STR* in_zaStr_1, INT in_Sizze_2, STR* *out_zaStr_3) {
	INT v7 = WRAP_I63(0LL);
	STR* v8;
	STR* v9 = mw_std_str_zaStr_slice(in_zaStr_1, v7, in_Sizze_2, &v8);
	*out_zaStr_3 = v8;
	return v9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x186f35(%rip), %rax    # 0x36ea50
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x1c700
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x30, %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_lastzebyte
static enum std_byte_Byte mw_std_str_zaStr_lastzebyte (STR* in_zaStr_1, STR* *out_zaStr_3) {
	incref(MKSTR(in_zaStr_1));
	enum std_byte_Byte v4 = mw_std_prim_Str_lastzebyte(in_zaStr_1);
	*out_zaStr_3 = in_zaStr_1;
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x1a95e9(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1e7c01
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x1a95c4(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x28(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x30(%rbp), %rax
cmpq $0x0, %rax
je 0x1e7c01
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x1a9599(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x1e7c01
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x1a9574(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x48(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x50(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x1e7c03
movq -0x8(%rbp), %rdi
callq 0x1e7d00
movl %eax, -0x54(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x54(%rbp), %eax
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: mtw_mirth_token_TokenValue_LabelPop
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_LabelPop (uint64_t in_Label_1) {
	struct mirth_token_TokenValue_LabelPop* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mLabel = in_Label_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_LabelPop, .ptr.LabelPop=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 0x1e7cc0
movl $0x2, %edi
leaq 0x174a17(%rip), %rsi    # 0x35c6b9
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e7cc2
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1d, -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_lastzebyte
static enum std_byte_Byte mw_std_prim_Str_lastzebyte (STR* in_Str_1) {
	incref(MKSTR(in_Str_1));
	uint64_t v3 = str_size(in_Str_1);
	INT v4 = u64_to_int(v3);
	INT v5 = WRAP_I63(1LL);
	INT v6 = v5;
	INT v7 = int_sub(v4, v6);
	enum std_byte_Byte v8 = mw_std_prim_Str_bytezo(v7, in_Str_1);
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1a943a(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1e7db0
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x1a9415(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x20(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x28(%rbp), %rax
cmpq $0x0, %rax
je 0x1e7db0
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x1a93ea(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x1e7db0
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x1a93c5(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x40(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x48(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x1e7db2
movq -0x8(%rbp), %rdi
callq 0x1b3f0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1b520
movq %rax, -0x58(%rbp)
movq 0x186c85(%rip), %rax    # 0x36ea58
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x1c670
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x1b8e0
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
addq $0x80, %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_dropzelastzebyte
static STR* mw_std_str_zaStr_dropzelastzebyte (STR* in_zaStr_1, STR* *out_zaStr_2) {
	incref(MKSTR(in_zaStr_1));
	uint64_t v6 = str_size(in_zaStr_1);
	INT v7 = u64_to_int(v6);
	INT v8 = WRAP_I63(1LL);
	INT v9 = v8;
	INT v10 = int_sub(v7, v9);
	STR* v11;
	STR* v12 = mw_std_str_zaStr_takezeslice(in_zaStr_1, v10, &v11);
	*out_zaStr_2 = v11;
	return v12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x1a9326(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1e7ec4
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x1a9301(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x28(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x30(%rbp), %rax
cmpq $0x0, %rax
je 0x1e7ec4
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x1a92d6(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x1e7ec4
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x1a92b1(%rip), %rax    # 0x391158
orq $0x1, %rax
movq %rax, -0x48(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x50(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x1e7ec6
movq -0x8(%rbp), %rdi
callq 0x1b3f0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x1b520
movq %rax, -0x60(%rbp)
movq 0x186b71(%rip), %rax    # 0x36ea58
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x1c670
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rdi
movq -0x78(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x1e7b00
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_token_TokenValue_LabelPopR
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_LabelPopR (uint64_t in_Label_1) {
	struct mirth_token_TokenValue_LabelPopR* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mLabel = in_Label_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_LabelPopR, .ptr.LabelPopR=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 0x1e7f90
movl $0x2, %edi
leaq 0x174779(%rip), %rsi    # 0x35c6eb
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e7f92
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1f, -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: mtw_mirth_token_TokenValue_LabelGet
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_LabelGet (uint64_t in_Label_1) {
	struct mirth_token_TokenValue_LabelGet* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mLabel = in_Label_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_LabelGet, .ptr.LabelGet=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 0x1e8020
movl $0x2, %edi
leaq 0x17471b(%rip), %rsi    # 0x35c71d
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e8022
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x21, -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: mtw_mirth_token_TokenValue_LabelSet
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_LabelSet (uint64_t in_Label_1) {
	struct mirth_token_TokenValue_LabelSet* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mLabel = in_Label_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_LabelSet, .ptr.LabelSet=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 0x1e80b0
movl $0x2, %edi
leaq 0x1746bd(%rip), %rsi    # 0x35c74f
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e80b2
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x22, -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: mtw_mirth_token_TokenValue_LabelLam
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_LabelLam (uint64_t in_Label_1) {
	struct mirth_token_TokenValue_LabelLam* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mLabel = in_Label_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_LabelLam, .ptr.LabelLam=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 0x1e8140
movl $0x2, %edi
leaq 0x17465f(%rip), %rsi    # 0x35c781
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e8142
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x23, -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: mtw_mirth_token_TokenValue_Name
static struct mirth_token_TokenValue mtw_mirth_token_TokenValue_Name (uint64_t in_Name_1) {
	struct mirth_token_TokenValue_Name* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mName = in_Name_1;
	struct mirth_token_TokenValue v4 = { .tag=mirth_token_TokenValue_Name, .ptr.Name=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 0x1e81d0
movl $0x2, %edi
leaq 0x174601(%rip), %rsi    # 0x35c7b3
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1e81d2
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1b, -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: mtp_mirth_lexer_zaLexer_zaLexer
static void mtp_mirth_lexer_zaLexer_zaLexer (struct mirth_lexer_zaLexer* in_zaLexer_1, uint64_t *out_Module_2, INT *out_Row_3, INT *out_Col_4, struct std_maybe_Maybe_1 *out_Maybe_5, struct std_list_List_1 *out_List_6, uint64_t *out_Token_7, uint64_t *out_Token_8, STR* *out_Str_9, INT *out_Offset_10) {
	struct mirth_lexer_zaLexer v11 = *in_zaLexer_1;
	free(in_zaLexer_1);
	*out_Offset_10 = v11.mlexerzeoffset;
	*out_Str_9 = v11.mlexerzesource;
	*out_Token_8 = v11.mlexerzelastzetoken;
	*out_Token_7 = v11.mlexerzefirstzetoken;
	*out_List_6 = v11.mlexerzestack;
	*out_Maybe_5 = v11.mlexerzedoc;
	*out_Col_4 = v11.mlexerzecol;
	*out_Row_3 = v11.mlexerzerow;
	*out_Module_2 = v11.mlexerzemodule;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movl $0x58, %edx
callq 0x50e0
movq -0x8(%rbp), %rdi
callq 0x5030
movq 0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, (%rax)
movq -0x88(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x90, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_module_Module_start
static uint64_t mw_mirth_module_Module_start (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Module_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_module_Module_start, in_Module_2);
	VAL v6 = mut_get(v5);
	*out_zaMirth_3 = in_zaMirth_1;
	return V_mirth_token_Token(v6);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x11ae461(%rip), %rdi   # 0x1396840
callq 0x40d30
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x40f30
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_elab_ModuleHeader_ModuleHeader
static struct mirth_elab_ModuleHeader* mtw_mirth_elab_ModuleHeader_ModuleHeader (struct std_maybe_Maybe_1 in_Maybe_1, uint64_t in_Package_2, uint64_t in_Name_3, uint64_t in_Token_4, struct std_list_List_1 in_List_5) {
	struct mirth_elab_ModuleHeader* v7 = calloc(1, sizeof *v7);
	ASSERT(v7);
	v7->refs = 1;
	v7->mimports = in_List_5;
	v7->mhead = in_Token_4;
	v7->mname = in_Name_3;
	v7->mpackage = in_Package_2;
	v7->mdoc = in_Maybe_1;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x1, %edi
movl $0x40, %esi
callq 0x50c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1ecf87
movl $0x2, %edi
leaq 0x16f9d5(%rip), %rsi    # 0x35c93e
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1ecf89
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movq -0x30(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x30(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x38(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_list_Nest_1_singlezy
static struct std_maybe_Maybe_1 mw_std_list_Nest_1_singlezy (struct std_list_Nest_1* in_Nest_1) {
	VAL v3;
	struct std_list_List_1 v4;
	mtp_std_list_Nest_1_Nest(in_Nest_1, &v3, &v4);
	bool v5 = mw_std_list_List_1_emptyzy(v4);
	struct std_maybe_Maybe_1 branch_Maybe_6;
	if (v5) {
		struct std_maybe_Maybe_1 v7 = mtw_std_maybe_Maybe_1_Some(v3);
		branch_Maybe_6 = v7;
	} else {
		decref(v3);
		struct std_maybe_Maybe_1 v8 = { .tag=std_maybe_Maybe_1_None };
		branch_Maybe_6 = v8;
	}
	return branch_Maybe_6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x1ef80
movl -0x38(%rbp), %edi
movq -0x30(%rbp), %rsi
callq 0x1f3c0
andb $0x1, %al
movb %al, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
je 0x1ed24a
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xca10
movl %eax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1ed2c7
jmp 0x1ed24c
movq -0x20(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1ed2a5
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x28(%rbp), %rax
cmpq $0x0, %rax
je 0x1ed2a5
movq -0x28(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x1ed2a5
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq -0x28(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x1ed2a3
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x127c0
jmp 0x1ed2a5
jmp 0x1ed2a7
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x5080
movq -0x60(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
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: mw_mirth_package_Package_FindzeOrzeNewzx
static uint64_t mw_mirth_package_Package_FindzeOrzeNewzx (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Name_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	struct std_maybe_Maybe_1 v6 = mw_mirth_package_Package_Findzy(in_zaMirth_1, in_Name_2, &v5);
	struct mirth_mirth_zaMirth* branch_zaMirth_7;
	uint64_t branch_Name_8;
	uint64_t branch_Package_9;
	switch ((v6).tag) {
		case std_maybe_Maybe_1_Some: {
			VAL v10 = mtp_std_maybe_Maybe_1_Some(v6);
			branch_Package_9 = V_mirth_package_Package(v10);
			branch_Name_8 = in_Name_2;
			branch_zaMirth_7 = v5;
		} break;
		case std_maybe_Maybe_1_None: {
			struct std_maybe_Maybe_1 v11 = { .tag=std_maybe_Maybe_1_None };
			struct mirth_mirth_zaMirth* v12;
			uint64_t v13 = mw_mirth_package_Package_Newzx(v5, v11, in_Name_2, &v12);
			branch_Package_9 = v13;
			branch_Name_8 = in_Name_2;
			branch_zaMirth_7 = v12;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	*out_zaMirth_3 = branch_zaMirth_7;
	return branch_Package_9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1c2c20
movl %eax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x7c(%rbp)
testl %eax, %eax
je 0x1ed353
jmp 0x1ed31b
movl -0x7c(%rbp), %eax
subl $0x1, %eax
jne 0x1ed399
jmp 0x1ed325
movl -0x30(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0x174a0
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x1ed3b2
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x5080
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl -0x68(%rbp), %esi
movq -0x60(%rbp), %rdx
leaq -0x70(%rbp), %r8
callq 0x1c3850
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x1ed3b2
leaq 0x166ae1(%rip), %rdi    # 0x353e81
movl $0x20, %esi
callq 0xb6c0
movq %rax, %rdi
callq 0xc620
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)