LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_token_TokenValue_U16
static uint16_t mtp_mirth_token_TokenValue_U16 (struct mirth_token_TokenValue in_TokenValue_1) {
	struct mirth_token_TokenValue_U16 v3 = *in_TokenValue_1.ptr.U16;
	if (!--(in_TokenValue_1.ptr.U16->refs)) {
		free(in_TokenValue_1.ptr.U16);
	} else {
	}
	return v3.mU16;
}

// 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 0x110205
movq -0x8(%rbp), %rdi
callq 0x5030
jmp 0x110207
jmp 0x110207
movw -0x14(%rbp), %ax
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_arrow_PushValue_U16
static struct mirth_arrow_PushValue mtw_mirth_arrow_PushValue_U16 (uint16_t in_U16_1) {
	struct mirth_arrow_PushValue_U16* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mU16 = in_U16_1;
	struct mirth_arrow_PushValue v4 = { .tag=mirth_arrow_PushValue_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 0x110273
movl $0x2, %edi
leaq 0x2499a4(%rip), %rsi    # 0x359bf9
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x110275
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movw -0x12(%rbp), %cx
movq -0x20(%rbp), %rax
movw %cx, 0x4(%rax)
movl $0x4, -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: mtp_mirth_token_TokenValue_U32
static uint32_t mtp_mirth_token_TokenValue_U32 (struct mirth_token_TokenValue in_TokenValue_1) {
	struct mirth_token_TokenValue_U32 v3 = *in_TokenValue_1.ptr.U32;
	if (!--(in_TokenValue_1.ptr.U32->refs)) {
		free(in_TokenValue_1.ptr.U32);
	} else {
	}
	return v3.mU32;
}

// 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 0x1102e5
movq -0x8(%rbp), %rdi
callq 0x5030
jmp 0x1102e7
jmp 0x1102e7
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: mtw_mirth_arrow_PushValue_U32
static struct mirth_arrow_PushValue mtw_mirth_arrow_PushValue_U32 (uint32_t in_U32_1) {
	struct mirth_arrow_PushValue_U32* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mU32 = in_U32_1;
	struct mirth_arrow_PushValue v4 = { .tag=mirth_arrow_PushValue_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 0x11033f
movl $0x2, %edi
leaq 0x24990a(%rip), %rsi    # 0x359c2b
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x110341
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x5, -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_token_TokenValue_U64
static uint64_t mtp_mirth_token_TokenValue_U64 (struct mirth_token_TokenValue in_TokenValue_1) {
	struct mirth_token_TokenValue_U64 v3 = *in_TokenValue_1.ptr.U64;
	if (!--(in_TokenValue_1.ptr.U64->refs)) {
		free(in_TokenValue_1.ptr.U64);
	} else {
	}
	return v3.mU64;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %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 0x1103bd
movq -0x8(%rbp), %rdi
callq 0x5030
jmp 0x1103bf
jmp 0x1103bf
movq -0x18(%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_arrow_PushValue_U64
static struct mirth_arrow_PushValue mtw_mirth_arrow_PushValue_U64 (uint64_t in_U64_1) {
	struct mirth_arrow_PushValue_U64* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mU64 = in_U64_1;
	struct mirth_arrow_PushValue v4 = { .tag=mirth_arrow_PushValue_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 0x110420
movl $0x2, %edi
leaq 0x24985b(%rip), %rsi    # 0x359c5d
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x110422
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x6, -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_token_TokenValue_I8
static int8_t mtp_mirth_token_TokenValue_I8 (struct mirth_token_TokenValue in_TokenValue_1) {
	struct mirth_token_TokenValue_I8 v3 = *in_TokenValue_1.ptr.I8;
	if (!--(in_TokenValue_1.ptr.I8->refs)) {
		free(in_TokenValue_1.ptr.I8);
	} else {
	}
	return v3.mI8;
}

// 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 0x110495
movq -0x8(%rbp), %rdi
callq 0x5030
jmp 0x110497
jmp 0x110497
movb -0x14(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtw_mirth_arrow_PushValue_I8
static struct mirth_arrow_PushValue mtw_mirth_arrow_PushValue_I8 (int8_t in_I8_1) {
	struct mirth_arrow_PushValue_I8* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mI8 = in_I8_1;
	struct mirth_arrow_PushValue v4 = { .tag=mirth_arrow_PushValue_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 0x1104f2
movl $0x2, %edi
leaq 0x2497bb(%rip), %rsi    # 0x359c8f
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1104f4
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x4(%rax)
movl $0x7, -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_token_TokenValue_I16
static int16_t mtp_mirth_token_TokenValue_I16 (struct mirth_token_TokenValue in_TokenValue_1) {
	struct mirth_token_TokenValue_I16 v3 = *in_TokenValue_1.ptr.I16;
	if (!--(in_TokenValue_1.ptr.I16->refs)) {
		free(in_TokenValue_1.ptr.I16);
	} else {
	}
	return v3.mI16;
}

// 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 0x110565
movq -0x8(%rbp), %rdi
callq 0x5030
jmp 0x110567
jmp 0x110567
movw -0x14(%rbp), %ax
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_arrow_PushValue_I16
static struct mirth_arrow_PushValue mtw_mirth_arrow_PushValue_I16 (int16_t in_I16_1) {
	struct mirth_arrow_PushValue_I16* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mI16 = in_I16_1;
	struct mirth_arrow_PushValue v4 = { .tag=mirth_arrow_PushValue_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 0x1105d3
movl $0x2, %edi
leaq 0x24970c(%rip), %rsi    # 0x359cc1
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1105d5
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movw -0x12(%rbp), %cx
movq -0x20(%rbp), %rax
movw %cx, 0x4(%rax)
movl $0x8, -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: mtp_mirth_token_TokenValue_I32
static int32_t mtp_mirth_token_TokenValue_I32 (struct mirth_token_TokenValue in_TokenValue_1) {
	struct mirth_token_TokenValue_I32 v3 = *in_TokenValue_1.ptr.I32;
	if (!--(in_TokenValue_1.ptr.I32->refs)) {
		free(in_TokenValue_1.ptr.I32);
	} else {
	}
	return v3.mI32;
}

// 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 0x110645
movq -0x8(%rbp), %rdi
callq 0x5030
jmp 0x110647
jmp 0x110647
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: mtw_mirth_arrow_PushValue_I32
static struct mirth_arrow_PushValue mtw_mirth_arrow_PushValue_I32 (int32_t in_I32_1) {
	struct mirth_arrow_PushValue_I32* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mI32 = in_I32_1;
	struct mirth_arrow_PushValue v4 = { .tag=mirth_arrow_PushValue_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 0x11069f
movl $0x2, %edi
leaq 0x249672(%rip), %rsi    # 0x359cf3
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x1106a1
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x9, -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_arrow_PushValue_I64
static struct mirth_arrow_PushValue mtw_mirth_arrow_PushValue_I64 (int64_t in_I64_1) {
	struct mirth_arrow_PushValue_I64* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mI64 = in_I64_1;
	struct mirth_arrow_PushValue v4 = { .tag=mirth_arrow_PushValue_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 0x110780
movl $0x2, %edi
leaq 0x2495c3(%rip), %rsi    # 0x359d25
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x110782
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0xa, -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_token_TokenValue_F32
static float mtp_mirth_token_TokenValue_F32 (struct mirth_token_TokenValue in_TokenValue_1) {
	struct mirth_token_TokenValue_F32 v3 = *in_TokenValue_1.ptr.F32;
	if (!--(in_TokenValue_1.ptr.F32->refs)) {
		free(in_TokenValue_1.ptr.F32);
	} else {
	}
	return v3.mF32;
}

// 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 0x1107f5
movq -0x8(%rbp), %rdi
callq 0x5030
jmp 0x1107f7
jmp 0x1107f7
movss -0x14(%rbp), %xmm0
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_arrow_PushValue_F32
static struct mirth_arrow_PushValue mtw_mirth_arrow_PushValue_F32 (float in_F32_1) {
	struct mirth_arrow_PushValue_F32* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mF32 = in_F32_1;
	struct mirth_arrow_PushValue v4 = { .tag=mirth_arrow_PushValue_F32, .ptr.F32=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x14(%rbp)
movl $0x1, %edi
movl $0x8, %esi
callq 0x50c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x110861
movl $0x2, %edi
leaq 0x249514(%rip), %rsi    # 0x359d57
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x110863
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movss -0x14(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x4(%rax)
movl $0xb, -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: mtp_mirth_token_TokenValue_F64
static double mtp_mirth_token_TokenValue_F64 (struct mirth_token_TokenValue in_TokenValue_1) {
	struct mirth_token_TokenValue_F64 v3 = *in_TokenValue_1.ptr.F64;
	if (!--(in_TokenValue_1.ptr.F64->refs)) {
		free(in_TokenValue_1.ptr.F64);
	} else {
	}
	return v3.mF64;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %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 0x1108dd
movq -0x8(%rbp), %rdi
callq 0x5030
jmp 0x1108df
jmp 0x1108df
movsd -0x18(%rbp), %xmm0
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_arrow_PushValue_F64
static struct mirth_arrow_PushValue mtw_mirth_arrow_PushValue_F64 (double in_F64_1) {
	struct mirth_arrow_PushValue_F64* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mF64 = in_F64_1;
	struct mirth_arrow_PushValue v4 = { .tag=mirth_arrow_PushValue_F64, .ptr.F64=v3 };
	return v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x18(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x50c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x110941
movl $0x2, %edi
leaq 0x249466(%rip), %rsi    # 0x359d89
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x110943
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movl $0xc, -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: mw_mirth_elab_zaAB_elabzeatomzeblockzx
static void mw_mirth_elab_zaAB_elabzeatomzeblockzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_arrow_Arrow* in_zaAB_2, struct mirth_mirth_zaMirth* *out_zaMirth_3, struct mirth_arrow_Arrow* *out_zaAB_4) {
	struct mirth_arrow_Arrow* v5;
	uint64_t v6 = mw_mirth_elab_zaAB_abzetokenzo(in_zaAB_2, &v5);
	struct mirth_mirth_zaMirth* v7;
	uint64_t v8 = mw_mirth_token_Token_argsze1(in_zaMirth_1, v6, &v7);
	struct mirth_mirth_zaMirth* v9;
	struct mirth_arrow_Arrow* v10;
	uint64_t v11 = mw_mirth_elab_zaAB_elabzeblockzeatzx(v7, v5, v8, &v9, &v10);
	struct mirth_arrow_Op v12 = mtw_mirth_arrow_Op_BlockPush(v11);
	struct std_list_List_1 v13 = { .tag=std_list_List_1_Nil };
	struct mirth_mirth_zaMirth* v14;
	struct mirth_arrow_Arrow* v15;
	mw_mirth_elab_zaAB_abzeopzx(v9, v10, v13, v12, &v14, &v15);
	*out_zaAB_4 = v15;
	*out_zaMirth_3 = v14;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xe0b80
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xa8660
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x48(%rbp), %rcx
leaq -0x50(%rbp), %r8
callq 0x11c500
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x11dd70
movl %eax, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x5080
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x78(%rbp), %edx
movq -0x70(%rbp), %rcx
movl -0x68(%rbp), %r8d
movq -0x60(%rbp), %r9
leaq -0x80(%rbp), %r10
leaq -0x88(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xe1ee0
movq -0x88(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x80(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0xa0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_token_TokenValue_LabelPopR
static uint64_t mtp_mirth_token_TokenValue_LabelPopR (struct mirth_token_TokenValue in_TokenValue_1) {
	struct mirth_token_TokenValue_LabelPopR v3 = *in_TokenValue_1.ptr.LabelPopR;
	if (!--(in_TokenValue_1.ptr.LabelPopR->refs)) {
		free(in_TokenValue_1.ptr.LabelPopR);
	} else {
	}
	return v3.mLabel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %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 0x110f2d
movq -0x8(%rbp), %rdi
callq 0x5030
jmp 0x110f2f
jmp 0x110f2f
movq -0x18(%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: mtp_mirth_token_TokenValue_LabelLam
static uint64_t mtp_mirth_token_TokenValue_LabelLam (struct mirth_token_TokenValue in_TokenValue_1) {
	struct mirth_token_TokenValue_LabelLam v3 = *in_TokenValue_1.ptr.LabelLam;
	if (!--(in_TokenValue_1.ptr.LabelLam->refs)) {
		free(in_TokenValue_1.ptr.LabelLam);
	} else {
	}
	return v3.mLabel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %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 0x1116dd
movq -0x8(%rbp), %rdi
callq 0x5030
jmp 0x1116df
jmp 0x1116df
movq -0x18(%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_mirth_elab_zaAB_elabzelabelzelamzx
static void mw_mirth_elab_zaAB_elabzelabelzelamzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_arrow_Arrow* in_zaAB_2, struct std_list_List_1 in_List_3, uint64_t in_Label_4, struct mirth_mirth_zaMirth* *out_zaMirth_5, struct mirth_arrow_Arrow* *out_zaAB_6, struct std_list_List_1 *out_List_7) {
	struct mirth_mirth_zaMirth* v8;
	struct mirth_arrow_Arrow* v9;
	mw_mirth_elab_zaAB_abzelabelzepushzx(in_zaMirth_1, in_zaAB_2, in_Label_4, &v8, &v9);
	struct std_list_List_1 v10 = mw_std_list_List_1_cons(MK_mirth_label_Label(in_Label_4), in_List_3);
	*out_List_7 = v10;
	*out_zaAB_6 = v9;
	*out_zaMirth_5 = v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movl %edx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x38(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x110d30
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x280c19(%rip), %rax    # 0x392358
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rcx
callq 0x12740
movl %eax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq 0x18(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%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_elab_zaAB_elabzenozeargszx
static void mw_mirth_elab_zaAB_elabzenozeargszx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_arrow_Arrow* in_zaAB_2, struct mirth_mirth_zaMirth* *out_zaMirth_3, struct mirth_arrow_Arrow* *out_zaAB_4) {
	struct mirth_arrow_Arrow* v5;
	uint64_t v6 = mw_mirth_elab_zaAB_abzetokenzo(in_zaAB_2, &v5);
	struct mirth_mirth_zaMirth* v7;
	mw_mirth_token_Token_argsze0(in_zaMirth_1, v6, &v7);
	*out_zaAB_4 = v5;
	*out_zaMirth_3 = v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xe0b80
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x78300
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
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: mtw_mirth_arrow_Op_Var
static struct mirth_arrow_Op mtw_mirth_arrow_Op_Var (uint64_t in_Var_1) {
	struct mirth_arrow_Op_Var* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mVar = in_Var_1;
	struct mirth_arrow_Op v4 = { .tag=mirth_arrow_Op_Var, .ptr.Var=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 0x112b70
movl $0x2, %edi
leaq 0x246c14(%rip), %rsi    # 0x359766
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x112b72
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x9, -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_mirth_elab_zaAB_elabzeatomzefailedzx
static void mw_mirth_elab_zaAB_elabzeatomzefailedzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_arrow_Arrow* in_zaAB_2, struct mirth_mirth_zaMirth* *out_zaMirth_3, struct mirth_arrow_Arrow* *out_zaAB_4) {
	struct mirth_type_StackType v5 = { .tag=mirth_type_StackType_Error };
	struct mirth_arrow_Arrow* v6;
	mw_mirth_elab_zaAB_abzetypezx(in_zaAB_2, v5, &v6);
	*out_zaAB_4 = v6;
	*out_zaMirth_3 = in_zaMirth_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x5080
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
movq -0x28(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x113a00
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_macro_MacroAction_callablezy
static bool mw_mirth_macro_MacroAction_callablezy (struct mirth_macro_MacroAction in_MacroAction_1) {
	struct std_maybe_Maybe_1 v3 = mw_mirth_macro_MacroAction_arrowzy(in_MacroAction_1);
	int64_t v4 = (v3).tag;
	decref(MK_std_maybe_Maybe_1(v3));
	INT v5 = WRAP_I63(0LL);
	INT v6 = v5;
	INT v7 = i64_to_int(v4);
	bool v8 = int_eq(v7, v6);
	bool v9 = !v8;
	return v9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl -0x10(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x1137e0
movl %eax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x20(%rbp), %eax
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x133a0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x30(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x11376d
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x133a0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x48(%rbp), %rax
cmpq $0x0, %rax
je 0x11376d
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x133a0
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x58(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x11376d
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x133a0
movq %rax, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq -0x68(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x11376b
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x133a0
movq %rax, -0x78(%rbp)
movq %rdx, -0x70(%rbp)
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x127c0
jmp 0x11376d
jmp 0x11376f
movq 0x25b2da(%rip), %rax    # 0x36ea50
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1a290
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x194b0
andb $0x1, %al
movb %al, -0x91(%rbp)
movb -0x91(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x92(%rbp)
movb -0x92(%rbp), %al
andb $0x1, %al
addq $0xa0, %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_macro_MacroAction_arrowzy
static struct std_maybe_Maybe_1 mw_mirth_macro_MacroAction_arrowzy (struct mirth_macro_MacroAction in_MacroAction_1) {
	struct std_maybe_Maybe_1 branch_Maybe_3;
	switch ((in_MacroAction_1).tag) {
		case mirth_macro_MacroAction_Arrow: {
			VAL v4 = mtp_mirth_macro_MacroAction_Arrow(in_MacroAction_1);
			struct std_maybe_Maybe_1 v5 = mtw_std_maybe_Maybe_1_Some(v4);
			branch_Maybe_3 = v5;
		} break;
		default: {
			decref(MK_mirth_macro_MacroAction(in_MacroAction_1));
			struct std_maybe_Maybe_1 v6 = { .tag=std_maybe_Maybe_1_None };
			branch_Maybe_3 = v6;
		} break;
	}
	return branch_Maybe_3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl -0x20(%rbp), %eax
subl $0x2, %eax
jne 0x113839
jmp 0x1137fc
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x113950
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xca10
movl %eax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x113933
jmp 0x11383b
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x77280
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x48(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x113908
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x77280
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x60(%rbp), %rax
cmpq $0x0, %rax
je 0x113908
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x77280
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x70(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x113908
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x77280
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq -0x80(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x113906
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x77280
movq %rax, -0x90(%rbp)
movq %rdx, -0x88(%rbp)
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x127c0
jmp 0x113908
jmp 0x11390a
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x5080
movq -0xa0(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0xa0, %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_macro_MacroAction_Arrow
static VAL mtp_mirth_macro_MacroAction_Arrow (struct mirth_macro_MacroAction in_MacroAction_1) {
	struct mirth_macro_MacroAction_Arrow v3 = *in_MacroAction_1.ptr.Arrow;
	if (!--(in_MacroAction_1.ptr.Arrow->refs)) {
		free(in_MacroAction_1.ptr.Arrow);
	} 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 0x113995
movq -0x18(%rbp), %rdi
callq 0x5030
jmp 0x1139e0
jmp 0x113997
movq -0x28(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1139dc
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x30(%rbp), %rax
cmpq $0x0, %rax
je 0x1139dc
movq -0x30(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x1139dc
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x30(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x1139de
jmp 0x1139e0
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: mw_mirth_elab_zaAB_abzetypezx
static void mw_mirth_elab_zaAB_abzetypezx (struct mirth_arrow_Arrow* in_zaAB_1, struct mirth_type_StackType in_StackType_2, struct mirth_arrow_Arrow* *out_zaAB_3) {
	incref(MK_mirth_arrow_Arrow(in_zaAB_1));
	struct mirth_arrow_Arrow* v4 = mirth_arrow_Arrow_set_cod(in_zaAB_1, in_StackType_2);
	decref(MK_mirth_arrow_Arrow(in_zaAB_1));
	*out_zaAB_3 = v4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %esi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x27ea07(%rip), %rax    # 0x392430
orq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x113abb
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x27e9e2(%rip), %rax    # 0x392430
orq $0x1, %rax
movq %rax, -0x38(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x40(%rbp), %rax
cmpq $0x0, %rax
je 0x113abb
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x27e9b7(%rip), %rax    # 0x392430
orq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x113abb
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x27e992(%rip), %rax    # 0x392430
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 0x113abd
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rdx
callq 0x113be0
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq 0x27e950(%rip), %rax    # 0x392430
orq $0x1, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x113bc9
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq 0x27e924(%rip), %rax    # 0x392430
orq $0x1, %rax
movq %rax, -0x80(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x88(%rbp), %rax
cmpq $0x0, %rax
je 0x113bc9
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq 0x27e8ef(%rip), %rax    # 0x392430
orq $0x1, %rax
movq %rax, -0x90(%rbp)
movq -0x98(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x113bc9
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq 0x27e8c1(%rip), %rax    # 0x392430
orq $0x1, %rax
movq %rax, -0xa0(%rbp)
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq -0xa8(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x113bc7
movq -0x18(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq 0x27e887(%rip), %rax    # 0x392430
orq $0x1, %rax
movq %rax, -0xb0(%rbp)
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x127c0
jmp 0x113bc9
jmp 0x113bcb
movq -0x68(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_alias_Alias_target
static struct mirth_def_Def mw_mirth_alias_Alias_target (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Alias_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = field_mut(&mfld_mirth_alias_Alias_zttarget, in_Alias_2);
	struct mirth_mirth_zaMirth* v6;
	VAL v7 = mw_mirth_mirth_Prop_1_forcezx(in_zaMirth_1, v5, &v6);
	*out_zaMirth_3 = v6;
	return V_mirth_def_Def(v7);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x20(%rbp), %rsi
leaq 0x1281469(%rip), %rdi   # 0x1395558
callq 0x40d30
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x5d130
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x452c0
movl %eax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_elab_zaAB_abzewordzx
static void mw_mirth_elab_zaAB_abzewordzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_arrow_Arrow* in_zaAB_2, struct std_list_List_1 in_List_3, uint64_t in_Word_4, struct mirth_mirth_zaMirth* *out_zaMirth_5, struct mirth_arrow_Arrow* *out_zaAB_6) {
	struct mirth_arrow_Op v7 = mtw_mirth_arrow_Op_Word(in_Word_4);
	struct mirth_mirth_zaMirth* v8;
	struct mirth_arrow_Arrow* v9;
	mw_mirth_elab_zaAB_abzeopzx(in_zaMirth_1, in_zaAB_2, in_List_3, v7, &v8, &v9);
	*out_zaAB_6 = v9;
	*out_zaMirth_5 = v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movl %edx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x11dc50
movl %eax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rcx
movl -0x40(%rbp), %r8d
movq -0x38(%rbp), %r9
leaq -0x48(%rbp), %r10
leaq -0x50(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xe1ee0
movq -0x50(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%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_elab_zaAB_elabzeprimzx
static void mw_mirth_elab_zaAB_elabzeprimzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_arrow_Arrow* in_zaAB_2, enum mirth_prim_Prim in_Prim_3, struct mirth_mirth_zaMirth* *out_zaMirth_4, struct mirth_arrow_Arrow* *out_zaAB_5) {
	struct mirth_mirth_zaMirth* v6;
	struct mirth_arrow_Arrow* v7;
	struct std_list_List_1 v8 = mw_mirth_elab_zaAB_elabzeargszx(in_zaMirth_1, in_zaAB_2, &v6, &v7);
	struct mirth_mirth_zaMirth* v9;
	struct mirth_arrow_Arrow* v10;
	mw_mirth_elab_zaAB_abzeprimzx(v6, v7, v8, in_Prim_3, &v9, &v10);
	*out_zaAB_5 = v10;
	*out_zaMirth_4 = v9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x114f60
movl %eax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x14(%rbp), %r8d
movl -0x48(%rbp), %edx
movq -0x40(%rbp), %rcx
leaq -0x50(%rbp), %r9
leaq -0x58(%rbp), %rax
movq %rax, (%rsp)
callq 0x10f930
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%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: mtw_mirth_arrow_Op_Buffer
static struct mirth_arrow_Op mtw_mirth_arrow_Op_Buffer (uint64_t in_Buffer_1) {
	struct mirth_arrow_Op_Buffer* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mBuffer = in_Buffer_1;
	struct mirth_arrow_Op v4 = { .tag=mirth_arrow_Op_Buffer, .ptr.Buffer=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 0x115cb0
movl $0x2, %edi
leaq 0x243b3f(%rip), %rsi    # 0x3597d1
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x115cb2
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x3, -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_arrow_Op_External
static struct mirth_arrow_Op mtw_mirth_arrow_Op_External (uint64_t in_External_1) {
	struct mirth_arrow_Op_External* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mExternal = in_External_1;
	struct mirth_arrow_Op v4 = { .tag=mirth_arrow_Op_External, .ptr.External=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 0x115d40
movl $0x2, %edi
leaq 0x243ae1(%rip), %rsi    # 0x359803
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x115d42
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x2, -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_arrow_Op_Field
static struct mirth_arrow_Op mtw_mirth_arrow_Op_Field (uint64_t in_Field_1) {
	struct mirth_arrow_Op_Field* v3 = calloc(1, sizeof *v3);
	ASSERT(v3);
	v3->refs = 1;
	v3->mField = in_Field_1;
	struct mirth_arrow_Op v4 = { .tag=mirth_arrow_Op_Field, .ptr.Field=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 0x115dd0
movl $0x2, %edi
leaq 0x243a83(%rip), %rsi    # 0x359835
movl $0x31, %edx
callq 0x5060
callq 0x5310
callq 0x53b0
movl $0x1, %edi
callq 0x5130
jmp 0x115dd2
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x4, -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_list_List_1_tail
static struct std_list_List_1 mw_std_list_List_1_tail (struct std_list_List_1 in_List_1) {
	struct std_list_List_1 branch_List_3;
	switch ((in_List_1).tag) {
		case std_list_List_1_Nil: {
			struct std_list_List_1 v4 = { .tag=std_list_List_1_Nil };
			branch_List_3 = v4;
		} break;
		case std_list_List_1_Cons: {
			struct std_list_List_1 v5;
			VAL v6 = mtp_std_list_List_1_Cons(in_List_1, &v5);
			decref(v6);
			branch_List_3 = v5;
		} break;
		default: {
			do_panic(str_make("unexpected fallthrough in match\n", 32));
		}
	}
	return branch_List_3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x54(%rbp)
testl %eax, %eax
je 0x11c828
jmp 0x11c81b
movl -0x54(%rbp), %eax
subl $0x1, %eax
je 0x11c84d
jmp 0x11c8d2
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x5080
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11c8eb
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x125e0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x48(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x11c8be
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x50(%rbp), %rax
cmpq $0x0, %rax
je 0x11c8be
movq -0x50(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x11c8be
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq -0x50(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x11c8bc
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x127c0
jmp 0x11c8be
jmp 0x11c8c0
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11c8eb
leaq 0x2375a8(%rip), %rdi    # 0x353e81
movl $0x20, %esi
callq 0xb6c0
movq %rax, %rdi
callq 0xc620
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_token_Token_tozerunzeend
static uint64_t mw_mirth_token_Token_tozerunzeend (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_Token_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_mirth_zaMirth* v5;
	bool v6 = mw_mirth_token_Token_runzeendzy(in_zaMirth_1, in_Token_2, &v5);
	bool v7 = !v6;
	uint64_t v8 = in_Token_2;
	struct mirth_mirth_zaMirth* r9 = v5;
	bool v10 = v7;
	while (v10) {
		uint64_t v11 = v8;
		struct mirth_mirth_zaMirth* r12 = r9;
		struct mirth_mirth_zaMirth* v13;
		uint64_t v14 = mw_mirth_token_Token_next(r12, v11, &v13);
		struct mirth_mirth_zaMirth* v15;
		bool v16 = mw_mirth_token_Token_runzeendzy(v13, v14, &v15);
		bool v17 = !v16;
		v10 = v17;
		r9 = v15;
		v8 = v14;
	}
	*out_zaMirth_3 = r9;
	return v8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %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 0xacc30
andb $0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x22(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movb -0x22(%rbp), %al
andb $0x1, %al
movb %al, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
je 0x11c9b1
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x7b380
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0xacc30
andb $0x1, %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x6a(%rbp)
movb -0x6a(%rbp), %al
andb $0x1, %al
movb %al, -0x39(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x11c94c
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%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: mw_mirth_token_Token_alloczenonezx
static uint64_t mw_mirth_token_Token_alloczenonezx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_mirth_zaMirth* *out_zaMirth_2) {
	struct std_maybe_Maybe_1 v4 = { .tag=std_maybe_Maybe_1_None };
	INT v5 = WRAP_I63(0LL);
	INT v6 = WRAP_I63(0LL);
	uint64_t v7 = mw_mirth_module_Module_Nil();
	struct mirth_token_TokenValue v8 = { .tag=mirth_token_TokenValue_None };
	struct mirth_mirth_zaMirth* v9;
	uint64_t v10 = mw_mirth_token_Token_Makezx(in_zaMirth_1, v8, v7, v5, v6, v4, &v9);
	*out_zaMirth_2 = v9;
	return v10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x5080
movq 0x252059(%rip), %rax    # 0x36ea50
movq %rax, -0x28(%rbp)
movq 0x25204e(%rip), %rax    # 0x36ea50
movq %rax, -0x30(%rbp)
callq 0x11d070
movq %rax, -0x38(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x5080
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rcx
movl -0x48(%rbp), %esi
movq -0x40(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x20(%rbp), %r10
leaq -0x50(%rbp), %rax
movq (%r10), %r11
movq %r11, (%rsp)
movq 0x8(%r10), %r10
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x11d090
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%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: mw_mirth_token_Token_locationzx
static void mw_mirth_token_Token_locationzx (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_location_Location* in_Location_2, uint64_t in_Token_3, struct mirth_mirth_zaMirth* *out_zaMirth_4) {
	uint64_t v5;
	INT v6;
	INT v7;
	mtp_mirth_location_Location_Location(in_Location_2, &v5, &v6, &v7);
	struct mirth_mirth_zaMirth* v8;
	mw_mirth_token_Token_modulezx(in_zaMirth_1, v5, in_Token_3, &v8);
	struct mirth_mirth_zaMirth* v9;
	mw_mirth_token_Token_rowzx(v8, v6, in_Token_3, &v9);
	struct mirth_mirth_zaMirth* v10;
	mw_mirth_token_Token_colzx(v9, v7, in_Token_3, &v10);
	*out_zaMirth_4 = v10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x61670
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x11d2b0
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %rcx
callq 0x11d320
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rcx
callq 0x11d390
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_token_Token_fromzeindex
static uint64_t mw_mirth_token_Token_fromzeindex (struct mirth_mirth_zaMirth* in_zaMirth_1, uint64_t in_U64_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	void* v5 = mbuf_mirth_token_Token_NumBuffer;
	uint64_t v6 = *(uint64_t*)v5;
	bool v7 = (in_U64_2 <= v6);
	struct mirth_mirth_zaMirth* branch_zaMirth_8;
	uint64_t branch_U64_9;
	if (v7) {
		branch_U64_9 = in_U64_2;
		branch_zaMirth_8 = in_zaMirth_1;
	} else {
		uint64_t v10 = 0ULL;
		branch_U64_9 = v10;
		branch_zaMirth_8 = in_zaMirth_1;
	}
	uint64_t v11 = branch_U64_9;
	*out_zaMirth_3 = branch_zaMirth_8;
	return v11;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x1278a21(%rip), %rax   # 0x1395538
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x28(%rbp), %rax
setbe %al
andb $0x1, %al
movb %al, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
je 0x11cb4e
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x11cb66
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rax
popq %rbp
retq
nop