LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x46251
cmpl $0x0, (%rbx)
je 0x34874
movq $-0x1, %rax
jmp 0x34896
movq %rax, %r15
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x348a2
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_O1/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, %r15
movq %rdi, %r14
leaq 0x18(%rsp), %r9
movq $-0x1, (%r9)
leaq 0x4002c(%rip), %rax     # 0x748f8
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
subq $0x8, %rsp
leaq 0x403f1(%rip), %r8      # 0x74cd0
movl $0x1, %edx
pushq %rbx
callq 0x34307
addq $0x10, %rsp
movl (%rbx), %ecx
movq $-0x1, %rdx
testl %ecx, %ecx
je 0x34911
cmpl $0x20, %ecx
jne 0x34a05
movq %rbx, %rdi
callq 0x14404
jmp 0x34a00
movq 0x48(%r14), %rcx
movq %rcx, 0x8(%rsp)
movq %rax, 0x48(%r14)
cmpq $0x0, 0x28(%r15)
je 0x349da
leaq 0x8(%r15), %rax
movq %rax, 0x10(%rsp)
xorl %r12d, %r12d
xorl %ebp, %ebp
movq 0x18(%r15), %rsi
addq %r12, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x37b1b
cmpl $0x0, (%rbx)
jne 0x349eb
movq %rax, %r13
cmpq $-0x1, %rax
je 0x349c6
testq %rbp, %rbp
je 0x3498c
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x30118
movq 0x48(%r14), %rdi
movl %eax, %ecx
movl $0x4, %edx
movl $0x9, %esi
movq %rbx, %r8
callq 0x2c00f
cmpl $0x0, (%rbx)
je 0x34991
jmp 0x349eb
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 0x4031b(%rip), %r9      # 0x74cd0
pushq %rbx
pushq $0x0
callq 0x1e9b2
addq $0x10, %rsp
cmpl $0x0, (%rbx)
jne 0x349eb
incq %rbp
addq $0x148, %r12            # imm = 0x148
cmpq 0x28(%r15), %rbp
jb 0x34937
movq 0x48(%r14), %rdi
movl $0x46, %esi
movq %rbx, %rdx
callq 0x2c1b7
movq 0x8(%rsp), %rax
movq %rax, 0x48(%r14)
cmpl $0x0, (%rbx)
movq $-0x1, %rdx
jne 0x34a05
movq 0x18(%rsp), %rdx
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_O1/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 0x46251
cmpl $0x0, (%rbx)
je 0x34a46
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 0x348a2
cmpl $0x0, (%rbx)
jne 0x34a83
leaq 0x4026a(%rip), %r9      # 0x74cd0
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x9, %ecx
xorl %r8d, %r8d
pushq %rbx
pushq $0x0
callq 0x1e9b2
addq $0x10, %rsp
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x122c0
// File: /workspace/github_c_makefile_star2_O1/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 0x46304
cmpl $0x0, (%rbx)
jne 0x34b81
movq %rax, %r14
leaq 0x8(%rsp), %r9
movq $-0x1, (%r9)
leaq 0x3fe20(%rip), %rax     # 0x748f8
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
subq $0x8, %rsp
leaq 0x401e5(%rip), %r8      # 0x74cd0
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rsi
pushq %rbx
callq 0x34307
addq $0x10, %rsp
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x34b15
cmpl $0x20, %ecx
jne 0x34b50
movq %rbx, %rdi
callq 0x14404
jmp 0x34b50
movq 0x48(%r12), %rbp
movq %rax, 0x48(%r12)
movl $0x4, %edx
movq %r12, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x463ec
cmpl $0x0, (%rbx)
jne 0x34b4b
movq 0x48(%r12), %rdi
movl $0x46, %esi
movq %rbx, %rdx
callq 0x2c1b7
movq %rbp, 0x48(%r12)
cmpl $0x0, (%rbx)
jne 0x34b79
leaq 0x40174(%rip), %r9      # 0x74cd0
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x9, %ecx
xorl %r8d, %r8d
pushq %rbx
pushq $0x0
callq 0x1e9b2
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_O1/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, %r14
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 0x34c2b
movq %rax, %r15
leaq 0x4070b(%rip), %rsi     # 0x752d6
leaq 0x406fe(%rip), %rcx     # 0x752d0
movq %rax, %rdi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x12280
leaq 0x3fd12(%rip), %rax     # 0x748f8
movq %rsp, %rcx
movq %rax, (%rcx)
subq $0x8, %rsp
leaq 0x400d9(%rip), %r8      # 0x74cd0
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rsi
xorl %r9d, %r9d
pushq %rbx
callq 0x34307
addq $0x10, %rsp
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x34c52
cmpl $0x20, %ecx
jne 0x34cf4
movq %rbx, %rdi
callq 0x14404
jmp 0x34cc6
leaq 0x40617(%rip), %rdx     # 0x75249
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 0x145f4
movq 0x48(%r12), %rbp
movq %rax, 0x48(%r12)
movq %r13, %rdi
callq 0x30333
movl $0x4, %edx
movq %r12, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
movq %rax, %r8
movq %rbx, %r9
callq 0x45c55
cmpl $0x0, (%rbx)
jne 0x34cbc
movq 0x48(%r12), %rdi
movq 0x98(%rdi), %rsi
movq %rbx, %rdx
callq 0x2d017
cmpl $0x0, (%rbx)
jne 0x34cbc
movq 0x48(%r12), %rdi
movl $0x46, %esi
movq %rbx, %rdx
callq 0x2c1b7
cmpl $0x0, (%rbx)
jne 0x34cbc
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4375c
movq %rbp, 0x48(%r12)
cmpl $0x0, (%rbx)
jne 0x34cf4
movq %r13, %rdi
callq 0x30499
movzbl %al, %eax
leaq 0x3fff8(%rip), %r9      # 0x74cd0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x9, %ecx
xorl %r8d, %r8d
pushq %rbx
pushq %rax
callq 0x1e9b2
addq $0x10, %rsp
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x122c0
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r13
movl $0x38, %edi
callq 0x121d0
testq %rax, %rax
je 0x35ba3
movl 0x40(%rsp), %ecx
movq %r13, (%rax)
movq %r12, 0x8(%rax)
movb %bpl, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x30(%rax)
movl %ecx, 0x28(%rax)
jmp 0x35bc0
movq 0x48(%rsp), %rdi
leaq 0x3f746(%rip), %rdx     # 0x752f5
movl $0x1, %esi
movl $0x1f, %ecx
callq 0x145f4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/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 0x35bf3
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x2f7d2
movq 0x18(%rbx), %rdi
callq 0x122c0
movq %rbx, %rdi
popq %rbx
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x35c63
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 0x2f72e
cmpl $0x0, (%r15)
jne 0x35c7e
movq %r14, 0x18(%rbx)
movq (%rsp), %rax
movq %rax, 0x168(%rbx)
jmp 0x35c90
leaq 0x3f68b(%rip), %rdx     # 0x752f5
movq 0x40(%rsp), %rdi
movl $0x1, %esi
movl $0x45, %ecx
callq 0x145f4
movq %r14, %rdi
callq 0x122c0
movq %rbx, %rdi
callq 0x35ca2
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_O1/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 0x35cc6
pushq %rbx
movq %rdi, %rbx
addq $0x20, %rdi
callq 0x2f843
movq 0x18(%rbx), %rdi
callq 0x122c0
movq %rbx, %rdi
popq %rbx
jmp 0x122c0
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2eec8
testq %rax, %rax
je 0x35d19
movq %rax, %r12
leaq 0x8(%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x379c3
cmpl $0x0, (%rbx)
je 0x35d46
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 0x2e6e8
cmpl $0x0, (%rbx)
je 0x35cf0
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b4c3
movq (%r12), %rdx
cmpb $0x1, 0x2a8(%r12)
jne 0x35d74
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 0x363e2
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 0x36416
// File: /workspace/github_c_makefile_star2_O1/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 0x1e7ed
cmpl $0x0, (%rbx)
je 0x35dcd
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 0x37676
testb %al, %al
je 0x35df9
cmpb $0x0, 0x2a8(%r13)
je 0x35e3d
movl (%r13), %esi
movq %r14, %rdi
jmp 0x35e80
movl (%r14), %eax
cmpl $0x7, %eax
je 0x35e59
cmpl $0x16, %eax
je 0x35e59
cmpl $0x9, %eax
je 0x35de3
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x3f4e8(%rip), %rax     # 0x75305
leaq 0x3dfd1(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x2c, %esi
movq %r12, %rdx
pushq $0x5a
pushq %rax
callq 0x1442a
addq $0x10, %rsp
jmp 0x35dbd
movq 0x8(%rsp), %rdx
movq (%r13), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %r8
callq 0x364c2
jmp 0x35dbf
movq 0x8(%rsp), %rsi
movq (%r13), %rdx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x4d763
movq %rax, 0x8(%rsp)
cmpl $0x0, (%rbx)
jne 0x35dbd
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x2b971
jmp 0x35dbf
// File: /workspace/github_c_makefile_star2_O1/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 0x6b29f(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x35ef0
jmpq *%rax
pushq %rax
leaq 0x3f43c(%rip), %rdx     # 0x75334
movq %rsi, %rdi
movl $0xf, %esi
movl $0xa4, %ecx
callq 0x145f4
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6b248(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x35f4b
movq %rbx, %rcx
popq %rbx
jmpq *%rax
movq %rdx, %rdi
callq 0x2b4c3
leaq 0x3f3da(%rip), %rdx     # 0x75334
movq %rbx, %rdi
movl $0xf, %esi
movl $0xbe, %ecx
callq 0x145f4
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6b207(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x35f88
jmpq *%rax
pushq %rax
leaq 0x3f3a4(%rip), %rax     # 0x75334
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0xcd, %ecx
callq 0x145f4
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6b1ce(%rip), %r10     # 0xa1180
movq (%r10,%rax,8), %rax
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x35fc5
movzbl %r8b, %r8d
jmpq *%rax
leaq 0x3f368(%rip), %rdx     # 0x75334
movq %r9, %rdi
movl $0xf, %esi
movl $0xdb, %ecx
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x6b199(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x60(%rax), %rax
testq %rax, %rax
je 0x35ff6
jmpq *%rax
leaq 0x3f337(%rip), %rdx     # 0x75334
movq %r8, %rdi
movl $0xf, %esi
movl $0xe9, %ecx
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x6b168(%rip), %r10     # 0xa1180
movq (%r10,%rax,8), %rax
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x36027
jmpq *%rax
leaq 0x3f306(%rip), %rdx     # 0x75334
movq %r9, %rdi
movl $0xf, %esi
movl $0xf7, %ecx
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x6b0d5(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x50(%rax), %rax
testq %rax, %rax
je 0x360bd
movq %rdx, %rsi
jmpq *%rax
pushq %rax
leaq 0x3f26f(%rip), %rax     # 0x75334
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x123, %ecx            # imm = 0x123
callq 0x145f4
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6b099(%rip), %r8      # 0xa1180
movq (%r8,%rax,8), %rax
movq 0x58(%rax), %rax
testq %rax, %rax
je 0x360f6
jmpq *%rax
leaq 0x3f237(%rip), %rdx     # 0x75334
movq %rcx, %rdi
movl $0xf, %esi
movl $0x131, %ecx            # imm = 0x131
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x3612c
movl (%rdi), %eax
leaq 0x6b063(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x70(%rax), %rax
testq %rax, %rax
je 0x36148
jmpq *%rax
leaq 0x3f201(%rip), %rax     # 0x75334
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x13d, %ecx            # imm = 0x13D
jmp 0x145f4
leaq 0x3f1e5(%rip), %rax     # 0x75334
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x143, %ecx            # imm = 0x143
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x36181
movl (%rdi), %eax
leaq 0x6b00e(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x78(%rax), %rax
testq %rax, %rax
je 0x3619d
jmpq *%rax
leaq 0x3f1ac(%rip), %rax     # 0x75334
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x14f, %ecx            # imm = 0x14F
jmp 0x145f4
leaq 0x3f190(%rip), %rax     # 0x75334
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x155, %ecx            # imm = 0x155
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x361d6
movl (%rdi), %eax
leaq 0x6afb9(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x68(%rax), %rax
testq %rax, %rax
je 0x361f2
jmpq *%rax
leaq 0x3f157(%rip), %rax     # 0x75334
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x162, %ecx            # imm = 0x162
jmp 0x145f4
leaq 0x3f13b(%rip), %rax     # 0x75334
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x168, %ecx            # imm = 0x168
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x36237
movl (%rsi), %eax
leaq 0x6af64(%rip), %rdi     # 0xa1180
movq (%rdi,%rax,8), %rax
movq 0x80(%rax), %rax
testq %rax, %rax
je 0x36250
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
jmpq *%rax
leaq 0x3f0f6(%rip), %rdx     # 0x75334
movq %rcx, %rdi
movl $0xf, %esi
movl $0x176, %ecx            # imm = 0x176
jmp 0x145f4
leaq 0x3f0dd(%rip), %rdx     # 0x75334
movq %rcx, %rdi
movl $0xf, %esi
movl $0x17c, %ecx            # imm = 0x17C
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x36294
movq %rdx, %rax
movq %rbx, %rdx
popq %rbx
jmpq *%rax
movq %rsi, %rdi
callq 0x2b4c3
leaq 0x3f091(%rip), %rdx     # 0x75334
movq %rbx, %rdi
movl $0xf, %esi
movl $0x49, %ecx
callq 0x145f4
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2b90d
cmpl $0x0, (%r14)
jne 0x36339
movq %rax, %rbx
movl (%r15), %eax
leaq 0x6ae8b(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x98(%rax), %rax
testq %rax, %rax
je 0x36318
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *%rax
cmpl $0x0, (%r14)
jne 0x36331
jmp 0x3633b
leaq 0x3f015(%rip), %rdx     # 0x75334
movq %r14, %rdi
movl $0xf, %esi
movl $0x19b, %ecx            # imm = 0x19B
callq 0x145f4
movq %rbx, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6ae1f(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0xa0(%rax), %rax
testq %rax, %rax
je 0x3638a
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 0x2f882
movq (%r12), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3ef8f(%rip), %r10     # 0x75334
leaq 0x3ef9b(%rip), %rdx     # 0x75347
movq %r15, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0x1b2                  # imm = 0x1B2
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %r14, %rdi
callq 0x2b4c3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2b4c3
// File: /workspace/github_c_makefile_star2_O1/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 0x6ad95(%rip), %r8      # 0xa1180
movq (%r8,%rax,8), %rax
movq 0xa8(%rax), %rax
testq %rax, %rax
je 0x363fd
jmpq *%rax
leaq 0x3ef30(%rip), %rdx     # 0x75334
movq %rcx, %rdi
movl $0xf, %esi
movl $0x1c1, %ecx            # imm = 0x1C1
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x36438
leaq 0x3ef0e(%rip), %rdx     # 0x75334
movq %r8, %rdi
movl $0xf, %esi
movl $0x1ce, %ecx            # imm = 0x1CE
jmp 0x145f4
movl (%rcx), %eax
leaq 0x6ad3f(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0xb0(%rax), %rax
testq %rax, %rax
je 0x36453
jmpq *%rax
leaq 0x3eeda(%rip), %rdx     # 0x75334
movq %r8, %rdi
movl $0xf, %esi
movl $0x1d4, %ecx            # imm = 0x1D4
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x3648e
leaq 0x3eeb8(%rip), %rdx     # 0x75334
movq %r8, %rdi
movl $0xf, %esi
movl $0x1e1, %ecx            # imm = 0x1E1
jmp 0x145f4
movl (%rcx), %eax
leaq 0x6ace9(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0xb8(%rax), %rax
testq %rax, %rax
je 0x364a9
jmpq *%rax
leaq 0x3ee84(%rip), %rdx     # 0x75334
movq %r8, %rdi
movl $0xf, %esi
movl $0x1e7, %ecx            # imm = 0x1E7
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x364e2
leaq 0x3ee61(%rip), %rdx     # 0x75334
movq %r8, %rdi
movl $0xf, %esi
movl $0x1f5, %ecx            # imm = 0x1F5
jmp 0x36513
movl (%rsi), %eax
leaq 0x6ac95(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x100(%rax), %rax
testq %rax, %rax
je 0x364ff
popq %r9
jmpq *%rax
leaq 0x3ee2e(%rip), %rdx     # 0x75334
movq %r8, %rdi
movl $0xf, %esi
movl $0x1fb, %ecx            # imm = 0x1FB
callq 0x145f4
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x36548
leaq 0x3edfc(%rip), %rdx     # 0x75334
movl $0xf, %esi
movl $0x20a, %ecx            # imm = 0x20A
popq %rax
jmp 0x145f4
movl (%rdx), %r10d
leaq 0x6ac2e(%rip), %r11     # 0xa1180
movq (%r11,%r10,8), %r10
movq 0xc0(%r10), %r11
testq %r11, %r11
je 0x3656c
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmpq *%r11
movq (%rsi), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3edb6(%rip), %r10     # 0x75334
leaq 0x3d870(%rip), %rcx     # 0x73df5
movl $0x3d, %esi
movq %rax, %rdx
pushq $0x211                  # imm = 0x211
pushq %r10
callq 0x1442a
addq $0x10, %rsp
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x365cb
leaq 0x3ed79(%rip), %rdx     # 0x75334
movl $0xf, %esi
movl $0x220, %ecx            # imm = 0x220
popq %rax
jmp 0x145f4
movl (%rdx), %r10d
leaq 0x6abab(%rip), %r11     # 0xa1180
movq (%r11,%r10,8), %r10
movq 0xc8(%r10), %r11
testq %r11, %r11
je 0x365ef
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmpq *%r11
movq (%rsi), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3ed33(%rip), %r10     # 0x75334
leaq 0x3d7ed(%rip), %rcx     # 0x73df5
movl $0x3d, %esi
movq %rax, %rdx
pushq $0x227                  # imm = 0x227
pushq %r10
callq 0x1442a
addq $0x10, %rsp
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3664e
leaq 0x3ecf6(%rip), %rdx     # 0x75334
movl $0xf, %esi
movl $0x236, %ecx            # imm = 0x236
popq %rax
jmp 0x145f4
movl (%rdx), %r10d
leaq 0x6ab28(%rip), %r11     # 0xa1180
movq (%r11,%r10,8), %r10
movq 0xd0(%r10), %r11
testq %r11, %r11
je 0x36672
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmpq *%r11
movq (%rsi), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3ecb0(%rip), %r10     # 0x75334
leaq 0x3d76a(%rip), %rcx     # 0x73df5
movl $0x3d, %esi
movq %rax, %rdx
pushq $0x23d                  # imm = 0x23D
pushq %r10
callq 0x1442a
addq $0x10, %rsp
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x366d2
leaq 0x3ec73(%rip), %rdx     # 0x75334
movl $0xf, %esi
movl $0x24c, %ecx            # imm = 0x24C
callq 0x145f4
jmp 0x36727
movl (%rdx), %r10d
leaq 0x6aaa4(%rip), %r11     # 0xa1180
movq (%r11,%r10,8), %r10
movq 0xd8(%r10), %r11
testq %r11, %r11
je 0x366f6
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmpq *%r11
movq (%rsi), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3ec2c(%rip), %r10     # 0x75334
leaq 0x3d6e6(%rip), %rcx     # 0x73df5
movl $0x3d, %esi
movq %rax, %rdx
pushq $0x253                  # imm = 0x253
pushq %r10
callq 0x1442a
addq $0x10, %rsp
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3675b
leaq 0x3ebea(%rip), %rdx     # 0x75334
movl $0xf, %esi
movl $0x261, %ecx            # imm = 0x261
callq 0x145f4
jmp 0x367b3
movl (%rdx), %r9d
leaq 0x6aa1b(%rip), %r10     # 0xa1180
movq (%r10,%r9,8), %r9
movq 0xe0(%r9), %r11
testq %r11, %r11
je 0x36782
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 0x3eba0(%rip), %r10     # 0x75334
leaq 0x3d65a(%rip), %rcx     # 0x73df5
movl $0x3d, %esi
movq %rax, %rdx
pushq $0x268                  # imm = 0x268
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %rbx, %rdi
popq %rbx
jmp 0x2b4c3
// File: /workspace/github_c_makefile_star2_O1/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 0x6a8e9(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0xf8(%rax), %rax
testq %rax, %rax
je 0x368c1
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 0x2f882
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3ea58(%rip), %r10     # 0x75334
leaq 0x3ea74(%rip), %rdx     # 0x75357
movq %r12, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0x2a2                  # imm = 0x2A2
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %r15, %rdi
callq 0x2b4c3
movq %r14, %rdi
callq 0x2b4c3
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b4c3
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_to_int
subtilis_exp_t *subtilis_type_if_to_int(subtilis_parser_t *p, subtilis_exp_t *e,
					subtilis_error_t *err)
{
	if (!prv_type_map[e->type.type]->to_int32) {
		subtilis_error_set_integer_expected(
		    err, subtilis_type_name(&e->type), p->l->stream->name,
		    p->l->line);
		subtilis_exp_delete(e);
		return NULL;
	}
	return prv_call_unary_fn(p, e, prv_type_map[e->type.type]->to_int32,
				 err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl (%rsi), %eax
leaq 0x6a84a(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x108(%rax), %rax
testq %rax, %rax
je 0x36956
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movq %rbx, %rdi
callq 0x2f882
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3e9c4(%rip), %r10     # 0x75334
leaq 0x3d47e(%rip), %rcx     # 0x73df5
movq %r14, %rdi
movl $0x17, %esi
movq %rax, %rdx
pushq $0x2b5                  # imm = 0x2B5
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b4c3
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_to_byte
subtilis_exp_t *subtilis_type_if_to_byte(subtilis_parser_t *p,
					 subtilis_exp_t *e,
					 subtilis_error_t *err)
{
	if (subtilis_type_if_is_const(&e->type)) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	if (!prv_type_map[e->type.type]->to_byte) {
		subtilis_error_set_byte_expected(
		    err, subtilis_type_name(&e->type), p->l->stream->name,
		    p->l->line);
		subtilis_exp_delete(e);
		return NULL;
	}

	return prv_call_unary_fn(p, e, prv_type_map[e->type.type]->to_byte,
				 err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl (%rsi), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
je 0x369e7
leaq 0x6a7bd(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rcx
cmpb $0x1, (%rcx)
jne 0x369e7
leaq 0x3e961(%rip), %rdx     # 0x75334
movq %r14, %rdi
movl $0xf, %esi
movl $0x2c2, %ecx            # imm = 0x2C2
callq 0x145f4
jmp 0x36a52
leaq 0x6a792(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x118(%rax), %rax
testq %rax, %rax
je 0x36a0e
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movq %rbx, %rdi
callq 0x2f882
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3e90c(%rip), %r10     # 0x75334
leaq 0x3d3c6(%rip), %rcx     # 0x73df5
movq %r14, %rdi
movl $0x18, %esi
movq %rax, %rdx
pushq $0x2c9                  # imm = 0x2C9
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b4c3
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_zerox
subtilis_exp_t *subtilis_type_if_zerox(subtilis_parser_t *p, subtilis_exp_t *e,
				       const subtilis_type_t *type,
				       subtilis_error_t *err)
{
	if (!prv_type_map[e->type.type]->zerox) {
		subtilis_error_set_bad_zero_extend(
		    err, subtilis_type_name(&e->type), subtilis_type_name(type),
		    p->l->stream->name, p->l->line);
		subtilis_exp_delete(e);
		return NULL;
	}

	return prv_type_map[e->type.type]->zerox(p, e, type, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movl (%rsi), %eax
leaq 0x6a6cf(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x110(%rax), %rax
testq %rax, %rax
je 0x36ad8
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
movq %rbx, %rdi
callq 0x2f882
movq %rax, %r13
movq %r12, %rdi
callq 0x2f882
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3e837(%rip), %r10     # 0x75334
movq %r14, %rdi
movl $0x46, %esi
movq %r13, %rdx
movq %rax, %rcx
pushq $0x2e1                  # imm = 0x2E1
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b4c3
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq