LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: subtilis_arm_reg_alloc_alloc
void subtilis_arm_reg_alloc_alloc(subtilis_arm_reg_ud_t *ud,
				  subtilis_arm_op_t *current,
				  subtilis_arm_reg_class_t *int_regs,
				  subtilis_arm_reg_class_t *regs,
				  subtilis_arm_reg_t *reg,
				  subtilis_arm_reg_t restricted,
				  subtilis_error_t *err)
{
	size_t assigned;
	size_t virt_num = *reg;

	if (regs->is_fixed(*reg)) {
		if (*reg >= regs->max_regs)
			return;
		prv_allocate_fixed(ud, current, int_regs, regs, reg, err);
	} else {
		assigned = prv_virt_to_phys(regs, reg);
		if (assigned != INT_MAX) {
			*reg = assigned;
		} else {
			prv_allocate_floating(ud, current, int_regs, regs, reg,
					      restricted, err);
		}
	}

	if (err->type != SUBTILIS_ERROR_OK)
		return;

	regs->phys_to_virt[*reg] = virt_num;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbp
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r13
movq %rdi, %r12
movq (%r8), %r15
movq %r15, %rdi
callq *0x70(%rcx)
testb %al, %al
je 0x4fae3
movq (%rbx), %rax
cmpq (%r14), %rax
jae 0x4fb2e
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq 0x40(%rsp), %r12
movq %r12, %r8
callq 0x4fb3d
jmp 0x4fb1c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4fb6d
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jne 0x4fb14
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %rbp, %r8
movq 0x40(%rsp), %r12
movq %r12, %r9
callq 0x4fb8f
jmp 0x4fb1c
movq %rax, (%rbx)
movq 0x40(%rsp), %r12
cmpl $0x0, (%r12)
jne 0x4fb2e
movq 0x8(%r14), %rax
movq (%rbx), %rcx
movq %r15, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_allocate_floating
static void
prv_allocate_floating(subtilis_arm_reg_ud_t *ud, subtilis_arm_op_t *current,
		      subtilis_arm_reg_class_t *int_regs,
		      subtilis_arm_reg_class_t *regs, subtilis_arm_reg_t *reg,
		      subtilis_arm_reg_t restricted, subtilis_error_t *err)
{
	subtilis_arm_reg_t target_reg;
	int i;
	int next = regs->max_regs;
	int max_next = -1;

	/* Virtual register is not already assigned. */

	for (i = regs->max_regs - 1; i >= 0; i--)
		if ((regs->phys_to_virt[i] == INT_MAX) &&
		    (restricted == SIZE_MAX || restricted != i))
			break;

	if (i >= 0) {
		target_reg = (size_t)i;
	} else {
		/* No free physical regs.  Need to spill. */

		for (i = 0; i < regs->max_regs; i++)
			if ((regs->next[i] > max_next) &&
			    (restricted == SIZE_MAX || restricted != i)) {
				max_next = regs->next[i];
				next = i;
			}
		if (next == regs->max_regs) {
			subtilis_error_set_assertion_failed(err);
			return;
		}
		target_reg = next;
		prv_spill_reg(ud, current, regs->phys_to_virt[next], int_regs,
			      regs, target_reg, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

	*reg = target_reg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %r14
movq %rcx, %rbx
movq %rdx, %rcx
movq (%rdx), %rax
movl %eax, %edx
movl %eax, %r9d
decq %r9
testl %r9d, %r9d
js 0x4fbd4
movl %r9d, %r15d
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
decq %r9
cmpq %r8, %r15
je 0x4fbaa
movq 0x8(%rcx), %r10
cmpq $0x7fffffff, (%r10,%r15,8) # imm = 0x7FFFFFFF
jne 0x4fbaa
movq %r15, (%rbx)
jmp 0x4fc48
pushq $-0x1
popq %r10
xorl %r9d, %r9d
cmpq %r9, %rax
je 0x4fc06
movq 0x10(%rcx), %r11
movl (%r11,%r9,4), %r11d
cmpl %r10d, %r11d
setle %bpl
cmpq %r9, %r8
sete %r15b
orb %bpl, %r15b
jne 0x4fc01
movl %r9d, %edx
movl %r11d, %r10d
incq %r9
jmp 0x4fbdb
movslq %edx, %r15
cmpq %r15, %rax
jne 0x4fc2f
leaq 0x1ff96(%rip), %rdx     # 0x6fbab
pushq $0xf
popq %rsi
movq %r14, %rdi
movl $0x33a, %ecx            # imm = 0x33A
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1429e
movq 0x8(%rcx), %rax
movq (%rax,%r15,8), %rdx
movq %r15, %r8
movq %r14, %r9
callq 0x51be1
cmpl $0x0, (%r14)
je 0x4fbcf
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: subtilis_arm_reg_alloc_ensure
bool subtilis_arm_reg_alloc_ensure(subtilis_arm_reg_ud_t *ud,
				   subtilis_arm_op_t *current,
				   subtilis_arm_reg_class_t *int_regs,
				   subtilis_arm_reg_class_t *regs,
				   subtilis_arm_reg_t *reg,
				   subtilis_error_t *err)
{
	size_t assigned;
	subtilis_arm_reg_t target_reg;

	if (regs->is_fixed(*reg)) {
		/*
		 * Register has fixed use and is unavailable to user's code
		 * Physical register has already been allocated, e.g., r12, r13
		 */
		if (*reg >= regs->max_regs)
			return true;

		assigned = regs->phys_to_virt[*reg];
		if (assigned != *reg) {
			prv_allocate_fixed(ud, current, int_regs, regs, reg,
					   err);
			if (err->type != SUBTILIS_ERROR_OK)
				return false;
			prv_load_spilled_reg(ud, current, regs, *reg, *reg,
					     err);
			if (err->type != SUBTILIS_ERROR_OK)
				return false;
		}
	} else {
		assigned = prv_virt_to_phys(regs, reg);
		if (assigned != INT_MAX) {
			*reg = assigned;
		} else {
			target_reg = *reg;
			prv_allocate_floating(ud, current, int_regs, regs,
					      &target_reg, SIZE_MAX, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return false;
			prv_load_spilled_reg(ud, current, regs, *reg,
					     target_reg, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return false;
			*reg = target_reg;
		}
	}

	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq (%r8), %rdi
callq *0x70(%rcx)
testb %al, %al
je 0x4fcc5
movq (%r14), %rcx
movb $0x1, %al
cmpq (%r15), %rcx
jae 0x4fd25
movq 0x8(%r15), %rax
cmpq %rcx, (%rax,%rcx,8)
je 0x4fd23
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x4fb3d
cmpl $0x0, (%rbx)
jne 0x4fd23
movq (%r14), %rcx
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rcx, %r8
movq %rbx, %r9
callq 0x4fd34
jmp 0x4fd23
movq %r15, %rdi
movq %r14, %rsi
callq 0x4fb6d
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jne 0x4fd20
movq (%r14), %rax
movq %rsp, %rcx
movq %rax, (%rcx)
pushq $-0x1
popq %r8
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %r9
callq 0x4fb8f
cmpl $0x0, (%rbx)
jne 0x4fd23
movq (%r14), %rcx
movq (%rsp), %rbp
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbp, %r8
movq %rbx, %r9
callq 0x4fd34
cmpl $0x0, (%rbx)
jne 0x4fd23
movq %rbp, (%r14)
jmp 0x4fd23
movq %rax, (%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_load_spilled_reg
static void prv_load_spilled_reg(subtilis_arm_reg_ud_t *ud,
				 subtilis_arm_op_t *current,
				 subtilis_arm_reg_class_t *regs,
				 subtilis_arm_reg_t virt,
				 subtilis_arm_reg_t phys, subtilis_error_t *err)
{
	int i;
	size_t pos;
	subtilis_arm_section_t *arm_s = ud->arm_s;
	int32_t basic_offset = regs->spilt_regs[virt];

	if (basic_offset == INT_MAX) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	if (regs->spill_top == 0) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	if (current->prev == SIZE_MAX)
		pos = arm_s->first_op;
	else
		pos = arm_s->op_pool->ops[current->prev].next;

	prv_add_spill_point(regs, SUBTILIS_SPILL_POINT_LOAD, pos, basic_offset,
			    phys, err);

	regs->phys_to_virt[phys] = virt;
	regs->spilt_regs[virt] = INT_MAX;
	i = basic_offset / regs->reg_size;
	regs->spill_stack[i] = basic_offset;
	if (i == regs->spill_top - 1) {
		regs->spill_top--;
		for (i = i - 1; i >= 0; i--) {
			if (regs->spill_stack[i] == INT_MAX)
				break;
			regs->spill_top--;
		}
	}
	regs->next[phys] = -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x20(%rdx), %rax
movslq (%rax,%rcx,4), %r15
cmpq $0x7fffffff, %r15       # imm = 0x7FFFFFFF
jne 0x4fd61
leaq 0x1fe57(%rip), %rdx     # 0x6fbab
pushq $0xf
popq %rsi
movq %r9, %rdi
movl $0x2c0, %ecx            # imm = 0x2C0
jmp 0x4fda5
movq %rdx, %r14
cmpq $0x0, 0x30(%rdx)
je 0x4fd93
movq %r8, %rbx
movq %rcx, %r12
movq 0x18(%rdi), %rax
movq 0x60(%rsi), %rcx
cmpq $-0x1, %rcx
je 0x4fdb5
movq 0x38(%rax), %rax
movq (%rax), %rax
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
addq $0x58, %rax
jmp 0x4fdb9
leaq 0x1fe11(%rip), %rdx     # 0x6fbab
pushq $0xf
popq %rsi
movq %r9, %rdi
movl $0x2c5, %ecx            # imm = 0x2C5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1429e
addq $0x20, %rax
movq (%rax), %rdx
movq %r14, %rdi
xorl %esi, %esi
movl %r15d, %ecx
movq %rbx, %r8
callq 0x51c89
movq 0x8(%r14), %rax
movq %r12, (%rax,%rbx,8)
movq 0x20(%r14), %rax
movl $0x7fffffff, (%rax,%r12,4) # imm = 0x7FFFFFFF
movq %r15, %rax
xorl %edx, %edx
divq 0x40(%r14)
movq 0x28(%r14), %rcx
movslq %eax, %rsi
movq %r15, (%rcx,%rsi,8)
movq 0x30(%r14), %rdx
decq %rdx
cmpq %rdx, %rsi
jne 0x4fe1c
movl %eax, %eax
movq %rdx, 0x30(%r14)
testl %eax, %eax
jle 0x4fe1c
decq %rdx
cmpq $0x7fffffff, -0x8(%rcx,%rax,8) # imm = 0x7FFFFFFF
leaq -0x1(%rax), %rax
jne 0x4fe02
movq 0x10(%r14), %rax
orl $-0x1, (%rax,%rbx,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_allocate_dest_restricted
static void prv_allocate_dest_restricted(subtilis_arm_reg_ud_t *ud,
					 subtilis_arm_op_t *op,
					 subtilis_arm_reg_t *dest,
					 subtilis_arm_reg_t restricted,
					 subtilis_error_t *err)
{
	int dist_dest;
	size_t vreg_dest = *dest;

	if ((ud->int_regs->is_fixed(vreg_dest)) &&
	    (vreg_dest >= SUBTILIS_ARM_REG_MAX_INT_REGS))
		return;

	subtilis_arm_reg_alloc_alloc(ud, op, ud->int_regs, ud->int_regs, dest,
				     restricted, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	dist_dest = subtilis_arm_reg_alloc_calculate_dist(
	    ud, vreg_dest, op, &ud->int_regs->dist_walker, ud->int_regs);
	if (dist_dest == -1)
		ud->int_regs->phys_to_virt[*dest] = INT_MAX;
	ud->int_regs->next[*dest] = dist_dest;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %rbp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdx), %r12
movq 0x8(%rdi), %rax
movq %r12, %rdi
callq *0x70(%rax)
cmpq $0xb, %r12
jb 0x4fe69
testb %al, %al
jne 0x4fec4
movq 0x8(%r14), %rcx
movq %r13, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %r8
movq %rbp, %r9
callq 0x4fa99
cmpl $0x0, (%r13)
jne 0x4fec4
movq 0x8(%r14), %r8
leaq 0x90(%r8), %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4f9f0
movq 0x8(%r14), %rcx
cmpl $-0x1, %eax
jne 0x4feba
movq 0x8(%rcx), %rdx
movq (%rbx), %rsi
movq $0x7fffffff, (%rdx,%rsi,8) # imm = 0x7FFFFFFF
movq 0x10(%rcx), %rcx
movq (%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: subtilis_arm_reg_alloc_alloc_fp_dest
void subtilis_arm_reg_alloc_alloc_fp_dest(subtilis_arm_reg_ud_t *ud,
					  subtilis_arm_op_t *op,
					  subtilis_arm_reg_t *dest,
					  subtilis_error_t *err)
{
	int dist_dest;
	size_t vreg_dest = *dest;

	subtilis_arm_reg_alloc_alloc(ud, op, ud->int_regs, ud->real_regs, dest,
				     SIZE_MAX, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	dist_dest = subtilis_arm_reg_alloc_calculate_dist(
	    ud, vreg_dest, op, &ud->real_regs->dist_walker, ud->real_regs);
	if (dist_dest == -1)
		ud->real_regs->phys_to_virt[*dest] = INT_MAX;
	ud->real_regs->next[*dest] = dist_dest;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdx), %r12
movq 0x10(%rdi), %rcx
movq %r13, (%rsp)
pushq $-0x1
popq %r9
movq %rdx, %r8
callq 0x4fa99
cmpl $0x0, (%r13)
jne 0x4ff45
movq 0x10(%r14), %r8
leaq 0x90(%r8), %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4f9f0
movq 0x10(%r14), %rcx
cmpl $-0x1, %eax
jne 0x4ff3b
movq 0x8(%rcx), %rdx
movq (%rbx), %rsi
movq $0x7fffffff, (%rdx,%rsi,8) # imm = 0x7FFFFFFF
movq 0x10(%rcx), %rcx
movq (%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_alloc_data_instr
static void prv_alloc_data_instr(void *user_data, subtilis_arm_op_t *op,
				 subtilis_arm_instr_type_t type,
				 subtilis_arm_data_instr_t *instr,
				 subtilis_error_t *err)
{
	int dist_op1;
	int dist_op2;
	int dist_op2_shift;
	size_t vreg_op1;
	bool fixed_reg_op1;
	subtilis_arm_reg_ud_t *ud = user_data;
	subtilis_arm_reg_t *reg = NULL;
	subtilis_arm_reg_t *shift_reg = NULL;

	vreg_op1 = instr->op1;
	fixed_reg_op1 = subtilis_arm_reg_alloc_ensure(
	    ud, op, ud->int_regs, ud->int_regs, &instr->op1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	reg = prv_ensure_op2(ud, op, &instr->op2, &dist_op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	shift_reg =
	    prv_ensure_op2_shift_reg(ud, op, &instr->op2, &dist_op2_shift, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (!fixed_reg_op1) {
		dist_op1 = subtilis_arm_reg_alloc_calculate_dist(
		    ud, vreg_op1, op, &ud->int_regs->dist_walker, ud->int_regs);
		if (dist_op1 == -1)
			ud->int_regs->phys_to_virt[instr->op1] = INT_MAX;
	}

	subtilis_arm_reg_alloc_alloc_dest(ud, op, &instr->dest, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (!fixed_reg_op1)
		ud->int_regs->next[instr->op1] = dist_op1;
	if (reg)
		ud->int_regs->next[*reg] = dist_op2;
	if (shift_reg)
		ud->int_regs->next[*shift_reg] = dist_op2_shift;

	ud->instr_count++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rcx), %r14
movq 0x10(%rcx), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rdi), %rcx
movq %r14, %r8
movq %r15, %r9
callq 0x4fc53
movb %al, 0xb(%rsp)
cmpl $0x0, (%r15)
jne 0x5077b
leaq 0x18(%r12), %rbp
leaq 0x14(%rsp), %rcx
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r15, %r8
callq 0x52612
cmpl $0x0, (%r15)
jne 0x5077b
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, 0x18(%rsp)
movq %rbp, %rdx
movq %r15, %r8
callq 0x5262c
cmpl $0x0, (%r15)
jne 0x5077b
movq %rax, %rbp
cmpb $0x0, 0xb(%rsp)
jne 0x5070f
movq 0x8(%rbx), %r8
leaq 0x90(%r8), %rcx
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
movq %r13, %rdx
callq 0x4f9f0
movl %eax, 0xc(%rsp)
cmpl $-0x1, %eax
jne 0x5070f
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq (%r14), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
pushq $-0x1
popq %rax
movl %eax, 0xc(%rsp)
addq $0x8, %r12
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x4fe30
cmpl $0x0, (%r15)
movq 0x18(%rsp), %rdx
jne 0x5077b
cmpb $0x0, 0xb(%rsp)
jne 0x50748
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq (%r14), %rcx
movl 0xc(%rsp), %esi
movl %esi, (%rax,%rcx,4)
testq %rdx, %rdx
je 0x5075f
movl 0x14(%rsp), %eax
movq 0x8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq (%rdx), %rdx
movl %eax, (%rcx,%rdx,4)
testq %rbp, %rbp
je 0x50777
movl 0x10(%rsp), %eax
movq 0x8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq (%rbp), %rdx
movl %eax, (%rcx,%rdx,4)
incq 0x20(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_alloc_mov_instr
static void prv_alloc_mov_instr(void *user_data, subtilis_arm_op_t *op,
				subtilis_arm_instr_type_t type,
				subtilis_arm_data_instr_t *instr,
				subtilis_error_t *err)
{
	int dist_op2_shift;
	subtilis_arm_reg_t *reg;
	subtilis_arm_reg_t *shift_reg;
	int dist_op2 = -1;
	subtilis_arm_reg_ud_t *ud = user_data;

	reg = prv_ensure_op2(ud, op, &instr->op2, &dist_op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	shift_reg =
	    prv_ensure_op2_shift_reg(ud, op, &instr->op2, &dist_op2_shift, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_reg_alloc_alloc_dest(ud, op, &instr->dest, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	/* Need to check for useless moves */

	if (reg && !shift_reg && ((type != SUBTILIS_ARM_INSTR_MOV) ||
				  (instr->dest != instr->op2.op.reg)))
		ud->int_regs->next[*reg] = dist_op2;

	if (shift_reg)
		ud->int_regs->next[*shift_reg] = dist_op2_shift;

	ud->instr_count++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r13
movq %rcx, %r12
movl %edx, (%rsp)
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x14(%rsp), %r14
orl $-0x1, (%r14)
leaq 0x18(%rcx), %rbp
movq %rbp, %rdx
movq %r14, %rcx
callq 0x52612
cmpl $0x0, (%r13)
jne 0x50b02
leaq 0x4(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, 0x8(%rsp)
movq %rbp, %rdx
movq %r13, %r8
callq 0x5262c
cmpl $0x0, (%r13)
jne 0x50b02
leaq 0x8(%r12), %rdx
movq %rbx, %rdi
movq %rax, %rbp
movq %r15, %rsi
movq %r13, %rcx
callq 0x4fe30
movq 0x8(%rsp), %rdx
cmpl $0x0, (%r13)
jne 0x50b02
testq %rdx, %rdx
sete %al
testq %rbp, %rbp
setne %cl
orb %al, %cl
je 0x50adb
movq %rbp, %rdx
leaq 0x4(%rsp), %r14
testq %rbp, %rbp
jne 0x50aed
jmp 0x50afe
cmpl $0xd, (%rsp)
jne 0x50aed
movq 0x8(%r12), %rax
cmpq 0x20(%r12), %rax
je 0x50afe
movl (%r14), %eax
movq 0x8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq (%rdx), %rdx
movl %eax, (%rcx,%rdx,4)
incq 0x20(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_alloc_br_instr
static void prv_alloc_br_instr(void *user_data, subtilis_arm_op_t *op,
			       subtilis_arm_instr_type_t type,
			       subtilis_arm_br_instr_t *instr,
			       subtilis_error_t *err)
{
	size_t vreg_op1;
	bool fixed_reg_op1 = true;
	int dist_op1 = -1;
	subtilis_arm_reg_ud_t *ud = user_data;
	size_t reg = 0;
	subtilis_arm_reg_class_t *regs = NULL;

	if (instr->indirect) {
		vreg_op1 = instr->target.reg;
		fixed_reg_op1 = subtilis_arm_reg_alloc_ensure(
		    ud, op, ud->int_regs, ud->int_regs, &instr->target.reg,
		    err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		if (!fixed_reg_op1) {
			dist_op1 = subtilis_arm_reg_alloc_calculate_dist(
			    ud, vreg_op1, op, &ud->int_regs->dist_walker,
			    ud->int_regs);
			if (dist_op1 == -1)
				ud->int_regs->phys_to_virt[instr->target.reg] =
				    INT_MAX;
		}
	}

	/*
	 * We need to make sure that F0 or R0 are marked as being
	 * allocated when we return from a function.  Otherwise we
	 * can get an assertion when we ensure them later in the code.
	 */

	if (instr->link_type == SUBTILIS_ARM_BR_LINK_INT)
		regs = ud->int_regs;
	else if (instr->link_type == SUBTILIS_ARM_BR_LINK_REAL)
		regs = ud->real_regs;

	if (regs) {
		subtilis_arm_reg_alloc_alloc(ud, op, ud->int_regs, regs, &reg,
					     SIZE_MAX, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

	if (instr->indirect && !fixed_reg_op1)
		ud->int_regs->next[instr->target.reg] = dist_op1;

	ud->instr_count++;

	prv_check_current_ss(ud, op, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r12
movq %rsi, %r14
andq $0x0, 0x10(%rsp)
movq %rdi, %r15
pushq $-0x1
popq %rax
movl %eax, 0xc(%rsp)
cmpb $0x1, 0x6(%rcx)
jne 0x50d30
leaq 0x10(%r12), %r13
movq 0x10(%r12), %rbp
movq 0x8(%r15), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %r8
movq %rbx, %r9
callq 0x4fc53
cmpl $0x0, (%rbx)
jne 0x50d6e
testb %al, %al
je 0x50dbc
xorl %ebp, %ebp
movl 0x8(%r12), %eax
cmpl $0x1, %eax
je 0x50d45
cmpl $0x2, %eax
jne 0x50d7d
pushq $0x10
jmp 0x50d47
pushq $0x8
popq %rax
movq (%r15,%rax), %rcx
testq %rcx, %rcx
je 0x50d7d
movq %rbx, (%rsp)
leaq 0x10(%rsp), %r8
pushq $-0x1
popq %r9
movq %r15, %rdi
movq %r14, %rsi
callq 0x4fa99
cmpl $0x0, (%rbx)
je 0x50d7d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
andb 0x6(%r12), %bpl
cmpb $0x1, %bpl
jne 0x50d9c
movq 0x8(%r15), %rax
movq 0x10(%rax), %rax
movq 0x10(%r12), %rcx
movl 0xc(%rsp), %edx
movl %edx, (%rax,%rcx,4)
incq 0x20(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x525db
movq 0x8(%r15), %r8
leaq 0x90(%r8), %rcx
movq %r15, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x4f9f0
movb $0x1, %bpl
cmpl $-0x1, %eax
je 0x50de6
movl %eax, 0xc(%rsp)
jmp 0x50d32
movq 0x8(%r15), %rax
movq 0x8(%rax), %rax
movq (%r13), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
jmp 0x50d32
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_alloc_swi_instr
static void prv_alloc_swi_instr(void *user_data, subtilis_arm_op_t *op,
				subtilis_arm_instr_type_t type,
				subtilis_arm_swi_instr_t *instr,
				subtilis_error_t *err)
{
	size_t i;
	int dist;
	subtilis_arm_reg_t reg;
	subtilis_arm_reg_ud_t *ud = user_data;

	/* SWIs can only use the first 10 regs */

	for (i = 0; i < 10; i++) {
		if ((1 << i) & instr->reg_read_mask) {
			reg = i;
			subtilis_arm_reg_alloc_ensure(ud, op, ud->int_regs,
						      ud->int_regs, &reg, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
			dist = subtilis_arm_reg_alloc_calculate_dist(
			    ud, reg, op, &ud->int_regs->dist_walker,
			    ud->int_regs);
			if (dist == -1)
				ud->int_regs->phys_to_virt[reg] = INT_MAX;
			ud->int_regs->next[reg] = dist;
		} else if ((1 << i) & instr->reg_write_mask) {
			reg = i;
			subtilis_arm_reg_alloc_alloc_dest(ud, op, &reg, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		}
	}

	ud->instr_count++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r15
xorl %r13d, %r13d
cmpq $0xa, %r13
je 0x50eb6
pushq $0x1
popq %rax
movl %r13d, %ecx
shll %cl, %eax
movl 0x10(%r14), %ecx
btl %r13d, %ecx
jae 0x50e8e
movq %r13, (%rsp)
movq 0x8(%r15), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %rsp, %r8
movq %rbx, %r9
callq 0x4fc53
cmpl $0x0, (%rbx)
jne 0x50eba
movq (%rsp), %rbp
movq 0x8(%r15), %r8
leaq 0x90(%r8), %rcx
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x4f9f0
movq 0x8(%r15), %rcx
cmpl $-0x1, %eax
jne 0x50e85
movq 0x8(%rcx), %rdx
movq $0x7fffffff, (%rdx,%rbp,8) # imm = 0x7FFFFFFF
movq 0x10(%rcx), %rcx
movl %eax, (%rcx,%rbp,4)
jmp 0x50eae
testl %eax, 0x14(%r14)
je 0x50eae
movq %r13, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %rsp, %rdx
movq %rbx, %rcx
callq 0x4fe30
cmpl $0x0, (%rbx)
jne 0x50eba
incq %r13
jmp 0x50e19
incq 0x20(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_alloc_cmov_instr
static void prv_alloc_cmov_instr(void *user_data, subtilis_arm_op_t *op,
				 subtilis_arm_instr_type_t type,
				 subtilis_arm_cmov_instr_t *instr,
				 subtilis_error_t *err)
{
	int dist_op[3];
	size_t vreg_op[3];
	bool fixed_reg_op[3];
	subtilis_arm_reg_t *reg_ptr[3];
	size_t i;
	subtilis_arm_reg_ud_t *ud = user_data;
	size_t count = 2;

	if (!instr->fused)
		count++;

	i = 0;

	if (!instr->fused) {
		vreg_op[i] = instr->op1;
		reg_ptr[i++] = &instr->op1;
	}
	vreg_op[i] = instr->op2;
	reg_ptr[i++] = &instr->op2;
	vreg_op[i] = instr->op3;
	reg_ptr[i] = &instr->op3;

	for (i = 0; i < count; i++) {
		fixed_reg_op[i] = subtilis_arm_reg_alloc_ensure(
		    ud, op, ud->int_regs, ud->int_regs, reg_ptr[i], err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

	for (i = 0; i < count; i++) {
		if (!fixed_reg_op[i]) {
			dist_op[i] = subtilis_arm_reg_alloc_calculate_dist(
			    ud, vreg_op[i], op, &ud->int_regs->dist_walker,
			    ud->int_regs);
			if (dist_op[i] == -1)
				ud->int_regs->phys_to_virt[*reg_ptr[i]] =
				    INT_MAX;
		}
	}

	subtilis_arm_reg_alloc_alloc_dest(ud, op, &instr->dest, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	for (i = 0; i < count; i++)
		if (!fixed_reg_op[i])
			ud->int_regs->next[*reg_ptr[i]] = dist_op[i];

	ud->instr_count++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movzbl 0x20(%rcx), %r13d
leaq 0x18(%rsp), %rax
leaq 0x38(%rsp), %rcx
testq %r13, %r13
je 0x50f7b
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rsi
jmp 0x50f9b
movq %rcx, %rdx
leaq 0x40(%rsp), %rcx
movq %rax, %rsi
leaq 0x20(%rsp), %rax
leaq 0x8(%r15), %rdi
movq 0x8(%r15), %r8
movq %r8, -0x10(%rcx)
movq %rdi, -0x10(%rax)
xorq $0x3, %r13
leaq 0x10(%r15), %rdi
movq 0x10(%r15), %r8
movq %r8, (%rdx)
movq %rdi, (%rsi)
leaq 0x18(%r15), %rdx
movq 0x18(%r15), %rsi
movq %rsi, (%rcx)
movq %rdx, (%rax)
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x50feb
movq 0x8(%rbx), %rcx
movq 0x10(%rsp,%rbp,8), %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %r9
callq 0x4fc53
movb %al, 0xd(%rsp,%rbp)
incq %rbp
cmpl $0x0, (%r14)
je 0x50fbd
jmp 0x5107f
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x5103a
cmpb $0x0, 0xd(%rsp,%rbp)
jne 0x51035
movq 0x30(%rsp,%rbp,8), %rsi
movq 0x8(%rbx), %r8
leaq 0x90(%r8), %rcx
movq %rbx, %rdi
movq %r12, %rdx
callq 0x4f9f0
movl %eax, 0x4c(%rsp,%rbp,4)
cmpl $-0x1, %eax
jne 0x51035
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp,%rbp,8), %rcx
movq (%rcx), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
incq %rbp
jmp 0x50fed
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4fe30
cmpl $0x0, (%r14)
jne 0x5107f
xorl %eax, %eax
cmpq %rax, %r13
je 0x5107b
cmpb $0x0, 0xd(%rsp,%rax)
jne 0x51076
movl 0x4c(%rsp,%rax,4), %ecx
movq 0x8(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq 0x10(%rsp,%rax,8), %rsi
movq (%rsi), %rsi
movl %ecx, (%rdx,%rsi,4)
incq %rax
jmp 0x51053
incq 0x20(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_alloc_flags_instr
static void prv_alloc_flags_instr(void *user_data, subtilis_arm_op_t *op,
				  subtilis_arm_instr_type_t type,
				  subtilis_arm_flags_instr_t *instr,
				  subtilis_error_t *err)
{
	subtilis_arm_reg_t vreg;
	subtilis_arm_reg_ud_t *ud = user_data;
	bool fixed_reg;
	int dist;

	if (type == SUBTILIS_ARM_INSTR_MRS) {
		subtilis_arm_reg_alloc_alloc_dest(ud, op, &instr->op.reg, err);
	} else if (instr->flag_reg) {
		vreg = instr->op.reg;
		fixed_reg = subtilis_arm_reg_alloc_ensure(
		    ud, op, ud->int_regs, ud->int_regs, &instr->op.reg, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		if (!fixed_reg) {
			dist = subtilis_arm_reg_alloc_calculate_dist(
			    ud, vreg, op, &ud->int_regs->dist_walker,
			    ud->int_regs);
			if (dist == -1)
				ud->int_regs->phys_to_virt[instr->op.reg] =
				    INT_MAX;
			ud->int_regs->next[instr->op.reg] = dist;
		}
	}

	ud->instr_count++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x1d, %edx
jne 0x510bf
addq $0x10, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x4fe30
jmp 0x51129
cmpl $0x0, 0x4(%r14)
je 0x51129
movq 0x10(%r14), %r13
addq $0x10, %r14
movq 0x8(%rbx), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %r8
movq %r12, %r9
callq 0x4fc53
cmpl $0x0, (%r12)
jne 0x5112d
testb %al, %al
jne 0x51129
movq 0x8(%rbx), %r8
leaq 0x90(%r8), %rcx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x4f9f0
movq 0x8(%rbx), %rcx
cmpl $-0x1, %eax
jne 0x5111f
movq 0x8(%rcx), %rdx
movq (%r14), %rsi
movq $0x7fffffff, (%rdx,%rsi,8) # imm = 0x7FFFFFFF
movq 0x10(%rcx), %rcx
movq (%r14), %rdx
movl %eax, (%rcx,%rdx,4)
incq 0x20(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_alloc_signx_instr
static void prv_alloc_signx_instr(void *user_data, subtilis_arm_op_t *op,
				  subtilis_arm_instr_type_t type,
				  subtilis_arm_signx_instr_t *instr,
				  subtilis_error_t *err)
{
	size_t vreg_op1;
	bool fixed_reg_op1;
	int dist_op1 = -1;
	subtilis_arm_reg_ud_t *ud = user_data;

	vreg_op1 = instr->op1;
	fixed_reg_op1 = subtilis_arm_reg_alloc_ensure(
	    ud, op, ud->int_regs, ud->int_regs, &instr->op1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (!fixed_reg_op1) {
		dist_op1 = subtilis_arm_reg_alloc_calculate_dist(
		    ud, vreg_op1, op, &ud->int_regs->dist_walker, ud->int_regs);
		if (dist_op1 == -1)
			ud->int_regs->phys_to_virt[instr->op1] = INT_MAX;
	}

	subtilis_arm_reg_alloc_alloc_dest(ud, op, &instr->dest, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (!fixed_reg_op1)
		ud->int_regs->next[instr->op1] = dist_op1;

	ud->instr_count++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rcx), %r14
movq 0x10(%rcx), %rbp
movq 0x8(%rdi), %rcx
movq %r14, %r8
movq %r15, %r9
callq 0x4fc53
cmpl $0x0, (%r15)
jne 0x511e5
pushq $-0x1
popq %rcx
movb %al, 0x7(%rsp)
testb %al, %al
je 0x5117a
movl %ecx, %ebp
jmp 0x511b0
movq 0x8(%rbx), %r8
leaq 0x90(%r8), %rcx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x4f9f0
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x511b0
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq (%r14), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
pushq $-0x1
popq %rbp
addq $0x8, %r12
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x4fe30
cmpl $0x0, (%r15)
movb 0x7(%rsp), %al
jne 0x511e5
testb %al, %al
jne 0x511e1
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq (%r14), %rcx
movl %ebp, (%rax,%rcx,4)
incq 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_free_arm_reg_ud
static void prv_free_arm_reg_ud(subtilis_arm_reg_ud_t *ud)
{
	if (!ud)
		return;

	prv_free_regs(ud->real_regs);
	prv_free_regs(ud->int_regs);
	free(ud->ss_terminators);
}

// Assembly:
testq %rdi, %rdi
je 0x513f1
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x51fbc
movq 0x8(%rbx), %rdi
callq 0x51fbc
movq 0x38(%rbx), %rdi
popq %rbx
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: subtilis_arm_regs_used_before_from_tov
void subtilis_arm_regs_used_before_from_tov(subtilis_arm_section_t *arm_s,
					    subtilis_arm_op_t *from,
					    subtilis_arm_op_t *op,
					    size_t int_args, size_t real_args,
					    subtilis_regs_used_virt_t *used,
					    subtilis_error_t *err)
{
	size_t i;
	subtilis_arm_reg_ud_t ud;

	prv_init_arm_reg_ud(&ud, arm_s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	for (i = SUBTILIS_ARM_INT_VIRT_REG_START; i < int_args; i++) {
		if (prv_is_reg_used_before(&ud, i, &ud.int_regs->used_walker,
					   from, op)) {
			subtilis_bitset_set(&used->int_regs, i, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		}
	}

	for (i = arm_s->fp_if->max_regs; i < real_args; i++) {
		if (prv_is_reg_used_before(&ud, i, &ud.real_regs->used_walker,
					   from, op)) {
			subtilis_bitset_set(&used->real_regs, i, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		}
	}

	prv_free_arm_reg_ud(&ud);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, (%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rsi
movq 0xa0(%rsp), %r13
leaq 0x18(%rsp), %rdi
movq %rsi, 0x8(%rsp)
movq %r13, %rdx
callq 0x5048a
cmpl $0x0, (%r13)
jne 0x514ec
pushq $0x10
popq %r14
leaq 0x18(%rsp), %rbx
cmpq %rbp, %r14
jae 0x51485
movq 0x20(%rsp), %rdx
movl $0x1b8, %eax            # imm = 0x1B8
addq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rcx
movq %r15, %r8
callq 0x514fb
testb %al, %al
je 0x51480
movq (%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x59a32
cmpl $0x0, (%r13)
jne 0x514ec
incq %r14
jmp 0x51443
movq 0x8(%rsp), %rax
movq 0xc0(%rax), %rax
movq (%rax), %rbp
addq $0x18, (%rsp)
movl $0x1b8, %ebx            # imm = 0x1B8
leaq 0x18(%rsp), %r14
cmpq 0x10(%rsp), %rbp
jae 0x514e2
movq 0x28(%rsp), %rdx
addq %rbx, %rdx
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rcx
movq %r15, %r8
callq 0x514fb
testb %al, %al
je 0x514dd
movq (%rsp), %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x59a32
cmpl $0x0, (%r13)
jne 0x514ec
incq %rbp
jmp 0x514a3
leaq 0x18(%rsp), %rdi
callq 0x513cc
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_is_reg_used_before
static bool prv_is_reg_used_before(subtilis_arm_reg_ud_t *ud, size_t reg_num,
				   subtlis_arm_walker_t *used_walker,
				   subtilis_arm_op_t *from,
				   subtilis_arm_op_t *to)
{
	subtilis_error_t err;

	subtilis_error_init(&err);
	ud->dist_data.reg_num = reg_num;
	ud->dist_data.last_used = 0;
	subtilis_arm_walk_from_to(ud->arm_s, used_walker, from, to, &err);
	if ((err.type == SUBTILIS_ERROR_OK) || (ud->dist_data.last_used != -1))
		return false;

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc18, %rsp            # imm = 0xC18
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0xc(%rsp), %rbp
movq %rbp, %rdi
callq 0x140a4
movq %r13, 0x28(%rbx)
andl $0x0, 0x30(%rbx)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbp, %r8
callq 0x4f510
cmpl $0x0, (%rbp)
je 0x51554
cmpl $-0x1, 0x30(%rbx)
sete %al
jmp 0x51556
xorl %eax, %eax
addq $0xc18, %rsp            # imm = 0xC18
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: subtilis_arm_regs_used_before
void subtilis_arm_regs_used_before(subtilis_arm_section_t *arm_s,
				   subtilis_arm_op_t *op, size_t int_args,
				   size_t real_args,
				   subtilis_regs_used_t *regs_used,
				   subtilis_error_t *err)
{
	subtilis_arm_op_t *from;

	from = &arm_s->op_pool->ops[arm_s->first_op];
	prv_arm_regs_used_before_from_to(arm_s, from, op, int_args, real_args,
					 regs_used, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %r13
movq %r8, %rbp
movq %rcx, 0x8(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x38(%rdi), %rax
imulq $0x68, 0x20(%rdi), %r12
addq (%rax), %r12
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
movq %r9, %rdx
callq 0x5048a
cmpl $0x0, (%r13)
jne 0x51698
movq %rbp, (%rsp)
cmpq $0x4, %rbx
pushq $0x4
popq %r13
cmovaeq %r13, %rbx
xorl %ebp, %ebp
movq 0x8(%rsp), %rdx
movq %r15, 0x10(%rsp)
cmpq $0xb, %rbx
je 0x51627
movq 0xa0(%r15), %rax
cmpq 0x158(%rax), %rbx
jb 0x51618
movq %rbp, %r15
movq %rdx, %rbp
movq 0x20(%rsp), %rdx
movl $0x1b8, %eax            # imm = 0x1B8
addq %rax, %rdx
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rcx
movq %r14, %r8
callq 0x514fb
movq %rbp, %rdx
movq %r15, %rbp
movq 0x10(%rsp), %r15
testb %al, %al
je 0x51622
pushq $0x1
popq %rax
movl %ebx, %ecx
shll %cl, %eax
orq %rax, %rbp
incq %rbx
jmp 0x515cd
cmpq $0x4, %rdx
cmovbq %rdx, %r13
xorl %ebx, %ebx
movq 0xc0(%r15), %rax
cmpq (%rax), %r13
jae 0x51683
movq 0xa0(%r15), %rax
cmpq 0x160(%rax), %r13
jb 0x51671
movq 0x28(%rsp), %rdx
movl $0x1b8, %eax            # imm = 0x1B8
addq %rax, %rdx
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rcx
movq %r14, %r8
callq 0x514fb
testb %al, %al
je 0x5167e
pushq $0x1
popq %rax
movl %r13d, %ecx
shll %cl, %eax
cltq
orq %rax, %rbx
incq %r13
jmp 0x51631
movq (%rsp), %rax
movq %rbp, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x18(%rsp), %rdi
callq 0x513cc
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: subtilis_arm_regs_used_afterv
void subtilis_arm_regs_used_afterv(subtilis_arm_section_t *arm_s,
				   subtilis_arm_op_t *from,
				   subtilis_arm_op_t *to, size_t int_args,
				   size_t real_args, size_t count,
				   subtilis_regs_used_virt_t *used,
				   subtilis_error_t *err)
{
	size_t i;
	subtilis_arm_reg_ud_t ud;

	prv_init_arm_reg_ud(&ud, arm_s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	ud.instr_count = count + 1;

	for (i = SUBTILIS_ARM_INT_VIRT_REG_START; i < int_args; i++) {
		if (prv_is_reg_used_after_to(&ud, i, &ud.int_regs->dist_walker,
					     from, to)) {
			subtilis_bitset_set(&used->int_regs, i, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		}
	}

	for (i = arm_s->fp_if->max_regs; i < real_args; i++) {
		if (prv_is_reg_used_after_to(&ud, i, &ud.real_regs->dist_walker,
					     from, to)) {
			subtilis_bitset_set(&used->real_regs, i, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		}
	}

	prv_free_arm_reg_ud(&ud);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %r12
movq %r8, 0x10(%rsp)
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rsi
movq 0xa8(%rsp), %rbx
leaq 0x18(%rsp), %rdi
movq %rsi, 0x8(%rsp)
movq %rbx, %rdx
callq 0x5048a
cmpl $0x0, (%rbx)
jne 0x517d1
movq 0xa0(%rsp), %rax
movq %rax, (%rsp)
incq %r12
leaq 0x18(%rsp), %rbx
movq %r12, 0x20(%rbx)
pushq $0x10
popq %r12
movl $0x90, %r13d
cmpq %rbp, %r12
jae 0x51761
movq 0x20(%rsp), %rdx
addq %r13, %rdx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rcx
movq %r14, %r8
callq 0x517e0
testb %al, %al
je 0x5175c
movq 0xa0(%rsp), %rdi
movq %r12, %rsi
movq %rbx, %r13
movq 0xa8(%rsp), %rbx
movq %rbx, %rdx
callq 0x59a32
cmpl $0x0, (%rbx)
movq %r13, %rbx
movl $0x90, %r13d
jne 0x517d1
incq %r12
jmp 0x5170e
movq 0x8(%rsp), %rax
movq 0xc0(%rax), %rax
movq (%rax), %rbp
addq $0x18, (%rsp)
movl $0x90, %r13d
leaq 0x18(%rsp), %rbx
cmpq 0x10(%rsp), %rbp
jae 0x517c7
movq 0x28(%rsp), %rdx
addq %r13, %rdx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rcx
movq %r14, %r8
callq 0x517e0
testb %al, %al
je 0x517c2
movq (%rsp), %rdi
movq %rbp, %rsi
movq 0xa8(%rsp), %r12
movq %r12, %rdx
callq 0x59a32
cmpl $0x0, (%r12)
jne 0x517d1
incq %rbp
jmp 0x51780
leaq 0x18(%rsp), %rdi
callq 0x513cc
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_is_reg_used_after_to
static bool prv_is_reg_used_after_to(subtilis_arm_reg_ud_t *ud, size_t reg_num,
				     subtlis_arm_walker_t *dist_walker,
				     subtilis_arm_op_t *from,
				     subtilis_arm_op_t *to)
{
	subtilis_error_t err;

	subtilis_error_init(&err);

	ud->dist_data.reg_num = reg_num;
	ud->dist_data.last_used = ud->instr_count + 1;

	subtilis_arm_walk_from_to(ud->arm_s, dist_walker, from, to, &err);

	/*
	 * Check that reg_num is used and that the  first usage of
	 * reg_num is not a write.
	 */

	return (err.type != SUBTILIS_ERROR_OK) &&
	       (ud->dist_data.last_used != -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc18, %rsp            # imm = 0xC18
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0xc(%rsp), %rbp
movq %rbp, %rdi
callq 0x140a4
movq %r13, 0x28(%rbx)
movl 0x20(%rbx), %eax
incl %eax
movl %eax, 0x30(%rbx)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbp, %r8
callq 0x4f510
cmpl $0x0, (%rbp)
je 0x5183d
cmpl $-0x1, 0x30(%rbx)
setne %al
jmp 0x5183f
xorl %eax, %eax
addq $0xc18, %rsp            # imm = 0xC18
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: subtilis_arm_regs_used_after
void subtilis_arm_regs_used_after(subtilis_arm_section_t *arm_s,
				  subtilis_arm_op_t *op, size_t int_args,
				  size_t real_args,
				  subtilis_regs_used_t *regs_used,
				  subtilis_error_t *err)
{
	size_t i;
	subtilis_arm_reg_ud_t ud;
	size_t int_reg_list = 0;
	size_t real_reg_list = 0;

	prv_init_arm_reg_ud(&ud, arm_s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	i = int_args;
	if (i > SUBTILIS_ARM_REG_MAX_ARGS)
		i = SUBTILIS_ARM_REG_MAX_ARGS;
	for (; i <= SUBTILIS_ARM_REG_MAX_INT_REGS - 1; i++) {
		if (prv_is_reg_used_after(&ud, i, &ud.int_regs->dist_walker,
					  op))
			int_reg_list |= 1 << i;
	}

	i = real_args;
	if (i > SUBTILIS_ARM_REG_MAX_ARGS)
		i = SUBTILIS_ARM_REG_MAX_ARGS;
	for (; i < arm_s->fp_if->max_regs; i++) {
		if (prv_is_reg_used_after(&ud, i, &ud.real_regs->dist_walker,
					  op))
			real_reg_list |= 1 << i;
	}

	regs_used->int_regs = int_reg_list;
	regs_used->real_regs = real_reg_list;

	prv_free_arm_reg_ud(&ud);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
movq %r9, %rdx
callq 0x5048a
cmpl $0x0, (%rbx)
jne 0x51945
movq %r13, 0x8(%rsp)
movq %r12, 0x10(%rsp)
cmpq $0x4, %rbp
pushq $0x4
popq %r12
cmovaeq %r12, %rbp
xorl %r13d, %r13d
pushq $0x1
popq %rbx
cmpq $0xb, %rbp
je 0x518dd
movq 0x20(%rsp), %rdx
movl $0x90, %eax
addq %rax, %rdx
leaq 0x18(%rsp), %rdi
movq %rbp, %rsi
movq %r14, %rcx
callq 0x51954
movl %ebx, %edx
movl %ebp, %ecx
shll %cl, %edx
testb %al, %al
jne 0x518d5
xorl %edx, %edx
orq %rdx, %r13
incq %rbp
jmp 0x518a6
movq 0x8(%rsp), %rax
cmpq $0x4, %rax
cmovbq %rax, %r12
xorl %ebp, %ebp
movq 0xc0(%r15), %rax
cmpq (%rax), %r12
jae 0x5192f
movq 0x28(%rsp), %rdx
movl $0x90, %eax
addq %rax, %rdx
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rcx
callq 0x51954
movl %ebx, %edx
movl %r12d, %ecx
shll %cl, %edx
testb %al, %al
jne 0x51924
xorl %eax, %eax
jmp 0x51927
movslq %edx, %rax
orq %rax, %rbp
incq %r12
jmp 0x518ec
movq 0x10(%rsp), %rax
movq %r13, (%rax)
movq %rbp, 0x8(%rax)
leaq 0x18(%rsp), %rdi
callq 0x513cc
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_update_arg_offsets
static void prv_update_arg_offsets(subtilis_arm_section_t *arm_s,
				   subtilis_arm_call_site_t *call_site,
				   size_t int_regs_used, size_t real_regs_used,
				   subtilis_error_t *err)
{
	size_t i;
	size_t ptr;
	subtilis_arm_op_t *op;
	subtilis_arm_stran_instr_t *st;
	size_t bytes_saved = 0;

	for (i = 0; i < 15; i++)
		if (1 << i & int_regs_used)
			bytes_saved += sizeof(int32_t);

	if (!arm_s->fp_if) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	for (i = 0; i < arm_s->fp_if->max_regs; i++)
		if (1 << i & real_regs_used)
			bytes_saved += sizeof(double);

	if (call_site->int_args > 4) {
		for (i = 0; i < call_site->int_args - 4; i++) {
			ptr = call_site->int_arg_ops[i];
			op = &arm_s->op_pool->ops[ptr];
			st = &op->op.instr.operands.stran;
			st->offset.op.integer += bytes_saved;
		}
	}

	if (call_site->real_args > 4)
		arm_s->fp_if->update_offs_fn(arm_s, call_site, bytes_saved,
					     err);
}

// Assembly:
pushq %rbx
movq %rcx, %rax
movq %rdx, %rcx
xorl %r9d, %r9d
xorl %edx, %edx
cmpq $0xf, %r9
je 0x51b48
leaq 0x4(%rdx), %r10
btq %r9, %rcx
cmovbq %r10, %rdx
incq %r9
jmp 0x51b31
movq 0xc0(%rdi), %rcx
testq %rcx, %rcx
je 0x51bc5
movq (%rcx), %r9
xorl %ecx, %ecx
movl $0x1, %r10d
cmpq %rcx, %r9
je 0x51b7d
movl %r10d, %r11d
shll %cl, %r11d
movslq %r11d, %r11
leaq 0x8(%rdx), %rbx
testq %rax, %r11
cmovneq %rbx, %rdx
incq %rcx
jmp 0x51b5f
movq 0x20(%rsi), %rcx
cmpq $0x5, %rcx
jb 0x51bad
xorl %eax, %eax
addq $-0x4, %rcx
cmpq %rcx, %rax
jae 0x51bad
movq 0x38(%rdi), %rcx
imulq $0x68, 0x38(%rsi,%rax,8), %r9
movq (%rcx), %rcx
addl %edx, 0x30(%rcx,%r9)
incq %rax
movq 0x20(%rsi), %rcx
jmp 0x51b89
cmpq $0x5, 0x28(%rsi)
jb 0x51bdf
movq 0xc0(%rdi), %rax
movq 0x40(%rax), %rax
movq %r8, %rcx
popq %rbx
jmpq *%rax
leaq 0x1dfdf(%rip), %rdx     # 0x6fbab
movl $0xf, %esi
movq %r8, %rdi
movl $0x8c1, %ecx            # imm = 0x8C1
popq %rbx
jmp 0x1429e
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_spill_reg
static void prv_spill_reg(subtilis_arm_reg_ud_t *ud, subtilis_arm_op_t *current,
			  size_t assigned, subtilis_arm_reg_class_t *int_regs,
			  subtilis_arm_reg_class_t *regs,
			  subtilis_arm_reg_t reg, subtilis_error_t *err)
{
	size_t i;
	int32_t offset;
	size_t pos;
	subtilis_arm_section_t *arm_s = ud->arm_s;

	if (regs->spill_top == regs->vr_reg_count) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	for (i = 0; i < regs->spill_top; i++)
		if (regs->spill_stack[i] != INT_MAX)
			break;

	offset = (int32_t)regs->spill_stack[i];
	regs->spill_stack[i] = INT_MAX;
	if (i == regs->spill_top) {
		regs->spill_top++;
		if (regs->spill_max < regs->spill_top)
			regs->spill_max = regs->spill_top;
	}

	regs->spilt_regs[assigned] = offset;

	if (current->prev == SIZE_MAX)
		pos = arm_s->first_op;
	else
		pos = arm_s->op_pool->ops[current->prev].next;

	prv_add_spill_point(regs, SUBTILIS_SPILL_POINT_STORE, pos, offset, reg,
			    err);
}

// Assembly:
pushq %rbx
movq 0x30(%rcx), %r10
cmpq 0x18(%rcx), %r10
jne 0x51c06
leaq 0x1dfb8(%rip), %rdx     # 0x6fbab
movl $0xf, %esi
movq %r9, %rdi
movl $0x2eb, %ecx            # imm = 0x2EB
popq %rbx
jmp 0x1429e
movq 0x18(%rdi), %rdi
movq 0x28(%rcx), %r11
xorl %ebx, %ebx
cmpq %rbx, %r10
je 0x51c26
movq (%r11,%rbx,8), %rax
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jne 0x51c2c
incq %rbx
jmp 0x51c10
movq (%r11,%r10,8), %rax
jmp 0x51c2f
movq %rbx, %r10
movq $0x7fffffff, (%r11,%r10,8) # imm = 0x7FFFFFFF
cmpq 0x30(%rcx), %r10
jne 0x51c4e
incq %r10
movq %r10, 0x30(%rcx)
cmpq %r10, 0x38(%rcx)
jae 0x51c4e
movq %r10, 0x38(%rcx)
movq 0x20(%rcx), %r10
movl %eax, (%r10,%rdx,4)
movq 0x60(%rsi), %rdx
cmpq $-0x1, %rdx
je 0x51c75
movq 0x38(%rdi), %rsi
movq (%rsi), %rsi
imulq $0x68, %rdx, %rdx
leaq (%rsi,%rdx), %rdi
addq $0x58, %rdi
jmp 0x51c79
addq $0x20, %rdi
movq (%rdi), %rdx
movl $0x1, %esi
movq %rcx, %rdi
movl %eax, %ecx
popq %rbx
jmp 0x51c89
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_add_spill_point
static void prv_add_spill_point(subtilis_arm_reg_class_t *regs,
				subtilis_spill_point_type_t type, size_t pos,
				int32_t offset, subtilis_arm_reg_t phys,
				subtilis_error_t *err)
{
	subtilis_spill_point_t *sp;
	size_t new_max;

	if (regs->spill_points_count == regs->spill_points_max) {
		new_max = regs->spill_points_count + SUBTILIS_CONFIG_SSS_GRAN;
		sp = realloc(regs->spill_points, new_max * sizeof(*sp));
		if (!sp) {
			subtilis_error_set_oom(err);
			return;
		}
		regs->spill_points = sp;
		regs->spill_points_max = new_max;
	}
	sp = &regs->spill_points[regs->spill_points_count++];
	sp->type = type;
	sp->pos = pos;
	sp->offset = offset;
	sp->phys = phys;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
movq 0x80(%rdi), %r13
cmpq 0x88(%rdi), %r13
jne 0x51ce7
movq %r9, (%rsp)
addq $0x10, %r13
movq 0x78(%r12), %rdi
movq %r13, %rsi
shlq $0x5, %rsi
callq 0x12210
testq %rax, %rax
je 0x51d1e
movq %rax, 0x78(%r12)
movq %r13, 0x88(%r12)
movq 0x80(%r12), %r13
jmp 0x51cec
movq 0x78(%r12), %rax
leaq 0x1(%r13), %rcx
movq %rcx, 0x80(%r12)
shlq $0x5, %r13
movl %r15d, (%rax,%r13)
movq %r14, 0x8(%rax,%r13)
movl %ebp, 0x10(%rax,%r13)
movq %rbx, 0x18(%rax,%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1de86(%rip), %rdx     # 0x6fbab
pushq $0x1
popq %rsi
movq (%rsp), %rdi
movl $0x1d3, %ecx            # imm = 0x1D3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_free_regs
static void prv_free_regs(subtilis_arm_reg_class_t *regs)
{
	if (regs) {
		free(regs->spill_points);
		free(regs->spill_stack);
		free(regs->spilt_regs);
		free(regs->next);
		free(regs->phys_to_virt);
		free(regs);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x51ffb
pushq %rbx
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
callq 0x122c0
movq 0x28(%rbx), %rdi
callq 0x122c0
movq 0x20(%rbx), %rdi
callq 0x122c0
movq 0x10(%rbx), %rdi
callq 0x122c0
movq 0x8(%rbx), %rdi
callq 0x122c0
movq %rbx, %rdi
popq %rbx
jmp 0x122c0
retq