LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/byte_type_if.c
// Function: prv_commutative
static subtilis_exp_t *prv_commutative(subtilis_parser_t *p, subtilis_exp_t *a1,
				       subtilis_exp_t *a2,
				       subtilis_op_instr_type_t in_var_var,
				       subtilis_type_if_binary_t binary_fn,
				       subtilis_error_t *err)
{
	size_t reg;

	if (a2->type.type == SUBTILIS_TYPE_BYTE) {
		reg = subtilis_ir_section_add_instr(
		    p->current, in_var_var, a1->exp.ir_op, a2->exp.ir_op, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
		a1->exp.ir_op.reg = reg;
		subtilis_exp_delete(a2);
		return a1;
	}

	a1 = prv_to_int32(p, a1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	return binary_fn(p, a1, a2, err);

on_error:
	subtilis_exp_delete(a1);
	subtilis_exp_delete(a2);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x53663
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x24(%rbp), %esi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %r8
movq 0x148(%rcx), %rdx
movq 0x148(%rax), %rcx
callq 0x38230
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x53641
jmp 0x5369f
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x536b9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x523e0
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x53683
jmp 0x5369f
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x536b9
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -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/byte_type_if.c
// Function: prv_compare
static subtilis_exp_t *prv_compare(subtilis_parser_t *p, subtilis_exp_t *a1,
				   subtilis_exp_t *a2,
				   subtilis_op_instr_type_t in_var_var,
				   subtilis_type_if_binary_t binary_fn,
				   subtilis_error_t *err)
{
	size_t reg;

	/*
	 * Just used for eq and neq.   Here we can zero extend instead of sign
	 * extending which may be cheaper.
	 */

	if (a2->type.type == SUBTILIS_TYPE_BYTE) {
		a1 = prv_zerox(p, a1, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;

		a2 = prv_zerox(p, a2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;

		reg = subtilis_ir_section_add_instr(
		    p->current, in_var_var, a1->exp.ir_op, a2->exp.ir_op, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
		a1->exp.ir_op.reg = reg;
		subtilis_exp_delete(a2);
		return a1;
	}

	a1 = prv_to_int32(p, a1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	return binary_fn(p, a1, a2, err);

on_error:
	subtilis_exp_delete(a1);
	subtilis_exp_delete(a2);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x5379d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x53450
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5371f
jmp 0x537d9
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x53450
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x53742
jmp 0x537d9
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x24(%rbp), %esi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %r8
movq 0x148(%rcx), %rdx
movq 0x148(%rax), %rcx
callq 0x38230
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5377b
jmp 0x537d9
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x537f3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x523e0
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x537bd
jmp 0x537d9
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x537f3
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rdi
callq 0x36ee0
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/byte_type_if.c
// Function: prv_compare_nc
static subtilis_exp_t *prv_compare_nc(subtilis_parser_t *p, subtilis_exp_t *a1,
				      subtilis_exp_t *a2,
				      subtilis_type_if_binary_nc_t binary_nc_fn,
				      bool swapped, subtilis_error_t *err)
{
	/*
	 * Here we have to sign extend otherwise comparsions will not work
	 * properly on negative values.
	 */

	a1 = prv_to_int32(p, a1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	return binary_nc_fn(p, a1, a2, swapped, err);

on_error:

	subtilis_exp_delete(a2);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x523e0
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x53844
jmp 0x53869
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb -0x29(%rbp), %cl
movq -0x38(%rbp), %r8
andb $0x1, %cl
movzbl %cl, %ecx
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x5387a
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_int32_type.c
// Function: prv_data_size
static subtilis_exp_t *prv_data_size(subtilis_parser_t *p,
				     const subtilis_type_t *type,
				     subtilis_exp_t *e, subtilis_error_t *err)
{
	subtilis_exp_t *two;

	two = subtilis_exp_new_int32(2, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(e);
		return NULL;
	}

	return subtilis_type_if_lsl(p, e, two, 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 -0x28(%rbp), %rsi
movl $0x2, %edi
callq 0x37800
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x53906
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x5391f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x498c0
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/array_int32_type.c
// Function: prv_append
static void prv_append(subtilis_parser_t *p, subtilis_exp_t *a1,
		       subtilis_exp_t *a2, subtilis_exp_t *gran,
		       subtilis_error_t *err)
{
	if ((a2->type.type == SUBTILIS_TYPE_ARRAY_INTEGER) ||
	    (a2->type.type == SUBTILIS_TYPE_VECTOR_INTEGER)) {
		if (gran) {
			subtilis_error_set_too_many_args(
			    err, 3, 2, p->l->stream->name, p->l->line);
			goto cleanup;
		}
		subtilis_array_append_scalar_array(p, a1, a2, err);
		return;
	} else if (subtilis_type_if_is_numeric(&a2->type)) {
		a2 = subtilis_type_if_to_int(p, a2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		subtilis_array_append_scalar(p, a1, a2, gran, err);
		return;
	}
	subtilis_error_set_expected(err, "integer or array of integers",
				    subtilis_type_name(&a2->type),
				    p->l->stream->name, p->l->line);

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

// 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 -0x18(%rbp), %rax
cmpl $0xb, (%rax)
je 0x5469e
movq -0x18(%rbp), %rax
cmpl $0x11, (%rax)
jne 0x54705
cmpq $0x0, -0x20(%rbp)
je 0x546eb
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
leaq 0x57e1e(%rip), %rax     # 0xac4f3
movq %rax, (%rsp)
movl $0xb7, 0x8(%rsp)
callq 0x157b0
jmp 0x547a3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x61270
jmp 0x547be
movq -0x18(%rbp), %rdi
callq 0x49d10
testb $0x1, %al
jne 0x54714
jmp 0x5474f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x54734
jmp 0x547a3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x60890
jmp 0x547be
jmp 0x54751
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e190
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x57e44(%rip), %rdx     # 0xac5cf
leaq 0x57d61(%rip), %rax     # 0xac4f3
movq %rax, (%rsp)
movl $0xc5, 0x8(%rsp)
callq 0x156d0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x10(%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/array_byte_type.c
// Function: prv_append
static void prv_append(subtilis_parser_t *p, subtilis_exp_t *a1,
		       subtilis_exp_t *a2, subtilis_exp_t *gran,
		       subtilis_error_t *err)
{
	if ((a2->type.type == SUBTILIS_TYPE_ARRAY_BYTE) ||
	    (a2->type.type == SUBTILIS_TYPE_VECTOR_BYTE)) {
		if (gran) {
			subtilis_error_set_too_many_args(
			    err, 3, 2, p->l->stream->name, p->l->line);
			goto cleanup;
		}
		subtilis_array_append_scalar_array(p, a1, a2, err);
		return;
	} else if (subtilis_type_if_is_numeric(&a2->type)) {
		a2 = subtilis_type_if_exp_to_var(p, a2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		a2 = subtilis_type_if_to_byte(p, a2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		subtilis_array_append_scalar(p, a1, a2, gran, err);
		return;
	}
	subtilis_error_set_expected(err, "byte or array of bytes",
				    subtilis_type_name(&a2->type),
				    p->l->stream->name, p->l->line);

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

// 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 -0x18(%rbp), %rax
cmpl $0xc, (%rax)
je 0x5577e
movq -0x18(%rbp), %rax
cmpl $0x12, (%rax)
jne 0x557e5
cmpq $0x0, -0x20(%rbp)
je 0x557cb
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
leaq 0x56e37(%rip), %rax     # 0xac5ec
movq %rax, (%rsp)
movl $0xa6, 0x8(%rsp)
callq 0x157b0
jmp 0x558a6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x61270
jmp 0x558c1
movq -0x18(%rbp), %rdi
callq 0x49d10
testb $0x1, %al
jne 0x557f4
jmp 0x55852
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x47c10
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x55817
jmp 0x558a6
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x48980
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x55837
jmp 0x558a6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x60890
jmp 0x558c1
jmp 0x55854
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e190
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x56d79(%rip), %rdx     # 0xac607
leaq 0x56d57(%rip), %rax     # 0xac5ec
movq %rax, (%rsp)
movl $0xb7, 0x8(%rsp)
callq 0x156d0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x10(%rbp), %rdi
callq 0x36ee0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_float64_type.c
// Function: prv_data_size
static subtilis_exp_t *prv_data_size(subtilis_parser_t *p,
				     const subtilis_type_t *type,
				     subtilis_exp_t *e, subtilis_error_t *err)
{
	subtilis_exp_t *three;

	three = subtilis_exp_new_int32(3, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(e);
		return NULL;
	}

	return subtilis_type_if_lsl(p, e, three, 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 -0x28(%rbp), %rsi
movl $0x3, %edi
callq 0x37800
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x55b36
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x55b4f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x498c0
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/array_float64_type.c
// Function: prv_append
static void prv_append(subtilis_parser_t *p, subtilis_exp_t *a1,
		       subtilis_exp_t *a2, subtilis_exp_t *gran,
		       subtilis_error_t *err)
{
	if ((a2->type.type == SUBTILIS_TYPE_ARRAY_REAL) ||
	    (a2->type.type == SUBTILIS_TYPE_VECTOR_REAL)) {
		if (gran) {
			subtilis_error_set_too_many_args(
			    err, 3, 2, p->l->stream->name, p->l->line);
			goto cleanup;
		}
		subtilis_array_append_scalar_array(p, a1, a2, err);
		return;
	} else if (subtilis_type_if_is_numeric(&a2->type)) {
		a2 = subtilis_type_if_to_float64(p, a2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		subtilis_array_append_scalar(p, a1, a2, gran, err);
		return;
	}
	subtilis_error_set_expected(err, "real or array of reals",
				    subtilis_type_name(&a2->type),
				    p->l->stream->name, p->l->line);

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

// 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 -0x18(%rbp), %rax
cmpl $0xa, (%rax)
je 0x568ce
movq -0x18(%rbp), %rax
cmpl $0x10, (%rax)
jne 0x56935
cmpq $0x0, -0x20(%rbp)
je 0x5691b
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
leaq 0x55d19(%rip), %rax     # 0xac61e
movq %rax, (%rsp)
movl $0xb7, 0x8(%rsp)
callq 0x157b0
jmp 0x569d3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x61270
jmp 0x569ee
movq -0x18(%rbp), %rdi
callq 0x49d10
testb $0x1, %al
jne 0x56944
jmp 0x5697f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x48ae0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x56964
jmp 0x569d3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x60890
jmp 0x569ee
jmp 0x56981
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e190
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x55c81(%rip), %rdx     # 0xac63c
leaq 0x55c5c(%rip), %rax     # 0xac61e
movq %rax, (%rsp)
movl $0xc5, 0x8(%rsp)
callq 0x156d0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x10(%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/array_string_type.c
// Function: prv_data_size
static subtilis_exp_t *prv_data_size(subtilis_parser_t *p,
				     const subtilis_type_t *type,
				     subtilis_exp_t *e, subtilis_error_t *err)
{
	subtilis_exp_t *sizee;
	size_t string_size = subtilis_string_type_size(&subtilis_type_string);

	sizee = subtilis_exp_new_int32(string_size, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(e);
		return NULL;
	}

	return subtilis_type_if_mul(p, e, sizee, err);
}

// 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)
leaq 0x54ea1(%rip), %rdi     # 0xabb60
callq 0x65ec0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl %eax, %edi
movq -0x28(%rbp), %rsi
callq 0x37800
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x56cf7
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x56d10
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x48fb0
movq %rax, -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_string_type.c
// Function: prv_assign_array_ref_exp
static void prv_assign_array_ref_exp(subtilis_parser_t *p,
				     const subtilis_type_t *type,
				     size_t mem_reg, size_t loc,
				     subtilis_exp_t *e, subtilis_error_t *err)
{
	subtilis_type_compare_diag(p, type, &e->type, err);
	if (err->type == SUBTILIS_ERROR_OK)
		prv_assign_ref(p, type, mem_reg, loc, e->exp.ir_op.reg, err);
	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 %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x4a960
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x56df2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x148(%rax), %r8
movq -0x30(%rbp), %r9
callq 0x57c10
movq -0x28(%rbp), %rdi
callq 0x36ee0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_string_type.c
// Function: prv_indexed_add
static void prv_indexed_add(subtilis_parser_t *p, const char *var_name,
			    const subtilis_type_t *type, size_t mem_reg,
			    size_t loc, subtilis_exp_t *e,
			    subtilis_exp_t **indices, size_t index_count,
			    subtilis_error_t *err)
{
	subtilis_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)
		return;

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

	subtilis_exp_delete(offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
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 -0x20(%rbp), %rcx
movq -0x28(%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, -0x38(%rbp)
movq 0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x56fc9
jmp 0x56ff2
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x148(%rax), %rsi
movq -0x30(%rbp), %rcx
movq 0x20(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x6b320
movq -0x38(%rbp), %rdi
callq 0x36ee0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_string_type.c
// Function: prv_append
static void prv_append(subtilis_parser_t *p, subtilis_exp_t *a1,
		       subtilis_exp_t *a2, subtilis_exp_t *gran,
		       subtilis_error_t *err)
{
	if ((a2->type.type == SUBTILIS_TYPE_ARRAY_STRING) ||
	    (a2->type.type == SUBTILIS_TYPE_VECTOR_STRING)) {
		if (gran) {
			subtilis_error_set_too_many_args(
			    err, 3, 2, p->l->stream->name, p->l->line);
			goto cleanup;
		}
		subtilis_array_append_ref_array(p, a1, a2, err);
		return;
	} else if ((a2->type.type == SUBTILIS_TYPE_STRING) ||
		   (a2->type.type == SUBTILIS_TYPE_CONST_STRING)) {
		subtilis_array_append_scalar(p, a1, a2, gran, err);
		return;
	}
	subtilis_error_set_expected(err, "string or array of strings",
				    subtilis_type_name(&a2->type),
				    p->l->stream->name, p->l->line);
cleanup:
	subtilis_exp_delete(gran);
	subtilis_exp_delete(a2);
	subtilis_exp_delete(a1);
}

// 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 -0x18(%rbp), %rax
cmpl $0xd, (%rax)
je 0x57afe
movq -0x18(%rbp), %rax
cmpl $0x13, (%rax)
jne 0x57b65
cmpq $0x0, -0x20(%rbp)
je 0x57b4b
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
leaq 0x54b1e(%rip), %rax     # 0xac653
movq %rax, (%rsp)
movl $0xff, 0x8(%rsp)
callq 0x157b0
jmp 0x57be6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x61840
jmp 0x57c01
movq -0x18(%rbp), %rax
cmpl $0x7, (%rax)
je 0x57b77
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x57b92
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x60890
jmp 0x57c01
jmp 0x57b94
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e190
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x54ab6(%rip), %rdx     # 0xac684
leaq 0x54a7e(%rip), %rax     # 0xac653
movq %rax, (%rsp)
movl $0x10b, 0x8(%rsp)       # imm = 0x10B
callq 0x156d0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x10(%rbp), %rdi
callq 0x36ee0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_string_type.c
// Function: prv_assign_ref
static void prv_assign_ref(subtilis_parser_t *p, const subtilis_type_t *type,
			   size_t dest_mem_reg, size_t dest_loc,
			   size_t source_reg, subtilis_error_t *err)
{
	size_t data_ptr;
	bool check_size = subtilis_type_if_is_vector(type);

	data_ptr =
	    subtilis_reference_get_pointer(p, dest_mem_reg, dest_loc, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_builtin_call_ir_deref_array_els(p, type, data_ptr, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_reference_type_init_ref(p, dest_mem_reg, dest_loc, source_reg,
					 check_size, true, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_array_type_copy_dims(p, type, dest_mem_reg, dest_loc,
				      source_reg, err);
}

// 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 %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4a040
andb $0x1, %al
movb %al, -0x39(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x6d920
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x57c62
jmp 0x57cd9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x44d80
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x57c82
jmp 0x57cd9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movb -0x39(%rbp), %r8b
movq -0x30(%rbp), %rax
movl $0x1, %r9d
andb $0x1, %r8b
movzbl %r8b, %r8d
movq %rax, (%rsp)
callq 0x6cb60
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x57cbc
jmp 0x57cd9
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 0x5e9e0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_fn_type.c
// Function: prv_indexed_write
static void prv_indexed_write(subtilis_parser_t *p, const char *var_name,
			      const subtilis_type_t *type, size_t mem_reg,
			      size_t loc, subtilis_exp_t *e,
			      subtilis_exp_t **indices, size_t index_count,
			      subtilis_error_t *err)
{
	subtilis_type_t fn_type;

	subtilis_type_init_copy_from_fn(&fn_type, &type->params.array.params.fn,
					err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(e);
		return;
	}

	subtilis_array_write(p, var_name, type, &fn_type, mem_reg, loc, e,
			     indices, index_count, err);
	subtilis_type_free(&fn_type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
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 -0x20(%rbp), %rsi
addq $0x8, %rsi
addq $0x30, %rsi
movq 0x20(%rbp), %rdx
leaq -0x180(%rbp), %rdi
callq 0x3e9b0
movq 0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x58250
movq -0x38(%rbp), %rdi
callq 0x36ee0
jmp 0x5829f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %rbx
movq 0x10(%rbp), %r11
movq 0x18(%rbp), %r10
movq 0x20(%rbp), %rax
leaq -0x180(%rbp), %rcx
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x5f920
leaq -0x180(%rbp), %rdi
callq 0x3e100
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_fn_type.c
// Function: prv_indexed_read
static subtilis_exp_t *
prv_indexed_read(subtilis_parser_t *p, const char *var_name,
		 const subtilis_type_t *type, size_t mem_reg, size_t loc,
		 subtilis_exp_t **indices, size_t index_count,
		 subtilis_error_t *err)
{
	subtilis_type_t fn_type;
	subtilis_exp_t *e;

	subtilis_type_init_copy_from_fn(&fn_type, &type->params.array.params.fn,
					err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	e = subtilis_array_read(p, var_name, type, &fn_type, mem_reg, loc,
				indices, index_count, err);
	subtilis_type_free(&fn_type);

	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
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 -0x20(%rbp), %rsi
addq $0x8, %rsi
addq $0x30, %rsi
movq 0x18(%rbp), %rdx
leaq -0x180(%rbp), %rdi
callq 0x3e9b0
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5840a
movq $0x0, -0x8(%rbp)
jmp 0x58462
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %r11
movq 0x10(%rbp), %r10
movq 0x18(%rbp), %rax
leaq -0x180(%rbp), %rcx
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x5fa20
movq %rax, -0x188(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x3e100
movq -0x188(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_fn_type.c
// Function: prv_zero_buf
static void prv_zero_buf(subtilis_parser_t *p, const subtilis_type_t *type,
			 size_t data_reg, size_t size_reg,
			 subtilis_error_t *err)
{
	subtilis_type_t el_type;
	subtilis_exp_t *e = NULL;

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

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

	subtilis_builtin_memset_i32(p, data_reg, size_reg, e->exp.ir_op.reg,
				    err);

cleanup:
	subtilis_type_free(&el_type);
	subtilis_exp_delete(e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x178(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x170(%rbp), %rdx
callq 0x47b70
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5851d
jmp 0x5857e
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x170(%rbp), %rsi
callq 0x47580
movq %rax, -0x178(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x58543
jmp 0x58566
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x178(%rbp), %rax
movq 0x148(%rax), %rcx
movq -0x28(%rbp), %r8
callq 0x3fb30
leaq -0x170(%rbp), %rdi
callq 0x3e100
movq -0x178(%rbp), %rdi
callq 0x36ee0
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_fn_type.c
// Function: prv_append
static void prv_append(subtilis_parser_t *p, subtilis_exp_t *a1,
		       subtilis_exp_t *a2, subtilis_exp_t *gran,
		       subtilis_error_t *err)
{
	if ((a2->type.type == SUBTILIS_TYPE_ARRAY_FN) ||
	    (a2->type.type == SUBTILIS_TYPE_VECTOR_FN)) {
		if (gran) {
			subtilis_error_set_too_many_args(
			    err, 3, 2, p->l->stream->name, p->l->line);
			goto cleanup;
		}
		subtilis_array_append_scalar_array(p, a1, a2, err);
		return;
	} else if (a2->type.type == SUBTILIS_TYPE_FN) {
		subtilis_array_append_scalar(p, a1, a2, gran, err);
		return;
	}
	subtilis_error_set_expected(err, "fn or collection of fn",
				    subtilis_type_name(&a2->type),
				    p->l->stream->name, p->l->line);

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

// 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 -0x18(%rbp), %rax
cmpl $0xe, (%rax)
je 0x58f1e
movq -0x18(%rbp), %rax
cmpl $0x14, (%rax)
jne 0x58f85
cmpq $0x0, -0x20(%rbp)
je 0x58f6b
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
leaq 0x5374a(%rip), %rax     # 0xac69f
movq %rax, (%rsp)
movl $0xe0, 0x8(%rsp)
callq 0x157b0
jmp 0x58ffd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x61270
jmp 0x59018
movq -0x18(%rbp), %rax
cmpl $0x9, (%rax)
jne 0x58fa9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x60890
jmp 0x59018
jmp 0x58fab
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e190
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x53703(%rip), %rdx     # 0xac6e8
leaq 0x536b3(%rip), %rax     # 0xac69f
movq %rax, (%rsp)
movl $0xeb, 0x8(%rsp)
callq 0x156d0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x10(%rbp), %rdi
callq 0x36ee0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_rec_type.c
// Function: prv_data_size
static subtilis_exp_t *prv_data_size(subtilis_parser_t *p,
				     const subtilis_type_t *type,
				     subtilis_exp_t *e, subtilis_error_t *err)
{
	subtilis_exp_t *el_size;
	subtilis_type_t typ;
	int32_t data_size;

	typ.type = SUBTILIS_TYPE_VOID;
	subtilis_type_copy_from_rec(&typ, &type->params.array.params.rec, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(e);
		return NULL;
	}

	data_size = (int32_t)subtilis_type_rec_size(&typ);
	subtilis_type_free(&typ);
	el_size = subtilis_exp_new_int32(data_size, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(e);
		return NULL;
	}

	return subtilis_type_if_mul(p, e, el_size, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x8, -0x178(%rbp)
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
addq $0x30, %rsi
movq -0x28(%rbp), %rdx
leaq -0x178(%rbp), %rdi
callq 0x3ea70
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x592ad
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x59313
leaq -0x178(%rbp), %rdi
callq 0x3f0d0
movl %eax, -0x17c(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x3e100
movl -0x17c(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0x37800
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x592fa
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x59313
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x48fb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_rec_type.c
// Function: prv_assign_array_ref_exp
static void prv_assign_array_ref_exp(subtilis_parser_t *p,
				     const subtilis_type_t *type,
				     size_t mem_reg, size_t loc,
				     subtilis_exp_t *e, subtilis_error_t *err)
{
	subtilis_type_t el_type;

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

	el_type.type = SUBTILIS_TYPE_VOID;
	subtilis_type_if_element_type(p, type, &el_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	if (!subtilis_type_rec_need_deref(&el_type)) {
		subtilis_type_free(&el_type);
		subtilis_array_type_assign_ref_exp(p, type, mem_reg, loc, e,
						   err);
		return;
	}

	prv_assign_ref(p, type, &el_type, mem_reg, loc, e->exp.ir_op.reg, err);
	subtilis_type_free(&el_type);

cleanup:
	subtilis_exp_delete(e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
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 -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x4a960
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x593d6
jmp 0x59479
movl $0x8, -0x178(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rcx
leaq -0x178(%rbp), %rdx
callq 0x47b70
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x59403
jmp 0x59479
leaq -0x178(%rbp), %rdi
callq 0x3f560
testb $0x1, %al
jne 0x5943e
leaq -0x178(%rbp), %rdi
callq 0x3e100
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 0x5e960
jmp 0x59482
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %rax
movq 0x148(%rax), %r9
movq -0x30(%rbp), %rax
leaq -0x178(%rbp), %rdx
movq %rax, (%rsp)
callq 0x5a4d0
leaq -0x178(%rbp), %rdi
callq 0x3e100
movq -0x28(%rbp), %rdi
callq 0x36ee0
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_rec_type.c
// Function: prv_copy_col
static void prv_copy_col(subtilis_parser_t *p, subtilis_exp_t *e1,
			 subtilis_exp_t *e2, subtilis_error_t *err)
{
	bool scalar;
	subtilis_type_t typ;

	typ.type = SUBTILIS_TYPE_VOID;
	prv_element_type(&e1->type, &typ, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	scalar = subtilis_type_rec_is_scalar(&typ);
	subtilis_type_free(&typ);

	if (!scalar) {
		subtilis_collection_copy_ref(p, e1, e2, err);
		return;
	}
	subtilis_collection_copy_scalar(p, e1, e2, false, err);
}

// 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)
movl $0x8, -0x170(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x170(%rbp), %rsi
callq 0x594e0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x59584
jmp 0x595d5
leaq -0x170(%rbp), %rdi
callq 0x3f160
andb $0x1, %al
movb %al, -0x21(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x3e100
testb $0x1, -0x21(%rbp)
jne 0x595be
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x6f970
jmp 0x595d5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %r8
xorl %ecx, %ecx
callq 0x6f5a0
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_rec_type.c
// Function: prv_indexed_write
static void prv_indexed_write(subtilis_parser_t *p, const char *var_name,
			      const subtilis_type_t *type, size_t mem_reg,
			      size_t loc, subtilis_exp_t *e,
			      subtilis_exp_t **indices, size_t index_count,
			      subtilis_error_t *err)
{
	subtilis_type_t rec_type;

	subtilis_type_init_copy_from_rec(&rec_type,
					 &type->params.array.params.rec, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	e = subtilis_type_if_coerce_type(p, e, &rec_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto free_type;

	subtilis_array_write(p, var_name, type, &rec_type, mem_reg, loc, e,
			     indices, index_count, err);

free_type:
	subtilis_type_free(&rec_type);

cleanup:
	subtilis_exp_delete(e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
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 -0x20(%rbp), %rsi
addq $0x8, %rsi
addq $0x30, %rsi
movq 0x20(%rbp), %rdx
leaq -0x180(%rbp), %rdi
callq 0x3ea30
movq 0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x59637
jmp 0x596ad
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq 0x20(%rbp), %rcx
leaq -0x180(%rbp), %rdx
callq 0x4a2e0
movq %rax, -0x38(%rbp)
movq 0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5965e
jmp 0x596a1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %rbx
movq 0x10(%rbp), %r11
movq 0x18(%rbp), %r10
movq 0x20(%rbp), %rax
leaq -0x180(%rbp), %rcx
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x5f920
leaq -0x180(%rbp), %rdi
callq 0x3e100
movq -0x38(%rbp), %rdi
callq 0x36ee0
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_rec_type.c
// Function: prv_indexed_read
static subtilis_exp_t *
prv_indexed_read(subtilis_parser_t *p, const char *var_name,
		 const subtilis_type_t *type, size_t mem_reg, size_t loc,
		 subtilis_exp_t **indices, size_t index_count,
		 subtilis_error_t *err)
{
	subtilis_exp_t *e;

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

	subtilis_type_if_element_type(p, type, &e->type, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(e);
		return NULL;
	}

	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
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 -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %r10
movq 0x18(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x5edb0
movq %rax, -0x40(%rbp)
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5982d
movq $0x0, -0x8(%rbp)
jmp 0x59866
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x18(%rbp), %rcx
callq 0x47b70
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5985e
movq -0x40(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x59866
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_rec_type.c
// Function: prv_zero_buf
static void prv_zero_buf(subtilis_parser_t *p, const subtilis_type_t *type,
			 size_t data_reg, size_t size_reg,
			 subtilis_error_t *err)
{
	subtilis_type_t el_type;

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

	if (subtilis_type_rec_can_zero_fill(&el_type))
		subtilis_builtin_bzero_reg(p, data_reg, 0, size_reg, err);
	else
		prv_zero_non_scalar(p, &el_type, data_reg, size_reg, err);

	subtilis_type_free(&el_type);
}

// 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 -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x170(%rbp), %rdx
callq 0x47b70
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x59912
jmp 0x59967
leaq -0x170(%rbp), %rdi
callq 0x3f2d0
testb $0x1, %al
jne 0x59924
jmp 0x5993f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x3fee0
jmp 0x5995b
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x170(%rbp), %rsi
callq 0x5a750
leaq -0x170(%rbp), %rdi
callq 0x3e100
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_rec_type.c
// Function: prv_destructor
static size_t prv_destructor(subtilis_parser_t *p, const subtilis_type_t *type,
			     subtilis_error_t *err)
{
	subtilis_type_t el_type;
	size_t call_index = SIZE_MAX;

	el_type.type = SUBTILIS_TYPE_VOID;
	subtilis_type_if_element_type(p, type, &el_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return SIZE_MAX;

	if (!subtilis_type_rec_need_deref(&el_type)) {
		call_index = subtilis_type_if_destruct_deref(p, type, err);
		goto cleanup;
	}

	call_index = subtilis_builtin_ir_deref_array_recs(p, &el_type, err);

cleanup:
	subtilis_type_free(&el_type);

	return call_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $-0x1, -0x170(%rbp)
movl $0x8, -0x168(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq -0x168(%rbp), %rdx
callq 0x47b70
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5a2c7
movq $-0x1, -0x8(%rbp)
jmp 0x5a323
leaq -0x168(%rbp), %rdi
callq 0x3f560
testb $0x1, %al
jne 0x5a2f1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4aa10
movq %rax, -0x170(%rbp)
jmp 0x5a30c
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x168(%rbp), %rsi
callq 0x44e00
movq %rax, -0x170(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x3e100
movq -0x170(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_rec_type.c
// Function: prv_append
static void prv_append(subtilis_parser_t *p, subtilis_exp_t *a1,
		       subtilis_exp_t *a2, subtilis_exp_t *gran,
		       subtilis_error_t *err)
{
	subtilis_type_t el_type;
	bool need_deref;

	if (a2->type.type == SUBTILIS_TYPE_REC) {
		subtilis_array_append_scalar(p, a1, a2, gran, err);
		return;
	}

	if (gran) {
		subtilis_error_set_too_many_args(err, 3, 2, p->l->stream->name,
						 p->l->line);
		goto cleanup;
	}

	el_type.type = SUBTILIS_TYPE_VOID;
	prv_element_type(&a1->type, &el_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	need_deref = subtilis_type_rec_need_deref(&el_type);
	subtilis_type_free(&el_type);
	if (!need_deref) {
		subtilis_array_append_scalar_array(p, a1, a2, err);
		return;
	}

	subtilis_array_append_ref_array(p, a1, a2, err);

	return;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x16, (%rax)
jne 0x5a3d6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x60890
jmp 0x5a4be
cmpq $0x0, -0x20(%rbp)
je 0x5a423
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
leaq 0x522f2(%rip), %rax     # 0xac6ff
movq %rax, (%rsp)
movl $0x165, 0x8(%rsp)       # imm = 0x165
callq 0x157b0
jmp 0x5a4a3
movl $0x8, -0x170(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x170(%rbp), %rsi
callq 0x594e0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5a44c
jmp 0x5a4a3
leaq -0x170(%rbp), %rdi
callq 0x3f560
andb $0x1, %al
movb %al, -0x171(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x3e100
testb $0x1, -0x171(%rbp)
jne 0x5a48c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x61270
jmp 0x5a4be
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x61840
jmp 0x5a4be
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x10(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rdi
callq 0x36ee0
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/array_rec_type.c
// Function: prv_assign_ref
static void prv_assign_ref(subtilis_parser_t *p, const subtilis_type_t *type,
			   const subtilis_type_t *el_type, size_t dest_mem_reg,
			   size_t dest_loc, size_t source_reg,
			   subtilis_error_t *err)
{
	size_t data_ptr;
	bool check_size = subtilis_type_if_is_vector(type);

	data_ptr =
	    subtilis_reference_get_pointer(p, dest_mem_reg, dest_loc, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_builtin_ir_call_deref_array_recs(p, el_type, data_ptr, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_reference_type_init_ref(p, dest_mem_reg, dest_loc, source_reg,
					 check_size, true, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_array_type_copy_dims(p, type, dest_mem_reg, dest_loc,
				      source_reg, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
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 -0x10(%rbp), %rdi
callq 0x4a040
andb $0x1, %al
movb %al, -0x39(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0x6d920
movq %rax, -0x38(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5a526
jmp 0x5a59d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0x44fd0
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5a546
jmp 0x5a59d
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movb -0x39(%rbp), %r8b
movq 0x10(%rbp), %rax
movl $0x1, %r9d
andb $0x1, %r8b
movzbl %r8b, %r8d
movq %rax, (%rsp)
callq 0x6cb60
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5a580
jmp 0x5a59d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq 0x10(%rbp), %r9
callq 0x5e9e0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)