LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_input.c
// Function: subtilis_parser_inkey
subtilis_exp_t *subtilis_parser_inkey(subtilis_parser_t *p, subtilis_token_t *t,
				      subtilis_error_t *err)
{
	subtilis_exp_t *e;
	size_t reg;
	subtilis_ir_section_t *current;

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
callq 0x1e3d1
cmpl $0x0, (%rbx)
jne 0x24db1
movq %rax, %r15
cmpl $0x1, (%rax)
jne 0x24d23
movl 0x148(%r15), %ebp
cmpl $0xffffff00, %ebp       # imm = 0xFFFFFF00
jne 0x24d60
movq 0x48(%r14), %rdi
pushq $0x6f
popq %rsi
movq %rbx, %rdx
callq 0x2a98b
jmp 0x24d91
movq 0x148(%r15), %r12
movq %r15, %rdi
callq 0x29d88
leaq 0x48c86(%rip), %rsi     # 0x6d9bf
leaq 0x49b88(%rip), %rdx     # 0x6e8c8
movq %r14, %rdi
movq %rbx, %rcx
callq 0x3169f
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x24dbc
cmpl $0x20, %ecx
jne 0x24db1
movq %rbx, %rdi
callq 0x140a4
jmp 0x24dcc
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3415f
movq %rax, %r15
cmpl $0x0, (%rbx)
jne 0x24da9
shrl $0x1f, %ebp
addl $0x6d, %ebp
movq 0x148(%r15), %rdx
movq 0x48(%r14), %rdi
movl %ebp, %esi
movq %rbx, %rcx
callq 0x2a981
cmpl $0x0, (%rbx)
jne 0x24da9
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29c49
cmpl $0x0, (%rbx)
je 0x24df2
movq %r15, %rdi
callq 0x29d88
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2ef98
cmpl $0x0, (%rbx)
jne 0x24db1
leaq 0x48bec(%rip), %rsi     # 0x6d9bf
leaq 0x49aee(%rip), %r9      # 0x6e8c8
pushq $0x9
popq %rcx
movq %r14, %rdi
movq %r12, %rdx
xorl %r8d, %r8d
pushq %rbx
pushq $0x1
callq 0x1de0d
popq %rcx
popq %rdx
jmp 0x24db3
movq %r15, %rdi
callq 0x29d88
movl %r12d, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2a336
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_mem.c
// Function: subtilis_parser_mem_heap_free
subtilis_exp_t *subtilis_parser_mem_heap_free(subtilis_parser_t *p,
					      subtilis_token_t *t,
					      subtilis_error_t *err)
{
	size_t reg;
	subtilis_exp_t *e = NULL;

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

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

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

	return e;

cleanup:

	subtilis_exp_delete(e);

	return NULL;
}

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

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

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

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

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

	tbuf = subtilis_token_get_text(t);
	if ((t->type != SUBTILIS_TOKEN_OPERATOR) || strcmp(tbuf, "(")) {
		subtilis_error_set_expected(err, "( ", tbuf, p->l->stream->name,
					    p->l->line);
		return;
	}

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

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

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

	return;

cleanup:

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
movq %rcx, %rdx
callq 0x12e0e
cmpl $0x0, (%r14)
je 0x24ede
addq $0x8, %rsp
jmp 0x24f27
movq %r15, %rdi
callq 0x12a25
cmpl $0x2, (%r15)
jne 0x24ef7
cmpb $0x28, (%rax)
jne 0x24ef7
cmpb $0x0, 0x1(%rax)
je 0x24f2f
movq (%r12), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x48ad5(%rip), %r10     # 0x6d9df
leaq 0x489a1(%rip), %rdx     # 0x6d8b2
pushq $0x1d
popq %rsi
movq %r14, %rdi
movq %rax, %rcx
pushq $0x43
pushq %r10
callq 0x140cd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x2
popq %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %r8
callq 0x1e658
cmpl $0x0, (%r14)
jne 0x24ed8
movq (%r12), %rdi
cmpq $0x2, %rax
jne 0x24f69
movq %r15, %rsi
movq %r14, %rdx
callq 0x12e0e
cmpl $0x0, (%r14)
jne 0x24f96
jmp 0x24ed8
movq 0x30(%rdi), %r8
movl 0x38(%rdi), %r9d
leaq 0x48a67(%rip), %rax     # 0x6d9df
leaq 0x48b3e(%rip), %rdx     # 0x6dabd
leaq 0x48e3f(%rip), %rcx     # 0x6ddc5
pushq $0x15
popq %rsi
movq %r14, %rdi
pushq $0x4d
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
movq 0x8(%rbx), %rdi
callq 0x29d88
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x29d88
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_mem.c
// Function: subtilis_parser_copy_exp
subtilis_exp_t *subtilis_parser_copy_exp(subtilis_parser_t *p,
					 subtilis_token_t *t,
					 subtilis_error_t *err)
{
	subtilis_exp_t *objs[2] = {NULL, NULL};
	subtilis_exp_t *retval = NULL;

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

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

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

	return retval;

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

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

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
movq %rbx, %rcx
callq 0x250d4
cmpl $0x0, (%rbx)
je 0x25066
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq (%rsp), %rsi
cmpq $0x0, 0x158(%rsi)
je 0x250bd
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x48959(%rip), %rax     # 0x6d9df
leaq 0x48939(%rip), %rdx     # 0x6d9c6
leaq 0x48d31(%rip), %rcx     # 0x6ddc5
pushq $0x53
popq %rsi
movq %rbx, %rdi
pushq $0xbc
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
xorl %ebx, %ebx
cmpq $0x3, %rbx
je 0x2505e
movq (%rsp,%rbx,8), %rdi
callq 0x29d88
incq %rbx
jmp 0x250a9
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %r8
callq 0x3472e
jmp 0x2505e
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_mem.c
// Function: prv_append_statement
static void prv_append_statement(subtilis_parser_t *p, subtilis_token_t *t,
				 subtilis_exp_t **objs, subtilis_error_t *err)
{
	const char *tbuf;
	size_t args;
	size_t i;

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

	tbuf = subtilis_token_get_text(t);
	if ((t->type != SUBTILIS_TOKEN_OPERATOR) || strcmp(tbuf, "(")) {
		subtilis_error_set_expected(err, "( ", tbuf, p->l->stream->name,
					    p->l->line);
		return;
	}

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

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

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

	return;

cleanup:

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movq (%rdi), %rdi
movq %rcx, %rdx
callq 0x12e0e
cmpl $0x0, (%r14)
jne 0x25142
movq %r12, %rdi
callq 0x12a25
cmpl $0x2, (%r12)
jne 0x25114
cmpb $0x28, (%rax)
jne 0x25114
cmpb $0x0, 0x1(%rax)
je 0x2514c
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x488b8(%rip), %r10     # 0x6d9df
leaq 0x48784(%rip), %rdx     # 0x6d8b2
pushq $0x1d
popq %rsi
movq %r14, %rdi
movq %rax, %rcx
pushq $0x6b
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x3
popq %rcx
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %r8
callq 0x1e658
cmpl $0x0, (%r14)
jne 0x25142
movq %rax, %r15
movq (%r13), %rdi
cmpq $0x1, %rax
ja 0x251a2
movq 0x30(%rdi), %r8
movl 0x38(%rdi), %r9d
leaq 0x4885d(%rip), %rax     # 0x6d9df
leaq 0x48934(%rip), %rdx     # 0x6dabd
leaq 0x48c35(%rip), %rcx     # 0x6ddc5
pushq $0x15
popq %rsi
movq %r14, %rdi
pushq $0x75
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
jmp 0x251b3
movq %r12, %rsi
movq %r14, %rdx
callq 0x12e0e
cmpl $0x0, (%r14)
je 0x25142
xorl %r14d, %r14d
cmpq %r14, %r15
je 0x25142
movq (%rbx,%r14,8), %rdi
callq 0x29d88
incq %r14
jmp 0x251b6
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_output.c
// Function: prv_vdu_byte
static void prv_vdu_byte(subtilis_parser_t *p, subtilis_exp_t *e,
			 subtilis_error_t *err)
{
	subtilis_op_instr_type_t itype;

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl (%rsi), %eax
cmpl $0x5, %eax
je 0x25614
cmpl $0x1, %eax
jne 0x25643
pushq $0x70
jmp 0x25616
pushq $0x71
popq %rax
movq 0x48(%r14), %rdi
movq 0x148(%rsi), %rdx
movl %eax, %esi
movq %rbx, %rcx
callq 0x2a997
cmpl $0x0, (%rbx)
jne 0x2563b
cmpb $0x0, 0xb9(%r14)
je 0x2565f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x483b5(%rip), %rdx     # 0x6d9ff
pushq $0xf
popq %rsi
pushq $0x21
popq %rcx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1429e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x29c49
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_output.c
// Function: prv_vdu_1byte9zeros
static void prv_vdu_1byte9zeros(subtilis_parser_t *p, subtilis_exp_t *e,
				subtilis_error_t *err)
{
	size_t i;
	subtilis_ir_operand_t op1;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x255fa
cmpl $0x0, (%rbx)
je 0x257c8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x9
popq %r15
pushq $0x70
popq %rbp
subq $0x1, %r15
jb 0x257bd
movq 0x48(%r14), %rdi
movl %ebp, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x2a997
cmpl $0x0, (%rbx)
jne 0x257bd
cmpb $0x0, 0xb9(%r14)
jne 0x257cf
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29c49
cmpl $0x0, (%rbx)
je 0x257cf
jmp 0x257bd
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_output.c
// Function: prv_pos
static subtilis_exp_t *prv_pos(subtilis_parser_t *p, subtilis_token_t *t,
			       subtilis_op_instr_type_t itype,
			       subtilis_error_t *err)
{
	size_t reg;

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

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

	return subtilis_exp_new_int32_var(reg, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x48(%rdi), %rdi
movl %edx, %esi
movq %rcx, %rdx
callq 0x2a98b
cmpl $0x0, (%rbx)
jne 0x25d47
movq %rax, %r14
movq (%r12), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
je 0x25d55
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl %r14d, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2a336
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_os.c
// Function: subtilis_parser_oscli
void subtilis_parser_oscli(subtilis_parser_t *p, subtilis_token_t *t,
			   subtilis_error_t *err)
{
	subtilis_exp_t *command;

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

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

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

	subtilis_exp_handle_errors(p, err);

cleanup:

	subtilis_exp_delete(command);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %r15
callq 0x1dfd5
cmpl $0x0, (%r14)
je 0x26aca
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl (%rax), %eax
cmpl $0x3, %eax
je 0x26ae9
cmpl $0x7, %eax
jne 0x26b25
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4612a
jmp 0x26af7
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x45d61
movq %rax, %rbx
movq 0x48(%r15), %rdi
movq 0x148(%rax), %rdx
movl $0x9a, %esi
movq %r14, %rcx
callq 0x2a997
cmpl $0x0, (%r14)
jne 0x26b47
movq %r15, %rdi
movq %r14, %rsi
callq 0x29c49
jmp 0x26b47
movq (%r15), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x46f13(%rip), %r8      # 0x6da49
pushq $0x49
popq %rsi
movq %r14, %rdi
movl $0x1ab, %r9d            # imm = 0x1AB
callq 0x142c0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x29d88
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_os.c
// Function: subtilis_parser_osargs
subtilis_exp_t *subtilis_parser_osargs(subtilis_parser_t *p,
				       subtilis_token_t *t,
				       subtilis_error_t *err)
{
	size_t reg;
	subtilis_exp_t *e;

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

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

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

	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x48(%rdi), %rdi
movl $0x9c, %esi
callq 0x2a98b
cmpl $0x0, (%rbx)
jne 0x26baa
movq %r12, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x45ddc
cmpl $0x0, (%rbx)
jne 0x26baa
movq %rax, %r14
movq (%r12), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
je 0x26bad
movq %r14, %rdi
callq 0x29d88
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_string.c
// Function: subtilis_parser_chrstr
subtilis_exp_t *subtilis_parser_chrstr(subtilis_parser_t *p,
				       subtilis_token_t *t,
				       subtilis_error_t *err)
{
	subtilis_exp_t *e;
	subtilis_exp_t *retval;
	subtilis_buffer_t buf;
	char c_str[2];

	subtilis_buffer_init(&buf, 2);

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

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

	return subtilis_string_type_new_tmp_from_char(p, e, err);

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

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x10(%rsp), %rdi
pushq $0x2
popq %rsi
callq 0x146a8
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1e3d1
cmpl $0x0, (%r14)
je 0x26bf7
xorl %r14d, %r14d
jmp 0x26c77
movq %rax, %rbx
movq %rax, %rdi
callq 0x348f9
testb %al, %al
je 0x26c41
movb 0x148(%rbx), %al
leaq 0xe(%rsp), %rsi
movb %al, (%rsi)
movb $0x0, 0x1(%rsi)
leaq 0x10(%rsp), %rdi
pushq $0x2
popq %rdx
movq %r14, %rcx
callq 0x14795
cmpl $0x0, (%r14)
je 0x26c54
leaq 0x10(%rsp), %rdi
callq 0x14a01
movq %rbx, %rdi
callq 0x29d88
jmp 0x26bef
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x45bcc
movq %rax, %r14
jmp 0x26c77
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a406
movq %rax, %r14
movq %r15, %rdi
callq 0x14a01
movq %rbx, %rdi
callq 0x29d88
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_string.c
// Function: subtilis_parser_left_str_exp
subtilis_exp_t *subtilis_parser_left_str_exp(subtilis_parser_t *p,
					     subtilis_token_t *t,
					     subtilis_error_t *err)
{
	subtilis_exp_t *e[2];

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

	return subtilis_string_type_left_exp(p, e[0], e[1], err);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsp, %rdx
pushq $0x1
popq %rcx
movq %rbx, %r8
callq 0x26d2a
cmpl $0x0, (%rbx)
je 0x26d0e
xorl %eax, %eax
jmp 0x26d22
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x46cac
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_string.c
// Function: prv_left_right_args
static void prv_left_right_args(subtilis_parser_t *p, subtilis_token_t *t,
				subtilis_exp_t **e, int32_t default_val,
				subtilis_error_t *err)
{
	size_t args;
	size_t i;
	const char *tbuf;

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

	tbuf = subtilis_token_get_text(t);
	if (strcmp(tbuf, "(")) {
		subtilis_error_set_exp_expected(err, "( ", p->l->stream->name,
						p->l->line);
		return;
	}

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

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

	if (args == 0) {
		subtilis_error_set_string_expected(err, p->l->stream->name,
						   p->l->line);
		goto cleanup;
	}

	if (args == 1) {
		e[1] = subtilis_exp_new_int32(default_val, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	return;

cleanup:

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r12
movq (%rdi), %rdi
movq %r8, %rdx
callq 0x12e0e
cmpl $0x0, (%r14)
je 0x26d5a
addq $0x8, %rsp
jmp 0x26da0
movq %r13, %rdi
callq 0x12a25
cmpb $0x28, (%rax)
jne 0x26d6d
cmpb $0x0, 0x1(%rax)
je 0x26dab
movq (%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x46d02(%rip), %rax     # 0x6da82
leaq 0x46b2b(%rip), %rdx     # 0x6d8b2
leaq 0x47037(%rip), %rcx     # 0x6ddc5
pushq $0x15
popq %rsi
movq %r14, %rdi
pushq $0x6a
pushq %rax
callq 0x140cd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x2
popq %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r14, %r8
callq 0x1e658
cmpl $0x0, (%r14)
jne 0x26d54
movq %rax, %r15
movq (%r12), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x12e0e
cmpl $0x0, (%r14)
je 0x26df7
xorl %r14d, %r14d
cmpq %r14, %r15
je 0x26d54
movq (%rbx,%r14,8), %rdi
callq 0x29d88
incq %r14
jmp 0x26de0
cmpq $0x1, %r15
je 0x26e29
testq %r15, %r15
jne 0x26d54
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x46c6a(%rip), %r8      # 0x6da82
pushq $0x49
popq %rsi
pushq $0x78
popq %r9
movq %r14, %rdi
callq 0x142c0
jmp 0x26ddd
movl %ebp, %edi
movq %r14, %rsi
callq 0x2a369
movq %rax, 0x8(%rbx)
cmpl $0x0, (%r14)
jne 0x26ddd
jmp 0x26d54
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_string.c
// Function: subtilis_parser_right_str_exp
subtilis_exp_t *subtilis_parser_right_str_exp(subtilis_parser_t *p,
					      subtilis_token_t *t,
					      subtilis_error_t *err)
{
	subtilis_exp_t *e[2];

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

	return subtilis_string_type_right_exp(p, e[0], e[1], err);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsp, %rdx
pushq $0x1
popq %rcx
movq %rbx, %r8
callq 0x26d2a
cmpl $0x0, (%rbx)
je 0x26e66
xorl %eax, %eax
jmp 0x26e7a
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x471e7
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_string.c
// Function: subtilis_parser_mid_str_exp
subtilis_exp_t *subtilis_parser_mid_str_exp(subtilis_parser_t *p,
					    subtilis_token_t *t,
					    subtilis_error_t *err)
{
	subtilis_exp_t *e[3];
	size_t args;
	size_t i;
	const char *tbuf;

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

	tbuf = subtilis_token_get_text(t);
	if (strcmp(tbuf, "(")) {
		subtilis_error_set_exp_expected(err, "( ", p->l->stream->name,
						p->l->line);
		return NULL;
	}

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

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

	if (args == 0) {
		subtilis_error_set_string_expected(err, p->l->stream->name,
						   p->l->line);
		return NULL;
	}

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

	return subtilis_string_type_mid_exp(p, e[0], e[1], e[2], err);

cleanup:

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

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x12e0e
cmpl $0x0, (%rbx)
jne 0x26ee9
movq %r12, %rdi
callq 0x12a25
cmpb $0x28, (%rax)
jne 0x26eb6
cmpb $0x0, 0x1(%rax)
je 0x26efa
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x46bba(%rip), %rax     # 0x6da82
leaq 0x469e3(%rip), %rdx     # 0x6d8b2
leaq 0x46eef(%rip), %rcx     # 0x6ddc5
pushq $0x15
popq %rsi
movq %rbx, %rdi
pushq $0xb4
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsp, %rdx
pushq $0x3
popq %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %r8
callq 0x1e658
cmpl $0x0, (%rbx)
jne 0x26ee9
movq %rax, %r15
movq (%r14), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
je 0x26f41
xorl %ebx, %ebx
xorl %r14d, %r14d
cmpq %r14, %r15
je 0x26eeb
movq (%rsp,%r14,8), %rdi
callq 0x29d88
incq %r14
jmp 0x26f2e
cmpq $0x1, %r15
je 0x26f73
testq %r15, %r15
jne 0x26fa8
movq (%r14), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x46b25(%rip), %r8      # 0x6da82
pushq $0x49
popq %rsi
movq %rbx, %rdi
movl $0xc2, %r9d
callq 0x142c0
jmp 0x26ee9
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x46afd(%rip), %rax     # 0x6da82
leaq 0x46606(%rip), %rdx     # 0x6d592
leaq 0x46b2a(%rip), %rcx     # 0x6dabd
pushq $0x1d
popq %rsi
movq %rbx, %rdi
pushq $0xc8
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
jmp 0x26f29
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %r8
callq 0x4777f
movq %rax, %rbx
jmp 0x26eeb
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_string.c
// Function: subtilis_parser_string_str
subtilis_exp_t *subtilis_parser_string_str(subtilis_parser_t *p,
					   subtilis_token_t *t,
					   subtilis_error_t *err)
{
	subtilis_exp_t *e[2];
	const char *tbuf;
	size_t args;
	size_t i;

	e[0] = NULL;
	e[1] = NULL;

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

	tbuf = subtilis_token_get_text(t);
	if (strcmp(tbuf, "(")) {
		subtilis_error_set_exp_expected(err, "( ", p->l->stream->name,
						p->l->line);
		return NULL;
	}

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

	if (args != 2 || ((e[1]->type.type != SUBTILIS_TYPE_CONST_STRING) &&
			  (e[1]->type.type != SUBTILIS_TYPE_STRING))) {
		subtilis_error_set_string_expected(err, p->l->stream->name,
						   p->l->line);
		goto cleanup;
	}

	e[0] = subtilis_type_if_to_int(p, e[0], err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	e[0] = subtilis_string_type_string(p, e[0], e[1], err);

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

	return e[0];

cleanup:

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

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq (%rdi), %rdi
callq 0x12e0e
cmpl $0x0, (%rbx)
jne 0x27038
movq %r15, %rdi
callq 0x12a25
cmpb $0x28, (%rax)
jne 0x27004
cmpb $0x0, 0x1(%rax)
je 0x27049
movq (%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x46a6b(%rip), %rax     # 0x6da82
leaq 0x46894(%rip), %rdx     # 0x6d8b2
leaq 0x46da0(%rip), %rcx     # 0x6ddc5
pushq $0x15
popq %rsi
movq %rbx, %rdi
pushq $0xe9
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsp, %rdx
pushq $0x2
popq %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %r8
callq 0x1e658
cmpl $0x0, (%rbx)
jne 0x27038
movq %rax, %r14
cmpq $0x2, %rax
jne 0x270c6
movq 0x8(%rsp), %rax
movl (%rax), %eax
orl $0x4, %eax
cmpl $0x7, %eax
jne 0x270c6
movq (%rsp), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x347d5
movq %rax, (%rsp)
cmpl $0x0, (%rbx)
jne 0x270e9
movq 0x8(%rsp), %rdx
movq %r12, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0x48947
movq %rax, (%rsp)
movq (%r12), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
jne 0x270e9
movq (%rsp), %rbx
jmp 0x2703a
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x469aa(%rip), %r8      # 0x6da82
pushq $0x49
popq %rsi
movq %rbx, %rdi
movl $0xf4, %r9d
callq 0x142c0
xorl %ebx, %ebx
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x2703a
movq (%rsp,%r15,8), %rdi
callq 0x29d88
incq %r15
jmp 0x270ee
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_string.c
// Function: subtilis_parser_left_str
void subtilis_parser_left_str(subtilis_parser_t *p, subtilis_token_t *t,
			      subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_exp_t *e[2];
	subtilis_exp_t *value;

	prv_left_right_args(p, t, e, -1, 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_assignment_op_expected(
		    err, tbuf, p->l->stream->name, p->l->line);
		goto cleanup;
	}

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

	subtilis_string_type_left(p, e[0], e[1], value, err);
	return;

cleanup:
	subtilis_exp_delete(e[0]);
	subtilis_exp_delete(e[1]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rdx
pushq $-0x1
popq %rcx
movq %rbx, %r8
callq 0x26d2a
cmpl $0x0, (%rbx)
jne 0x272dc
movq %r15, %rdi
callq 0x12a25
cmpl $0x2, (%r15)
jne 0x27299
cmpb $0x3d, (%rax)
jne 0x27299
cmpb $0x0, 0x1(%rax)
je 0x272e6
movq (%r14), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x467d7(%rip), %r10     # 0x6da82
leaq 0x46b13(%rip), %rcx     # 0x6ddc5
pushq $0x14
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
pushq $0x151                  # imm = 0x151
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq (%rsp), %rdi
callq 0x29d88
movq 0x8(%rsp), %rdi
callq 0x29d88
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1dfd5
cmpl $0x0, (%rbx)
jne 0x272c9
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rcx
movq %rbx, %r8
callq 0x48099
jmp 0x272dc
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_rec.c
// Function: subtilis_parser_rec_init
void subtilis_parser_rec_init(subtilis_parser_t *p, subtilis_token_t *t,
			      const subtilis_type_t *type, const char *var_name,
			      bool local, bool push, subtilis_error_t *err)
{
	const subtilis_symbol_t *s;
	const char *tbuf;

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

	/*
	 * Special case here.  If we're creating a new local variable from a
	 * temporary REC returned from a function we can just promote the
	 * temporary and avoid the copy.
	 */

	tbuf = subtilis_token_get_text(t);
	if (local &&
	    !((t->type == SUBTILIS_TOKEN_OPERATOR) && !strcmp(tbuf, "("))) {
		prv_rec_init_check_tmp(p, t, type, var_name, push, err);
		return;
	}
	s = subtilis_symbol_table_insert(local ? p->local_st : p->st, var_name,
					 type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	prv_rec_init(p, t, type,
		     local ? SUBTILIS_IR_REG_LOCAL : SUBTILIS_IR_REG_GLOBAL,
		     s->loc, push, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x14(%rsp)
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
movq 0x50(%rsp), %r14
movq (%rdi), %rdi
movq %r14, %rdx
callq 0x12e0e
cmpl $0x0, (%r14)
je 0x28918
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
callq 0x12a25
testb %bpl, %bpl
je 0x28990
cmpl $0x2, (%r13)
jne 0x2893b
cmpb $0x28, (%rax)
jne 0x2893b
cmpb $0x0, 0x1(%rax)
je 0x289d6
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1dccf
cmpl $0x0, (%r14)
jne 0x28909
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x35977
movq %rax, %r13
cmpl $0x0, (%r14)
jne 0x28a44
movq 0x158(%r13), %rdx
movq 0x68(%r15), %rdi
testq %rdx, %rdx
je 0x289da
movq %rbx, %rsi
movq %r12, %rcx
movq %r14, %r8
callq 0x2d01c
jmp 0x28a44
pushq $0x60
popq %rax
movq (%r15,%rax), %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x2cbb7
cmpl $0x0, (%r14)
jne 0x28909
movzbl %bpl, %ecx
incq %rcx
movq (%rax), %r8
movq %r14, (%rsp)
movzbl 0x14(%rsp), %r9d
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x28a5a
jmp 0x28909
pushq $0x68
jmp 0x28992
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x2cbb7
cmpl $0x0, (%r14)
jne 0x28a44
movq %rax, %r12
movq (%rax), %rcx
movq 0x148(%r13), %r8
movq %r14, (%rsp)
pushq $0x2
popq %rdx
pushq $0x1
popq %r9
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4376f
cmpl $0x0, (%r14)
setne %al
movl 0x14(%rsp), %ecx
xorb $0x1, %cl
orb %al, %cl
jne 0x28a44
movq %rbx, %rdi
callq 0x2e7c9
testb %al, %al
je 0x28a44
movq (%r12), %rcx
pushq $0x2
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %r8
callq 0x4a8be
movq %r13, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29d88
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_rec.c
// Function: prv_check_id
static void prv_check_id(subtilis_parser_t *p, subtilis_token_t *t,
			 subtilis_type_t *field_type, subtilis_error_t *err)
{
	const char *tbuf;

	tbuf = subtilis_token_get_text(t);
	if (t->type != SUBTILIS_TOKEN_IDENTIFIER) {
		subtilis_error_set_id_expected(err, tbuf, p->l->stream->name,
					       p->l->line);
		return;
	}

	subtilis_type_init_copy(field_type, &t->tok.id_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if ((field_type->type == SUBTILIS_TYPE_FN) ||
	    (field_type->type == SUBTILIS_TYPE_REC)) {
		subtilis_complete_custom_type(p, tbuf, field_type, err);
		if (err->type != SUBTILIS_ERROR_OK)
			subtilis_type_free(field_type);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
movq %rsi, %rdi
callq 0x12a25
movq %rax, %r15
cmpl $0x6, (%r13)
jne 0x2970d
addq $0x8, %r13
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2db73
cmpl $0x0, (%rbx)
jne 0x2973a
movl (%r14), %eax
cmpl $0x16, %eax
je 0x296e6
cmpl $0x9, %eax
jne 0x2973a
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1eb36
cmpl $0x0, (%rbx)
je 0x2973a
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2dc7c
movq (%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x44382(%rip), %rax     # 0x6daa2
leaq 0x4469e(%rip), %rcx     # 0x6ddc5
pushq $0x12
popq %rsi
movq %rbx, %rdi
movq %r15, %rdx
pushq $0x27
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_add_call_addrs
void subtilis_exp_add_call_addrs(subtilis_parser_t *p,
				 subtilis_parser_call_addr_t *call_addr,
				 subtilis_error_t *err)
{
	subtilis_parser_call_addr_t **new_call_addrs;
	size_t new_max;

	if (p->num_call_addrs == p->max_call_addrs) {
		new_max = p->max_call_addrs + SUBTILIS_CONFIG_PROC_GRAN;
		new_call_addrs =
		    realloc(p->call_addrs, new_max * sizeof(*new_call_addrs));
		if (!new_call_addrs) {
			subtilis_error_set_oom(err);
			return;
		}
		p->call_addrs = new_call_addrs;
		p->max_call_addrs = new_max;
	}
	p->call_addrs[p->num_call_addrs++] = call_addr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x98(%rdi), %r12
cmpq 0xa0(%rdi), %r12
jne 0x29ba9
movq %rdx, %r15
movq 0xa8(%r14), %rdi
leaq 0x200(,%r12,8), %rsi
callq 0x12210
testq %rax, %rax
je 0x29bcc
addq $0x40, %r12
movq %rax, 0xa8(%r14)
movq %r12, 0xa0(%r14)
movq 0x98(%r14), %r12
jmp 0x29bb0
movq 0xa8(%r14), %rax
leaq 0x1(%r12), %rcx
movq %rcx, 0x98(%r14)
movq %rbx, (%rax,%r12,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x43eff(%rip), %rdx     # 0x6dad2
pushq $0x1
popq %rsi
pushq $0x3b
popq %rcx
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_return_default_value
void subtilis_exp_return_default_value(subtilis_parser_t *p,
				       subtilis_error_t *err)
{
	subtilis_ir_operand_t end_label;

	end_label.label = p->current->end_label;
	if ((p->current == p->main) ||
	    (p->current->type->type.params.fn.ret_val->type ==
	     SUBTILIS_TYPE_VOID)) {
		subtilis_ir_section_add_instr_no_reg(
		    p->current, SUBTILIS_OP_INSTR_JMP, end_label, err);
		return;
	}

	subtilis_type_if_zero_reg(p, p->current->type->type.params.fn.ret_val,
				  p->current->ret_reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_ir_section_add_instr_no_reg(p->current, SUBTILIS_OP_INSTR_JMP,
					     end_label, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x48(%rdi), %rdi
movq 0x98(%rdi), %r14
cmpq 0x50(%r15), %rdi
je 0x29c36
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rsi
cmpl $0x8, (%rsi)
je 0x29c36
movq 0xa8(%rdi), %rdx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x33fe6
cmpl $0x0, (%rbx)
je 0x29c32
popq %rbx
popq %r14
popq %r15
retq
movq 0x48(%r15), %rdi
pushq $0x45
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x2a997
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_delete
void subtilis_exp_delete(subtilis_exp_t *e)
{
	if (!e)
		return;
	if (e->type.type == SUBTILIS_TYPE_CONST_STRING)
		subtilis_buffer_free(&e->exp.str);
	subtilis_type_free(&e->type);
	free(e->partial_name);
	free(e->temporary);
	free(e);
}

// Assembly:
testq %rdi, %rdi
je 0x29dcb
pushq %rbx
movq %rdi, %rbx
cmpl $0x3, (%rdi)
jne 0x29da2
leaq 0x148(%rbx), %rdi
callq 0x14a01
movq %rbx, %rdi
callq 0x2dc7c
movq 0x160(%rbx), %rdi
callq 0x122c0
movq 0x158(%rbx), %rdi
callq 0x122c0
movq %rbx, %rdi
popq %rbx
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/expression.c
// Function: prv_tmp_ref_return
static void prv_tmp_ref_return(subtilis_parser_t *p,
			       const subtilis_type_t *fn_type,
			       subtilis_exp_t *e, subtilis_error_t *err)
{
	size_t reg;
	char *tmp_name = NULL;

	if (fn_type->type != SUBTILIS_TYPE_VOID &&
	    fn_type->type != SUBTILIS_TYPE_FN &&
	    !subtilis_type_if_is_numeric(fn_type)) {
		reg = prv_create_tmp_ref(p, e->exp.ir_op.reg, fn_type,
					 &tmp_name, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		e->exp.ir_op.reg = reg;
		e->temporary = tmp_name;
	}
}

// Assembly:
movl (%rsi), %eax
andl $-0x2, %eax
cmpl $0x8, %eax
je 0x2a126
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0x35655
testb %al, %al
jne 0x2a118
movq 0x148(%rbx), %r13
movq 0x68(%r12), %rdi
movq %rsp, %rdx
movq %r15, %rsi
movq %r14, %rcx
callq 0x2cee3
cmpl $0x0, (%r14)
jne 0x2a118
movq (%rax), %rax
testq %rax, %rax
je 0x2a0d4
movq 0x48(%r12), %rdi
movl %eax, %ecx
pushq $0x9
popq %rsi
pushq $0x2
popq %rdx
movq %r14, %r8
callq 0x2a819
cmpl $0x0, (%r14)
jne 0x2a0f1
movq %rax, %rbp
jmp 0x2a0d7
pushq $0x2
popq %rbp
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x33ef0
cmpl $0x0, (%r14)
je 0x2a106
movq (%rsp), %rdi
callq 0x122c0
cmpl $0x0, (%r14)
jne 0x2a118
xorl %ebp, %ebp
xorl %eax, %eax
jmp 0x2a10a
movq (%rsp), %rax
movq %rbp, 0x148(%rbx)
movq %rax, 0x158(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_add_call_ptr
subtilis_exp_t *subtilis_exp_add_call_ptr(subtilis_parser_t *p,
					  subtilis_ir_arg_t *args,
					  const subtilis_type_t *fn_type,
					  size_t ptr, size_t num_params,
					  subtilis_error_t *err)
{
	size_t call_site;
	subtilis_exp_t *e = NULL;

	if (fn_type->type == SUBTILIS_TYPE_VOID)
		subtilis_ir_section_add_call_ptr(p->current, num_params, args,
						 ptr, err);
	else
		e = subtilis_type_if_call_ptr(p, fn_type, args, num_params, ptr,
					      err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	args = NULL;

	/* For calls made inside handlers we will add the offset from the start
	 * of the handler section and fix it up later on when checking the
	 * calls.
	 */

	call_site = p->current->in_error_handler ? p->current->error_len
						 : p->current->len;
	call_site--;

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

	prv_tmp_ref_return(p, fn_type, e, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	return e;

on_error:

	subtilis_exp_delete(e);
	free(args);

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %rcx, %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
cmpl $0x8, (%rdx)
jne 0x2a15e
movq 0x48(%r13), %rdi
movq %r8, %rsi
movq %r14, %rdx
movq %rax, %rcx
movq %rbx, %r8
callq 0x2bb0a
xorl %r15d, %r15d
jmp 0x2a178
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r8, %rcx
movq %rax, %r8
movq %rbx, %r9
callq 0x356aa
movq %rax, %r15
cmpl $0x0, (%rbx)
jne 0x2a1a6
movq %r13, %rdi
movq %rbx, %rsi
callq 0x29c49
cmpl $0x0, (%rbx)
jne 0x2a1a3
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2a057
cmpl $0x0, (%rbx)
je 0x2a1b9
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x29d88
movq %r14, %rdi
callq 0x122c0
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_new_empty
subtilis_exp_t *subtilis_exp_new_empty(const subtilis_type_t *type,
				       subtilis_error_t *err)
{
	subtilis_exp_t *e = calloc(1, sizeof(*e));

	if (!e) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	subtilis_type_init_copy(&e->type, type, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		free(e);
		return NULL;
	}

	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
testq %rax, %rax
je 0x2a204
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2db73
cmpl $0x0, (%r14)
je 0x2a21d
movq %rbx, %rdi
callq 0x122c0
jmp 0x2a21b
leaq 0x438c7(%rip), %rdx     # 0x6dad2
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x18c, %ecx            # imm = 0x18C
callq 0x1429e
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_new_var
subtilis_exp_t *subtilis_exp_new_var(const subtilis_type_t *type,
				     unsigned int reg, subtilis_error_t *err)
{
	subtilis_exp_t *e = subtilis_exp_new_empty(type, err);

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

	e->exp.ir_op.reg = reg;
	return e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdx, %rsi
callq 0x2a1c6
cmpl $0x0, (%r14)
je 0x2a241
xorl %eax, %eax
jmp 0x2a24a
movl %ebx, %ecx
movq %rcx, 0x148(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_new_tmp_var
subtilis_exp_t *subtilis_exp_new_tmp_var(const subtilis_type_t *type,
					 unsigned int reg, char *tmp_name,
					 subtilis_error_t *err)
{
	subtilis_exp_t *e = subtilis_exp_new_var(type, reg, err);

	if (err->type != SUBTILIS_ERROR_OK) {
		free(tmp_name);
		return NULL;
	}

	e->temporary = tmp_name;
	return e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rcx, %rdx
callq 0x2a226
cmpl $0x0, (%r14)
je 0x2a276
movq %rbx, %rdi
callq 0x122c0
xorl %eax, %eax
jmp 0x2a27d
movq %rbx, 0x158(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_new_var_block
subtilis_exp_t *subtilis_exp_new_var_block(subtilis_parser_t *p,
					   const subtilis_type_t *type,
					   unsigned int mem_reg, size_t offset,
					   subtilis_error_t *err)
{
	subtilis_ir_operand_t op0;
	subtilis_ir_operand_t op1;
	subtilis_exp_t *e = calloc(1, sizeof(*e));

	if (!e) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	subtilis_type_init_copy(&e->type, type, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		free(e);
		return NULL;
	}

	if (offset > 0) {
		op0.reg = mem_reg;
		op1.integer = offset;
		e->exp.ir_op.reg = subtilis_ir_section_add_instr(
		    p->current, SUBTILIS_OP_INSTR_ADDI_I32, op0, op1, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
	} else {
		e->exp.ir_op.reg = mem_reg;
	}

	return e;

on_error:

	subtilis_exp_delete(e);

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r12
pushq $0x1
popq %rdi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
testq %rax, %rax
je 0x2a2d1
movq %rax, %rbx
movq %rax, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2db73
cmpl $0x0, (%r14)
je 0x2a2fc
movq %rbx, %rdi
callq 0x122c0
jmp 0x2a2e8
leaq 0x437fa(%rip), %rdx     # 0x6dad2
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x1be, %ecx            # imm = 0x1BE
callq 0x1429e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edx
testq %r15, %r15
je 0x2a32d
movq 0x48(%r12), %rdi
movl %r15d, %ecx
pushq $0x9
popq %rsi
movq %r14, %r8
callq 0x2a819
movq %rax, 0x148(%rbx)
cmpl $0x0, (%r14)
je 0x2a2ea
movq %rbx, %rdi
callq 0x29d88
jmp 0x2a2e8
movq %rdx, 0x148(%rbx)
jmp 0x2a2ea
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_new_int32
subtilis_exp_t *subtilis_exp_new_int32(int32_t integer, subtilis_error_t *err)
{
	subtilis_exp_t *e = calloc(1, sizeof(*e));

	if (!e) {
		subtilis_error_set_oom(err);
		return NULL;
	}
	e->type.type = SUBTILIS_TYPE_CONST_INTEGER;
	e->exp.ir_op.integer = integer;

	return e;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebp
pushq $0x1
popq %rdi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
movq %rax, %rbx
testq %rax, %rax
je 0x2a395
movl $0x1, (%rbx)
movl %ebp, 0x148(%rbx)
jmp 0x2a3ac
leaq 0x43736(%rip), %rdx     # 0x6dad2
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x1f3, %ecx            # imm = 0x1F3
callq 0x1429e
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq