LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: subtilis_parser_zero_local_fn
void subtilis_parser_zero_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 = NULL;

	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;
	e = subtilis_type_if_zero(p, &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 %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %r8, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq %rsp, %rdi
movq %rcx, %rsi
movq %r8, %rdx
callq 0x2db73
cmpl $0x0, (%rbx)
jne 0x17b10
movq %rsp, %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x1eb36
cmpl $0x0, (%rbx)
je 0x17ad0
xorl %r12d, %r12d
jmp 0x17b00
movq %rsp, %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x33e86
movq %rax, %r12
cmpl $0x0, (%rbx)
jne 0x17b00
movq 0x68(%r15), %rdi
movq 0x148(%r12), %rcx
movq %rsp, %rdx
movq %r14, %rsi
movq %rbx, %r8
callq 0x2d0fe
movq %r12, %rdi
callq 0x29d88
movq %rsp, %rdi
callq 0x2dc7c
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1dfd5
cmpl $0x0, (%r14)
jne 0x17bf8
movq %rax, %rbx
cmpl $0x9, (%rax)
jne 0x17ba7
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2db73
cmpl $0x0, (%r14)
jne 0x17bf8
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
callq 0x1eb36
cmpl $0x0, (%r14)
jne 0x17be6
cmpq $0x0, 0x160(%rbx)
je 0x17c09
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1cc3c
jmp 0x17c1f
movq %r13, %rdi
callq 0x2dcbb
movq %rax, %r12
movq %rbx, %rdi
callq 0x2dcbb
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x559d8(%rip), %r10     # 0x6d5a4
pushq $0x1d
popq %rsi
movq %r14, %rdi
movq %r12, %rdx
movq %rax, %rcx
pushq $0x21e                  # imm = 0x21E
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %rbx, %rdi
callq 0x29d88
leaq 0x8(%rsp), %rdi
callq 0x2dc7c
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 0x35977
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x17be6
movq 0x68(%r15), %rdi
movq 0x148(%rbx), %rcx
leaq 0x8(%rsp), %rdx
movq %r12, %rsi
movq %r14, %r8
callq 0x2d0fe
jmp 0x17be6
// File: /workspace/github_c_makefile_star2_O2/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 0x2db73
cmpl $0x0, (%r15)
jne 0x17cb3
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x1eb36
cmpl $0x0, (%r15)
jne 0x17ca9
movq %r15, (%rsp)
leaq 0x10(%rsp), %rdx
pushq $0x1
popq %r8
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rcx
movl %r8d, %r9d
callq 0x288d1
leaq 0x10(%rsp), %rdi
callq 0x2dc7c
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12a25
movq %rax, %rbp
movq %rax, %rdi
callq 0x120f0
leaq 0x1(%rax), %rdi
callq 0x121d0
testq %rax, %rax
je 0x17d29
movq %rax, %r14
movq %rax, %rdi
movq %rbp, %rsi
callq 0x12070
movl 0x8(%r15), %eax
cmpl $0x16, %eax
je 0x17d16
cmpl $0x9, %eax
jne 0x17d42
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x1eb36
jmp 0x17d51
leaq 0x55874(%rip), %rdx     # 0x6d5a4
pushq $0x1
popq %rsi
movq %rbx, %rdi
movl $0x29a, %ecx            # imm = 0x29A
callq 0x1429e
jmp 0x17d72
leaq 0x8(%r15), %rsi
movq %r13, %rdi
movq %rbx, %rdx
callq 0x2de8a
cmpl $0x0, (%rbx)
jne 0x17d6a
movq (%r12), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
je 0x17d75
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_O2/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 0x2d376
movq %rax, (%r13)
testq %rax, %rax
je 0x17dc4
movq $0x2, (%r15)
jmp 0x17e56
movq 0x60(%r14), %rdi
movq %rbx, %rsi
callq 0x2d376
movq %rax, (%r13)
testq %rax, %rax
je 0x17de2
movq $0x1, (%r15)
jmp 0x17e56
movq 0x30(%rsp), %rdi
movq 0x48(%r14), %rax
cmpq 0x50(%r14), %rax
je 0x17e17
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x557a1(%rip), %rax     # 0x6d5a4
leaq 0x55fbb(%rip), %rcx     # 0x6ddc5
pushq $0x1b
popq %rsi
movq %rbx, %rdx
pushq $0x2dd                  # imm = 0x2DD
jmp 0x17e4e
movb $0x1, (%r12)
movq $0x1, (%r15)
cmpq $0x0, 0x78(%r14)
je 0x17e56
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x55768(%rip), %rax     # 0x6d5a4
leaq 0x55f82(%rip), %rcx     # 0x6ddc5
pushq $0x3e
popq %rsi
movq %rbx, %rdx
pushq $0x2d9                  # imm = 0x2D9
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/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 0x12e0e
cmpl $0x0, (%rbx)
jne 0x18ede
cmpl $0x6, (%r15)
jne 0x18ea6
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x17e60
movq %r15, %rdi
callq 0x12a25
movq (%r14), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x546e4(%rip), %r10     # 0x6d5a4
leaq 0x54efe(%rip), %rcx     # 0x6ddc5
pushq $0x12
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
pushq $0x4cb                  # imm = 0x4CB
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: subtilis_parser_swap
void subtilis_parser_swap(subtilis_parser_t *p, subtilis_token_t *t,
			  subtilis_error_t *err)
{
	const char *tbuf;
	bool lreg;
	bool rreg;
	subtilis_ir_operand_t lop;
	subtilis_ir_operand_t rop;
	subtilis_type_t ltype;
	subtilis_type_t rtype;

	ltype.type = SUBTILIS_TYPE_VOID;
	rtype.type = SUBTILIS_TYPE_VOID;

	lreg = subtilis_exp_get_lvalue(p, t, &lop, &ltype, 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;
	}

	rreg = subtilis_exp_get_lvalue(p, t, &rop, &rtype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_type_compare_diag_custom(p, &ltype, &rtype, NULL,
					  prv_swap_mismatch, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	if (lreg) {
		if (rreg)
			subtilis_type_if_swap_reg_reg(p, &ltype, lop.reg,
						      rop.reg, err);
		else
			subtilis_type_if_swap_reg_mem(p, &ltype, lop.reg,
						      rop.reg, err);
	} else if (rreg) {
		subtilis_type_if_swap_reg_mem(p, &ltype, rop.reg, lop.reg, err);
	} else {
		subtilis_type_if_swap_mem_mem(p, &ltype, lop.reg, rop.reg, err);
	}
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

cleanup:

	subtilis_type_free(&rtype);
	subtilis_type_free(&ltype);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2a8, %rsp            # imm = 0x2A8
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x8
popq %rax
leaq 0x18(%rsp), %rcx
movl %eax, (%rcx)
movl %eax, 0x160(%rsp)
leaq 0x10(%rsp), %rdx
movq %rbx, %r8
callq 0x1db8e
cmpl $0x0, (%rbx)
jne 0x18f68
movl %eax, %ebp
movq %r15, %rdi
callq 0x12a25
cmpl $0x2, (%r15)
jne 0x18f38
cmpb $0x2c, (%rax)
jne 0x18f38
cmpb $0x0, 0x1(%rax)
je 0x18f8d
movq (%r14), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x5465a(%rip), %r10     # 0x6d5a4
leaq 0x54641(%rip), %rdx     # 0x6d592
pushq $0x1d
popq %rsi
movq %rbx, %rdi
movq %rax, %rcx
pushq $0x4ee                  # imm = 0x4EE
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
leaq 0x160(%rsp), %rdi
callq 0x2dc7c
leaq 0x18(%rsp), %rdi
callq 0x2dc7c
addq $0x2a8, %rsp            # imm = 0x2A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rdx
leaq 0x160(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %r8
callq 0x1db8e
cmpl $0x0, (%rbx)
jne 0x18f68
movl %eax, %r15d
leaq 0x8b(%rip), %r8         # 0x19042
leaq 0x18(%rsp), %rsi
leaq 0x160(%rsp), %rdx
movq %r14, %rdi
xorl %ecx, %ecx
movq %rbx, %r9
callq 0x35ce0
cmpl $0x0, (%rbx)
jne 0x18f68
testb %bpl, %bpl
je 0x18fff
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
testb %r15b, %r15b
je 0x1900e
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %r8
callq 0x35a1e
jmp 0x18f68
testb %r15b, %r15b
je 0x19023
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %r8
callq 0x35a50
jmp 0x18f68
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %r8
callq 0x35a82
jmp 0x18f68
// File: /workspace/github_c_makefile_star2_O2/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 0x5454b(%rip), %rsi     # 0x6d5d4
pushq $0x7
popq %rdx
movq %r15, %rdi
callq 0x12060
testl %eax, %eax
je 0x190e0
leaq 0x5453d(%rip), %rsi     # 0x6d5dc
pushq $0x7
popq %rdx
movq %r15, %rdi
callq 0x12060
testl %eax, %eax
je 0x190e0
leaq 0x5452f(%rip), %rsi     # 0x6d5e4
pushq $0x5
popq %rdx
movq %r15, %rdi
callq 0x12060
testl %eax, %eax
je 0x190ff
leaq 0x5451f(%rip), %rsi     # 0x6d5ea
pushq $0x5
popq %rdx
movq %r15, %rdi
callq 0x12060
testl %eax, %eax
je 0x190ff
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x544b3(%rip), %r8      # 0x6d5a4
pushq $0x50
popq %rsi
movq %rbx, %rdi
movl $0x83, %r9d
jmp 0x1911c
movq (%r14), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x54494(%rip), %r8      # 0x6d5a4
pushq $0x51
popq %rsi
movq %rbx, %rdi
movl $0x87, %r9d
popq %rbx
popq %r14
popq %r15
jmp 0x142c0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x12a25
cmpl $0x2, (%r15)
jne 0x19920
movzbl (%rax), %ecx
cmpl $0x2b, %ecx
je 0x19969
cmpl $0x2d, %ecx
je 0x19949
cmpl $0x3a, %ecx
je 0x19959
cmpl $0x3d, %ecx
jne 0x19975
cmpb $0x0, 0x1(%rax)
jne 0x19975
xorl %eax, %eax
jmp 0x199a8
movq (%r14), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x53c72(%rip), %r10     # 0x6d5a4
leaq 0x5448c(%rip), %rcx     # 0x6ddc5
pushq $0x14
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
pushq $0x9c
jmp 0x1999c
cmpb $0x3d, 0x1(%rax)
jne 0x19975
cmpb $0x0, 0x2(%rax)
jne 0x19975
pushq $0x2
jmp 0x199a7
cmpb $0x3d, 0x1(%rax)
jne 0x19975
cmpb $0x0, 0x2(%rax)
jne 0x19975
pushq $0x3
jmp 0x199a7
cmpb $0x3d, 0x1(%rax)
jne 0x19975
cmpb $0x0, 0x2(%rax)
je 0x199ae
movq (%r14), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x53c1d(%rip), %r10     # 0x6d5a4
leaq 0x54437(%rip), %rcx     # 0x6ddc5
pushq $0x14
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
pushq $0xaa
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
pushq $0x4
popq %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x1
jmp 0x199a7
// File: /workspace/github_c_makefile_star2_O2/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 0x12a25
movq %rax, %r14
cmpl $0x1, (%r13)
jne 0x1a40f
movl 0x8(%r13), %eax
cmpl $0x2, %eax
jae 0x1a40f
testb %bpl, %bpl
jne 0x1a454
cmpl $0x1, %eax
jne 0x1a450
addq $0x4, %r14
jmp 0x1a454
movq (%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x531ee(%rip), %rax     # 0x6d610
leaq 0x53094(%rip), %rdx     # 0x6d4bd
pushq $0x1d
popq %rsi
movq %rbx, %rdi
movq %r14, %rcx
pushq $0xf1
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
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 0x1a48e
movq %rax, %rbp
addq $0x10, %r13
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2de8a
cmpl $0x0, (%rbx)
je 0x1a4a7
movq %rbp, %rdi
callq 0x122c0
jmp 0x1a43f
leaq 0x5317b(%rip), %rdx     # 0x6d610
pushq $0x1
popq %rsi
movq %rbx, %rdi
movl $0xfe, %ecx
callq 0x1429e
jmp 0x1a43f
movl (%r15), %eax
cmpl $0x16, %eax
je 0x1a4b4
cmpl $0x9, %eax
jne 0x1a4ca
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1eb36
cmpl $0x0, (%rbx)
jne 0x1a484
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_O2/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
imulq $0x18, %rsi, %rdi
callq 0x121d0
movq %rax, %rbx
testq %rax, %rax
je 0x1a539
movq %rbx, %r12
addq $0x8, %r12
subq $0x1, %r14
jb 0x1a54e
movq %r15, %rdi
callq 0x35ab4
movl %eax, -0x8(%r12)
movups 0x148(%r15), %xmm0
movups %xmm0, (%r12)
addq $0x158, %r15            # imm = 0x158
addq $0x18, %r12
jmp 0x1a50c
leaq 0x530d0(%rip), %rdx     # 0x6d610
pushq $0x1
popq %rsi
pushq $0x31
popq %rcx
movq %r12, %rdi
callq 0x1429e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_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 0x1a594
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %r15
subq $0x1, %r14
jb 0x1a587
movq %r15, %rdi
callq 0x2dc7c
addq $0x158, %r15            # imm = 0x158
jmp 0x1a570
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x357cc
testb %al, %al
je 0x1a5e9
movl 0x8(%r15), %ecx
leaq 0x53073(%rip), %rdx     # 0x6d633
movq %rsp, %rdi
pushq $0x40
popq %rsi
xorl %eax, %eax
callq 0x12120
movl %eax, %r12d
cmpl $0x40, %eax
jl 0x1a604
leaq 0x53034(%rip), %rdx     # 0x6d610
pushq $0xf
popq %rsi
movq %r14, %rdi
movl $0x162, %ecx            # imm = 0x162
jmp 0x1a64c
movq %r15, %rdi
callq 0x357ea
testb %al, %al
je 0x1a65b
movw $0x7d7b, (%rsp)         # imm = 0x7D7B
movb $0x0, 0x2(%rsp)
pushq $0x2
popq %r12
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 0x1a63a
movq %rax, %r12
movslq %r15d, %rdi
addq %rax, %rdi
movq %rsp, %rsi
callq 0x12070
movq %r12, %rbx
jmp 0x1a65b
leaq 0x52fcf(%rip), %rdx     # 0x6d610
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x171, %ecx            # imm = 0x171
callq 0x1429e
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_O2/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 0x1a6a1
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %r15
subq $0x1, %r14
jb 0x1a694
movq %r15, %rdi
callq 0x2dc7c
addq $0x148, %r15            # imm = 0x148
jmp 0x1a67d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rdi, %rbx
pushq $0x8
popq %rax
movl %eax, 0x10(%rsp)
movl %eax, 0x158(%rsp)
movq 0x48(%rdi), %rax
cmpq 0x50(%rdi), %rax
je 0x1a6f5
movq (%rbx), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
pushq $0x21
popq %rsi
movq %r15, %rdi
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1429e
movq %rsi, %r12
movq %r15, %rdi
callq 0x2ca24
movq %rax, %r14
movq %rax, 0x68(%rbx)
cmpl $0x0, (%r15)
jne 0x1a721
movq (%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x12e0e
cmpl $0x0, (%r15)
je 0x1a76c
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x2cac8
movq %r13, %rdi
callq 0x122c0
leaq 0x158(%rsp), %rdi
callq 0x2dc7c
leaq 0x10(%rsp), %rdi
callq 0x2dc7c
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 %r12, %rsi
xorl %ecx, %ecx
movq %r15, %r8
callq 0x1a7b1
movq %rax, %r13
cmpl $0x0, (%r15)
jne 0x1a724
movq %r15, (%rsp)
leaq 0x10(%rsp), %rdx
leaq 0x158(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %r8
xorl %r9d, %r9d
callq 0x1a849
jmp 0x1a721
// File: /workspace/github_c_makefile_star2_O2/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 0x1a3cb
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x1a815
leaq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rcx
callq 0x1ccc5
cmpl $0x0, (%r14)
jne 0x1a815
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x2de8a
cmpl $0x0, (%r14)
je 0x1a83d
leaq 0x8(%rsp), %rdi
callq 0x2dc7c
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 0x2dc7c
jmp 0x1a829
// File: /workspace/github_c_makefile_star2_O2/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 0x1bd82
movq (%r14), %r13
jmp 0x1bda6
leaq 0x8(%r14), %rsi
movq (%r14), %rcx
movq %r12, %rdi
movq %r8, %rdx
movq %rbx, %r8
callq 0x343a4
movq 0x148(%rax), %r13
movq %rax, %rdi
callq 0x29d88
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 0x1bae2
// File: /workspace/github_c_makefile_star2_O2/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 0x1c3ee
movq %rsi, %rbx
callq 0x2b774
movq %rax, %r15
movq 0x48(%r14), %rdi
callq 0x2b774
movq %rax, %r13
movq 0x48(%r14), %rdi
callq 0x2b774
movq %rax, %r12
movq 0x48(%r14), %rdi
movq 0xb8(%rdi), %rbp
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2b781
cmpl $0x0, (%rbx)
jne 0x1c3ee
movq 0x48(%r14), %rdi
pushq $0x43
popq %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq %r12, %r8
movq %rbx, %r9
callq 0x2a8c1
cmpl $0x0, (%rbx)
jne 0x1c3ee
movq 0x48(%r14), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2b781
cmpl $0x0, (%rbx)
jne 0x1c3ee
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4bac7
cmpl $0x0, (%rbx)
jne 0x1c3ee
movq 0x48(%r14), %rdi
pushq $0x45
popq %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2a997
cmpl $0x0, (%rbx)
je 0x1c3fd
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 0x2b781
// File: /workspace/github_c_makefile_star2_O2/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 0x1c482
movq %rsi, %r15
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x2db73
cmpl $0x0, (%rbx)
jne 0x1c50b
cmpl $0x8, 0x8(%rsp)
jne 0x1c4b0
movq (%r14), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x511a1(%rip), %r8      # 0x6d610
pushq $0x30
popq %rsi
movq %rbx, %rdi
movl $0x6ca, %r9d            # imm = 0x6CA
callq 0x142c0
jmp 0x1c501
movq (%r14), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x5117d(%rip), %r8      # 0x6d610
pushq $0x2f
popq %rsi
movq %rbx, %rdi
movl $0x6c0, %r9d            # imm = 0x6C0
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %r15
jmp 0x142c0
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1dfd5
cmpl $0x0, (%rbx)
jne 0x1c501
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0x1c518
cmpl $0x0, (%rbx)
jne 0x1c501
movq 0x48(%r14), %rdi
movq 0x98(%rdi), %rdx
pushq $0x45
popq %rsi
movq %rbx, %rcx
callq 0x2a997
cmpl $0x0, (%rbx)
jne 0x1c501
movq 0x48(%r14), %rax
movb $0x1, 0x88(%rax)
leaq 0x8(%rsp), %rdi
callq 0x2dc7c
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c59d
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
cmpl $0x8, (%rax)
jne 0x1c5bc
movq %rsi, %r14
movb $0x1, 0x88(%rdi)
movq 0x98(%rdi), %rdx
pushq $0x45
popq %rsi
movq %rbx, %rcx
callq 0x2a997
cmpl $0x0, (%rbx)
je 0x1c5e3
popq %rbx
popq %r14
popq %r15
retq
movq (%r15), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x51062(%rip), %r8      # 0x6d610
pushq $0x2d
popq %rsi
movq %rbx, %rdi
movl $0x6eb, %r9d            # imm = 0x6EB
jmp 0x1c5d9
movq (%r15), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x51043(%rip), %r8      # 0x6d610
pushq $0x34
popq %rsi
movq %rbx, %rdi
movl $0x6f2, %r9d            # imm = 0x6F2
popq %rbx
popq %r14
popq %r15
jmp 0x142c0
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x12e0e
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
movq %rdx, %rdi
movq %rcx, %rdx
callq 0x2de8a
cmpl $0x0, (%rbx)
jne 0x1cc94
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 0x33b17
andq $0x0, 0x160(%r15)
cmpl $0x0, (%rbx)
je 0x1cc9e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x29b54
cmpl $0x0, (%rbx)
je 0x1cc94
movq %r15, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x33bc1
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x8, (%rsp)
movq (%rdi), %rdi
movq %rcx, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
jne 0x1cd23
movq %r15, %rdi
callq 0x12a25
cmpl $0x2, (%r15)
jne 0x1cd23
cmpb $0x7b, (%rax)
jne 0x1cd23
cmpb $0x0, 0x1(%rax)
jne 0x1cd23
movq (%r12), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
je 0x1cd32
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x12a25
cmpl $0x2, (%r15)
jne 0x1cd4b
cmpb $0x7d, (%rax)
jne 0x1cd4b
cmpb $0x0, 0x1(%rax)
je 0x1cd83
movq (%r12), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x508b2(%rip), %r10     # 0x6d610
leaq 0x508a8(%rip), %rdx     # 0x6d60d
pushq $0x1d
popq %rsi
movq %rbx, %rdi
movq %rax, %rcx
pushq $0x427                  # imm = 0x427
pushq %r10
callq 0x140cd
addq $0x158, %rsp            # imm = 0x158
jmp 0x1cd2a
movq (%r12), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
jne 0x1cd23
movq %r15, %rdi
callq 0x12a25
movq %rsp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2db73
cmpl $0x0, (%rbx)
jne 0x1cd23
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x34066
movq %r15, %rdi
callq 0x2dc7c
cmpl $0x0, (%rbx)
jne 0x1cd23
movabsq $-0xffffffff, %rax      # imm = 0xFFFFFFFF00000001
movq %rax, 0x8(%r14)
jmp 0x1cd23
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_process_array_param_type
static void prv_process_array_param_type(subtilis_parser_t *p,
					 subtilis_token_t *t,
					 const subtilis_type_t *type,
					 subtilis_type_t *ptype,
					 subtilis_error_t *err)
{
	subtilis_exp_t *e;
	int32_t num_dims;
	size_t i;

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

	if (e->type.type != SUBTILIS_TYPE_CONST_INTEGER) {
		subtilis_exp_delete(e);
		subtilis_error_set_const_integer_expected(
		    err, p->l->stream->name, p->l->line);
		return;
	}
	num_dims = e->exp.ir_op.integer;
	subtilis_exp_delete(e);

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

	subtilis_type_if_array_of(type, ptype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	ptype->params.array.num_dims = num_dims;
	for (i = 0; i < ptype->params.array.num_dims; i++)
		ptype->params.array.dims[i] = SUBTILIS_DYNAMIC_DIMENSION;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq %r8, %rdx
callq 0x1e2a1
cmpl $0x0, (%r14)
je 0x1ce22
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, (%rax)
jne 0x1ce78
movl 0x148(%rax), %ebp
movq %rax, %rdi
callq 0x29d88
movq (%r12), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x12e0e
cmpl $0x0, (%r14)
jne 0x1ce13
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x34015
cmpl $0x0, (%r14)
jne 0x1ce13
movl %ebp, 0x8(%rbx)
xorl %eax, %eax
movslq %ebp, %rcx
cmpq %rcx, %rax
jae 0x1ce13
orl $-0x1, 0xc(%rbx,%rax,4)
incq %rax
movl 0x8(%rbx), %ebp
jmp 0x1ce63
movq %rax, %rdi
callq 0x29d88
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x5077e(%rip), %r8      # 0x6d610
pushq $0x43
popq %rsi
movq %r14, %rdi
movl $0x21e, %r9d            # imm = 0x21E
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x142c0
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_process_vector_param_type
static void prv_process_vector_param_type(subtilis_parser_t *p,
					  subtilis_token_t *t,
					  const subtilis_type_t *type,
					  subtilis_type_t *ptype,
					  subtilis_error_t *err)
{
	const char *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;
	}

	ptype->params.array.num_dims = 1;

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

	subtilis_type_if_vector_of(type, ptype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	ptype->params.array.dims[0] = SUBTILIS_DYNAMIC_DIMENSION;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq (%rdi), %rdi
movq %r8, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
je 0x1cee3
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x12a25
cmpl $0x2, (%r12)
jne 0x1cf28
movl $0x1, 0x8(%r14)
movq (%r13), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
jne 0x1ced9
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x34066
cmpl $0x0, (%rbx)
jne 0x1ced9
orl $-0x1, 0xc(%r14)
jmp 0x1ced9
cmpb $0x7d, (%rax)
jne 0x1cf33
cmpb $0x0, 0x1(%rax)
je 0x1cef2
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x506ca(%rip), %r10     # 0x6d610
leaq 0x506c0(%rip), %rdx     # 0x6d60d
pushq $0x1d
popq %rsi
movq %rbx, %rdi
movq %rax, %rcx
pushq $0x240                  # imm = 0x240
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
jmp 0x1ced9
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_compound.c
// Function: subtilis_parser_compound_at_sym_level
void subtilis_parser_compound_at_sym_level(subtilis_parser_t *p,
					   subtilis_token_t *t, int end_key,
					   subtilis_error_t *err)
{
	unsigned int start;
	subtilis_ir_operand_t var_reg;

	start = p->l->line;
	while (t->type != SUBTILIS_TOKEN_EOF) {
		if ((t->type == SUBTILIS_TOKEN_KEYWORD) &&
		    (t->tok.keyword.type == end_key))
			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);
	if ((end_key != SUBTILIS_KEYWORD_NEXT) &&
	    (end_key != SUBTILIS_KEYWORD_UNTIL) &&
	    (end_key != SUBTILIS_KEYWORD_ENDPROC))
		p->current->endproc = false;

	var_reg.reg = SUBTILIS_IR_REG_LOCAL;
	subtilis_reference_deallocate_refs(p, var_reg, p->local_st, p->level,
					   err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	p->level--;
	subtilis_symbol_table_level_down(p->local_st, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	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 %rcx, %r14
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x38(%rax), %r15d
movl (%r12), %eax
cmpl $0x1, %eax
je 0x1d606
testl %eax, %eax
jne 0x1d60d
jmp 0x1d626
cmpl %ebp, 0x8(%r12)
je 0x1d648
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x14d03
cmpl $0x0, (%r14)
je 0x1d5f7
jmp 0x1d6b0
movq (%rbx), %rax
movq 0x30(%rax), %rdx
leaq 0x50008(%rip), %r8      # 0x6d63c
pushq $0x1e
popq %rsi
movq %r14, %rdi
movl %r15d, %ecx
movl $0x117, %r9d            # imm = 0x117
callq 0x142c0
cmpl $0x28, %ebp
je 0x1d665
cmpl $0x51, %ebp
je 0x1d665
cmpl $0x8b, %ebp
je 0x1d665
movq 0x48(%rbx), %rax
movb $0x0, 0x88(%rax)
movq 0x68(%rbx), %rdx
movq 0x78(%rbx), %rcx
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r14, %r8
callq 0x4bbc0
cmpl $0x0, (%r14)
jne 0x1d6b0
decq 0x78(%rbx)
movq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x2cb44
cmpl $0x0, (%r14)
jne 0x1d6b0
movq 0x48(%rbx), %rax
movq 0x78(%rbx), %rsi
movq 0x78(%rax), %rdi
callq 0x2a68e
movq 0x48(%rbx), %rcx
movq %rax, 0x78(%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq