LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_ir_call_str_to_int32
subtilis_exp_t *subtilis_builtin_ir_call_str_to_int32(subtilis_parser_t *p,
						      size_t str_reg,
						      size_t base_reg,
						      subtilis_error_t *err)
{
	subtilis_ir_section_t *fn;
	const subtilis_type_t *ptype[2];

	ptype[0] = &subtilis_type_integer;
	ptype[1] = &subtilis_type_integer;

	fn = prv_add_args(p, "_str_to_int32", 2, ptype, &subtilis_type_integer,
			  err);
	if (err->type != SUBTILIS_ERROR_OK) {
		if (err->type != SUBTILIS_ERROR_ALREADY_DEFINED)
			return NULL;
		subtilis_error_init(err);
	} else {
		prv_builtins_ir_str_to_int32(p, fn, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return NULL;
	}

	return subtilis_parser_call_2_arg_fn(
	    p, "_str_to_int32", str_reg, base_reg, SUBTILIS_IR_REG_TYPE_INTEGER,
	    SUBTILIS_IR_REG_TYPE_INTEGER, &subtilis_type_integer, true, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq 0x67491(%rip), %rax     # 0xab8d0
movq %rax, -0x40(%rbp)
leaq 0x67486(%rip), %rax     # 0xab8d0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rcx
movq -0x28(%rbp), %r9
leaq 0x67e51(%rip), %rsi     # 0xac2b2
movl $0x2, %edx
leaq 0x67463(%rip), %r8      # 0xab8d0
callq 0x42960
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4449d
movq -0x28(%rbp), %rax
cmpl $0x20, (%rax)
je 0x44492
movq $0x0, -0x8(%rbp)
jmp 0x44501
movq -0x28(%rbp), %rdi
callq 0x15670
jmp 0x444c3
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x44510
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x444c1
movq $0x0, -0x8(%rbp)
jmp 0x44501
jmp 0x444c3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
leaq 0x67dd8(%rip), %rsi     # 0xac2b2
xorl %r9d, %r9d
leaq 0x673ec(%rip), %r10     # 0xab8d0
movl %r9d, %r8d
movq %r10, (%rsp)
movl $0x1, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x248d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_ir_deref_array_els
size_t subtilis_builtin_ir_deref_array_els(subtilis_parser_t *p,
					   subtilis_error_t *err)
{
	subtilis_ir_section_t *fn;
	const subtilis_type_t *ptype[2];
	size_t call_index;
	const char *name = "_deref_array";

	ptype[0] = &subtilis_type_integer;

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

	return call_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x67a59(%rip), %rax     # 0xac2c0
movq %rax, -0x40(%rbp)
leaq 0x6705e(%rip), %rax     # 0xab8d0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movl $0x1, %edx
leaq 0x67416(%rip), %r8      # 0xabca8
leaq -0x38(%rbp), %r9
movq %rax, (%rsp)
callq 0x44910
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x448ca
movq -0x18(%rbp), %rax
cmpl $0x20, (%rax)
je 0x448bf
movq $-0x1, -0x8(%rbp)
jmp 0x448f8
movq -0x18(%rbp), %rdi
callq 0x15670
jmp 0x448f0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x44ab0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x448ee
movq $-0x1, -0x8(%rbp)
jmp 0x448f8
jmp 0x448f0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_call_ir_deref_array_els
void subtilis_builtin_call_ir_deref_array_els(subtilis_parser_t *p,
					      const subtilis_type_t *type,
					      size_t base_reg,
					      subtilis_error_t *err)
{
	const char *name = "_deref_array";
	(void)subtilis_builtin_ir_deref_array_els(p, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	(void)subtilis_parser_call_1_arg_fn(
		p, name, base_reg, SUBTILIS_BUILTINS_MAX,
		SUBTILIS_IR_REG_TYPE_INTEGER, &subtilis_type_void, false,
		err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x67521(%rip), %rax     # 0xac2c0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x44850
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x44dbb
jmp 0x44deb
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movl $0x9, %ecx
xorl %r8d, %r8d
leaq 0x66ece(%rip), %r9      # 0xabca8
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x24790
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_ir_deref_array_recs
size_t subtilis_builtin_ir_deref_array_recs(subtilis_parser_t *p,
					    const subtilis_type_t *el_type,
					    subtilis_error_t *err)
{
	char *name;
	size_t call_index;

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

	call_index = prv_ir_deref_array_recs_create(p, el_type, name, err);

	free(name);
	return call_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x44e70
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x44e38
movq $-0x1, -0x8(%rbp)
jmp 0x44e62
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x44f20
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x12290
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: prv_get_deref_array_recs_name
static char *prv_get_deref_array_recs_name(const subtilis_type_t *el_type,
					   subtilis_error_t *err)
{
	char *name;
	const char *base_name = "_deref_array_";
	const char *el_type_name = subtilis_type_name(el_type);

	name = malloc(strlen(base_name) + strlen(el_type_name) + 1);
	if (!name) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	sprintf(name, "%s%s", base_name, el_type_name);

	return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x67469(%rip), %rax     # 0xac2f0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e190
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x120d0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x120d0
movq -0x38(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
callq 0x121b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x44eed
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x67379(%rip), %rdx     # 0xac252
movl $0xd40, %ecx            # imm = 0xD40
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x44f0f
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq 0x687c4(%rip), %rsi     # 0xad6c4
movb $0x0, %al
callq 0x12250
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: prv_ir_deref_array_recs_create
static size_t prv_ir_deref_array_recs_create(subtilis_parser_t *p,
					     const subtilis_type_t *el_type,
					     const char *name,
					     subtilis_error_t *err)
{
	subtilis_ir_section_t *fn;
	const subtilis_type_t *ptype[2];
	size_t call_index = SIZE_MAX;

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

	return call_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $-0x1, -0x48(%rbp)
leaq 0x66989(%rip), %rax     # 0xab8d0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movl $0x1, %edx
leaq 0x66d41(%rip), %r8      # 0xabca8
leaq -0x48(%rbp), %r9
movq %rax, (%rsp)
callq 0x44910
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x44f9f
movq -0x28(%rbp), %rax
cmpl $0x20, (%rax)
je 0x44f94
movq $-0x1, -0x8(%rbp)
jmp 0x44fbc
movq -0x28(%rbp), %rdi
callq 0x15670
jmp 0x44fb4
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x46c00
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_ir_call_deref_array_recs
void subtilis_builtin_ir_call_deref_array_recs(subtilis_parser_t *p,
					       const subtilis_type_t *el_type,
					       size_t base_reg,
					       subtilis_error_t *err)
{
	char *name;

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

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

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

cleanup:
	free(name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x44e70
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x45004
jmp 0x4505d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x44f20
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x45024
jmp 0x45054
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movl $0x9, %ecx
xorl %r8d, %r8d
leaq 0x66c65(%rip), %r9      # 0xabca8
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x24790
movq -0x28(%rbp), %rdi
callq 0x12290
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x67246(%rip), %rax     # 0xac2cd
movq %rax, -0x38(%rbp)
leaq 0x6683e(%rip), %rax     # 0xab8d0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movl $0x1, %edx
leaq 0x66bf6(%rip), %r8      # 0xabca8
leaq -0x30(%rbp), %r9
movq %rax, (%rsp)
callq 0x44910
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x450ea
movq -0x18(%rbp), %rax
cmpl $0x20, (%rax)
je 0x450df
movq $-0x1, -0x8(%rbp)
jmp 0x45118
movq -0x18(%rbp), %rdi
callq 0x15670
jmp 0x45110
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x45130
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4510e
movq $-0x1, -0x8(%rbp)
jmp 0x45118
jmp 0x45110
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x628d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x452e8
movq $-0x1, -0x8(%rbp)
jmp 0x45312
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x45320
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x12290
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $-0x1, -0x40(%rbp)
leaq 0x66589(%rip), %rax     # 0xab8d0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movl $0x1, %edx
leaq 0x66941(%rip), %r8      # 0xabca8
leaq -0x40(%rbp), %r9
movq %rax, (%rsp)
callq 0x44910
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4539f
movq -0x28(%rbp), %rax
cmpl $0x20, (%rax)
je 0x45394
movq $-0x1, -0x8(%rbp)
jmp 0x453d1
movq -0x28(%rbp), %rdi
callq 0x15670
jmp 0x453c9
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x46d10
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x453c7
movq $-0x1, -0x8(%rbp)
jmp 0x453d1
jmp 0x453c9
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x628d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x45414
jmp 0x4546d
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x45320
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x45434
jmp 0x45464
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movl $0x9, %ecx
xorl %r8d, %r8d
leaq 0x66855(%rip), %r9      # 0xabca8
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x24790
movq -0x28(%rbp), %rdi
callq 0x12290
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x629d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x454b4
jmp 0x4550d
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x45520
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x454d4
jmp 0x45504
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movl $0x9, %ecx
xorl %r8d, %r8d
leaq 0x667b5(%rip), %r9      # 0xabca8
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x24790
movq -0x28(%rbp), %rdi
callq 0x12290
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: prv_get_rec_ref_fn
static void prv_get_rec_ref_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;
		subtilis_error_init(err);
	} else {
		prv_builtins_ir_gen_rec_ref(p, type, fn, err);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $-0x1, -0x38(%rbp)
leaq 0x66389(%rip), %rax     # 0xab8d0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movl $0x1, %edx
leaq 0x66741(%rip), %r8      # 0xabca8
leaq -0x38(%rbp), %r9
movq %rax, (%rsp)
callq 0x44910
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x45597
movq -0x20(%rbp), %rax
cmpl $0x20, (%rax)
je 0x4558c
jmp 0x455ac
movq -0x20(%rbp), %rdi
callq 0x15670
jmp 0x455ac
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x46e90
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x66cfa(%rip), %rax     # 0xac2d9
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x120d0
movq %rax, %rdi
addq $0x5, %rdi
addq $0x1, %rdi
addq $0x1, %rdi
callq 0x121b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x4562e
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x66c33(%rip), %rdx     # 0xac252
movl $0xe20, %ecx            # imm = 0xE20
callq 0x158e0
jmp 0x45710
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x66c9e(%rip), %rsi     # 0xac2df
leaq 0x66c91(%rip), %rcx     # 0xac2d9
movb $0x0, %al
callq 0x12250
leaq 0x6627a(%rip), %rax     # 0xab8d0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x30(%rbp), %rcx
movq -0x20(%rbp), %r9
movl $0x1, %edx
leaq 0x66632(%rip), %r8      # 0xabca8
callq 0x42960
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4569e
movq -0x20(%rbp), %rax
cmpl $0x20, (%rax)
je 0x45693
jmp 0x45707
movq -0x20(%rbp), %rdi
callq 0x15670
jmp 0x456c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x45720
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x456be
jmp 0x45707
jmp 0x456c0
movq -0x10(%rbp), %rdi
callq 0x3f620
andb $0x1, %al
movb %al, -0x39(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb -0x39(%rbp), %r10b
movq -0x20(%rbp), %rax
movl $0x9, %ecx
xorl %r8d, %r8d
leaq 0x665b7(%rip), %r9      # 0xabca8
andb $0x1, %r10b
movzbl %r10b, %r10d
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x24790
movq -0x38(%rbp), %rdi
callq 0x12290
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: prv_builtins_ir_gen_rec_zero
static void prv_builtins_ir_gen_rec_zero(subtilis_parser_t *p,
					 const subtilis_type_t *type,
					 subtilis_ir_section_t *current,
					 subtilis_error_t *err)
{
	subtilis_ir_section_t *old_current;

	old_current = p->current;
	p->current = current;

	subtilis_rec_type_zero_body(p, type, SUBTILIS_IR_REG_TEMP_START, 0,
				    subtilis_type_rec_zero_fill_size(type),
				    err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_ir_section_add_label(p->current, p->current->end_label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_ir_section_add_instr_no_arg(p->current, SUBTILIS_OP_INSTR_RET,
					     err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_array_gen_index_error_code(p, err);

cleanup:
	p->current = old_current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3f380
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %r8
movq -0x20(%rbp), %r9
movl $0x4, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x621c0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x45791
jmp 0x457ea
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x98(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x39960
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x457bc
jmp 0x457ea
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rdx
movl $0x46, %esi
callq 0x385f0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x457dd
jmp 0x457ea
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5ed10
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: prv_builtins_ir_gen_rec_copy
static void prv_builtins_ir_gen_rec_copy(subtilis_parser_t *p,
					 const subtilis_type_t *type,
					 subtilis_ir_section_t *current,
					 bool new_rec, subtilis_error_t *err)
{
	subtilis_ir_section_t *old_current;

	old_current = p->current;
	p->current = current;

	subtilis_type_rec_copy_ref(p, type, SUBTILIS_IR_REG_TEMP_START,
				   0, SUBTILIS_IR_REG_TEMP_START + 1,
				   new_rec, err);

	subtilis_ir_section_add_label(p->current, p->current->end_label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_ir_section_add_instr_no_arg(p->current, SUBTILIS_OP_INSTR_RET,
					     err);

cleanup:
	p->current = old_current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x19(%rbp), %r9b
movq -0x28(%rbp), %rax
movl $0x4, %edx
xorl %ecx, %ecx
movl $0x5, %r8d
andb $0x1, %r9b
movzbl %r9b, %r9d
movq %rax, (%rsp)
callq 0x62380
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x98(%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x39960
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x45a30
jmp 0x45a46
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %rdx
movl $0x46, %esi
callq 0x385f0
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: prv_builtins_ir_deref_array_recs
static void prv_builtins_ir_deref_array_recs(subtilis_parser_t *p,
					     subtilis_ir_section_t *current,
					     const subtilis_type_t *el_type,
					     subtilis_error_t *err)
{
	subtilis_ir_section_t *old_current;
	size_t el_size;
	subtilis_ir_operand_t ci;
	subtilis_ir_operand_t op2;
	size_t base_reg;
	size_t el_size_reg;

	old_current = p->current;
	p->current = current;

	base_reg = SUBTILIS_IR_REG_TEMP_START;
	op2.label = subtilis_type_if_destructor(p, el_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	ci.reg = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_GET_PROC_ADDR, op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	el_size = subtilis_type_rec_size(el_type);

	op2.integer = (int32_t)el_size;
	el_size_reg = subtilis_ir_section_add_instr2(
	    current, SUBTILIS_OP_INSTR_MOVI_I32, op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_builtin_ir_call_deref_array_recs_gen(p, base_reg, el_size_reg,
						      ci.reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_ir_section_add_instr_no_arg(p->current, SUBTILIS_OP_INSTR_RET,
					     err);

cleanup:
	p->current = old_current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq $0x4, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4a570
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x46c5b
jmp 0x46cf7
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rdx
movl $0x9b, %esi
callq 0x38490
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x46c84
jmp 0x46cf7
movq -0x18(%rbp), %rdi
callq 0x3f0d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rdx
movl $0x1b, %esi
callq 0x38490
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x46cbd
jmp 0x46cf7
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x42790
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x46ce1
jmp 0x46cf7
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rdx
movl $0x46, %esi
callq 0x385f0
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: prv_builtins_ir_gen_rec_ref
static void prv_builtins_ir_gen_rec_ref(subtilis_parser_t *p,
					const subtilis_type_t *type,
					subtilis_ir_section_t *current,
					subtilis_error_t *err)
{
	subtilis_ir_section_t *old_current;

	old_current = p->current;
	p->current = current;

	subtilis_rec_type_ref_gen(p, type, SUBTILIS_IR_REG_TEMP_START, 0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_ir_section_add_instr_no_arg(p->current, SUBTILIS_OP_INSTR_RET,
					     err);

cleanup:
	p->current = old_current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %r8
movl $0x4, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x62b00
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x46ee5
jmp 0x46efb
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rdx
movl $0x46, %esi
callq 0x385f0
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq 0x18(%rbp), %rdx
movl 0x10(%rbp), %edx
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x38, %edi
callq 0x121b0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x46f6b
movq 0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x6539f(%rip), %rdx     # 0xac2fe
movl $0x1f, %ecx
callq 0x158e0
jmp 0x46fc7
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movb -0x19(%rbp), %cl
movq -0x40(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x30(%rax)
movl 0x10(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x46fcf
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x46ff5
jmp 0x47018
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3e040
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rdi
callq 0x12290
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq 0x10(%rbp), %rdx
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x170, %edi            # imm = 0x170
callq 0x121b0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x47078
movq 0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x65292(%rip), %rdx     # 0xac2fe
movl $0x45, %ecx
callq 0x158e0
jmp 0x470ec
movq -0x40(%rbp), %rax
movl $0x8, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movb -0x19(%rbp), %cl
movq -0x40(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x8(%rax)
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
movq -0x30(%rbp), %rsi
movq 0x10(%rbp), %rdx
callq 0x3dec0
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x470c7
jmp 0x470ec
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x168(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x47106
movq -0x28(%rbp), %rdi
callq 0x12290
movq -0x40(%rbp), %rdi
callq 0x47110
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x47125
jmp 0x47148
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x3e100
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rdi
callq 0x12290
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3cff0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x471b2
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x3c480
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x471b0
jmp 0x47227
jmp 0x471b2
movq $0x1, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq $0x8, %rdx
movq -0x28(%rbp), %rcx
callq 0x4a2e0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x471e2
jmp 0x47230
movq -0x30(%rbp), %rax
testb $0x1, 0x2a8(%rax)
je 0x47209
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x47ea0
jmp 0x47225
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x47f20
jmp 0x47230
movq -0x20(%rbp), %rdi
callq 0x36ee0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %rdx
callq 0x24480
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x47283
movq $0x0, -0x8(%rbp)
jmp 0x473a3
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x49d10
testb $0x1, %al
jne 0x4729e
movq -0x30(%rbp), %rax
cmpl $0x9, 0x8(%rax)
jne 0x472f7
movq -0x30(%rbp), %rax
testb $0x1, 0x2a8(%rax)
jne 0x472d4
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %r8
callq 0x48080
movq %rax, -0x8(%rbp)
jmp 0x473a3
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl %eax, %esi
movq -0x20(%rbp), %rdx
callq 0x37590
movq %rax, -0x8(%rbp)
jmp 0x473a3
movq -0x30(%rbp), %rax
cmpl $0x7, 0x8(%rax)
je 0x4730b
movq -0x30(%rbp), %rax
cmpl $0x16, 0x8(%rax)
jne 0x47357
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
callq 0x6d920
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4733a
movq $0x0, -0x8(%rbp)
jmp 0x473a3
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rax
movl %eax, %esi
movq -0x20(%rbp), %rdx
callq 0x37590
movq %rax, -0x8(%rbp)
jmp 0x473a3
jmp 0x47359
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x2c, %esi
leaq 0x63ef3(%rip), %rcx     # 0xab276
leaq 0x64f84(%rip), %rax     # 0xac30e
movq %rax, (%rsp)
movl $0x5a, 0x8(%rsp)
callq 0x156d0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/variable.c
// Function: subtilis_var_set_eflag
void subtilis_var_set_eflag(subtilis_parser_t *p, bool value,
			    subtilis_error_t *err)
{
	subtilis_exp_t *ecode;

	ecode = subtilis_exp_new_int32(value ? -1 : 0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_var_assign_hidden(p, subtilis_eflag_hidden_var,
				   &subtilis_type_integer, ecode, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movb -0x9(%rbp), %cl
xorl %edi, %edi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb $0x1, %cl
cmovnel %eax, %edi
movq -0x18(%rbp), %rsi
callq 0x37800
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x473f0
jmp 0x47412
movq -0x8(%rbp), %rdi
leaq 0x8d43d(%rip), %rax     # 0xd4838
movq (%rax), %rsi
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq 0x644c3(%rip), %rdx     # 0xab8d0
callq 0x47150
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8d411(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x47476
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x64edb(%rip), %rdx     # 0xac33d
movl $0xa4, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x47484
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_align
size_t subtilis_type_if_align(const subtilis_type_t *type,
			      subtilis_error_t *err)
{
	subtilis_type_if_size_t fn;

	fn = prv_type_map[type->type]->alignment;
	if (!fn)
		return subtilis_type_if_size(type, err);
	return fn(type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8d3a1(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x474d5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x47420
movq %rax, -0x8(%rbp)
jmp 0x474e3
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8d339(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x47557
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x64dfa(%rip), %rdx     # 0xac33d
movl $0xbe, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x47571
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8d2ad(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x475da
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x64d77(%rip), %rdx     # 0xac33d
movl $0xcd, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x475f0
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8d21d(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x47662
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x64ce7(%rip), %rdx     # 0xac33d
movl $0xdb, %ecx
callq 0x158e0
jmp 0x47688
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movb -0x21(%rbp), %r8b
movq -0x30(%rbp), %r9
andb $0x1, %r8b
movzbl %r8b, %r8d
callq *%rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8d195(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x476ea
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x64c5f(%rip), %rdx     # 0xac33d
movl $0xe9, %ecx
callq 0x158e0
jmp 0x47704
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)