LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/byte_type_if.c
// Function: prv_div
static subtilis_exp_t *prv_div(subtilis_parser_t *p, subtilis_exp_t *a1,
			       subtilis_exp_t *a2, subtilis_error_t *err)
{
	a1 = prv_to_int32(p, a1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	return subtilis_type_int32.div(p, a1, a2, err);

on_error:

	subtilis_exp_delete(a2);
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
movq %rcx, %rdx
callq 0x39f21
cmpl $0x0, (%r14)
je 0x3a2f6
movq %rbx, %rdi
callq 0x29d88
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6c553(%rip), %rcx     # 0xa6850
movq 0x190(%rcx), %r8
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmpq *%r8
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/byte_type_if.c
// Function: prv_mod
static subtilis_exp_t *prv_mod(subtilis_parser_t *p, subtilis_exp_t *a1,
			       subtilis_exp_t *a2, subtilis_error_t *err)
{
	a1 = prv_to_int32(p, a1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	return subtilis_type_int32.mod(p, a1, a2, err);

on_error:

	subtilis_exp_delete(a2);
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
movq %rcx, %rdx
callq 0x39f21
cmpl $0x0, (%r14)
je 0x3a344
movq %rbx, %rdi
callq 0x29d88
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6c505(%rip), %rcx     # 0xa6850
movq 0x198(%rcx), %r8
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmpq *%r8
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/byte_type_if.c
// Function: prv_lsl
static subtilis_exp_t *prv_lsl(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.lsl(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 0x6c45c(%rip), %rax     # 0xa6850
callq *0x1d0(%rax)
cmpl $0x0, (%rbx)
je 0x3a403
xorl %eax, %eax
jmp 0x3a409
movl $0x6, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6c434(%rip), %rax     # 0xa6850
callq *0x1d8(%rax)
cmpl $0x0, (%rbx)
je 0x3a42b
xorl %eax, %eax
jmp 0x3a431
movl $0x6, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x39f21
cmpl $0x0, (%r14)
je 0x3a45b
movq %rbx, %rdi
callq 0x29d88
xorl %eax, %eax
jmp 0x3a47b
leaq 0x6c3ee(%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_O2/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 0x39f21
cmpl $0x0, (%rbx)
je 0x3a499
xorl %eax, %eax
jmp 0x3a4b5
leaq 0x6c3b0(%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_O2/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
pushq $0x1d
popq %rsi
movq %r8, %rcx
callq 0x2a981
cmpl $0x0, (%rbx)
jne 0x3a68c
movq %rax, %r12
movq 0x48(%r15), %rdi
pushq $0x11
popq %rsi
movq %r13, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x2a8c1
cmpl $0x0, (%rbx)
je 0x3a696
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x48(%r15), %rdi
pushq $0x16
popq %rsi
movq %r12, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
movq %rbx, %r9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2a8c1
// File: /workspace/github_c_makefile_star2_O2/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 0x48(%rdi), %rdi
movq 0x148(%rsi), %rdx
pushq $0x25
popq %rsi
movl $0xff, %ecx
movq %r14, %r8
callq 0x2a819
cmpl $0x0, (%r14)
je 0x3a6fb
movq %rbx, %rdi
callq 0x29d88
xorl %ebx, %ebx
jmp 0x3a708
movl $0x5, (%rbx)
movq %rax, 0x148(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3a768
movq 0x48(%r12), %rdi
movq 0x148(%r14), %rdx
movq 0x148(%rbx), %rax
movl %ecx, %esi
movq %rax, %rcx
movq %r15, %r8
callq 0x2a819
cmpl $0x0, (%r15)
jne 0x3a785
movq %rax, 0x148(%r14)
movq %rbx, %rdi
callq 0x29d88
jmp 0x3a798
movl %r9d, %ebp
movq %r8, %r13
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x39f21
movq %rax, %r14
cmpl $0x0, (%r15)
je 0x3a7aa
movq %r14, %rdi
callq 0x29d88
movq %rbx, %rdi
callq 0x29d88
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_O2/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 0x3a81e
movq 0x48(%r12), %rdi
movq 0x148(%r14), %rdx
movq 0x148(%rbx), %rax
movl %ecx, %esi
movq %rax, %rcx
movq %r15, %r8
callq 0x2a819
cmpl $0x0, (%r15)
jne 0x3a838
movq %rax, 0x148(%r14)
movq %rbx, %rdi
callq 0x29d88
jmp 0x3a84b
movq %r8, %r13
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x39f21
movq %rax, %r14
cmpl $0x0, (%r15)
je 0x3a858
movq %r14, %rdi
callq 0x29d88
movq %rbx, %rdi
callq 0x29d88
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_O2/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 0x3a8ec
movl %ecx, %ebp
movq %r12, %rdi
movq %r15, %rdx
callq 0x3a6c4
movq %rax, %r14
cmpl $0x0, (%r15)
jne 0x3a903
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3a6c4
movq %rax, %rbx
cmpl $0x0, (%r15)
jne 0x3a903
movq 0x48(%r12), %rdi
movq 0x148(%r14), %rdx
movq 0x148(%rbx), %rcx
movl %ebp, %esi
movq %r15, %r8
callq 0x2a819
cmpl $0x0, (%r15)
jne 0x3a903
movq %rax, 0x148(%r14)
movq %rbx, %rdi
callq 0x29d88
jmp 0x3a916
movq %r8, %r13
movq %r12, %rdi
movq %r15, %rdx
callq 0x39f21
movq %rax, %r14
cmpl $0x0, (%r15)
je 0x3a928
movq %r14, %rdi
callq 0x29d88
movq %rbx, %rdi
callq 0x29d88
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_O2/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 0x39f21
cmpl $0x0, (%rbx)
je 0x3a97e
movq %r14, %rdi
callq 0x29d88
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_O2/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
pushq $0x2
popq %rdi
movq %rcx, %rsi
callq 0x2a369
cmpl $0x0, (%rbx)
je 0x3a9d3
movq %r14, %rdi
callq 0x29d88
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 0x3531d
// File: /workspace/github_c_makefile_star2_O2/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 0x3b002
cmpl $0xb, %eax
jne 0x3b036
testq %r15, %r15
je 0x3b077
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x344c9(%rip), %rax     # 0x6f4e3
pushq $0x29
popq %rsi
pushq $0x3
popq %rdx
pushq $0x2
popq %rcx
movq %r12, %rdi
pushq $0xb7
pushq %rax
callq 0x14179
jmp 0x3b0c8
movq %r14, %rdi
callq 0x35655
testb %al, %al
je 0x3b091
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x347d5
movq %rax, %r14
cmpl $0x0, (%r12)
jne 0x3b0ca
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 0x42173
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x427cf
movq %r14, %rdi
callq 0x2dcbb
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x34437(%rip), %r10     # 0x6f4e3
leaq 0x3450c(%rip), %rdx     # 0x6f5bf
pushq $0x1d
popq %rsi
movq %r12, %rdi
movq %rax, %rcx
pushq $0xc5
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %r15, %rdi
callq 0x29d88
movq %r14, %rdi
callq 0x29d88
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x29d88
// File: /workspace/github_c_makefile_star2_O2/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 0x3b86e
cmpl $0xc, %eax
jne 0x3b8a6
testq %r14, %r14
je 0x3b903
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x33d52(%rip), %rax     # 0x6f5dc
pushq $0x29
popq %rsi
pushq $0x3
popq %rdx
pushq $0x2
popq %rcx
movq %r12, %rdi
pushq $0xa6
pushq %rax
callq 0x14179
jmp 0x3b954
movq %r15, %rdi
callq 0x35655
testb %al, %al
je 0x3b91d
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3415f
movq %rax, %r15
cmpl $0x0, (%r12)
jne 0x3b956
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x34854
movq %rax, %r15
cmpl $0x0, (%r12)
jne 0x3b956
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 0x42173
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x427cf
movq %r15, %rdi
callq 0x2dcbb
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x33ca4(%rip), %r10     # 0x6f5dc
leaq 0x33cb8(%rip), %rdx     # 0x6f5f7
pushq $0x1d
popq %rsi
movq %r12, %rdi
movq %rax, %rcx
pushq $0xb7
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %r14, %rdi
callq 0x29d88
movq %r15, %rdi
callq 0x29d88
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x29d88
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x3
popq %rdi
movq %rcx, %rsi
callq 0x2a369
cmpl $0x0, (%rbx)
je 0x3bb0b
movq %r14, %rdi
callq 0x29d88
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 0x3531d
// File: /workspace/github_c_makefile_star2_O2/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 0x3c13a
cmpl $0xa, %eax
jne 0x3c16e
testq %r15, %r15
je 0x3c1af
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x334bc(%rip), %rax     # 0x6f60e
pushq $0x29
popq %rsi
pushq $0x3
popq %rdx
pushq $0x2
popq %rcx
movq %r12, %rdi
pushq $0xb7
pushq %rax
callq 0x14179
jmp 0x3c200
movq %r14, %rdi
callq 0x35655
testb %al, %al
je 0x3c1c9
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x34916
movq %rax, %r14
cmpl $0x0, (%r12)
jne 0x3c202
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 0x42173
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x427cf
movq %r14, %rdi
callq 0x2dcbb
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3342a(%rip), %r10     # 0x6f60e
leaq 0x33441(%rip), %rdx     # 0x6f62c
pushq $0x1d
popq %rsi
movq %r12, %rdi
movq %rax, %rcx
pushq $0xc5
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %r15, %rdi
callq 0x29d88
movq %r14, %rdi
callq 0x29d88
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x29d88
// File: /workspace/github_c_makefile_star2_O2/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 0x3277e(%rip), %rdi     # 0x6eb58
callq 0x4597e
movl %eax, %edi
movq %rbx, %rsi
callq 0x2a369
cmpl $0x0, (%rbx)
je 0x3c3fe
movq %r14, %rdi
callq 0x29d88
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 0x34bfb
// File: /workspace/github_c_makefile_star2_O2/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 0x35d40
cmpl $0x0, (%r14)
jne 0x3c508
movq 0x148(%rbx), %rax
movq %rax, 0x10(%rsp)
movq %r13, %rdi
callq 0x357ea
movb %al, 0xf(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4ab28
cmpl $0x0, (%r14)
jne 0x3c508
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x32bcd
cmpl $0x0, (%r14)
jne 0x3c508
movq %r14, (%rsp)
movzbl 0xf(%rsp), %r8d
pushq $0x1
popq %r9
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0x10(%rsp), %rcx
callq 0x4a250
cmpl $0x0, (%r14)
jne 0x3c508
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq 0x10(%rsp), %r8
movq %r14, %r9
callq 0x40e00
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29d88
// File: /workspace/github_c_makefile_star2_O2/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 0x4108f
addq $0x10, %rsp
cmpl $0x0, (%r14)
je 0x3c5ae
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 0x493b7
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x29d88
// File: /workspace/github_c_makefile_star2_O2/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 0x3cb9b
leaq 0x32b04(%rip), %rcx     # 0x6f644
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 0x42173
testq %r15, %r15
je 0x3cbf5
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x32ae6(%rip), %rax     # 0x6f668
pushq $0x29
popq %rsi
pushq $0x3
popq %rdx
pushq $0x2
popq %rcx
movq %r12, %rdi
pushq $0xff
pushq %rax
callq 0x14179
jmp 0x3cbd2
movq %r14, %rdi
callq 0x2dcbb
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x32ab2(%rip), %r10     # 0x6f668
leaq 0x32adc(%rip), %rdx     # 0x6f699
pushq $0x1d
popq %rsi
movq %r12, %rdi
movq %rax, %rcx
pushq $0x10b                  # imm = 0x10B
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %r15, %rdi
callq 0x29d88
movq %r14, %rdi
callq 0x29d88
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x29d88
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x42be3
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/array_fn_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;

	/*
	 * TODO: This is a pointer really not a 32 bit int.
	 */

	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
pushq $0x2
popq %rdi
movq %rcx, %rsi
callq 0x2a369
cmpl $0x0, (%rbx)
je 0x3ceaf
movq %r14, %rdi
callq 0x29d88
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 0x3531d
// File: /workspace/github_c_makefile_star2_O2/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 0x2e190
cmpl $0x0, (%r12)
je 0x3cf7b
movq %rbx, %rdi
callq 0x29d88
jmp 0x3cfb6
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 0x41747
addq $0x20, %rsp
movq %r14, %rdi
callq 0x2dc7c
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2e190
cmpl $0x0, (%r12)
je 0x3d089
xorl %ebx, %ebx
jmp 0x3d0c5
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 0x417ed
addq $0x20, %rsp
movq %rax, %rbx
movq %r13, %rdi
callq 0x2dc7c
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_O2/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 0x34108
cmpl $0x0, (%rbx)
jne 0x3d15e
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x33e86
movq %rax, %r13
cmpl $0x0, (%rbx)
jne 0x3d14c
movq 0x148(%r13), %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %r8
callq 0x2ebb4
leaq 0x8(%rsp), %rdi
callq 0x2dc7c
movq %r13, %rdi
callq 0x29d88
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3d673
cmpl $0x14, %eax
je 0x3d63e
cmpl $0xe, %eax
jne 0x3d690
testq %r15, %r15
je 0x3d6ea
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x3205a(%rip), %rax     # 0x6f6b4
pushq $0x29
popq %rsi
pushq $0x3
popq %rdx
pushq $0x2
popq %rcx
movq %r12, %rdi
pushq $0xe0
pushq %rax
callq 0x14179
jmp 0x3d6c7
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 0x42173
movq %r14, %rdi
callq 0x2dcbb
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x32009(%rip), %r10     # 0x6f6b4
leaq 0x3204b(%rip), %rdx     # 0x6f6fd
pushq $0x1d
popq %rsi
movq %r12, %rdi
movq %rax, %rcx
pushq $0xeb
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %r15, %rdi
callq 0x29d88
movq %r14, %rdi
callq 0x29d88
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x29d88
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x427cf
// File: /workspace/github_c_makefile_star2_O2/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 0x2e1d4
cmpl $0x0, (%r14)
jne 0x3d8cc
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x2e586
movq %rax, %r13
movq %r12, %rdi
callq 0x2dc7c
movl %r13d, %edi
movq %r14, %rsi
callq 0x2a369
cmpl $0x0, (%r14)
je 0x3d8e7
movq %rbx, %rdi
callq 0x29d88
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 0x34bfb
jmp 0x3d8d6
// File: /workspace/github_c_makefile_star2_O2/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 0x35d40
cmpl $0x0, (%r14)
jne 0x3da32
leaq 0x20(%rsp), %rdx
movl $0x8, (%rdx)
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rcx
callq 0x34108
cmpl $0x0, (%r14)
jne 0x3da32
leaq 0x20(%rsp), %rdi
callq 0x2e7c9
testb %al, %al
je 0x3da4c
movq 0x148(%rbx), %rax
movq %rax, 0x18(%rsp)
movq %r13, %rdi
callq 0x357ea
movb %al, 0x17(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4ab28
cmpl $0x0, (%r14)
jne 0x3da28
leaq 0x20(%rsp), %rsi
movq %rbp, %rdi
movq %rax, %rdx
movq %r14, %rcx
callq 0x32dec
cmpl $0x0, (%r14)
jne 0x3da28
movq %r14, (%rsp)
movzbl 0x17(%rsp), %r8d
pushq $0x1
popq %r9
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0x18(%rsp), %rcx
callq 0x4a250
cmpl $0x0, (%r14)
jne 0x3da28
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq 0x18(%rsp), %r8
movq %r14, %r9
callq 0x40e00
leaq 0x20(%rsp), %rdi
callq 0x2dc7c
movq %rbx, %rdi
callq 0x29d88
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %rdi
callq 0x2dc7c
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
movq %r14, %r9
callq 0x40da1
jmp 0x3da3a
// File: /workspace/github_c_makefile_star2_O2/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 0x2e1c5
cmpl $0x0, (%rbx)
jne 0x3db01
movq %rsp, %r13
movq %r13, %rdi
callq 0x2e5bf
movl %eax, %ebp
movq %r13, %rdi
callq 0x2dc7c
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
testb %bpl, %bpl
je 0x3daf9
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x4bc20
jmp 0x3db01
movq %rbx, %rcx
callq 0x4bee7
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2e1c5
cmpl $0x0, (%r15)
jne 0x3dbc1
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 0x35977
movq %rax, %rbx
cmpl $0x0, (%r15)
jne 0x3dbb7
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 0x41747
addq $0x20, %rsp
leaq 0x20(%rsp), %rdi
callq 0x2dc7c
movq %rbx, %rdi
callq 0x29d88
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4108f
addq $0x10, %rsp
cmpl $0x0, (%r14)
jne 0x3dc9d
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x34108
cmpl $0x0, (%r14)
je 0x3dc9f
movq %rbx, %rdi
callq 0x29d88
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r13
movq %rdx, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %rdx
movq %r8, %rcx
callq 0x34108
cmpl $0x0, (%rbx)
jne 0x3de37
leaq 0x10(%rsp), %rdi
callq 0x2e67a
testb %al, %al
je 0x3dd1b
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r13, %rcx
movq %rbx, %r8
callq 0x2ee2d
jmp 0x3de2d
movq 0x48(%r14), %rdi
callq 0x2b774
movq %rax, %r12
movq 0x48(%r14), %rdi
callq 0x2b774
movq %rax, 0x8(%rsp)
movq 0x48(%r14), %rdi
pushq $0x1d
popq %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2a981
cmpl $0x0, (%rbx)
jne 0x3de2d
movq %rax, %rbp
movq 0x48(%r14), %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r13, %rcx
movq %rbx, %r8
callq 0x2a819
cmpl $0x0, (%rbx)
jne 0x3de2d
movq %rax, %r15
movq 0x48(%r14), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2b781
cmpl $0x0, (%rbx)
jne 0x3de2d
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %rbp, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x433f5
cmpl $0x0, (%rbx)
jne 0x3de2d
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq %rax, %r13
leaq 0x10(%rsp), %rdi
callq 0x2e586
movq 0x48(%r14), %rdi
movl %eax, %r8d
orq %r13, %r8
pushq $0x9
popq %rsi
movq %rbp, %rdx
movq %rbp, %rcx
movq %rbx, %r9
callq 0x2a8c1
cmpl $0x0, (%rbx)
jne 0x3de2d
movq 0x48(%r14), %rdi
pushq $0x3b
popq %rsi
movq %rbp, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x2a819
cmpl $0x0, (%rbx)
jne 0x3de2d
movq 0x48(%r14), %rdi
pushq $0x43
popq %rsi
movq %rax, %rdx
movq %r12, %rcx
movq 0x8(%rsp), %r8
movq %rbx, %r9
callq 0x2a8c1
cmpl $0x0, (%rbx)
jne 0x3de2d
movq 0x48(%r14), %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x2b781
leaq 0x10(%rsp), %rdi
callq 0x2dc7c
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
movl $0x8, (%rdx)
movq %rbx, %rcx
callq 0x34108
cmpl $0x0, (%rbx)
je 0x3e309
pushq $-0x1
popq %rbx
jmp 0x3e344
leaq 0x8(%rsp), %rdi
callq 0x2e7c9
testb %al, %al
je 0x3e329
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x32c1f
jmp 0x3e337
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x35d83
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2dc7c
movq %rbx, %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %r15
retq