LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_loops.c
// Function: subtilis_parser_repeat
void subtilis_parser_repeat(subtilis_parser_t *p, subtilis_token_t *t,
			    subtilis_error_t *err)
{
	subtilis_exp_t *e = NULL;
	subtilis_ir_operand_t cond;
	subtilis_ir_operand_t start_label;
	subtilis_ir_operand_t true_label;

	start_label.reg = subtilis_ir_section_new_label(p->current);
	subtilis_ir_section_add_label(p->current, start_label.reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

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

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

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

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

	true_label.reg = subtilis_ir_section_new_label(p->current);

	subtilis_ir_section_add_instr_reg(p->current, SUBTILIS_OP_INSTR_JMPC,
					  cond, true_label, start_label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_ir_section_add_label(p->current, true_label.reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

cleanup:
	subtilis_exp_delete(e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x39940
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x39960
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2a0d0
jmp 0x2a1b5
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 0x2a0f2
jmp 0x2a1b5
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2d400
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2a10d
jmp 0x2a1b5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x8b, %edx
callq 0x23ca0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2a131
jmp 0x2a1b5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq -0x28(%rbp), %rdx
callq 0x23cf0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2a155
jmp 0x2a1be
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x39940
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %r9
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0x43, %esi
callq 0x38360
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2a193
jmp 0x2a1b5
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x39960
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2a1b3
jmp 0x2a1b5
jmp 0x2a1b5
movq -0x20(%rbp), %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_loops.c
// Function: subtilis_parser_range
void subtilis_parser_range(subtilis_parser_t *p, subtilis_token_t *t,
			   subtilis_error_t *err)

{
	size_t i;
	subtilis_exp_t *e;
	size_t var_count;
	bool new_locals;
	subtilis_range_var_t *range_vars = NULL;

	range_vars = prv_get_range_vars(p, t, &var_count, &e, &new_locals, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	prv_range_compound(p, t, e, var_count, new_locals, range_vars, err);

	subtilis_exp_delete(e);
	for (i = 0; i < var_count; i++) {
		subtilis_type_free(&range_vars[i].type);
		subtilis_type_free(&range_vars[i].for_ctx.type);
		free(range_vars[i].name);
	}
	free(range_vars);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %r9
leaq -0x30(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x31(%rbp), %r8
callq 0x2a2d0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2a21b
jmp 0x2a2c8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movb -0x31(%rbp), %r8b
movq -0x40(%rbp), %r9
movq -0x18(%rbp), %rax
andb $0x1, %r8b
movzbl %r8b, %r8d
movq %rax, (%rsp)
callq 0x2a900
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x2a2bf
movq -0x40(%rbp), %rdi
imulq $0x2c8, -0x20(%rbp), %rax # imm = 0x2C8
addq %rax, %rdi
addq $0x8, %rdi
callq 0x3e100
movq -0x40(%rbp), %rdi
imulq $0x2c8, -0x20(%rbp), %rax # imm = 0x2C8
addq %rax, %rdi
addq $0x150, %rdi            # imm = 0x150
addq $0x18, %rdi
callq 0x3e100
movq -0x40(%rbp), %rax
imulq $0x2c8, -0x20(%rbp), %rcx # imm = 0x2C8
addq %rcx, %rax
movq (%rax), %rdi
callq 0x12290
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2a259
movq -0x40(%rbp), %rdi
callq 0x12290
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_loops.c
// Function: prv_init_array_var
static void prv_init_array_var(subtilis_parser_t *p, subtilis_token_t *t,
			       subtilis_for_context_t *for_ctx,
			       const char *var_name, subtilis_error_t *err)
{
	subtilis_ir_operand_t op1;
	const subtilis_symbol_t *s;
	bool new_global = false;

	subtilis_parser_lookup_assignment_var(p, t, var_name, &s, &op1.reg,
					      &new_global, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (new_global) {
		subtilis_error_set_unknown_variable(
		    err, var_name, p->l->stream->name, p->l->line);
		return;
	}

	prv_for_assign_array(p, var_name, t, s, op1.reg, for_ctx, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movb $0x0, -0x39(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
leaq -0x38(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x39(%rbp), %r9
movq %rax, (%rsp)
callq 0x1b6a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2afc0
jmp 0x2b02f
testb $0x1, -0x39(%rbp)
je 0x2b00a
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1b, %esi
leaq 0x80286(%rip), %rcx     # 0xab276
leaq 0x7f9b3(%rip), %rax     # 0xaa9aa
movq %rax, (%rsp)
movl $0x118, 0x8(%rsp)       # imm = 0x118
callq 0x156d0
jmp 0x2b02f
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x18(%rbp), %r9
movq -0x28(%rbp), %rax
movq %rax, (%rsp)
callq 0x2b340
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_loops.c
// Function: prv_init_vector_var
static void prv_init_vector_var(subtilis_parser_t *p, subtilis_token_t *t,
				subtilis_for_context_t *for_ctx,
				const char *var_name, subtilis_error_t *err)
{
	subtilis_ir_operand_t op1;
	const subtilis_symbol_t *s;
	bool new_global = false;

	subtilis_parser_lookup_assignment_var(p, t, var_name, &s, &op1.reg,
					      &new_global, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (new_global) {
		subtilis_error_set_unknown_variable(
		    err, var_name, p->l->stream->name, p->l->line);
		return;
	}

	prv_for_assign_vector(p, var_name, t, s, op1.reg, for_ctx, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movb $0x0, -0x39(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
leaq -0x38(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x39(%rbp), %r9
movq %rax, (%rsp)
callq 0x1b6a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2b090
jmp 0x2b0ff
testb $0x1, -0x39(%rbp)
je 0x2b0da
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1b, %esi
leaq 0x801b6(%rip), %rcx     # 0xab276
leaq 0x7f8e3(%rip), %rax     # 0xaa9aa
movq %rax, (%rsp)
movl $0x12e, 0x8(%rsp)       # imm = 0x12E
callq 0x156d0
jmp 0x2b0ff
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x18(%rbp), %r9
movq -0x28(%rbp), %rax
movq %rax, (%rsp)
callq 0x2b4c0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_loops.c
// Function: prv_for_assign_array
static void prv_for_assign_array(subtilis_parser_t *p, const char *var_name,
				 subtilis_token_t *t,
				 const subtilis_symbol_t *s, size_t mem_reg,
				 subtilis_for_context_t *ctx,
				 subtilis_error_t *err)
{
	subtilis_exp_t *indices[SUBTILIS_MAX_DIMENSIONS];
	size_t i;
	subtilis_exp_t *e = NULL;
	size_t dims = 0;

	dims = subtilis_var_bracketed_int_args_have_b(
	    p, t, indices, SUBTILIS_MAX_DIMENSIONS, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

	subtilis_type_if_element_type(p, &s->t, &ctx->type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	e = subtilis_array_index_calc(p, var_name, &s->t, mem_reg, s->loc,
				      indices, dims, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	ctx->is_reg = false;
	ctx->reg = e->exp.ir_op.reg;
	ctx->loc = 0;

cleanup:

	subtilis_exp_delete(e);

	for (i = 0; i < dims; i++)
		subtilis_exp_delete(indices[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x90(%rbp)
movq $0x0, -0x98(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x80(%rbp), %rdx
movq 0x10(%rbp), %r8
movl $0xa, %ecx
callq 0x251f0
movq %rax, -0x98(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2b3ac
jmp 0x2b4b5
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq 0x10(%rbp), %rdx
callq 0x133f0
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2b3ce
jmp 0x2b469
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movq -0x30(%rbp), %rdx
addq $0x18, %rdx
movq 0x10(%rbp), %rcx
callq 0x47b70
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2b3f6
jmp 0x2b469
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x8, %rdx
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %r8
leaq -0x80(%rbp), %r9
movq -0x98(%rbp), %r10
movq 0x10(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x5edb0
movq %rax, -0x90(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2b440
jmp 0x2b469
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x90(%rbp), %rax
movq 0x148(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x90(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x88(%rbp)
movq -0x88(%rbp), %rax
cmpq -0x98(%rbp), %rax
jae 0x2b4b5
movq -0x88(%rbp), %rax
movq -0x80(%rbp,%rax,8), %rdi
callq 0x36ee0
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x2b480
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_loops.c
// Function: prv_for_assign_vector
static void prv_for_assign_vector(subtilis_parser_t *p, const char *var_name,
				  subtilis_token_t *t,
				  const subtilis_symbol_t *s, size_t mem_reg,
				  subtilis_for_context_t *ctx,
				  subtilis_error_t *err)
{
	subtilis_exp_t *index[1];
	subtilis_exp_t *e = NULL;

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

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

	subtilis_type_if_element_type(p, &s->t, &ctx->type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	e = subtilis_array_index_calc(p, var_name, &s->t, mem_reg, s->loc,
				      index, 1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	ctx->is_reg = false;
	ctx->reg = e->exp.ir_op.reg;
	ctx->loc = 0;

cleanup:

	subtilis_exp_delete(e);
	subtilis_exp_delete(index[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x10(%rbp), %rdx
callq 0x259e0
movq %rax, -0x38(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2b50f
jmp 0x2b5d5
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq 0x10(%rbp), %rdx
callq 0x133f0
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2b531
jmp 0x2b5c3
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movq -0x30(%rbp), %rdx
addq $0x18, %rdx
movq 0x10(%rbp), %rcx
callq 0x47b70
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2b559
jmp 0x2b5c3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x8, %rdx
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %r8
leaq -0x38(%rbp), %r9
movq 0x10(%rbp), %rax
movq $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x5edb0
movq %rax, -0x40(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2b59d
jmp 0x2b5c3
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x40(%rbp), %rax
movq 0x148(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x40(%rbp), %rdi
callq 0x36ee0
movq -0x38(%rbp), %rdi
callq 0x36ee0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_loops.c
// Function: prv_for_loop_start
static void prv_for_loop_start(subtilis_parser_t *p, subtilis_token_t *t,
			       subtilis_ir_operand_t *start_label,
			       subtilis_ir_operand_t *true_label,
			       subtilis_error_t *err)
{
	start_label->reg = subtilis_ir_section_new_label(p->current);
	subtilis_ir_section_add_label(p->current, start_label->reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

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

	true_label->reg = subtilis_ir_section_new_label(p->current);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x39940
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x39960
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2b636
jmp 0x2b686
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2d400
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2b64e
jmp 0x2b686
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
movl $0x51, %edx
callq 0x23a00
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2b66f
jmp 0x2b686
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x39940
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_loops.c
// Function: prv_init_tilde_var
static void prv_init_tilde_var(subtilis_for_context_t *for_ctx,
			       const subtilis_type_t *type,
			       subtilis_error_t *err)
{
	subtilis_type_copy(&for_ctx->type, type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	for_ctx->is_reg = false;
	for_ctx->reg = SIZE_MAX;
	for_ctx->loc = SIZE_MAX;
}

// 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
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3e4f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2bed4
jmp 0x2bef3
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $-0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $-0x1, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_loops.c
// Function: prv_range_loop_end
static void
prv_range_loop_end(subtilis_parser_t *p, const subtilis_range_var_t *range_vars,
		   subtilis_ir_operand_t ptr, subtilis_ir_operand_t start_label,
		   subtilis_ir_operand_t end_label, subtilis_error_t *err)
{
	subtilis_ir_operand_t op1;

	op1.integer = subtilis_type_if_size(&range_vars[0].for_ctx.type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_instr_reg(
	    p->current, SUBTILIS_OP_INSTR_ADDI_I32, ptr, ptr, op1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_instr_no_reg(p->current, SUBTILIS_OP_INSTR_JMP,
					     start_label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_label(p->current, end_label.label, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rdi
addq $0x150, %rdi            # imm = 0x150
addq $0x18, %rdi
movq -0x30(%rbp), %rsi
callq 0x47420
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2c866
jmp 0x2c8cd
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %r9
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rcx
movq -0x38(%rbp), %r8
movl $0x9, %esi
callq 0x38360
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2c893
jmp 0x2c8cd
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdx
movl $0x45, %esi
callq 0x38540
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2c8b8
jmp 0x2c8cd
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x39960
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_loops.c
// Function: prv_range_loop_end_index
static void prv_range_loop_end_index(subtilis_parser_t *p, size_t var_count,
				     const subtilis_range_var_t *range_vars,
				     subtilis_ir_operand_t ptr,
				     subtilis_error_t *err)
{
	subtilis_ir_operand_t op1;
	size_t i;
	subtilis_exp_t *inc;

	op1.integer = subtilis_type_if_size(&range_vars[0].for_ctx.type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_instr_reg(
	    p->current, SUBTILIS_OP_INSTR_ADDI_I32, ptr, ptr, op1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	for (i = var_count - 1; i > 0; i--) {
		inc = subtilis_exp_new_int32(1, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;

		inc = prv_increment_var(p, inc, &range_vars[i].for_ctx, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		subtilis_exp_delete(inc);

		subtilis_ir_section_add_instr_no_reg(
		    p->current, SUBTILIS_OP_INSTR_JMP,
		    range_vars[i].start_label, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		subtilis_ir_section_add_label(
		    p->current, range_vars[i].end_label.label, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rcx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
addq $0x150, %rdi            # imm = 0x150
addq $0x18, %rdi
movq -0x28(%rbp), %rsi
callq 0x47420
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2c925
jmp 0x2ca4a
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %r9
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0x9, %esi
callq 0x38360
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2c955
jmp 0x2ca4a
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jbe 0x2ca4a
movq -0x28(%rbp), %rsi
movl $0x1, %edi
callq 0x37800
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2c98c
jmp 0x2ca4a
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x20(%rbp), %rdx
imulq $0x2c8, -0x38(%rbp), %rax # imm = 0x2C8
addq %rax, %rdx
addq $0x150, %rdx            # imm = 0x150
movq -0x28(%rbp), %rcx
callq 0x2b690
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2c9c5
jmp 0x2ca4a
movq -0x40(%rbp), %rdi
callq 0x36ee0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rax
imulq $0x2c8, -0x38(%rbp), %rcx # imm = 0x2C8
addq %rcx, %rax
movq -0x28(%rbp), %rcx
movq 0x2b0(%rax), %rdx
movl $0x45, %esi
callq 0x38540
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2ca05
jmp 0x2ca4a
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rax
imulq $0x2c8, -0x38(%rbp), %rcx # imm = 0x2C8
addq %rcx, %rax
movq 0x2b8(%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x39960
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2ca37
jmp 0x2ca4a
jmp 0x2ca39
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2c961
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_math.c
// Function: subtilis_parser_rad
subtilis_exp_t *subtilis_parser_rad(subtilis_parser_t *p, subtilis_token_t *t,
				    subtilis_error_t *err)
{
	subtilis_exp_t *e = NULL;
	subtilis_exp_t *e2 = NULL;
	subtilis_exp_t *e3 = NULL;
	const double radian = ((22 / 7.0) / 180);

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

	if (e->type.type == SUBTILIS_TYPE_CONST_REAL) {
		e2 = subtilis_exp_new_real(e->exp.ir_op.real * radian, err);
	} else {
		e3 = subtilis_exp_new_real(radian, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		e2 = subtilis_type_if_mul(p, e, e3, err);
		e = NULL;
	}
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_exp_delete(e);

	return e2;

cleanup:

	subtilis_exp_delete(e);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movsd 0x7dd7c(%rip), %xmm0    # 0xaa9d0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x25190
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2cc84
movq $0x0, -0x8(%rbp)
jmp 0x2cd20
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x2ccb0
movq -0x28(%rbp), %rax
movsd 0x7dd37(%rip), %xmm0    # 0xaa9d0
mulsd 0x148(%rax), %xmm0
movq -0x20(%rbp), %rdi
callq 0x37880
movq %rax, -0x30(%rbp)
jmp 0x2ccf1
movq -0x20(%rbp), %rdi
movsd 0x7dd14(%rip), %xmm0    # 0xaa9d0
callq 0x37880
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2ccd0
jmp 0x2cd0f
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x48fb0
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2ccfc
jmp 0x2cd0f
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2cd20
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_math.c
// Function: subtilis_parser_pi
subtilis_exp_t *subtilis_parser_pi(subtilis_parser_t *p, subtilis_token_t *t,
				   subtilis_error_t *err)
{
	subtilis_exp_t *e;

	e = subtilis_exp_new_real(22 / 7.0, 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 -0x20(%rbp), %rdi
movsd 0x7dc88(%rip), %xmm0    # 0xaa9d8
callq 0x37880
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2cd6c
movq $0x0, -0x8(%rbp)
jmp 0x2cda4
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 0x2cd9c
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x2cda4
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_math.c
// Function: subtilis_parser_int
subtilis_exp_t *subtilis_parser_int(subtilis_parser_t *p, subtilis_token_t *t,
				    subtilis_error_t *err)
{
	size_t reg;
	subtilis_exp_t *e = NULL;
	subtilis_exp_t *e2 = NULL;

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

	if (e->type.type == SUBTILIS_TYPE_CONST_REAL) {
		e2 = subtilis_exp_new_int32((int32_t)floor(e->exp.ir_op.real),
					    err);
	} else {
		reg = subtilis_ir_section_add_instr2(
		    p->current, SUBTILIS_OP_INSTR_MOV_FPRD_I32, e->exp.ir_op,
		    err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;

		e2 = subtilis_exp_new_int32_var(reg, err);
	}
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_exp_delete(e);

	return e2;

cleanup:

	subtilis_exp_delete(e);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x25190
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2cdff
movq $0x0, -0x8(%rbp)
jmp 0x2ce9e
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x2ce2c
movq -0x30(%rbp), %rax
movsd 0x148(%rax), %xmm0
callq 0x12230
cvttsd2si %xmm0, %edi
movq -0x20(%rbp), %rsi
callq 0x37800
movq %rax, -0x38(%rbp)
jmp 0x2ce6f
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x148(%rax), %rdx
movl $0x53, %esi
callq 0x38490
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2ce5c
jmp 0x2ce8d
movq -0x28(%rbp), %rax
movl %eax, %edi
movq -0x20(%rbp), %rsi
callq 0x37770
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2ce7a
jmp 0x2ce8d
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2ce9e
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_math.c
// Function: subtilis_parser_intz
subtilis_exp_t *subtilis_parser_intz(subtilis_parser_t *p, subtilis_token_t *t,
				     subtilis_error_t *err)
{
	subtilis_exp_t *e = NULL;

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

	return subtilis_type_if_zerox(p, e, &subtilis_type_integer, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x25000
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2cef4
movq $0x0, -0x8(%rbp)
jmp 0x2cf10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq 0x7e9c9(%rip), %rdx     # 0xab8d0
callq 0x48b30
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_math.c
// Function: prv_real_unary_fn
static subtilis_exp_t *prv_real_unary_fn(subtilis_parser_t *p,
					 subtilis_token_t *t,
					 subtilis_op_instr_type_t itype,
					 double (*const_fn)(double),
					 subtilis_error_t *err)
{
	size_t reg;
	subtilis_exp_t *e = NULL;
	subtilis_exp_t *e2 = NULL;

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

	if (e->type.type == SUBTILIS_TYPE_CONST_REAL) {
		e2 = subtilis_exp_new_real(const_fn(e->exp.ir_op.real), err);
	} else {
		reg = subtilis_ir_section_add_instr2(p->current, itype,
						     e->exp.ir_op, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;

		e2 = subtilis_exp_new_real_var(reg, err);
	}
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_exp_delete(e);

	return e2;

cleanup:

	subtilis_exp_delete(e);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x25190
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2cfb6
movq $0x0, -0x8(%rbp)
jmp 0x2d050
movq -0x40(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x2cfe0
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movsd 0x148(%rcx), %xmm0
callq *%rax
movq -0x30(%rbp), %rdi
callq 0x37880
movq %rax, -0x48(%rbp)
jmp 0x2d021
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x1c(%rbp), %esi
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x148(%rax), %rdx
callq 0x38490
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2d00e
jmp 0x2d03f
movq -0x38(%rbp), %rax
movl %eax, %edi
movq -0x30(%rbp), %rsi
callq 0x377d0
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2d02c
jmp 0x2d03f
movq -0x40(%rbp), %rdi
callq 0x36ee0
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2d050
movq -0x40(%rbp), %rdi
callq 0x36ee0
movq $0x0, -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_math.c
// Function: subtilis_parser_log
subtilis_exp_t *subtilis_parser_log(subtilis_parser_t *p, subtilis_token_t *t,
				    subtilis_op_instr_type_t itype,
				    double (*log_fn)(double),
				    subtilis_error_t *err)
{
	subtilis_exp_t *e;

	e = prv_real_unary_fn(p, t, itype, log_fn, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	subtilis_exp_handle_errors(p, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(e);
		return NULL;
	}
	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x2cf60
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2d1ea
movq $0x0, -0x8(%rbp)
jmp 0x2d21b
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x36ce0
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2d213
movq -0x38(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x2d21b
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_math.c
// Function: subtilis_parser_abs
subtilis_exp_t *subtilis_parser_abs(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_type_if_abs(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 0x2d2ec
movq $0x0, -0x8(%rbp)
jmp 0x2d301
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x49bb0
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_math.c
// Function: subtilis_parser_sgn
subtilis_exp_t *subtilis_parser_sgn(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_type_if_sgn(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 0x2d34c
movq $0x0, -0x8(%rbp)
jmp 0x2d361
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x49c00
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_error.c
// Function: subtilis_parser_get_err
subtilis_exp_t *subtilis_parser_get_err(subtilis_parser_t *p,
					subtilis_token_t *t,
					subtilis_error_t *err)
{
	subtilis_exp_t *e;

	e = subtilis_var_lookup_var(p, subtilis_err_hidden_var, 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), %rdi
leaq 0xa74b1(%rip), %rax     # 0xd4840
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x47240
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2d3b2
movq $0x0, -0x8(%rbp)
jmp 0x2d3ea
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 0x2d3e2
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x2d3ea
movq -0x28(%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_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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0xb8(%rax)
je 0x2d42b
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
testb $0x1, 0x60(%rax)
je 0x2d42d
jmp 0x2d45b
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rdx
movl $0x75, %esi
callq 0x385f0
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2d44e
jmp 0x2d45b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x36ce0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %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 0x2d7e3
jmp 0x2d857
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x24550
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2d803
jmp 0x2d857
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x488b0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2d82c
movq -0x20(%rbp), %rdi
callq 0x36ee0
jmp 0x2d857
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x37d10
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2d848
jmp 0x2d857
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movb $0x1, 0x88(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %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
callq 0x39940
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x68(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rax)
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 0x2db2b
jmp 0x2dbf7
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x78(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x37fd0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, 0x78(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2db69
jmp 0x2dbf7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x2a, %edx
callq 0x23b50
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2db8a
jmp 0x2dbf7
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 0x2dba9
jmp 0x2dbf7
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x39960
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2dbc9
jmp 0x2dbf7
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x473b0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2dbe3
jmp 0x2dbf7
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x68(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x68(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %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
callq 0x39940
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x68(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rax)
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 0x2dedb
jmp 0x2df8f
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x78(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x37fd0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, 0x78(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2df16
jmp 0x2df8f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x23bb0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2df32
jmp 0x2df8f
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movb $0x0, 0x88(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x39960
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2df61
jmp 0x2df8f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x473b0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2df7b
jmp 0x2df8f
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x68(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x68(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_graphics.c
// Function: subtilis_parser_get_tint
subtilis_exp_t *subtilis_parser_get_tint(subtilis_parser_t *p,
					 subtilis_token_t *t,
					 subtilis_error_t *err)
{
	if (!(p->backend.caps & SUBTILIS_BACKEND_HAVE_TINT)) {
		subtilis_error_set_not_supported(
		    err, "TINT on this target", p->l->stream->name, p->l->line);
		return NULL;
	}

	return subtilis_parser_bracketed_2_int_args(
	    p, t, SUBTILIS_OP_INSTR_TINT, 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), %rax
movl 0x8(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x2e042
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x13, %esi
leaq 0x7c9df(%rip), %rdx     # 0xaa9f8
leaq 0x7d256(%rip), %rcx     # 0xab276
leaq 0x7c9e5(%rip), %rax     # 0xaaa0c
movq %rax, (%rsp)
movl $0x25, 0x8(%rsp)
callq 0x156d0
movq $0x0, -0x8(%rbp)
jmp 0x2e05c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x73, %edx
callq 0x24cb0
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_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 %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 0x2e0a3
jmp 0x2e114
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x24a80
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2e0c3
jmp 0x2e114
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x148(%rax), %rdx
movl $0x55, %esi
callq 0x38540
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2e0ef
jmp 0x2e10b
movq -0x8(%rbp), %rax
testb $0x1, 0xb9(%rax)
jne 0x2e109
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36ce0
jmp 0x2e10b
movq -0x20(%rbp), %rdi
callq 0x36ee0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %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 0x2e166
jmp 0x2e214
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq -0x18(%rbp), %r8
movl $0x3, %ecx
callq 0x24b30
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2e18b
jmp 0x2e1e9
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %r9
movq 0x148(%rdx), %rdx
movq 0x148(%rcx), %rcx
movq 0x148(%rax), %r8
movl $0x56, %esi
callq 0x38360
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2e1cd
jmp 0x2e1e9
movq -0x8(%rbp), %rax
testb $0x1, 0xb9(%rax)
jne 0x2e1e7
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36ce0
jmp 0x2e1e9
movq $0x0, -0x20(%rbp)
cmpq $0x3, -0x20(%rbp)
jae 0x2e214
movq -0x20(%rbp), %rax
movq -0x40(%rbp,%rax,8), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2e1f1
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %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 $0x5f, %esi
callq 0x385f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2e255
jmp 0x2e290
movq -0x8(%rbp), %rax
testb $0x1, 0xb9(%rax)
jne 0x2e27c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36ce0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2e27a
jmp 0x2e290
jmp 0x2e27c
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)