LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/byte_type_if.c
// Function: prv_lsr
static subtilis_exp_t *prv_lsr(subtilis_parser_t *p, subtilis_exp_t *a1,
			       subtilis_exp_t *a2, subtilis_error_t *err)
{
	a1->type.type = SUBTILIS_TYPE_INTEGER;
	a1 = subtilis_type_int32.lsr(p, a1, a2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	a1->type.type = SUBTILIS_TYPE_BYTE;
	return a1;
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
movl $0x5, (%rsi)
leaq 0x6a21b(%rip), %rax     # 0xa6850
callq *0x1d8(%rax)
cmpl $0x0, (%rbx)
je 0x3c644
xorl %eax, %eax
jmp 0x3c64a
movl $0x6, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/byte_type_if.c
// Function: prv_asr
static subtilis_exp_t *prv_asr(subtilis_parser_t *p, subtilis_exp_t *a1,
			       subtilis_exp_t *a2, subtilis_error_t *err)
{
	/*
	 * This one needs to be sign extended.
	 */

	a1 = prv_to_int32(p, a1, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(a2);
		return NULL;
	}
	a1 = subtilis_type_int32.asr(p, a1, a2, err);
	a1->type.type = SUBTILIS_TYPE_BYTE;
	return a1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
movq %rcx, %rdx
callq 0x3c119
cmpl $0x0, (%r14)
je 0x3c674
movq %rbx, %rdi
callq 0x2b166
xorl %eax, %eax
jmp 0x3c694
leaq 0x6a1d5(%rip), %r8      # 0xa6850
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq *0x1e0(%r8)
movl $0x6, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/byte_type_if.c
// Function: prv_abs
static subtilis_exp_t *prv_abs(subtilis_parser_t *p, subtilis_exp_t *e,
			       subtilis_error_t *err)
{
	/*
	 * This one needs to be sign extended.
	 */

	e = prv_to_int32(p, e, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	e = (subtilis_type_int32.abs)(p, e, err);
	e->type.type = SUBTILIS_TYPE_BYTE;
	return e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x3c119
cmpl $0x0, (%rbx)
je 0x3c6b2
xorl %eax, %eax
jmp 0x3c6ce
leaq 0x6a197(%rip), %rcx     # 0xa6850
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq *0x1e8(%rcx)
movl $0x6, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/byte_type_if.c
// Function: prv_swap_reg_mem
static void prv_swap_reg_mem(subtilis_parser_t *p, const subtilis_type_t *type,
			     size_t reg1, size_t reg2, subtilis_error_t *err)
{
	subtilis_ir_operand_t op1;
	subtilis_ir_operand_t op2;
	subtilis_ir_operand_t zero;
	subtilis_ir_operand_t tmp;

	op1.reg = reg1;
	op2.reg = reg2;
	zero.integer = 0;

	tmp.reg = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_MOV, op1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_instr_reg(
	    p->current, SUBTILIS_OP_INSTR_LOADO_I8, op1, op2, zero, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_instr_reg(
	    p->current, SUBTILIS_OP_INSTR_STOREO_I8, tmp, op2, zero, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rdi, %r15
movq 0x48(%rdi), %rdi
movl $0x1d, %esi
movq %r8, %rcx
callq 0x2be09
cmpl $0x0, (%rbx)
jne 0x3c8b4
movq %rax, %r12
movq 0x48(%r15), %rdi
movl $0x11, %esi
movq %r13, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x2bd42
cmpl $0x0, (%rbx)
je 0x3c8be
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x48(%r15), %rdi
movl $0x16, %esi
movq %r12, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
movq %rbx, %r9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2bd42
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/byte_type_if.c
// Function: prv_zerox
static subtilis_exp_t *prv_zerox(subtilis_parser_t *p, subtilis_exp_t *e,
				 subtilis_error_t *err)
{
	size_t reg;
	subtilis_ir_operand_t op;

	op.integer = 255;
	reg = subtilis_ir_section_add_instr(
	    p->current, SUBTILIS_OP_INSTR_ANDI_I32, e->exp.ir_op, op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	e->type.type = SUBTILIS_TYPE_INTEGER;
	e->exp.ir_op.reg = reg;
	return e;

on_error:

	subtilis_exp_delete(e);
	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq 0x148(%rsi), %rdx
movl $0xff, %ecx
movl $0x25, %esi
movq %r14, %r8
callq 0x2bc8f
cmpl $0x0, (%r14)
je 0x3c923
movq %rbx, %rdi
callq 0x2b166
xorl %ebx, %ebx
jmp 0x3c930
movl $0x5, (%rbx)
movq %rax, 0x148(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3c990
movq 0x48(%r12), %rdi
movq 0x148(%r14), %rdx
movq 0x148(%rbx), %rax
movl %ecx, %esi
movq %rax, %rcx
movq %r15, %r8
callq 0x2bc8f
cmpl $0x0, (%r15)
jne 0x3c9ad
movq %rax, 0x148(%r14)
movq %rbx, %rdi
callq 0x2b166
jmp 0x3c9c0
movl %r9d, %ebp
movq %r8, %r13
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3c119
movq %rax, %r14
cmpl $0x0, (%r15)
je 0x3c9d2
movq %r14, %rdi
callq 0x2b166
movq %rbx, %rdi
callq 0x2b166
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_O3/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 0x3ca46
movq 0x48(%r12), %rdi
movq 0x148(%r14), %rdx
movq 0x148(%rbx), %rax
movl %ecx, %esi
movq %rax, %rcx
movq %r15, %r8
callq 0x2bc8f
cmpl $0x0, (%r15)
jne 0x3ca60
movq %rax, 0x148(%r14)
movq %rbx, %rdi
callq 0x2b166
jmp 0x3ca73
movq %r8, %r13
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3c119
movq %rax, %r14
cmpl $0x0, (%r15)
je 0x3ca80
movq %r14, %rdi
callq 0x2b166
movq %rbx, %rdi
callq 0x2b166
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_O3/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 0x3cb18
movl %ecx, %ebp
movq 0x48(%r12), %rdi
movq %r15, %rdx
callq 0x3c8ee
movq %rax, %r14
cmpl $0x0, (%r15)
jne 0x3cb2f
movq 0x48(%r12), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3c8ee
movq %rax, %rbx
cmpl $0x0, (%r15)
jne 0x3cb2f
movq 0x48(%r12), %rdi
movq 0x148(%r14), %rdx
movq 0x148(%rbx), %rcx
movl %ebp, %esi
movq %r15, %r8
callq 0x2bc8f
cmpl $0x0, (%r15)
jne 0x3cb2f
movq %rax, 0x148(%r14)
movq %rbx, %rdi
callq 0x2b166
jmp 0x3cb42
movq %r8, %r13
movq %r12, %rdi
movq %r15, %rdx
callq 0x3c119
movq %rax, %r14
cmpl $0x0, (%r15)
je 0x3cb54
movq %r14, %rdi
callq 0x2b166
movq %rbx, %rdi
callq 0x2b166
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_O3/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 0x3c119
cmpl $0x0, (%rbx)
je 0x3cbaa
movq %r14, %rdi
callq 0x2b166
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_O3/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 0x2b7af
cmpl $0x0, (%rbx)
je 0x3cc03
movq %r14, %rdi
callq 0x2b166
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 0x371f8
// File: /workspace/github_c_makefile_star2_O3/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 0x3d27d
cmpl $0xb, %eax
jne 0x3d2b7
testq %r15, %r15
je 0x3d2f8
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x382c2(%rip), %rax     # 0x75557
movq %r12, %rdi
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
pushq $0xb7
pushq %rax
callq 0x14486
jmp 0x3d34b
movq %r14, %rdi
callq 0x37534
testb %al, %al
je 0x3d312
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x367cf
movq %rax, %r14
cmpl $0x0, (%r12)
jne 0x3d34f
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 0x448f4
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x44fa1
movq %r14, %rdi
callq 0x2f5ad
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3822a(%rip), %r10     # 0x75557
leaq 0x382ff(%rip), %rdx     # 0x75633
movq %r12, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0xc5
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %r15, %rdi
callq 0x2b166
movq %r14, %rdi
callq 0x2b166
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b166
// File: /workspace/github_c_makefile_star2_O3/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 0x3db4b
cmpl $0xc, %eax
jne 0x3db89
testq %r14, %r14
je 0x3dbe6
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x37ae9(%rip), %rax     # 0x75650
movq %r12, %rdi
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
pushq $0xa6
pushq %rax
callq 0x14486
jmp 0x3dc39
movq %r15, %rdi
callq 0x37534
testb %al, %al
je 0x3dc00
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x36119
movq %rax, %r15
cmpl $0x0, (%r12)
jne 0x3dc3d
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x36852
movq %rax, %r15
cmpl $0x0, (%r12)
jne 0x3dc3d
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 0x448f4
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x44fa1
movq %r15, %rdi
callq 0x2f5ad
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x37a35(%rip), %r10     # 0x75650
leaq 0x37a49(%rip), %rdx     # 0x7566b
movq %r12, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0xb7
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %r14, %rdi
callq 0x2b166
movq %r15, %rdi
callq 0x2b166
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b166
// File: /workspace/github_c_makefile_star2_O3/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 0x2b7af
cmpl $0x0, (%rbx)
je 0x3de03
movq %r14, %rdi
callq 0x2b166
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 0x371f8
// File: /workspace/github_c_makefile_star2_O3/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 0x3e47d
cmpl $0xa, %eax
jne 0x3e4b7
testq %r15, %r15
je 0x3e4f8
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x371ed(%rip), %rax     # 0x75682
movq %r12, %rdi
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
pushq $0xb7
pushq %rax
callq 0x14486
jmp 0x3e54b
movq %r14, %rdi
callq 0x37534
testb %al, %al
je 0x3e512
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3691a
movq %rax, %r14
cmpl $0x0, (%r12)
jne 0x3e54f
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 0x448f4
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x44fa1
movq %r14, %rdi
callq 0x2f5ad
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x37155(%rip), %r10     # 0x75682
leaq 0x3716c(%rip), %rdx     # 0x756a0
movq %r12, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0xc5
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %r15, %rdi
callq 0x2b166
movq %r14, %rdi
callq 0x2b166
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b166
// File: /workspace/github_c_makefile_star2_O3/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 0x36470(%rip), %rdi     # 0x74ba8
callq 0x482a4
movl %eax, %edi
movq %rbx, %rsi
callq 0x2b7af
cmpl $0x0, (%rbx)
je 0x3e75c
movq %r14, %rdi
callq 0x2b166
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 0x36bc7
// File: /workspace/github_c_makefile_star2_O3/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 0x37c3d
cmpl $0x0, (%r14)
jne 0x3e86c
movq 0x148(%rbx), %rax
movq %rax, 0x10(%rsp)
movq %r13, %rdi
callq 0x376d3
movb %al, 0xf(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4d71f
cmpl $0x0, (%r14)
jne 0x3e86c
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x342ba
cmpl $0x0, (%r14)
jne 0x3e86c
movq %r14, (%rsp)
movzbl 0xf(%rsp), %r8d
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r9d
callq 0x4cdcc
cmpl $0x0, (%r14)
jne 0x3e86c
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq 0x10(%rsp), %r8
movq %r14, %r9
callq 0x43434
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b166
// File: /workspace/github_c_makefile_star2_O3/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 0x43706
addq $0x10, %rsp
cmpl $0x0, (%r14)
je 0x3e914
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 0x4bec6
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2b166
// File: /workspace/github_c_makefile_star2_O3/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 0x3ef53
leaq 0x367c6(%rip), %rcx     # 0x756b8
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 0x448f4
testq %r15, %r15
je 0x3efb1
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x367a8(%rip), %rax     # 0x756dc
movq %r12, %rdi
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
pushq $0xff
pushq %rax
callq 0x14486
jmp 0x3ef8c
movq %r14, %rdi
callq 0x2f5ad
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3676e(%rip), %r10     # 0x756dc
leaq 0x36798(%rip), %rdx     # 0x7570d
movq %r12, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0x10b                  # imm = 0x10B
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %r15, %rdi
callq 0x2b166
movq %r14, %rdi
callq 0x2b166
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b166
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x453cf
// File: /workspace/github_c_makefile_star2_O3/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 0x2fab8
cmpl $0x0, (%r12)
je 0x3f34d
movq %rbx, %rdi
callq 0x2b166
jmp 0x3f388
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 0x43e73
addq $0x20, %rsp
movq %r14, %rdi
callq 0x2f56e
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2fab8
cmpl $0x0, (%r12)
je 0x3f463
xorl %ebx, %ebx
jmp 0x3f49f
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 0x43f1b
addq $0x20, %rsp
movq %rax, %rbx
movq %r13, %rdi
callq 0x2f56e
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_O3/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 0x360be
cmpl $0x0, (%rbx)
jne 0x3f538
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x35e20
movq %rax, %r13
cmpl $0x0, (%rbx)
jne 0x3f526
movq 0x148(%r13), %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %r8
callq 0x306b0
leaq 0x8(%rsp), %rdi
callq 0x2f56e
movq %r13, %rdi
callq 0x2b166
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3fa98
cmpl $0x14, %eax
je 0x3fa5d
cmpl $0xe, %eax
jne 0x3fab5
testq %r15, %r15
je 0x3fb13
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x35caf(%rip), %rax     # 0x75728
movq %r12, %rdi
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
pushq $0xe0
pushq %rax
callq 0x14486
jmp 0x3faee
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 0x448f4
movq %r14, %rdi
callq 0x2f5ad
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x35c58(%rip), %r10     # 0x75728
leaq 0x35c9a(%rip), %rdx     # 0x75771
movq %r12, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0xeb
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %r15, %rdi
callq 0x2b166
movq %r14, %rdi
callq 0x2b166
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b166
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x44fa1
// File: /workspace/github_c_makefile_star2_O3/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 0x2fb07
cmpl $0x0, (%r14)
jne 0x3fd06
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x2fee3
movq %rax, %r13
movq %r12, %rdi
callq 0x2f56e
movl %r13d, %edi
movq %r14, %rsi
callq 0x2b7af
cmpl $0x0, (%r14)
je 0x3fd21
movq %rbx, %rdi
callq 0x2b166
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 0x36bc7
jmp 0x3fd10
// File: /workspace/github_c_makefile_star2_O3/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 0x37c3d
cmpl $0x0, (%r14)
jne 0x3fe72
leaq 0x20(%rsp), %rdx
movl $0x8, (%rdx)
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rcx
callq 0x360be
cmpl $0x0, (%r14)
jne 0x3fe72
leaq 0x20(%rsp), %rdi
callq 0x30171
testb %al, %al
je 0x3fe8c
movq 0x148(%rbx), %rax
movq %rax, 0x18(%rsp)
movq %r13, %rdi
callq 0x376d3
movb %al, 0x17(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4d71f
cmpl $0x0, (%r14)
jne 0x3fe68
leaq 0x20(%rsp), %rsi
movq %rbp, %rdi
movq %rax, %rdx
movq %r14, %rcx
callq 0x344e3
cmpl $0x0, (%r14)
jne 0x3fe68
movq %r14, (%rsp)
movzbl 0x17(%rsp), %r8d
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0x18(%rsp), %rcx
movl $0x1, %r9d
callq 0x4cdcc
cmpl $0x0, (%r14)
jne 0x3fe68
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq 0x18(%rsp), %r8
movq %r14, %r9
callq 0x43434
leaq 0x20(%rsp), %rdi
callq 0x2f56e
movq %rbx, %rdi
callq 0x2b166
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %rdi
callq 0x2f56e
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
movq %r14, %r9
callq 0x433d5
jmp 0x3fe7a
// File: /workspace/github_c_makefile_star2_O3/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 0x2faf8
cmpl $0x0, (%rbx)
jne 0x3ff43
movq %rsp, %r13
movq %r13, %rdi
callq 0x2ff1c
movl %eax, %ebp
movq %r13, %rdi
callq 0x2f56e
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
testb %bpl, %bpl
je 0x3ff3b
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x4e974
jmp 0x3ff43
movq %rbx, %rcx
callq 0x4ec49
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2faf8
cmpl $0x0, (%r15)
jne 0x40003
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 0x37860
movq %rax, %rbx
cmpl $0x0, (%r15)
jne 0x3fff9
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 0x43e73
addq $0x20, %rsp
leaq 0x20(%rsp), %rdi
callq 0x2f56e
movq %rbx, %rdi
callq 0x2b166
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x43706
addq $0x10, %rsp
cmpl $0x0, (%r14)
jne 0x400e7
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x360be
cmpl $0x0, (%r14)
je 0x400e9
movq %rbx, %rdi
callq 0x2b166
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x360be
cmpl $0x0, (%rbx)
jne 0x40289
leaq 0x10(%rsp), %rdi
callq 0x30011
testb %al, %al
je 0x40165
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r12, %rcx
movq %rbx, %r8
callq 0x3095f
jmp 0x4027f
movq 0x48(%r14), %rdi
callq 0x2cc99
movq %rax, %r13
movq 0x48(%r14), %rdi
callq 0x2cc99
movq %rax, 0x8(%rsp)
movq 0x48(%r14), %rdi
movl $0x1d, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2be09
cmpl $0x0, (%rbx)
jne 0x4027f
movq %rax, %rbp
movq 0x48(%r14), %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
movq %rbx, %r8
callq 0x2bc8f
cmpl $0x0, (%rbx)
jne 0x4027f
movq %rax, %r15
movq 0x48(%r14), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2cca6
cmpl $0x0, (%rbx)
jne 0x4027f
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %rbp, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x45c2d
cmpl $0x0, (%rbx)
jne 0x4027f
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq %rax, %r12
leaq 0x10(%rsp), %rdi
callq 0x2fee3
movq 0x48(%r14), %rdi
movl %eax, %r8d
orq %r12, %r8
movl $0x9, %esi
movq %rbp, %rdx
movq %rbp, %rcx
movq %rbx, %r9
callq 0x2bd42
cmpl $0x0, (%rbx)
jne 0x4027f
movq 0x48(%r14), %rdi
movl $0x3b, %esi
movq %rbp, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x2bc8f
cmpl $0x0, (%rbx)
jne 0x4027f
movq 0x48(%r14), %rdi
movl $0x43, %esi
movq %rax, %rdx
movq %r13, %rcx
movq 0x8(%rsp), %r8
movq %rbx, %r9
callq 0x2bd42
cmpl $0x0, (%rbx)
jne 0x4027f
movq 0x48(%r14), %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x2cca6
leaq 0x10(%rsp), %rdi
callq 0x2f56e
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x360be
movq $-0x1, %r12
cmpl $0x0, (%rbx)
jne 0x407d8
movq %rsp, %rdi
callq 0x30171
testb %al, %al
je 0x407bf
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x34303
jmp 0x407cd
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x37cc7
movq %rax, %r12
movq %rsp, %rdi
callq 0x2f56e
movq %r12, %rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4084b
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 0x448f4
testq %r12, %r12
je 0x40886
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x34f25(%rip), %rax     # 0x75788
movq %r15, %rdi
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
pushq $0x165                  # imm = 0x165
pushq %rax
callq 0x14486
addq $0x10, %rsp
jmp 0x408a1
movq %rsp, %rdi
movl $0x8, (%rdi)
leaq 0x38(%r14), %rsi
movq %r15, %rdx
callq 0x2faf8
cmpl $0x0, (%r15)
je 0x408cb
movq %r12, %rdi
callq 0x2b166
movq %r14, %rdi
callq 0x2b166
movq %rbx, %rdi
callq 0x2b166
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 0x30171
movl %eax, %ebp
movq %r12, %rdi
callq 0x2f56e
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
testb %bpl, %bpl
je 0x408f8
callq 0x453cf
jmp 0x408b9
callq 0x44fa1
jmp 0x408b9