LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_error.c
// Function: subtilis_parser_handle_escape
void subtilis_parser_handle_escape(subtilis_parser_t *p, subtilis_error_t *err)
{
	/* Let's not test for escape in an error handler. */

	if (!p->settings.handle_escapes || p->current->in_error_handler)
		return;

	subtilis_ir_section_add_instr_no_arg(p->current,
					     SUBTILIS_OP_INSTR_TESTESC, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_exp_handle_errors(p, err);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0xb8(%rdi)
jne 0x24732
movq %rdi, %r14
movq 0x48(%rdi), %rdi
cmpb $0x0, 0x60(%rdi)
jne 0x24732
movq %rsi, %rbx
movl $0x75, %esi
movq %rbx, %rdx
callq 0x2c1b7
cmpl $0x0, (%rbx)
je 0x2473a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2b37c
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_error.c
// Function: subtilis_parser_error
void subtilis_parser_error(subtilis_parser_t *p, subtilis_token_t *t,
			   subtilis_error_t *err)
{
	subtilis_exp_t *e;

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

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

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

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

	p->current->endproc = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x24980
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1e874
cmpl $0x0, (%r14)
je 0x24986
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x3691f
cmpl $0x0, (%r14)
je 0x249a7
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2b4c3
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2bdd4
cmpl $0x0, (%r14)
jne 0x24980
movq 0x48(%rbx), %rax
movb $0x1, 0x88(%rax)
jmp 0x24980
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_error.c
// Function: subtilis_parser_try
void subtilis_parser_try(subtilis_parser_t *p, subtilis_token_t *t,
			 subtilis_error_t *err)
{
	subtilis_ir_operand_t handler_label;

	handler_label.label = subtilis_ir_section_new_label(p->current);

	p->level++;
	p->current->try_depth++;

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

	p->current->handler_list = subtilis_handler_list_update(
	    p->current->handler_list, p->level, handler_label.label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

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

	subtilis_ir_section_add_label(p->current, handler_label.label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_var_set_eflag(p, false, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	p->current->try_depth--;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
callq 0x2d00a
movq %rax, %r15
incq 0x78(%rbx)
movq 0x48(%rbx), %rax
incq 0x68(%rax)
movq (%rbx), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x24c21
movq 0x48(%rbx), %rax
movq 0x78(%rbx), %rsi
movq 0x78(%rax), %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2bea7
movq 0x48(%rbx), %rcx
movq %rax, 0x78(%rcx)
cmpl $0x0, (%r14)
jne 0x24c21
movq %rbx, %rdi
movq %r12, %rsi
movl $0x2a, %edx
movq %r14, %rcx
callq 0x1e230
cmpl $0x0, (%r14)
jne 0x24c21
movq (%rbx), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x24c21
movq 0x48(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2d017
cmpl $0x0, (%r14)
jne 0x24c21
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x35e8d
cmpl $0x0, (%r14)
jne 0x24c21
movq 0x48(%rbx), %rax
decq 0x68(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_error.c
// Function: subtilis_parser_try_one
void subtilis_parser_try_one(subtilis_parser_t *p, subtilis_token_t *t,
			     subtilis_error_t *err)
{
	subtilis_ir_operand_t handler_label;

	handler_label.label = subtilis_ir_section_new_label(p->current);

	p->level++;
	p->current->try_depth++;

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

	p->current->handler_list = subtilis_handler_list_update(
	    p->current->handler_list, p->level, handler_label.label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

	p->current->endproc = false;

	subtilis_ir_section_add_label(p->current, handler_label.label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_var_set_eflag(p, false, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	p->current->try_depth--;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
callq 0x2d00a
movq %rax, %r15
incq 0x78(%rbx)
movq 0x48(%rbx), %rax
incq 0x68(%rax)
movq (%rbx), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x24e72
movq 0x48(%rbx), %rax
movq 0x78(%rbx), %rsi
movq 0x78(%rax), %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2bea7
movq 0x48(%rbx), %rcx
movq %rax, 0x78(%rcx)
cmpl $0x0, (%r14)
jne 0x24e72
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1e27b
cmpl $0x0, (%r14)
jne 0x24e72
movq 0x48(%rbx), %rdi
movb $0x0, 0x88(%rdi)
movq %r15, %rsi
movq %r14, %rdx
callq 0x2d017
cmpl $0x0, (%r14)
jne 0x24e72
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x35e8d
cmpl $0x0, (%r14)
jne 0x24e72
movq 0x48(%rbx), %rax
decq 0x68(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_graphics.c
// Function: subtilis_parser_mode
void subtilis_parser_mode(subtilis_parser_t *p, subtilis_token_t *t,
			  subtilis_error_t *err)
{
	subtilis_exp_t *e;

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

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

	subtilis_ir_section_add_instr_no_reg(
	    p->current, SUBTILIS_OP_INSTR_MODE_I32, e->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	if (!p->settings.ignore_graphics_errors)
		subtilis_exp_handle_errors(p, err);

cleanup:

	subtilis_exp_delete(e);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x24f0b
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1ebbe
cmpl $0x0, (%rbx)
je 0x24f11
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq 0x48(%r14), %rdi
movq 0x148(%rax), %rdx
movl $0x55, %esi
movq %rbx, %rcx
callq 0x2c19f
cmpl $0x0, (%rbx)
jne 0x24f46
cmpb $0x0, 0xb9(%r14)
jne 0x24f46
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b37c
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2b4c3
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_graphics.c
// Function: subtilis_parser_plot
void subtilis_parser_plot(subtilis_parser_t *p, subtilis_token_t *t,
			  subtilis_error_t *err)
{
	size_t i;
	subtilis_exp_t *e[3];

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

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

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

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

	if (!p->settings.ignore_graphics_errors)
		subtilis_exp_handle_errors(p, err);

cleanup:
	for (i = 0; i < 3; i++)
		subtilis_exp_delete(e[i]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%rdi), %rdi
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x24fff
movq %rsp, %rdx
movl $0x3, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %r8
callq 0x1ec0a
cmpl $0x0, (%rbx)
jne 0x24feb
movq 0x48(%r14), %rdi
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rsi
movq 0x148(%rax), %rdx
movq 0x148(%rcx), %rcx
movq 0x148(%rsi), %r8
movl $0x56, %esi
movq %rbx, %r9
callq 0x2c0c2
cmpl $0x0, (%rbx)
jne 0x24feb
cmpb $0x0, 0xb9(%r14)
jne 0x24feb
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b37c
xorl %ebx, %ebx
movq (%rsp,%rbx,8), %rdi
callq 0x2b4c3
incq %rbx
cmpq $0x3, %rbx
jne 0x24fed
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_graphics.c
// Function: subtilis_parser_wait
void subtilis_parser_wait(subtilis_parser_t *p, subtilis_token_t *t,
			  subtilis_error_t *err)
{
	subtilis_ir_section_add_instr_no_arg(p->current, SUBTILIS_OP_INSTR_WAIT,
					     err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (!p->settings.ignore_graphics_errors) {
		subtilis_exp_handle_errors(p, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x48(%rdi), %rdi
movl $0x5f, %esi
callq 0x2c1b7
cmpl $0x0, (%rbx)
je 0x25030
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x0, 0xb9(%r15)
jne 0x2504a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2b37c
cmpl $0x0, (%rbx)
jne 0x2502a
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x12eda
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_graphics.c
// Function: prv_move_draw
static void prv_move_draw(subtilis_parser_t *p, subtilis_token_t *t,
			  int32_t plot_code, subtilis_error_t *err)
{
	subtilis_lexer_get(p->l, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	if ((t->type == SUBTILIS_TOKEN_KEYWORD) &&
	    (t->tok.keyword.type == SUBTILIS_KEYWORD_BY)) {
		plot_code -= 4;
		subtilis_lexer_get(p->l, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

	prv_simple_plot(p, t, plot_code, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
movq %rcx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
je 0x25094
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, (%r14)
jne 0x250b7
cmpl $0x10, 0x8(%r14)
jne 0x250b7
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x25089
addl $-0x4, %ebp
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x25104
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_graphics.c
// Function: prv_simple_plot
static void prv_simple_plot(subtilis_parser_t *p, subtilis_token_t *t,
			    int32_t plot_code, subtilis_error_t *err)
{
	size_t i;
	subtilis_exp_t *e[3];

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

	subtilis_parser_statement_int_args(p, t, &e[1], 2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	e[0] = subtilis_exp_new_int32(plot_code, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

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

	if (!p->settings.ignore_graphics_errors)
		subtilis_exp_handle_errors(p, err);

cleanup:
	for (i = 0; i < 3; i++)
		subtilis_exp_delete(e[i]);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %rdx
movaps %xmm0, -0x8(%rdx)
movq $0x0, 0x8(%rdx)
movl $0x2, %ecx
movq %rbx, %r8
callq 0x1ec0a
cmpl $0x0, (%rbx)
je 0x25150
xorl %ebx, %ebx
movq (%rsp,%rbx,8), %rdi
callq 0x2b4c3
incq %rbx
cmpq $0x3, %rbx
jne 0x2513c
jmp 0x2517a
movl %ebp, %edi
movq %rbx, %rsi
callq 0x2bb29
movq %rax, (%rsp)
cmpl $0x0, (%rbx)
jne 0x2517a
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x36269
movq %rax, (%rsp)
cmpl $0x0, (%rbx)
je 0x25183
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x48(%r14), %rdi
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rsi
movq 0x148(%rax), %rdx
movq 0x148(%rcx), %rcx
movq 0x148(%rsi), %r8
movl $0x56, %esi
movq %rbx, %r9
callq 0x2c0c2
cmpl $0x0, (%rbx)
jne 0x2513a
cmpb $0x0, 0xb9(%r14)
jne 0x2513a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b37c
jmp 0x2513a
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_graphics.c
// Function: subtilis_parser_line
void subtilis_parser_line(subtilis_parser_t *p, subtilis_token_t *t,
			  subtilis_error_t *err)
{
	const char *tbuf;

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

	prv_simple_plot(p, t, 4, err);

	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;

	prv_simple_plot(p, t, 5, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x12eda
cmpl $0x0, (%rbx)
je 0x251fd
addq $0x8, %rsp
jmp 0x25292
movq %r15, %rdi
movq %r14, %rsi
movl $0x4, %edx
movq %rbx, %rcx
callq 0x25104
movq %r14, %rdi
callq 0x12ad0
movq %rax, %r12
cmpl $0x2, (%r14)
jne 0x2525f
leaq 0x4e370(%rip), %rsi     # 0x73598
movq %r12, %rdi
callq 0x12160
movq (%r15), %rdi
testl %eax, %eax
je 0x2529a
movq 0x30(%rdi), %r8
movl 0x38(%rdi), %r9d
leaq 0x4e786(%rip), %rax     # 0x739cc
leaq 0x4e34b(%rip), %rdx     # 0x73598
movq %rbx, %rdi
movl $0x1d, %esi
movq %r12, %rcx
pushq $0xcd
jmp 0x25288
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4e75b(%rip), %rax     # 0x739cc
leaq 0x4e320(%rip), %rdx     # 0x73598
movq %rbx, %rdi
movl $0x1d, %esi
movq %r12, %rcx
pushq $0xc7
pushq %rax
callq 0x1442a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x251f4
movq %r15, %rdi
movq %r14, %rsi
movl $0x5, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x25104
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_graphics.c
// Function: subtilis_parser_rectangle
void subtilis_parser_rectangle(subtilis_parser_t *p, subtilis_token_t *t,
			       subtilis_error_t *err)
{
	const char *tbuf;
	bool fill = false;

	subtilis_lexer_get(p->l, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	if ((t->type == SUBTILIS_TOKEN_KEYWORD) &&
	    (t->tok.keyword.type == SUBTILIS_KEYWORD_FILL)) {
		subtilis_lexer_get(p->l, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		fill = true;
	}

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

	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;

	if (fill)
		prv_simple_plot(p, t, 97, err);
	else
		prv_rectangle_outline(p, t, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x25569
cmpl $0x1, (%r14)
jne 0x254c9
cmpl $0x35, 0x8(%r14)
jne 0x254c9
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x25569
movb $0x1, %bpl
jmp 0x254cb
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rsi
movl $0x4, %edx
movq %rbx, %rcx
callq 0x25104
cmpl $0x0, (%rbx)
jne 0x25569
movq %r14, %rdi
callq 0x12ad0
movq %rax, %r12
cmpl $0x2, (%r14)
jne 0x25536
leaq 0x4e099(%rip), %rsi     # 0x73598
movq %r12, %rdi
callq 0x12160
movq (%r15), %rdi
testl %eax, %eax
je 0x25572
movq 0x30(%rdi), %r8
movl 0x38(%rdi), %r9d
leaq 0x4e4af(%rip), %rax     # 0x739cc
leaq 0x4e074(%rip), %rdx     # 0x73598
movq %rbx, %rdi
movl $0x1d, %esi
movq %r12, %rcx
pushq $0x189                  # imm = 0x189
jmp 0x2555f
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4e484(%rip), %rax     # 0x739cc
leaq 0x4e049(%rip), %rdx     # 0x73598
movq %rbx, %rdi
movl $0x1d, %esi
movq %r12, %rcx
pushq $0x183                  # imm = 0x183
pushq %rax
callq 0x1442a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x25569
movq %r15, %rdi
movq %r14, %rsi
testb %bpl, %bpl
je 0x255a2
movl $0x61, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x25104
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x255af
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_graphics.c
// Function: subtilis_parser_point
void subtilis_parser_point(subtilis_parser_t *p, subtilis_token_t *t,
			   subtilis_error_t *err)
{
	int32_t plot_code = 69;

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

	/*
	 * TODO: Implement POINT TO, once I figure out how
	 */

	if ((t->type == SUBTILIS_TOKEN_KEYWORD) &&
	    (t->tok.keyword.type == SUBTILIS_KEYWORD_BY)) {
		plot_code -= 4;
		subtilis_lexer_get(p->l, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

	prv_simple_plot(p, t, plot_code, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x12eda
cmpl $0x0, (%rbx)
je 0x25805
popq %rbx
popq %r14
popq %r15
retq
movl $0x45, %edx
cmpl $0x1, (%r14)
jne 0x2582f
cmpl $0x10, 0x8(%r14)
jne 0x2582f
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x257ff
movl $0x41, %edx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x25104
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_graphics.c
// Function: subtilis_parser_origin
void subtilis_parser_origin(subtilis_parser_t *p, subtilis_token_t *t,
			    subtilis_error_t *err)
{
	size_t i;
	subtilis_exp_t *e[2];
	subtilis_ir_operand_t op2;

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

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

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

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

	if (!p->settings.ignore_graphics_errors)
		subtilis_exp_handle_errors(p, err);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq (%rdi), %rdi
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x25ad5
movq %rsp, %rdx
movl $0x2, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %r8
callq 0x1ec0a
cmpl $0x0, (%rbx)
jne 0x25ac1
movq 0x48(%r14), %rdi
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x148(%rax), %rdx
movq 0x148(%rcx), %rcx
movl $0x59, %esi
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x2c0c2
cmpl $0x0, (%rbx)
jne 0x25ac1
cmpb $0x0, 0xb9(%r14)
jne 0x25ac1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b37c
xorl %ebx, %ebx
movq (%rsp,%rbx,8), %rdi
callq 0x2b4c3
incq %rbx
cmpq $0x1, %rbx
je 0x25ac3
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_graphics.c
// Function: subtilis_parser_cls
void subtilis_parser_cls(subtilis_parser_t *p, subtilis_token_t *t,
			 subtilis_error_t *err)
{
	subtilis_ir_section_add_instr_no_arg(p->current, SUBTILIS_OP_INSTR_CLS,
					     err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (!p->settings.ignore_graphics_errors) {
		subtilis_exp_handle_errors(p, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x48(%rdi), %rdi
movl $0x5b, %esi
callq 0x2c1b7
cmpl $0x0, (%rbx)
je 0x25b06
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x0, 0xb9(%r15)
jne 0x25b20
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2b37c
cmpl $0x0, (%rbx)
jne 0x25b00
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x12eda
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_graphics.c
// Function: subtilis_parser_clg
void subtilis_parser_clg(subtilis_parser_t *p, subtilis_token_t *t,
			 subtilis_error_t *err)
{
	subtilis_ir_section_add_instr_no_arg(p->current, SUBTILIS_OP_INSTR_CLG,
					     err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (!p->settings.ignore_graphics_errors) {
		subtilis_exp_handle_errors(p, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x48(%rdi), %rdi
movl $0x5c, %esi
callq 0x2c1b7
cmpl $0x0, (%rbx)
je 0x25b5a
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x0, 0xb9(%r15)
jne 0x25b74
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2b37c
cmpl $0x0, (%rbx)
jne 0x25b54
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x12eda
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_graphics.c
// Function: subtilis_parser_on
void subtilis_parser_on(subtilis_parser_t *p, subtilis_token_t *t,
			subtilis_error_t *err)
{
	subtilis_ir_section_add_instr_no_arg(p->current, SUBTILIS_OP_INSTR_ON,
					     err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (!p->settings.ignore_graphics_errors) {
		subtilis_exp_handle_errors(p, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x48(%rdi), %rdi
movl $0x5d, %esi
callq 0x2c1b7
cmpl $0x0, (%rbx)
je 0x25bae
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x0, 0xb9(%r15)
jne 0x25bc8
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2b37c
cmpl $0x0, (%rbx)
jne 0x25ba8
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x12eda
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_graphics.c
// Function: subtilis_parser_off
void subtilis_parser_off(subtilis_parser_t *p, subtilis_token_t *t,
			 subtilis_error_t *err)
{
	subtilis_ir_section_add_instr_no_arg(p->current, SUBTILIS_OP_INSTR_OFF,
					     err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (!p->settings.ignore_graphics_errors) {
		subtilis_exp_handle_errors(p, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x48(%rdi), %rdi
movl $0x5e, %esi
callq 0x2c1b7
cmpl $0x0, (%rbx)
je 0x25c02
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x0, 0xb9(%r15)
jne 0x25c1c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2b37c
cmpl $0x0, (%rbx)
jne 0x25bfc
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x12eda
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_input.c
// Function: subtilis_parser_get
subtilis_exp_t *subtilis_parser_get(subtilis_parser_t *p, subtilis_token_t *t,
				    subtilis_error_t *err)
{
	size_t reg;
	subtilis_exp_t *e;

	reg = subtilis_ir_section_add_instr1(p->current, SUBTILIS_OP_INSTR_GET,
					     err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

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

	e = subtilis_exp_new_int32_var(reg, err);

	subtilis_lexer_get(p->l, t, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(e);
		return NULL;
	}

	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x48(%rdi), %rdi
movl $0x6c, %esi
callq 0x2c193
cmpl $0x0, (%rbx)
jne 0x25ea4
movq %rax, %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2b37c
cmpl $0x0, (%rbx)
jne 0x25ea4
movl %r12d, %edi
movq %rbx, %rsi
callq 0x2ba99
movq %rax, %r12
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
je 0x25ea7
movq %r12, %rdi
callq 0x2b4c3
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_input.c
// Function: subtilis_parser_inkey
subtilis_exp_t *subtilis_parser_inkey(subtilis_parser_t *p, subtilis_token_t *t,
				      subtilis_error_t *err)
{
	subtilis_exp_t *e;
	size_t reg;
	subtilis_ir_section_t *current;

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

	if (e->type.type == SUBTILIS_TYPE_CONST_INTEGER)
		return prv_inkey_const(p, t, e, err);

	reg = e->exp.ir_op.reg;
	subtilis_exp_delete(e);

	current = subtilis_builtins_ir_add_1_arg_int(
	    p, "_inkey", &subtilis_type_integer, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		if (err->type != SUBTILIS_ERROR_ALREADY_DEFINED)
			return NULL;
		subtilis_error_init(err);
	} else {
		subtilis_builtins_ir_inkey(current, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return NULL;
	}

	return subtilis_parser_call_1_arg_fn(
	    p, "_inkey", reg, SUBTILIS_BUILTINS_MAX,
	    SUBTILIS_IR_REG_TYPE_INTEGER, &subtilis_type_integer, true, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
callq 0x1efb1
cmpl $0x0, (%rbx)
jne 0x25fbd
movq %rax, %r15
cmpl $0x1, (%rax)
jne 0x25f2f
movl 0x148(%r15), %ebp
cmpl $0xffffff00, %ebp       # imm = 0xFFFFFF00
jne 0x25f6c
movq 0x48(%r14), %rdi
movl $0x6f, %esi
movq %rbx, %rdx
callq 0x2c193
jmp 0x25f9d
movq 0x148(%r15), %r12
movq %r15, %rdi
callq 0x2b4c3
leaq 0x4daa2(%rip), %rsi     # 0x739e7
leaq 0x4e9ac(%rip), %rdx     # 0x748f8
movq %r14, %rdi
movq %rbx, %rcx
callq 0x33542
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x25fc8
cmpl $0x20, %ecx
jne 0x25fbd
movq %rbx, %rdi
callq 0x14404
jmp 0x25fd8
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x36269
movq %rax, %r15
cmpl $0x0, (%rbx)
jne 0x25fb5
shrl $0x1f, %ebp
addl $0x6d, %ebp
movq 0x148(%r15), %rdx
movq 0x48(%r14), %rdi
movl %ebp, %esi
movq %rbx, %rcx
callq 0x2c189
cmpl $0x0, (%rbx)
jne 0x25fb5
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b37c
cmpl $0x0, (%rbx)
je 0x26002
movq %r15, %rdi
callq 0x2b4c3
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
movq %rbx, %rsi
callq 0x30c94
cmpl $0x0, (%rbx)
jne 0x25fbd
leaq 0x4da08(%rip), %rsi     # 0x739e7
leaq 0x4e912(%rip), %r9      # 0x748f8
movq %r14, %rdi
movq %r12, %rdx
movl $0x9, %ecx
xorl %r8d, %r8d
pushq %rbx
pushq $0x1
callq 0x1e9b2
addq $0x10, %rsp
jmp 0x25fbf
movq %r15, %rdi
callq 0x2b4c3
movl %r12d, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2ba99
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_mem.c
// Function: subtilis_parser_mem_heap_free
subtilis_exp_t *subtilis_parser_mem_heap_free(subtilis_parser_t *p,
					      subtilis_token_t *t,
					      subtilis_error_t *err)
{
	size_t reg;
	subtilis_exp_t *e = NULL;

	reg = subtilis_ir_section_add_instr1(p->current,
					     SUBTILIS_OP_INSTR_HEAP_FREE, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	e = subtilis_exp_new_int32_var(reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

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

	return e;

cleanup:

	subtilis_exp_delete(e);

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x48(%rdi), %rdi
movl $0x87, %esi
callq 0x2c193
cmpl $0x0, (%rbx)
jne 0x26072
movl %eax, %edi
movq %rbx, %rsi
callq 0x2ba99
cmpl $0x0, (%rbx)
jne 0x26072
movq %rax, %r14
movq (%r12), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
je 0x26075
movq %r14, %rdi
callq 0x2b4c3
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_mem.c
// Function: subtilis_parser_copy
void subtilis_parser_copy(subtilis_parser_t *p, subtilis_token_t *t,
			  subtilis_error_t *err)
{
	subtilis_exp_t *objs[2] = {NULL, NULL};

	prv_mem_statement(p, t, &objs[0], err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_type_if_memcpy(p, objs[0], objs[1], err);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq %rbx, %rcx
callq 0x260c3
cmpl $0x0, (%rbx)
jne 0x260bb
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x36344
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_mem.c
// Function: prv_mem_statement
static void prv_mem_statement(subtilis_parser_t *p, subtilis_token_t *t,
			      subtilis_exp_t **objs, subtilis_error_t *err)
{
	const char *tbuf;
	size_t args;

	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;
	}

	args = subtilis_var_bracketed_args_have_b(p, t, &objs[0], 2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (args != 2) {
		subtilis_error_set_exp_expected(err, ")", p->l->stream->name,
						p->l->line);
		goto cleanup;
	}

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

	return;

cleanup:

	subtilis_exp_delete(objs[1]);
	subtilis_exp_delete(objs[0]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
movq %rcx, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x2613e
movq %r15, %rdi
callq 0x12ad0
movq %rax, %r13
cmpl $0x2, (%r15)
jne 0x2610d
leaq 0x4e111(%rip), %rsi     # 0x74212
movq %r13, %rdi
callq 0x12160
testl %eax, %eax
je 0x26148
movq (%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4d8e7(%rip), %rax     # 0x73a07
leaq 0x4d79b(%rip), %rdx     # 0x738c2
movq %r14, %rdi
movl $0x1d, %esi
movq %r13, %rcx
pushq $0x43
pushq %rax
callq 0x1442a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x2, %ecx
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %r8
callq 0x1f290
cmpl $0x0, (%r14)
jne 0x2613e
movq (%r12), %rdi
cmpq $0x2, %rax
jne 0x26181
movq %r15, %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x261b2
jmp 0x2613e
movq 0x30(%rdi), %r8
movl 0x38(%rdi), %r9d
leaq 0x4d877(%rip), %rax     # 0x73a07
leaq 0x4d956(%rip), %rdx     # 0x73aed
leaq 0x4dc57(%rip), %rcx     # 0x73df5
movq %r14, %rdi
movl $0x15, %esi
pushq $0x4d
pushq %rax
callq 0x1442a
addq $0x10, %rsp
movq 0x8(%rbx), %rdi
callq 0x2b4c3
movq (%rbx), %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b4c3
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_mem.c
// Function: subtilis_parser_copy_exp
subtilis_exp_t *subtilis_parser_copy_exp(subtilis_parser_t *p,
					 subtilis_token_t *t,
					 subtilis_error_t *err)
{
	subtilis_exp_t *objs[2] = {NULL, NULL};
	subtilis_exp_t *retval = NULL;

	prv_mem_statement(p, t, &objs[0], err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	retval = subtilis_type_if_dup(objs[0], err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_type_if_memcpy(p, objs[0], objs[1], err);
	objs[0] = NULL;
	objs[1] = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	return retval;

cleanup:
	subtilis_exp_delete(retval);
	subtilis_exp_delete(objs[1]);
	subtilis_exp_delete(objs[0]);
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r15
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq %rbx, %rcx
callq 0x260c3
cmpl $0x0, (%rbx)
jne 0x26240
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x362d2
movq %rax, %r14
cmpl $0x0, (%rbx)
jne 0x26225
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x36344
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
cmpl $0x0, (%rbx)
je 0x26243
movq %r14, %rdi
callq 0x2b4c3
movq 0x8(%rsp), %rdi
callq 0x2b4c3
movq (%rsp), %rdi
callq 0x2b4c3
xorl %r14d, %r14d
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_mem.c
// Function: subtilis_parser_append
void subtilis_parser_append(subtilis_parser_t *p, subtilis_token_t *t,
			    subtilis_error_t *err)
{
	subtilis_exp_t *objs[3] = {NULL};
	size_t i;

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

	if (objs[0]->temporary) {
		subtilis_error_set_temporary_not_allowed(
		    err, "first argument to append", p->l->stream->name,
		    p->l->line);
		goto cleanup;
	}

	subtilis_type_if_append(p, objs[0], objs[1], objs[2], err);
	return;

cleanup:
	for (i = 0; i < 3; i++)
		subtilis_exp_delete(objs[i]);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq %rbx, %rcx
callq 0x262f3
cmpl $0x0, (%rbx)
jne 0x262eb
movq (%rsp), %rsi
cmpq $0x0, 0x158(%rsi)
je 0x262d6
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4d76c(%rip), %rax     # 0x73a07
leaq 0x4d74c(%rip), %rdx     # 0x739ee
leaq 0x4db4c(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x53, %esi
pushq $0xbc
pushq %rax
callq 0x1442a
addq $0x10, %rsp
xorl %ebx, %ebx
movq (%rsp,%rbx,8), %rdi
callq 0x2b4c3
incq %rbx
cmpq $0x3, %rbx
jne 0x262c2
jmp 0x262eb
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %r8
callq 0x36876
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_mem.c
// Function: prv_append_statement
static void prv_append_statement(subtilis_parser_t *p, subtilis_token_t *t,
				 subtilis_exp_t **objs, subtilis_error_t *err)
{
	const char *tbuf;
	size_t args;
	size_t i;

	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;
	}

	args = subtilis_var_bracketed_args_have_b(p, t, &objs[0], 3, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (args < 2) {
		subtilis_error_set_exp_expected(err, ")", p->l->stream->name,
						p->l->line);
		goto cleanup;
	}

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

	return;

cleanup:

	for (i = 0; i < args; i++)
		subtilis_exp_delete(objs[i]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movq (%rdi), %rdi
movq %rcx, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x2636f
movq %r12, %rdi
callq 0x12ad0
movq %rax, %r15
cmpl $0x2, (%r12)
jne 0x2633e
leaq 0x4dee0(%rip), %rsi     # 0x74212
movq %r15, %rdi
callq 0x12160
testl %eax, %eax
je 0x26379
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4d6b6(%rip), %rax     # 0x73a07
leaq 0x4d56a(%rip), %rdx     # 0x738c2
movq %r14, %rdi
movl $0x1d, %esi
movq %r15, %rcx
pushq $0x6b
pushq %rax
callq 0x1442a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x3, %ecx
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %r8
callq 0x1f290
cmpl $0x0, (%r14)
jne 0x2636f
movq %rax, %r15
movq (%r13), %rdi
cmpq $0x1, %rax
ja 0x263db
movq 0x30(%rdi), %r8
movl 0x38(%rdi), %r9d
leaq 0x4d656(%rip), %rax     # 0x73a07
leaq 0x4d735(%rip), %rdx     # 0x73aed
leaq 0x4da36(%rip), %rcx     # 0x73df5
movq %r14, %rdi
movl $0x15, %esi
pushq $0x75
pushq %rax
callq 0x1442a
addq $0x10, %rsp
cmpq $0x1, %r15
jne 0x2636f
jmp 0x263ec
movq %r12, %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
je 0x2636f
cmpq $0x1, %r15
adcq $0x0, %r15
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
callq 0x2b4c3
incq %r14
cmpq %r14, %r15
jne 0x263f7
jmp 0x2636f
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_output.c
// Function: prv_vdu_byte
static void prv_vdu_byte(subtilis_parser_t *p, subtilis_exp_t *e,
			 subtilis_error_t *err)
{
	subtilis_op_instr_type_t itype;

	if (e->type.type == SUBTILIS_TYPE_INTEGER) {
		itype = SUBTILIS_OP_INSTR_VDU;
	} else if (e->type.type == SUBTILIS_TYPE_CONST_INTEGER) {
		itype = SUBTILIS_OP_INSTR_VDUI;
	} else {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	subtilis_ir_section_add_instr_no_reg(p->current, itype, e->exp.ir_op,
					     err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (!p->settings.ignore_graphics_errors)
		subtilis_exp_handle_errors(p, err);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl (%rsi), %eax
cmpl $0x5, %eax
je 0x268be
cmpl $0x1, %eax
jne 0x268ef
movl $0x70, %eax
jmp 0x268c3
movl $0x71, %eax
movq 0x48(%r14), %rdi
movq 0x148(%rsi), %rdx
movl %eax, %esi
movq %rbx, %rcx
callq 0x2c19f
cmpl $0x0, (%rbx)
jne 0x268e7
cmpb $0x0, 0xb9(%r14)
je 0x2690f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4d133(%rip), %rdx     # 0x73a29
movq %rbx, %rdi
movl $0xf, %esi
movl $0x21, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x145f4
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2b37c
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_output.c
// Function: prv_vdu_2bytes
static void prv_vdu_2bytes(subtilis_parser_t *p, subtilis_exp_t *e,
			   subtilis_error_t *err)
{
	subtilis_ir_operand_t op1;
	subtilis_ir_operand_t op2;

	if (e->type.type == SUBTILIS_TYPE_INTEGER) {
		op2.integer = 0xff;
		op1.reg = subtilis_ir_section_add_instr(
		    p->current, SUBTILIS_OP_INSTR_ANDI_I32, e->exp.ir_op, op2,
		    err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		subtilis_ir_section_add_instr_no_reg(
		    p->current, SUBTILIS_OP_INSTR_VDU, op1, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		if (!p->settings.ignore_graphics_errors) {
			subtilis_exp_handle_errors(p, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		}
		op2.integer = 8;
		op1.reg = subtilis_ir_section_add_instr(
		    p->current, SUBTILIS_OP_INSTR_LSRI_I32, e->exp.ir_op, op2,
		    err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		subtilis_ir_section_add_instr_no_reg(
		    p->current, SUBTILIS_OP_INSTR_VDU, op1, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	} else if (e->type.type == SUBTILIS_TYPE_CONST_INTEGER) {
		op1.integer = e->exp.ir_op.integer & 0xff;
		subtilis_ir_section_add_instr_no_reg(
		    p->current, SUBTILIS_OP_INSTR_VDUI, op1, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		if (!p->settings.ignore_graphics_errors) {
			subtilis_exp_handle_errors(p, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		}
		op1.integer = (e->exp.ir_op.integer >> 8) & 0xff;
		subtilis_ir_section_add_instr_no_reg(
		    p->current, SUBTILIS_OP_INSTR_VDUI, op1, err);
	} else {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	if (!p->settings.ignore_graphics_errors)
		subtilis_exp_handle_errors(p, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl (%rsi), %eax
cmpl $0x1, %eax
je 0x269d9
cmpl $0x5, %eax
jne 0x269fd
movq 0x48(%r14), %rdi
movq 0x148(%r15), %rdx
movl $0xff, %ecx
movl $0x25, %esi
movq %rbx, %r8
callq 0x2c00f
cmpl $0x0, (%rbx)
jne 0x269f7
movq 0x48(%r14), %rdi
movl $0x71, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x2c19f
cmpl $0x0, (%rbx)
jne 0x269f7
cmpb $0x0, 0xb9(%r14)
jne 0x2699c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b37c
cmpl $0x0, (%rbx)
jne 0x269f7
movq 0x48(%r14), %rdi
movq 0x148(%r15), %rdx
movl $0x8, %ecx
movl $0x4e, %esi
movq %rbx, %r8
callq 0x2c00f
cmpl $0x0, (%rbx)
jne 0x269f7
movq 0x48(%r14), %rdi
movl $0x71, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x2c19f
cmpl $0x0, (%rbx)
jne 0x269f7
jmp 0x26a4e
movzbl 0x148(%r15), %edx
movq 0x48(%r14), %rdi
movl $0x70, %esi
movq %rbx, %rcx
callq 0x2c19f
cmpl $0x0, (%rbx)
je 0x26a1b
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4d025(%rip), %rdx     # 0x73a29
movq %rbx, %rdi
movl $0xf, %esi
movl $0x5d, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x145f4
cmpb $0x0, 0xb9(%r14)
jne 0x26a35
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b37c
cmpl $0x0, (%rbx)
jne 0x269f7
movzbl 0x149(%r15), %edx
movq 0x48(%r14), %rdi
movl $0x70, %esi
movq %rbx, %rcx
callq 0x2c19f
cmpb $0x0, 0xb9(%r14)
jne 0x269f7
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2b37c
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_output.c
// Function: prv_vdu_1byte9zeros
static void prv_vdu_1byte9zeros(subtilis_parser_t *p, subtilis_exp_t *e,
				subtilis_error_t *err)
{
	size_t i;
	subtilis_ir_operand_t op1;

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

	op1.integer = 0;
	for (i = 0; i < 9; i++) {
		subtilis_ir_section_add_instr_no_reg(
		    p->current, SUBTILIS_OP_INSTR_VDUI, op1, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		if (!p->settings.ignore_graphics_errors) {
			subtilis_exp_handle_errors(p, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
callq 0x268a1
cmpl $0x0, (%rbx)
jne 0x26adb
movq 0x48(%r14), %rdi
movl $0x70, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x2c19f
cmpl $0x0, (%rbx)
jne 0x26adb
xorl %r15d, %r15d
cmpb $0x0, 0xb9(%r14)
je 0x26aaa
cmpq $0x7, %r15
jbe 0x26ac0
jmp 0x26adb
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b37c
cmpl $0x0, (%rbx)
jne 0x26adb
cmpq $0x8, %r15
jae 0x26adb
incq %r15
movq 0x48(%r14), %rdi
movl $0x70, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x2c19f
cmpl $0x0, (%rbx)
je 0x26a98
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_output.c
// Function: prv_pos
static subtilis_exp_t *prv_pos(subtilis_parser_t *p, subtilis_token_t *t,
			       subtilis_op_instr_type_t itype,
			       subtilis_error_t *err)
{
	size_t reg;

	reg = subtilis_ir_section_add_instr1(p->current, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

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

	return subtilis_exp_new_int32_var(reg, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x48(%rdi), %rdi
movl %edx, %esi
movq %rcx, %rdx
callq 0x2c193
cmpl $0x0, (%rbx)
jne 0x26ea9
movq %rax, %r14
movq (%r12), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
je 0x26eb7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl %r14d, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2ba99
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_os.c
// Function: prv_get_args
static subtilis_exp_t **prv_get_args(subtilis_parser_t *p, subtilis_token_t *t,
				     size_t *no_args, subtilis_error_t *err)
{
	subtilis_exp_t **tmp;
	const char *tbuf;
	size_t i;
	subtilis_exp_t **args = NULL;
	size_t count = 0;
	size_t max_count = 0;
	subtilis_exp_t *e;

	do {
		subtilis_lexer_get(p->l, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;

		tbuf = subtilis_token_get_text(t);
		if ((t->type == SUBTILIS_TOKEN_OPERATOR) &&
		    (!strcmp(tbuf, ","))) {
			e = NULL;
		} else {
			e = subtilis_parser_priority7(p, t, err);
			if (err->type != SUBTILIS_ERROR_OK)
				goto cleanup;
			tbuf = subtilis_token_get_text(t);
		}

		if (count == max_count) {
			if (args) {
				subtilis_error_set_sys_max_too_many_args(
				    err, p->l->stream->name, p->l->line);
				goto cleanup;
			}
			max_count += 16;
			tmp = realloc(args, sizeof(*args) * max_count);
			if (!tmp) {
				subtilis_error_set_oom(err);
				goto cleanup;
			}
			args = tmp;
		}
		args[count++] = e;
	} while ((t->type == SUBTILIS_TOKEN_OPERATOR) && (!strcmp(tbuf, ",")));

	*no_args = count;
	return args;

cleanup:

	for (i = 0; i < count; i++)
		subtilis_exp_delete(args[i]);
	free(args);
	*no_args = 0;

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, 0x18(%rsp)
movq %rsi, %r13
movq %rdi, 0x8(%rsp)
xorl %r14d, %r14d
xorl %ecx, %ecx
movq $0x0, 0x10(%rsp)
movq %rcx, %r12
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x12eda
cmpl $0x0, (%r15)
jne 0x2790e
movq %r13, %rdi
callq 0x12ad0
cmpl $0x2, (%r13)
jne 0x27836
movq %rax, %rbx
movq %rax, %rdi
leaq 0x4bd6f(%rip), %rsi     # 0x73598
callq 0x12160
testl %eax, %eax
je 0x278bc
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x1e874
cmpl $0x0, (%r15)
jne 0x2790e
movq %rax, %rbp
movq %r13, %rdi
callq 0x12ad0
movq %rax, %rbx
movq 0x10(%rsp), %rax
cmpq %rax, %r12
jne 0x27893
testq %r14, %r14
jne 0x278c5
movq %r14, 0x20(%rsp)
leaq 0x80(,%rax,8), %rdi
movq %rax, %r14
callq 0x121d0
testq %rax, %rax
je 0x278f0
addq $0x10, %r14
movq %r14, 0x10(%rsp)
movq %rax, %r14
movq %rbp, (%r14,%r12,8)
cmpl $0x2, (%r13)
jne 0x278c0
movq %rbx, %rdi
leaq 0x4bcf0(%rip), %rsi     # 0x73598
callq 0x12160
leaq 0x1(%r12), %rcx
testl %eax, %eax
je 0x277ed
jmp 0x278c0
xorl %ebp, %ebp
jmp 0x2785e
incq %r12
jmp 0x27934
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x4c198(%rip), %r8      # 0x73a73
movq %r15, %rdi
movl $0x4e, %esi
movl $0x39, %r9d
callq 0x14618
jmp 0x2790e
leaq 0x4c17c(%rip), %rdx     # 0x73a73
movq %r15, %rdi
movl $0x1, %esi
movl $0x3f, %ecx
callq 0x145f4
movq 0x20(%rsp), %r14
testq %r12, %r12
je 0x27926
xorl %ebx, %ebx
movq (%r14,%rbx,8), %rdi
callq 0x2b4c3
incq %rbx
cmpq %rbx, %r12
jne 0x27915
movq %r14, %rdi
callq 0x122c0
xorl %r12d, %r12d
xorl %r14d, %r14d
movq 0x18(%rsp), %rax
movq %r12, (%rax)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_os.c
// Function: prv_handle_flags
static size_t prv_handle_flags(subtilis_parser_t *p, subtilis_token_t *t,
			       bool *is_local, subtilis_error_t *err)
{
	subtilis_exp_t *e;
	bool local;
	size_t ret_val = SIZE_MAX;

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

	e = subtilis_var_lookup_ref(p, t, &local, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return SIZE_MAX;

	if (e->type.type != SUBTILIS_TYPE_INTEGER) {
		subtilis_error_set_sys_bad_args(err, p->l->stream->name,
						p->l->line);
		goto cleanup;
	}

	*is_local = local;
	ret_val = e->exp.ir_op.reg;

cleanup:

	subtilis_exp_delete(e);
	return ret_val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
movq (%rdi), %rdi
movq %rcx, %rdx
callq 0x12eda
movq $-0x1, %r12
cmpl $0x0, (%rbx)
jne 0x27e26
leaq 0xf(%rsp), %rdx
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x1f5ea
cmpl $0x0, (%rbx)
jne 0x27e26
movq %rax, %r14
cmpl $0x5, (%rax)
jne 0x27df2
movb 0xf(%rsp), %al
movb %al, (%r15)
movq 0x148(%r14), %r12
jmp 0x27e1e
movq (%r13), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x4bc6f(%rip), %r8      # 0x73a73
movq %rbx, %rdi
movl $0x4d, %esi
movl $0xf6, %r9d
callq 0x14618
movq $-0x1, %r12
movq %r14, %rdi
callq 0x2b4c3
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq