LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x3ba34(%rip), %rax     # 0x6e8c8
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq %rsi, (%rsp)
leaq 0x3c3ed(%rip), %rsi     # 0x6f294
leaq 0x3bdf2(%rip), %r8      # 0x6eca0
pushq $0x1
popq %rdx
leaq 0x8(%rsp), %r9
callq 0x32a8c
movl (%rbx), %ecx
pushq $-0x1
popq %r15
testl %ecx, %ecx
je 0x32ee0
cmpl $0x20, %ecx
jne 0x32f8e
movq %rbx, %rdi
callq 0x140a4
movq 0x8(%rsp), %r15
jmp 0x32f8e
movq 0x48(%r14), %rbp
movq %rax, 0x48(%r14)
movq %rax, %rdi
callq 0x2b774
movq %rax, %r13
movq 0x48(%r14), %rdi
callq 0x2b774
movq %rax, %r12
movq 0x48(%r14), %rdi
pushq $0x12
popq %rsi
pushq $0x4
popq %rdx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x2a819
cmpl $0x0, (%rbx)
jne 0x32f8a
movq 0x48(%r14), %rdi
pushq $0x43
popq %rsi
movq %rax, %rdx
movq %r13, %rcx
movq %r12, %r8
movq %rbx, %r9
callq 0x2a8c1
cmpl $0x0, (%rbx)
jne 0x32f8a
movq 0x48(%r14), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2b781
cmpl $0x0, (%rbx)
jne 0x32f8a
movq 0x48(%r14), %rdi
pushq $0x12
popq %rsi
pushq $0x4
popq %rdx
pushq $0x8
popq %rcx
movq %rbx, %r8
callq 0x2a819
cmpl $0x0, (%rbx)
jne 0x32f8a
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x4a982
cmpl $0x0, (%rbx)
jne 0x32f8a
movq 0x48(%r14), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2b781
cmpl $0x0, (%rbx)
je 0x32fa0
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
pushq $0x46
popq %rsi
movq %rbx, %rdx
callq 0x2a9af
cmpl $0x0, (%rbx)
movq %rbp, 0x48(%r14)
jne 0x32f8e
jmp 0x32ed6
// File: /workspace/github_c_makefile_star2_O2/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 0x43964
cmpl $0x0, (%rbx)
je 0x32fe3
pushq $-0x1
popq %rax
jmp 0x33005
movq %rax, %r15
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x33011
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_O2/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
leaq 0x18(%rsp), %r9
orq $-0x1, (%r9)
movq %rdi, %r14
leaq 0x3b890(%rip), %rax     # 0x6e8c8
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
subq $0x8, %rsp
leaq 0x3bc55(%rip), %r8      # 0x6eca0
pushq $0x1
popq %rdx
pushq %rbx
callq 0x32a8c
addq $0x10, %rsp
movl (%rbx), %ecx
pushq $-0x1
popq %rdx
testl %ecx, %ecx
je 0x3307c
cmpl $0x20, %ecx
jne 0x33165
movq %rbx, %rdi
callq 0x140a4
movq 0x18(%rsp), %rdx
jmp 0x33165
leaq 0x8(%r12), %rcx
movq %rcx, 0x10(%rsp)
movq 0x48(%r14), %rcx
movq %rcx, 0x8(%rsp)
movq %rax, 0x48(%r14)
xorl %r13d, %r13d
xorl %r15d, %r15d
cmpq 0x28(%r12), %r15
jae 0x33141
movq 0x18(%r12), %rsi
addq %r13, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x35ac5
cmpl $0x0, (%rbx)
jne 0x33133
movq %rax, %rbp
cmpq $-0x1, %rax
je 0x33124
pushq $0x4
popq %rax
testq %r15, %r15
je 0x330f3
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x2e515
movq 0x48(%r14), %rdi
movl %eax, %ecx
pushq $0x9
popq %rsi
pushq $0x4
popq %rdx
movq %rbx, %r8
callq 0x2a819
cmpl $0x0, (%rbx)
jne 0x33133
movq 0x58(%r14), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rcx
movq (%rcx,%rbp,8), %rsi
movq %r14, %rdi
movq %rax, %rdx
pushq $0x9
popq %rcx
xorl %r8d, %r8d
leaq 0x3bb8b(%rip), %r9      # 0x6eca0
pushq %rbx
pushq $0x0
callq 0x1de0d
popq %rcx
popq %rdx
cmpl $0x0, (%rbx)
jne 0x33133
incq %r15
addq $0x148, %r13            # imm = 0x148
jmp 0x33099
movq 0x8(%rsp), %rax
movq %rax, 0x48(%r14)
pushq $-0x1
popq %rdx
jmp 0x33165
movq 0x48(%r14), %rdi
pushq $0x46
popq %rsi
movq %rbx, %rdx
callq 0x2a9af
cmpl $0x0, (%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x48(%r14)
pushq $-0x1
popq %rdx
je 0x33072
movq %rdx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/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
subq $0x10, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x43964
cmpl $0x0, (%r12)
je 0x331b0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x33011
cmpl $0x0, (%r12)
jne 0x331ef
movq %r12, 0x8(%rsp)
andl $0x0, (%rsp)
leaq 0x3bac5(%rip), %r9      # 0x6eca0
pushq $0x9
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %r8d, %r8d
callq 0x1de0d
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x122c0
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x43a13
cmpl $0x0, (%r12)
jne 0x332e8
movq %rax, %rbx
leaq 0x18(%rsp), %r9
orq $-0x1, (%r9)
leaq 0x3b681(%rip), %rax     # 0x6e8c8
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
movq %r12, (%rsp)
leaq 0x3ba46(%rip), %r8      # 0x6eca0
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x32a8c
movl (%r12), %ecx
testl %ecx, %ecx
je 0x3327f
cmpl $0x20, %ecx
jne 0x332b8
movq %r12, %rdi
callq 0x140a4
jmp 0x332b4
movq 0x48(%r15), %rbp
movq %rax, 0x48(%r15)
pushq $0x4
popq %rdx
movq %r15, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
movq %r12, %r8
callq 0x43afb
cmpl $0x0, (%r12)
jne 0x332b0
movq 0x48(%r15), %rdi
pushq $0x46
popq %rsi
movq %r12, %rdx
callq 0x2a9af
movq %rbp, 0x48(%r15)
movl (%r12), %ecx
testl %ecx, %ecx
jne 0x332e0
movq %r12, 0x8(%rsp)
andl $0x0, (%rsp)
leaq 0x3b9d4(%rip), %r9      # 0x6eca0
pushq $0x9
popq %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %r8d, %r8d
callq 0x1de0d
movq %rbx, %rdi
callq 0x122c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/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 0x333b5
movq %rax, %r14
leaq 0x3bf70(%rip), %rsi     # 0x6f2a6
leaq 0x3bf63(%rip), %rcx     # 0x6f2a0
movq %rax, %rdi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x12280
leaq 0x3b577(%rip), %rax     # 0x6e8c8
movq %rsp, %rcx
movq %rax, (%rcx)
leaq 0x3b942(%rip), %r8      # 0x6eca0
pushq $0x1
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %r9
callq 0x314be
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x333da
cmpl $0x20, %ecx
jne 0x3343a
movq %rbx, %rdi
callq 0x140a4
movq %r13, %rdi
callq 0x2e826
movzbl %al, %eax
leaq 0x3b908(%rip), %r9      # 0x6eca0
pushq $0x9
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
pushq %rbx
pushq %rax
callq 0x1de0d
popq %rcx
popq %rdx
jmp 0x3343a
leaq 0x3be5d(%rip), %rdx     # 0x6f219
pushq $0x1
popq %rsi
movq %rbx, %rdi
movl $0xe20, %ecx            # imm = 0xE20
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1429e
movq 0x48(%r12), %rbp
movq %rax, 0x48(%r12)
movq %r13, %rdi
callq 0x2e6d8
pushq $0x4
popq %rdx
movq %r12, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
movq %rax, %r8
movq %rbx, %r9
callq 0x43375
cmpl $0x0, (%rbx)
jne 0x33435
movq 0x48(%r12), %rdi
movq 0x98(%rdi), %rsi
movq %rbx, %rdx
callq 0x2b781
cmpl $0x0, (%rbx)
jne 0x33435
movq 0x48(%r12), %rdi
pushq $0x46
popq %rsi
movq %rbx, %rdx
callq 0x2a9af
cmpl $0x0, (%rbx)
je 0x33450
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 0x4103a
cmpl $0x0, (%rbx)
movq %rbp, 0x48(%r12)
jne 0x3343a
jmp 0x33386
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x38
popq %rdi
callq 0x121d0
movq %rax, %rbx
testq %rax, %rax
je 0x33ac9
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 0x33ae0
movq 0x48(%rsp), %rdi
leaq 0x3b7f0(%rip), %rdx     # 0x6f2c5
pushq $0x1
popq %rsi
pushq $0x1f
popq %rcx
callq 0x1429e
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_O2/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 0x33b16
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x2dc17
movq 0x18(%rbx), %rdi
callq 0x122c0
movq %rbx, %rdi
popq %rbx
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movl $0x170, %edi            # imm = 0x170
callq 0x121d0
movq %rax, %rbx
testq %rax, %rax
je 0x33b86
movq %rbx, %rdi
addq $0x20, %rdi
movl $0x8, 0x20(%rbx)
movq %r12, (%rbx)
movq %r15, 0x10(%rbx)
movb %bpl, 0x8(%rbx)
movq %r13, %rsi
movq 0x40(%rsp), %r15
movq %r15, %rdx
callq 0x2db73
cmpl $0x0, (%r15)
jne 0x33b9d
movq %r14, 0x18(%rbx)
movq (%rsp), %rax
movq %rax, 0x168(%rbx)
jmp 0x33baf
leaq 0x3b738(%rip), %rdx     # 0x6f2c5
pushq $0x1
popq %rsi
pushq $0x45
popq %rcx
movq 0x40(%rsp), %rdi
callq 0x1429e
movq %r14, %rdi
callq 0x122c0
movq %rbx, %rdi
callq 0x33bc1
xorl %ebx, %ebx
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_O2/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 0x33be5
pushq %rbx
movq %rdi, %rbx
addq $0x20, %rdi
callq 0x2dc7c
movq 0x18(%rbx), %rdi
callq 0x122c0
movq %rbx, %rdi
popq %rbx
jmp 0x122c0
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2d376
testq %rax, %rax
je 0x33c39
movq %rax, %r12
leaq 0x8(%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x35977
cmpl $0x0, (%rbx)
je 0x33c66
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 0x2cbb7
cmpl $0x0, (%rbx)
je 0x33c10
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29d88
movq (%r12), %rdx
cmpb $0x1, 0x2a8(%r12)
jne 0x33c94
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 0x342ce
pushq $0x1
popq %rsi
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 0x34300
// File: /workspace/github_c_makefile_star2_O2/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 0x1dc51
cmpl $0x0, (%rbx)
je 0x33ceb
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 0x35655
testb %al, %al
je 0x33d17
cmpb $0x0, 0x2a8(%r13)
je 0x33d57
movl (%r13), %esi
movq %r14, %rdi
jmp 0x33d9a
movl (%r14), %eax
cmpl $0x7, %eax
je 0x33d73
cmpl $0x16, %eax
je 0x33d73
cmpl $0x9, %eax
je 0x33d01
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x3b59a(%rip), %rax     # 0x6f2d5
leaq 0x3a083(%rip), %rcx     # 0x6ddc5
pushq $0x2c
popq %rsi
movq %rbx, %rdi
movq %r12, %rdx
pushq $0x5a
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
jmp 0x33cdb
movq 0x8(%rsp), %rdx
movq (%r13), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %r8
callq 0x343a4
jmp 0x33cdd
movq 0x8(%rsp), %rsi
movq (%r13), %rdx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x4ab28
movq %rax, 0x8(%rsp)
cmpl $0x0, (%rbx)
jne 0x33cdb
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x2a226
jmp 0x33cdd
// File: /workspace/github_c_makefile_star2_O2/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 0x6d387(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x33e08
jmpq *%rax
pushq %rax
leaq 0x3b4f4(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rax
movq %rsi, %rdi
movl %eax, %esi
movl $0xa4, %ecx
callq 0x1429e
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6d330(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x33e63
movq %rbx, %rcx
popq %rbx
jmpq *%rax
movq %rdx, %rdi
callq 0x29d88
leaq 0x3b492(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %rbx, %rdi
movl $0xbe, %ecx
callq 0x1429e
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6d2f1(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x33e9e
jmpq *%rax
pushq %rax
leaq 0x3b45e(%rip), %rax     # 0x6f304
pushq $0xf
popq %rsi
movq %rdx, %rdi
movq %rax, %rdx
movl $0xcd, %ecx
callq 0x1429e
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6d2ba(%rip), %r10     # 0xa1180
movq (%r10,%rax,8), %rax
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x33ed9
movzbl %r8b, %r8d
jmpq *%rax
leaq 0x3b424(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r9, %rdi
movl $0xdb, %ecx
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 0x6d287(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x60(%rax), %rax
testq %rax, %rax
je 0x33f08
jmpq *%rax
leaq 0x3b3f5(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0xe9, %ecx
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 0x6d258(%rip), %r10     # 0xa1180
movq (%r10,%rax,8), %rax
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x33f37
jmpq *%rax
leaq 0x3b3c6(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r9, %rdi
movl $0xf7, %ecx
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_assign_ref
void subtilis_type_if_assign_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]->assign_ref;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, type, mem_reg, loc, e, err);
}

// Assembly:
movl (%rsi), %eax
leaq 0x6d229(%rip), %r10     # 0xa1180
movq (%r10,%rax,8), %rax
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x33f66
jmpq *%rax
leaq 0x3b397(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r9, %rdi
movl $0x106, %ecx            # imm = 0x106
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_assign_ref_no_rc
void subtilis_type_if_assign_ref_no_rc(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]->assign_ref_no_rc;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, type, mem_reg, loc, e, err);
}

// Assembly:
movl (%rsi), %eax
leaq 0x6d1fa(%rip), %r10     # 0xa1180
movq (%r10,%rax,8), %rax
movq 0x48(%rax), %rax
testq %rax, %rax
je 0x33f95
jmpq *%rax
leaq 0x3b368(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r9, %rdi
movl $0x115, %ecx            # imm = 0x115
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 0x6d1cb(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x50(%rax), %rax
testq %rax, %rax
je 0x33fc7
movq %rdx, %rsi
jmpq *%rax
pushq %rax
leaq 0x3b335(%rip), %rax     # 0x6f304
pushq $0xf
popq %rsi
movq %rdx, %rdi
movq %rax, %rdx
movl $0x123, %ecx            # imm = 0x123
callq 0x1429e
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6d191(%rip), %r8      # 0xa1180
movq (%r8,%rax,8), %rax
movq 0x58(%rax), %rax
testq %rax, %rax
je 0x33ffe
jmpq *%rax
leaq 0x3b2ff(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %rcx, %rdi
movl $0x131, %ecx            # imm = 0x131
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 0x34032
movl (%rdi), %eax
leaq 0x6d15d(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x70(%rax), %rax
testq %rax, %rax
je 0x3404c
jmpq *%rax
leaq 0x3b2cb(%rip), %rax     # 0x6f304
pushq $0xf
popq %rsi
movq %rdx, %rdi
movq %rax, %rdx
movl $0x13d, %ecx            # imm = 0x13D
jmp 0x1429e
leaq 0x3b2b1(%rip), %rax     # 0x6f304
pushq $0xf
popq %rsi
movq %rdx, %rdi
movq %rax, %rdx
movl $0x143, %ecx            # imm = 0x143
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 0x34083
movl (%rdi), %eax
leaq 0x6d10c(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x78(%rax), %rax
testq %rax, %rax
je 0x3409d
jmpq *%rax
leaq 0x3b27a(%rip), %rax     # 0x6f304
pushq $0xf
popq %rsi
movq %rdx, %rdi
movq %rax, %rdx
movl $0x14f, %ecx            # imm = 0x14F
jmp 0x1429e
leaq 0x3b260(%rip), %rax     # 0x6f304
pushq $0xf
popq %rsi
movq %rdx, %rdi
movq %rax, %rdx
movl $0x155, %ecx            # imm = 0x155
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 0x340d4
movl (%rdi), %eax
leaq 0x6d0bb(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x68(%rax), %rax
testq %rax, %rax
je 0x340ee
jmpq *%rax
leaq 0x3b229(%rip), %rax     # 0x6f304
pushq $0xf
popq %rsi
movq %rdx, %rdi
movq %rax, %rdx
movl $0x162, %ecx            # imm = 0x162
jmp 0x1429e
leaq 0x3b20f(%rip), %rax     # 0x6f304
pushq $0xf
popq %rsi
movq %rdx, %rdi
movq %rax, %rdx
movl $0x168, %ecx            # imm = 0x168
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 0x34131
movl (%rsi), %eax
leaq 0x6d06a(%rip), %rdi     # 0xa1180
movq (%rdi,%rax,8), %rax
movq 0x80(%rax), %rax
testq %rax, %rax
je 0x34148
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
jmpq *%rax
leaq 0x3b1cc(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %rcx, %rdi
movl $0x176, %ecx            # imm = 0x176
jmp 0x1429e
leaq 0x3b1b5(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %rcx, %rdi
movl $0x17c, %ecx            # imm = 0x17C
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 0x3418a
movq %rdx, %rax
movq %rbx, %rdx
popq %rbx
jmpq *%rax
movq %rsi, %rdi
callq 0x29d88
leaq 0x3b16b(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
pushq $0x49
popq %rcx
movq %rbx, %rdi
callq 0x1429e
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2a1c6
cmpl $0x0, (%r14)
jne 0x34229
movq %rax, %rbx
movl (%r15), %eax
leaq 0x6cf99(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x98(%rax), %rax
testq %rax, %rax
je 0x3420a
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *%rax
cmpl $0x0, (%r14)
jne 0x34221
jmp 0x3422b
leaq 0x3b0f3(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r14, %rdi
movl $0x19b, %ecx            # imm = 0x19B
callq 0x1429e
movq %rbx, %rdi
callq 0x29d88
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6cf2f(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0xa0(%rax), %rax
testq %rax, %rax
je 0x3427a
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 0x2dcbb
movq (%r12), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3b06f(%rip), %r10     # 0x6f304
leaq 0x3b07b(%rip), %rdx     # 0x6f317
pushq $0x1d
popq %rsi
movq %r15, %rdi
movq %rax, %rcx
pushq $0x1b2                  # imm = 0x1B2
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %r14, %rdi
callq 0x29d88
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x29d88
// File: /workspace/github_c_makefile_star2_O2/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 0x6cea9(%rip), %r8      # 0xa1180
movq (%r8,%rax,8), %rax
movq 0xa8(%rax), %rax
testq %rax, %rax
je 0x342e9
jmpq *%rax
leaq 0x3b014(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %rcx, %rdi
movl $0x1c1, %ecx            # imm = 0x1C1
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 0x34320
leaq 0x3aff4(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x1ce, %ecx            # imm = 0x1CE
jmp 0x1429e
movl (%rcx), %eax
leaq 0x6ce57(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0xb0(%rax), %rax
testq %rax, %rax
je 0x3433b
jmpq *%rax
leaq 0x3afc2(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x1d4, %ecx            # imm = 0x1D4
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 0x34372
leaq 0x3afa2(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x1e1, %ecx            # imm = 0x1E1
jmp 0x1429e
movl (%rcx), %eax
leaq 0x6ce05(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0xb8(%rax), %rax
testq %rax, %rax
je 0x3438d
jmpq *%rax
leaq 0x3af70(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x1e7, %ecx            # imm = 0x1E7
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 0x343c2
leaq 0x3af4f(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x1f5, %ecx            # imm = 0x1F5
jmp 0x343f1
movl (%rsi), %eax
leaq 0x6cdb5(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x100(%rax), %rax
testq %rax, %rax
je 0x343df
popq %r9
jmpq *%rax
leaq 0x3af1e(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x1fb, %ecx            # imm = 0x1FB
callq 0x1429e
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x34424
leaq 0x3aeee(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movl $0x20a, %ecx            # imm = 0x20A
popq %rax
jmp 0x1429e
movl (%rdx), %r10d
leaq 0x6cd52(%rip), %r11     # 0xa1180
movq (%r11,%r10,8), %r10
movq 0xc0(%r10), %r11
testq %r11, %r11
je 0x34448
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmpq *%r11
movq (%rsi), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3aeaa(%rip), %r10     # 0x6f304
leaq 0x39964(%rip), %rcx     # 0x6ddc5
pushq $0x3d
popq %rsi
movq %rax, %rdx
pushq $0x211                  # imm = 0x211
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x344a1
leaq 0x3ae71(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movl $0x220, %ecx            # imm = 0x220
popq %rax
jmp 0x1429e
movl (%rdx), %r10d
leaq 0x6ccd5(%rip), %r11     # 0xa1180
movq (%r11,%r10,8), %r10
movq 0xc8(%r10), %r11
testq %r11, %r11
je 0x344c5
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmpq *%r11
movq (%rsi), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3ae2d(%rip), %r10     # 0x6f304
leaq 0x398e7(%rip), %rcx     # 0x6ddc5
pushq $0x3d
popq %rsi
movq %rax, %rdx
pushq $0x227                  # imm = 0x227
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3451e
leaq 0x3adf4(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movl $0x236, %ecx            # imm = 0x236
popq %rax
jmp 0x1429e
movl (%rdx), %r10d
leaq 0x6cc58(%rip), %r11     # 0xa1180
movq (%r11,%r10,8), %r10
movq 0xd0(%r10), %r11
testq %r11, %r11
je 0x34542
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmpq *%r11
movq (%rsi), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3adb0(%rip), %r10     # 0x6f304
leaq 0x3986a(%rip), %rcx     # 0x6ddc5
pushq $0x3d
popq %rsi
movq %rax, %rdx
pushq $0x23d                  # imm = 0x23D
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3459c
leaq 0x3ad77(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movl $0x24c, %ecx            # imm = 0x24C
callq 0x1429e
jmp 0x345ed
movl (%rdx), %r10d
leaq 0x6cbda(%rip), %r11     # 0xa1180
movq (%r11,%r10,8), %r10
movq 0xd8(%r10), %r11
testq %r11, %r11
je 0x345c0
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmpq *%r11
movq (%rsi), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3ad32(%rip), %r10     # 0x6f304
leaq 0x397ec(%rip), %rcx     # 0x6ddc5
pushq $0x3d
popq %rsi
movq %rax, %rdx
pushq $0x253                  # imm = 0x253
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3461f
leaq 0x3acf4(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movl $0x261, %ecx            # imm = 0x261
callq 0x1429e
jmp 0x34673
movl (%rdx), %r9d
leaq 0x6cb57(%rip), %r10     # 0xa1180
movq (%r10,%r9,8), %r9
movq 0xe0(%r9), %r11
testq %r11, %r11
je 0x34646
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 0x3acac(%rip), %r10     # 0x6f304
leaq 0x39766(%rip), %rcx     # 0x6ddc5
pushq $0x3d
popq %rsi
movq %rax, %rdx
pushq $0x268                  # imm = 0x268
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %rbx, %rdi
popq %rbx
jmp 0x29d88
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_zero_buf
void subtilis_type_if_zero_buf(subtilis_parser_t *p,
			       const subtilis_type_t *type, size_t data_reg,
			       size_t size_reg, subtilis_error_t *err)
{
	subtilis_type_if_reg2_t fn;

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

	fn(p, type, data_reg, size_reg, err);
}

// Assembly:
movl (%rsi), %eax
leaq 0x6cafb(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0xe8(%rax), %rax
testq %rax, %rax
je 0x34697
jmpq *%rax
leaq 0x3ac66(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x27b, %ecx            # imm = 0x27B
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_append
void subtilis_type_if_append(subtilis_parser_t *p, subtilis_exp_t *a1,
			     subtilis_exp_t *a2, subtilis_exp_t *gran,
			     subtilis_error_t *err)
{
	subtilis_type_if_append_t fn;

	fn = prv_type_map[a1->type.type]->append;
	if (!fn) {
		subtilis_error_set_expected(err, "string or 1d array",
					    subtilis_type_name(&a1->type),
					    p->l->stream->name, p->l->line);
		goto cleanup;
	}

	fn(p, a1, a2, gran, err);
	return;

cleanup:
	subtilis_exp_delete(gran);
	subtilis_exp_delete(a2);
	subtilis_exp_delete(a1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r13
movl (%rsi), %eax
leaq 0x6ca31(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0xf8(%rax), %rax
testq %rax, %rax
je 0x34779
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
movq %rbx, %rdi
callq 0x2dcbb
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3ab70(%rip), %r10     # 0x6f304
leaq 0x3ab8c(%rip), %rdx     # 0x6f327
pushq $0x1d
popq %rsi
movq %r12, %rdi
movq %rax, %rcx
pushq $0x2a2                  # imm = 0x2A2
pushq %r10
callq 0x140cd
addq $0x10, %rsp
movq %r15, %rdi
callq 0x29d88
movq %r14, %rdi
callq 0x29d88
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x29d88