LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_type.c
// Function: prv_compute_element_address
static subtilis_exp_t *prv_compute_element_address(subtilis_parser_t *p,
						   const subtilis_type_t *type,
						   size_t mem_reg, size_t loc,
						   subtilis_exp_t *sizee,
						   subtilis_error_t *err)
{
	subtilis_exp_t *base;

	base =
	    subtilis_type_if_load_from_mem(p, &subtilis_type_integer, mem_reg,
					   loc + SUBTIILIS_ARRAY_DATA_OFF, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	if ((sizee->type.type == SUBTILIS_TYPE_CONST_INTEGER) &&
	    (sizee->exp.ir_op.integer == 0)) {
		subtilis_exp_delete(sizee);
		return base;
	}

	sizee = subtilis_type_if_data_size(p, type, sizee, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	return subtilis_type_if_add(p, base, sizee, err);

cleanup:

	subtilis_exp_delete(base);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
addq $0x4, %rcx
movq -0x38(%rbp), %r8
leaq 0x4c055(%rip), %rsi     # 0xab8d0
callq 0x48080
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5f897
movq $0x0, -0x8(%rbp)
jmp 0x5f910
movq -0x30(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x5f8c0
movq -0x30(%rbp), %rax
cmpl $0x0, 0x148(%rax)
jne 0x5f8c0
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5f910
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x474f0
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5f8e4
jmp 0x5f8ff
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x48e20
movq %rax, -0x8(%rbp)
jmp 0x5f910
movq -0x40(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_type.c
// Function: subtilis_array_write
void subtilis_array_write(subtilis_parser_t *p, const char *var_name,
			  const subtilis_type_t *type,
			  const subtilis_type_t *el_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_exp_t *offset;

	offset = subtilis_array_index_calc(p, var_name, type, mem_reg, loc,
					   indices, index_count, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

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

	subtilis_type_if_assign_to_mem(p, offset->exp.ir_op.reg, 0, e, err);
	e = NULL;

cleanup:

	subtilis_exp_delete(offset);
	subtilis_exp_delete(e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq 0x18(%rbp), %r9
movq 0x20(%rbp), %r10
movq 0x28(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x5edb0
movq %rax, -0x38(%rbp)
movq 0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5f98d
jmp 0x5f9fe
movq 0x10(%rbp), %rax
cmpq $0x0, 0x160(%rax)
je 0x5f9b2
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq 0x10(%rbp), %rdx
movq 0x28(%rbp), %rcx
callq 0x21910
jmp 0x5f9cb
movq -0x8(%rbp), %rdi
movq 0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq 0x28(%rbp), %rcx
callq 0x4a2e0
movq %rax, 0x10(%rbp)
movq 0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5f9d6
jmp 0x5f9fe
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x148(%rax), %rsi
movq 0x10(%rbp), %rcx
movq 0x28(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x47f20
movq $0x0, 0x10(%rbp)
movq -0x38(%rbp), %rdi
callq 0x36ee0
movq 0x10(%rbp), %rdi
callq 0x36ee0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_type.c
// Function: subtilis_array_read
subtilis_exp_t *subtilis_array_read(subtilis_parser_t *p, const char *var_name,
				    const subtilis_type_t *type,
				    const subtilis_type_t *el_type,
				    size_t mem_reg, size_t loc,
				    subtilis_exp_t **indices,
				    size_t index_count, subtilis_error_t *err)
{
	subtilis_exp_t *offset;
	subtilis_exp_t *e;

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

	e = subtilis_type_if_load_from_mem(p, el_type, offset->exp.ir_op.reg, 0,
					   err);
	subtilis_exp_delete(offset);
	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq 0x10(%rbp), %r9
movq 0x18(%rbp), %r10
movq 0x20(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x5edb0
movq %rax, -0x40(%rbp)
movq 0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5fa91
movq $0x0, -0x8(%rbp)
jmp 0x5fac6
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rax
movq 0x148(%rax), %rdx
movq 0x20(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0x48080
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x36ee0
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_type.c
// Function: subtilis_array_add
void subtilis_array_add(subtilis_parser_t *p, const char *var_name,
			const subtilis_type_t *type,
			const subtilis_type_t *el_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_exp_t *offset;
	subtilis_exp_t *cur_val;

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

	cur_val = subtilis_type_if_load_from_mem(p, el_type,
						 offset->exp.ir_op.reg, 0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

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

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

	subtilis_type_if_assign_to_mem(p, offset->exp.ir_op.reg, 0, e, err);

cleanup:
	subtilis_exp_delete(offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq 0x18(%rbp), %r9
movq 0x20(%rbp), %r10
movq 0x28(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x5edb0
movq %rax, -0x38(%rbp)
movq 0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5fb40
jmp 0x5fbe0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rax
movq 0x148(%rax), %rdx
movq 0x28(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0x48080
movq %rax, -0x40(%rbp)
movq 0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5fb6f
jmp 0x5fbd7
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq 0x10(%rbp), %rdx
movq 0x28(%rbp), %rcx
callq 0x48e20
movq %rax, 0x10(%rbp)
movq 0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5fb93
jmp 0x5fbd7
movq -0x8(%rbp), %rdi
movq 0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq 0x28(%rbp), %rcx
callq 0x4a2e0
movq %rax, 0x10(%rbp)
movq 0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5fbb7
jmp 0x5fbd7
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x148(%rax), %rsi
movq 0x10(%rbp), %rcx
movq 0x28(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x47f20
movq -0x38(%rbp), %rdi
callq 0x36ee0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_type.c
// Function: subtilis_array_sub
void subtilis_array_sub(subtilis_parser_t *p, const char *var_name,
			const subtilis_type_t *type,
			const subtilis_type_t *el_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_exp_t *offset;
	subtilis_exp_t *cur_val;

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

	cur_val = subtilis_type_if_load_from_mem(p, el_type,
						 offset->exp.ir_op.reg, 0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

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

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

	subtilis_type_if_assign_to_mem(p, offset->exp.ir_op.reg, 0, e, err);

cleanup:
	subtilis_exp_delete(offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq 0x18(%rbp), %r9
movq 0x20(%rbp), %r10
movq 0x28(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x5edb0
movq %rax, -0x38(%rbp)
movq 0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5fc60
jmp 0x5fd00
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rax
movq 0x148(%rax), %rdx
movq 0x28(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0x48080
movq %rax, -0x40(%rbp)
movq 0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5fc8f
jmp 0x5fcf7
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq 0x10(%rbp), %rdx
movq 0x28(%rbp), %rcx
callq 0x492c0
movq %rax, 0x10(%rbp)
movq 0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5fcb3
jmp 0x5fcf7
movq -0x8(%rbp), %rdi
movq 0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq 0x28(%rbp), %rcx
callq 0x4a2e0
movq %rax, 0x10(%rbp)
movq 0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5fcd7
jmp 0x5fcf7
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x148(%rax), %rsi
movq 0x10(%rbp), %rcx
movq 0x28(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x47f20
movq -0x38(%rbp), %rdi
callq 0x36ee0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_type.c
// Function: prv_check_dimension_num
static void prv_check_dimension_num(subtilis_parser_t *p, subtilis_exp_t *e,
				    int32_t max_dims, subtilis_error_t *err)
{
	subtilis_exp_t *limit = NULL;

	limit = subtilis_exp_new_int32(max_dims, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	prv_check_dynamic_dim(p, e, 1, limit, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x37800
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5ffaa
jmp 0x5ffc4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x1, %edx
callq 0x5eb40
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_type.c
// Function: prv_check_arrays_compat
static void prv_check_arrays_compat(subtilis_parser_t *p,
				    const subtilis_type_t *el_type,
				    subtilis_exp_t *a1, subtilis_exp_t *a2,
				    subtilis_error_t *err)
{
	subtilis_type_t el_type2;

	if (a1->type.type != a2->type.type) {
		/*
		 * Check to see if a2 is an array.  We can append an
		 * array to a vector, but not the other way around.
		 */

		/*
		 * Number of dimensions aren't important here.  We're
		 * just going to copy all the elements from a2.
		 */

		if (!subtilis_type_if_is_array(&a2->type)) {
			subtilis_error_set_array_type_mismatch(
			    err, p->l->stream->name, p->l->line);
			return;
		}

		subtilis_type_if_element_type(p, &a2->type, &el_type2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;

		if (!subtilis_type_eq(el_type, &el_type2))
			subtilis_error_set_array_type_mismatch(
			    err, p->l->stream->name, p->l->line);

		subtilis_type_free(&el_type2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x61773
movq -0x20(%rbp), %rdi
callq 0x49ff0
testb $0x1, %al
jne 0x61700
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x41, %esi
leaq 0x4b28a(%rip), %r8      # 0xac97d
movl $0xb3c, %r9d            # imm = 0xB3C
callq 0x15930
jmp 0x61773
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x170(%rbp), %rdx
callq 0x47b70
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x61723
jmp 0x61773
movq -0x10(%rbp), %rdi
leaq -0x170(%rbp), %rsi
callq 0x3d880
testb $0x1, %al
jne 0x61767
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x41, %esi
leaq 0x4b221(%rip), %r8      # 0xac97d
movl $0xb46, %r9d            # imm = 0xB46
callq 0x15930
leaq -0x170(%rbp), %rdi
callq 0x3e100
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_type.c
// Function: prv_div_by_const
static size_t prv_div_by_const(subtilis_parser_t *p, size_t reg,
			       int32_t divisor, subtilis_error_t *err)
{
	subtilis_exp_t *a1;
	subtilis_exp_t *a2 = NULL;

	a1 = subtilis_exp_new_int32_var(reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return SIZE_MAX;

	a2 = subtilis_exp_new_int32(divisor, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(a1);
		return SIZE_MAX;
	}

	a1 = subtilis_type_if_div(p, a1, a2, err);
	reg = a1->exp.ir_op.reg;
	subtilis_exp_delete(a1);

	return reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %edi
movq -0x28(%rbp), %rsi
callq 0x37770
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x617c5
movq $-0x1, -0x8(%rbp)
jmp 0x6182a
movl -0x1c(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0x37800
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x617f1
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq $-0x1, -0x8(%rbp)
jmp 0x6182a
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x49330
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x148(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq -0x18(%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/array_type.c
// Function: subtilis_array_type_dup
void subtilis_array_type_dup(subtilis_exp_t *src, subtilis_exp_t *dst,
			     subtilis_error_t *err)
{
	subtilis_type_copy(&dst->type, &src->type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (src->temporary) {
		dst->temporary = malloc(strlen(src->temporary) + 1);
		if (!dst->temporary) {
			subtilis_error_set_oom(err);
			return;
		}
		strcpy(dst->temporary, src->temporary);
	} else {
		dst->temporary = NULL;
	}
	dst->exp.ir_op.reg = src->exp.ir_op.reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3e4f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x61c73
jmp 0x61d17
movq -0x8(%rbp), %rax
cmpq $0x0, 0x158(%rax)
je 0x61cf2
movq -0x8(%rbp), %rax
movq 0x158(%rax), %rdi
callq 0x120d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x121b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x158(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x158(%rax)
jne 0x61cd5
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x4acb4(%rip), %rdx     # 0xac97d
movl $0xc3c, %ecx            # imm = 0xC3C
callq 0x158e0
jmp 0x61d17
movq -0x10(%rbp), %rax
movq 0x158(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x158(%rax), %rsi
callq 0x12060
jmp 0x61d01
movq -0x10(%rbp), %rax
movq $0x0, 0x158(%rax)
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x148(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/sizet_vector.c
// Function: subtilis_sizet_vector_append
void subtilis_sizet_vector_append(subtilis_sizet_vector_t *v, size_t val,
				  subtilis_error_t *err)
{
	size_t new_max;
	size_t *new_vals;

	if (v->len == v->max_len) {
		new_max = v->len + SUBTILIS_CONFIG_SIZET_SIZE;
		new_vals = realloc(v->vals, new_max * sizeof(size_t));
		if (!new_vals) {
			subtilis_error_set_oom(err);
			return;
		}
		v->max_len = new_max;
		v->vals = new_vals;
	}
	v->vals[v->len++] = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x61dd8
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x40, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
shlq $0x3, %rsi
callq 0x121e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x61dc0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x4ac18(%rip), %rdx     # 0xac9cc
movl $0x27, %ecx
callq 0x158e0
jmp 0x61df9
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movq (%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, (%rsi)
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type.c
// Function: subtilis_rec_type_init_array
void subtilis_rec_type_init_array(subtilis_parser_t *p,
				  const subtilis_type_t *type,
				  const char *var_name, size_t mem_reg,
				  size_t loc, subtilis_error_t *err)
{
	size_t i;
	subtilis_ir_operand_t op;
	subtilis_exp_t *e[SUBTILIS_MAX_DIMENSIONS] = {NULL};
	const subtilis_type_array_t *arr = &type->params.array;

	for (i = 0; i < arr->num_dims; i++) {
		e[i] = subtilis_exp_new_int32(arr->dims[i], err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	op.reg = mem_reg;
	subtilis_array_type_allocate(p, var_name, type, loc, e, op, false, err);

cleanup:
	for (i = 0; i < arr->num_dims; i++)
		subtilis_exp_delete(e[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x12110
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x98(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x98(%rbp), %rcx
movslq (%rcx), %rcx
cmpq %rcx, %rax
jae 0x61ed2
movq -0x98(%rbp), %rax
movq -0x38(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %edi
movq -0x30(%rbp), %rsi
callq 0x37800
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x90(%rbp,%rax,8)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x61ec2
jmp 0x61f0d
jmp 0x61ec4
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x61e7d
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x90(%rbp), %r8
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %r9
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x5be00
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x98(%rbp), %rcx
movslq (%rcx), %rcx
cmpq %rcx, %rax
jae 0x61f47
movq -0x38(%rbp), %rax
movq -0x90(%rbp,%rax,8), %rdi
callq 0x36ee0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x61f15
addq $0xb0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type.c
// Function: subtilis_rec_type_init_vector
void subtilis_rec_type_init_vector(subtilis_parser_t *p,
				   const subtilis_type_t *type, size_t mem_reg,
				   size_t loc, int32_t vec_dim,
				   subtilis_error_t *err)
{
	subtilis_ir_operand_t op;
	subtilis_exp_t *e = NULL;

	e = subtilis_exp_new_int32(vec_dim, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	op.reg = mem_reg;
	subtilis_array_type_vector_alloc(p, loc, type, e, op, false, err);
	subtilis_exp_delete(e);
}

// 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)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movl -0x24(%rbp), %edi
movq -0x30(%rbp), %rsi
callq 0x37800
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x61f93
jmp 0x61fc8
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %r8
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0x5c4a0
movq -0x40(%rbp), %rdi
callq 0x36ee0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type.c
// Function: subtilis_rec_type_init_field
void subtilis_rec_type_init_field(subtilis_parser_t *p,
				  const subtilis_type_t *type,
				  subtilis_type_field_t *field, size_t mem_reg,
				  size_t loc, bool memset,
				  subtilis_error_t *err)
{
	subtilis_exp_t *e;

	if (subtilis_type_if_is_array(type)) {
		subtilis_rec_type_init_array(p, type, field->name, mem_reg, loc,
					     err);
	} else if (subtilis_type_if_is_vector(type) && (field->vec_dim >= 0)) {
		subtilis_rec_type_init_vector(p, type, mem_reg, loc,
					      field->vec_dim, err);
	} else if (subtilis_type_if_is_reference(type)) {
		subtilis_type_if_zero_ref(p, type, mem_reg, loc, false, err);
	} else if (type->type == SUBTILIS_TYPE_REC) {
		prv_rec_type_zero(p, type, mem_reg, loc, memset, err);
	} else if (subtilis_type_if_is_numeric(type) ||
		   (type->type == SUBTILIS_TYPE_FN)) {
		e = subtilis_type_if_zero(p, type, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		subtilis_type_if_assign_to_mem(p, mem_reg, loc, e, err);
	} else {
		subtilis_error_set_assertion_failed(err);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movq 0x10(%rbp), %r9
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49ff0
testb $0x1, %al
jne 0x62007
jmp 0x6202c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq 0x10(%rbp), %r9
callq 0x61e30
jmp 0x6213b
movq -0x10(%rbp), %rdi
callq 0x4a040
testb $0x1, %al
jne 0x6203b
jmp 0x6206b
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jl 0x6206b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x10(%rax), %r8d
movq 0x10(%rbp), %r9
callq 0x61f50
jmp 0x62139
movq -0x10(%rbp), %rdi
callq 0x4a090
testb $0x1, %al
jne 0x6207a
jmp 0x6209b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq 0x10(%rbp), %r9
xorl %r8d, %r8d
callq 0x47600
jmp 0x62137
movq -0x10(%rbp), %rax
cmpl $0x16, (%rax)
jne 0x620c8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movb -0x29(%rbp), %al
movq 0x10(%rbp), %r9
andb $0x1, %al
movzbl %al, %r8d
callq 0x62150
jmp 0x62135
movq -0x10(%rbp), %rdi
callq 0x49d10
testb $0x1, %al
jne 0x620de
movq -0x10(%rbp), %rax
cmpl $0x9, (%rax)
jne 0x62119
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x10(%rbp), %rdx
callq 0x47580
movq %rax, -0x38(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x620fe
jmp 0x6213b
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x47f20
jmp 0x62133
movq 0x10(%rbp), %rdi
movl $0xf, %esi
leaq 0x4a8b9(%rip), %rdx     # 0xac9e2
movl $0x6c, %ecx
callq 0x158e0
jmp 0x62135
jmp 0x62137
jmp 0x62139
jmp 0x6213b
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type.c
// Function: subtilis_rec_type_zero_body
void subtilis_rec_type_zero_body(subtilis_parser_t *p,
				 const subtilis_type_t *type, size_t mem_reg,
				 size_t loc, size_t zero_fill_size,
				 subtilis_error_t *err)
{
	bool memset = false;

	/*
	 * If the record and any nested records contain more than 16 bytes
	 * of data that can be zero initialised, we'll just memset the whole
	 * thing.
	 */

	if (zero_fill_size > 16) {
		prv_rec_memset_zero(p, type, mem_reg, loc, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		memset = true;
	}

	prv_rec_type_zero(p, type, mem_reg, loc, memset, 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 %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
cmpq $0x10, -0x28(%rbp)
jbe 0x62213
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x62240
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x6220f
jmp 0x62235
movb $0x1, -0x31(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movb -0x31(%rbp), %al
movq -0x30(%rbp), %r9
andb $0x1, %al
movzbl %al, %r8d
callq 0x62150
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type.c
// Function: subtilis_rec_type_zero
void subtilis_rec_type_zero(subtilis_parser_t *p, const subtilis_type_t *type,
			    size_t mem_reg, size_t loc, bool push,
			    subtilis_error_t *err)
{
	size_t zfs = subtilis_type_rec_zero_fill_size(type);

	if (subtilis_type_rec_size(type) - zfs < 16) {
		subtilis_rec_type_zero_body(p, type, mem_reg, loc, zfs, err);
	} else {
		mem_reg = subtilis_reference_get_pointer(p, mem_reg, loc, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		loc = 0;
		subtilis_builtin_ir_rec_zero(p, type, mem_reg, err);
	}
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (push && subtilis_type_rec_need_deref(type))
		subtilis_reference_type_push_reference(p, type, mem_reg, loc,
						       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), %rdi
callq 0x3f380
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3f0d0
subq -0x38(%rbp), %rax
cmpq $0x10, %rax
jae 0x622f3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x621c0
jmp 0x62334
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x6d920
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x62317
jmp 0x6236d
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x455c0
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x6233f
jmp 0x6236d
testb $0x1, -0x21(%rbp)
je 0x6236d
movq -0x10(%rbp), %rdi
callq 0x3f560
testb $0x1, %al
jne 0x62354
jmp 0x6236d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x6d540
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type.c
// Function: subtilis_rec_type_copy
void subtilis_rec_type_copy(subtilis_parser_t *p, const subtilis_type_t *type,
			    size_t dest_reg, size_t loc, size_t src_reg,
			    bool new_rec, subtilis_error_t *err)
{
	size_t zfs;
	subtilis_ir_operand_t op1;
	subtilis_ir_operand_t op2;

	zfs = subtilis_type_rec_zero_fill_size(type);
	if (subtilis_type_rec_is_scalar(type) && (zfs > 16)) {
		prv_memcpy_struct(p, type, dest_reg, loc, src_reg, err);
		return;
	}

	if (subtilis_type_rec_size(type) - zfs < 16) {
		subtilis_type_rec_copy_ref(p, type, dest_reg, loc, src_reg,
					   new_rec, err);
	} else {
		op1.reg = dest_reg;
		op2.integer = loc;
		dest_reg = subtilis_ir_section_add_instr(
		    p->current, SUBTILIS_OP_INSTR_ADDI_I32, op1, op2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		subtilis_builtin_ir_rec_copy(p, type, dest_reg, src_reg,
					     new_rec, err);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r9b, %al
movq 0x10(%rbp), %r9
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3f380
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3f160
testb $0x1, %al
jne 0x626c4
jmp 0x626ed
cmpq $0x10, -0x38(%rbp)
jbe 0x626ed
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq 0x10(%rbp), %r9
callq 0x62830
jmp 0x6278d
movq -0x10(%rbp), %rdi
callq 0x3f0d0
subq -0x38(%rbp), %rax
cmpq $0x10, %rax
jae 0x6272f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movb -0x29(%rbp), %r9b
movq 0x10(%rbp), %rax
andb $0x1, %r9b
movzbl %r9b, %r9d
movq %rax, (%rsp)
callq 0x62380
jmp 0x6278d
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl %eax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq 0x10(%rbp), %r8
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
movl $0x9, %esi
callq 0x38230
movq %rax, -0x18(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x6276b
jmp 0x6278d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movb -0x29(%rbp), %al
movq 0x10(%rbp), %r9
andb $0x1, %al
movzbl %al, %r8d
callq 0x45800
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type.c
// Function: subtilis_rec_type_tmp_copy
void subtilis_rec_type_tmp_copy(subtilis_parser_t *p,
				const subtilis_type_t *type, size_t dest_reg,
				size_t loc, size_t src_reg,
				subtilis_error_t *err)
{
	if (subtilis_type_rec_is_scalar(type) &&
	    subtilis_type_rec_zero_fill_size(type) <= 16)
		subtilis_type_rec_copy_ref(p, type, dest_reg, loc, src_reg,
					   true, err);
	else
		prv_memcpy_struct(p, type, dest_reg, loc, src_reg, 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 %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3f160
testb $0x1, %al
jne 0x627cf
jmp 0x62807
movq -0x10(%rbp), %rdi
callq 0x3f380
cmpq $0x10, %rax
ja 0x62807
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %rax
movl $0x1, %r9d
movq %rax, (%rsp)
callq 0x62380
jmp 0x62824
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x62830
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type.c
// Function: prv_memcpy_struct
static void prv_memcpy_struct(subtilis_parser_t *p, const subtilis_type_t *type,
			      size_t dest_reg, size_t loc, size_t src_reg,
			      subtilis_error_t *err)
{
	subtilis_ir_operand_t op;
	size_t size_reg;

	dest_reg = subtilis_reference_get_pointer(p, dest_reg, loc, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	op.integer = subtilis_type_rec_size(type);
	size_reg = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_MOVI_I32, op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_reference_type_memcpy_dest(p, dest_reg, src_reg, size_reg,
					    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 %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x6d920
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x62874
jmp 0x628c2
movq -0x10(%rbp), %rdi
callq 0x3f0d0
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rdx
movl $0x1b, %esi
callq 0x38490
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x628a9
jmp 0x628c2
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x6dad0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type.c
// Function: prv_make_ref_fn_name
static char *prv_make_ref_fn_name(const subtilis_type_t *type, const char *base,
				  subtilis_error_t *err)
{
	char *fn_name;
	int name_len;
	const subtilis_type_rec_t *rec = &type->params.rec;

	name_len = strlen(rec->name);
	fn_name = malloc(name_len + 1 + 1 + strlen(base));
	if (!fn_name) {
		subtilis_error_set_oom(err);
		return NULL;
	}
	fn_name[0] = '_';
	strcpy(&fn_name[1], rec->name);
	strcpy(&fn_name[name_len + 1], base);

	return fn_name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x120d0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
addl $0x1, %eax
cltq
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x120d0
movq -0x40(%rbp), %rdi
addq %rax, %rdi
callq 0x121b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x62983
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x4a073(%rip), %rdx     # 0xac9e2
movl $0x171, %ecx            # imm = 0x171
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x629bf
movq -0x28(%rbp), %rax
movb $0x5f, (%rax)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x12060
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %eax
addl $0x1, %eax
cltq
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x12060
movq -0x28(%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/rec_type.c
// Function: subtilis_rec_type_deref
void subtilis_rec_type_deref(subtilis_parser_t *p, const subtilis_type_t *type,
			     size_t mem_reg, size_t loc, subtilis_error_t *err)
{
	size_t base_reg;

	if (!subtilis_type_rec_need_deref(type))
		return;

	base_reg = subtilis_reference_get_pointer(p, mem_reg, loc, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_builtin_call_ir_rec_deref(p, type, base_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), %rdi
callq 0x3f560
testb $0x1, %al
jne 0x62a2b
jmp 0x62a64
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6d920
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x62a4f
jmp 0x62a64
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x453e0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type.c
// Function: subtilis_rec_type_ref
void subtilis_rec_type_ref(subtilis_parser_t *p, const subtilis_type_t *type,
			   size_t mem_reg, size_t loc, subtilis_error_t *err)
{
	if (subtilis_type_rec_need_ref_fn(type)) {
		mem_reg = subtilis_reference_get_pointer(p, mem_reg, loc, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;

		subtilis_builtin_call_ir_rec_ref(p, type, mem_reg, err);
		return;
	}
	subtilis_rec_type_ref_gen(p, type, mem_reg, loc, 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), %rdi
callq 0x3f450
testb $0x1, %al
jne 0x62a9b
jmp 0x62ad6
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6d920
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x62abf
jmp 0x62aef
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x45480
jmp 0x62aef
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x62b00
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type.c
// Function: subtilis_rec_type_ref_gen
void subtilis_rec_type_ref_gen(subtilis_parser_t *p,
			       const subtilis_type_t *type, size_t mem_reg,
			       size_t loc, subtilis_error_t *err)
{
	bool check_size;
	size_t i;
	size_t offset;
	subtilis_type_t *field;
	const subtilis_type_rec_t *rec = &type->params.rec;

	for (i = 0; i < rec->num_fields; i++) {
		field = &rec->field_types[i];

		if (!subtilis_type_if_is_reference(field) &&
		    (field->type != SUBTILIS_TYPE_REC))
			continue;

		offset = loc + subtilis_type_rec_field_offset_id(rec, i);
		if (subtilis_type_if_is_reference(field)) {
			check_size = !subtilis_type_if_is_array(field);
			subtilis_reference_type_ref(p, mem_reg, offset,
						    check_size, err);
		} else {
			subtilis_rec_type_ref(p, field, mem_reg, offset, err);
		}
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x50(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x62c0d
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x148, -0x38(%rbp), %rcx # imm = 0x148
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x4a090
testb $0x1, %al
jne 0x62b74
movq -0x48(%rbp), %rax
cmpl $0x16, (%rax)
je 0x62b74
jmp 0x62bfc
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x3efb0
movl %eax, %ecx
movq -0x58(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
callq 0x4a090
testb $0x1, %al
jne 0x62ba7
jmp 0x62bd6
movq -0x48(%rbp), %rdi
callq 0x49ff0
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
movb -0x29(%rbp), %al
movq -0x28(%rbp), %r8
andb $0x1, %al
movzbl %al, %ecx
callq 0x6d350
jmp 0x62bef
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x62a70
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x62bfa
jmp 0x62c0d
jmp 0x62bfc
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x62b30
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type.c
// Function: subtilis_rec_type_copy_ret
void subtilis_rec_type_copy_ret(subtilis_parser_t *p, const subtilis_type_t *t,
				size_t dest_reg, size_t source_reg,
				subtilis_error_t *err)
{
	subtilis_rec_type_tmp_copy(p, t, dest_reg, 0, source_reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (!subtilis_type_rec_need_deref(t))
		return;

	/*
	 * It's important that this comes last as the reference we're
	 * copying might be left on the stack of a previous function.
	 * We don't want to overwrite the data before we've copied it.
	 */

	subtilis_reference_push_ref(p, t, dest_reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_reference_inc_cleanup_stack(p, t, 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 -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
xorl %eax, %eax
movl %eax, %ecx
callq 0x627a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x62c64
jmp 0x62ca4
movq -0x10(%rbp), %rdi
callq 0x3f560
testb $0x1, %al
jne 0x62c73
jmp 0x62ca4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6ce80
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x62c93
jmp 0x62ca4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x6d280
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type.c
// Function: subtilis_rec_type_assign_to_reg
void subtilis_rec_type_assign_to_reg(subtilis_parser_t *p, size_t reg,
				     subtilis_exp_t *e, subtilis_error_t *err)
{
	subtilis_ir_operand_t op0;
	bool ref_needed = subtilis_type_rec_need_deref(&e->type);

	op0.reg = reg;
	subtilis_ir_section_add_instr_no_reg2(p->current, SUBTILIS_OP_INSTR_MOV,
					      op0, e->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	if (ref_needed)
		subtilis_rec_type_ref(p, &e->type, reg, 0, err);

cleanup:
	subtilis_exp_delete(e);
}

// 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 -0x18(%rbp), %rdi
callq 0x3f560
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %rdx
movq 0x148(%rax), %rcx
movl $0x1d, %esi
callq 0x385a0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x62d0e
jmp 0x62d2f
testb $0x1, -0x29(%rbp)
je 0x62d2d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0x62a70
jmp 0x62d2f
movq -0x18(%rbp), %rdi
callq 0x36ee0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type.c
// Function: subtilis_rec_type_swap
void subtilis_rec_type_swap(subtilis_parser_t *p, const subtilis_type_t *type,
			    size_t reg1, size_t reg2, subtilis_error_t *err)
{
	subtilis_ir_operand_t ptr1;
	subtilis_ir_operand_t ptr2;
	size_t offset;
	size_t i;
	size_t size = subtilis_type_rec_size(type);

	offset = size - (size & 3);
	if (size >= 4) {
		ptr1.reg = reg1;
		ptr2.reg = reg2;
		reg1 = subtilis_ir_section_add_instr2(
		    p->current, SUBTILIS_OP_INSTR_MOV, ptr1, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		reg2 = subtilis_ir_section_add_instr2(
		    p->current, SUBTILIS_OP_INSTR_MOV, ptr2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;

		prv_rec_swap_32(p, offset, reg1, reg2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

	i = 0;
	for (; offset < size; offset++, i++) {
		subtilis_exp_swap_int8_mem(p, reg1, reg2, i, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3f0d0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq -0x50(%rbp), %rcx
andq $0x3, %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
cmpq $0x4, -0x50(%rbp)
jb 0x62e12
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
movl $0x1d, %esi
callq 0x38490
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x62dc3
jmp 0x62e66
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rdx
movl $0x1d, %esi
callq 0x38490
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x62dec
jmp 0x62e66
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x62e70
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x62e10
jmp 0x62e66
jmp 0x62e12
movq $0x0, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x50(%rbp), %rax
jae 0x62e66
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %r8
callq 0x26030
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x62e4a
jmp 0x62e66
jmp 0x62e4c
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x62e1a
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type.c
// Function: prv_uninit_fields
static void prv_uninit_fields(subtilis_parser_t *p, const subtilis_type_t *type,
			      size_t mem_reg, size_t loc, subtilis_error_t *err)
{
	size_t i;
	const subtilis_type_rec_t *rec;
	const subtilis_type_t *field;
	uint32_t offset;

	/*
	 * We only need to initialise fields that cannot be zero initialised.
	 */

	rec = &type->params.rec;
	for (i = 0; i < rec->num_fields; i++) {
		field = &rec->field_types[i];
		if (subtilis_type_if_is_numeric(field) ||
		    field->type == SUBTILIS_TYPE_STRING)
			continue;
		offset = subtilis_type_rec_field_offset_id(rec, i);
		subtilis_rec_type_init_field(p, field, &rec->fields[i], mem_reg,
					     offset + loc, true, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x63158
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x148, -0x30(%rbp), %rcx # imm = 0x148
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x49d10
testb $0x1, %al
jne 0x630ef
movq -0x40(%rbp), %rax
cmpl $0x7, (%rax)
jne 0x630f1
jmp 0x63147
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3efb0
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdx
imulq $0x18, -0x30(%rbp), %rax
addq %rax, %rdx
movq -0x18(%rbp), %rcx
movl -0x44(%rbp), %eax
movl %eax, %r8d
addq -0x20(%rbp), %r8
movq -0x28(%rbp), %rax
movl $0x1, %r9d
movq %rax, (%rsp)
callq 0x61fd0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x63145
jmp 0x63158
jmp 0x63147
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x630b0
addq $0x50, %rsp
popq %rbp
retq
nop