LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_new_ref
void subtilis_type_if_new_ref(subtilis_parser_t *p, const subtilis_type_t *type,
			      size_t mem_reg, size_t loc, subtilis_exp_t *e,
			      subtilis_error_t *err)
{
	subtilis_type_if_initref_t fn;

	fn = prv_type_map[type->type]->new_ref;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, type, mem_reg, loc, e, err);
}

// 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 %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8d111(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x38(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x4776e
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x64bdb(%rip), %rdx     # 0xac33d
movl $0xf7, %ecx
callq 0x158e0
jmp 0x4778c
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq *%rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_assign_ref
void subtilis_type_if_assign_ref(subtilis_parser_t *p,
				 const subtilis_type_t *type, size_t mem_reg,
				 size_t loc, subtilis_exp_t *e,
				 subtilis_error_t *err)
{
	subtilis_type_if_initref_t fn;

	fn = prv_type_map[type->type]->assign_ref;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, type, mem_reg, loc, e, err);
}

// 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 %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8d081(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x477fe
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x64b4b(%rip), %rdx     # 0xac33d
movl $0x106, %ecx            # imm = 0x106
callq 0x158e0
jmp 0x4781c
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq *%rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_assign_ref_no_rc
void subtilis_type_if_assign_ref_no_rc(subtilis_parser_t *p,
				       const subtilis_type_t *type,
				       size_t mem_reg, size_t loc,
				       subtilis_exp_t *e, subtilis_error_t *err)
{
	subtilis_type_if_initref_t fn;

	fn = prv_type_map[type->type]->assign_ref_no_rc;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, type, mem_reg, loc, e, err);
}

