LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_array.c
// Function: subtils_parser_read_array
subtilis_exp_t *subtils_parser_read_array(subtilis_parser_t *p,
					  subtilis_token_t *t,
					  const char *var_name,
					  subtilis_error_t *err)
{
	size_t mem_reg;
	const subtilis_symbol_t *s;

	s = subtilis_parser_get_symbol(p, var_name, &mem_reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	if (!subtilis_type_if_is_array(&s->t)) {
		subtilis_error_not_array(err, var_name, p->l->stream->name,
					 p->l->line);
		return NULL;
	}

	return subtils_parser_read_array_with_type(p, t, &s->t, mem_reg, s->loc,
						   var_name, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %rdx
callq 0x24480
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x17ab7
movq $0x0, -0x8(%rbp)
jmp 0x17b44
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x49ff0
testb $0x1, %al
jne 0x17b14
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x3b, %esi
leaq 0x93784(%rip), %rcx     # 0xab276
leaq 0x92a04(%rip), %rax     # 0xaa4fd
movq %rax, (%rsp)
movl $0x2b, 0x8(%rsp)
callq 0x156d0
movq $0x0, -0x8(%rbp)
jmp 0x17b44
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq $0x8, %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq (%rax), %r8
movq -0x20(%rbp), %r9
movq -0x28(%rbp), %rax
movq %rax, (%rsp)
callq 0x17b50
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_array.c
// Function: prv_read_rec_el
static subtilis_exp_t *
prv_read_rec_el(subtilis_parser_t *p, subtilis_token_t *t,
		const subtilis_type_t *type, subtilis_exp_t **indices,
		size_t dims, size_t mem_reg, size_t loc, const char *var_name,
		subtilis_error_t *err)
{
	subtilis_type_t el_type;
	subtilis_exp_t *offset;
	subtilis_exp_t *e;

	offset = subtilis_array_index_calc(p, var_name, type, mem_reg, loc,
					   indices, dims, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	el_type.type = SUBTILIS_TYPE_VOID;
	subtilis_type_if_element_type(p, type, &el_type, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(offset);
		return NULL;
	}

	e = subtilis_parser_rec_exp(p, t, &el_type, offset->exp.ir_op.reg, 0,
				    err);
	subtilis_exp_delete(offset);
	subtilis_type_free(&el_type);

	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq 0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq 0x10(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %r10
movq 0x20(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x5edb0
movq %rax, -0x188(%rbp)
movq 0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x17f6a
movq $0x0, -0x8(%rbp)
jmp 0x18000
movl $0x8, -0x180(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq 0x20(%rbp), %rcx
leaq -0x180(%rbp), %rdx
callq 0x47b70
movq 0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x17fab
movq -0x188(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x18000
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x188(%rbp), %rax
movq 0x148(%rax), %rcx
movq 0x20(%rbp), %r9
leaq -0x180(%rbp), %rdx
xorl %eax, %eax
movl %eax, %r8d
callq 0x349a0
movq %rax, -0x190(%rbp)
movq -0x188(%rbp), %rdi
callq 0x36ee0
leaq -0x180(%rbp), %rdi
callq 0x3e100
movq -0x190(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_array.c
// Function: subtils_parser_read_vector
subtilis_exp_t *subtils_parser_read_vector(subtilis_parser_t *p,
					   subtilis_token_t *t,
					   const char *var_name,
					   subtilis_error_t *err)
{
	size_t mem_reg;
	const subtilis_symbol_t *s;

	s = subtilis_parser_get_symbol(p, var_name, &mem_reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	if (!subtilis_type_if_is_vector(&s->t)) {
		subtilis_error_not_vector(err, var_name, p->l->stream->name,
					  p->l->line);
		return NULL;
	}

	return subtils_parser_read_vector_with_type(p, t, &s->t, mem_reg,
						    s->loc, var_name, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %rdx
callq 0x24480
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x18317
movq $0x0, -0x8(%rbp)
jmp 0x183a4
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x4a040
testb $0x1, %al
jne 0x18374
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x3c, %esi
leaq 0x92f24(%rip), %rcx     # 0xab276
leaq 0x921a4(%rip), %rax     # 0xaa4fd
movq %rax, (%rsp)
movl $0xf3, 0x8(%rsp)
callq 0x156d0
movq $0x0, -0x8(%rbp)
jmp 0x183a4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq $0x8, %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq (%rax), %r8
movq -0x20(%rbp), %r9
movq -0x28(%rbp), %rax
movq %rax, (%rsp)
callq 0x183b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_array.c
// Function: subtils_parser_element_address
subtilis_exp_t *
subtils_parser_element_address(subtilis_parser_t *p, subtilis_token_t *t,
			       const subtilis_symbol_t *s, size_t mem_reg,
			       const char *var_name, subtilis_error_t *err)
{
	subtilis_exp_t *indices[SUBTILIS_MAX_DIMENSIONS];
	size_t i;
	subtilis_exp_t *e = NULL;
	size_t dims = 0;

	dims = subtilis_var_bracketed_int_args_have_b(
	    p, t, indices, SUBTILIS_MAX_DIMENSIONS, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

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

	if (dims == 0) {
		subtilis_error_bad_index_count(err, var_name,
					       p->l->stream->name, p->l->line);
		goto cleanup;
	}

	e = subtilis_type_if_indexed_address(p, var_name, &s->t, mem_reg,
					     s->loc, indices, dims, err);

cleanup:

	for (i = 0; i < dims; i++)
		subtilis_exp_delete(indices[i]);

	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq $0x0, -0xa0(%rbp)
movq $0x0, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x90(%rbp), %rdx
movq -0x38(%rbp), %r8
movl $0xa, %ecx
callq 0x251f0
movq %rax, -0xa8(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x18983
movq $0x0, -0x8(%rbp)
jmp 0x18a83
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x133f0
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x189a5
jmp 0x18a35
cmpq $0x0, -0xa8(%rbp)
jne 0x189f3
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x3a, %esi
leaq 0x9289d(%rip), %rcx     # 0xab276
leaq 0x91b1d(%rip), %rax     # 0xaa4fd
movq %rax, (%rsp)
movl $0x1a0, 0x8(%rsp)       # imm = 0x1A0
callq 0x156d0
jmp 0x18a35
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x8, %rdx
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %r8
leaq -0x90(%rbp), %r9
movq -0xa8(%rbp), %r10
movq -0x38(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x486c0
movq %rax, -0xa0(%rbp)
movq $0x0, -0x98(%rbp)
movq -0x98(%rbp), %rax
cmpq -0xa8(%rbp), %rax
jae 0x18a78
movq -0x98(%rbp), %rax
movq -0x90(%rbp,%rax,8), %rdi
callq 0x36ee0
movq -0x98(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x98(%rbp)
jmp 0x18a40
movq -0xa0(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_array.c
// Function: parser_array_var_bracketed_int_args
size_t parser_array_var_bracketed_int_args(subtilis_parser_t *p,
					   subtilis_token_t *t,
					   subtilis_exp_t **e, size_t max,
					   bool *vec, subtilis_error_t *err)
{
	const char *tbuf;

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

	tbuf = subtilis_token_get_text(t);
	if (t->type == SUBTILIS_TOKEN_OPERATOR) {
		if (!strcmp(tbuf, "(")) {
			*vec = false;
			return subtilis_var_bracketed_int_args_have_b(p, t, e,
								      max, err);
		} else if (!strcmp(tbuf, "{")) {
			e[0] = subtilis_curly_bracketed_arg_have_b(p, t, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return 0;

			*vec = true;
			return e[0] ? 1 : 0;
		}
	}

	subtilis_error_set_expected(err, "( or {", tbuf, p->l->stream->name,
				    p->l->line);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x133f0
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x18ada
movq $0x0, -0x8(%rbp)
jmp 0x18be7
movq -0x18(%rbp), %rdi
callq 0x12d70
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x18b9d
movq -0x40(%rbp), %rdi
leaq 0x9279d(%rip), %rsi     # 0xab29c
callq 0x12140
cmpl $0x0, %eax
jne 0x18b32
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x251f0
movq %rax, -0x8(%rbp)
jmp 0x18be7
movq -0x40(%rbp), %rdi
leaq 0x94ace(%rip), %rsi     # 0xad60b
callq 0x12140
cmpl $0x0, %eax
jne 0x18b99
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x259e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x18b75
movq $0x0, -0x8(%rbp)
jmp 0x18be7
movq -0x30(%rbp), %rax
movb $0x1, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x18be7
jmp 0x18b9b
jmp 0x18b9d
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x919c0(%rip), %rdx     # 0xaa587
leaq 0x9192f(%rip), %rax     # 0xaa4fd
movq %rax, (%rsp)
movl $0x1d0, 0x8(%rsp)       # imm = 0x1D0
callq 0x156d0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_array.c
// Function: prv_parse_string_initialiser
static void prv_parse_string_initialiser(subtilis_parser_t *p,
					 subtilis_token_t *t, subtilis_exp_t *e,
					 const subtilis_array_desc_t *d,
					 subtilis_error_t *err)
{
	size_t data_reg;
	subtilis_exp_t **ee;
	size_t table_base;
	size_t element_size;
	size_t entries = 0;
	size_t i = 0;

	ee = prv_parse_expression_list(p, e, &subtilis_type_const_string, t,
				       &entries, prv_string_check_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	element_size = subtilis_type_if_size(&subtilis_type_string, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	prv_check_expression_list_size(p, d, ee, entries, element_size, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	table_base = prv_init_lca_table(p, ee, entries, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	data_reg = subtilis_reference_get_data(p, d->reg, d->loc, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	prv_read_string_table(p, data_reg, table_base, entries, element_size,
			      err);

cleanup:

	for (i = 0; i < entries; i++)
		subtilis_exp_delete(ee[i]);
	free(ee);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
leaq 0x9221d(%rip), %rdx     # 0xab640
leaq -0x50(%rbp), %r8
leaq 0x12c2(%rip), %r9       # 0x1a6f0
movq %rax, (%rsp)
callq 0x1a4b0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x19449
jmp 0x1953a
movq -0x28(%rbp), %rsi
leaq 0x9270c(%rip), %rdi     # 0xabb60
callq 0x47420
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1946b
jmp 0x19500
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %r8
movq -0x28(%rbp), %r9
callq 0x1a750
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x19493
jmp 0x19500
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1a8b0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x194b7
jmp 0x19500
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x28(%rbp), %rcx
callq 0x6d1e0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x194e3
jmp 0x19500
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %r8
movq -0x28(%rbp), %r9
callq 0x1aae0
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x50(%rbp), %rax
jae 0x19531
movq -0x38(%rbp), %rax
movq -0x58(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x36ee0
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x19508
movq -0x38(%rbp), %rdi
callq 0x12290
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_array.c
// Function: prv_fn_check_type
static void prv_fn_check_type(subtilis_parser_t *p, subtilis_exp_t *e1,
			      const subtilis_type_t *type,
			      subtilis_error_t *err)
{
	if (e1->partial_name)
		subtilis_parser_call_add_addr(p, type, e1, err);
	else if (!subtilis_type_eq(&e1->type, type))
		subtilis_error_set_fn_type_mismatch(err, p->l->stream->name,
						    p->l->line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x160(%rax)
je 0x1957d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x21910
jmp 0x195c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d880
testb $0x1, %al
jne 0x195be
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x42, %esi
leaq 0x90f4a(%rip), %r8      # 0xaa4fd
movl $0x3fe, %r9d            # imm = 0x3FE
callq 0x15930
jmp 0x195c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_array.c
// Function: prv_parse_fn_initialiser
static void prv_parse_fn_initialiser(subtilis_parser_t *p, subtilis_token_t *t,
				     const subtilis_type_t *el_type,
				     subtilis_exp_t *e,
				     const subtilis_array_desc_t *d,
				     subtilis_error_t *err)
{
	subtilis_exp_t **ee;
	size_t element_size;
	size_t data_reg;
	size_t entries = 0;
	size_t i = 0;

	ee = prv_parse_expression_list(p, e, el_type, t, &entries,
				       prv_fn_check_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	element_size = subtilis_type_if_size(&e->type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	prv_check_expression_list_size(p, d, ee, entries, element_size, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	data_reg = subtilis_reference_get_data(p, d->reg, d->loc, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	prv_parse_fn_list(p, data_reg, ee, entries, element_size, err);

cleanup:

	for (i = 0; i < entries; i++)
		subtilis_exp_delete(ee[i]);
	free(ee);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
leaq -0x50(%rbp), %r8
leaq -0xdf(%rip), %r9        # 0x19540
movq %rax, (%rsp)
callq 0x1a4b0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1963a
jmp 0x19701
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x47420
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x19656
jmp 0x196c7
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x1a750
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1967e
jmp 0x196c7
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x30(%rbp), %rcx
callq 0x6d1e0
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x196aa
jmp 0x196c7
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x1ae80
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x50(%rbp), %rax
jae 0x196f8
movq -0x38(%rbp), %rax
movq -0x58(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x36ee0
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x196cf
movq -0x38(%rbp), %rdi
callq 0x12290
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_array.c
// Function: prv_create_vector
static void prv_create_vector(subtilis_parser_t *p,
			      subtilis_ir_operand_t local_global,
			      const subtilis_type_t *element_type, size_t *dims,
			      subtilis_exp_t **e, const char *var_name,
			      bool local, subtilis_error_t *err)
{
	subtilis_type_t type;
	const subtilis_symbol_t *s;

	subtilis_array_type_vector_init(element_type, &type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	/*
	 * No dimensions means a vector with no
	 * elements.
	 */

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

	s = subtilis_symbol_table_insert(local ? p->local_st : p->st, var_name,
					 &type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	subtilis_array_type_vector_alloc(p, s->loc, &type, e[0], local_global,
					 true, err);

cleanup:
	subtilis_type_free(&type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq 0x18(%rbp), %rax
movb 0x10(%rbp), %al
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x18(%rbp), %rdi
movq 0x18(%rbp), %rdx
leaq -0x180(%rbp), %rsi
callq 0x5c1d0
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x19d31
jmp 0x19dfe
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x19d6c
movq 0x18(%rbp), %rsi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x37800
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x19d61
jmp 0x19df2
movq -0x20(%rbp), %rax
movq $0x1, (%rax)
testb $0x1, -0x31(%rbp)
je 0x19d83
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x190(%rbp)
jmp 0x19d92
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x190(%rbp)
movq -0x190(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq 0x18(%rbp), %rcx
leaq -0x180(%rbp), %rdx
callq 0x3c480
movq %rax, -0x188(%rbp)
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x19dbf
jmp 0x19df2
movq -0x10(%rbp), %rdi
movq -0x188(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq 0x18(%rbp), %rax
movq -0x8(%rbp), %r8
leaq -0x180(%rbp), %rdx
movl $0x1, %r9d
movq %rax, (%rsp)
callq 0x5c4a0
leaq -0x180(%rbp), %rdi
callq 0x3e100
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_array.c
// Function: prv_create_array
static void prv_create_array(subtilis_parser_t *p,
			     subtilis_ir_operand_t local_global,
			     const subtilis_type_t *element_type, size_t dims,
			     subtilis_exp_t **e, const char *var_name,
			     bool local, subtilis_error_t *err)
{
	subtilis_type_t type;
	const subtilis_symbol_t *s;

	if (dims == 0) {
		subtilis_error_set_integer_exp_expected(err, p->l->stream->name,
							p->l->line);
		return;
	}

	type.type = SUBTILIS_TYPE_VOID;
	subtilis_array_type_init(p, var_name, element_type, &type, &e[0], dims,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	s = subtilis_symbol_table_insert(local ? p->local_st : p->st, var_name,
					 &type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	subtilis_array_type_allocate(p, var_name, &type, s->loc, &e[0],
				     local_global, true, err);

cleanup:
	subtilis_type_free(&type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq 0x18(%rbp), %rax
movb 0x10(%rbp), %al
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x19e6e
movq 0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x1c, %esi
callq 0x158e0
jmp 0x19f43
movl $0x8, -0x180(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x20(%rbp), %r9
movq 0x18(%rbp), %rax
leaq -0x180(%rbp), %rcx
movq %rax, (%rsp)
callq 0x5c080
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x19eae
jmp 0x19f43
testb $0x1, -0x31(%rbp)
je 0x19ec5
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x190(%rbp)
jmp 0x19ed4
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x190(%rbp)
movq -0x190(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq 0x18(%rbp), %rcx
leaq -0x180(%rbp), %rdx
callq 0x3c480
movq %rax, -0x188(%rbp)
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x19f01
jmp 0x19f37
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x188(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %r8
movq 0x18(%rbp), %rax
movq -0x8(%rbp), %r9
leaq -0x180(%rbp), %rdx
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x5be00
leaq -0x180(%rbp), %rdi
callq 0x3e100
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_array.c
// Function: prv_append_const_el
static uint8_t *prv_append_const_el(subtilis_parser_t *p, subtilis_exp_t *e,
				    const subtilis_type_t *el_type,
				    size_t element_size, uint8_t *buffer,
				    size_t el, size_t *max_els,
				    subtilis_error_t *err)
{
	uint8_t *new_buf;
	size_t new_max;

	if (el == *max_els) {
		new_max = *max_els + SUBTILIS_CONFIG_CONSTANT_ARRAY_GRAN;
		new_buf = realloc(buffer, new_max * element_size);
		if (!new_buf) {
			subtilis_error_set_oom(err);
			goto cleanup;
		}
		buffer = new_buf;
		*max_els = new_max;
	}

	if (!subtilis_type_if_is_const(&e->type)) {
		subtilis_error_set_const_expression_expected(
		    err, p->l->stream->name, p->l->line);
		goto cleanup;
	}

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

	memcpy(&buffer[el * element_size], &e->exp.ir_op, element_size);

cleanup:

	subtilis_exp_delete(e);

	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x1a325
movq 0x10(%rbp), %rax
movq (%rax), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rsi
imulq -0x20(%rbp), %rsi
callq 0x121e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x1a312
movq 0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x901fa(%rip), %rdx     # 0xaa4fd
movl $0x1e2, %ecx            # imm = 0x1E2
callq 0x158e0
jmp 0x1a3ac
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x48a90
testb $0x1, %al
jne 0x1a364
movq 0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x48, %esi
leaq 0x901a6(%rip), %r8      # 0xaa4fd
movl $0x1eb, %r9d            # imm = 0x1EB
callq 0x15930
jmp 0x1a3ac
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq 0x18(%rbp), %rcx
callq 0x4a2e0
movq %rax, -0x10(%rbp)
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1a388
jmp 0x1a3ac
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
imulq -0x20(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x148, %rsi            # imm = 0x148
movq -0x20(%rbp), %rdx
callq 0x12190
movq -0x10(%rbp), %rdi
callq 0x36ee0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_array.c
// Function: prv_check_initialiser_count
static void prv_check_initialiser_count(subtilis_parser_t *p, size_t entries,
					size_t mem_reg, subtilis_exp_t *maxe,
					subtilis_error_t *err)
{
	subtilis_exp_t *sizee = NULL;
	subtilis_ir_operand_t error_label;
	subtilis_ir_operand_t ok_label;

	error_label = subtilis_array_type_error_label(p);
	ok_label.label = subtilis_ir_section_new_label(p->current);

	sizee = subtilis_exp_new_int32(entries, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	sizee = subtilis_type_if_lte(p, sizee, maxe, err);
	maxe = NULL;
	subtilis_ir_section_add_instr_reg(p->current, SUBTILIS_OP_INSTR_JMPC,
					  sizee->exp.ir_op, ok_label,
					  error_label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

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

cleanup:
	subtilis_exp_delete(maxe);
	subtilis_exp_delete(sizee);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d190
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x39940
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl %eax, %edi
movq -0x28(%rbp), %rsi
callq 0x37800
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1a428
jmp 0x1a492
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x49700
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %r9
movq 0x148(%rax), %rdx
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %r8
movl $0x43, %esi
callq 0x38360
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1a47d
jmp 0x1a492
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x39960
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x30(%rbp), %rdi
callq 0x36ee0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_array.c
// Function: prv_check_expression_list_size
static void prv_check_expression_list_size(subtilis_parser_t *p,
					   const subtilis_array_desc_t *d,
					   subtilis_exp_t **ee, size_t entries,
					   size_t element_size,
					   subtilis_error_t *err)
{
	int32_t dim;
	bool dynamic = false;
	size_t max_elements = 1;
	subtilis_exp_t *maxe = NULL;
	subtilis_exp_t *maxe_dup = NULL;
	size_t i = 0;
	const subtilis_type_t *type = d->t;

	do {
		dim = type->params.array.dims[i];
		if (dim == SUBTILIS_DYNAMIC_DIMENSION) {
			max_elements = SIZE_MAX;
			dynamic = true;
			break;
		}
		max_elements *= (dim + 1);
		i++;
	} while (i < type->params.array.num_dims);

	if (!dynamic) {
		if (entries > max_elements)
			subtilis_error_bad_element_count(
			    err, p->l->stream->name, p->l->line);
	} else {
		maxe = subtilis_array_type_dynamic_size(p, d->reg, d->loc, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		maxe_dup = subtilis_type_if_dup(maxe, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		prv_check_initialiser_count(p, entries * element_size, d->reg,
					    maxe_dup, err);
	}

cleanup:

	subtilis_exp_delete(maxe);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movb $0x0, -0x35(%rbp)
movq $0x1, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0xc(%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0x1a7c3
movq $-0x1, -0x40(%rbp)
movb $0x1, -0x35(%rbp)
jmp 0x1a7f1
movl -0x34(%rbp), %eax
addl $0x1, %eax
cltq
imulq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movslq 0x8(%rcx), %rcx
cmpq %rcx, %rax
jb 0x1a7a0
testb $0x1, -0x35(%rbp)
jne 0x1a833
movq -0x20(%rbp), %rax
cmpq -0x40(%rbp), %rax
jbe 0x1a831
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x47, %esi
leaq 0x8fcd7(%rip), %r8      # 0xaa4fd
movl $0x3b1, %r9d            # imm = 0x3B1
callq 0x15930
jmp 0x1a89d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x30(%rbp), %rcx
callq 0x5ffd0
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1a85f
jmp 0x1a89f
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x47d20
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1a87b
jmp 0x1a89f
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
imulq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x1a3c0
jmp 0x1a89f
movq -0x48(%rbp), %rdi
callq 0x36ee0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_array.c
// Function: prv_parse_fn_list
static void prv_parse_fn_list(subtilis_parser_t *p, size_t array_base,
			      subtilis_exp_t **ee, size_t entries,
			      size_t element_size, subtilis_error_t *err)
{
	size_t i;
	subtilis_ir_operand_t op1;
	subtilis_ir_operand_t op2;

	op1.reg = array_base;
	op2.integer = (int32_t)element_size;

	for (i = 0; i < entries - 1; i++) {
		subtilis_type_if_assign_to_mem(p, op1.reg, 0, ee[i], err);
		ee[i] = NULL;
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		op1.reg = subtilis_ir_section_add_instr(
		    p->current, SUBTILIS_OP_INSTR_ADDI_I32, op1, op2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}
	subtilis_type_if_assign_to_mem(p, op1.reg, 0, ee[i], err);
	ee[i] = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movl %eax, -0x48(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x1af44
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x30(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x47f20
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1af04
jmp 0x1af75
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %r8
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
movl $0x9, %esi
callq 0x38230
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1af31
jmp 0x1af75
jmp 0x1af33
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1aeb7
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x30(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x47f20
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: subtilis_parser_assign_local_num
subtilis_exp_t *subtilis_parser_assign_local_num(subtilis_parser_t *p,
						 subtilis_token_t *t,
						 const char *var_name,
						 const subtilis_type_t *type,
						 subtilis_error_t *err)
{
	subtilis_exp_t *e;

	e = subtilis_parser_expression(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	if (!subtilis_type_if_is_numeric(&e->type)) {
		subtilis_error_set_expected(err, "Numeric expression",
					    subtilis_type_name(&e->type),
					    p->l->stream->name, p->l->line);
		subtilis_exp_delete(e);
		return NULL;
	}
	e = subtilis_type_if_copy_var(p, e, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	e = subtilis_type_if_exp_to_var(p, e, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	e = subtilis_type_if_coerce_type(p, e, type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x24a20
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1b157
movq $0x0, -0x8(%rbp)
jmp 0x1b250
movq -0x38(%rbp), %rdi
callq 0x49d10
testb $0x1, %al
jne 0x1b1cc
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3e190
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x8f43b(%rip), %rdx     # 0xaa5d9
leaq 0x8f417(%rip), %rax     # 0xaa5bc
movq %rax, (%rsp)
movl $0x1e3, 0x8(%rsp)       # imm = 0x1E3
callq 0x156d0
movq -0x38(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x1b250
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x47cd0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1b1f4
movq $0x0, -0x8(%rbp)
jmp 0x1b250
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x47c10
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1b21c
movq $0x0, -0x8(%rbp)
jmp 0x1b250
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x4a2e0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1b248
movq $0x0, -0x8(%rbp)
jmp 0x1b250
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x178(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x170(%rbp), %rdi
callq 0x3dec0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1b2ac
jmp 0x1b337
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x170(%rbp), %rdx
callq 0x25e50
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1b2cf
jmp 0x1b31f
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x170(%rbp), %rsi
callq 0x47580
movq %rax, -0x178(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1b2f5
jmp 0x1b31f
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x178(%rbp), %rax
movq 0x148(%rax), %rcx
movq -0x28(%rbp), %r8
leaq -0x170(%rbp), %rdx
callq 0x3cc20
movq -0x178(%rbp), %rdi
callq 0x36ee0
leaq -0x170(%rbp), %rdi
callq 0x3e100
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x24a20
movq %rax, -0x178(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1b385
jmp 0x1b4e6
movq -0x178(%rbp), %rax
cmpl $0x9, (%rax)
je 0x1b401
movq -0x28(%rbp), %rax
movq %rax, -0x188(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3e190
movq %rax, -0x180(%rbp)
movq -0x178(%rbp), %rdi
callq 0x3e190
movq -0x188(%rbp), %rdi
movq -0x180(%rbp), %rdx
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x8f1d1(%rip), %rax     # 0xaa5bc
movq %rax, (%rsp)
movl $0x21e, 0x8(%rsp)       # imm = 0x21E
callq 0x156d0
jmp 0x1b4ce
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x170(%rbp), %rdi
callq 0x3dec0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1b423
jmp 0x1b4e6
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x170(%rbp), %rdx
callq 0x25e50
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1b449
jmp 0x1b4ce
movq -0x178(%rbp), %rax
cmpq $0x0, 0x160(%rax)
je 0x1b477
movq -0x8(%rbp), %rdi
movq -0x178(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x170(%rbp), %rsi
callq 0x21910
jmp 0x1b499
movq -0x8(%rbp), %rdi
movq -0x178(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x170(%rbp), %rdx
callq 0x4a2e0
movq %rax, -0x178(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1b4a4
jmp 0x1b4ce
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x178(%rbp), %rax
movq 0x148(%rax), %rcx
movq -0x28(%rbp), %r8
leaq -0x170(%rbp), %rdx
callq 0x3cc20
movq -0x178(%rbp), %rdi
callq 0x36ee0
leaq -0x170(%rbp), %rdi
callq 0x3e100
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x170(%rbp), %rdi
callq 0x3dec0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1b52e
jmp 0x1b586
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x170(%rbp), %rdx
callq 0x25e50
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1b551
jmp 0x1b57a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
leaq -0x170(%rbp), %rdx
movl $0x1, %r9d
movl %r9d, %r8d
movq %rax, (%rsp)
callq 0x34e20
leaq -0x170(%rbp), %rdi
callq 0x3e100
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12d70
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x120d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x121b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x1b604
movq -0x28(%rbp), %rdi
movl $0x1, %esi
leaq 0x8efcf(%rip), %rdx     # 0xaa5bc
movl $0x29a, %ecx            # imm = 0x29A
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x1b696
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x12060
movq -0x18(%rbp), %rax
cmpl $0x9, 0x8(%rax)
je 0x1b625
movq -0x18(%rbp), %rax
cmpl $0x16, 0x8(%rax)
jne 0x1b63c
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x25e50
jmp 0x1b651
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movq -0x28(%rbp), %rdx
callq 0x3e4f0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1b65c
jmp 0x1b685
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x133f0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1b67b
jmp 0x1b685
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1b696
movq -0x38(%rbp), %rdi
callq 0x12290
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3cff0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1b700
movq -0x28(%rbp), %rax
movq $0x2, (%rax)
jmp 0x1b7ee
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3cff0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1b735
movq -0x28(%rbp), %rax
movq $0x1, (%rax)
jmp 0x1b7ec
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jne 0x1b7a8
movq -0x30(%rbp), %rax
movb $0x1, (%rax)
movq -0x28(%rbp), %rax
movq $0x1, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x1b7a6
movq 0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x3e, %esi
leaq 0x8fae8(%rip), %rcx     # 0xab276
leaq 0x8ee27(%rip), %rax     # 0xaa5bc
movq %rax, (%rsp)
movl $0x2d9, 0x8(%rsp)       # imm = 0x2D9
callq 0x156d0
jmp 0x1b7ea
movq 0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1b, %esi
leaq 0x8faa4(%rip), %rcx     # 0xab276
leaq 0x8ede3(%rip), %rax     # 0xaa5bc
movq %rax, (%rsp)
movl $0x2dd, 0x8(%rsp)       # imm = 0x2DD
callq 0x156d0
jmp 0x1b7ec
jmp 0x1b7ee
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)