LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/byte_type_if.c
// Function: prv_commutative_nc
static subtilis_exp_t *
prv_commutative_nc(subtilis_parser_t *p, subtilis_exp_t *a1, subtilis_exp_t *a2,
		   subtilis_op_instr_type_t in_var_var,
		   subtilis_type_if_binary_nc_t binary_nc_fn, bool swapped,
		   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_nc_fn(p, a1, a2, swapped, err);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x40(%rsp), %r15
cmpl $0x6, (%rdx)
jne 0x3cac7
movq 0x48(%r12), %rdi
movq 0x148(%r14), %rdx
movq 0x148(%rbx), %rax
movl %ecx, %esi
movq %rax, %rcx
movq %r15, %r8
callq 0x2c00f
cmpl $0x0, (%r15)
jne 0x3cae4
movq %rax, 0x148(%r14)
movq %rbx, %rdi
callq 0x2b4c3
jmp 0x3caf7
movl %r9d, %ebp
movq %r8, %r13
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3c251
movq %rax, %r14
cmpl $0x0, (%r15)
je 0x3cb09
movq %r14, %rdi
callq 0x2b4c3
movq %rbx, %rdi
callq 0x2b4c3
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %ecx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %r8
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
cmpl $0x6, (%rdx)
jne 0x3cb7d
movq 0x48(%r12), %rdi
movq 0x148(%r14), %rdx
movq 0x148(%rbx), %rax
movl %ecx, %esi
movq %rax, %rcx
movq %r15, %r8
callq 0x2c00f
cmpl $0x0, (%r15)
jne 0x3cb97
movq %rax, 0x148(%r14)
movq %rbx, %rdi
callq 0x2b4c3
jmp 0x3cbaa
movq %r8, %r13
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3c251
movq %rax, %r14
cmpl $0x0, (%r15)
je 0x3cbb7
movq %r14, %rdi
callq 0x2b4c3
movq %rbx, %rdi
callq 0x2b4c3
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %rdx, %rbx
movq %rdi, %r12
cmpl $0x6, (%rdx)
jne 0x3cc4b
movl %ecx, %ebp
movq %r12, %rdi
movq %r15, %rdx
callq 0x3ca21
movq %rax, %r14
cmpl $0x0, (%r15)
jne 0x3cc62
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3ca21
movq %rax, %rbx
cmpl $0x0, (%r15)
jne 0x3cc62
movq 0x48(%r12), %rdi
movq 0x148(%r14), %rdx
movq 0x148(%rbx), %rcx
movl %ebp, %esi
movq %r15, %r8
callq 0x2c00f
cmpl $0x0, (%r15)
jne 0x3cc62
movq %rax, 0x148(%r14)
movq %rbx, %rdi
callq 0x2b4c3
jmp 0x3cc75
movq %r8, %r13
movq %r12, %rdi
movq %r15, %rdx
callq 0x3c251
movq %rax, %r14
cmpl $0x0, (%r15)
je 0x3cc87
movq %r14, %rdi
callq 0x2b4c3
movq %rbx, %rdi
callq 0x2b4c3
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %r15
movq %r9, %rdx
callq 0x3c251
cmpl $0x0, (%rbx)
je 0x3ccdd
movq %r14, %rdi
callq 0x2b4c3
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %ecx
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %r8
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movl $0x2, %edi
movq %rcx, %rsi
callq 0x2bb29
cmpl $0x0, (%rbx)
je 0x3cd37
movq %r14, %rdi
callq 0x2b4c3
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x37336
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r13
movl (%rdx), %eax
cmpl $0x11, %eax
je 0x3d3b1
cmpl $0xb, %eax
jne 0x3d3eb
testq %r15, %r15
je 0x3d42c
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x3814a(%rip), %rax     # 0x75513
movq %r12, %rdi
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
pushq $0xb7
pushq %rax
callq 0x144d6
jmp 0x3d47f
movq %r14, %rdi
callq 0x37676
testb %al, %al
je 0x3d446
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3691f
movq %rax, %r14
cmpl $0x0, (%r12)
jne 0x3d483
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4499a
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4504b
movq %r14, %rdi
callq 0x2f882
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x380b2(%rip), %r10     # 0x75513
leaq 0x38187(%rip), %rdx     # 0x755ef
movq %r12, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0xc5
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %r15, %rdi
callq 0x2b4c3
movq %r14, %rdi
callq 0x2b4c3
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b4c3
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r13
movl (%rdx), %eax
cmpl $0x12, %eax
je 0x3dc7f
cmpl $0xc, %eax
jne 0x3dcbd
testq %r14, %r14
je 0x3dd1a
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x37971(%rip), %rax     # 0x7560c
movq %r12, %rdi
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
pushq $0xa6
pushq %rax
callq 0x144d6
jmp 0x3dd6d
movq %r15, %rdi
callq 0x37676
testb %al, %al
je 0x3dd34
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x36269
movq %rax, %r15
cmpl $0x0, (%r12)
jne 0x3dd71
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x369a2
movq %rax, %r15
cmpl $0x0, (%r12)
jne 0x3dd71
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %r12, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4499a
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4504b
movq %r15, %rdi
callq 0x2f882
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x378bd(%rip), %r10     # 0x7560c
leaq 0x378d1(%rip), %rdx     # 0x75627
movq %r12, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0xb7
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %r14, %rdi
callq 0x2b4c3
movq %r15, %rdi
callq 0x2b4c3
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b4c3
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movl $0x3, %edi
movq %rcx, %rsi
callq 0x2bb29
cmpl $0x0, (%rbx)
je 0x3df37
movq %r14, %rdi
callq 0x2b4c3
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x37336
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r13
movl (%rdx), %eax
cmpl $0x10, %eax
je 0x3e5b1
cmpl $0xa, %eax
jne 0x3e5eb
testq %r15, %r15
je 0x3e62c
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x37075(%rip), %rax     # 0x7563e
movq %r12, %rdi
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
pushq $0xb7
pushq %rax
callq 0x144d6
jmp 0x3e67f
movq %r14, %rdi
callq 0x37676
testb %al, %al
je 0x3e646
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x36a77
movq %rax, %r14
cmpl $0x0, (%r12)
jne 0x3e683
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4499a
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4504b
movq %r14, %rdi
callq 0x2f882
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x36fdd(%rip), %r10     # 0x7563e
leaq 0x36ff4(%rip), %rdx     # 0x7565c
movq %r12, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0xc5
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %r15, %rdi
callq 0x2b4c3
movq %r14, %rdi
callq 0x2b4c3
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b4c3
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x3631c(%rip), %rdi     # 0x74b88
callq 0x48324
movl %eax, %edi
movq %rbx, %rsi
callq 0x2bb29
cmpl $0x0, (%rbx)
je 0x3e890
movq %r14, %rdi
callq 0x2b4c3
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x36d24
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq %r8, %rdx
movq %r9, %rcx
callq 0x37da0
cmpl $0x0, (%r14)
jne 0x3e9a0
movq 0x148(%rbx), %rax
movq %rax, 0x10(%rsp)
movq %r13, %rdi
callq 0x37815
movb %al, 0xf(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4d763
cmpl $0x0, (%r14)
jne 0x3e9a0
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x3444f
cmpl $0x0, (%r14)
jne 0x3e9a0
movq %r14, (%rsp)
movzbl 0xf(%rsp), %r8d
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r9d
callq 0x4ce10
cmpl $0x0, (%r14)
jne 0x3e9a0
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq 0x10(%rsp), %r8
movq %r14, %r9
callq 0x434e1
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b4c3
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rdi, %r15
movq 0x40(%rsp), %r14
movq 0x30(%rsp), %r9
pushq %r14
pushq 0x40(%rsp)
callq 0x437b3
addq $0x10, %rsp
cmpl $0x0, (%r14)
je 0x3ea48
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r12
movq 0x148(%rax), %rsi
movq %r15, %rdi
xorl %edx, %edx
movq %rbx, %rcx
movq %r14, %r8
callq 0x4bf09
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2b4c3
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r13
movl (%rdx), %eax
addl $-0x3, %eax
rorl %eax
cmpl $0x8, %eax
ja 0x3f087
leaq 0x3664e(%rip), %rcx     # 0x75674
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4499a
testq %r15, %r15
je 0x3f0e5
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x36630(%rip), %rax     # 0x75698
movq %r12, %rdi
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
pushq $0xff
pushq %rax
callq 0x144d6
jmp 0x3f0c0
movq %r14, %rdi
callq 0x2f882
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x365f6(%rip), %r10     # 0x75698
leaq 0x36620(%rip), %rdx     # 0x756c9
movq %r12, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0x10b                  # imm = 0x10B
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %r15, %rdi
callq 0x2b4c3
movq %r14, %rdi
callq 0x2b4c3
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b4c3
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4547c
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %r9, %rbx
movq %r8, 0x8(%rsp)
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq 0x1a0(%rsp), %r12
leaq 0x38(%rdx), %rsi
leaq 0x10(%rsp), %rdi
movq %r12, %rdx
callq 0x2fd8c
cmpl $0x0, (%r12)
je 0x3f481
movq %rbx, %rdi
callq 0x2b4c3
jmp 0x3f4bc
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %rcx, %r14
movq %r15, %r8
movq 0x8(%rsp), %r9
pushq %r12
pushq 0x1a0(%rsp)
pushq 0x1a0(%rsp)
pushq %rbx
callq 0x43f19
addq $0x20, %rsp
movq %r14, %rdi
callq 0x2f843
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %r9, 0x8(%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x198(%rsp), %r12
leaq 0x38(%rdx), %rsi
leaq 0x10(%rsp), %rdi
movq %r12, %rdx
callq 0x2fd8c
cmpl $0x0, (%r12)
je 0x3f597
xorl %ebx, %ebx
jmp 0x3f5d3
subq $0x8, %rsp
leaq 0x18(%rsp), %rcx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %rcx, %r13
movq %r15, %r8
movq %r14, %r9
pushq %r12
pushq 0x1a0(%rsp)
pushq 0x20(%rsp)
callq 0x43fc1
addq $0x20, %rsp
movq %rax, %rbx
movq %r13, %rdi
callq 0x2f843
movq %rbx, %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
leaq 0x8(%rsp), %rdx
movq %r8, %rcx
callq 0x3620e
cmpl $0x0, (%rbx)
jne 0x3f66c
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x35f70
movq %rax, %r13
cmpl $0x0, (%rbx)
jne 0x3f65a
movq 0x148(%r13), %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %r8
callq 0x3087c
leaq 0x8(%rsp), %rdi
callq 0x2f843
movq %r13, %rdi
callq 0x2b4c3
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r13
movl (%rdx), %eax
cmpl $0x9, %eax
je 0x3fbcc
cmpl $0x14, %eax
je 0x3fb91
cmpl $0xe, %eax
jne 0x3fbe9
testq %r15, %r15
je 0x3fc47
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x35b37(%rip), %rax     # 0x756e4
movq %r12, %rdi
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
pushq $0xe0
pushq %rax
callq 0x144d6
jmp 0x3fc22
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4499a
movq %r14, %rdi
callq 0x2f882
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x35ae0(%rip), %r10     # 0x756e4
leaq 0x35b22(%rip), %rdx     # 0x7572d
movq %r12, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0xeb
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %r15, %rdi
callq 0x2b4c3
movq %r14, %rdi
callq 0x2b4c3
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b4c3
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4504b
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
movl $0x8, (%rdi)
addq $0x38, %rsi
movq %rcx, %rdx
callq 0x2fddb
cmpl $0x0, (%r14)
jne 0x3fe3a
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x30197
movq %rax, %r13
movq %r12, %rdi
callq 0x2f843
movl %r13d, %edi
movq %r14, %rsi
callq 0x2bb29
cmpl $0x0, (%r14)
je 0x3fe55
movq %rbx, %rdi
callq 0x2b4c3
xorl %eax, %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x36d24
jmp 0x3fe44
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq %r8, %rdx
movq %r9, %rcx
callq 0x37da0
cmpl $0x0, (%r14)
jne 0x3ffa6
leaq 0x20(%rsp), %rdx
movl $0x8, (%rdx)
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rcx
callq 0x3620e
cmpl $0x0, (%r14)
jne 0x3ffa6
leaq 0x20(%rsp), %rdi
callq 0x3041c
testb %al, %al
je 0x3ffc0
movq 0x148(%rbx), %rax
movq %rax, 0x18(%rsp)
movq %r13, %rdi
callq 0x37815
movb %al, 0x17(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4d763
cmpl $0x0, (%r14)
jne 0x3ff9c
leaq 0x20(%rsp), %rsi
movq %rbp, %rdi
movq %rax, %rdx
movq %r14, %rcx
callq 0x3467b
cmpl $0x0, (%r14)
jne 0x3ff9c
movq %r14, (%rsp)
movzbl 0x17(%rsp), %r8d
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0x18(%rsp), %rcx
movl $0x1, %r9d
callq 0x4ce10
cmpl $0x0, (%r14)
jne 0x3ff9c
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq 0x18(%rsp), %r8
movq %r14, %r9
callq 0x434e1
leaq 0x20(%rsp), %rdi
callq 0x2f843
movq %rbx, %rdi
callq 0x2b4c3
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %rdi
callq 0x2f843
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
movq %r14, %r9
callq 0x43482
jmp 0x3ffae
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsp, %rdi
movl $0x8, (%rdi)
addq $0x38, %rsi
movq %rcx, %rdx
callq 0x2fdcc
cmpl $0x0, (%rbx)
jne 0x40077
movq %rsp, %r13
movq %r13, %rdi
callq 0x301d0
movl %eax, %ebp
movq %r13, %rdi
callq 0x2f843
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
testb %bpl, %bpl
je 0x4006f
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x4e9b8
jmp 0x40077
movq %rbx, %rcx
callq 0x4ec8d
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %r9, %rbx
movq %r8, 0x18(%rsp)
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r12
movq 0x1b0(%rsp), %r15
leaq 0x38(%rdx), %rsi
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq 0x2fdcc
cmpl $0x0, (%r15)
jne 0x40137
movq %r15, %rax
movq %r14, 0x8(%rsp)
movq %rbp, 0x10(%rsp)
leaq 0x20(%rsp), %rdx
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %r14
movq %rax, %rcx
callq 0x379c3
movq %rax, %rbx
cmpl $0x0, (%r15)
jne 0x4012d
leaq 0x20(%rsp), %rcx
movq %r12, %rdi
movq 0x8(%rsp), %rsi
movq %r13, %rdx
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
pushq %r14
pushq 0x1b0(%rsp)
pushq 0x1b0(%rsp)
pushq %rbx
callq 0x43f19
addq $0x20, %rsp
leaq 0x20(%rsp), %rdi
callq 0x2f843
movq %rbx, %rdi
callq 0x2b4c3
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r12
movq 0x38(%rsp), %r14
pushq %r14
pushq 0x38(%rsp)
callq 0x437b3
addq $0x10, %rsp
cmpl $0x0, (%r14)
jne 0x4021b
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x3620e
cmpl $0x0, (%r14)
je 0x4021d
movq %rbx, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %rdx
movq %r8, %rcx
callq 0x3620e
cmpl $0x0, (%rbx)
jne 0x403bd
leaq 0x10(%rsp), %rdi
callq 0x302bf
testb %al, %al
je 0x40299
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r12, %rcx
movq %rbx, %r8
callq 0x30b2b
jmp 0x403b3
movq 0x48(%r14), %rdi
callq 0x2d00a
movq %rax, %r13
movq 0x48(%r14), %rdi
callq 0x2d00a
movq %rax, 0x8(%rsp)
movq 0x48(%r14), %rdi
movl $0x1d, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2c189
cmpl $0x0, (%rbx)
jne 0x403b3
movq %rax, %rbp
movq 0x48(%r14), %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
movq %rbx, %r8
callq 0x2c00f
cmpl $0x0, (%rbx)
jne 0x403b3
movq %rax, %r15
movq 0x48(%r14), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2d017
cmpl $0x0, (%rbx)
jne 0x403b3
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %rbp, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x45cd5
cmpl $0x0, (%rbx)
jne 0x403b3
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq %rax, %r12
leaq 0x10(%rsp), %rdi
callq 0x30197
movq 0x48(%r14), %rdi
movl %eax, %r8d
orq %r12, %r8
movl $0x9, %esi
movq %rbp, %rdx
movq %rbp, %rcx
movq %rbx, %r9
callq 0x2c0c2
cmpl $0x0, (%rbx)
jne 0x403b3
movq 0x48(%r14), %rdi
movl $0x3b, %esi
movq %rbp, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x2c00f
cmpl $0x0, (%rbx)
jne 0x403b3
movq 0x48(%r14), %rdi
movl $0x43, %esi
movq %rax, %rdx
movq %r13, %rcx
movq 0x8(%rsp), %r8
movq %rbx, %r9
callq 0x2c0c2
cmpl $0x0, (%rbx)
jne 0x403b3
movq 0x48(%r14), %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x2d017
leaq 0x10(%rsp), %rdi
callq 0x2f843
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rdx
movl $0x8, (%rdx)
movq %rbx, %rcx
callq 0x3620e
movq $-0x1, %r12
cmpl $0x0, (%rbx)
jne 0x4090c
movq %rsp, %rdi
callq 0x3041c
testb %al, %al
je 0x408f3
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x34498
jmp 0x40901
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x37e2a
movq %rax, %r12
movq %rsp, %rdi
callq 0x2f843
movq %r12, %rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
cmpl $0x16, (%rdx)
jne 0x4097f
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movq %r15, %r8
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4499a
testq %r12, %r12
je 0x409ba
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x34dad(%rip), %rax     # 0x75744
movq %r15, %rdi
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
pushq $0x165                  # imm = 0x165
pushq %rax
callq 0x144d6
addq $0x10, %rsp
jmp 0x409d5
movq %rsp, %rdi
movl $0x8, (%rdi)
leaq 0x38(%r14), %rsi
movq %r15, %rdx
callq 0x2fdcc
cmpl $0x0, (%r15)
je 0x409ff
movq %r12, %rdi
callq 0x2b4c3
movq %r14, %rdi
callq 0x2b4c3
movq %rbx, %rdi
callq 0x2b4c3
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %r12
movq %r12, %rdi
callq 0x3041c
movl %eax, %ebp
movq %r12, %rdi
callq 0x2f843
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
testb %bpl, %bpl
je 0x40a2c
callq 0x4547c
jmp 0x409ed
callq 0x4504b
jmp 0x409ed
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/array_rec_type.c
// Function: prv_set
static void prv_set(subtilis_parser_t *p, const char *var_name,
		    const subtilis_type_t *type, size_t mem_reg, size_t loc,
		    subtilis_exp_t *e, bool check_size, subtilis_error_t *err)
{
	subtilis_type_t el_type;
	size_t sizee;
	//	size_t ptr;
	subtilis_ir_operand_t gt_zero;
	subtilis_ir_operand_t eq_zero;
	subtilis_ir_operand_t op0;

	eq_zero.label = SIZE_MAX;

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

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

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

	if (check_size) {
		gt_zero.label = subtilis_ir_section_new_label(p->current);
		eq_zero.label = subtilis_ir_section_new_label(p->current);
		op0.reg = sizee;
		subtilis_ir_section_add_instr_reg(p->current,
						  SUBTILIS_OP_INSTR_JMPC, op0,
						  gt_zero, eq_zero, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		subtilis_ir_section_add_label(p->current, gt_zero.label, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	//	ptr = subtilis_reference_get_data(p, mem_reg, loc, err);
	//	if (err->type != SUBTILIS_ERROR_OK)
	//		goto cleanup;

	subtilis_error_set_assertion_failed(err);
	goto cleanup;

	if (check_size)
		subtilis_ir_section_add_label(p->current, eq_zero.label, err);

cleanup:
	subtilis_type_free(&el_type);

free_e:
	subtilis_exp_delete(e);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movl %r9d, %ebp
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r15
movq 0x180(%rsp), %r14
movq %rsp, %rdx
movl $0x8, (%rdx)
movq %r14, %rcx
callq 0x3620e
cmpl $0x0, (%r14)
jne 0x40b1e
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x379c3
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x40b16
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x4d908
cmpl $0x0, (%r14)
jne 0x40b16
testb %bpl, %bpl
je 0x40afd
movq %rax, %r12
movq 0x48(%r15), %rdi
callq 0x2d00a
movq %rax, %r13
movq 0x48(%r15), %rdi
callq 0x2d00a
movq 0x48(%r15), %rdi
movl $0x43, %esi
movq %r12, %rdx
movq %r13, %rcx
movq %rax, %r8
movq %r14, %r9
callq 0x2c0c2
cmpl $0x0, (%r14)
jne 0x40b16
movq 0x48(%r15), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2d017
cmpl $0x0, (%r14)
jne 0x40b16
leaq 0x34c40(%rip), %rdx     # 0x75744
movq %r14, %rdi
movl $0xf, %esi
movl $0xf0, %ecx
callq 0x145f4
movq %rsp, %rdi
callq 0x2f843
movq %rbx, %rdi
callq 0x2b4c3
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/fn_type.c
// Function: prv_zero
static subtilis_exp_t *prv_zero(subtilis_parser_t *p,
				const subtilis_type_t *type,
				subtilis_error_t *err)
{
	subtilis_ir_operand_t op1;
	size_t reg_num;
	subtilis_exp_t *e = NULL;
	size_t call_index;

	call_index = prv_generate_zero_fn(p, type->params.fn.ret_val, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	op1.label = (int32_t)call_index;
	reg_num = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_GET_PROC_ADDR, op1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	e = subtilis_exp_new_int32_var(reg_num, err);

	return e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
callq 0x41276
cmpl $0x0, (%rbx)
jne 0x40b6f
movslq %eax, %rdx
movq 0x48(%r14), %rdi
movl $0x9b, %esi
movq %rbx, %rcx
callq 0x2c189
cmpl $0x0, (%rbx)
je 0x40b79
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %eax, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2ba99
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/fn_type.c
// Function: prv_zero_reg
static void prv_zero_reg(subtilis_parser_t *p, const subtilis_type_t *type,
			 size_t reg, subtilis_error_t *err)
{
	subtilis_ir_operand_t op0;
	subtilis_ir_operand_t op1;
	size_t call_index;

	call_index = prv_generate_zero_fn(p, type->params.fn.ret_val, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	op0.reg = reg;
	op1.label = (int32_t)call_index;
	subtilis_ir_section_add_instr_no_reg2(
	    p->current, SUBTILIS_OP_INSTR_GET_PROC_ADDR, op0, op1, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x8(%rsi), %rsi
movq %rcx, %rdx
callq 0x41276
cmpl $0x0, (%rbx)
je 0x40baf
popq %rbx
popq %r14
popq %r15
retq
movslq %eax, %rcx
movq 0x48(%r15), %rdi
movl $0x9b, %esi
movq %r14, %rdx
movq %rbx, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x2c1ac
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/fn_type.c
// Function: prv_load_from_mem
static subtilis_exp_t *prv_load_from_mem(subtilis_parser_t *p,
					 const subtilis_type_t *type,
					 size_t mem_reg, size_t loc,
					 subtilis_error_t *err)
{
	subtilis_ir_operand_t op1;
	subtilis_ir_operand_t op2;
	size_t reg;

	op1.reg = mem_reg;
	op2.integer = (int32_t)loc;
	reg = subtilis_ir_section_add_instr(
	    p->current, SUBTILIS_OP_INSTR_LOADO_I32, op1, op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	return subtilis_exp_new_var(type, reg, err);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rsi, %r14
movq 0x48(%rdi), %rdi
movl %ecx, %ecx
movl $0x12, %esi
callq 0x2c00f
cmpl $0x0, (%rbx)
je 0x40cc8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2b971
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/fn_type.c
// Function: prv_logical
static subtilis_exp_t *prv_logical(subtilis_parser_t *p,
				   subtilis_op_instr_type_t type,
				   subtilis_exp_t *a1, subtilis_exp_t *a2,
				   subtilis_error_t *err)
{
	size_t reg;

	if (!subtilis_type_eq(&a1->type, &a2->type)) {
		subtilis_error_set_fn_type_mismatch(err, p->l->stream->name,
						    p->l->line);
		goto cleanup;
	}

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

cleanup:

	subtilis_exp_delete(a1);
	subtilis_exp_delete(a2);

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x2f3e4
testb %al, %al
je 0x415ae
movq 0x48(%r12), %rdi
movq 0x148(%r14), %rdx
movq 0x148(%rbx), %rcx
movl %ebp, %esi
movq %r15, %r8
callq 0x2c00f
cmpl $0x0, (%r15)
jne 0x415d3
movq %rax, 0x148(%r14)
jmp 0x415de
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x34324(%rip), %r8      # 0x758e4
movq %r15, %rdi
movl $0x42, %esi
movl $0x149, %r9d            # imm = 0x149
callq 0x14618
movq %r14, %rdi
callq 0x2b4c3
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x2b4c3
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop