LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x1eb88
cmpl $0x0, (%r14)
je 0x27e53
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl (%rax), %eax
cmpl $0x3, %eax
je 0x27e72
cmpl $0x7, %eax
jne 0x27eae
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x48b02
jmp 0x27e80
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4871c
movq %rax, %rbx
movq 0x48(%r15), %rdi
movq 0x148(%rax), %rdx
movl $0x9a, %esi
movq %r14, %rcx
callq 0x2c19f
cmpl $0x0, (%r14)
jne 0x27ed2
movq %r15, %rdi
movq %r14, %rsi
callq 0x2b37c
jmp 0x27ed2
movq (%r15), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x4bbb4(%rip), %r8      # 0x73a73
movq %r14, %rdi
movl $0x49, %esi
movl $0x1ab, %r9d            # imm = 0x1AB
callq 0x14618
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2b4c3
// File: /workspace/github_c_makefile_star2_O1/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 0x2c193
cmpl $0x0, (%rbx)
jne 0x27f35
movq %r12, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x48797
cmpl $0x0, (%rbx)
jne 0x27f35
movq %rax, %r14
movq (%r12), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
je 0x27f38
movq %r14, %rdi
callq 0x2b4c3
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x2, %esi
callq 0x14a40
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1efb1
cmpl $0x0, (%r14)
je 0x27f85
xorl %r14d, %r14d
jmp 0x28007
movq %rax, %rbx
movq %rax, %rdi
callq 0x36a5a
testb %al, %al
je 0x27fd1
movb 0x148(%rbx), %al
leaq 0xe(%rsp), %rsi
movb %al, (%rsi)
movb $0x0, 0x1(%rsi)
leaq 0x10(%rsp), %rdi
movl $0x2, %edx
movq %r14, %rcx
callq 0x14b32
cmpl $0x0, (%r14)
je 0x27fe4
leaq 0x10(%rsp), %rdi
callq 0x14da6
movq %rbx, %rdi
callq 0x2b4c3
jmp 0x27f7d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x48578
movq %rax, %r14
jmp 0x28007
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2bbce
movq %rax, %r14
movq %r15, %rdi
callq 0x14da6
movq %rbx, %rdi
callq 0x2b4c3
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %ecx
movq %rbx, %r8
callq 0x280bc
cmpl $0x0, (%rbx)
je 0x280a0
xorl %eax, %eax
jmp 0x280b4
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x496d4
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x12eda
cmpl $0x0, (%r14)
je 0x280ec
addq $0x8, %rsp
jmp 0x2813c
movq %r13, %rdi
callq 0x12ad0
leaq 0x4c117(%rip), %rsi     # 0x74212
movq %rax, %rdi
callq 0x12160
testl %eax, %eax
je 0x28147
movq (%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4b992(%rip), %rax     # 0x73aac
leaq 0x4b7a1(%rip), %rdx     # 0x738c2
leaq 0x4bccd(%rip), %rcx     # 0x73df5
movq %r14, %rdi
movl $0x15, %esi
pushq $0x6a
pushq %rax
callq 0x1442a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x2, %ecx
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r14, %r8
callq 0x1f290
cmpl $0x0, (%r14)
jne 0x280e6
movq %rax, %r15
movq (%r12), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
je 0x281a5
testq %r15, %r15
je 0x280e6
cmpq $0x1, %r15
adcq $0x0, %r15
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
callq 0x2b4c3
incq %r14
cmpq %r14, %r15
jne 0x2818f
jmp 0x280e6
cmpq $0x1, %r15
je 0x281db
testq %r15, %r15
jne 0x280e6
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x4b8e6(%rip), %r8      # 0x73aac
movq %r14, %rdi
movl $0x49, %esi
movl $0x78, %r9d
callq 0x14618
jmp 0x2817b
movl %ebp, %edi
movq %r14, %rsi
callq 0x2bb29
movq %rax, 0x8(%rbx)
cmpl $0x0, (%r14)
setne %al
testq %r15, %r15
setne %cl
testb %cl, %al
je 0x280e6
jmp 0x28184
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %ecx
movq %rbx, %r8
callq 0x280bc
cmpl $0x0, (%rbx)
je 0x28226
xorl %eax, %eax
jmp 0x2823a
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x49c31
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x12eda
cmpl $0x0, (%rbx)
jne 0x282d2
movq %r12, %rdi
callq 0x12ad0
leaq 0x4bfa0(%rip), %rsi     # 0x74212
movq %rax, %rdi
callq 0x12160
testl %eax, %eax
je 0x282b7
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4b81c(%rip), %rax     # 0x73aac
leaq 0x4b62b(%rip), %rdx     # 0x738c2
leaq 0x4bb57(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x15, %esi
pushq $0xb4
pushq %rax
callq 0x1442a
addq $0x10, %rsp
jmp 0x282d2
movq %rsp, %rdx
movl $0x3, %ecx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %r8
callq 0x1f290
cmpl $0x0, (%rbx)
je 0x282e3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%r14), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
je 0x28316
testq %r15, %r15
je 0x282d2
xorl %ebx, %ebx
xorl %r14d, %r14d
movq (%rsp,%r14,8), %rdi
callq 0x2b4c3
incq %r14
cmpq %r14, %r15
jne 0x28303
jmp 0x282d4
cmpq $0x1, %r15
je 0x28347
testq %r15, %r15
jne 0x28383
movq (%r14), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x4b77a(%rip), %r8      # 0x73aac
movq %rbx, %rdi
movl $0x49, %esi
movl $0xc2, %r9d
callq 0x14618
jmp 0x282d2
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4b753(%rip), %rax     # 0x73aac
leaq 0x4b238(%rip), %rdx     # 0x73598
leaq 0x4b786(%rip), %rcx     # 0x73aed
movq %rbx, %rdi
movl $0x1d, %esi
pushq $0xc8
pushq %rax
callq 0x1442a
addq $0x10, %rsp
jmp 0x282f9
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %r8
callq 0x4a1f9
movq %rax, %rbx
jmp 0x282d4
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rdi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq (%rdi), %rdi
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x2843c
movq %r14, %rdi
callq 0x12ad0
leaq 0x4be37(%rip), %rsi     # 0x74212
movq %rax, %rdi
callq 0x12160
testl %eax, %eax
je 0x28421
movq (%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4b6b2(%rip), %rax     # 0x73aac
leaq 0x4b4c1(%rip), %rdx     # 0x738c2
leaq 0x4b9ed(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x15, %esi
pushq $0xe9
pushq %rax
callq 0x1442a
addq $0x10, %rsp
jmp 0x2843c
movq %rsp, %rdx
movl $0x2, %ecx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %r8
callq 0x1f290
cmpl $0x0, (%rbx)
je 0x2844d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
cmpq $0x2, %rax
jne 0x284ae
movq 0x8(%rsp), %rax
movl (%rax), %eax
orl $0x4, %eax
cmpl $0x7, %eax
jne 0x284ae
movq (%rsp), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x3691f
movq %rax, (%rsp)
cmpl $0x0, (%rbx)
jne 0x284d3
movq 0x8(%rsp), %rdx
movq %r12, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0x4b429
movq %rax, (%rsp)
movq (%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x284d3
movq (%rsp), %rbx
jmp 0x2843e
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x4b5ec(%rip), %r8      # 0x73aac
movq %rbx, %rdi
movl $0x49, %esi
movl $0xf4, %r9d
callq 0x14618
testq %r15, %r15
je 0x2843c
xorl %ebx, %ebx
xorl %r14d, %r14d
movq (%rsp,%r14,8), %rdi
callq 0x2b4c3
incq %r14
cmpq %r14, %r15
jne 0x284e1
jmp 0x2843e
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rbx, %r8
callq 0x280bc
cmpl $0x0, (%rbx)
jne 0x28702
movq %r15, %rdi
callq 0x12ad0
movq %rax, %r12
cmpl $0x2, (%r15)
jne 0x286bc
leaq 0x4af54(%rip), %rsi     # 0x73604
movq %r12, %rdi
callq 0x12160
testl %eax, %eax
je 0x2870e
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4b3de(%rip), %rax     # 0x73aac
leaq 0x4b720(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x14, %esi
movq %r12, %rdx
pushq $0x151                  # imm = 0x151
pushq %rax
callq 0x1442a
addq $0x10, %rsp
movq (%rsp), %rdi
callq 0x2b4c3
movq 0x8(%rsp), %rdi
callq 0x2b4c3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1eb88
cmpl $0x0, (%rbx)
jne 0x286ef
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rcx
movq %rbx, %r8
callq 0x4ab47
jmp 0x28702
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_string.c
// Function: subtilis_parser_val
subtilis_exp_t *subtilis_parser_val(subtilis_parser_t *p, subtilis_token_t *t,
				    subtilis_error_t *err)
{
	size_t args;
	const char *tbuf;
	subtilis_exp_t *e[2];
	size_t i;

	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;

	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)
		return prv_val_real(p, t, e[0], err);

	if (args == 2)
		return prv_val_int(p, t, e, err);

	subtilis_error_set_bad_arg_count(err, 2, args, p->l->stream->name,
					 p->l->line);
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, %r15
movq (%rdi), %rdi
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x28a9c
movq %r12, %rdi
callq 0x12ad0
leaq 0x4b7d6(%rip), %rsi     # 0x74212
movq %rax, %rdi
callq 0x12160
testl %eax, %eax
je 0x28a81
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4b052(%rip), %rax     # 0x73aac
leaq 0x4ae61(%rip), %rdx     # 0x738c2
leaq 0x4b38d(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x15, %esi
pushq $0x2df                  # imm = 0x2DF
pushq %rax
callq 0x1442a
addq $0x10, %rsp
jmp 0x28a9c
movq %rsp, %rdx
movl $0x2, %ecx
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %r8
callq 0x1f290
cmpl $0x0, (%rbx)
je 0x28aad
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
je 0x28ae0
testq %r14, %r14
je 0x28a9c
xorl %ebx, %ebx
xorl %r15d, %r15d
movq (%rsp,%r15,8), %rdi
callq 0x2b4c3
incq %r15
cmpq %r15, %r14
jne 0x28acd
jmp 0x28a9e
cmpq $0x2, %r14
je 0x28b28
cmpq $0x1, %r14
je 0x28b17
testq %r14, %r14
jne 0x28b3e
movq (%r15), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x4afaa(%rip), %r8      # 0x73aac
movq %rbx, %rdi
movl $0x49, %esi
movl $0x2ed, %r9d            # imm = 0x2ED
callq 0x14618
jmp 0x28ac3
movq (%rsp), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x28b74
jmp 0x28b36
movq %rsp, %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x28d58
movq %rax, %rbx
jmp 0x28a9e
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4af5c(%rip), %rax     # 0x73aac
movq %rbx, %rdi
movl $0x28, %esi
movl $0x2, %edx
movl %r14d, %ecx
pushq $0x2f8                  # imm = 0x2F8
pushq %rax
callq 0x144d6
addq $0x10, %rsp
jmp 0x28ac3
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_rec.c
// Function: subtilis_parser_parse_rec_type
char *subtilis_parser_parse_rec_type(subtilis_parser_t *p, subtilis_token_t *t,
				     subtilis_type_t *type,
				     subtilis_error_t *err)
{
	const char *tbuf;
	char *name = NULL;

	tbuf = subtilis_token_get_text(t);
	subtilis_type_init_rec(type, tbuf, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	name = malloc(strlen(tbuf) + 1);
	if (!name) {
		subtilis_error_set_oom(err);
		return NULL;
	}
	strcpy(name, tbuf);

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

	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;

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

	if (type->params.rec.num_fields == 0) {
		subtilis_error_set_empty_rec(err, name, 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 name;

cleanup:

	free(name);

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0x12ad0
movq %rax, %rbp
movq %r13, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2fe7d
cmpl $0x0, (%r14)
jne 0x293ea
movq %rbp, %rdi
callq 0x120f0
leaq 0x1(%rax), %rdi
callq 0x121d0
testq %rax, %rax
je 0x293d1
movq %rax, %rbx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x12070
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x293c7
movq %r15, %rdi
callq 0x12ad0
movq %rax, %rbp
cmpl $0x2, (%r15)
jne 0x29393
leaq 0x4ae8b(%rip), %rsi     # 0x74212
movq %rbp, %rdi
callq 0x12160
testl %eax, %eax
je 0x293fe
movq (%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4a72c(%rip), %rax     # 0x73ad2
leaq 0x4ae65(%rip), %rdx     # 0x74212
movq %r14, %rdi
movl $0x1d, %esi
movq %rbp, %rcx
pushq $0xeb
pushq %rax
callq 0x1442a
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x122c0
jmp 0x293ea
leaq 0x4a6fa(%rip), %rdx     # 0x73ad2
movq %r14, %rdi
movl $0x1, %esi
movl $0xdf, %ecx
callq 0x145f4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x293c7
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x29473
cmpl $0x0, (%r14)
jne 0x293c7
cmpq $0x0, 0x28(%r13)
movq (%r12), %rdi
je 0x29448
movq %r15, %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x293c7
jmp 0x293ec
movq 0x30(%rdi), %r8
movl 0x38(%rdi), %r9d
leaq 0x4a67b(%rip), %rax     # 0x73ad2
leaq 0x4a997(%rip), %rcx     # 0x73df5
movq %r14, %rdi
movl $0x6b, %esi
movq %rbx, %rdx
pushq $0xf9
jmp 0x293bd
// File: /workspace/github_c_makefile_star2_O1/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 0x12eda
cmpl $0x0, (%r14)
je 0x29ecd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
callq 0x12ad0
testb %bpl, %bpl
je 0x29f53
cmpl $0x2, (%r13)
jne 0x29ef4
leaq 0x4a32a(%rip), %rsi     # 0x74212
movq %rax, %rdi
callq 0x12160
testl %eax, %eax
je 0x29f49
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1e874
cmpl $0x0, (%r14)
jne 0x29ebe
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x379c3
movq %rax, %r13
cmpl $0x0, (%r14)
jne 0x2a00b
movq 0x158(%r13), %rdx
movq 0x68(%r15), %rdi
testq %rdx, %rdx
je 0x29f9b
movq %rbx, %rsi
movq %r12, %rcx
movq %r14, %r8
callq 0x2eb46
jmp 0x2a00b
movl $0x68, %eax
testb %bpl, %bpl
jne 0x29f58
movl $0x60, %eax
movq (%r15,%rax), %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x2e6e8
cmpl $0x0, (%r14)
jne 0x29ebe
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 0x2a021
jmp 0x29ebe
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x2e6e8
cmpl $0x0, (%r14)
jne 0x2a00b
movq %rax, %r12
movq (%rax), %rcx
movq 0x148(%r13), %r8
movq %r14, (%rsp)
movl $0x2, %edx
movq %r15, %rdi
movq %rbx, %rsi
movl $0x1, %r9d
callq 0x46056
cmpl $0x0, (%r14)
setne %al
movl 0x14(%rsp), %ecx
xorb $0x1, %cl
orb %al, %cl
jne 0x2a00b
movq %rbx, %rdi
callq 0x3041c
testb %al, %al
je 0x2a00b
movq (%r12), %rcx
movl $0x2, %edx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %r8
callq 0x4d4ea
movq %r13, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b4c3
// File: /workspace/github_c_makefile_star2_O1/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 0x12ad0
movq %rax, %r15
cmpl $0x6, (%r13)
jne 0x2ae02
addq $0x8, %r13
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2f72e
cmpl $0x0, (%rbx)
jne 0x2ae33
movl (%r14), %eax
cmpl $0x16, %eax
je 0x2addb
cmpl $0x9, %eax
jne 0x2ae33
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1f7e6
cmpl $0x0, (%rbx)
je 0x2ae33
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2f843
movq (%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x48cbd(%rip), %rax     # 0x73ad2
leaq 0x48fd9(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x12, %esi
movq %r15, %rdx
pushq $0x27
pushq %rax
callq 0x1442a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_rnd.c
// Function: subtilis_parser_rnd
subtilis_exp_t *subtilis_parser_rnd(subtilis_parser_t *p, subtilis_token_t *t,
				    subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_exp_t *e = NULL;
	subtilis_exp_t *e_dup = NULL;

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

	if (t->type == SUBTILIS_TOKEN_OPERATOR) {
		tbuf = subtilis_token_get_text(t);
		if (!strcmp(tbuf, "(")) {
			e = subtilis_parser_bracketed_exp_internal(p, t, err);
			if (err->type != SUBTILIS_ERROR_OK)
				goto cleanup;

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

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

			if (e->type.type == SUBTILIS_TYPE_CONST_INTEGER)
				return prv_rnd_const(p, e, err);
			return prv_rnd_var(p, e, err);
		}
	}

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

	e_dup = subtilis_type_if_dup(e, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_var_assign_hidden(p, subtilis_rnd_hidden_var,
				   &subtilis_type_integer, e_dup, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	return e;

cleanup:

	subtilis_exp_delete(e);
	subtilis_exp_delete(e_dup);

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x12eda
cmpl $0x0, (%rbx)
je 0x2ae63
xorl %r14d, %r14d
jmp 0x2ae98
cmpl $0x2, (%r12)
jne 0x2ae85
movq %r12, %rdi
callq 0x12ad0
leaq 0x49399(%rip), %rsi     # 0x74212
movq %rax, %rdi
callq 0x12160
testl %eax, %eax
je 0x2aef6
movq %r15, %rdi
movq %rbx, %rsi
callq 0x30e97
movq %rax, %r14
cmpl $0x0, (%rbx)
je 0x2aebd
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x2b4c3
movq %r12, %rdi
callq 0x2b4c3
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x362d2
movq %rax, %r12
cmpl $0x0, (%rbx)
jne 0x2ae9b
leaq 0x7b299(%rip), %rax     # 0xa6170
movq (%rax), %rsi
leaq 0x49a17(%rip), %rdx     # 0x748f8
movq %r15, %rdi
movq %r12, %rcx
movq %rbx, %r8
callq 0x35cc8
cmpl $0x0, (%rbx)
jne 0x2ae9b
jmp 0x2aeae
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1ee69
movq %rax, %r14
cmpl $0x0, (%rbx)
jne 0x2ae98
movq (%r15), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x2ae98
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3691f
movq %rax, %r14
cmpl $0x0, (%rbx)
jne 0x2ae98
cmpl $0x1, (%r14)
jne 0x2af59
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2af6f
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2afc4
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_rnd.c
// Function: prv_rnd_const
static subtilis_exp_t *prv_rnd_const(subtilis_parser_t *p, subtilis_exp_t *e,
				     subtilis_error_t *err)
{
	int32_t val = e->exp.ir_op.integer;

	subtilis_exp_delete(e);
	if (val == 0)
		return subtilis_builtins_ir_rnd_0(p, err);
	else if (val == 1)
		return subtilis_builtins_ir_rnd_1(p, err);
	else if (val < 0)
		return subtilis_builtins_ir_rnd_neg(p, val, err);
	else
		return subtilis_builtins_ir_rnd_pos(p, val, err);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl 0x148(%rsi), %ebp
movq %rsi, %rdi
callq 0x2b4c3
movq %r14, %rdi
cmpl $0x1, %ebp
je 0x2af9f
testl %ebp, %ebp
jne 0x2afab
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x30f49
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x31020
movl %ebp, %esi
movq %rbx, %rdx
js 0x2afbb
popq %rbx
popq %r14
popq %rbp
jmp 0x31126
popq %rbx
popq %r14
popq %rbp
jmp 0x31238
// File: /workspace/github_c_makefile_star2_O1/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 0xa0(%rdi), %r12
cmpq %r12, 0x98(%rdi)
jne 0x2b2d0
movq %rdx, %r15
movq 0xa8(%r14), %rdi
leaq 0x200(,%r12,8), %rsi
callq 0x12210
testq %rax, %rax
je 0x2b2f9
addq $0x40, %r12
movq %rax, 0xa8(%r14)
movq %r12, 0xa0(%r14)
movq 0x98(%r14), %rax
movq 0xa8(%r14), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x98(%r14)
movq %rbx, (%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x48802(%rip), %rdx     # 0x73b02
movq %r15, %rdi
movl $0x1, %esi
movl $0x3b, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x2b367
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rsi
cmpl $0x8, (%rsi)
je 0x2b367
movq 0xa8(%rdi), %rdx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x360de
cmpl $0x0, (%rbx)
je 0x2b363
popq %rbx
popq %r14
popq %r15
retq
movq 0x48(%r15), %rdi
movl $0x45, %esi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x2c19f
// File: /workspace/github_c_makefile_star2_O1/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 0x2b506
pushq %rbx
movq %rdi, %rbx
cmpl $0x3, (%rdi)
jne 0x2b4dd
leaq 0x148(%rbx), %rdi
callq 0x14da6
movq %rbx, %rdi
callq 0x2f843
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_O1/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 0x2b86d
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 0x37676
testb %al, %al
jne 0x2b85f
movq 0x148(%rbx), %r13
movq 0x68(%r12), %rdi
movq %rsp, %rdx
movq %r15, %rsi
movq %r14, %rcx
callq 0x2ea12
xorl %ecx, %ecx
cmpl $0x0, (%r14)
movl $0x0, %ebp
jne 0x2b84b
movq (%rax), %rax
testq %rax, %rax
je 0x2b819
movq 0x48(%r12), %rdi
movl %eax, %ecx
movl $0x2, %edx
movl $0x9, %esi
movq %r14, %r8
callq 0x2c00f
cmpl $0x0, (%r14)
jne 0x2b838
movq %rax, %rbp
jmp 0x2b81e
movl $0x2, %ebp
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x35fde
cmpl $0x0, (%r14)
je 0x2b847
movq (%rsp), %rdi
callq 0x122c0
xorl %ecx, %ecx
xorl %ebp, %ebp
jmp 0x2b84b
movq (%rsp), %rcx
cmpl $0x0, (%r14)
jne 0x2b85f
movq %rbp, 0x148(%rbx)
movq %rcx, 0x158(%rbx)
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/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 0x2b8a5
movq 0x48(%r13), %rdi
movq %r8, %rsi
movq %r14, %rdx
movq %rax, %rcx
movq %rbx, %r8
callq 0x2d3a8
xorl %r15d, %r15d
jmp 0x2b8bf
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r8, %rcx
movq %rax, %r8
movq %rbx, %r9
callq 0x376cd
movq %rax, %r15
cmpl $0x0, (%rbx)
jne 0x2b8ed
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2b37c
cmpl $0x0, (%rbx)
jne 0x2b8ea
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2b791
cmpl $0x0, (%rbx)
je 0x2b900
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x2b4c3
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_O1/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
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
testq %rax, %rax
je 0x2b94d
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2f72e
cmpl $0x0, (%r14)
je 0x2b968
movq %rbx, %rdi
callq 0x122c0
jmp 0x2b966
leaq 0x481ae(%rip), %rdx     # 0x73b02
movq %r14, %rdi
movl $0x1, %esi
movl $0x18c, %ecx            # imm = 0x18C
callq 0x145f4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2b90d
cmpl $0x0, (%r14)
je 0x2b98c
xorl %eax, %eax
jmp 0x2b995
movl %ebx, %ecx
movq %rcx, 0x148(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rcx, %rsi
callq 0x2b90d
cmpl $0x0, (%r14)
je 0x2b9bb
xorl %eax, %eax
jmp 0x2b9c4
movl %ebp, %ecx
movq %rcx, 0x148(%rax)
cmpl $0x0, (%r14)
je 0x2b9d6
movq %rbx, %rdi
callq 0x122c0
xorl %eax, %eax
jmp 0x2b9dd
movq %rbx, 0x158(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
testq %rax, %rax
je 0x2ba30
movq %rax, %rbx
movq %rax, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2f72e
cmpl $0x0, (%r14)
je 0x2ba5d
movq %rbx, %rdi
callq 0x122c0
jmp 0x2ba49
leaq 0x480cb(%rip), %rdx     # 0x73b02
movq %r14, %rdi
movl $0x1, %esi
movl $0x1be, %ecx            # imm = 0x1BE
callq 0x145f4
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 0x2ba90
movq 0x48(%r12), %rdi
movl %r15d, %ecx
movl $0x9, %esi
movq %r14, %r8
callq 0x2c00f
movq %rax, 0x148(%rbx)
cmpl $0x0, (%r14)
je 0x2ba4b
movq %rbx, %rdi
callq 0x2b4c3
jmp 0x2ba49
movq %rdx, 0x148(%rbx)
jmp 0x2ba4b
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
testq %rax, %rax
je 0x2bb53
movl $0x1, (%rax)
movl %ebp, 0x148(%rax)
jmp 0x2bb6e
leaq 0x47fa8(%rip), %rdx     # 0x73b02
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1f3, %ecx            # imm = 0x1F3
callq 0x145f4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_new_real
subtilis_exp_t *subtilis_exp_new_real(double real, 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_REAL;
	e->exp.ir_op.real = real;

	return e;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
testq %rax, %rax
je 0x2bbad
movl $0x0, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x148(%rax)
jmp 0x2bbc8
leaq 0x47f4e(%rip), %rdx     # 0x73b02
movq %rbx, %rdi
movl $0x1, %esi
movl $0x201, %ecx            # imm = 0x201
callq 0x145f4
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_new_str
subtilis_exp_t *subtilis_exp_new_str(subtilis_buffer_t *str,
				     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_STRING;
	subtilis_buffer_init(&e->exp.str, str->granularity);
	if (subtilis_buffer_get_size(str) > 0)
		subtilis_buffer_append(&e->exp.str, str->buffer->data,
				       subtilis_buffer_get_size(str), err);

	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
testq %rax, %rax
je 0x2bc3f
movq %rax, %rbx
movl $0x3, (%rax)
movq %rax, %r12
addq $0x148, %r12            # imm = 0x148
movq (%r15), %rsi
movq %r12, %rdi
callq 0x14a40
movq %r15, %rdi
callq 0x14ba1
testq %rax, %rax
je 0x2bc5a
movq 0x8(%r15), %r13
addq $0x18, %r13
movq %r15, %rdi
callq 0x14ba1
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x14b32
jmp 0x2bc5a
leaq 0x47ebc(%rip), %rdx     # 0x73b02
movq %r14, %rdi
movl $0x1, %esi
movl $0x210, %ecx            # imm = 0x210
callq 0x145f4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_new_fn
subtilis_exp_t *subtilis_exp_new_fn(size_t call_index, const subtilis_type_t *t,
				    subtilis_error_t *err)
{
	subtilis_exp_t *e = calloc(1, sizeof(*e));

	if (!e) {
		subtilis_error_set_oom(err);
		return NULL;
	}
	e->exp.ir_op.reg = call_index;
	subtilis_type_init_copy(&e->type, 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
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
testq %rax, %rax
je 0x2bcb4
movq %rax, %rbx
movq %r12, 0x148(%rax)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2f72e
cmpl $0x0, (%r14)
je 0x2bccf
movq %rbx, %rdi
callq 0x2b4c3
jmp 0x2bccd
leaq 0x47e47(%rip), %rdx     # 0x73b02
movq %r14, %rdi
movl $0x1, %esi
movl $0x222, %ecx            # imm = 0x222
callq 0x145f4
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/expression.c
// Function: subtilis_exp_new_partial_fn
subtilis_exp_t *subtilis_exp_new_partial_fn(size_t call_index, const char *name,
					    size_t call_site,
					    subtilis_error_t *err)
{
	subtilis_exp_t *e = calloc(1, sizeof(*e));

	if (!e) {
		subtilis_error_set_oom(err);
		return NULL;
	}
	e->exp.ir_op.reg = call_index;
	e->type.type = SUBTILIS_TYPE_FN;
	e->type.params.fn.num_params = 0;
	e->type.params.fn.ret_val = malloc(sizeof(*e->type.params.fn.ret_val));
	if (!e->type.params.fn.ret_val) {
		subtilis_error_set_oom(err);
		goto cleanup;
	}
	e->type.params.fn.ret_val->type = SUBTILIS_TYPE_VOID;
	e->partial_name = malloc(strlen(name) + 1);
	if (!e->partial_name) {
		subtilis_error_set_oom(err);
		goto cleanup;
	}
	strcpy(e->partial_name, name);
	e->call_site = call_site;

	return e;

cleanup:

	subtilis_exp_delete(e);
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
testq %rax, %rax
je 0x2bd69
movq %rax, %rbx
movq %r13, 0x148(%rax)
movl $0x9, (%rax)
movq $0x0, 0x10(%rax)
movl $0x148, %edi            # imm = 0x148
callq 0x121d0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x2bd84
movl $0x8, (%rax)
movq %r12, %rdi
callq 0x120f0
leaq 0x1(%rax), %rdi
callq 0x121d0
movq %rax, 0x160(%rbx)
testq %rax, %rax
je 0x2bd8b
movq %rax, %rdi
movq %r12, %rsi
callq 0x12070
movq %r15, 0x168(%rbx)
jmp 0x2bdae
leaq 0x47d92(%rip), %rdx     # 0x73b02
movq %r14, %rdi
movl $0x1, %esi
movl $0x236, %ecx            # imm = 0x236
callq 0x145f4
jmp 0x2bdac
movl $0x23e, %ecx            # imm = 0x23E
jmp 0x2bd90
movl $0x244, %ecx            # imm = 0x244
leaq 0x47d6b(%rip), %rdx     # 0x73b02
movq %r14, %rdi
movl $0x1, %esi
callq 0x145f4
movq %rbx, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/ir.c
// Function: subtilis_handler_list_free
void subtilis_handler_list_free(subtilis_handler_list_t *list)
{
	subtilis_handler_list_t *p;

	while (list) {
		p = list->next;
		free(list);
		list = p;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x2be74
pushq %rbx
movq 0x10(%rdi), %rbx
callq 0x122c0
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x2be62
popq %rbx
retq