LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: prv_ir_deref_array_recs_create
static size_t prv_ir_deref_array_recs_create(subtilis_parser_t *p,
					     const subtilis_type_t *el_type,
					     const char *name,
					     subtilis_error_t *err)
{
	subtilis_ir_section_t *fn;
	const subtilis_type_t *ptype[2];
	size_t call_index = SIZE_MAX;

	ptype[0] = &subtilis_type_integer;
	fn = prv_add_args_ci(p, name, 1, ptype, &subtilis_type_void,
			     &call_index, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		if (err->type != SUBTILIS_ERROR_ALREADY_DEFINED)
			return SIZE_MAX;
		subtilis_error_init(err);
	} else {
		prv_builtins_ir_deref_array_recs(p, fn, el_type, err);
	}

	return call_index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r9
movq $-0x1, (%r9)
leaq 0x40528(%rip), %rdx     # 0x74918
leaq 0x10(%rsp), %rcx
movq %rdx, (%rcx)
movq %rbx, (%rsp)
leaq 0x408ed(%rip), %r8      # 0x74cf0
movl $0x1, %edx
movq %rax, %rsi
callq 0x34176
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x34433
movq $-0x1, %rax
cmpl $0x20, %ecx
jne 0x344d4
movq %rbx, %rdi
callq 0x143b4
jmp 0x344cf
movq %rax, %r12
movq 0x48(%r14), %r13
movq %rax, 0x48(%r14)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x379b8
cmpl $0x0, (%rbx)
jne 0x344cb
movq %rax, %rbp
movq 0x48(%r14), %rdi
movl $0x9b, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x2be09
cmpl $0x0, (%rbx)
jne 0x344cb
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
andq %rcx, %rbp
movq %r15, %rdi
movq %rax, %r15
callq 0x2fee3
movl %eax, %edx
orq %rbp, %rdx
movq %r12, %rdi
movl $0x1b, %esi
movq %rbx, %rcx
callq 0x2be09
cmpl $0x0, (%rbx)
jne 0x344cb
movq %r15, %rcx
movl $0x4, %esi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %r8
callq 0x32e53
cmpl $0x0, (%rbx)
jne 0x344cb
movq 0x48(%r14), %rdi
movl $0x46, %esi
movq %rbx, %rdx
callq 0x2be37
movq %r13, 0x48(%r14)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_ir_call_deref_array_recs
void subtilis_builtin_ir_call_deref_array_recs(subtilis_parser_t *p,
					       const subtilis_type_t *el_type,
					       size_t base_reg,
					       subtilis_error_t *err)
{
	char *name;

	name = prv_get_deref_array_recs_name(el_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	(void)prv_ir_deref_array_recs_create(p, el_type, name, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	(void)subtilis_parser_call_1_arg_fn(
		p, name, base_reg, SUBTILIS_BUILTINS_MAX,
		SUBTILIS_IR_REG_TYPE_INTEGER, &subtilis_type_void, false,
		err);

cleanup:
	free(name);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x3435b
cmpl $0x0, (%rbx)
je 0x34512
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x343c3
cmpl $0x0, (%rbx)
jne 0x3454f
leaq 0x407be(%rip), %r9      # 0x74cf0
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x9, %ecx
xorl %r8d, %r8d
pushq %rbx
pushq $0x0
callq 0x1ea76
addq $0x10, %rsp
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x122c0
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_ir_call_deref
size_t subtilis_builtin_ir_call_deref(subtilis_parser_t *p,
				      subtilis_error_t *err)
{
	subtilis_ir_section_t *fn;
	const subtilis_type_t *ptype[1];
	size_t call_index;
	const char *name = "_call_deref";

	ptype[0] = &subtilis_type_integer;

	fn = prv_add_args_ci(p, name, 1, ptype, &subtilis_type_void,
			     &call_index, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		if (err->type != SUBTILIS_ERROR_ALREADY_DEFINED)
			return SIZE_MAX;
		subtilis_error_init(err);
	} else {
		prv_builtins_ir_call_deref(p, fn, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return SIZE_MAX;
	}

	return call_index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4039d(%rip), %rax     # 0x74918
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq %rsi, (%rsp)
leaq 0x40d56(%rip), %rsi     # 0x752e4
leaq 0x4075b(%rip), %r8      # 0x74cf0
leaq 0x8(%rsp), %r9
movl $0x1, %edx
callq 0x34176
movl (%rbx), %ecx
movq $-0x1, %r15
testl %ecx, %ecx
je 0x345cc
cmpl $0x20, %ecx
jne 0x34686
movq %rbx, %rdi
callq 0x143b4
movq 0x8(%rsp), %r15
jmp 0x34686
movq 0x48(%r14), %rbp
movq %rax, 0x48(%r14)
movq %rax, %rdi
callq 0x2cc99
movq %rax, %r13
movq 0x48(%r14), %rdi
callq 0x2cc99
movq %rax, %r12
movq 0x48(%r14), %rdi
movl $0x4, %edx
movl $0x12, %esi
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x2bc8f
cmpl $0x0, (%rbx)
jne 0x34682
movq 0x48(%r14), %rdi
movl $0x43, %esi
movq %rax, %rdx
movq %r13, %rcx
movq %r12, %r8
movq %rbx, %r9
callq 0x2bd42
cmpl $0x0, (%rbx)
jne 0x34682
movq 0x48(%r14), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2cca6
cmpl $0x0, (%rbx)
jne 0x34682
movq 0x48(%r14), %rdi
movl $0x4, %edx
movl $0x8, %ecx
movl $0x12, %esi
movq %rbx, %r8
callq 0x2bc8f
cmpl $0x0, (%rbx)
jne 0x34682
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x4d56b
cmpl $0x0, (%rbx)
jne 0x34682
movq 0x48(%r14), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2cca6
cmpl $0x0, (%rbx)
je 0x34698
movq %rbp, 0x48(%r14)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x48(%r14), %rdi
movl $0x46, %esi
movq %rbx, %rdx
callq 0x2be37
cmpl $0x0, (%rbx)
movq %rbp, 0x48(%r14)
jne 0x34686
jmp 0x345c2
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_ir_rec_deref
size_t subtilis_builtin_ir_rec_deref(subtilis_parser_t *p,
				     const subtilis_type_t *type,
				     subtilis_error_t *err)
{
	char *name;
	size_t call_index;

	name = subtilis_rec_type_deref_fn_name(type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return SIZE_MAX;

	call_index = prv_get_rec_deref_fn(p, name, type, err);
	free(name);
	return call_index;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x461a9
cmpl $0x0, (%rbx)
je 0x346e1
movq $-0x1, %rax
jmp 0x34703
movq %rax, %r15
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3470f
movq %rax, %rbx
movq %r15, %rdi
callq 0x122c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: prv_get_rec_deref_fn
static size_t prv_get_rec_deref_fn(subtilis_parser_t *p,
				   const char *name,
				   const subtilis_type_t *type,
				   subtilis_error_t *err)
{
	subtilis_ir_section_t *fn;
	const subtilis_type_t *ptype[1];
	size_t call_index = SIZE_MAX;

	ptype[0] = &subtilis_type_integer;

	fn = prv_add_args_ci(p, name, 1, ptype, &subtilis_type_void,
			     &call_index, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		if (err->type != SUBTILIS_ERROR_ALREADY_DEFINED)
			return SIZE_MAX;
		subtilis_error_init(err);
	} else {
		prv_builtins_ir_gen_rec_deref(p, type, fn, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return SIZE_MAX;
	}

	return call_index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rdi, %r14
leaq 0x18(%rsp), %r9
movq $-0x1, (%r9)
leaq 0x401df(%rip), %rax     # 0x74918
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
subq $0x8, %rsp
leaq 0x405a4(%rip), %r8      # 0x74cf0
movl $0x1, %edx
pushq %rbx
callq 0x34176
addq $0x10, %rsp
movl (%rbx), %ecx
movq $-0x1, %r15
testl %ecx, %ecx
je 0x34783
cmpl $0x20, %ecx
jne 0x3488e
movq %rbx, %rdi
callq 0x143b4
movq 0x18(%rsp), %r15
jmp 0x3488e
movq 0x48(%r14), %r13
movq %rax, 0x48(%r14)
cmpq $0x0, 0x28(%r12)
je 0x34860
movq %r13, 0x8(%rsp)
leaq 0x8(%r12), %rax
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x18(%r12), %rsi
addq %r15, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x379b8
cmpl $0x0, (%rbx)
jne 0x3487e
movq %rax, %r13
cmpq $-0x1, %rax
je 0x3483b
testq %rbp, %rbp
je 0x34801
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x2fe6a
movq 0x48(%r14), %rdi
movl %eax, %ecx
movl $0x4, %edx
movl $0x9, %esi
movq %rbx, %r8
callq 0x2bc8f
cmpl $0x0, (%rbx)
je 0x34806
jmp 0x3487e
movl $0x4, %eax
movq 0x58(%r14), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rcx
movq (%rcx,%r13,8), %rsi
movq %r14, %rdi
movq %rax, %rdx
movl $0x9, %ecx
xorl %r8d, %r8d
leaq 0x404c6(%rip), %r9      # 0x74cf0
pushq %rbx
pushq $0x0
callq 0x1ea76
addq $0x10, %rsp
cmpl $0x0, (%rbx)
jne 0x3487e
incq %rbp
addq $0x148, %r15            # imm = 0x148
cmpq 0x28(%r12), %rbp
jb 0x347ab
movq 0x48(%r14), %rax
movq $-0x1, %r15
movq 0x8(%rsp), %r13
movq %rax, %rdi
movl $0x46, %esi
movq %rbx, %rdx
callq 0x2be37
cmpl $0x0, (%rbx)
movq %r13, 0x48(%r14)
jne 0x3488e
jmp 0x34779
movq 0x8(%rsp), %rax
movq %rax, 0x48(%r14)
movq $-0x1, %r15
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_call_ir_rec_deref
void subtilis_builtin_call_ir_rec_deref(subtilis_parser_t *p,
					const subtilis_type_t *type,
					size_t base_reg,
					subtilis_error_t *err)
{
	char *name;

	name = subtilis_rec_type_deref_fn_name(type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	(void)prv_get_rec_deref_fn(p, name, type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	(void)subtilis_parser_call_1_arg_fn(
		p, name, base_reg, SUBTILIS_BUILTINS_MAX,
		SUBTILIS_IR_REG_TYPE_INTEGER, &subtilis_type_void, false,
		err);

cleanup:

	free(name);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x461a9
cmpl $0x0, (%rbx)
je 0x348cf
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r12, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x3470f
cmpl $0x0, (%rbx)
jne 0x3490c
leaq 0x40401(%rip), %r9      # 0x74cf0
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x9, %ecx
xorl %r8d, %r8d
pushq %rbx
pushq $0x0
callq 0x1ea76
addq $0x10, %rsp
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x122c0
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_call_ir_rec_ref
void subtilis_builtin_call_ir_rec_ref(subtilis_parser_t *p,
				      const subtilis_type_t *type,
				      size_t base_reg,
				      subtilis_error_t *err)
{
	char *name;

	name = subtilis_rec_type_ref_fn_name(type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	prv_get_rec_ref_fn(p, name, type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	(void)subtilis_parser_call_1_arg_fn(
		p, name, base_reg, SUBTILIS_BUILTINS_MAX,
		SUBTILIS_IR_REG_TYPE_INTEGER, &subtilis_type_void, false,
		err);

cleanup:

	free(name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x4625a
cmpl $0x0, (%rbx)
jne 0x34a0b
movq %rax, %r14
leaq 0x8(%rsp), %r9
movq $-0x1, (%r9)
leaq 0x3ffb7(%rip), %rax     # 0x74918
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
subq $0x8, %rsp
leaq 0x4037c(%rip), %r8      # 0x74cf0
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rsi
pushq %rbx
callq 0x34176
addq $0x10, %rsp
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x3499e
cmpl $0x20, %ecx
jne 0x349db
movq %rbx, %rdi
callq 0x143b4
jmp 0x349d9
movq 0x48(%r12), %rbp
movq %rax, 0x48(%r12)
movl $0x4, %edx
movq %r12, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x46346
cmpl $0x0, (%rbx)
jne 0x349d4
movq 0x48(%r12), %rdi
movl $0x46, %esi
movq %rbx, %rdx
callq 0x2be37
movq %rbp, 0x48(%r12)
movl (%rbx), %ecx
testl %ecx, %ecx
jne 0x34a03
leaq 0x4030a(%rip), %r9      # 0x74cf0
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x9, %ecx
xorl %r8d, %r8d
pushq %rbx
pushq $0x0
callq 0x1ea76
addq $0x10, %rsp
movq %r14, %rdi
callq 0x122c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_ir_rec_zero
void subtilis_builtin_ir_rec_zero(subtilis_parser_t *p,
				  const subtilis_type_t *type,
				  size_t base_reg, subtilis_error_t *err)
{
	subtilis_ir_section_t *fn;
	const subtilis_type_t *ptype[1];
	char *name;
	bool check_errors;
	const char * const zero = "_zero";

	name = malloc(strlen(type->params.rec.name) + strlen(zero)
		      + 1 + 1);
	if (!name) {
		subtilis_error_set_oom(err);
		return;
	}
	sprintf(name, "_%s%s", type->params.rec.name, zero);
	ptype[0] = &subtilis_type_integer;
	fn = prv_add_args(p, name, 1, ptype, &subtilis_type_void, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		if (err->type != SUBTILIS_ERROR_ALREADY_DEFINED)
			goto cleanup;
		subtilis_error_init(err);
	} else {
		prv_builtins_ir_gen_rec_zero(p, type, fn, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	check_errors = subtilis_type_rec_need_zero_alloc(type);
	(void)subtilis_parser_call_1_arg_fn(
		p, name, base_reg, SUBTILIS_BUILTINS_MAX,
		SUBTILIS_IR_REG_TYPE_INTEGER, &subtilis_type_void, check_errors,
		err);

cleanup:

	free(name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq 0x10(%rsi), %rbp
movq %rbp, %rdi
callq 0x120f0
leaq 0x7(%rax), %rdi
callq 0x121d0
testq %rax, %rax
je 0x34ae7
movq %rax, %r14
leaq 0x4089d(%rip), %rsi     # 0x752f6
leaq 0x40890(%rip), %rcx     # 0x752f0
movq %rax, %rdi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x12280
leaq 0x3fea4(%rip), %rax     # 0x74918
movq %rsp, %rcx
movq %rax, (%rcx)
subq $0x8, %rsp
leaq 0x4026b(%rip), %r8      # 0x74cf0
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rsi
xorl %r9d, %r9d
pushq %rbx
callq 0x34176
addq $0x10, %rsp
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x34b0e
cmpl $0x20, %ecx
jne 0x34b72
movq %rbx, %rdi
callq 0x143b4
movq %r13, %rdi
callq 0x301f1
movzbl %al, %eax
leaq 0x4022a(%rip), %r9      # 0x74cf0
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x9, %ecx
xorl %r8d, %r8d
pushq %rbx
pushq %rax
callq 0x1ea76
addq $0x10, %rsp
jmp 0x34b72
leaq 0x4077b(%rip), %rdx     # 0x75269
movq %rbx, %rdi
movl $0x1, %esi
movl $0xe20, %ecx            # imm = 0xE20
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x145a4
movq 0x48(%r12), %rbp
movq %rax, 0x48(%r12)
movq %r13, %rdi
callq 0x30088
movl $0x4, %edx
movq %r12, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
movq %rax, %r8
movq %rbx, %r9
callq 0x45bad
cmpl $0x0, (%rbx)
jne 0x34b6d
movq 0x48(%r12), %rdi
movq 0x98(%rdi), %rsi
movq %rbx, %rdx
callq 0x2cca6
cmpl $0x0, (%rbx)
jne 0x34b6d
movq 0x48(%r12), %rdi
movl $0x46, %esi
movq %rbx, %rdx
callq 0x2be37
cmpl $0x0, (%rbx)
je 0x34b88
movq %rbp, 0x48(%r12)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x122c0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x436af
cmpl $0x0, (%rbx)
movq %rbp, 0x48(%r12)
jne 0x34b72
jmp 0x34ab4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/call.c
// Function: subtilis_parser_call_new
subtilis_parser_call_t *
subtilis_parser_call_new(subtilis_ir_section_t *s, size_t index,
			 bool in_error_handler, char *name,
			 subtilis_type_section_t *ct, size_t line,
			 subtilis_builtin_type_t ft, subtilis_error_t *err)
{
	subtilis_parser_call_t *call;

	call = malloc(sizeof(*call));
	if (!call) {
		subtilis_error_set_oom(err);
		goto on_error;
	}

	call->s = s;
	call->index = index;
	call->in_error_handler = in_error_handler;
	call->name = name;
	call->call_type = ct;
	call->line = line;
	call->ftype = ft;

	return call;

on_error:

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r15
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r14
movl $0x38, %edi
callq 0x121d0
movq %rax, %rbx
testq %rax, %rax
je 0x35a47
movl 0x40(%rsp), %eax
movq %r14, (%rbx)
movq %r13, 0x8(%rbx)
movb %bpl, 0x10(%rbx)
movq %r12, 0x18(%rbx)
movq %r15, 0x20(%rbx)
movq (%rsp), %rcx
movq %rcx, 0x30(%rbx)
movl %eax, 0x28(%rbx)
jmp 0x35a62
movq 0x48(%rsp), %rdi
leaq 0x3f8c2(%rip), %rdx     # 0x75315
movl $0x1, %esi
movl $0x1f, %ecx
callq 0x145a4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/call.c
// Function: subtilis_parser_call_delete
void subtilis_parser_call_delete(subtilis_parser_call_t *call)
{
	if (!call)
		return;

	subtilis_type_section_delete(call->call_type);
	free(call->name);
	free(call);
}

// Assembly:
testq %rdi, %rdi
je 0x35a98
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x2f4fb
movq 0x18(%rbx), %rdi
callq 0x122c0
movq %rbx, %rdi
popq %rbx
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/call.c
// Function: subtilis_parser_call_addr_new
subtilis_parser_call_addr_t *
subtilis_parser_call_addr_new(subtilis_ir_section_t *s, size_t index, bool eh,
			      char *name, const subtilis_type_t *type,
			      size_t line, subtilis_error_t *err)
{
	subtilis_parser_call_addr_t *call_addr;

	call_addr = malloc(sizeof(*call_addr));
	if (!call_addr) {
		subtilis_error_set_oom(err);
		goto on_error;
	}
	call_addr->call_type.type = SUBTILIS_TYPE_VOID;

	call_addr->s = s;
	call_addr->index = index;
	call_addr->in_error_handler = eh;
	subtilis_type_init_copy(&call_addr->call_type, type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	call_addr->name = name;
	call_addr->line = line;

	return call_addr;

on_error:
	free(name);
	subtilis_parser_call_addr_delete(call_addr);

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r13
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movl $0x170, %edi            # imm = 0x170
callq 0x121d0
testq %rax, %rax
je 0x35b09
movq %rax, %r14
movq %rax, %rdi
addq $0x20, %rdi
movl $0x8, 0x20(%rax)
movq %r12, (%rax)
movq %r15, 0x10(%rax)
movb %bpl, 0x8(%rax)
movq %r13, %rsi
movq 0x40(%rsp), %r15
movq %r15, %rdx
callq 0x2f457
cmpl $0x0, (%r15)
je 0x35b31
movq %rbx, %rdi
callq 0x122c0
movq %r14, %rdi
callq 0x35b52
jmp 0x35b2c
leaq 0x3f805(%rip), %rdx     # 0x75315
movq 0x40(%rsp), %rdi
movl $0x1, %esi
movl $0x45, %ecx
callq 0x145a4
movq %rbx, %rdi
callq 0x122c0
xorl %r14d, %r14d
jmp 0x35b40
movq %rbx, 0x18(%r14)
movq (%rsp), %rax
movq %rax, 0x168(%r14)
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_O3/markdryan[P]subtilis/frontend/call.c
// Function: subtilis_parser_call_addr_delete
void subtilis_parser_call_addr_delete(subtilis_parser_call_addr_t *call_addr)
{
	if (!call_addr)
		return;

	subtilis_type_free(&call_addr->call_type);
	free(call_addr->name);
	free(call_addr);
}

// Assembly:
testq %rdi, %rdi
je 0x35b76
pushq %rbx
movq %rdi, %rbx
addq $0x20, %rdi
callq 0x2f56e
movq 0x18(%rbx), %rdi
callq 0x122c0
movq %rbx, %rdi
popq %rbx
jmp 0x122c0
retq
nop
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/variable.c
// Function: subtilis_var_assign_hidden
void subtilis_var_assign_hidden(subtilis_parser_t *p, const char *var_name,
				const subtilis_type_t *id_type,
				subtilis_exp_t *e, subtilis_error_t *err)
{
	const subtilis_symbol_t *s;
	subtilis_ir_operand_t op1;

	s = subtilis_symbol_table_lookup(p->st, var_name);
	if (!s) {
		s = subtilis_symbol_table_insert(p->st, var_name, id_type, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	op1.reg = SUBTILIS_IR_REG_GLOBAL;

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

	if (s->is_reg)
		subtilis_type_if_assign_to_reg(p, s->loc, e, err);
	else
		subtilis_type_if_assign_to_mem(p, op1.reg, s->loc, e, err);

	return;

cleanup:

	subtilis_exp_delete(e);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq 0x60(%rdi), %rdi
callq 0x2ebbc
testq %rax, %rax
je 0x35bc9
movq %rax, %r12
leaq 0x8(%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x37860
cmpl $0x0, (%rbx)
je 0x35bf6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x60(%r14), %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x2e3cd
cmpl $0x0, (%rbx)
je 0x35ba0
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b166
movq (%r12), %rdx
cmpb $0x1, 0x2a8(%r12)
jne 0x35c24
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x36292
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x362c6
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/variable.c
// Function: subtilis_var_lookup_var
subtilis_exp_t *subtilis_var_lookup_var(subtilis_parser_t *p, const char *tbuf,
					subtilis_error_t *err)
{
	size_t reg;
	const subtilis_symbol_t *s;

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

	if (subtilis_type_if_is_numeric(&s->t) ||
	    s->t.type == SUBTILIS_TYPE_FN) {
		if (!s->is_reg) {
			return subtilis_type_if_load_from_mem(p, &s->t, reg,
							      s->loc, err);
		} else {
			return subtilis_exp_new_var(&s->t, s->loc, err);
		}
	} else if ((s->t.type == SUBTILIS_TYPE_STRING) ||
		   (s->t.type == SUBTILIS_TYPE_REC)) {
		/*
		 * We have a reference type.  We return a pointer to it.
		 */
		reg = subtilis_reference_get_pointer(p, reg, s->loc, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return NULL;
		return subtilis_exp_new_var(&s->t, reg, err);
	}

	/*
	 * TODO: Not great but will do for now.
	 */

	subtilis_error_set_numeric_expected(err, tbuf, p->l->stream->name,
					    p->l->line);
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq 0x1e8b1
cmpl $0x0, (%rbx)
je 0x35c7d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r13
movq %rax, %r14
addq $0x8, %r14
movq %r14, %rdi
callq 0x37534
testb %al, %al
je 0x35ca9
cmpb $0x0, 0x2a8(%r13)
je 0x35ced
movl (%r13), %esi
movq %r14, %rdi
jmp 0x35d30
movl (%r14), %eax
cmpl $0x7, %eax
je 0x35d09
cmpl $0x16, %eax
je 0x35d09
cmpl $0x9, %eax
je 0x35c93
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x3f658(%rip), %rax     # 0x75325
leaq 0x3e141(%rip), %rcx     # 0x73e15
movq %rbx, %rdi
movl $0x2c, %esi
movq %r12, %rdx
pushq $0x5a
pushq %rax
callq 0x143da
addq $0x10, %rsp
jmp 0x35c6d
movq 0x8(%rsp), %rdx
movq (%r13), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %r8
callq 0x36372
jmp 0x35c6f
movq 0x8(%rsp), %rsi
movq (%r13), %rdx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x4d71f
movq %rax, 0x8(%rsp)
cmpl $0x0, (%rbx)
jne 0x35c6d
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x2b5fb
jmp 0x35c6f
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_size
size_t subtilis_type_if_size(const subtilis_type_t *type, subtilis_error_t *err)
{
	subtilis_type_if_size_t fn;

	fn = prv_type_map[type->type]->size;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return 0;
	}
	return fn(type);
}

// Assembly:
movl (%rdi), %eax
leaq 0x6b3ef(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x35da0
jmpq *%rax
pushq %rax
leaq 0x3f5ac(%rip), %rdx     # 0x75354
movq %rsi, %rdi
movl $0xf, %esi
movl $0xa4, %ecx
callq 0x145a4
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_data_size
subtilis_exp_t *subtilis_type_if_data_size(subtilis_parser_t *p,
					   const subtilis_type_t *type,
					   subtilis_exp_t *e,
					   subtilis_error_t *err)
{
	subtilis_type_if_dsize_t fn = prv_type_map[type->type]->data_size;

	if (!fn) {
		subtilis_exp_delete(e);
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	return fn(p, type, e, err);
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
movl (%rsi), %eax
leaq 0x6b398(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x35dfb
movq %rbx, %rcx
popq %rbx
jmpq *%rax
movq %rdx, %rdi
callq 0x2b166
leaq 0x3f54a(%rip), %rdx     # 0x75354
movq %rbx, %rdi
movl $0xf, %esi
movl $0xbe, %ecx
callq 0x145a4
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_zero
subtilis_exp_t *subtilis_type_if_zero(subtilis_parser_t *p,
				      const subtilis_type_t *type,
				      subtilis_error_t *err)
{
	subtilis_type_if_zero_t fn;

	fn = prv_type_map[type->type]->zero;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}
	return fn(p, type, err);
}

// Assembly:
movl (%rsi), %eax
leaq 0x6b357(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x35e38
jmpq *%rax
pushq %rax
leaq 0x3f514(%rip), %rax     # 0x75354
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0xcd, %ecx
callq 0x145a4
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_zero_ref
void subtilis_type_if_zero_ref(subtilis_parser_t *p,
			       const subtilis_type_t *type, size_t mem_reg,
			       size_t loc, bool push, subtilis_error_t *err)
{
	subtilis_type_if_zeroref_t fn;

	fn = prv_type_map[type->type]->zero_ref;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, type, mem_reg, loc, push, err);
}

// Assembly:
movl (%rsi), %eax
leaq 0x6b31e(%rip), %r10     # 0xa1180
movq (%r10,%rax,8), %rax
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x35e75
movzbl %r8b, %r8d
jmpq *%rax
leaq 0x3f4d8(%rip), %rdx     # 0x75354
movq %r9, %rdi
movl $0xf, %esi
movl $0xdb, %ecx
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_copy_ret
void subtilis_type_if_copy_ret(subtilis_parser_t *p,
			       const subtilis_type_t *type, size_t dest_reg,
			       size_t source_reg, subtilis_error_t *err)
{
	subtilis_type_if_reg2_t fn;

	fn = prv_type_map[type->type]->copy_ret;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, type, dest_reg, source_reg, err);
}

// Assembly:
movl (%rsi), %eax
leaq 0x6b2e9(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x60(%rax), %rax
testq %rax, %rax
je 0x35ea6
jmpq *%rax
leaq 0x3f4a7(%rip), %rdx     # 0x75354
movq %r8, %rdi
movl $0xf, %esi
movl $0xe9, %ecx
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_new_ref
void subtilis_type_if_new_ref(subtilis_parser_t *p, const subtilis_type_t *type,
			      size_t mem_reg, size_t loc, subtilis_exp_t *e,
			      subtilis_error_t *err)
{
	subtilis_type_if_initref_t fn;

	fn = prv_type_map[type->type]->new_ref;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, type, mem_reg, loc, e, err);
}

// Assembly:
movl (%rsi), %eax
leaq 0x6b2b8(%rip), %r10     # 0xa1180
movq (%r10,%rax,8), %rax
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x35ed7
jmpq *%rax
leaq 0x3f476(%rip), %rdx     # 0x75354
movq %r9, %rdi
movl $0xf, %esi
movl $0xf7, %ecx
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_top_bit
subtilis_exp_t *subtilis_type_if_top_bit(subtilis_parser_t *p,
					 const subtilis_type_t *type,
					 subtilis_error_t *err)
{
	subtilis_type_if_none_t fn;

	fn = prv_type_map[type->type]->top_bit;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}
	return fn(p, err);
}

// Assembly:
movl (%rsi), %eax
leaq 0x6b225(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x50(%rax), %rax
testq %rax, %rax
je 0x35f6d
movq %rdx, %rsi
jmpq *%rax
pushq %rax
leaq 0x3f3df(%rip), %rax     # 0x75354
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x123, %ecx            # imm = 0x123
callq 0x145a4
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_zero_reg
void subtilis_type_if_zero_reg(subtilis_parser_t *p,
			       const subtilis_type_t *type, size_t reg,
			       subtilis_error_t *err)
{
	subtilis_type_if_zeroreg_t fn;

	fn = prv_type_map[type->type]->zero_reg;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, type, reg, err);
}

// Assembly:
movl (%rsi), %eax
leaq 0x6b1e9(%rip), %r8      # 0xa1180
movq (%r8,%rax,8), %rax
movq 0x58(%rax), %rax
testq %rax, %rax
je 0x35fa6
jmpq *%rax
leaq 0x3f3a7(%rip), %rdx     # 0x75354
movq %rcx, %rdi
movl $0xf, %esi
movl $0x131, %ecx            # imm = 0x131
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_array_of
void subtilis_type_if_array_of(const subtilis_type_t *element_type,
			       subtilis_type_t *type, subtilis_error_t *err)
{
	subtilis_type_if_typeof_t fn;

	if (element_type == type) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[element_type->type]->array_of;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(element_type, type, err);
}

// Assembly:
cmpq %rsi, %rdi
je 0x35fdc
movl (%rdi), %eax
leaq 0x6b1b3(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x70(%rax), %rax
testq %rax, %rax
je 0x35ff8
jmpq *%rax
leaq 0x3f371(%rip), %rax     # 0x75354
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x13d, %ecx            # imm = 0x13D
jmp 0x145a4
leaq 0x3f355(%rip), %rax     # 0x75354
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x143, %ecx            # imm = 0x143
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_vector_of
void subtilis_type_if_vector_of(const subtilis_type_t *element_type,
				subtilis_type_t *type, subtilis_error_t *err)
{
	subtilis_type_if_typeof_t fn;

	if (element_type == type) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[element_type->type]->vector_of;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(element_type, type, err);
}

// Assembly:
cmpq %rsi, %rdi
je 0x36031
movl (%rdi), %eax
leaq 0x6b15e(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x78(%rax), %rax
testq %rax, %rax
je 0x3604d
jmpq *%rax
leaq 0x3f31c(%rip), %rax     # 0x75354
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x14f, %ecx            # imm = 0x14F
jmp 0x145a4
leaq 0x3f300(%rip), %rax     # 0x75354
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x155, %ecx            # imm = 0x155
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_const_of
void subtilis_type_if_const_of(const subtilis_type_t *type,
			       subtilis_type_t *const_type,
			       subtilis_error_t *err)
{
	subtilis_type_if_typeof_t fn;

	if (const_type == type) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[type->type]->const_of;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(type, const_type, err);
}

// Assembly:
cmpq %rdi, %rsi
je 0x36086
movl (%rdi), %eax
leaq 0x6b109(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x68(%rax), %rax
testq %rax, %rax
je 0x360a2
jmpq *%rax
leaq 0x3f2c7(%rip), %rax     # 0x75354
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x162, %ecx            # imm = 0x162
jmp 0x145a4
leaq 0x3f2ab(%rip), %rax     # 0x75354
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x168, %ecx            # imm = 0x168
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_element_type
void subtilis_type_if_element_type(subtilis_parser_t *p,
				   const subtilis_type_t *type,
				   subtilis_type_t *element_type,
				   subtilis_error_t *err)
{
	subtilis_type_if_typeof_t fn;

	if (element_type == type) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[type->type]->element_type;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(type, element_type, err);
}

// Assembly:
cmpq %rsi, %rdx
je 0x360e7
movl (%rsi), %eax
leaq 0x6b0b4(%rip), %rdi     # 0xa1180
movq (%rdi,%rax,8), %rax
movq 0x80(%rax), %rax
testq %rax, %rax
je 0x36100
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
jmpq *%rax
leaq 0x3f266(%rip), %rdx     # 0x75354
movq %rcx, %rdi
movl $0xf, %esi
movl $0x176, %ecx            # imm = 0x176
jmp 0x145a4
leaq 0x3f24d(%rip), %rdx     # 0x75354
movq %rcx, %rdi
movl $0xf, %esi
movl $0x17c, %ecx            # imm = 0x17C
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: prv_call_unary_fn
static subtilis_exp_t *prv_call_unary_fn(subtilis_parser_t *p,
					 subtilis_exp_t *e,
					 subtilis_type_if_unary_t fn,
					 subtilis_error_t *err)
{
	if (!fn) {
		subtilis_exp_delete(e);
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	return fn(p, e, err);
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
testq %rdx, %rdx
je 0x36144
movq %rdx, %rax
movq %rbx, %rdx
popq %rbx
jmpq *%rax
movq %rsi, %rdi
callq 0x2b166
leaq 0x3f201(%rip), %rdx     # 0x75354
movq %rbx, %rdi
movl $0xf, %esi
movl $0x49, %ecx
callq 0x145a4
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_dup
subtilis_exp_t *subtilis_type_if_dup(subtilis_exp_t *e, subtilis_error_t *err)
{
	subtilis_type_if_dup_t fn;
	subtilis_exp_t *exp = subtilis_exp_new_empty(&e->type, err);

	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	fn = prv_type_map[e->type.type]->dup;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		goto cleanup;
	}
	fn(e, exp, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	return exp;

cleanup:
	subtilis_exp_delete(exp);
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2b597
cmpl $0x0, (%r14)
jne 0x361e9
movq %rax, %rbx
movl (%r15), %eax
leaq 0x6afdb(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x98(%rax), %rax
testq %rax, %rax
je 0x361c8
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *%rax
cmpl $0x0, (%r14)
jne 0x361e1
jmp 0x361eb
leaq 0x3f185(%rip), %rdx     # 0x75354
movq %r14, %rdi
movl $0xf, %esi
movl $0x19b, %ecx            # imm = 0x19B
callq 0x145a4
movq %rbx, %rdi
callq 0x2b166
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_memcpy
void subtilis_type_if_memcpy(subtilis_parser_t *p, subtilis_exp_t *e1,
			     subtilis_exp_t *e2, subtilis_error_t *err)
{
	subtilis_type_if_copy_collection_t fn;

	fn = prv_type_map[e1->type.type]->copy_col;
	if (!fn) {
		subtilis_error_set_expected(err, "string or array",
					    subtilis_type_name(&e1->type),
					    p->l->stream->name, p->l->line);
		subtilis_exp_delete(e1);
		subtilis_exp_delete(e2);
		return;
	}
	fn(p, e1, e2, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movl (%rsi), %eax
leaq 0x6af6f(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0xa0(%rax), %rax
testq %rax, %rax
je 0x3623a
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
movq %r14, %rdi
callq 0x2f5ad
movq (%r12), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3f0ff(%rip), %r10     # 0x75354
leaq 0x3f10b(%rip), %rdx     # 0x75367
movq %r15, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0x1b2                  # imm = 0x1B2
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %r14, %rdi
callq 0x2b166
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2b166
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_assign_to_reg
void subtilis_type_if_assign_to_reg(subtilis_parser_t *p, size_t reg,
				    subtilis_exp_t *e, subtilis_error_t *err)
{
	subtilis_type_if_sizet_exp_t fn;

	fn = prv_type_map[e->type.type]->assign_reg;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, reg, e, err);
}

// Assembly:
movl (%rdx), %eax
leaq 0x6aee5(%rip), %r8      # 0xa1180
movq (%r8,%rax,8), %rax
movq 0xa8(%rax), %rax
testq %rax, %rax
je 0x362ad
jmpq *%rax
leaq 0x3f0a0(%rip), %rdx     # 0x75354
movq %rcx, %rdi
movl $0xf, %esi
movl $0x1c1, %ecx            # imm = 0x1C1
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_assign_to_mem
void subtilis_type_if_assign_to_mem(subtilis_parser_t *p, size_t mem_reg,
				    size_t loc, subtilis_exp_t *e,
				    subtilis_error_t *err)
{
	subtilis_type_if_sizet2_exp_t fn;

	if (loc > 0x7fffffff) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[e->type.type]->assign_mem;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, mem_reg, loc, e, err);
}

// Assembly:
movq %rdx, %rax
shrq $0x1f, %rax
je 0x362e8
leaq 0x3f07e(%rip), %rdx     # 0x75354
movq %r8, %rdi
movl $0xf, %esi
movl $0x1ce, %ecx            # imm = 0x1CE
jmp 0x145a4
movl (%rcx), %eax
leaq 0x6ae8f(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0xb0(%rax), %rax
testq %rax, %rax
je 0x36303
jmpq *%rax
leaq 0x3f04a(%rip), %rdx     # 0x75354
movq %r8, %rdi
movl $0xf, %esi
movl $0x1d4, %ecx            # imm = 0x1D4
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_assign_to_new_mem
void subtilis_type_if_assign_to_new_mem(subtilis_parser_t *p, size_t mem_reg,
					size_t loc, subtilis_exp_t *e,
					subtilis_error_t *err)
{
	subtilis_type_if_sizet2_exp_t fn;

	if (loc > 0x7fffffff) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[e->type.type]->assign_new_mem;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, mem_reg, loc, e, err);
}

// Assembly:
movq %rdx, %rax
shrq $0x1f, %rax
je 0x3633e
leaq 0x3f028(%rip), %rdx     # 0x75354
movq %r8, %rdi
movl $0xf, %esi
movl $0x1e1, %ecx            # imm = 0x1E1
jmp 0x145a4
movl (%rcx), %eax
leaq 0x6ae39(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0xb8(%rax), %rax
testq %rax, %rax
je 0x36359
jmpq *%rax
leaq 0x3eff4(%rip), %rdx     # 0x75354
movq %r8, %rdi
movl $0xf, %esi
movl $0x1e7, %ecx            # imm = 0x1E7
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_load_from_mem
subtilis_exp_t *subtilis_type_if_load_from_mem(subtilis_parser_t *p,
					       const subtilis_type_t *type,
					       size_t mem_reg, size_t loc,
					       subtilis_error_t *err)
{
	subtilis_type_if_load_t fn;

	if (loc > 0x7fffffff) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	fn = prv_type_map[type->type]->load_mem;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}
	return fn(p, type, mem_reg, loc, err);
}

// Assembly:
pushq %rax
movq %rcx, %rax
shrq $0x1f, %rax
je 0x36392
leaq 0x3efd1(%rip), %rdx     # 0x75354
movq %r8, %rdi
movl $0xf, %esi
movl $0x1f5, %ecx            # imm = 0x1F5
jmp 0x363c3
movl (%rsi), %eax
leaq 0x6ade5(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x100(%rax), %rax
testq %rax, %rax
je 0x363af
popq %r9
jmpq *%rax
leaq 0x3ef9e(%rip), %rdx     # 0x75354
movq %r8, %rdi
movl $0xf, %esi
movl $0x1fb, %ecx            # imm = 0x1FB
callq 0x145a4
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_indexed_write
void subtilis_type_if_indexed_write(subtilis_parser_t *p, const char *var_name,
				    const subtilis_type_t *type, size_t mem_reg,
				    size_t loc, subtilis_exp_t *e,
				    subtilis_exp_t **indices,
				    size_t index_count, subtilis_error_t *err)
{
	subtilis_type_if_iwrite_t fn;

	if (loc > 0x7fffffff) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[type->type]->indexed_write;
	if (!fn) {
		subtilis_error_not_array_or_vector(
		    err, var_name, p->l->stream->name, p->l->line);
		return;
	}
	fn(p, var_name, type, mem_reg, loc, e, indices, index_count, err);
}

// Assembly:
pushq %rax
movq %rsi, %rax
movq %rdi, %rsi
movq 0x20(%rsp), %rdi
movq %r8, %r10
shrq $0x1f, %r10
je 0x363f8
leaq 0x3ef6c(%rip), %rdx     # 0x75354
movl $0xf, %esi
movl $0x20a, %ecx            # imm = 0x20A
popq %rax
jmp 0x145a4
movl (%rdx), %r10d
leaq 0x6ad7e(%rip), %r11     # 0xa1180
movq (%r11,%r10,8), %r10
movq 0xc0(%r10), %r11
testq %r11, %r11
je 0x3641c
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmpq *%r11
movq (%rsi), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3ef26(%rip), %r10     # 0x75354
leaq 0x3d9e0(%rip), %rcx     # 0x73e15
movl $0x3d, %esi
movq %rax, %rdx
pushq $0x211                  # imm = 0x211
pushq %r10
callq 0x143da
addq $0x10, %rsp
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_indexed_add
void subtilis_type_if_indexed_add(subtilis_parser_t *p, const char *var_name,
				  const subtilis_type_t *type, size_t mem_reg,
				  size_t loc, subtilis_exp_t *e,
				  subtilis_exp_t **indices, size_t index_count,
				  subtilis_error_t *err)
{
	subtilis_type_if_iwrite_t fn;

	if (loc > 0x7fffffff) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[type->type]->indexed_add;
	if (!fn) {
		subtilis_error_not_array_or_vector(
		    err, var_name, p->l->stream->name, p->l->line);
		return;
	}
	fn(p, var_name, type, mem_reg, loc, e, indices, index_count, err);
}

// Assembly:
pushq %rax
movq %rsi, %rax
movq %rdi, %rsi
movq 0x20(%rsp), %rdi
movq %r8, %r10
shrq $0x1f, %r10
je 0x3647b
leaq 0x3eee9(%rip), %rdx     # 0x75354
movl $0xf, %esi
movl $0x220, %ecx            # imm = 0x220
popq %rax
jmp 0x145a4
movl (%rdx), %r10d
leaq 0x6acfb(%rip), %r11     # 0xa1180
movq (%r11,%r10,8), %r10
movq 0xc8(%r10), %r11
testq %r11, %r11
je 0x3649f
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmpq *%r11
movq (%rsi), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3eea3(%rip), %r10     # 0x75354
leaq 0x3d95d(%rip), %rcx     # 0x73e15
movl $0x3d, %esi
movq %rax, %rdx
pushq $0x227                  # imm = 0x227
pushq %r10
callq 0x143da
addq $0x10, %rsp
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_indexed_sub
void subtilis_type_if_indexed_sub(subtilis_parser_t *p, const char *var_name,
				  const subtilis_type_t *type, size_t mem_reg,
				  size_t loc, subtilis_exp_t *e,
				  subtilis_exp_t **indices, size_t index_count,
				  subtilis_error_t *err)
{
	subtilis_type_if_iwrite_t fn;

	if (loc > 0x7fffffff) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	fn = prv_type_map[type->type]->indexed_sub;
	if (!fn) {
		subtilis_error_not_array_or_vector(
		    err, var_name, p->l->stream->name, p->l->line);
		return;
	}
	fn(p, var_name, type, mem_reg, loc, e, indices, index_count, err);
}

// Assembly:
pushq %rax
movq %rsi, %rax
movq %rdi, %rsi
movq 0x20(%rsp), %rdi
movq %r8, %r10
shrq $0x1f, %r10
je 0x364fe
leaq 0x3ee66(%rip), %rdx     # 0x75354
movl $0xf, %esi
movl $0x236, %ecx            # imm = 0x236
popq %rax
jmp 0x145a4
movl (%rdx), %r10d
leaq 0x6ac78(%rip), %r11     # 0xa1180
movq (%r11,%r10,8), %r10
movq 0xd0(%r10), %r11
testq %r11, %r11
je 0x36522
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmpq *%r11
movq (%rsi), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3ee20(%rip), %r10     # 0x75354
leaq 0x3d8da(%rip), %rcx     # 0x73e15
movl $0x3d, %esi
movq %rax, %rdx
pushq $0x23d                  # imm = 0x23D
pushq %r10
callq 0x143da
addq $0x10, %rsp
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_indexed_read
subtilis_exp_t *
subtilis_type_if_indexed_read(subtilis_parser_t *p, const char *var_name,
			      const subtilis_type_t *type, size_t mem_reg,
			      size_t loc, subtilis_exp_t **indices,
			      size_t index_count, subtilis_error_t *err)
{
	subtilis_type_if_iread_t fn;

	if (loc > 0x7fffffff) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	fn = prv_type_map[type->type]->indexed_read;
	if (!fn) {
		subtilis_error_not_array_or_vector(
		    err, var_name, p->l->stream->name, p->l->line);
		return NULL;
	}
	return fn(p, var_name, type, mem_reg, loc, indices, index_count, err);
}

// Assembly:
pushq %rax
movq %rsi, %rax
movq %rdi, %rsi
movq 0x18(%rsp), %rdi
movq %r8, %r10
shrq $0x1f, %r10
je 0x36582
leaq 0x3ede3(%rip), %rdx     # 0x75354
movl $0xf, %esi
movl $0x24c, %ecx            # imm = 0x24C
callq 0x145a4
jmp 0x365d7
movl (%rdx), %r10d
leaq 0x6abf4(%rip), %r11     # 0xa1180
movq (%r11,%r10,8), %r10
movq 0xd8(%r10), %r11
testq %r11, %r11
je 0x365a6
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmpq *%r11
movq (%rsi), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3ed9c(%rip), %r10     # 0x75354
leaq 0x3d856(%rip), %rcx     # 0x73e15
movl $0x3d, %esi
movq %rax, %rdx
pushq $0x253                  # imm = 0x253
pushq %r10
callq 0x143da
addq $0x10, %rsp
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_array_set
void subtilis_type_if_array_set(subtilis_parser_t *p, const char *var_name,
				const subtilis_type_t *type, size_t mem_reg,
				size_t loc, subtilis_exp_t *e,
				subtilis_error_t *err)
{
	subtilis_type_if_set_t fn;

	if (loc > 0x7fffffff) {
		subtilis_error_set_assertion_failed(err);
		goto cleanup;
	}

	fn = prv_type_map[type->type]->set;
	if (!fn) {
		subtilis_error_not_array_or_vector(
		    err, var_name, p->l->stream->name, p->l->line);
		goto cleanup;
	}

	fn(p, var_name, type, mem_reg, loc, e, err);
	return;

cleanup:
	subtilis_exp_delete(e);
}

// Assembly:
pushq %rbx
movq %r9, %rbx
movq %rsi, %rax
movq %rdi, %rsi
movq 0x10(%rsp), %rdi
movq %r8, %r9
shrq $0x1f, %r9
je 0x3660b
leaq 0x3ed5a(%rip), %rdx     # 0x75354
movl $0xf, %esi
movl $0x261, %ecx            # imm = 0x261
callq 0x145a4
jmp 0x36663
movl (%rdx), %r9d
leaq 0x6ab6b(%rip), %r10     # 0xa1180
movq (%r10,%r9,8), %r9
movq 0xe0(%r9), %r11
testq %r11, %r11
je 0x36632
movq %rsi, %rdi
movq %rax, %rsi
movq %rbx, %r9
popq %rbx
jmpq *%r11
movq (%rsi), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3ed10(%rip), %r10     # 0x75354
leaq 0x3d7ca(%rip), %rcx     # 0x73e15
movl $0x3d, %esi
movq %rax, %rdx
pushq $0x268                  # imm = 0x268
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %rbx, %rdi
popq %rbx
jmp 0x2b166