// 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 %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8cff1(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x48(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x4788e
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x64abb(%rip), %rdx     # 0xac33d
movl $0x115, %ecx            # imm = 0x115
callq 0x158e0
jmp 0x478ac
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq *%rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_top_bit
subtilis_exp_t *subtilis_type_if_top_bit(subtilis_parser_t *p,
					 const subtilis_type_t *type,
					 subtilis_error_t *err)
{
	subtilis_type_if_none_t fn;

	fn = prv_type_map[type->type]->top_bit;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}
	return fn(p, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8cf6d(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4791a
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x64a37(%rip), %rdx     # 0xac33d
movl $0x123, %ecx            # imm = 0x123
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x4792c
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_zero_reg
void subtilis_type_if_zero_reg(subtilis_parser_t *p,
			       const subtilis_type_t *type, size_t reg,
			       subtilis_error_t *err)
{
	subtilis_type_if_zeroreg_t fn;

	fn = prv_type_map[type->type]->zero_reg;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, type, reg, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8cee9(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x47996
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x649b3(%rip), %rdx     # 0xac33d
movl $0x131, %ecx            # imm = 0x131
callq 0x158e0
jmp 0x479ac
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_array_of
void subtilis_type_if_array_of(const subtilis_type_t *element_type,
			       subtilis_type_t *type, subtilis_error_t *err)
{
	subtilis_type_if_typeof_t fn;

	if (element_type == type) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[element_type->type]->array_of;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(element_type, type, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x479fa
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x6494f(%rip), %rdx     # 0xac33d
movl $0x13d, %ecx            # imm = 0x13D
callq 0x158e0
jmp 0x47a4a
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8ce47(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x70(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x47a38
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x64911(%rip), %rdx     # 0xac33d
movl $0x143, %ecx            # imm = 0x143
callq 0x158e0
jmp 0x47a4a
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_vector_of
void subtilis_type_if_vector_of(const subtilis_type_t *element_type,
				subtilis_type_t *type, subtilis_error_t *err)
{
	subtilis_type_if_typeof_t fn;

	if (element_type == type) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[element_type->type]->vector_of;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(element_type, type, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x47a8a
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x648bf(%rip), %rdx     # 0xac33d
movl $0x14f, %ecx            # imm = 0x14F
callq 0x158e0
jmp 0x47ada
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8cdb7(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x47ac8
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x64881(%rip), %rdx     # 0xac33d
movl $0x155, %ecx            # imm = 0x155
callq 0x158e0
jmp 0x47ada
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_const_of
void subtilis_type_if_const_of(const subtilis_type_t *type,
			       subtilis_type_t *const_type,
			       subtilis_error_t *err)
{
	subtilis_type_if_typeof_t fn;

	if (const_type == type) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[type->type]->const_of;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(type, const_type, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x47b1a
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x6482f(%rip), %rdx     # 0xac33d
movl $0x162, %ecx            # imm = 0x162
callq 0x158e0
jmp 0x47b6a
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8cd27(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x68(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x47b58
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x647f1(%rip), %rdx     # 0xac33d
movl $0x168, %ecx            # imm = 0x168
callq 0x158e0
jmp 0x47b6a
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_element_type
void subtilis_type_if_element_type(subtilis_parser_t *p,
				   const subtilis_type_t *type,
				   subtilis_type_t *element_type,
				   subtilis_error_t *err)
{
	subtilis_type_if_typeof_t fn;

	if (element_type == type) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[type->type]->element_type;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(type, element_type, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x47bae
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x6479b(%rip), %rdx     # 0xac33d
movl $0x176, %ecx            # imm = 0x176
callq 0x158e0
jmp 0x47c01
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8cc93(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x80(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x47bef
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x6475a(%rip), %rdx     # 0xac33d
movl $0x17c, %ecx            # imm = 0x17C
callq 0x158e0
jmp 0x47c01
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: prv_call_unary_fn
static subtilis_exp_t *prv_call_unary_fn(subtilis_parser_t *p,
					 subtilis_exp_t *e,
					 subtilis_type_if_unary_t fn,
					 subtilis_error_t *err)
{
	if (!fn) {
		subtilis_exp_delete(e);
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	return fn(p, e, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x47cac
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x646a5(%rip), %rdx     # 0xac33d
movl $0x49, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x47cc2
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_dup
subtilis_exp_t *subtilis_type_if_dup(subtilis_exp_t *e, subtilis_error_t *err)
{
	subtilis_type_if_dup_t fn;
	subtilis_exp_t *exp = subtilis_exp_new_empty(&e->type, err);

	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	fn = prv_type_map[e->type.type]->dup;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		goto cleanup;
	}
	fn(e, exp, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	return exp;

cleanup:
	subtilis_exp_delete(exp);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x37500
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x47d54
movq $0x0, -0x8(%rbp)
jmp 0x47dcd
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8caed(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x98(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x47d95
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x645b4(%rip), %rdx     # 0xac33d
movl $0x19b, %ecx            # imm = 0x19B
callq 0x158e0
jmp 0x47dbc
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x47db2
jmp 0x47dbc
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x47dcd
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_memcpy
void subtilis_type_if_memcpy(subtilis_parser_t *p, subtilis_exp_t *e1,
			     subtilis_exp_t *e2, subtilis_error_t *err)
{
	subtilis_type_if_copy_collection_t fn;

	fn = prv_type_map[e1->type.type]->copy_col;
	if (!fn) {
		subtilis_error_set_expected(err, "string or array",
					    subtilis_type_name(&e1->type),
					    p->l->stream->name, p->l->line);
		subtilis_exp_delete(e1);
		subtilis_exp_delete(e2);
		return;
	}
	fn(p, e1, e2, err);
}

// 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), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8ca49(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x47e83
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e190
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x644f9(%rip), %rdx     # 0xac350
leaq 0x644df(%rip), %rax     # 0xac33d
movq %rax, (%rsp)
movl $0x1b2, 0x8(%rsp)       # imm = 0x1B2
callq 0x156d0
movq -0x10(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rdi
callq 0x36ee0
jmp 0x47e99
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq *%rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_assign_to_reg
void subtilis_type_if_assign_to_reg(subtilis_parser_t *p, size_t reg,
				    subtilis_exp_t *e, subtilis_error_t *err)
{
	subtilis_type_if_sizet_exp_t fn;

	fn = prv_type_map[e->type.type]->assign_reg;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, reg, e, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8c989(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x47ef9
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x64450(%rip), %rdx     # 0xac33d
movl $0x1c1, %ecx            # imm = 0x1C1
callq 0x158e0
jmp 0x47f0f
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_assign_to_mem
void subtilis_type_if_assign_to_mem(subtilis_parser_t *p, size_t mem_reg,
				    size_t loc, subtilis_exp_t *e,
				    subtilis_error_t *err)
{
	subtilis_type_if_sizet2_exp_t fn;

	if (loc > 0x7fffffff) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[e->type.type]->assign_mem;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, mem_reg, loc, e, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x7fffffff, -0x18(%rbp) # imm = 0x7FFFFFFF
jbe 0x47f62
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x643e7(%rip), %rdx     # 0xac33d
movl $0x1ce, %ecx            # imm = 0x1CE
callq 0x158e0
jmp 0x47fbd
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8c8df(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x47fa3
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x643a6(%rip), %rdx     # 0xac33d
movl $0x1d4, %ecx            # imm = 0x1D4
callq 0x158e0
jmp 0x47fbd
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_assign_to_new_mem
void subtilis_type_if_assign_to_new_mem(subtilis_parser_t *p, size_t mem_reg,
					size_t loc, subtilis_exp_t *e,
					subtilis_error_t *err)
{
	subtilis_type_if_sizet2_exp_t fn;

	if (loc > 0x7fffffff) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[e->type.type]->assign_new_mem;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, mem_reg, loc, e, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x7fffffff, -0x18(%rbp) # imm = 0x7FFFFFFF
jbe 0x48012
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x64337(%rip), %rdx     # 0xac33d
movl $0x1e1, %ecx            # imm = 0x1E1
callq 0x158e0
jmp 0x4806d
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8c82f(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0xb8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x48053
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x642f6(%rip), %rdx     # 0xac33d
movl $0x1e7, %ecx            # imm = 0x1E7
callq 0x158e0
jmp 0x4806d
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_load_from_mem
subtilis_exp_t *subtilis_type_if_load_from_mem(subtilis_parser_t *p,
					       const subtilis_type_t *type,
					       size_t mem_reg, size_t loc,
					       subtilis_error_t *err)
{
	subtilis_type_if_load_t fn;

	if (loc > 0x7fffffff) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	fn = prv_type_map[type->type]->load_mem;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}
	return fn(p, type, mem_reg, loc, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x7fffffff, -0x28(%rbp) # imm = 0x7FFFFFFF
jbe 0x480ca
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x64287(%rip), %rdx     # 0xac33d
movl $0x1f5, %ecx            # imm = 0x1F5
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x48131
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8c777(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x100(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x48113
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x6423e(%rip), %rdx     # 0xac33d
movl $0x1fb, %ecx            # imm = 0x1FB
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x48131
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_indexed_write
void subtilis_type_if_indexed_write(subtilis_parser_t *p, const char *var_name,
				    const subtilis_type_t *type, size_t mem_reg,
				    size_t loc, subtilis_exp_t *e,
				    subtilis_exp_t **indices,
				    size_t index_count, subtilis_error_t *err)
{
	subtilis_type_if_iwrite_t fn;

	if (loc > 0x7fffffff) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[type->type]->indexed_write;
	if (!fn) {
		subtilis_error_not_array_or_vector(
		    err, var_name, p->l->stream->name, p->l->line);
		return;
	}
	fn(p, var_name, type, mem_reg, loc, e, indices, index_count, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x7fffffff, -0x30(%rbp) # imm = 0x7FFFFFFF
jbe 0x48196
movq 0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x641b6(%rip), %rdx     # 0xac33d
movl $0x20a, %ecx            # imm = 0x20A
callq 0x158e0
jmp 0x48237
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8c6ab(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x481ff
movq 0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x3d, %esi
leaq 0x63091(%rip), %rcx     # 0xab276
leaq 0x64151(%rip), %rax     # 0xac33d
movq %rax, (%rsp)
movl $0x211, 0x8(%rsp)       # imm = 0x211
callq 0x156d0
jmp 0x48237
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rbx
movq 0x18(%rbp), %r11
movq 0x20(%rbp), %r10
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *%rax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_indexed_add
void subtilis_type_if_indexed_add(subtilis_parser_t *p, const char *var_name,
				  const subtilis_type_t *type, size_t mem_reg,
				  size_t loc, subtilis_exp_t *e,
				  subtilis_exp_t **indices, size_t index_count,
				  subtilis_error_t *err)
{
	subtilis_type_if_iwrite_t fn;

	if (loc > 0x7fffffff) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[type->type]->indexed_add;
	if (!fn) {
		subtilis_error_not_array_or_vector(
		    err, var_name, p->l->stream->name, p->l->line);
		return;
	}
	fn(p, var_name, type, mem_reg, loc, e, indices, index_count, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x7fffffff, -0x30(%rbp) # imm = 0x7FFFFFFF
jbe 0x48296
movq 0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x640b6(%rip), %rdx     # 0xac33d
movl $0x220, %ecx            # imm = 0x220
callq 0x158e0
jmp 0x48337
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8c5ab(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x482ff
movq 0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x3d, %esi
leaq 0x62f91(%rip), %rcx     # 0xab276
leaq 0x64051(%rip), %rax     # 0xac33d
movq %rax, (%rsp)
movl $0x227, 0x8(%rsp)       # imm = 0x227
callq 0x156d0
jmp 0x48337
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rbx
movq 0x18(%rbp), %r11
movq 0x20(%rbp), %r10
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *%rax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_indexed_sub
void subtilis_type_if_indexed_sub(subtilis_parser_t *p, const char *var_name,
				  const subtilis_type_t *type, size_t mem_reg,
				  size_t loc, subtilis_exp_t *e,
				  subtilis_exp_t **indices, size_t index_count,
				  subtilis_error_t *err)
{
	subtilis_type_if_iwrite_t fn;

	if (loc > 0x7fffffff) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[type->type]->indexed_sub;
	if (!fn) {
		subtilis_error_not_array_or_vector(
		    err, var_name, p->l->stream->name, p->l->line);
		return;
	}
	fn(p, var_name, type, mem_reg, loc, e, indices, index_count, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x7fffffff, -0x30(%rbp) # imm = 0x7FFFFFFF
jbe 0x48396
movq 0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x63fb6(%rip), %rdx     # 0xac33d
movl $0x236, %ecx            # imm = 0x236
callq 0x158e0
jmp 0x48437
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8c4ab(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x483ff
movq 0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x3d, %esi
leaq 0x62e91(%rip), %rcx     # 0xab276
leaq 0x63f51(%rip), %rax     # 0xac33d
movq %rax, (%rsp)
movl $0x23d, 0x8(%rsp)       # imm = 0x23D
callq 0x156d0
jmp 0x48437
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rbx
movq 0x18(%rbp), %r11
movq 0x20(%rbp), %r10
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *%rax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_indexed_read
subtilis_exp_t *
subtilis_type_if_indexed_read(subtilis_parser_t *p, const char *var_name,
			      const subtilis_type_t *type, size_t mem_reg,
			      size_t loc, subtilis_exp_t **indices,
			      size_t index_count, subtilis_error_t *err)
{
	subtilis_type_if_iread_t fn;

	if (loc > 0x7fffffff) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	fn = prv_type_map[type->type]->indexed_read;
	if (!fn) {
		subtilis_error_not_array_or_vector(
		    err, var_name, p->l->stream->name, p->l->line);
		return NULL;
	}
	return fn(p, var_name, type, mem_reg, loc, indices, index_count, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x7fffffff, -0x30(%rbp) # imm = 0x7FFFFFFF
jbe 0x48499
movq 0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x63ebb(%rip), %rdx     # 0xac33d
movl $0x24c, %ecx            # imm = 0x24C
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x4853d
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8c3a8(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x4850a
movq 0x18(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x3d, %esi
leaq 0x62d8e(%rip), %rcx     # 0xab276
leaq 0x63e4e(%rip), %rax     # 0xac33d
movq %rax, (%rsp)
movl $0x253, 0x8(%rsp)       # imm = 0x253
callq 0x156d0
movq $0x0, -0x8(%rbp)
jmp 0x4853d
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %r11
movq 0x18(%rbp), %r10
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_array_set
void subtilis_type_if_array_set(subtilis_parser_t *p, const char *var_name,
				const subtilis_type_t *type, size_t mem_reg,
				size_t loc, subtilis_exp_t *e,
				subtilis_error_t *err)
{
	subtilis_type_if_set_t fn;

	if (loc > 0x7fffffff) {
		subtilis_error_set_assertion_failed(err);
		goto cleanup;
	}

	fn = prv_type_map[type->type]->set;
	if (!fn) {
		subtilis_error_not_array_or_vector(
		    err, var_name, p->l->stream->name, p->l->line);
		goto cleanup;
	}

	fn(p, var_name, type, mem_reg, loc, e, err);
	return;

cleanup:
	subtilis_exp_delete(e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
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)
cmpq $0x7fffffff, -0x28(%rbp) # imm = 0x7FFFFFFF
jbe 0x4859d
movq 0x10(%rbp), %rdi
movl $0xf, %esi
leaq 0x63daf(%rip), %rdx     # 0xac33d
movl $0x261, %ecx            # imm = 0x261
callq 0x158e0
jmp 0x4862e
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8c2a4(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0xe0(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x48606
movq 0x10(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x3d, %esi
leaq 0x62c8a(%rip), %rcx     # 0xab276
leaq 0x63d4a(%rip), %rax     # 0xac33d
movq %rax, (%rsp)
movl $0x268, 0x8(%rsp)       # imm = 0x268
callq 0x156d0
jmp 0x4862e
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
jmp 0x48637
movq -0x30(%rbp), %rdi
callq 0x36ee0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_zero_buf
void subtilis_type_if_zero_buf(subtilis_parser_t *p,
			       const subtilis_type_t *type, size_t data_reg,
			       size_t size_reg, subtilis_error_t *err)
{
	subtilis_type_if_reg2_t fn;

	fn = prv_type_map[type->type]->zero_buf;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn(p, type, data_reg, size_reg, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8c1e5(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4869d
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x63cac(%rip), %rdx     # 0xac33d
movl $0x27b, %ecx            # imm = 0x27B
callq 0x158e0
jmp 0x486b7
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_append
void subtilis_type_if_append(subtilis_parser_t *p, subtilis_exp_t *a1,
			     subtilis_exp_t *a2, subtilis_exp_t *gran,
			     subtilis_error_t *err)
{
	subtilis_type_if_append_t fn;

	fn = prv_type_map[a1->type.type]->append;
	if (!fn) {
		subtilis_error_set_expected(err, "string or 1d array",
					    subtilis_type_name(&a1->type),
					    p->l->stream->name, p->l->line);
		goto cleanup;
	}

	fn(p, a1, a2, gran, err);
	return;

cleanup:
	subtilis_exp_delete(gran);
	subtilis_exp_delete(a2);
	subtilis_exp_delete(a1);
}

// 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 %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8c055(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x48865
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e190
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x63b15(%rip), %rdx     # 0xac360
leaq 0x63aeb(%rip), %rax     # 0xac33d
movq %rax, (%rsp)
movl $0x2a2, 0x8(%rsp)       # imm = 0x2A2
callq 0x156d0
jmp 0x48881
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq *%rax
jmp 0x4889c
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x10(%rbp), %rdi
callq 0x36ee0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_to_int
subtilis_exp_t *subtilis_type_if_to_int(subtilis_parser_t *p, subtilis_exp_t *e,
					subtilis_error_t *err)
{
	if (!prv_type_map[e->type.type]->to_int32) {
		subtilis_error_set_integer_expected(
		    err, subtilis_type_name(&e->type), p->l->stream->name,
		    p->l->line);
		subtilis_exp_delete(e);
		return NULL;
	}
	return prv_call_unary_fn(p, e, prv_type_map[e->type.type]->to_int32,
				 err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8bf7d(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x108(%rax)
jne 0x48946
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e190
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x17, %esi
leaq 0x6295b(%rip), %rcx     # 0xab276
leaq 0x63a1b(%rip), %rax     # 0xac33d
movq %rax, (%rsp)
movl $0x2b5, 0x8(%rsp)       # imm = 0x2B5
callq 0x156d0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x48975
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8bef3(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x108(%rax), %rdx
movq -0x20(%rbp), %rcx
callq 0x47c60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_to_byte
subtilis_exp_t *subtilis_type_if_to_byte(subtilis_parser_t *p,
					 subtilis_exp_t *e,
					 subtilis_error_t *err)
{
	if (subtilis_type_if_is_const(&e->type)) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	if (!prv_type_map[e->type.type]->to_byte) {
		subtilis_error_set_byte_expected(
		    err, subtilis_type_name(&e->type), p->l->stream->name,
		    p->l->line);
		subtilis_exp_delete(e);
		return NULL;
	}

	return prv_call_unary_fn(p, e, prv_type_map[e->type.type]->to_byte,
				 err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x48a90
testb $0x1, %al
jne 0x489a3
jmp 0x489ca
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x6398a(%rip), %rdx     # 0xac33d
movl $0x2c2, %ecx            # imm = 0x2C2
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x48a7b
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8be77(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x118(%rax)
jne 0x48a4c
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e190
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x18, %esi
leaq 0x62855(%rip), %rcx     # 0xab276
leaq 0x63915(%rip), %rax     # 0xac33d
movq %rax, (%rsp)
movl $0x2c9, 0x8(%rsp)       # imm = 0x2C9
callq 0x156d0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x48a7b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8bded(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x118(%rax), %rdx
movq -0x20(%rbp), %rcx
callq 0x47c60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_zerox
subtilis_exp_t *subtilis_type_if_zerox(subtilis_parser_t *p, subtilis_exp_t *e,
				       const subtilis_type_t *type,
				       subtilis_error_t *err)
{
	if (!prv_type_map[e->type.type]->zerox) {
		subtilis_error_set_bad_zero_extend(
		    err, subtilis_type_name(&e->type), subtilis_type_name(type),
		    p->l->stream->name, p->l->line);
		subtilis_exp_delete(e);
		return NULL;
	}

	return prv_type_map[e->type.type]->zerox(p, e, type, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8bcf9(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x110(%rax)
jne 0x48bd4
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e190
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3e190
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x46, %esi
leaq 0x6378d(%rip), %rax     # 0xac33d
movq %rax, (%rsp)
movl $0x2e1, 0x8(%rsp)       # imm = 0x2E1
callq 0x156d0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x48c04
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8bc6d(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x110(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_to_string
subtilis_exp_t *subtilis_type_if_to_string(subtilis_parser_t *p,
					   subtilis_exp_t *e,
					   subtilis_error_t *err)
{
	if (!prv_type_map[e->type.type]->to_string) {
		subtilis_error_set_bad_conversion(
		    err, subtilis_type_name(&e->type),
		    subtilis_type_name(&subtilis_type_string),
		    p->l->stream->name, p->l->line);
		subtilis_exp_delete(e);
		return NULL;
	}
	return prv_call_unary_fn(p, e, prv_type_map[e->type.type]->to_string,
				 err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8bc1d(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x128(%rax)
jne 0x48cb3
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e190
movq %rax, -0x28(%rbp)
leaq 0x62f03(%rip), %rdi     # 0xabb60
callq 0x3e190
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x45, %esi
leaq 0x636ae(%rip), %rax     # 0xac33d
movq %rax, (%rsp)
movl $0x2f1, 0x8(%rsp)       # imm = 0x2F1
callq 0x156d0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x48ce2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8bb86(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x128(%rax), %rdx
movq -0x20(%rbp), %rcx
callq 0x47c60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_to_hex_string
subtilis_exp_t *subtilis_type_if_to_hex_string(subtilis_parser_t *p,
					       subtilis_exp_t *e,
					       subtilis_error_t *err)
{
	if (!prv_type_map[e->type.type]->to_hex_string) {
		subtilis_error_set_bad_conversion(
		    err, subtilis_type_name(&e->type),
		    subtilis_type_name(&subtilis_type_string),
		    p->l->stream->name, p->l->line);
		subtilis_exp_delete(e);
		return NULL;
	}
	return prv_call_unary_fn(
	    p, e, prv_type_map[e->type.type]->to_hex_string, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8bb3d(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x130(%rax)
jne 0x48d93
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e190
movq %rax, -0x28(%rbp)
leaq 0x62e23(%rip), %rdi     # 0xabb60
callq 0x3e190
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x45, %esi
leaq 0x635ce(%rip), %rax     # 0xac33d
movq %rax, (%rsp)
movl $0x301, 0x8(%rsp)       # imm = 0x301
callq 0x156d0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x48dc2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8baa6(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x130(%rax), %rdx
movq -0x20(%rbp), %rcx
callq 0x47c60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: prv_order_expressions
static bool prv_order_expressions(subtilis_exp_t **a1, subtilis_exp_t **a2)
{
	subtilis_exp_t *e1;
	subtilis_exp_t *e2;
	bool swap;

	e1 = *a1;
	e2 = *a2;

	swap = !prv_type_map[e2->type.type]->is_const &&
	       prv_type_map[e1->type.type]->is_const;
	if (swap) {
		*a1 = e2;
		*a2 = e1;
	}

	return swap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8b98f(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rcx
xorl %eax, %eax
testb $0x1, (%rcx)
movb %al, -0x22(%rbp)
jne 0x48ee7
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8b972(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movb (%rax), %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
je 0x48f0b
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb -0x21(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: prv_call_binary_nc_fn
static subtilis_exp_t *
prv_call_binary_nc_fn(subtilis_parser_t *p, subtilis_exp_t *a1,
		      subtilis_exp_t *a2, subtilis_type_if_binary_nc_t fn,
		      bool swapped, subtilis_error_t *err)
{
	if (!fn) {
		subtilis_exp_delete(a1);
		subtilis_exp_delete(a2);
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	return fn(p, a1, a2, swapped, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x48f81
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x38(%rbp), %rdi
movl $0xf, %esi
leaq 0x633d0(%rip), %rdx     # 0xac33d
movl $0x78, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x48fa4
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb -0x29(%rbp), %cl
movq -0x38(%rbp), %r8
andb $0x1, %cl
movzbl %cl, %ecx
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: prv_call_binary_fn
static subtilis_exp_t *
prv_call_binary_fn(subtilis_parser_t *p, subtilis_exp_t *a1, subtilis_exp_t *a2,
		   subtilis_type_if_binary_t fn, subtilis_error_t *err)
{
	if (!fn) {
		subtilis_exp_delete(a1);
		subtilis_exp_delete(a2);
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}
	return fn(p, a1, a2, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x49069
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x632e8(%rip), %rdx     # 0xac33d
movl $0x6a, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x49083
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_div
subtilis_exp_t *subtilis_type_if_div(subtilis_parser_t *p, subtilis_exp_t *a1,
				     subtilis_exp_t *a2, subtilis_error_t *err)
{
	a1 = subtilis_type_if_to_int(p, a1, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(a2);
		return NULL;
	}

	a2 = subtilis_type_if_to_int(p, a2, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(a1);
		return NULL;
	}

	return prv_call_binary_fn(p, a1, a2, prv_type_map[a1->type.type]->div,
				  err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x49379
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x493dd
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x493aa
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x493dd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8b48b(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x190(%rax), %rcx
movq -0x28(%rbp), %r8
callq 0x49010
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)