LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_exp.c
// Function: prv_priority4
static subtilis_exp_t *prv_priority4(subtilis_parser_t *p, subtilis_token_t *t,
				     subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_exp_t *e1 = NULL;
	subtilis_exp_t *e2 = NULL;
	subtilis_exp_fn_t exp_fn;

	e1 = prv_priority3(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	tbuf = subtilis_token_get_text(t);

	/*
	 * Special case for number too big.
	 */

	if ((t->type == SUBTILIS_TOKEN_INTEGER) &&
	    (t->tok.integer == -2147483648)) {
		subtilis_error_set_number_too_long(
		    err, tbuf, p->l->stream->name, p->l->line);
		goto cleanup;
	}

	while (t->type == SUBTILIS_TOKEN_OPERATOR) {
		tbuf = subtilis_token_get_text(t);
		if (!strcmp(tbuf, "+"))
			exp_fn = subtilis_exp_add;
		else if (!strcmp(tbuf, "-"))
			exp_fn = subtilis_type_if_sub;
		else
			break;
		subtilis_lexer_get(p->l, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		e2 = prv_priority3(p, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;

		e1 = exp_fn(p, e1, e2, err);
		e2 = NULL;
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	return e1;

cleanup:

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0x1fcd9
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1fbfe
xorl %eax, %eax
movq %rax, %rdi
callq 0x2b166
movq %rbx, %rdi
callq 0x2b166
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x12ad0
cmpl $0x4, (%r12)
jne 0x1fc4c
xorl %ecx, %ecx
cmpl 0x8(%r12), %ecx
jno 0x1fc4c
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x53cb8(%rip), %r10     # 0x738e0
leaq 0x541e6(%rip), %rcx     # 0x73e15
movq %r14, %rdi
movl $0x8, %esi
movq %rax, %rdx
pushq $0x295                  # imm = 0x295
pushq %r10
callq 0x143da
addq $0x10, %rsp
jmp 0x1fbdd
cmpl $0x2, (%r12)
jne 0x1fbf1
movq %r12, %rdi
callq 0x12ad0
movzbl (%rax), %ecx
cmpl $0x2d, %ecx
je 0x1fc77
cmpl $0x2b, %ecx
jne 0x1fbf1
cmpb $0x0, 0x1(%rax)
jne 0x1fbf1
leaq 0xbdc2(%rip), %r13      # 0x2ba37
jmp 0x1fc88
cmpb $0x0, 0x1(%rax)
jne 0x1fbf1
leaq 0x1715c(%rip), %r13     # 0x36de4
movq (%r15), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x12edc
cmpl $0x0, (%r14)
jne 0x1fbdd
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1fcd9
cmpl $0x0, (%r14)
jne 0x1fbdf
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq *%r13
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1fc4c
jmp 0x1fbdd
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_exp.c
// Function: prv_priority3
static subtilis_exp_t *prv_priority3(subtilis_parser_t *p, subtilis_token_t *t,
				     subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_exp_t *e1 = NULL;
	subtilis_exp_t *e2 = NULL;
	subtilis_exp_fn_t exp_fn;

	e1 = prv_priority2(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	while ((t->type == SUBTILIS_TOKEN_OPERATOR) ||
	       (t->type == SUBTILIS_TOKEN_KEYWORD)) {
		tbuf = subtilis_token_get_text(t);
		if (t->type == SUBTILIS_TOKEN_KEYWORD) {
			if (t->tok.keyword.type == SUBTILIS_KEYWORD_DIV)
				exp_fn = subtilis_type_if_div;
			else if (t->tok.keyword.type == SUBTILIS_KEYWORD_MOD)
				exp_fn = subtilis_type_if_mod;
			else
				break;
		} else if (!strcmp(tbuf, "*")) {
			exp_fn = subtilis_type_if_mul;
		} else if (!strcmp(tbuf, "/")) {
			exp_fn = subtilis_type_if_divr;
		} else {
			break;
		}
		subtilis_lexer_get(p->l, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		e2 = prv_priority2(p, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;

		e1 = exp_fn(p, e1, e2, err);
		e2 = NULL;
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	return e1;

cleanup:

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x1fdd4
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1fd21
xorl %eax, %eax
movq %rax, %rdi
callq 0x2b166
movq %rbx, %rdi
callq 0x2b166
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17106(%rip), %r13     # 0x36e2e
movl (%r15), %eax
decl %eax
cmpl $0x1, %eax
ja 0x1fd0f
movq %r15, %rdi
callq 0x12ad0
cmpl $0x1, (%r15)
jne 0x1fd5a
movl 0x8(%r15), %eax
movq %r13, %rbp
cmpl $0x20, %eax
je 0x1fd83
cmpl $0x4d, %eax
jne 0x1fd0f
leaq 0x17156(%rip), %rbp     # 0x36eae
jmp 0x1fd83
movzbl (%rax), %ecx
cmpl $0x2f, %ecx
je 0x1fd76
cmpl $0x2a, %ecx
jne 0x1fd0f
cmpb $0x0, 0x1(%rax)
leaq 0x16e55(%rip), %rbp     # 0x36bc7
je 0x1fd83
jmp 0x1fd0f
cmpb $0x0, 0x1(%rax)
leaq 0x171ad(%rip), %rbp     # 0x36f2e
jne 0x1fd0f
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12edc
cmpl $0x0, (%r14)
jne 0x1fcfb
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1fdd4
cmpl $0x0, (%r14)
jne 0x1fcfd
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq *%rbp
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1fd28
jmp 0x1fcfb
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_exp.c
// Function: prv_priority2
static subtilis_exp_t *prv_priority2(subtilis_parser_t *p, subtilis_token_t *t,
				     subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_exp_t *e1 = NULL;
	subtilis_exp_t *e2 = NULL;

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

	while (t->type == SUBTILIS_TOKEN_OPERATOR) {
		tbuf = subtilis_token_get_text(t);
		if (strcmp(tbuf, "^"))
			break;

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

		e1 = subtilis_type_if_pow(p, e1, e2, err);
		e2 = NULL;
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	return e1;

cleanup:

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x1fe6b
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x1fe48
cmpl $0x2, (%r15)
jne 0x1fe5c
movq %r15, %rdi
callq 0x12ad0
cmpb $0x5e, (%rax)
jne 0x1fe5c
cmpb $0x0, 0x1(%rax)
jne 0x1fe5c
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12edc
cmpl $0x0, (%r14)
jne 0x1fe48
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1fe6b
cmpl $0x0, (%r14)
jne 0x1fe4a
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x371ae
jmp 0x1fdea
xorl %eax, %eax
movq %rax, %rdi
callq 0x2b166
movq %rbx, %rdi
callq 0x2b166
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_exp.c
// Function: prv_not_exp
static subtilis_exp_t *prv_not_exp(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 NULL;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x12edc
cmpl $0x0, (%rbx)
jne 0x20aa4
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1fe6b
cmpl $0x0, (%rbx)
je 0x20aac
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x36d38
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_exp.c
// Function: prv_gettime
static subtilis_exp_t *prv_gettime(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_GETTIME, 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);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

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

	return e;

on_error:
	subtilis_exp_delete(e);
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x48(%rdi), %rdi
movl $0x5a, %esi
callq 0x2be13
cmpl $0x0, (%rbx)
jne 0x20b25
movq %rax, %r15
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2b01f
cmpl $0x0, (%rbx)
jne 0x20b25
movl %r15d, %edi
movq %rbx, %rsi
callq 0x2b71f
cmpl $0x0, (%rbx)
jne 0x20b25
movq %rax, %r15
movq (%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12edc
cmpl $0x0, (%rbx)
je 0x20b28
movq %r15, %rdi
callq 0x2b166
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_file.c
// Function: prv_open
static subtilis_exp_t *prv_open(subtilis_parser_t *p, subtilis_token_t *t,
				subtilis_op_instr_type_t itype,
				subtilis_error_t *err)
{
	subtilis_exp_t *file_name;
	size_t ret;
	subtilis_exp_t *handle = NULL;

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

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

	ret = subtilis_ir_section_add_instr2(p->current, itype,
					     file_name->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

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

	handle = subtilis_exp_new_int32_var(ret, err);

cleanup:

	subtilis_exp_delete(file_name);

	return handle;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %r15
movq %rcx, %rdx
callq 0x1efbe
cmpl $0x0, (%r14)
je 0x20b68
xorl %r14d, %r14d
jmp 0x20c06
movq %rax, %rbx
movl (%rax), %eax
cmpl $0x3, %eax
je 0x20b87
cmpl $0x7, %eax
jne 0x20bd7
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x48a82
jmp 0x20b95
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4869c
movq %rax, %rbx
movq 0x48(%r15), %rdi
movq 0x148(%rax), %rdx
movl %ebp, %esi
movq %r14, %rcx
callq 0x2be09
cmpl $0x0, (%r14)
jne 0x20bfb
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x2b01f
cmpl $0x0, (%r14)
jne 0x20bfb
movl %r12d, %edi
movq %r14, %rsi
callq 0x2b71f
movq %rax, %r14
jmp 0x20bfe
movq (%r15), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x52d55(%rip), %r8      # 0x7393d
movq %r14, %rdi
movl $0x49, %esi
movl $0x2c, %r9d
callq 0x145c8
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x2b166
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_file.c
// Function: subtilis_parser_close
void subtilis_parser_close(subtilis_parser_t *p, subtilis_token_t *t,
			   subtilis_error_t *err)
{
	subtilis_ir_operand_t handle;

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

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

	subtilis_exp_handle_errors(p, err);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x20c73
cmpl $0x0, (%rbx)
jne 0x20c59
movq 0x48(%r14), %rdi
movl $0x8e, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x2be1f
cmpl $0x0, (%rbx)
je 0x20c61
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2b01f
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_file.c
// Function: prv_parse_handle
static subtilis_ir_operand_t prv_parse_handle(subtilis_parser_t *p,
					      subtilis_token_t *t,
					      subtilis_error_t *err)
{
	subtilis_exp_t *handle;
	subtilis_ir_operand_t ret;

	ret.reg = SIZE_MAX;

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

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

	ret = handle->exp.ir_op;

	subtilis_exp_delete(handle);

	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
callq 0x12edc
movq $-0x1, %rbx
cmpl $0x0, (%r14)
jne 0x20cbc
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1ec82
cmpl $0x0, (%r14)
jne 0x20cbc
movq 0x148(%rax), %rbx
movq %rax, %rdi
callq 0x2b166
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_file.c
// Function: parse_1arg_bkt_file_op
static subtilis_exp_t *parse_1arg_bkt_file_op(subtilis_parser_t *p,
					      subtilis_token_t *t,
					      subtilis_op_instr_type_t itype,
					      subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_exp_t *e;

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

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

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

	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);
		goto cleanup;
	}

	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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
movq %rcx, %rdx
callq 0x12edc
cmpl $0x0, (%rbx)
jne 0x20d45
movq %r14, %rdi
callq 0x12ad0
cmpl $0x2, (%r14)
jne 0x20d11
cmpb $0x28, (%rax)
jne 0x20d11
cmpb $0x0, 0x1(%rax)
je 0x20d54
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x52c1a(%rip), %r10     # 0x7393d
leaq 0x52bcc(%rip), %rdx     # 0x738f6
movq %rbx, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0xa6
pushq %r10
callq 0x143da
addq $0x10, %rsp
xorl %r12d, %r12d
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x20c73
cmpl $0x0, (%rbx)
jne 0x20d45
movq 0x48(%r15), %rdi
movl %ebp, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x2be09
cmpl $0x0, (%rbx)
jne 0x20d45
movq %rax, %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2b01f
cmpl $0x0, (%rbx)
jne 0x20d45
movl %r12d, %edi
movq %rbx, %rsi
callq 0x2b71f
cmpl $0x0, (%rbx)
jne 0x20d45
movq %rax, %r12
movq %r14, %rdi
callq 0x12ad0
cmpl $0x2, (%r14)
jne 0x20dbc
cmpb $0x29, (%rax)
jne 0x20dbc
cmpb $0x0, 0x1(%rax)
je 0x20dfd
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x52b6f(%rip), %r10     # 0x7393d
leaq 0x5627d(%rip), %rdx     # 0x77052
movq %rbx, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0xb1
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %r12, %rdi
callq 0x2b166
jmp 0x20d45
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12edc
cmpl $0x0, (%rbx)
jne 0x20df0
jmp 0x20d48
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_file.c
// Function: subtilis_parser_bput
void subtilis_parser_bput(subtilis_parser_t *p, subtilis_token_t *t,
			  subtilis_error_t *err)
{
	subtilis_ir_operand_t handle;
	const char *tbuf;
	subtilis_exp_t *val;

	handle = prv_parse_handle(p, 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;
	}

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

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

	subtilis_ir_section_add_instr_no_reg2(
	    p->current, SUBTILIS_OP_INSTR_BPUT, val->exp.ir_op, handle, err);
	subtilis_exp_delete(val);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_exp_handle_errors(p, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
callq 0x20c73
cmpl $0x0, (%rbx)
je 0x20e36
addq $0x8, %rsp
jmp 0x20e87
movq %rax, %r15
movq %r12, %rdi
callq 0x12ad0
cmpl $0x2, (%r12)
jne 0x20e53
cmpb $0x2c, (%rax)
jne 0x20e53
cmpb $0x0, 0x1(%rax)
je 0x20e8f
movq (%r14), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x52ad8(%rip), %r10     # 0x7393d
leaq 0x52726(%rip), %rdx     # 0x73592
movq %rbx, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0xd4
pushq %r10
callq 0x143da
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r14), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x12edc
cmpl $0x0, (%rbx)
jne 0x20e30
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1ec82
cmpl $0x0, (%rbx)
jne 0x20e30
movq %rax, %r12
movq 0x48(%r14), %rdi
movq 0x148(%rax), %rdx
movl $0x90, %esi
movq %r15, %rcx
movq %rbx, %r8
callq 0x2be2c
movq %r12, %rdi
callq 0x2b166
cmpl $0x0, (%rbx)
jne 0x20e30
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2b01f
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_file.c
// Function: subtilis_parser_put_hash
void subtilis_parser_put_hash(subtilis_parser_t *p, subtilis_token_t *t,
			      subtilis_error_t *err)
{
	subtilis_ir_operand_t handle;
	subtilis_ir_operand_t data;
	subtilis_ir_operand_t skip_label;
	subtilis_ir_operand_t array_size;
	subtilis_ir_operand_t put_label;
	bool check_dims;
	bool arg1_tmp;
	size_t val_reg;
	size_t el_size;
	bool cow = false;

	skip_label.label = subtilis_ir_section_new_label(p->current);
	put_label.label = subtilis_ir_section_new_label(p->current);

	check_dims =
	    prv_block_operation_prep(p, t, &handle, &array_size, &val_reg, &cow,
				     &arg1_tmp, &el_size, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (check_dims) {
		subtilis_ir_section_add_instr_reg(
		    p->current, SUBTILIS_OP_INSTR_JMPC, array_size, put_label,
		    skip_label, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;

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

	data.reg = subtilis_reference_get_data(p, val_reg, 0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_instr_reg(p->current,
					  SUBTILIS_OP_INSTR_BLOCK_PUT, handle,
					  data, array_size, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

	if (check_dims)
		subtilis_ir_section_add_label(p->current, skip_label.label,
					      err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
movq 0x48(%rdi), %rdi
callq 0x2cc99
movq %rax, %r15
movq 0x48(%r14), %rdi
callq 0x2cc99
movq %rax, %r12
subq $0x8, %rsp
leaq 0x28(%rsp), %rax
leaq 0xf(%rsp), %r10
leaq 0x20(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0x18(%rsp), %r8
leaq 0xe(%rsp), %r9
movq %r14, %rdi
movq %r13, %rsi
pushq %rbx
pushq %rax
pushq %r10
callq 0x212eb
addq $0x20, %rsp
cmpl $0x0, (%rbx)
je 0x21515
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebp
testb %al, %al
je 0x21550
movq 0x48(%r14), %rdi
movq 0x8(%rsp), %rdx
movl $0x43, %esi
movq %r12, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0x2bd42
cmpl $0x0, (%rbx)
jne 0x21506
movq 0x48(%r14), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2cca6
cmpl $0x0, (%rbx)
jne 0x21506
movq 0x10(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x4d258
cmpl $0x0, (%rbx)
jne 0x21506
movq 0x48(%r14), %rdi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %r8
movl $0x92, %esi
movq %rax, %rcx
movq %rbx, %r9
callq 0x2bd42
cmpl $0x0, (%rbx)
jne 0x21506
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b01f
cmpl $0x0, (%rbx)
sete %al
andb %bpl, %al
cmpb $0x1, %al
jne 0x21506
movq 0x48(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2cca6
nop
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_loops.c
// Function: prv_numeric_expression
static subtilis_exp_t *prv_numeric_expression(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 NULL;
	e = subtilis_parser_priority7(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	if (!subtilis_type_if_is_numeric(&e->type)) {
		subtilis_exp_delete(e);
		subtilis_error_set_numeric_exp_expected(err, p->l->stream->name,
							p->l->line);
		return NULL;
	}

	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x12edc
cmpl $0x0, (%rbx)
jne 0x22059
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1e938
cmpl $0x0, (%rbx)
jne 0x22059
movq %rax, %r15
movq %rax, %rdi
callq 0x37534
testb %al, %al
jne 0x2205c
movq %r15, %rdi
callq 0x2b166
movq (%r14), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x51946(%rip), %r8      # 0x7398c
movq %rbx, %rdi
movl $0x44, %esi
movl $0x2e, %r9d
callq 0x145c8
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_loops.c
// Function: prv_for_step_const
static void prv_for_step_const(subtilis_parser_t *p, subtilis_token_t *t,
			       subtilis_exp_t *to, subtilis_exp_t *step,
			       subtilis_step_type_t step_type,
			       const subtilis_for_context_t *for_ctx,
			       subtilis_error_t *err)
{
	subtilis_ir_operand_t start_label;
	subtilis_ir_operand_t true_label;
	subtilis_exp_t *conde = NULL;
	subtilis_exp_t *var = NULL;

	prv_for_loop_start(p, t, &start_label, &true_label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	var = prv_increment_var(p, step, for_ctx, err);
	step = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	if (step_type == SUBTILIS_STEP_CONST_INC) {
		conde = subtilis_exp_gt(p, var, to, err);
		var = NULL;
		to = NULL;
	} else {
		conde = subtilis_exp_lt(p, var, to, err);
		var = NULL;
		to = NULL;
	}
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

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

	subtilis_ir_section_add_label(p->current, true_label.reg, err);

cleanup:

	subtilis_exp_delete(conde);
	subtilis_exp_delete(var);
	subtilis_exp_delete(to);
	subtilis_exp_delete(step);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbp
movl %r8d, %r12d
movq %rcx, %r13
movq %rdx, %rbx
movq %rdi, %r15
movq 0x50(%rsp), %r14
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r14, %r8
callq 0x23ae5
cmpl $0x0, (%r14)
je 0x22944
xorl %r12d, %r12d
xorl %ebp, %ebp
jmp 0x22964
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x23b5f
movq %rax, %rbp
cmpl $0x0, (%r14)
je 0x22992
xorl %r13d, %r13d
xorl %r12d, %r12d
movq %r12, %rdi
callq 0x2b166
movq %rbp, %rdi
callq 0x2b166
movq %rbx, %rdi
callq 0x2b166
movq %r13, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b166
movq %r15, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r14, %rcx
testl %r12d, %r12d
je 0x229aa
callq 0x2ba46
jmp 0x229af
callq 0x2ba3c
movq %rax, %r12
cmpl $0x0, (%r14)
jne 0x229f3
movq 0x48(%r15), %rdi
movq 0x148(%r12), %rdx
movq 0x8(%rsp), %rbx
movq 0x10(%rsp), %r8
movl $0x43, %esi
movq %rbx, %rcx
movq %r14, %r9
callq 0x2bd42
cmpl $0x0, (%r14)
jne 0x229f3
movq 0x48(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2cca6
xorl %r13d, %r13d
xorl %ebx, %ebx
jmp 0x22940
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_loops.c
// Function: prv_for_no_step
static void prv_for_no_step(subtilis_parser_t *p, subtilis_token_t *t,
			    subtilis_exp_t *to,
			    const subtilis_for_context_t *for_ctx,
			    subtilis_error_t *err)
{
	subtilis_ir_operand_t start_label;
	subtilis_ir_operand_t true_label;
	subtilis_exp_t *inc = NULL;
	subtilis_exp_t *var = NULL;
	subtilis_exp_t *conde = NULL;

	prv_for_loop_start(p, t, &start_label, &true_label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	inc = subtilis_exp_new_int32(1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	var = prv_increment_var(p, inc, for_ctx, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	conde = subtilis_exp_gt(p, var, to, err);
	var = NULL;
	to = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

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

	subtilis_ir_section_add_label(p->current, true_label.reg, err);

cleanup:

	subtilis_exp_delete(conde);
	subtilis_exp_delete(var);
	subtilis_exp_delete(to);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %rdx
movq %rsp, %rcx
callq 0x23ae5
cmpl $0x0, (%r14)
jne 0x22a3c
movl $0x1, %edi
movq %r14, %rsi
callq 0x2b7af
cmpl $0x0, (%r14)
je 0x22a67
xorl %r13d, %r13d
xorl %r12d, %r12d
movq %r12, %rdi
callq 0x2b166
movq %r13, %rdi
callq 0x2b166
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b166
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x23b5f
movq %rax, %r13
cmpl $0x0, (%r14)
jne 0x22a3f
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x2ba3c
movq %rax, %r12
cmpl $0x0, (%r14)
jne 0x22ad5
movq 0x48(%r15), %rdi
movq 0x148(%r12), %rdx
movq (%rsp), %rbx
movq 0x8(%rsp), %r8
movl $0x43, %esi
movq %rbx, %rcx
movq %r14, %r9
callq 0x2bd42
cmpl $0x0, (%r14)
jne 0x22ad5
movq 0x48(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2cca6
xorl %ebx, %ebx
xorl %r13d, %r13d
jmp 0x22a42
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_loops.c
// Function: subtilis_parser_while
void subtilis_parser_while(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;
	subtilis_ir_operand_t false_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;

	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);
	false_label.reg = subtilis_ir_section_new_label(p->current);

	subtilis_ir_section_add_instr_reg(p->current, SUBTILIS_OP_INSTR_JMPC,
					  cond, true_label, false_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;

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

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

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

	subtilis_ir_section_add_label(p->current, false_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;

cleanup:
	subtilis_exp_delete(e);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x48(%rdi), %rdi
callq 0x2cc99
movq %rax, %r13
movq 0x48(%r12), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2cca6
cmpl $0x0, (%r14)
je 0x22b24
xorl %ebx, %ebx
movq %rbx, %rdi
callq 0x2b166
jmp 0x22b3d
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x1e3d8
cmpl $0x0, (%r14)
je 0x22b4c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%r12), %rdi
callq 0x2cc99
movq %rax, %rbp
movq 0x48(%r12), %rdi
callq 0x2cc99
movq 0x48(%r12), %rdi
movq 0x10(%rsp), %rdx
movl $0x43, %esi
movq %rbp, 0x8(%rsp)
movq %rbp, %rcx
movq %rax, %rbp
movq %rax, %r8
movq %r14, %r9
callq 0x2bd42
cmpl $0x0, (%r14)
jne 0x22b1a
movq %rbp, (%rsp)
movq 0x48(%r12), %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x2cca6
cmpl $0x0, (%r14)
jne 0x22b1a
movq %r12, %rdi
movq %r14, %rsi
callq 0x245ff
cmpl $0x0, (%r14)
jne 0x22b1a
movq %r12, %rdi
movq %r15, %rsi
movl $0x2b, %edx
movq %r14, %rcx
callq 0x1e3ce
cmpl $0x0, (%r14)
jne 0x22b1a
movq 0x48(%r12), %rdi
movl $0x45, %esi
movq %r13, %rdx
movq %r14, %rcx
callq 0x2be1f
cmpl $0x0, (%r14)
jne 0x22b1a
movq 0x48(%r12), %rdi
movq (%rsp), %rsi
movq %r14, %rdx
callq 0x2cca6
cmpl $0x0, (%r14)
jne 0x22b1a
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12edc
jmp 0x22b1a
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x48(%rdi), %rdi
callq 0x2cc99
movq %rax, %r15
movq 0x48(%r14), %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x2cca6
cmpl $0x0, (%rbx)
jne 0x22ca2
movq (%r14), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x12edc
cmpl $0x0, (%rbx)
jne 0x22ca2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x245ff
cmpl $0x0, (%rbx)
jne 0x22ca2
movq %r14, %rdi
movq %r12, %rsi
movl $0x8b, %edx
movq %rbx, %rcx
callq 0x1e3ce
cmpl $0x0, (%rbx)
je 0x22cbb
xorl %r12d, %r12d
movq %r12, %rdi
callq 0x2b166
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rcx
callq 0x1e3d8
cmpl $0x0, (%rbx)
jne 0x22cad
movq %rax, %r12
movq 0x48(%r14), %rdi
callq 0x2cc99
movq %rax, %r13
movq 0x48(%r14), %rdi
movq 0x8(%rsp), %rdx
movl $0x43, %esi
movq %rax, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0x2bd42
cmpl $0x0, (%rbx)
jne 0x22ca5
movq 0x48(%r14), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2cca6
jmp 0x22ca5
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
movq 0x48(%rdi), %rdi
callq 0x2cc99
movq %rax, (%r13)
movq 0x48(%r14), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x2cca6
cmpl $0x0, (%r15)
jne 0x23b55
movq %r14, %rdi
movq %r15, %rsi
callq 0x245ff
cmpl $0x0, (%r15)
jne 0x23b55
movq %r14, %rdi
movq %r12, %rsi
movl $0x51, %edx
movq %r15, %rcx
callq 0x1e21c
cmpl $0x0, (%r15)
jne 0x23b55
movq 0x48(%r14), %rdi
callq 0x2cc99
movq %rax, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_loops.c
// Function: prv_increment_var
static subtilis_exp_t *prv_increment_var(subtilis_parser_t *p,
					 subtilis_exp_t *inc,
					 const subtilis_for_context_t *for_ctx,
					 subtilis_error_t *err)
{
	subtilis_exp_t *var = NULL;
	subtilis_exp_t *e = NULL;

	if (for_ctx->is_reg)
		var = subtilis_exp_new_var(&for_ctx->type, for_ctx->loc, err);
	else
		var = subtilis_type_if_load_from_mem(
		    p, &for_ctx->type, for_ctx->reg, for_ctx->loc, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	e = subtilis_exp_add(p, var, inc, err);
	var = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

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

	if (for_ctx->is_reg) {
		subtilis_type_if_assign_to_reg(p, for_ctx->loc, e, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		var = subtilis_exp_new_var(&for_ctx->type, for_ctx->loc, err);
	} else {
		var = subtilis_type_if_dup(e, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		subtilis_type_if_assign_to_mem(p, for_ctx->reg, for_ctx->loc, e,
					       err);
	}

	return var;

cleanup:

	subtilis_exp_delete(var);
	subtilis_exp_delete(inc);

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x18(%rdx), %r13
cmpb $0x1, (%rdx)
jne 0x23b90
movl 0x10(%r15), %esi
movq %r13, %rdi
movq %r14, %rdx
callq 0x2b5fb
jmp 0x23ba6
movq 0x8(%r15), %rdx
movq 0x10(%r15), %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %r8
callq 0x36372
movq %rax, %rbp
cmpl $0x0, (%r14)
jne 0x23bdf
movq %r12, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x2ba37
cmpl $0x0, (%r14)
jne 0x23bdd
movq %r12, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x37860
cmpl $0x0, (%r14)
je 0x23c03
xorl %ebp, %ebp
movq %rbp, %rdi
callq 0x2b166
movq %rbx, %rdi
callq 0x2b166
xorl %ebp, %ebp
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x1, (%r15)
jne 0x23c3e
movq 0x10(%r15), %rsi
movq %r12, %rdi
movq %rax, %rdx
movq %r14, %rcx
callq 0x36292
cmpl $0x0, (%r14)
jne 0x23bdd
movl 0x10(%r15), %esi
movq %r13, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b5fb
movq %rax, %rdi
movq %r14, %rsi
movq %rax, %r13
callq 0x36182
movq %rax, %rbp
cmpl $0x0, (%r14)
jne 0x23bdf
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %r12, %rdi
movq %r13, %rcx
movq %r14, %r8
callq 0x362c6
jmp 0x23bf1
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r15
leaq 0x168(%rsi), %rdi
movq %r9, %rsi
callq 0x35d88
cmpl $0x0, (%rbx)
jne 0x23ffb
movq 0x48(%r15), %rdi
movl %eax, %r8d
movl $0x9, %esi
movq %r13, %rdx
movq %r13, %rcx
movq %rbx, %r9
callq 0x2bd42
cmpl $0x0, (%rbx)
jne 0x23ffb
movq 0x48(%r15), %rdi
movl $0x45, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2be1f
cmpl $0x0, (%rbx)
je 0x24005
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x48(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2cca6
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0x168(%rdx), %rdi
movq %r8, %rsi
callq 0x35d88
cmpl $0x0, (%rbx)
jne 0x24068
movq 0x48(%r15), %rdi
movl %eax, %r8d
movl $0x9, %esi
movq %r13, %rdx
movq %r13, %rcx
movq %rbx, %r9
callq 0x2bd42
cmpl $0x0, (%rbx)
je 0x24072
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
imulq $0x2c8, %r14, %rax      # imm = 0x2C8
addq %rax, %r12
addq $-0x178, %r12           # imm = 0xFE88
decq %r14
je 0x24068
movl $0x1, %edi
movq %rbx, %rsi
callq 0x2b7af
cmpl $0x0, (%rbx)
jne 0x24068
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x23b5f
cmpl $0x0, (%rbx)
jne 0x24068
movq %rax, %rdi
callq 0x2b166
movq 0x48(%r15), %rdi
movq 0x160(%r12), %rdx
movl $0x45, %esi
movq %rbx, %rcx
callq 0x2be1f
cmpl $0x0, (%rbx)
jne 0x24068
movq 0x48(%r15), %rdi
movq 0x168(%r12), %rsi
addq $-0x2c8, %r12           # imm = 0xFD38
movq %rbx, %rdx
callq 0x2cca6
cmpl $0x0, (%rbx)
je 0x24083
jmp 0x24068
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_loops.c
// Function: prv_assign_range_var
static void prv_assign_range_var(subtilis_parser_t *p,
				 subtilis_ir_operand_t ptr,
				 const subtilis_range_var_t *var,
				 bool new_locals, subtilis_error_t *err)
{
	subtilis_exp_t *val;

	if (var->for_ctx.type.type == SUBTILIS_TYPE_REC) {
		if (new_locals)
			/*
			 * Special handling for RECs.  We just memcpy.
			 */

			subtilis_rec_type_tmp_copy(
			    p, &var->for_ctx.type, var->for_ctx.reg,
			    var->for_ctx.loc, ptr.reg, err);
		else
			subtilis_rec_type_copy(
			    p, &var->for_ctx.type, var->for_ctx.reg,
			    var->for_ctx.loc, ptr.reg, false, err);
		return;
	}

	val = subtilis_type_if_load_from_mem(p, &var->for_ctx.type, ptr.reg, 0,
					     err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (!subtilis_type_if_is_numeric(&var->for_ctx.type) &&
	    var->for_ctx.type.type != SUBTILIS_TYPE_FN) {
		/*
		 * If we have a reference type and it's a new local, there's
		 * no need to go through all the reference counting.  We know
		 * that the array has references to every element we're
		 * iterating through, so this saves some code.
		 */

		if (!new_locals)
			subtilis_type_if_assign_ref(p, &var->type,
						    var->for_ctx.reg,
						    var->for_ctx.loc, val, err);
		else
			subtilis_type_if_assign_ref_no_rc(
			    p, &var->type, var->for_ctx.reg, var->for_ctx.loc,
			    val, err);

	} else if (var->for_ctx.is_reg) {
		subtilis_type_if_assign_to_reg(p, var->for_ctx.loc, val, err);
	} else {
		subtilis_type_if_assign_to_mem(p, var->for_ctx.reg,
					       var->for_ctx.loc, val, err);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r8
movq %rdi, %r14
leaq 0x168(%rdx), %r13
cmpl $0x16, 0x168(%rdx)
jne 0x24155
movq 0x158(%r12), %rdx
movq 0x160(%r12), %rcx
testb %bpl, %bpl
je 0x241b2
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x460b1
movq %r14, %rdi
movq %r13, %rsi
movq %r8, %rdx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x36372
cmpl $0x0, (%rbx)
jne 0x241c4
movq %rax, %r15
movq %r13, %rdi
callq 0x37534
testb %al, %al
jne 0x24183
cmpl $0x9, (%r13)
jne 0x241ff
cmpb $0x1, 0x150(%r12)
jne 0x241d3
movq 0x160(%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x36292
movq %rbx, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
xorl %r9d, %r9d
callq 0x45fae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x158(%r12), %rsi
movq 0x160(%r12), %rdx
movq %r14, %rdi
movq %r15, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x362c6
leaq 0x8(%r12), %rsi
movq 0x158(%r12), %rdx
movq 0x160(%r12), %rcx
movq %r14, %rdi
movq %r15, %r8
movq %rbx, %r9
addq $0x8, %rsp
testb %bpl, %bpl
je 0x24235
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x35f21
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x35ef0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %r15
callq 0x1f09e
cmpl $0x0, (%r14)
je 0x2425f
xorl %r15d, %r15d
jmp 0x242c2
movq %rax, %rbx
cmpl $0x0, (%rax)
je 0x24282
movsd 0x4f741(%rip), %xmm0    # 0x739b0
movq %r14, %rdi
callq 0x2b7fe
cmpl $0x0, (%r14)
je 0x2429c
xorl %r15d, %r15d
jmp 0x242ba
movsd 0x148(%rbx), %xmm0
mulsd 0x4f71e(%rip), %xmm0    # 0x739b0
movq %r14, %rdi
callq 0x2b7fe
jmp 0x242af
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x36bc7
xorl %ebx, %ebx
xorl %r15d, %r15d
cmpl $0x0, (%r14)
cmoveq %rax, %r15
movq %rbx, %rdi
callq 0x2b166
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movsd 0x4f6d4(%rip), %xmm0    # 0x739b8
movq %rdx, %rdi
callq 0x2b7fe
cmpl $0x0, (%r14)
jne 0x24312
movq %rax, %rbx
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12edc
cmpl $0x0, (%r14)
je 0x24314
movq %rbx, %rdi
callq 0x2b166
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %r15
callq 0x1f09e
cmpl $0x0, (%r14)
je 0x2433e
xorl %r15d, %r15d
jmp 0x2439d
movq %rax, %rbx
cmpl $0x0, (%rax)
je 0x24370
movq 0x48(%r15), %rdi
movq 0x148(%rbx), %rdx
movl $0x53, %esi
movq %r14, %rcx
callq 0x2be09
cmpl $0x0, (%r14)
jne 0x24392
movl %eax, %edi
movq %r14, %rsi
callq 0x2b71f
jmp 0x24389
movsd 0x148(%rbx), %xmm0
callq 0x12260
cvttsd2si %xmm0, %edi
movq %r14, %rsi
callq 0x2b7af
movq %rax, %r15
cmpl $0x0, (%r14)
je 0x24395
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x2b166
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq