LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: subtilis_parser_endproc
void subtilis_parser_endproc(subtilis_parser_t *p, subtilis_token_t *t,
			     subtilis_error_t *err)
{
	subtilis_ir_operand_t end_label;

	if (p->current == p->main) {
		subtilis_error_set_proc_in_main(err, p->l->stream->name,
						p->l->line);
		return;
	}

	if (p->current->type->type.params.fn.ret_val->type !=
	    SUBTILIS_TYPE_VOID) {
		subtilis_error_set_proc_in_fn(err, p->l->stream->name,
					      p->l->line);
		return;
	}

	p->current->endproc = true;
	end_label.label = p->current->end_label;
	subtilis_ir_section_add_instr_no_reg(p->current, SUBTILIS_OP_INSTR_JMP,
					     end_label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_lexer_get(p->l, t, 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
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jne 0x20d5b
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x2d, %esi
leaq 0x898e5(%rip), %r8      # 0xaa630
movl $0x6eb, %r9d            # imm = 0x6EB
callq 0x15930
jmp 0x20dfd
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x8, (%rax)
je 0x20da2
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x34, %esi
leaq 0x8989b(%rip), %r8      # 0xaa630
movl $0x6f2, %r9d            # imm = 0x6F2
callq 0x15930
jmp 0x20dfd
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movb $0x1, 0x88(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x98(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
movl $0x45, %esi
callq 0x38540
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x20de9
jmp 0x20dfd
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x133f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: subtilis_parser_check_calls
void subtilis_parser_check_calls(subtilis_parser_t *p, subtilis_error_t *err)
{
	size_t i;

	for (i = 0; i < p->num_calls; i++) {
		prv_check_call(p, p->calls[i], err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

	for (i = 0; i < p->num_call_addrs; i++) {
		prv_check_call_addr(p, p->call_addrs[i], err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x80(%rcx), %rax
jae 0x20e74
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rdx
callq 0x20ed0
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x20e64
jmp 0x20ec8
jmp 0x20e66
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x20e28
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x98(%rcx), %rax
jae 0x20ec8
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rdx
callq 0x215a0
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x20eb8
jmp 0x20ec8
jmp 0x20eba
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x20e7c
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: subtilis_parser_call_add_addr
void subtilis_parser_call_add_addr(subtilis_parser_t *p,
				   const subtilis_type_t *type,
				   subtilis_exp_t *e, subtilis_error_t *err)
{
	subtilis_parser_call_addr_t *call_addr = NULL;

	/*
	 * We're taking the address of a function we may not have seen
	 * yet.
	 */

	subtilis_type_copy(&e->type, type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	call_addr = subtilis_parser_call_addr_new(
	    p->current, e->call_site, p->current->in_error_handler,
	    e->partial_name, &e->type, p->l->line, err);
	e->partial_name = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_exp_add_call_addrs(p, call_addr, err);
	if (err->type != SUBTILIS_ERROR_OK)
		subtilis_parser_call_addr_delete(call_addr);
}

// 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 $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3e4f0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2194f
jmp 0x219dd
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x168(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movb 0x60(%rax), %dl
movq -0x18(%rbp), %rax
movq 0x160(%rax), %rcx
movq -0x18(%rbp), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %eax
movl %eax, %r9d
movq -0x20(%rbp), %rax
andb $0x1, %dl
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x47020
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x160(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x219ba
jmp 0x219dd
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x36b50
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x219dd
movq -0x28(%rbp), %rdi
callq 0x47110
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_parser_assembly
static void prv_parser_assembly(subtilis_parser_t *p, subtilis_token_t *t,
				const char *name,
				subtilis_type_section_t *stype,
				size_t *call_index, subtilis_error_t *err)
{
	subtilis_error_t err2;
	void *asm_code = NULL;

	subtilis_lexer_set_ass_keywords(p->l, true, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	asm_code = p->backend.asm_parse(p->l, t, p->backend.backend_data, stype,
					&p->settings, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	subtilis_ir_prog_asm_section_new(
	    p->prog, name, stype, p->l->stream->name, p->l->line,
	    p->eflag_offset, p->error_offset, p->backend.asm_free, asm_code,
	    call_index, err);
	stype = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	subtilis_error_init(&err2);
	subtilis_lexer_set_ass_keywords(p->l, false, &err2);

	subtilis_lexer_get(p->l, t, err);
	return;

on_error:

	subtilis_type_section_delete(stype);

	subtilis_error_init(&err2);
	subtilis_lexer_set_ass_keywords(p->l, false, &err2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc70, %rsp            # imm = 0xC70
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq $0x0, -0xc58(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rdx
movl $0x1, %esi
callq 0x12cc0
movq -0x40(%rbp), %rax
cmpl $0x0, (%rax)
je 0x220d4
jmp 0x221d5
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq 0x40(%rcx), %rdx
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %r8
addq $0xb8, %r8
movq -0x40(%rbp), %r9
callq *%rax
movq %rax, -0xc58(%rbp)
movq -0x40(%rbp), %rax
cmpl $0x0, (%rax)
je 0x22119
jmp 0x221d5
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %eax
movl %eax, %r8d
movq -0x18(%rbp), %rax
movl 0xb0(%rax), %r9d
movq -0x18(%rbp), %rax
movl 0xb4(%rax), %r14d
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rbx
movq -0xc58(%rbp), %r11
movq -0x38(%rbp), %r10
movq -0x40(%rbp), %rax
movl %r14d, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x39000
movq $0x0, -0x30(%rbp)
movq -0x40(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2219e
jmp 0x221d5
leaq -0xc4c(%rbp), %rdi
callq 0x15670
movq -0x18(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
leaq -0xc4c(%rbp), %rdx
callq 0x12cc0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x133f0
jmp 0x221ff
movq -0x30(%rbp), %rdi
callq 0x3e040
leaq -0xc4c(%rbp), %rdi
callq 0x15670
movq -0x18(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
leaq -0xc4c(%rbp), %rdx
callq 0x12cc0
addq $0xc70, %rsp            # imm = 0xC70
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_fn_compound
static void prv_fn_compound(subtilis_parser_t *p, subtilis_token_t *t,
			    subtilis_error_t *err)
{
	unsigned int start;
	const char *tbuf;

	start = p->l->line;
	while (t->type != SUBTILIS_TOKEN_EOF) {
		tbuf = subtilis_token_get_text(t);
		if ((t->type == SUBTILIS_TOKEN_OPERATOR) &&
		    !strcmp(tbuf, "<-") && (p->level == 0))
			break;

		subtilis_parser_statement(p, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

	if (t->type == SUBTILIS_TOKEN_EOF)
		subtilis_error_set_compund_not_term(err, p->l->stream->name,
						    start);
	//	p->current->endproc = false;
	p->current->handler_list =
	    subtilis_handler_list_truncate(p->current->handler_list, p->level);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x224d0
movq -0x10(%rbp), %rdi
callq 0x12d70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x224b2
movq -0x28(%rbp), %rdi
leaq 0x88040(%rip), %rsi     # 0xaa4db
callq 0x12140
cmpl $0x0, %eax
jne 0x224b2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x224b2
jmp 0x224d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x16bb0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x224ce
jmp 0x2252a
jmp 0x22471
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x22502
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movl -0x1c(%rbp), %ecx
movl $0x1e, %esi
leaq 0x88139(%rip), %r8      # 0xaa630
movl $0x398, %r9d            # imm = 0x398
callq 0x15930
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x78(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rsi
callq 0x37f70
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, 0x78(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_proc_compound
static void prv_proc_compound(subtilis_parser_t *p, subtilis_token_t *t,
			      subtilis_error_t *err)
{
	unsigned int start;

	start = p->l->line;
	while (t->type != SUBTILIS_TOKEN_EOF) {
		if ((t->type == SUBTILIS_TOKEN_KEYWORD) &&
		    (t->tok.keyword.type == SUBTILIS_KEYWORD_ENDPROC))
			break;

		subtilis_parser_statement(p, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

	if (t->type == SUBTILIS_TOKEN_EOF)
		subtilis_error_set_compund_not_term(err, p->l->stream->name,
						    start);
	//	p->current->endproc = false;
	p->current->handler_list =
	    subtilis_handler_list_truncate(p->current->handler_list, p->level);
}

// 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
movq (%rax), %rax
movl 0x38(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2258d
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2256f
movq -0x10(%rbp), %rax
cmpl $0x28, 0x8(%rax)
jne 0x2256f
jmp 0x2258d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x16bb0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2258b
jmp 0x225e7
jmp 0x22551
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x225bf
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movl -0x1c(%rbp), %ecx
movl $0x1e, %esi
leaq 0x8807c(%rip), %r8      # 0xaa630
movl $0x3b0, %r9d            # imm = 0x3B0
callq 0x15930
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x78(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rsi
callq 0x37f70
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, 0x78(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_process_array_param_type
static void prv_process_array_param_type(subtilis_parser_t *p,
					 subtilis_token_t *t,
					 const subtilis_type_t *type,
					 subtilis_type_t *ptype,
					 subtilis_error_t *err)
{
	subtilis_exp_t *e;
	int32_t num_dims;
	size_t i;

	e = subtilis_parser_bracketed_exp_internal(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (e->type.type != SUBTILIS_TYPE_CONST_INTEGER) {
		subtilis_exp_delete(e);
		subtilis_error_set_const_integer_expected(
		    err, p->l->stream->name, p->l->line);
		return;
	}
	num_dims = e->exp.ir_op.integer;
	subtilis_exp_delete(e);

	subtilis_lexer_get(p->l, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_type_if_array_of(type, ptype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	ptype->params.array.num_dims = num_dims;
	for (i = 0; i < ptype->params.array.num_dims; i++)
		ptype->params.array.dims[i] = SUBTILIS_DYNAMIC_DIMENSION;
}

// 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 -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x24f20
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x22acf
jmp 0x22ba8
movq -0x30(%rbp), %rax
cmpl $0x1, (%rax)
je 0x22b16
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x43, %esi
leaq 0x87b2a(%rip), %r8      # 0xaa630
movl $0x21e, %r9d            # imm = 0x21E
callq 0x15930
jmp 0x22ba8
movq -0x30(%rbp), %rax
movl 0x148(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x133f0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x22b4b
jmp 0x22ba8
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x479c0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x22b67
jmp 0x22ba8
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq 0x8(%rcx), %rcx
cmpq %rcx, %rax
jae 0x22ba8
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movl $0xffffffff, 0xc(%rax,%rcx,4) # imm = 0xFFFFFFFF
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x22b79
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_process_vector_param_type
static void prv_process_vector_param_type(subtilis_parser_t *p,
					  subtilis_token_t *t,
					  const subtilis_type_t *type,
					  subtilis_type_t *ptype,
					  subtilis_error_t *err)
{
	const char *tbuf;

	subtilis_lexer_get(p->l, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	tbuf = subtilis_token_get_text(t);
	if ((t->type != SUBTILIS_TOKEN_OPERATOR) && (strcmp(tbuf, "}"))) {
		subtilis_error_set_expected(err, "} ", tbuf, p->l->stream->name,
					    p->l->line);
		return;
	}

	ptype->params.array.num_dims = 1;

	subtilis_lexer_get(p->l, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_type_if_vector_of(type, ptype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	ptype->params.array.dims[0] = SUBTILIS_DYNAMIC_DIMENSION;
}

// 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 -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x133f0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x22bee
jmp 0x22cae
movq -0x10(%rbp), %rdi
callq 0x12d70
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
je 0x22c5d
movq -0x30(%rbp), %rdi
leaq 0x87a1c(%rip), %rsi     # 0xaa62b
callq 0x12140
cmpl $0x0, %eax
je 0x22c5d
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %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 0x879ea(%rip), %rdx     # 0xaa62d
leaq 0x879e6(%rip), %rax     # 0xaa630
movq %rax, (%rsp)
movl $0x240, 0x8(%rsp)       # imm = 0x240
callq 0x156d0
jmp 0x22cae
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x133f0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x22c87
jmp 0x22cae
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x47a50
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x22ca3
jmp 0x22cae
movq -0x20(%rbp), %rax
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_arg_check_failed
static void prv_arg_check_failed(subtilis_parser_t *p, const char *expected,
				 const char *got, void *ud,
				 subtilis_error_t *err)
{
	subtilis_check_call_ud_t *call_ud = (subtilis_check_call_ud_t *)ud;

	subtilis_error_set_bad_arg_type(err, call_ud->i + 1, expected, got,
					p->l->stream->name, call_ud->line,
					__FILE__, __LINE__);
}

// 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 -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
addq $0x1, %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %r9d
leaq 0x87648(%rip), %rax     # 0xaa630
movq %rax, (%rsp)
movl $0x70f, 0x8(%rsp)       # imm = 0x70F
callq 0x15bd0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_compound.c
// Function: subtilis_parser_compound_at_sym_level
void subtilis_parser_compound_at_sym_level(subtilis_parser_t *p,
					   subtilis_token_t *t, int end_key,
					   subtilis_error_t *err)
{
	unsigned int start;
	subtilis_ir_operand_t var_reg;

	start = p->l->line;
	while (t->type != SUBTILIS_TOKEN_EOF) {
		if ((t->type == SUBTILIS_TOKEN_KEYWORD) &&
		    (t->tok.keyword.type == end_key))
			break;
		subtilis_parser_statement(p, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

	if (t->type == SUBTILIS_TOKEN_EOF)
		subtilis_error_set_compund_not_term(err, p->l->stream->name,
						    start);
	if ((end_key != SUBTILIS_KEYWORD_NEXT) &&
	    (end_key != SUBTILIS_KEYWORD_UNTIL) &&
	    (end_key != SUBTILIS_KEYWORD_ENDPROC))
		p->current->endproc = false;

	var_reg.reg = SUBTILIS_IR_REG_LOCAL;
	subtilis_reference_deallocate_refs(p, var_reg, p->local_st, p->level,
					   err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	p->level--;
	subtilis_symbol_table_level_down(p->local_st, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	p->current->handler_list =
	    subtilis_handler_list_truncate(p->current->handler_list, p->level);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x23a65
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x23a44
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x23a44
jmp 0x23a65
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x16bb0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x23a63
jmp 0x23b43
jmp 0x23a24
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x23a97
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movl -0x24(%rbp), %ecx
movl $0x1e, %esi
leaq 0x86bd2(%rip), %r8      # 0xaa65e
movl $0x117, %r9d            # imm = 0x117
callq 0x15930
cmpl $0x51, -0x14(%rbp)
je 0x23abb
cmpl $0x8b, -0x14(%rbp)
je 0x23abb
cmpl $0x28, -0x14(%rbp)
je 0x23abb
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movb $0x0, 0x88(%rax)
movq $0x2, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rcx
movq -0x20(%rbp), %r8
movq -0x30(%rbp), %rsi
callq 0x6f4e0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x23aef
jmp 0x23b43
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x3c390
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x23b1b
jmp 0x23b43
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x78(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rsi
callq 0x37f70
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, 0x78(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_compound.c
// Function: subtilis_parser_compound_at_level
void subtilis_parser_compound_at_level(subtilis_parser_t *p,
				       subtilis_token_t *t, int end_key,
				       subtilis_error_t *err)
{
	subtilis_symbol_table_level_up(p->local_st, p->l, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_parser_compound_at_sym_level(p, t, end_key, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x3c320
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x23b8a
jmp 0x23b9e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x23a00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_compound.c
// Function: subtilis_parser_compound_statement_at_level
void subtilis_parser_compound_statement_at_level(subtilis_parser_t *p,
						 subtilis_token_t *t,
						 subtilis_error_t *err)
{
	subtilis_ir_operand_t var_reg;

	subtilis_symbol_table_level_up(p->local_st, p->l, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_parser_statement(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	var_reg.reg = SUBTILIS_IR_REG_LOCAL;
	subtilis_reference_deallocate_refs(p, var_reg, p->local_st, p->level,
					   err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	p->level--;
	subtilis_symbol_table_level_down(p->local_st, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	p->current->handler_list =
	    subtilis_handler_list_truncate(p->current->handler_list, p->level);
}

// 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
movq 0x68(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x3c320
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x23bea
jmp 0x23c91
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x16bb0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x23c09
jmp 0x23c91
movq $0x2, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %rsi
callq 0x6f4e0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x23c3d
jmp 0x23c91
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3c390
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x23c69
jmp 0x23c91
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x78(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rsi
callq 0x37f70
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, 0x78(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_cond.c
// Function: subtilis_parser_conditional_exp
subtilis_exp_t *subtilis_parser_conditional_exp(subtilis_parser_t *p,
						subtilis_token_t *t,
						subtilis_ir_operand_t *cond,
						subtilis_error_t *err)
{
	subtilis_exp_t *e;
	size_t reg;

	e = subtilis_parser_expression(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	e = subtilis_type_if_to_int(p, e, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	if (e->type.type == SUBTILIS_TYPE_CONST_INTEGER) {
		reg = subtilis_ir_section_add_instr2(
		    p->current, SUBTILIS_OP_INSTR_MOVI_I32, e->exp.ir_op, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		cond->reg = reg;
	} else if (e->type.type == SUBTILIS_TYPE_INTEGER) {
		cond->reg = e->exp.ir_op.reg;
	} else {
		subtilis_error_set_integer_exp_expected(err, p->l->stream->name,
							p->l->line);
		goto cleanup;
	}

	return e;

cleanup:
	subtilis_exp_delete(e);
	return NULL;
}

// 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 -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x24a20
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x23d33
movq $0x0, -0x8(%rbp)
jmp 0x23e03
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x23d5e
movq $0x0, -0x8(%rbp)
jmp 0x23e03
movq -0x30(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x23da4
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x148(%rax), %rdx
movl $0x1b, %esi
callq 0x38490
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x23d97
jmp 0x23df2
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x23de8
movq -0x30(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x23dc1
movq -0x30(%rbp), %rax
movq 0x148(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x23de6
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x1c, %esi
callq 0x158e0
jmp 0x23df2
jmp 0x23de8
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x23e03
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq $0x0, -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/parser_exp.c
// Function: subtilis_exp_get_lvalue
bool subtilis_exp_get_lvalue(subtilis_parser_t *p, subtilis_token_t *t,
			     subtilis_ir_operand_t *op, subtilis_type_t *type,
			     subtilis_error_t *err)
{
	const subtilis_symbol_t *s;
	const char *tbuf;
	size_t mem_reg = SUBTILIS_IR_REG_LOCAL;

	subtilis_lexer_get(p->l, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return false;

	tbuf = subtilis_token_get_text(t);
	if ((t->type != SUBTILIS_TOKEN_IDENTIFIER)) {
		subtilis_error_set_lvalue_expected(err, p->l->stream->name,
						   p->l->line);
		return false;
	}

	s = subtilis_parser_get_symbol(p, tbuf, &mem_reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return false;

	return subtilis_exp_get_lvalue_with_sym(
	    p, t, &s->t, s->key, mem_reg, s->loc, op, type, s->is_reg, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq $0x2, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x133f0
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2439b
movb $0x0, -0x9(%rbp)
jmp 0x24474
movq -0x20(%rbp), %rdi
callq 0x12d70
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x6, (%rax)
je 0x243ea
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x67, %esi
leaq 0x86516(%rip), %r8      # 0xaa8ec
movl $0xea, %r9d
callq 0x15930
movb $0x0, -0x9(%rbp)
jmp 0x24474
movq -0x18(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rcx
leaq -0x50(%rbp), %rdx
callq 0x24480
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x24412
movb $0x0, -0x9(%rbp)
jmp 0x24474
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq $0x8, %rdx
movq -0x40(%rbp), %rax
movq 0x298(%rax), %rcx
movq -0x50(%rbp), %r8
movq -0x40(%rbp), %rax
movq (%rax), %r9
movq -0x28(%rbp), %rbx
movq -0x30(%rbp), %r11
movq -0x40(%rbp), %rax
movb 0x2a8(%rax), %r10b
movq -0x38(%rbp), %rax
andb $0x1, %r10b
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movzbl %r10b, %r10d
movl %r10d, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x24070
andb $0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_parser_get_symbol
const subtilis_symbol_t *subtilis_parser_get_symbol(subtilis_parser_t *p,
						    const char *var_name,
						    size_t *mem_reg,
						    subtilis_error_t *err)
{
	const subtilis_symbol_t *s;

	s = subtilis_symbol_table_lookup(p->local_st, var_name);
	if (s) {
		*mem_reg = SUBTILIS_IR_REG_LOCAL;
	} else {
		s = subtilis_symbol_table_lookup(p->st, var_name);
		if (!s) {
			subtilis_error_set_unknown_variable(
			    err, var_name, p->l->stream->name, p->l->line);
			return NULL;
		}
		*mem_reg = SUBTILIS_IR_REG_GLOBAL;
	}

	return s;
}

// 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 -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3cff0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x244c1
movq -0x20(%rbp), %rax
movq $0x2, (%rax)
jmp 0x24534
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3cff0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x24529
movq -0x28(%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 $0x1b, %esi
leaq 0x86d6f(%rip), %rcx     # 0xab276
leaq 0x863de(%rip), %rax     # 0xaa8ec
movq %rax, (%rsp)
movl $0x5c9, 0x8(%rsp)       # imm = 0x5C9
callq 0x156d0
movq $0x0, -0x8(%rbp)
jmp 0x2453c
movq -0x20(%rbp), %rax
movq $0x1, (%rax)
movq -0x30(%rbp), %rax
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/parser_exp.c
// Function: subtilis_parser_priority7
subtilis_exp_t *subtilis_parser_priority7(subtilis_parser_t *p,
					  subtilis_token_t *t,
					  subtilis_error_t *err)
{
	subtilis_exp_t *e1 = NULL;
	subtilis_exp_t *e2 = NULL;
	subtilis_exp_fn_t exp_fn;

	e1 = prv_priority6(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	while (t->type == SUBTILIS_TOKEN_KEYWORD) {
		if (t->tok.keyword.type == SUBTILIS_KEYWORD_EOR)
			exp_fn = subtilis_type_if_eor;
		else if (t->tok.keyword.type == SUBTILIS_KEYWORD_OR)
			exp_fn = subtilis_type_if_or;
		else
			break;
		subtilis_lexer_get(p->l, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		e2 = prv_priority6(p, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		e1 = exp_fn(p, e1, e2, err);
		e2 = NULL;
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	return e1;

cleanup:

	subtilis_exp_delete(e2);
	subtilis_exp_delete(e1);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x24680
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x24597
jmp 0x24653
jmp 0x24599
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x24649
movq -0x18(%rbp), %rax
cmpl $0x2d, 0x8(%rax)
jne 0x245bd
leaq 0x24b99(%rip), %rax     # 0x49150
movq %rax, -0x38(%rbp)
jmp 0x245d8
movq -0x18(%rbp), %rax
cmpl $0x5a, 0x8(%rax)
jne 0x245d4
leaq 0x24b22(%rip), %rax     # 0x490f0
movq %rax, -0x38(%rbp)
jmp 0x245d6
jmp 0x24649
jmp 0x245d8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x133f0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x245f7
jmp 0x24653
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x24680
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x24617
jmp 0x24653
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq *%rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x24644
jmp 0x24653
jmp 0x24599
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2466d
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_exp.c
// Function: prv_priority6
static subtilis_exp_t *prv_priority6(subtilis_parser_t *p, subtilis_token_t *t,
				     subtilis_error_t *err)
{
	subtilis_exp_t *e1 = NULL;
	subtilis_exp_t *e2 = NULL;

	e1 = prv_priority5(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	while (t->type == SUBTILIS_TOKEN_KEYWORD &&
	       t->tok.keyword.type == SUBTILIS_KEYWORD_AND) {
		subtilis_lexer_get(p->l, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		e2 = prv_priority5(p, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		e1 = subtilis_type_if_and(p, e1, e2, err);
		e2 = NULL;
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	return e1;

cleanup:

	subtilis_exp_delete(e2);
	subtilis_exp_delete(e1);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x26110
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x246c7
jmp 0x24768
jmp 0x246c9
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl $0x1, (%rcx)
movb %al, -0x31(%rbp)
jne 0x246e5
movq -0x18(%rbp), %rax
cmpl $0x7, 0x8(%rax)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x246ee
jmp 0x2475e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x133f0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2470d
jmp 0x24768
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x26110
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2472d
jmp 0x24768
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x49090
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x24759
jmp 0x24768
jmp 0x246c9
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x24782
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq $0x0, -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/parser_exp.c
// Function: subtilis_parser_call_1_arg_fn
subtilis_exp_t *subtilis_parser_call_1_arg_fn(subtilis_parser_t *p,
					      const char *name, size_t reg,
					      subtilis_builtin_type_t ftype,
					      subtilis_ir_reg_type_t ptype,
					      const subtilis_type_t *rtype,
					      bool check_errors,
					      subtilis_error_t *err)
/* clang-format on */
{
	subtilis_ir_arg_t *args = NULL;
	char *name_dup = NULL;

	args = malloc(sizeof(*args) * 1);
	if (!args) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	name_dup = malloc(strlen(name) + 1);
	if (!name_dup) {
		subtilis_error_set_oom(err);
		goto cleanup;
	}
	strcpy(name_dup, name);

	args[0].type = ptype;
	args[0].reg = reg;

	return subtilis_exp_add_call(p, name_dup, ftype, NULL, args, rtype, 1,
				     check_errors, err);

cleanup:

	free(args);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x18(%rbp), %rax
movb 0x10(%rbp), %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movl $0x18, %edi
callq 0x121b0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x24807
movq 0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x860fc(%rip), %rdx     # 0xaa8ec
movl $0x345, %ecx            # imm = 0x345
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x248b8
movq -0x18(%rbp), %rdi
callq 0x120d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x121b0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x24843
movq 0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x860b5(%rip), %rdx     # 0xaa8ec
movl $0x34b, %ecx            # imm = 0x34B
callq 0x158e0
jmp 0x248a7
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12060
movl -0x28(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl -0x24(%rbp), %edx
movq -0x40(%rbp), %r8
movq -0x30(%rbp), %r9
movb -0x31(%rbp), %r10b
movq 0x18(%rbp), %rax
xorl %ecx, %ecx
andb $0x1, %r10b
movq $0x1, (%rsp)
movzbl %r10b, %r10d
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x36f50
movq %rax, -0x8(%rbp)
jmp 0x248b8
movq -0x40(%rbp), %rdi
callq 0x12290
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_parser_call_2_arg_fn
subtilis_exp_t *subtilis_parser_call_2_arg_fn(subtilis_parser_t *p,
					      const char *name, size_t arg1,
					      size_t arg2,
					      subtilis_ir_reg_type_t ptype1,
					      subtilis_ir_reg_type_t ptype2,
					      const subtilis_type_t *rtype,
					      bool check_errors,
					      subtilis_error_t *err)
/* clang-format on */

{
	subtilis_ir_arg_t *args = NULL;
	char *name_dup = NULL;

	args = malloc(sizeof(*args) * 2);
	if (!args) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	name_dup = malloc(strlen(name) + 1);
	if (!name_dup) {
		subtilis_error_set_oom(err);
		goto cleanup;
	}
	strcpy(name_dup, name);

	args[0].type = ptype1;
	args[0].reg = arg1;
	args[1].type = ptype2;
	args[1].reg = arg2;

	return subtilis_exp_add_call(p, name_dup, SUBTILIS_BUILTINS_MAX, NULL,
				     args, rtype, 2, check_errors, err);

cleanup:

	free(args);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x20(%rbp), %rax
movb 0x18(%rbp), %al
movq 0x10(%rbp), %r10
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movl $0x30, %edi
callq 0x121b0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x2494c
movq 0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x85fb7(%rip), %rdx     # 0xaa8ec
movl $0x36e, %ecx            # imm = 0x36E
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x24a15
movq -0x18(%rbp), %rdi
callq 0x120d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x121b0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x24988
movq 0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x85f70(%rip), %rdx     # 0xaa8ec
movl $0x374, %ecx            # imm = 0x374
callq 0x158e0
jmp 0x24a04
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12060
movl -0x2c(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x30(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %r8
movq 0x10(%rbp), %r9
movb -0x31(%rbp), %r10b
movq 0x20(%rbp), %rax
movl $0x9, %edx
xorl %ecx, %ecx
andb $0x1, %r10b
movq $0x2, (%rsp)
movzbl %r10b, %r10d
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x36f50
movq %rax, -0x8(%rbp)
jmp 0x24a15
movq -0x40(%rbp), %rdi
callq 0x12290
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_parser_expression
subtilis_exp_t *subtilis_parser_expression(subtilis_parser_t *p,
					   subtilis_token_t *t,
					   subtilis_error_t *err)
{
	subtilis_lexer_get(p->l, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	return subtilis_parser_priority7(p, t, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x133f0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x24a5b
movq $0x0, -0x8(%rbp)
jmp 0x24a70
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x24550
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_parser_int_var_expression
subtilis_exp_t *subtilis_parser_int_var_expression(subtilis_parser_t *p,
						   subtilis_token_t *t,
						   subtilis_error_t *err)
{
	subtilis_exp_t *e = NULL;

	e = subtilis_parser_priority7(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	e = subtilis_type_if_to_int(p, e, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	e = subtilis_type_if_exp_to_var(p, e, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	return e;

cleanup:

	subtilis_exp_delete(e);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x24550
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x24ac4
movq $0x0, -0x8(%rbp)
jmp 0x24b1f
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x488b0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x24ae4
jmp 0x24b0e
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x47c10
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x24b04
jmp 0x24b0e
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x24b1f
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq $0x0, -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/parser_exp.c
// Function: subtilis_parser_statement_int_args
void subtilis_parser_statement_int_args(subtilis_parser_t *p,
					subtilis_token_t *t, subtilis_exp_t **e,
					size_t expected, subtilis_error_t *err)
{
	size_t i;
	const char *tbuf;

	e[0] = subtilis_parser_int_var_expression(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	for (i = 1; i < expected; i++) {
		tbuf = subtilis_token_get_text(t);
		if (t->type != SUBTILIS_TOKEN_OPERATOR) {
			subtilis_error_set_expected(
			    err, ",", tbuf, p->l->stream->name, p->l->line);
			return;
		}

		if (strcmp(tbuf, ",")) {
			subtilis_error_set_expected(
			    err, ",", tbuf, p->l->stream->name, p->l->line);
			return;
		}

		subtilis_lexer_get(p->l, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;

		e[i] = subtilis_parser_int_var_expression(p, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}
}

// 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 -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x24a80
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x24b75
jmp 0x24c9e
movq $0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x24c9e
movq -0x10(%rbp), %rdi
callq 0x12d70
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
je 0x24be8
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %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 0x859de(%rip), %rdx     # 0xaa5a9
leaq 0x85d1a(%rip), %rax     # 0xaa8ec
movq %rax, (%rsp)
movl $0x3bb, 0x8(%rsp)       # imm = 0x3BB
callq 0x156d0
jmp 0x24c9e
movq -0x38(%rbp), %rdi
leaq 0x859b6(%rip), %rsi     # 0xaa5a9
callq 0x12140
cmpl $0x0, %eax
je 0x24c41
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %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 0x85982(%rip), %rdx     # 0xaa5a9
leaq 0x85cbe(%rip), %rax     # 0xaa8ec
movq %rax, (%rsp)
movl $0x3c1, 0x8(%rsp)       # imm = 0x3C1
callq 0x156d0
jmp 0x24c9e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x133f0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x24c60
jmp 0x24c9e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x24a80
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x24c8b
jmp 0x24c9e
jmp 0x24c8d
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x24b7d
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_parser_bracketed_2_int_args
subtilis_exp_t *
subtilis_parser_bracketed_2_int_args(subtilis_parser_t *p, subtilis_token_t *t,
				     subtilis_op_instr_type_t itype,
				     subtilis_error_t *err)
{
	subtilis_exp_t *e[2];
	size_t reg;
	size_t i;
	subtilis_exp_t *retval = NULL;

	memset(&e, 0, sizeof(e));

	prv_bracketed_int_args(p, t, e, 2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	reg = subtilis_ir_section_add_instr(p->current, itype, e[0]->exp.ir_op,
					    e[1]->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	retval = subtilis_exp_new_int32_var(reg, err);

cleanup:

	for (i = 0; i < 2; i++)
		subtilis_exp_delete(e[i]);

	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x12110
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq -0x28(%rbp), %r8
movl $0x2, %ecx
callq 0x24da0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x24d0c
movq $0x0, -0x8(%rbp)
jmp 0x24d8b
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x1c(%rbp), %esi
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %r8
movq 0x148(%rcx), %rdx
movq 0x148(%rax), %rcx
callq 0x38230
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x24d45
jmp 0x24d58
movq -0x48(%rbp), %rax
movl %eax, %edi
movq -0x28(%rbp), %rsi
callq 0x37770
movq %rax, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
cmpq $0x2, -0x50(%rbp)
jae 0x24d83
movq -0x50(%rbp), %rax
movq -0x40(%rbp,%rax,8), %rdi
callq 0x36ee0
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x24d60
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)