LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x1fdd7
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x1fdb1
movl (%r15), %eax
decl %eax
cmpl $0x1, %eax
ja 0x1fdc5
movq %r15, %rdi
callq 0x12ad0
cmpl $0x1, (%r15)
jne 0x1fd3d
movl 0x8(%r15), %eax
leaq 0x17247(%rip), %r13     # 0x36f6d
cmpl $0x20, %eax
je 0x1fd74
cmpl $0x4d, %eax
jne 0x1fdc5
leaq 0x172b2(%rip), %r13     # 0x36fed
jmp 0x1fd74
movq %rax, %rbp
movq %rax, %rdi
leaq 0x58fa4(%rip), %rsi     # 0x78cee
callq 0x12160
leaq 0x16fce(%rip), %r13     # 0x36d24
testl %eax, %eax
je 0x1fd74
movq %rbp, %rdi
leaq 0x53b73(%rip), %rsi     # 0x738d7
callq 0x12160
leaq 0x172fd(%rip), %r13     # 0x3706d
testl %eax, %eax
jne 0x1fdc5
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x1fdb1
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1fdd7
cmpl $0x0, (%r14)
jne 0x1fdb3
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq *%r13
jmp 0x1fcf2
xorl %eax, %eax
movq %rax, %rdi
callq 0x2b4c3
movq %rbx, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_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 %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x1fe84
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1fe18
xorl %eax, %eax
movq %rax, %rdi
callq 0x2b4c3
movq %rbx, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x53aba(%rip), %r13     # 0x738d9
cmpl $0x2, (%r15)
jne 0x1fe0b
movq %r15, %rdi
callq 0x12ad0
movq %rax, %rdi
movq %r13, %rsi
callq 0x12160
testl %eax, %eax
jne 0x1fe0b
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x1fdf7
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1fe84
cmpl $0x0, (%r14)
jne 0x1fdf9
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x372ec
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1fe1f
jmp 0x1fdf7
// File: /workspace/github_c_makefile_star2_O1/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 0x12eda
cmpl $0x0, (%rbx)
jne 0x20af9
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1fe84
cmpl $0x0, (%rbx)
je 0x20b01
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 0x36e81
// File: /workspace/github_c_makefile_star2_O1/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 0x2c193
cmpl $0x0, (%rbx)
jne 0x20b7a
movq %rax, %r15
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2b37c
cmpl $0x0, (%rbx)
jne 0x20b7a
movl %r15d, %edi
movq %rbx, %rsi
callq 0x2ba99
cmpl $0x0, (%rbx)
jne 0x20b7a
movq %rax, %r15
movq (%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
je 0x20b7d
movq %r15, %rdi
callq 0x2b4c3
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_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 0x1eef8
cmpl $0x0, (%r14)
je 0x20bbc
xorl %r14d, %r14d
jmp 0x20c5a
movq %rax, %rbx
movl (%rax), %eax
cmpl $0x3, %eax
je 0x20bdb
cmpl $0x7, %eax
jne 0x20c2b
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x48b02
jmp 0x20be9
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4871c
movq %rax, %rbx
movq 0x48(%r15), %rdi
movq 0x148(%rax), %rdx
movl %ebp, %esi
movq %r14, %rcx
callq 0x2c189
cmpl $0x0, (%r14)
jne 0x20c4f
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x2b37c
cmpl $0x0, (%r14)
jne 0x20c4f
movl %r12d, %edi
movq %r14, %rsi
callq 0x2ba99
movq %rax, %r14
jmp 0x20c52
movq (%r15), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x52cdf(%rip), %r8      # 0x7391b
movq %r14, %rdi
movl $0x49, %esi
movl $0x2c, %r9d
callq 0x14618
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x2b4c3
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x20cc7
cmpl $0x0, (%rbx)
jne 0x20cad
movq 0x48(%r14), %rdi
movl $0x8e, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x2c19f
cmpl $0x0, (%rbx)
je 0x20cb5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2b37c
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_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 0x12eda
movq $-0x1, %rbx
cmpl $0x0, (%r14)
jne 0x20d10
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1ebbe
cmpl $0x0, (%r14)
jne 0x20d10
movq 0x148(%rax), %rbx
movq %rax, %rdi
callq 0x2b4c3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
movq %rcx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x20da6
movq %r14, %rdi
callq 0x12ad0
movq %rax, %r12
cmpl $0x2, (%r14)
jne 0x20d73
leaq 0x534ab(%rip), %rsi     # 0x74212
movq %r12, %rdi
callq 0x12160
testl %eax, %eax
je 0x20dbb
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x52b96(%rip), %rax     # 0x7391b
leaq 0x52b36(%rip), %rdx     # 0x738c2
movq %rbx, %rdi
movl $0x1d, %esi
movq %r12, %rcx
pushq $0xa6
pushq %rax
callq 0x1442a
addq $0x10, %rsp
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x20cc7
cmpl $0x0, (%rbx)
jne 0x20dfb
movq 0x48(%r15), %rdi
movl %ebp, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x2c189
cmpl $0x0, (%rbx)
jne 0x20dfb
movq %rax, %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2b37c
cmpl $0x0, (%rbx)
je 0x20e7f
xorl %r12d, %r12d
cmpl $0x0, (%rbx)
jne 0x20da6
movq %r14, %rdi
callq 0x12ad0
movq %rax, %r13
cmpl $0x2, (%r14)
jne 0x20e27
leaq 0x52cd2(%rip), %rsi     # 0x73aed
movq %r13, %rdi
callq 0x12160
testl %eax, %eax
je 0x20e67
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x52ae2(%rip), %rax     # 0x7391b
leaq 0x561ae(%rip), %rdx     # 0x76fee
movq %rbx, %rdi
movl $0x1d, %esi
movq %r13, %rcx
pushq $0xb1
pushq %rax
callq 0x1442a
addq $0x10, %rsp
movq %r12, %rdi
callq 0x2b4c3
jmp 0x20da6
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x20e5a
jmp 0x20da9
movl %r12d, %edi
movq %rbx, %rsi
callq 0x2ba99
movq %rax, %r12
jmp 0x20dfe
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
callq 0x20cc7
cmpl $0x0, (%rbx)
jne 0x20f09
movq %rax, %r15
movq %r12, %rdi
callq 0x12ad0
movq %rax, %r13
cmpl $0x2, (%r12)
jne 0x20ed6
leaq 0x526ce(%rip), %rsi     # 0x73598
movq %r13, %rdi
callq 0x12160
testl %eax, %eax
je 0x20f13
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x52a33(%rip), %rax     # 0x7391b
leaq 0x526a9(%rip), %rdx     # 0x73598
movq %rbx, %rdi
movl $0x1d, %esi
movq %r13, %rcx
pushq $0xd4
pushq %rax
callq 0x1442a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%r14), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x20f09
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1ebbe
cmpl $0x0, (%rbx)
jne 0x20f09
movq %rax, %r12
movq 0x48(%r14), %rdi
movq 0x148(%rax), %rdx
movl $0x90, %esi
movq %r15, %rcx
movq %rbx, %r8
callq 0x2c1ac
movq %r12, %rdi
callq 0x2b4c3
cmpl $0x0, (%rbx)
jne 0x20f09
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b37c
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x6(%rsp), %rbp
movb $0x0, (%rbp)
movq 0x48(%rdi), %rdi
callq 0x2d00a
movq %rax, %r15
movq 0x48(%r14), %rdi
callq 0x2d00a
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
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %r9
pushq %rbx
pushq %rax
pushq %r10
callq 0x21371
addq $0x20, %rsp
cmpl $0x0, (%rbx)
je 0x215c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebp
testb %al, %al
je 0x215fb
movq 0x48(%r14), %rdi
movq 0x8(%rsp), %rdx
movl $0x43, %esi
movq %r12, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0x2c0c2
cmpl $0x0, (%rbx)
jne 0x215b1
movq 0x48(%r14), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2d017
cmpl $0x0, (%rbx)
jne 0x215b1
movq 0x10(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x4d29c
cmpl $0x0, (%rbx)
jne 0x215b1
movq 0x48(%r14), %rdi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %r8
movl $0x92, %esi
movq %rax, %rcx
movq %rbx, %r9
callq 0x2c0c2
cmpl $0x0, (%rbx)
jne 0x215b1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b37c
cmpl $0x0, (%rbx)
sete %al
andb %bpl, %al
cmpb $0x1, %al
jne 0x215b1
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 0x2d017
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x12eda
cmpl $0x0, (%rbx)
jne 0x220fd
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1e874
cmpl $0x0, (%rbx)
jne 0x220fd
movq %rax, %r15
movq %rax, %rdi
callq 0x37676
testb %al, %al
jne 0x22100
movq %r15, %rdi
callq 0x2b4c3
movq (%r14), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x51880(%rip), %r8      # 0x7396a
movq %rbx, %rdi
movl $0x44, %esi
movl $0x2e, %r9d
callq 0x14618
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x23be8
cmpl $0x0, (%r14)
je 0x229e8
xorl %r12d, %r12d
xorl %ebp, %ebp
jmp 0x22a08
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x23c62
movq %rax, %rbp
cmpl $0x0, (%r14)
je 0x22a36
xorl %r13d, %r13d
xorl %r12d, %r12d
movq %r12, %rdi
callq 0x2b4c3
movq %rbp, %rdi
callq 0x2b4c3
movq %rbx, %rdi
callq 0x2b4c3
movq %r13, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b4c3
movq %r15, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r14, %rcx
testl %r12d, %r12d
je 0x22a4e
callq 0x2bdca
jmp 0x22a53
callq 0x2bdc0
movq %rax, %r12
cmpl $0x0, (%r14)
jne 0x22a97
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 0x2c0c2
cmpl $0x0, (%r14)
jne 0x22a97
movq 0x48(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2d017
xorl %r13d, %r13d
xorl %ebx, %ebx
jmp 0x229e4
// File: /workspace/github_c_makefile_star2_O1/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 0x23be8
cmpl $0x0, (%r14)
jne 0x22ae0
movl $0x1, %edi
movq %r14, %rsi
callq 0x2bb29
cmpl $0x0, (%r14)
je 0x22b0b
xorl %r13d, %r13d
xorl %r12d, %r12d
movq %r12, %rdi
callq 0x2b4c3
movq %r13, %rdi
callq 0x2b4c3
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b4c3
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x23c62
movq %rax, %r13
cmpl $0x0, (%r14)
jne 0x22ae3
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x2bdc0
movq %rax, %r12
cmpl $0x0, (%r14)
jne 0x22b79
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 0x2c0c2
cmpl $0x0, (%r14)
jne 0x22b79
movq 0x48(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2d017
xorl %ebx, %ebx
xorl %r13d, %r13d
jmp 0x22ae6
// File: /workspace/github_c_makefile_star2_O1/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 0x2d00a
movq %rax, %r13
movq 0x48(%r12), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2d017
cmpl $0x0, (%r14)
je 0x22bc8
xorl %ebx, %ebx
movq %rbx, %rdi
callq 0x2b4c3
jmp 0x22be1
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x1e30c
cmpl $0x0, (%r14)
je 0x22bf0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%r12), %rdi
callq 0x2d00a
movq %rax, %rbp
movq 0x48(%r12), %rdi
callq 0x2d00a
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 0x2c0c2
cmpl $0x0, (%r14)
jne 0x22bbe
movq %rbp, (%rsp)
movq 0x48(%r12), %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x2d017
cmpl $0x0, (%r14)
jne 0x22bbe
movq %r12, %rdi
movq %r14, %rsi
callq 0x24703
cmpl $0x0, (%r14)
jne 0x22bbe
movq %r12, %rdi
movq %r15, %rsi
movl $0x2b, %edx
movq %r14, %rcx
callq 0x1e302
cmpl $0x0, (%r14)
jne 0x22bbe
movq 0x48(%r12), %rdi
movl $0x45, %esi
movq %r13, %rdx
movq %r14, %rcx
callq 0x2c19f
cmpl $0x0, (%r14)
jne 0x22bbe
movq 0x48(%r12), %rdi
movq (%rsp), %rsi
movq %r14, %rdx
callq 0x2d017
cmpl $0x0, (%r14)
jne 0x22bbe
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12eda
jmp 0x22bbe
// File: /workspace/github_c_makefile_star2_O1/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 0x2d00a
movq %rax, %r15
movq 0x48(%r14), %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x2d017
cmpl $0x0, (%rbx)
jne 0x22d46
movq (%r14), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x22d46
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24703
cmpl $0x0, (%rbx)
jne 0x22d46
movq %r14, %rdi
movq %r12, %rsi
movl $0x8b, %edx
movq %rbx, %rcx
callq 0x1e302
cmpl $0x0, (%rbx)
je 0x22d5f
xorl %r12d, %r12d
movq %r12, %rdi
callq 0x2b4c3
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 0x1e30c
cmpl $0x0, (%rbx)
jne 0x22d51
movq %rax, %r12
movq 0x48(%r14), %rdi
callq 0x2d00a
movq %rax, %r13
movq 0x48(%r14), %rdi
movq 0x8(%rsp), %rdx
movl $0x43, %esi
movq %rax, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0x2c0c2
cmpl $0x0, (%rbx)
jne 0x22d49
movq 0x48(%r14), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2d017
jmp 0x22d49
// File: /workspace/github_c_makefile_star2_O1/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 0x2d00a
movq %rax, (%r13)
movq 0x48(%r14), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x2d017
cmpl $0x0, (%r15)
jne 0x23c58
movq %r14, %rdi
movq %r15, %rsi
callq 0x24703
cmpl $0x0, (%r15)
jne 0x23c58
movq %r14, %rdi
movq %r12, %rsi
movl $0x51, %edx
movq %r15, %rcx
callq 0x1e14c
cmpl $0x0, (%r15)
jne 0x23c58
movq 0x48(%r14), %rdi
callq 0x2d00a
movq %rax, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x23c93
movl 0x10(%r15), %esi
movq %r13, %rdi
movq %r14, %rdx
callq 0x2b971
jmp 0x23ca9
movq 0x8(%r15), %rdx
movq 0x10(%r15), %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %r8
callq 0x364c2
movq %rax, %rbp
cmpl $0x0, (%r14)
jne 0x23ce2
movq %r12, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x2bdbb
cmpl $0x0, (%r14)
jne 0x23ce0
movq %r12, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x379c3
cmpl $0x0, (%r14)
je 0x23d06
xorl %ebp, %ebp
movq %rbp, %rdi
callq 0x2b4c3
movq %rbx, %rdi
callq 0x2b4c3
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 0x23d41
movq 0x10(%r15), %rsi
movq %r12, %rdi
movq %rax, %rdx
movq %r14, %rcx
callq 0x363e2
cmpl $0x0, (%r14)
jne 0x23ce0
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 0x2b971
movq %rax, %rdi
movq %r14, %rsi
movq %rax, %r13
callq 0x362d2
movq %rax, %rbp
cmpl $0x0, (%r14)
jne 0x23ce2
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %r12, %rdi
movq %r13, %rcx
movq %r14, %r8
callq 0x36416
jmp 0x23cf4
// File: /workspace/github_c_makefile_star2_O1/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 0x35ed8
cmpl $0x0, (%rbx)
jne 0x240fe
movq 0x48(%r15), %rdi
movl %eax, %r8d
movl $0x9, %esi
movq %r13, %rdx
movq %r13, %rcx
movq %rbx, %r9
callq 0x2c0c2
cmpl $0x0, (%rbx)
jne 0x240fe
movq 0x48(%r15), %rdi
movl $0x45, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2c19f
cmpl $0x0, (%rbx)
je 0x24108
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 0x2d017
// File: /workspace/github_c_makefile_star2_O1/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 0x35ed8
cmpl $0x0, (%rbx)
jne 0x2416b
movq 0x48(%r15), %rdi
movl %eax, %r8d
movl $0x9, %esi
movq %r13, %rdx
movq %r13, %rcx
movq %rbx, %r9
callq 0x2c0c2
cmpl $0x0, (%rbx)
je 0x24175
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 0x2416b
movl $0x1, %edi
movq %rbx, %rsi
callq 0x2bb29
cmpl $0x0, (%rbx)
jne 0x2416b
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x23c62
cmpl $0x0, (%rbx)
jne 0x2416b
movq %rax, %rdi
callq 0x2b4c3
movq 0x48(%r15), %rdi
movq 0x160(%r12), %rdx
movl $0x45, %esi
movq %rbx, %rcx
callq 0x2c19f
cmpl $0x0, (%rbx)
jne 0x2416b
movq 0x48(%r15), %rdi
movq 0x168(%r12), %rsi
addq $-0x2c8, %r12           # imm = 0xFD38
movq %rbx, %rdx
callq 0x2d017
cmpl $0x0, (%rbx)
je 0x24186
jmp 0x2416b
// File: /workspace/github_c_makefile_star2_O1/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 0x24258
movq 0x158(%r12), %rdx
movq 0x160(%r12), %rcx
testb %bpl, %bpl
je 0x242b5
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 0x46159
movq %r14, %rdi
movq %r13, %rsi
movq %r8, %rdx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x364c2
cmpl $0x0, (%rbx)
jne 0x242c7
movq %rax, %r15
movq %r13, %rdi
callq 0x37676
testb %al, %al
jne 0x24286
cmpl $0x9, (%r13)
jne 0x24302
cmpb $0x1, 0x150(%r12)
jne 0x242d6
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 0x363e2
movq %rbx, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
xorl %r9d, %r9d
callq 0x46056
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 0x36416
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 0x24338
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x36071
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x36040
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1efe4
cmpl $0x0, (%r14)
je 0x24363
xorl %r15d, %r15d
jmp 0x243c6
movq %rax, %rbx
cmpl $0x0, (%rax)
je 0x24386
movsd 0x4f61d(%rip), %xmm0    # 0x73990
movq %r14, %rdi
callq 0x2bb75
cmpl $0x0, (%r14)
je 0x243a0
xorl %r15d, %r15d
jmp 0x243be
movsd 0x148(%rbx), %xmm0
mulsd 0x4f5fa(%rip), %xmm0    # 0x73990
movq %r14, %rdi
callq 0x2bb75
jmp 0x243b3
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x36d24
xorl %ebx, %ebx
xorl %r15d, %r15d
cmpl $0x0, (%r14)
cmoveq %rax, %r15
movq %rbx, %rdi
callq 0x2b4c3
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4f5b0(%rip), %xmm0    # 0x73998
movq %rdx, %rdi
callq 0x2bb75
cmpl $0x0, (%r14)
jne 0x24416
movq %rax, %rbx
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
je 0x24418
movq %rbx, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_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 0x1efe4
cmpl $0x0, (%r14)
je 0x24442
xorl %r15d, %r15d
jmp 0x244a1
movq %rax, %rbx
cmpl $0x0, (%rax)
je 0x24474
movq 0x48(%r15), %rdi
movq 0x148(%rbx), %rdx
movl $0x53, %esi
movq %r14, %rcx
callq 0x2c189
cmpl $0x0, (%r14)
jne 0x24496
movl %eax, %edi
movq %r14, %rsi
callq 0x2ba99
jmp 0x2448d
movsd 0x148(%rbx), %xmm0
callq 0x12260
cvttsd2si %xmm0, %edi
movq %r14, %rsi
callq 0x2bb29
movq %rax, %r15
cmpl $0x0, (%r14)
je 0x24499
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x2b4c3
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %ebp
movq %rdi, %r12
movq %r8, %rdx
callq 0x1efe4
cmpl $0x0, (%rbx)
je 0x2451a
xorl %r15d, %r15d
jmp 0x24570
movq %rax, %r14
cmpl $0x0, (%rax)
je 0x24549
movq 0x48(%r12), %rdi
movq 0x148(%r14), %rdx
movl %ebp, %esi
movq %rbx, %rcx
callq 0x2c189
cmpl $0x0, (%rbx)
jne 0x24565
movl %eax, %edi
movq %rbx, %rsi
callq 0x2baf9
jmp 0x2455d
movsd 0x148(%r14), %xmm0
callq *%r15
movq %rbx, %rdi
callq 0x2bb75
movq %rax, %r15
cmpl $0x0, (%rbx)
je 0x24568
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x2b4c3
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %r8, %r14
movq %rdi, %r15
callq 0x244f5
cmpl $0x0, (%r14)
jne 0x24612
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2b37c
cmpl $0x0, (%r14)
je 0x24614
movq %rbx, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x81abc(%rip), %rax     # 0xa6180
movq (%rax), %rsi
callq 0x35d95
cmpl $0x0, (%r14)
jne 0x246f2
movq %rax, %rbx
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
je 0x246f4
movq %rbx, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq