LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: subtilis_parser_assign_local_fn
void subtilis_parser_assign_local_fn(subtilis_parser_t *p, subtilis_token_t *t,
				     const char *var_name,
				     const subtilis_type_t *id_type,
				     subtilis_error_t *err)
{
	subtilis_type_t type;
	subtilis_exp_t *e;

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

	if (e->type.type != SUBTILIS_TYPE_FN) {
		subtilis_error_set_expected(err, subtilis_type_name(id_type),
					    subtilis_type_name(&e->type),
					    p->l->stream->name, p->l->line);
		goto cleanup;
	}

	subtilis_type_init_copy(&type, id_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_complete_custom_type(p, var_name, &type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

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

	(void)subtilis_symbol_table_insert_reg(p->local_st, var_name, &type,
					       e->exp.ir_op.reg, err);

cleanup:
	subtilis_exp_delete(e);
	subtilis_type_free(&type);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %r15
movq %r8, %rdx
callq 0x1eb88
cmpl $0x0, (%r14)
jne 0x18274
movq %rax, %rbx
cmpl $0x9, (%rax)
jne 0x1821f
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2f72e
cmpl $0x0, (%r14)
jne 0x18274
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
callq 0x1f7e6
cmpl $0x0, (%r14)
jne 0x18262
cmpq $0x0, 0x160(%rbx)
je 0x18285
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1d2a6
jmp 0x1829b
movq %r13, %rdi
callq 0x2f882
movq %rax, %r12
movq %rbx, %rdi
callq 0x2f882
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x5b368(%rip), %r10     # 0x735ac
movq %r14, %rdi
movl $0x1d, %esi
movq %r12, %rdx
movq %rax, %rcx
pushq $0x21e                  # imm = 0x21E
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b4c3
leaq 0x8(%rsp), %rdi
callq 0x2f843
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x379c3
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x18262
movq 0x68(%r15), %rdi
movq 0x148(%rbx), %rcx
leaq 0x8(%rsp), %rdx
movq %r12, %rsi
movq %r14, %r8
callq 0x2ec2e
jmp 0x18262
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: subtilis_parser_assign_local_rec
void subtilis_parser_assign_local_rec(subtilis_parser_t *p, subtilis_token_t *t,
				      const char *var_name,
				      const subtilis_type_t *id_type,
				      subtilis_error_t *err)
{
	subtilis_type_t type;

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

	subtilis_complete_custom_type(p, var_name, &type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_parser_rec_init(p, t, &type, var_name, true, true, err);

cleanup:
	subtilis_type_free(&type);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %r8, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x10(%rsp), %rdi
movq %rcx, %rsi
movq %r8, %rdx
callq 0x2f72e
cmpl $0x0, (%r15)
jne 0x18334
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x1f7e6
cmpl $0x0, (%r15)
jne 0x1832a
movq %r15, (%rsp)
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rcx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x29e86
leaq 0x10(%rsp), %rdi
callq 0x2f843
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: subtilis_parser_get_assignment_var
char *subtilis_parser_get_assignment_var(subtilis_parser_t *p,
					 subtilis_token_t *t,
					 subtilis_type_t *id_type,
					 subtilis_error_t *err)
{
	const char *tbuf;
	char *var_name = NULL;

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

	/* We need special handling here.  If it's a REC of an FN
	 * to get the full type from the symbol table.  The type we get
	 * from the lexer is incomplete.  It knows that we have a
	 * custom type but it doesn't know all the details of that type.
	 */

	if ((t->tok.id_type.type == SUBTILIS_TYPE_FN) ||
	    (t->tok.id_type.type == SUBTILIS_TYPE_REC))
		subtilis_complete_custom_type(p, var_name, id_type, err);
	else
		subtilis_type_copy(id_type, &t->tok.id_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

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

	return var_name;

cleanup:
	free(var_name);

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0x12ad0
movq %rax, %rbp
movq %rax, %rdi
callq 0x120f0
leaq 0x1(%rax), %rdi
callq 0x121d0
testq %rax, %rax
je 0x183aa
movq %rax, %r14
movq %rax, %rdi
movq %rbp, %rsi
callq 0x12070
movl 0x8(%r15), %eax
cmpl $0x16, %eax
je 0x18397
cmpl $0x9, %eax
jne 0x183c5
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x1f7e6
jmp 0x183d4
leaq 0x5b1fb(%rip), %rdx     # 0x735ac
movq %rbx, %rdi
movl $0x1, %esi
movl $0x29a, %ecx            # imm = 0x29A
callq 0x145f4
jmp 0x183f5
leaq 0x8(%r15), %rsi
movq %r13, %rdi
movq %rbx, %rdx
callq 0x2fa5f
cmpl $0x0, (%rbx)
jne 0x183ed
movq (%r12), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
je 0x183f8
movq %r14, %rdi
callq 0x122c0
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: subtilis_parser_lookup_assignment_var
void subtilis_parser_lookup_assignment_var(subtilis_parser_t *p,
					   subtilis_token_t *t,
					   const char *var_name,
					   const subtilis_symbol_t **s,
					   size_t *mem_reg, bool *new_global,
					   subtilis_error_t *err)
/* clang-format on */

{
	*new_global = false;
	*s = subtilis_symbol_table_lookup(p->local_st, var_name);
	if (*s) {
		*mem_reg = SUBTILIS_IR_REG_LOCAL;
	} else {
		*s = subtilis_symbol_table_lookup(p->st, var_name);
		if (*s) {
			*mem_reg = SUBTILIS_IR_REG_GLOBAL;
		} else if (p->current == p->main) {
			/*
			 * We explicitly disable statements like
			 *
			 * X% = X% + 1  or
			 * X% += 1
			 *
			 * for the cases where X% has not been defined.
			 */
			*new_global = true;
			*mem_reg = SUBTILIS_IR_REG_GLOBAL;
			if (p->level != 0) {
				subtilis_error_variable_bad_level(
				    err, var_name, p->l->stream->name,
				    p->l->line);
			}
		} else {
			subtilis_error_set_unknown_variable(
			    err, var_name, p->l->stream->name, p->l->line);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r12
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %rbx
movq %rdi, %r14
movb $0x0, (%r9)
movq 0x68(%rdi), %rdi
movq %rdx, %rsi
callq 0x2eec8
movq %rax, (%r13)
testq %rax, %rax
je 0x18447
movq $0x2, (%r15)
jmp 0x184df
movq 0x60(%r14), %rdi
movq %rbx, %rsi
callq 0x2eec8
movq %rax, (%r13)
testq %rax, %rax
je 0x18465
movq $0x1, (%r15)
jmp 0x184df
movq 0x30(%rsp), %rdi
movq 0x48(%r14), %rax
cmpq 0x50(%r14), %rax
je 0x1849c
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x5b126(%rip), %rax     # 0x735ac
leaq 0x5b968(%rip), %rcx     # 0x73df5
movl $0x1b, %esi
movq %rbx, %rdx
pushq $0x2dd                  # imm = 0x2DD
jmp 0x184d5
movb $0x1, (%r12)
movq $0x1, (%r15)
cmpq $0x0, 0x78(%r14)
je 0x184df
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x5b0eb(%rip), %rax     # 0x735ac
leaq 0x5b92d(%rip), %rcx     # 0x73df5
movl $0x3e, %esi
movq %rbx, %rdx
pushq $0x2d9                  # imm = 0x2D9
pushq %rax
callq 0x1442a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: prv_assignment_operator
static subtilis_exp_t *prv_assignment_operator(subtilis_parser_t *p,
					       const char *var_name,
					       subtilis_exp_t *e,
					       subtilis_assign_type_t at,
					       subtilis_error_t *err)
{
	subtilis_exp_t *var;

	if (at == SUBTILIS_ASSIGN_TYPE_EQUAL)
		return e;

	var = subtilis_var_lookup_var(p, var_name, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	if (at == SUBTILIS_ASSIGN_TYPE_PLUS_EQUAL)
		e = subtilis_exp_add(p, var, e, err);
	else
		e = subtilis_type_if_sub(p, var, e, err);

	var = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	return e;

cleanup:

	subtilis_exp_delete(var);
	subtilis_exp_delete(e);

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
testl %ecx, %ecx
je 0x19547
movq %r8, %r14
movl %ecx, %ebp
movq %rdi, %r15
movq %r8, %rdx
callq 0x35d95
cmpl $0x0, (%r14)
jne 0x19535
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r14, %rcx
cmpl $0x1, %ebp
jne 0x19525
callq 0x2bdbb
jmp 0x1952a
callq 0x36f23
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x19547
xorl %eax, %eax
movq %rax, %rdi
callq 0x2b4c3
movq %rbx, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: subtilis_parser_let
void subtilis_parser_let(subtilis_parser_t *p, subtilis_token_t *t,
			 subtilis_error_t *err)
{
	const char *tbuf;

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

	subtilis_parser_assignment(p, t, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x195c5
cmpl $0x6, (%r15)
jne 0x19589
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x184e9
movq %r15, %rdi
callq 0x12ad0
movq (%r14), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x5a009(%rip), %r10     # 0x735ac
leaq 0x5a84b(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x12, %esi
movq %rax, %rdx
pushq $0x4cb                  # imm = 0x4CB
pushq %r10
callq 0x1442a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: prv_check_bad_def
static void prv_check_bad_def(subtilis_parser_t *p, const char *var_name,
			      subtilis_error_t *err)
{
	if (!strncmp(var_name, "DEFPROC", 7) ||
	    !strncmp(var_name, "defPROC", 7))
		subtilis_error_set_defproc_should_be_def_proc(
		    err, p->l->stream->name, p->l->line);
	else if (!strncmp(var_name, "DEFFN", 5) ||
		 !strncmp(var_name, "defFN", 5))
		subtilis_error_set_deffn_should_be_def_fn(
		    err, p->l->stream->name, p->l->line);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x59e5f(%rip), %rsi     # 0x735e2
movl $0x7, %edx
movq %r15, %rdi
callq 0x12060
testl %eax, %eax
je 0x197e2
leaq 0x59e4f(%rip), %rsi     # 0x735ea
movl $0x7, %edx
movq %r15, %rdi
callq 0x12060
testl %eax, %eax
je 0x197e2
leaq 0x59e3f(%rip), %rsi     # 0x735f2
movl $0x5, %edx
movq %r15, %rdi
callq 0x12060
testl %eax, %eax
je 0x19803
leaq 0x59e2d(%rip), %rsi     # 0x735f8
movl $0x5, %edx
movq %r15, %rdi
callq 0x12060
testl %eax, %eax
je 0x19803
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x59db9(%rip), %r8      # 0x735ac
movq %rbx, %rdi
movl $0x50, %esi
movl $0x83, %r9d
jmp 0x19822
movq (%r14), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x59d98(%rip), %r8      # 0x735ac
movq %rbx, %rdi
movl $0x51, %esi
movl $0x87, %r9d
popq %rbx
popq %r14
popq %r15
jmp 0x14618
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: prv_get_ass_op
static subtilis_assign_type_t
prv_get_ass_op(subtilis_parser_t *p, subtilis_token_t *t, subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_assign_type_t at = SUBTILIS_ASSIGN_TYPE_UNKNOWN;

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

	if (!strcmp(tbuf, "=")) {
		at = SUBTILIS_ASSIGN_TYPE_EQUAL;
	} else if (!strcmp(tbuf, "+=")) {
		at = SUBTILIS_ASSIGN_TYPE_PLUS_EQUAL;
	} else if (!strcmp(tbuf, "-=")) {
		at = SUBTILIS_ASSIGN_TYPE_MINUS_EQUAL;
	} else if (!strcmp(tbuf, ":=")) {
		at = SUBTILIS_ASSIGN_TYPE_CREATE_EQUAL;
	} else {
		subtilis_error_set_assignment_op_expected(
		    err, tbuf, p->l->stream->name, p->l->line);
	}

	return at;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq %rsi, %rdi
callq 0x12ad0
movq %rax, %r14
movl $0x9c, %r10d
cmpl $0x2, (%r12)
jne 0x1a0c1
leaq 0x5958e(%rip), %rsi     # 0x73604
movq %r14, %rdi
callq 0x12160
testl %eax, %eax
je 0x1a0f8
leaq 0x59553(%rip), %rsi     # 0x735dc
movq %r14, %rdi
callq 0x12160
testl %eax, %eax
je 0x1a0fc
leaq 0x59543(%rip), %rsi     # 0x735df
movq %r14, %rdi
callq 0x12160
testl %eax, %eax
je 0x1a103
leaq 0x598d8(%rip), %rsi     # 0x73987
movq %r14, %rdi
callq 0x12160
movl $0xaa, %r10d
testl %eax, %eax
je 0x1a10a
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x594d9(%rip), %rax     # 0x735ac
leaq 0x59d1b(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x14, %esi
movq %r14, %rdx
pushq %r10
pushq %rax
callq 0x1442a
addq $0x10, %rsp
movl $0x4, %eax
jmp 0x1a10f
xorl %eax, %eax
jmp 0x1a10f
movl $0x1, %eax
jmp 0x1a10f
movl $0x2, %eax
jmp 0x1a10f
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_proc_name_and_type
static char *prv_proc_name_and_type(subtilis_parser_t *p, subtilis_token_t *t,
				    subtilis_type_t *type, bool keep_prefix,
				    subtilis_error_t *err)
{
	const char *tbuf;
	char *name = NULL;

	tbuf = subtilis_token_get_text(t);
	if ((t->type != SUBTILIS_TOKEN_KEYWORD) ||
	    ((t->tok.keyword.type != SUBTILIS_KEYWORD_PROC) &&
	     (t->tok.keyword.type != SUBTILIS_KEYWORD_FN))) {
		subtilis_error_set_expected(err, "PROC or FN", tbuf,
					    p->l->stream->name, p->l->line);
		return NULL;
	}

	if (!keep_prefix) {
		if (t->tok.keyword.type == SUBTILIS_KEYWORD_PROC)
			tbuf += 4;
		else if (t->tok.keyword.type == SUBTILIS_KEYWORD_FN)
			tbuf += 2;
	}

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

	subtilis_type_copy(type, &t->tok.keyword.id_type, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		free(name);
		return NULL;
	}

	if ((type->type == SUBTILIS_TYPE_FN) ||
	    (type->type == SUBTILIS_TYPE_REC)) {
		subtilis_complete_custom_type(p, tbuf, type, err);
		if (err->type != SUBTILIS_ERROR_OK) {
			free(name);
			return NULL;
		}
	}
	strcpy(name, tbuf);

	return name;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq %rsi, %rdi
callq 0x12ad0
movq %rax, %r14
cmpl $0x1, (%r13)
jne 0x1a7c2
movl 0x8(%r13), %eax
cmpl $0x2, %eax
jae 0x1a7c2
testb %bpl, %bpl
jne 0x1a80b
testb $0x1, %al
je 0x1a807
addq $0x4, %r14
jmp 0x1a80b
movq (%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x58e4b(%rip), %rax     # 0x73620
leaq 0x58ce4(%rip), %rdx     # 0x734c0
movq %rbx, %rdi
movl $0x1d, %esi
movq %r14, %rcx
pushq $0xf1
pushq %rax
callq 0x1442a
addq $0x10, %rsp
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x2, %r14
movq %r14, %rdi
callq 0x120f0
leaq 0x1(%rax), %rdi
callq 0x121d0
testq %rax, %rax
je 0x1a845
movq %rax, %rbp
addq $0x10, %r13
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2fa5f
cmpl $0x0, (%rbx)
je 0x1a860
movq %rbp, %rdi
callq 0x122c0
jmp 0x1a7f6
leaq 0x58dd4(%rip), %rdx     # 0x73620
movq %rbx, %rdi
movl $0x1, %esi
movl $0xfe, %ecx
callq 0x145f4
jmp 0x1a7f6
movl (%r15), %eax
cmpl $0x16, %eax
je 0x1a86d
cmpl $0x9, %eax
jne 0x1a883
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1f7e6
cmpl $0x0, (%rbx)
jne 0x1a83b
movq %rbp, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12070
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_process_vector_fn_type
static void prv_process_vector_fn_type(subtilis_parser_t *p, const char *name,
				       subtilis_type_t *fn_type,
				       subtilis_error_t *err)
{
	subtilis_type_t fn_type_old;

	if (fn_type->type == SUBTILIS_TYPE_VOID) {
		subtilis_error_set_bad_proc_name(err, name, p->l->stream->name,
						 p->l->line);
		return;
	}

	subtilis_type_init_copy(&fn_type_old, fn_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_type_if_vector_of(&fn_type_old, fn_type, err);
	subtilis_type_free(&fn_type_old);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	fn_type->params.array.num_dims = 1;
	fn_type->params.array.dims[0] = SUBTILIS_DYNAMIC_DIMENSION;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rcx, %rbx
movq %rdx, %r14
cmpl $0x8, (%rdx)
jne 0x1a8eb
movq %rsi, %rdx
movq (%rdi), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x58d58(%rip), %rax     # 0x73620
leaq 0x59526(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0xb, %esi
pushq $0x142                  # imm = 0x142
pushq %rax
callq 0x1442a
addq $0x160, %rsp            # imm = 0x160
jmp 0x1a935
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2f72e
cmpl $0x0, (%rbx)
jne 0x1a92e
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x36164
movq %r15, %rdi
callq 0x2f843
cmpl $0x0, (%rbx)
jne 0x1a92e
movabsq $-0xffffffff, %rax      # imm = 0xFFFFFFFF00000001
movq %rax, 0x8(%r14)
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_process_array_fn_type
static void prv_process_array_fn_type(subtilis_parser_t *p,
				      subtilis_exp_t **poss_args,
				      size_t num_poss_args, const char *name,
				      subtilis_type_t *fn_type,
				      subtilis_error_t *err)
{
	subtilis_type_t fn_type_old;
	size_t i;

	if (fn_type->type == SUBTILIS_TYPE_VOID) {
		subtilis_error_set_bad_proc_name(err, name, p->l->stream->name,
						 p->l->line);
		return;
	}

	if ((num_poss_args != 1) ||
	    (poss_args[0]->type.type != SUBTILIS_TYPE_CONST_INTEGER) ||
	    (poss_args[0]->exp.ir_op.integer < 1) ||
	    (poss_args[0]->exp.ir_op.integer > SUBTILIS_MAX_DIMENSIONS)) {
		subtilis_error_bad_dim(err, "return type", p->l->stream->name,
				       p->l->line);
		return;
	}

	subtilis_type_init_copy(&fn_type_old, fn_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_type_if_array_of(&fn_type_old, fn_type, err);
	subtilis_type_free(&fn_type_old);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	fn_type->params.array.num_dims = poss_args[0]->exp.ir_op.integer;
	for (i = 0; i < fn_type->params.array.num_dims; i++)
		fn_type->params.array.dims[i] = SUBTILIS_DYNAMIC_DIMENSION;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %r9, %r14
cmpl $0x8, (%r8)
jne 0x1a982
movq (%rdi), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x58cbc(%rip), %r10     # 0x73620
leaq 0x5948a(%rip), %rax     # 0x73df5
movq %r14, %rdi
movl $0xb, %esi
movq %rcx, %rdx
movq %rax, %rcx
pushq $0x120                  # imm = 0x120
pushq %r10
jmp 0x1a9cf
cmpq $0x1, %rdx
jne 0x1a9a1
movq %rsi, %r15
movq (%rsi), %rax
cmpl $0x1, (%rax)
jne 0x1a9a1
movl 0x148(%rax), %eax
addl $-0xb, %eax
cmpl $-0xb, %eax
ja 0x1a9e3
movq (%rdi), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x58c6d(%rip), %rax     # 0x73620
leaq 0x58c7d(%rip), %rdx     # 0x73637
leaq 0x59434(%rip), %rcx     # 0x73df5
movq %r14, %rdi
movl $0x38, %esi
pushq $0x129                  # imm = 0x129
pushq %rax
callq 0x1442a
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r8, %rbx
movq %rsp, %rdi
movq %r8, %rsi
movq %r14, %rdx
callq 0x2f72e
cmpl $0x0, (%r14)
jne 0x1aa3f
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3610f
movq %r12, %rdi
callq 0x2f843
cmpl $0x0, (%r14)
jne 0x1aa3f
movq (%r15), %rax
movl 0x148(%rax), %eax
movl %eax, 0x8(%rbx)
testl %eax, %eax
je 0x1aa3f
xorl %eax, %eax
movl $0xffffffff, 0xc(%rbx,%rax,4) # imm = 0xFFFFFFFF
incq %rax
movslq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jb 0x1aa2b
addq $0x148, %rsp            # imm = 0x148
jmp 0x1a9db
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_parser_to_ir_args
static subtilis_ir_arg_t *prv_parser_to_ir_args(subtilis_parser_param_t *params,
						size_t num_params,
						subtilis_error_t *err)
{
	size_t i;
	subtilis_ir_arg_t *args = malloc(sizeof(*args) * num_params);

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

	for (i = 0; i < num_params; i++) {
		args[i].type = subtilis_type_if_reg_type(&params[i].type);
		args[i].reg = params[i].reg;
		args[i].nop = params[i].nop;
	}

	return args;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq (,%rsi,8), %rax
leaq (%rax,%rax,2), %rdi
callq 0x121d0
testq %rax, %rax
je 0x1ad0f
movq %rax, %rbx
testq %r14, %r14
je 0x1ad2a
movq %rbx, %r12
addq $0x10, %r12
movq %r15, %rdi
callq 0x37b0a
movl %eax, -0x10(%r12)
movq 0x148(%r15), %rax
movq %rax, -0x8(%r12)
movq 0x150(%r15), %rax
movq %rax, (%r12)
addq $0x18, %r12
addq $0x158, %r15            # imm = 0x158
decq %r14
jne 0x1acd9
jmp 0x1ad2a
leaq 0x5890a(%rip), %rdx     # 0x73620
movq %r12, %rdi
movl $0x1, %esi
movl $0x31, %ecx
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/parser_call.c
// Function: prv_parser_to_ptypes
static subtilis_type_t *prv_parser_to_ptypes(subtilis_parser_param_t *params,
					     size_t num_params,
					     subtilis_error_t *err)
{
	size_t i;
	subtilis_type_t *ptypes = malloc(sizeof(*ptypes) * num_params);

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

	for (i = 0; i < num_params; i++) {
		subtilis_type_init_copy(&ptypes[i], &params[i].type, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return NULL;
	}

	return ptypes;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
imulq $0x148, %rsi, %rdi      # imm = 0x148
callq 0x121d0
testq %rax, %rax
je 0x1ad90
movq %rax, %rbx
testq %r15, %r15
je 0x1adab
movq %rbx, %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2f72e
cmpl $0x0, (%r14)
jne 0x1ada9
addq $0x158, %r12            # imm = 0x158
addq $0x148, %r13            # imm = 0x148
decq %r15
jne 0x1ad67
jmp 0x1adab
leaq 0x58889(%rip), %rdx     # 0x73620
movq %r14, %rdi
movl $0x1, %esi
movl $0x46, %ecx
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/parser_call.c
// Function: prv_delete_params
static void prv_delete_params(subtilis_parser_param_t *params, size_t num_args)
{
	size_t i;

	if (!params)
		return;

	for (i = 0; i < num_args; i++)
		subtilis_type_free(&params[i].type);

	free(params);
}

// Assembly:
testq %rdi, %rdi
je 0x1adf1
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1ade4
movq %rbx, %r15
movq %r15, %rdi
callq 0x2f843
addq $0x158, %r15            # imm = 0x158
decq %r14
jne 0x1add0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_complete_fn_name
static char *prv_complete_fn_name(char *name, const subtilis_type_t *fn_type,
				  subtilis_error_t *err)
{
	char buffer[64];
	int ptr;
	int name_len;
	char *new_name;

	if (subtilis_type_if_is_array(fn_type)) {
		ptr = snprintf(buffer, 64, "(%d)",
			       fn_type->params.array.num_dims);
		if (ptr >= 64) {
			subtilis_error_set_assertion_failed(err);
			goto on_error;
		}
	} else if (subtilis_type_if_is_vector(fn_type)) {
		buffer[0] = '{';
		buffer[1] = '}';
		buffer[2] = 0;
		ptr = 2;
	} else {
		return name;
	}

	name_len = strlen(name);
	new_name = realloc(name, name_len + ptr + 1);
	if (!new_name) {
		subtilis_error_set_oom(err);
		goto on_error;
	}
	strcpy(new_name + name_len, buffer);

	return new_name;

on_error:
	free(name);

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x377f7
testb %al, %al
je 0x1ae4a
movl 0x8(%r15), %ecx
leaq 0x58826(%rip), %rdx     # 0x73643
movq %rsp, %rdi
movl $0x40, %esi
xorl %eax, %eax
callq 0x12120
movl %eax, %r12d
cmpl $0x40, %eax
jl 0x1ae67
leaq 0x587e5(%rip), %rdx     # 0x73620
movq %r14, %rdi
movl $0xf, %esi
movl $0x162, %ecx            # imm = 0x162
jmp 0x1aeb1
movq %r15, %rdi
callq 0x37815
testb %al, %al
je 0x1aec0
movw $0x7d7b, (%rsp)         # imm = 0x7D7B
movb $0x0, 0x2(%rsp)
movl $0x2, %r12d
movq %rbx, %rdi
callq 0x120f0
movq %rax, %r15
addl %r12d, %eax
incl %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x12210
testq %rax, %rax
je 0x1ae9d
movq %rax, %r12
movslq %r15d, %rdi
addq %rax, %rdi
movq %rsp, %rsi
callq 0x12070
movq %r12, %rbx
jmp 0x1aec0
leaq 0x5877c(%rip), %rdx     # 0x73620
movq %r14, %rdi
movl $0x1, %esi
movl $0x171, %ecx            # imm = 0x171
callq 0x145f4
movq %rbx, %rdi
callq 0x122c0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_delete_ptypes
static void prv_delete_ptypes(subtilis_type_t *ptypes, size_t num_args)
{
	size_t i;

	if (!ptypes)
		return;

	for (i = 0; i < num_args; i++)
		subtilis_type_free(&ptypes[i]);

	free(ptypes);
}

// Assembly:
testq %rdi, %rdi
je 0x1af08
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1aefb
movq %rbx, %r15
movq %r15, %rdi
callq 0x2f843
addq $0x148, %r15            # imm = 0x148
decq %r14
jne 0x1aee7
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: subtilis_parser_def
void subtilis_parser_def(subtilis_parser_t *p, subtilis_token_t *t,
			 subtilis_error_t *err)
{
	subtilis_type_t return_type;
	subtilis_type_t section_type;
	subtilis_symbol_table_t *local_st = NULL;
	char *name = NULL;

	return_type.type = SUBTILIS_TYPE_VOID;
	section_type.type = SUBTILIS_TYPE_VOID;

	if (p->current != p->main) {
		subtilis_error_set_nested_procedure(err, p->l->stream->name,
						    p->l->line);
		return;
	}

	local_st = subtilis_symbol_table_new(err);
	p->local_st = local_st;
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

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

	name = prv_initial_proc_fn_type(p, t, &return_type, false, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	prv_def_internal(p, t, &return_type, &section_type, name, local_st,
			 NULL, err);
	name = NULL;

on_error:

	subtilis_symbol_table_delete(local_st);
	free(name);
	subtilis_type_free(&section_type);
	subtilis_type_free(&return_type);
	p->local_st = p->main_st;
	p->current = p->main;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdx, %r12
movq %rdi, %rbx
movl $0x8, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x158(%rsp)
movq 0x48(%rdi), %rax
cmpq 0x50(%rdi), %rax
je 0x1af60
movq (%rbx), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
movq %r12, %rdi
movl $0x21, %esi
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x145f4
movq %rsi, %r15
movq %r12, %rdi
callq 0x2e528
movq %rax, %r14
movq %rax, 0x68(%rbx)
cmpl $0x0, (%r12)
jne 0x1af8e
movq (%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x12eda
cmpl $0x0, (%r12)
je 0x1afd9
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x2e5e7
movq %r13, %rdi
callq 0x122c0
leaq 0x158(%rsp), %rdi
callq 0x2f843
leaq 0x10(%rsp), %rdi
callq 0x2f843
movq 0x50(%rbx), %rax
movq 0x70(%rbx), %rcx
movq %rcx, 0x68(%rbx)
movq %rax, 0x48(%rbx)
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
movq %r12, %r8
callq 0x1b01f
movq %rax, %r13
cmpl $0x0, (%r12)
jne 0x1af91
movq %r12, (%rsp)
leaq 0x10(%rsp), %rdx
leaq 0x158(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %r8
xorl %r9d, %r9d
callq 0x1b0b7
jmp 0x1af8e
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_initial_proc_fn_type
static char *prv_initial_proc_fn_type(subtilis_parser_t *p, subtilis_token_t *t,
				      subtilis_type_t *ftype, bool keep_prefix,
				      subtilis_error_t *err)
{
	subtilis_type_t fn_type;
	char *name = NULL;

	fn_type.type = SUBTILIS_TYPE_VOID;

	name = prv_proc_name_and_type(p, t, &fn_type, keep_prefix, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	prv_complete_proc_fn_type(p, t, &fn_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	subtilis_type_copy(ftype, &fn_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	subtilis_type_free(&fn_type);
	return name;

on_error:
	subtilis_type_free(&fn_type);
	free(name);

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x8(%rsp), %rdx
movl $0x8, (%rdx)
callq 0x1a77f
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x1b083
leaq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rcx
callq 0x1d335
cmpl $0x0, (%r14)
jne 0x1b083
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x2fa5f
cmpl $0x0, (%r14)
je 0x1b0ab
leaq 0x8(%rsp), %rdi
callq 0x2f843
movq %rbx, %rdi
callq 0x122c0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rdi
callq 0x2f843
jmp 0x1b097
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: subtilis_parser_call_ptr
subtilis_exp_t *subtilis_parser_call_ptr(subtilis_parser_t *p,
					 subtilis_token_t *t,
					 const subtilis_symbol_t *s,
					 const char *var_name, size_t mem_reg,
					 subtilis_error_t *err)
{
	size_t reg;
	subtilis_exp_t *e;

	if (!s->is_reg) {
		e = subtilis_type_if_load_from_mem(p, &s->t, mem_reg, s->loc,
						   err);
		reg = e->exp.ir_op.reg;
		subtilis_exp_delete(e);
	} else {
		reg = s->loc;
	}

	return subtilis_parser_call_known_ptr(p, t, &s->t, reg, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpb $0x0, 0x2a8(%rdx)
je 0x1c2e4
movq (%r14), %r13
jmp 0x1c308
leaq 0x8(%r14), %rsi
movq (%r14), %rcx
movq %r12, %rdi
movq %r8, %rdx
movq %rbx, %r8
callq 0x364c2
movq 0x148(%rax), %r13
movq %rax, %rdi
callq 0x2b4c3
addq $0x8, %r14
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1c019
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: subtilis_parser_unwind
void subtilis_parser_unwind(subtilis_parser_t *p, subtilis_error_t *err)
{
	subtilis_ir_operand_t start_label;
	subtilis_ir_operand_t start_inner_label;
	subtilis_ir_operand_t end_label;
	subtilis_ir_operand_t counter;

	if (p->current->cleanup_stack == SIZE_MAX)
		return;

	start_label.label = subtilis_ir_section_new_label(p->current);
	start_inner_label.label = subtilis_ir_section_new_label(p->current);
	end_label.label = subtilis_ir_section_new_label(p->current);
	counter.reg = p->current->cleanup_stack;

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

	subtilis_ir_section_add_instr_reg(p->current, SUBTILIS_OP_INSTR_JMPC,
					  counter, start_inner_label, end_label,
					  err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_ir_section_add_label(p->current, start_inner_label.label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x48(%rdi), %rdi
cmpq $-0x1, 0xb8(%rdi)
je 0x1c9b6
movq %rsi, %rbx
callq 0x2d00a
movq %rax, %r15
movq 0x48(%r14), %rdi
callq 0x2d00a
movq %rax, %r13
movq 0x48(%r14), %rdi
callq 0x2d00a
movq %rax, %r12
movq 0x48(%r14), %rdi
movq 0xb8(%rdi), %rbp
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2d017
cmpl $0x0, (%rbx)
jne 0x1c9b6
movq 0x48(%r14), %rdi
movl $0x43, %esi
movq %rbp, %rdx
movq %r13, %rcx
movq %r12, %r8
movq %rbx, %r9
callq 0x2c0c2
cmpl $0x0, (%rbx)
jne 0x1c9b6
movq 0x48(%r14), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2d017
cmpl $0x0, (%rbx)
jne 0x1c9b6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4e83d
cmpl $0x0, (%rbx)
jne 0x1c9b6
movq 0x48(%r14), %rdi
movl $0x45, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2c19f
cmpl $0x0, (%rbx)
je 0x1c9c5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x48(%r14), %rdi
movq %r12, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2d017
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: subtilis_parser_return
void subtilis_parser_return(subtilis_parser_t *p, subtilis_token_t *t,
			    subtilis_error_t *err)
{
	subtilis_exp_t *e;
	subtilis_type_t fn_type;
	subtilis_ir_operand_t end_label;

	if (p->current == p->main) {
		subtilis_error_set_return_in_main(err, p->l->stream->name,
						  p->l->line);
		return;
	}

	subtilis_type_init_copy(&fn_type,
				p->current->type->type.params.fn.ret_val, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	if (fn_type.type == SUBTILIS_TYPE_VOID) {
		subtilis_error_set_return_in_proc(err, p->l->stream->name,
						  p->l->line);
		goto cleanup;
	}

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

	/* Ownership of e is passed to add_fn_ret */

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

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

	p->current->endproc = true;

cleanup:
	subtilis_type_free(&fn_type);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rdx, %rbx
movq %rdi, %r14
movq 0x48(%rdi), %rax
cmpq 0x50(%rdi), %rax
je 0x1ca4f
movq %rsi, %r15
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x2f72e
cmpl $0x0, (%rbx)
jne 0x1cadc
cmpl $0x8, 0x8(%rsp)
jne 0x1ca7f
movq (%r14), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x56be9(%rip), %r8      # 0x73620
movq %rbx, %rdi
movl $0x30, %esi
movl $0x6ca, %r9d            # imm = 0x6CA
callq 0x14618
jmp 0x1cad2
movq (%r14), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x56bc0(%rip), %r8      # 0x73620
movq %rbx, %rdi
movl $0x2f, %esi
movl $0x6c0, %r9d            # imm = 0x6C0
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %r15
jmp 0x14618
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1eb88
cmpl $0x0, (%rbx)
jne 0x1cad2
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0x1cae9
cmpl $0x0, (%rbx)
jne 0x1cad2
movq 0x48(%r14), %rdi
movq 0x98(%rdi), %rdx
movl $0x45, %esi
movq %rbx, %rcx
callq 0x2c19f
cmpl $0x0, (%rbx)
jne 0x1cad2
movq 0x48(%r14), %rax
movb $0x1, 0x88(%rax)
leaq 0x8(%rsp), %rdi
callq 0x2f843
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: subtilis_parser_endproc
void subtilis_parser_endproc(subtilis_parser_t *p, subtilis_token_t *t,
			     subtilis_error_t *err)
{
	subtilis_ir_operand_t end_label;

	if (p->current == p->main) {
		subtilis_error_set_proc_in_main(err, p->l->stream->name,
						p->l->line);
		return;
	}

	if (p->current->type->type.params.fn.ret_val->type !=
	    SUBTILIS_TYPE_VOID) {
		subtilis_error_set_proc_in_fn(err, p->l->stream->name,
					      p->l->line);
		return;
	}

	p->current->endproc = true;
	end_label.label = p->current->end_label;
	subtilis_ir_section_add_instr_no_reg(p->current, SUBTILIS_OP_INSTR_JMP,
					     end_label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_lexer_get(p->l, t, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r15
movq 0x48(%rdi), %rdi
cmpq 0x50(%r15), %rdi
je 0x1cb70
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
cmpl $0x8, (%rax)
jne 0x1cb91
movq %rsi, %r14
movb $0x1, 0x88(%rdi)
movq 0x98(%rdi), %rdx
movl $0x45, %esi
movq %rbx, %rcx
callq 0x2c19f
cmpl $0x0, (%rbx)
je 0x1cbba
popq %rbx
popq %r14
popq %r15
retq
movq (%r15), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x56a9f(%rip), %r8      # 0x73620
movq %rbx, %rdi
movl $0x2d, %esi
movl $0x6eb, %r9d            # imm = 0x6EB
jmp 0x1cbb0
movq (%r15), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x56a7e(%rip), %r8      # 0x73620
movq %rbx, %rdi
movl $0x34, %esi
movl $0x6f2, %r9d            # imm = 0x6F2
popq %rbx
popq %r14
popq %r15
jmp 0x14618
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x12eda
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: subtilis_parser_call_add_addr
void subtilis_parser_call_add_addr(subtilis_parser_t *p,
				   const subtilis_type_t *type,
				   subtilis_exp_t *e, subtilis_error_t *err)
{
	subtilis_parser_call_addr_t *call_addr = NULL;

	/*
	 * We're taking the address of a function we may not have seen
	 * yet.
	 */

	subtilis_type_copy(&e->type, type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	call_addr = subtilis_parser_call_addr_new(
	    p->current, e->call_site, p->current->in_error_handler,
	    e->partial_name, &e->type, p->l->line, err);
	e->partial_name = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_exp_add_call_addrs(p, call_addr, err);
	if (err->type != SUBTILIS_ERROR_OK)
		subtilis_parser_call_addr_delete(call_addr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
movq %rdx, %rdi
movq %rcx, %rdx
callq 0x2fa5f
cmpl $0x0, (%rbx)
jne 0x1d300
movq (%r14), %rax
movq 0x48(%r14), %rdi
movq 0x160(%r15), %rcx
movq 0x168(%r15), %rsi
movzbl 0x60(%rdi), %edx
movl 0x38(%rax), %r9d
movq %rbx, (%rsp)
movq %r15, %r8
callq 0x35bf4
movq $0x0, 0x160(%r15)
cmpl $0x0, (%rbx)
je 0x1d30c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x2b284
cmpl $0x0, (%rbx)
je 0x1d300
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x35ca2
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_complete_proc_fn_type
static void prv_complete_proc_fn_type(subtilis_parser_t *p, subtilis_token_t *t,
				      subtilis_type_t *fn_type,
				      subtilis_error_t *err)
{
	subtilis_type_t id_type;
	const char *tbuf;

	id_type.type = SUBTILIS_TYPE_VOID;

	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_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;
		}
		subtilis_lexer_get(p->l, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		tbuf = subtilis_token_get_text(t);

		subtilis_type_init_copy(&id_type, fn_type, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;

		subtilis_type_if_vector_of(&id_type, fn_type, err);
		subtilis_type_free(&id_type);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		fn_type->params.array.num_dims = 1;
		fn_type->params.array.dims[0] = SUBTILIS_DYNAMIC_DIMENSION;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x8, 0x8(%rsp)
movq (%rdi), %rdi
movq %rcx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x1d39e
movq %r15, %rdi
callq 0x12ad0
cmpl $0x2, (%r15)
jne 0x1d39e
leaq 0x592d3(%rip), %rsi     # 0x76651
movq %rax, %rdi
callq 0x12160
testl %eax, %eax
jne 0x1d39e
movq (%r12), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
je 0x1d3af
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x12ad0
movq %rax, %r13
cmpl $0x2, (%r15)
jne 0x1d3d3
leaq 0x56254(%rip), %rsi     # 0x7361b
movq %r13, %rdi
callq 0x12160
testl %eax, %eax
je 0x1d40c
movq (%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x5623a(%rip), %rax     # 0x73620
leaq 0x56230(%rip), %rdx     # 0x7361d
movq %rbx, %rdi
movl $0x1d, %esi
movq %r13, %rcx
pushq $0x427                  # imm = 0x427
pushq %rax
callq 0x1442a
addq $0x160, %rsp            # imm = 0x160
jmp 0x1d3a5
movq (%r12), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x1d39e
movq %r15, %rdi
callq 0x12ad0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2f72e
cmpl $0x0, (%rbx)
jne 0x1d39e
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x36164
movq %r15, %rdi
callq 0x2f843
cmpl $0x0, (%rbx)
jne 0x1d39e
movabsq $-0xffffffff, %rax      # imm = 0xFFFFFFFF00000001
movq %rax, 0x8(%r14)
jmp 0x1d39e
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_parser_assembly
static void prv_parser_assembly(subtilis_parser_t *p, subtilis_token_t *t,
				const char *name,
				subtilis_type_section_t *stype,
				size_t *call_index, subtilis_error_t *err)
{
	subtilis_error_t err2;
	void *asm_code = NULL;

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

	asm_code = p->backend.asm_parse(p->l, t, p->backend.backend_data, stype,
					&p->settings, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	subtilis_ir_prog_asm_section_new(
	    p->prog, name, stype, p->l->stream->name, p->l->line,
	    p->eflag_offset, p->error_offset, p->backend.asm_free, asm_code,
	    call_index, err);
	stype = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	subtilis_error_init(&err2);
	subtilis_lexer_set_ass_keywords(p->l, false, &err2);

	subtilis_lexer_get(p->l, t, err);
	return;

on_error:

	subtilis_type_section_delete(stype);

	subtilis_error_init(&err2);
	subtilis_lexer_set_ass_keywords(p->l, false, &err2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc18, %rsp            # imm = 0xC18
movq %r9, %r14
movq %r8, %r13
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x1, %esi
movq %r9, %rdx
callq 0x12a77
cmpl $0x0, (%r14)
jne 0x1d518
movq (%rbx), %rdi
movq 0x40(%rbx), %rdx
leaq 0xb8(%rbx), %r8
movq %r15, %rsi
movq %r12, %rcx
movq %r14, %r9
callq *0x30(%rbx)
cmpl $0x0, (%r14)
jne 0x1d518
movq 0x58(%rbx), %rdi
movq (%rbx), %rdx
movq 0x30(%rdx), %rcx
movl 0x38(%rdx), %r8d
movl 0xb0(%rbx), %r9d
movl 0xb4(%rbx), %r10d
subq $0x8, %rsp
movq %rbp, %rsi
movq %r12, %rdx
pushq %r14
pushq %r13
pushq %rax
pushq 0x38(%rbx)
pushq %r10
callq 0x2c7fa
addq $0x30, %rsp
cmpl $0x0, (%r14)
je 0x1d54c
xorl %r12d, %r12d
movq %r12, %rdi
callq 0x2f7d2
leaq 0xc(%rsp), %r14
movq %r14, %rdi
callq 0x14404
movq (%rbx), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x12a77
addq $0xc18, %rsp            # imm = 0xC18
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc(%rsp), %r12
movq %r12, %rdi
callq 0x14404
movq (%rbx), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12a77
movq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12eda
jmp 0x1d53a
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_fn_compound
static void prv_fn_compound(subtilis_parser_t *p, subtilis_token_t *t,
			    subtilis_error_t *err)
{
	unsigned int start;
	const char *tbuf;

	start = p->l->line;
	while (t->type != SUBTILIS_TOKEN_EOF) {
		tbuf = subtilis_token_get_text(t);
		if ((t->type == SUBTILIS_TOKEN_OPERATOR) &&
		    !strcmp(tbuf, "<-") && (p->level == 0))
			break;

		subtilis_parser_statement(p, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

	if (t->type == SUBTILIS_TOKEN_EOF)
		subtilis_error_set_compund_not_term(err, p->l->stream->name,
						    start);
	//	p->current->endproc = false;
	p->current->handler_list =
	    subtilis_handler_list_truncate(p->current->handler_list, p->level);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x38(%rax), %ebp
leaq 0x55d77(%rip), %r12     # 0x734a9
cmpl $0x0, (%r15)
je 0x1d772
movq %r15, %rdi
callq 0x12ad0
cmpl $0x2, (%r15)
jne 0x1d75c
movq %rax, %rdi
movq %r12, %rsi
callq 0x12160
testl %eax, %eax
jne 0x1d75c
cmpq $0x0, 0x78(%rbx)
je 0x1d772
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x150d5
cmpl $0x0, (%r14)
je 0x1d732
jmp 0x1d7b4
cmpl $0x0, (%r15)
jne 0x1d79b
movq (%rbx), %rax
movq 0x30(%rax), %rdx
leaq 0x55e9a(%rip), %r8      # 0x73620
movq %r14, %rdi
movl $0x1e, %esi
movl %ebp, %ecx
movl $0x398, %r9d            # imm = 0x398
callq 0x14618
movq 0x48(%rbx), %rax
movq 0x78(%rbx), %rsi
movq 0x78(%rax), %rdi
callq 0x2be75
movq 0x48(%rbx), %rcx
movq %rax, 0x78(%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq