LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
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 (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x133f0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2e306
jmp 0x2e357
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2e343
movq -0x10(%rbp), %rax
cmpl $0x10, 0x8(%rax)
jne 0x2e343
movl -0x14(%rbp), %eax
subl $0x4, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x133f0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2e341
jmp 0x2e357
jmp 0x2e343
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x2e3b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_graphics.c
// Function: subtilis_parser_fill
void subtilis_parser_fill(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;

	prv_simple_plot(p, t, 133, 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 (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x133f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2e393
jmp 0x2e3a9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x85, %edx
callq 0x2e3b0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x12110
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdx
addq $0x8, %rdx
movq -0x20(%rbp), %r8
movl $0x2, %ecx
callq 0x24b30
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2e403
jmp 0x2e4a2
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x37800
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2e421
jmp 0x2e4cd
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x47c10
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2e444
jmp 0x2e4cd
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %r9
movq 0x148(%rdx), %rdx
movq 0x148(%rcx), %rcx
movq 0x148(%rax), %r8
movl $0x56, %esi
callq 0x38360
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2e486
jmp 0x2e4a2
movq -0x8(%rbp), %rax
testb $0x1, 0xb9(%rax)
jne 0x2e4a0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x36ce0
jmp 0x2e4a2
movq $0x0, -0x28(%rbp)
cmpq $0x3, -0x28(%rbp)
jae 0x2e4cd
movq -0x28(%rbp), %rax
movq -0x40(%rbp,%rax,8), %rdi
callq 0x36ee0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2e4aa
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %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), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x133f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2e516
jmp 0x2e617
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x4, %edx
callq 0x2e3b0
movq -0x10(%rbp), %rdi
callq 0x12d70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
je 0x2e589
movq -0x18(%rbp), %rdi
movq -0x20(%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 0x7c03d(%rip), %rdx     # 0xaa5a9
leaq 0x7c499(%rip), %rax     # 0xaaa0c
movq %rax, (%rsp)
movl $0xc7, 0x8(%rsp)
callq 0x156d0
jmp 0x2e617
movq -0x20(%rbp), %rdi
leaq 0x7c015(%rip), %rsi     # 0xaa5a9
callq 0x12140
cmpl $0x0, %eax
je 0x2e5e2
movq -0x18(%rbp), %rdi
movq -0x20(%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 0x7bfe1(%rip), %rdx     # 0xaa5a9
leaq 0x7c43d(%rip), %rax     # 0xaaa0c
movq %rax, (%rsp)
movl $0xcd, 0x8(%rsp)
callq 0x156d0
jmp 0x2e617
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x133f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2e601
jmp 0x2e617
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x5, %edx
callq 0x2e3b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x45, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x133f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2ed7a
jmp 0x2edcb
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2edb7
movq -0x10(%rbp), %rax
cmpl $0x10, 0x8(%rax)
jne 0x2edb7
movl -0x1c(%rbp), %eax
subl $0x4, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x133f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2edb5
jmp 0x2edcb
jmp 0x2edb7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x2e3b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x12110
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x12110
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x133f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f0d6
jmp 0x2f17d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movq -0x18(%rbp), %r8
movl $0x2, %ecx
callq 0x24b30
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f0fb
jmp 0x2f152
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %r9
movq 0x148(%rcx), %rdx
movq 0x148(%rax), %rcx
movq -0x38(%rbp), %r8
movl $0x59, %esi
callq 0x38360
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f136
jmp 0x2f152
movq -0x8(%rbp), %rax
testb $0x1, 0xb9(%rax)
jne 0x2f150
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36ce0
jmp 0x2f152
movq $0x0, -0x20(%rbp)
cmpq $0x2, -0x20(%rbp)
jae 0x2f17d
movq -0x20(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2f15a
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %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), %rdi
movq -0x18(%rbp), %rdx
movl $0x5b, %esi
callq 0x385f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f1c5
jmp 0x2f200
movq -0x8(%rbp), %rax
testb $0x1, 0xb9(%rax)
jne 0x2f1ec
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36ce0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f1ea
jmp 0x2f200
jmp 0x2f1ec
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_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 %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), %rdi
movq -0x18(%rbp), %rdx
movl $0x5c, %esi
callq 0x385f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f245
jmp 0x2f280
movq -0x8(%rbp), %rax
testb $0x1, 0xb9(%rax)
jne 0x2f26c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36ce0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f26a
jmp 0x2f280
jmp 0x2f26c
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_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 %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), %rdi
movq -0x18(%rbp), %rdx
movl $0x5d, %esi
callq 0x385f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f2c5
jmp 0x2f300
movq -0x8(%rbp), %rax
testb $0x1, 0xb9(%rax)
jne 0x2f2ec
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36ce0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f2ea
jmp 0x2f300
jmp 0x2f2ec
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_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 %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), %rdi
movq -0x18(%rbp), %rdx
movl $0x5e, %esi
callq 0x385f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f345
jmp 0x2f380
movq -0x8(%rbp), %rax
testb $0x1, 0xb9(%rax)
jne 0x2f36c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36ce0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f36a
jmp 0x2f380
jmp 0x2f36c
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_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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rdx
movl $0x6c, %esi
callq 0x384e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f691
movq $0x0, -0x8(%rbp)
jmp 0x2f6fc
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x36ce0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f6b1
movq $0x0, -0x8(%rbp)
jmp 0x2f6fc
movq -0x28(%rbp), %rax
movl %eax, %edi
movq -0x20(%rbp), %rsi
callq 0x37770
movq %rax, -0x30(%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 0x2f6f4
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x2f6fc
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_input.c
// Function: subtilis_parser_get_str
subtilis_exp_t *subtilis_parser_get_str(subtilis_parser_t *p,
					subtilis_token_t *t,
					subtilis_error_t *err)
{
	subtilis_exp_t *e;

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

	return subtilis_string_type_new_tmp_from_char(p, e, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2f650
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f74c
movq $0x0, -0x8(%rbp)
jmp 0x2f761
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x661f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x25130
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f7af
movq $0x0, -0x8(%rbp)
jmp 0x2f88d
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2f7d6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2f8a0
movq %rax, -0x8(%rbp)
jmp 0x2f88d
movq -0x28(%rbp), %rax
movq 0x148(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rcx
leaq 0x7b22a(%rip), %rsi     # 0xaaa27
leaq 0x7c0cc(%rip), %rdx     # 0xab8d0
callq 0x42fb0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f834
movq -0x20(%rbp), %rax
cmpl $0x20, (%rax)
je 0x2f829
movq $0x0, -0x8(%rbp)
jmp 0x2f88d
movq -0x20(%rbp), %rdi
callq 0x15670
jmp 0x2f856
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x400f0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f854
movq $0x0, -0x8(%rbp)
jmp 0x2f88d
jmp 0x2f856
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rax
leaq 0x7b1be(%rip), %rsi     # 0xaaa27
movl $0x9, %ecx
xorl %r8d, %r8d
leaq 0x7c058(%rip), %r9      # 0xab8d0
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x24790
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_input.c
// Function: prv_inkey_const
static subtilis_exp_t *prv_inkey_const(subtilis_parser_t *p,
				       subtilis_token_t *t, subtilis_exp_t *e,
				       subtilis_error_t *err)
{
	size_t reg;
	subtilis_op_instr_type_t itype;
	subtilis_ir_operand_t op1;
	int32_t inkey_value = e->exp.ir_op.integer;

	if (inkey_value == -256) {
		reg = subtilis_ir_section_add_instr1(
		    p->current, SUBTILIS_OP_INSTR_OS_BYTE_ID, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		subtilis_exp_handle_errors(p, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	} else {
		if (inkey_value >= 0)
			itype = SUBTILIS_OP_INSTR_GET_TO;
		else
			itype = SUBTILIS_OP_INSTR_INKEY;

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

		op1.reg = e->exp.ir_op.reg;
		;
		reg =
		    subtilis_ir_section_add_instr2(p->current, itype, op1, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		subtilis_exp_handle_errors(p, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	subtilis_exp_delete(e);

	return subtilis_exp_new_int32_var(reg, err);

cleanup:

	subtilis_exp_delete(e);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x148(%rax), %eax
movl %eax, -0x44(%rbp)
cmpl $0xffffff00, -0x44(%rbp) # imm = 0xFFFFFF00
jne 0x2f916
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %rdx
movl $0x6f, %esi
callq 0x384e0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f8f6
jmp 0x2f9ba
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x36ce0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f911
jmp 0x2f9ba
jmp 0x2f99c
cmpl $0x0, -0x44(%rbp)
jl 0x2f925
movl $0x6d, -0x34(%rbp)
jmp 0x2f92c
movl $0x6e, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x47c10
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f94c
jmp 0x2f9ba
movq -0x20(%rbp), %rax
movq 0x148(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x34(%rbp), %esi
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rdx
callq 0x38490
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f982
jmp 0x2f9ba
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x36ce0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2f99a
jmp 0x2f9ba
jmp 0x2f99c
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x30(%rbp), %rax
movl %eax, %edi
movq -0x28(%rbp), %rsi
callq 0x37770
movq %rax, -0x8(%rbp)
jmp 0x2f9cb
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rdx
movl $0x87, %esi
callq 0x384e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2fa29
movq $0x0, -0x8(%rbp)
jmp 0x2fa89
movq -0x28(%rbp), %rax
movl %eax, %edi
movq -0x20(%rbp), %rsi
callq 0x37770
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2fa4f
movq $0x0, -0x8(%rbp)
jmp 0x2fa89
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 0x2fa6e
jmp 0x2fa78
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2fa89
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x12110
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x2fb00
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2fae4
jmp 0x2faf9
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x47de0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x133f0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2fb3a
jmp 0x2fc60
movq -0x10(%rbp), %rdi
callq 0x12d70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x2fb65
movq -0x28(%rbp), %rdi
leaq 0x7b741(%rip), %rsi     # 0xab29c
callq 0x12140
cmpl $0x0, %eax
je 0x2fbac
movq -0x20(%rbp), %rdi
movq -0x28(%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 0x7ad73(%rip), %rdx     # 0xaa902
leaq 0x7aeb1(%rip), %rax     # 0xaaa47
movq %rax, (%rsp)
movl $0x43, 0x8(%rsp)
callq 0x156d0
jmp 0x2fc60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %r8
movl $0x2, %ecx
callq 0x255b0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2fbd8
jmp 0x2fc60
cmpq $0x2, -0x30(%rbp)
je 0x2fc26
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x15, %esi
leaq 0x7af4c(%rip), %rdx     # 0xaab51
leaq 0x7b66a(%rip), %rcx     # 0xab276
leaq 0x7ae34(%rip), %rax     # 0xaaa47
movq %rax, (%rsp)
movl $0x4d, 0x8(%rsp)
callq 0x156d0
jmp 0x2fc47
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x133f0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2fc45
jmp 0x2fc47
jmp 0x2fc60
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x36ee0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x12110
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2fb00
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2fcc4
movq $0x0, -0x8(%rbp)
jmp 0x2fd3d
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x47d20
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2fce0
jmp 0x2fd1a
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x47de0
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2fd10
jmp 0x2fd1a
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2fd3d
movq -0x38(%rbp), %rdi
callq 0x36ee0
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq -0x30(%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_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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x12110
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x2fe40
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2fd97
jmp 0x2fe32
movq -0x30(%rbp), %rax
cmpq $0x0, 0x158(%rax)
je 0x2fdec
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x53, %esi
leaq 0x7ac63(%rip), %rdx     # 0xaaa2e
leaq 0x7b4a4(%rip), %rcx     # 0xab276
leaq 0x7ac6e(%rip), %rax     # 0xaaa47
movq %rax, (%rsp)
movl $0xbc, 0x8(%rsp)
callq 0x156d0
jmp 0x2fe07
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0x487d0
jmp 0x2fe32
movq $0x0, -0x38(%rbp)
cmpq $0x3, -0x38(%rbp)
jae 0x2fe32
movq -0x38(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rdi
callq 0x36ee0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2fe0f
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x133f0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2fe7a
jmp 0x2ffb8
movq -0x10(%rbp), %rdi
callq 0x12d70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x2fea5
movq -0x28(%rbp), %rdi
leaq 0x7b401(%rip), %rsi     # 0xab29c
callq 0x12140
cmpl $0x0, %eax
je 0x2feec
movq -0x20(%rbp), %rdi
movq -0x28(%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 0x7aa33(%rip), %rdx     # 0xaa902
leaq 0x7ab71(%rip), %rax     # 0xaaa47
movq %rax, (%rsp)
movl $0x6b, 0x8(%rsp)
callq 0x156d0
jmp 0x2ffb8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %r8
movl $0x3, %ecx
callq 0x255b0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2ff18
jmp 0x2ffb8
cmpq $0x2, -0x30(%rbp)
jae 0x2ff66
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x15, %esi
leaq 0x7ac0c(%rip), %rdx     # 0xaab51
leaq 0x7b32a(%rip), %rcx     # 0xab276
leaq 0x7aaf4(%rip), %rax     # 0xaaa47
movq %rax, (%rsp)
movl $0x75, 0x8(%rsp)
callq 0x156d0
jmp 0x2ff87
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x133f0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2ff85
jmp 0x2ff87
jmp 0x2ffb8
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x2ffb8
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x36ee0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2ff8f
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x30686
movl $0x71, -0x1c(%rbp)
jmp 0x306b6
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x30698
movl $0x70, -0x1c(%rbp)
jmp 0x306b4
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x7a3c1(%rip), %rdx     # 0xaaa69
movl $0x21, %ecx
callq 0x158e0
jmp 0x306fa
jmp 0x306b6
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x148(%rax), %rdx
callq 0x38540
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x306e0
jmp 0x306fa
movq -0x8(%rbp), %rax
testb $0x1, 0xb9(%rax)
jne 0x306fa
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36ce0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x30660
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x30930
jmp 0x309a2
movl $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x9, -0x20(%rbp)
jae 0x309a2
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movl $0x70, %esi
callq 0x38540
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3096b
jmp 0x309a2
movq -0x8(%rbp), %rax
testb $0x1, 0xb9(%rax)
jne 0x30992
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36ce0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x30990
jmp 0x309a2
jmp 0x30992
jmp 0x30994
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3093f
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_output.c
// Function: prv_parse_spc
static void prv_parse_spc(subtilis_parser_t *p, subtilis_token_t *t,
			  subtilis_error_t *err)
{
	subtilis_exp_t *e;

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

	prv_spc(p, e, 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), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x25130
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x30e94
jmp 0x30ea5
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x31220
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x384e0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x30f22
movq $0x0, -0x8(%rbp)
jmp 0x30f5c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x133f0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x30f49
movq $0x0, -0x8(%rbp)
jmp 0x30f5c
movq -0x30(%rbp), %rax
movl %eax, %edi
movq -0x28(%rbp), %rsi
callq 0x37770
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $-0x1, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x133f0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x322da
movq $-0x1, -0x8(%rbp)
jmp 0x3236d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x31(%rbp), %rdx
callq 0x25b40
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x32306
movq $-0x1, -0x8(%rbp)
jmp 0x3236d
movq -0x30(%rbp), %rax
cmpl $0x5, (%rax)
je 0x32341
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 $0x4d, %esi
leaq 0x7877f(%rip), %r8      # 0xaaab3
movl $0xf6, %r9d
callq 0x15930
jmp 0x3235c
movb -0x31(%rbp), %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movq 0x148(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq -0x40(%rbp), %rax
movq %rax, -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_os.c
// Function: subtilis_parser_oscli
void subtilis_parser_oscli(subtilis_parser_t *p, subtilis_token_t *t,
			   subtilis_error_t *err)
{
	subtilis_exp_t *command;

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

	if (command->type.type == SUBTILIS_TYPE_STRING) {
		command = subtilis_string_zt_non_const(p, command, err);
	} else if (command->type.type == SUBTILIS_TYPE_CONST_STRING) {
		command = subtilis_string_lca_const_zt(p, command, err);
	} else {
		subtilis_error_set_string_expected(err, p->l->stream->name,
						   p->l->line);
		goto cleanup;
	}

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

	subtilis_exp_handle_errors(p, err);

cleanup:

	subtilis_exp_delete(command);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x24a20
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x323b7
jmp 0x3246d
movq -0x20(%rbp), %rax
cmpl $0x7, (%rax)
jne 0x323d7
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x669b0
movq %rax, -0x20(%rbp)
jmp 0x3242b
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x323f7
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x66470
movq %rax, -0x20(%rbp)
jmp 0x32429
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 $0x49, %esi
leaq 0x78697(%rip), %r8      # 0xaaab3
movl $0x1ab, %r9d            # imm = 0x1AB
callq 0x15930
jmp 0x32464
jmp 0x3242b
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x148(%rax), %rdx
movl $0x9a, %esi
callq 0x38540
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x32457
jmp 0x32464
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36ce0
movq -0x20(%rbp), %rdi
callq 0x36ee0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_os.c
// Function: subtilis_parser_osargs
subtilis_exp_t *subtilis_parser_osargs(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_OS_ARGS, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

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

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

	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rdx
movl $0x9c, %esi
callq 0x384e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x324c1
movq $0x0, -0x8(%rbp)
jmp 0x32521
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x66520
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x324e9
movq $0x0, -0x8(%rbp)
jmp 0x32521
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 0x32519
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x32521
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_string.c
// Function: subtilis_parser_chrstr
subtilis_exp_t *subtilis_parser_chrstr(subtilis_parser_t *p,
				       subtilis_token_t *t,
				       subtilis_error_t *err)
{
	subtilis_exp_t *e;
	subtilis_exp_t *retval;
	subtilis_buffer_t buf;
	char c_str[2];

	subtilis_buffer_init(&buf, 2);

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

	if (subtilis_type_if_is_const(&e->type)) {
		c_str[0] = e->exp.ir_op.integer & 255;
		c_str[1] = 0;
		subtilis_buffer_append(&buf, c_str, 2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		retval = subtilis_exp_new_str(&buf, err);
		subtilis_buffer_free(&buf);
		subtilis_exp_delete(e);
		return retval;
	}

	return subtilis_string_type_new_tmp_from_char(p, e, err);

cleanup:
	subtilis_buffer_free(&buf);
	subtilis_exp_delete(e);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x2, %esi
callq 0x15f80
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x25130
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3257d
movq $0x0, -0x8(%rbp)
jmp 0x32621
movq -0x28(%rbp), %rdi
callq 0x48a90
testb $0x1, %al
jne 0x3258c
jmp 0x325f0
movq -0x28(%rbp), %rax
movl 0x148(%rax), %eax
andl $0xff, %eax
movb %al, -0x42(%rbp)
movb $0x0, -0x41(%rbp)
leaq -0x42(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %rdi
movl $0x2, %edx
callq 0x16200
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x325c3
jmp 0x32607
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x37900
movq %rax, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x16650
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x32621
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x661f0
movq %rax, -0x8(%rbp)
jmp 0x32621
leaq -0x40(%rbp), %rdi
callq 0x16650
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_string.c
// Function: subtilis_parser_asc
subtilis_exp_t *subtilis_parser_asc(subtilis_parser_t *p, subtilis_token_t *t,
				    subtilis_error_t *err)
{
	subtilis_exp_t *e;

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

	return subtilis_string_type_asc(p, e, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x25000
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3266c
movq $0x0, -0x8(%rbp)
jmp 0x32681
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x67460
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)