LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x70(%rax), %rax
movq -0x38(%rbp), %rdi
callq *%rax
testb $0x1, %al
jne 0x7787f
jmp 0x7788b
cmpq $0xb, -0x38(%rbp)
jb 0x7788b
jmp 0x77928
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
movq -0x28(%rbp), %rax
movq %rax, (%rsp)
callq 0x77130
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x778c3
jmp 0x77928
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x90, %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
callq 0x77010
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x7790f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
movl -0x2c(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %rax
movq $-0x1, %r9
movq %rax, (%rsp)
callq 0x77130
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7798e
jmp 0x779f3
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x90, %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %r8
callq 0x77010
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x779da
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
movl -0x24(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_alloc_label
static void prv_alloc_label(void *user_data, subtilis_arm_op_t *op,
			    size_t label, subtilis_error_t *err)
{
	subtilis_arm_reg_ud_t *ud = user_data;

	prv_check_current_ss(ud, op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	ud->instr_count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7b7d0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7821c
jmp 0x7822c
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0xffffffff, -0x44(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x18, %rdx
movq -0x28(%rbp), %r8
leaq -0x44(%rbp), %rcx
callq 0x7b850
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x78849
jmp 0x7890b
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x18, %rdx
movq -0x28(%rbp), %r8
leaq -0x2c(%rbp), %rcx
callq 0x7b8f0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x78878
jmp 0x7890b
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x8, %rdx
movq -0x28(%rbp), %rcx
callq 0x77800
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7889c
jmp 0x7890b
cmpq $0x0, -0x38(%rbp)
je 0x788db
cmpq $0x0, -0x40(%rbp)
jne 0x788db
cmpl $0xd, -0x14(%rbp)
jne 0x788c2
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x788db
movl -0x44(%rbp), %edx
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
cmpq $0x0, -0x40(%rbp)
je 0x788fb
movl -0x2c(%rbp), %edx
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0xa, -0x30(%rbp)
jae 0x78ea7
movq -0x30(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
movq -0x20(%rbp), %rcx
andl 0x10(%rcx), %eax
cmpl $0x0, %eax
je 0x78e4f
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %r9
leaq -0x40(%rbp), %r8
callq 0x774b0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x78dee
jmp 0x78eb7
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x90, %rcx
movq -0x48(%rbp), %rax
movq 0x8(%rax), %r8
callq 0x77010
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0x78e37
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x40(%rbp), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
movl -0x34(%rbp), %edx
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq -0x40(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x78e94
movq -0x30(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
movq -0x20(%rbp), %rcx
andl 0x14(%rcx), %eax
cmpl $0x0, %eax
je 0x78e92
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x40(%rbp), %rdx
callq 0x77800
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x78e90
jmp 0x78eb7
jmp 0x78e92
jmp 0x78e94
jmp 0x78e96
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x78d8b
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_alloc_ldrc_instr
static void prv_alloc_ldrc_instr(void *user_data, subtilis_arm_op_t *op,
				 subtilis_arm_instr_type_t type,
				 subtilis_arm_ldrc_instr_t *instr,
				 subtilis_error_t *err)
{
	subtilis_arm_reg_ud_t *ud = user_data;

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

	ud->instr_count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x8, %rdx
movq -0x28(%rbp), %rcx
callq 0x77800
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x78f07
jmp 0x78f17
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x1d, -0x14(%rbp)
jne 0x79297
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x10, %rdx
movq -0x28(%rbp), %rcx
callq 0x77800
jmp 0x7935e
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x7935c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %r8
addq $0x10, %r8
movq -0x28(%rbp), %r9
callq 0x774b0
andb $0x1, %al
movb %al, -0x39(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x792ed
jmp 0x7936e
testb $0x1, -0x39(%rbp)
jne 0x7935a
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x90, %rcx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %r8
callq 0x77010
movl %eax, -0x40(%rbp)
cmpl $-0x1, -0x40(%rbp)
jne 0x79340
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
movl -0x40(%rbp), %edx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x7935c
jmp 0x7935e
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %r8
addq $0x10, %r8
movq -0x28(%rbp), %r9
callq 0x774b0
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x793f2
jmp 0x7949b
testb $0x1, -0x31(%rbp)
jne 0x79447
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x90, %rcx
movq -0x40(%rbp), %rax
movq 0x8(%rax), %r8
callq 0x77010
movl %eax, -0x38(%rbp)
cmpl $-0x1, -0x38(%rbp)
jne 0x79445
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
jmp 0x79447
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x8, %rdx
movq -0x28(%rbp), %rcx
callq 0x77800
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7946b
jmp 0x7949b
testb $0x1, -0x31(%rbp)
jne 0x7948b
movl -0x38(%rbp), %edx
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_insert_spill_code
static void prv_insert_spill_code(subtilis_arm_reg_ud_t *ud,
				  subtilis_arm_reg_class_t *regs,
				  int32_t offset, int32_t arg_offset,
				  subtilis_error_t *err)
{
	size_t i;
	subtilis_spill_point_t *sp;
	subtilis_arm_op_t *current;
	int32_t basic_offset;
	subtilis_arm_section_t *arm_s = ud->arm_s;

	for (i = 0; i < regs->spill_points_count; i++) {
		sp = &regs->spill_points[i];
		current = &arm_s->op_pool->ops[sp->pos];
		if (sp->offset < regs->spilt_args * regs->reg_size)
			basic_offset = arg_offset;
		else
			basic_offset = offset;
		basic_offset += sp->offset;
		if (sp->type == SUBTILIS_SPILL_POINT_LOAD) {
			prv_insert_spill_code_load(arm_s, sp->phys, current,
						   regs, basic_offset, err);
		} else {
			prv_insert_spill_code_store(arm_s, sp->phys, current,
						    ud->int_regs, regs,
						    basic_offset, err);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x80(%rcx), %rax
jae 0x795ca
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
imulq $0x68, 0x8(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movslq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rcx
movq -0x10(%rbp), %rdx
imulq 0x40(%rdx), %rcx
cmpq %rcx, %rax
jae 0x7954b
movl -0x18(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x79551
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x7958a
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl -0x3c(%rbp), %r8d
movq -0x20(%rbp), %r9
callq 0x7ba30
jmp 0x795b7
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %r8
movl -0x3c(%rbp), %r9d
movq -0x20(%rbp), %rax
movq %rax, (%rsp)
callq 0x7bb00
jmp 0x795b9
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x794de
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x795e5
jmp 0x7960c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7aa10
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7aa10
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x12290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rsi
movq 0x10(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x77d80
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x79669
jmp 0x79758
movq $0x10, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x796d5
movq -0x38(%rbp), %rsi
movq -0x80(%rbp), %rdx
addq $0x1b8, %rdx            # imm = 0x1B8
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq -0x88(%rbp), %rdi
callq 0x79770
testb $0x1, %al
jne 0x796a4
jmp 0x796c5
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq 0x10(%rbp), %rdx
callq 0x88810
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x796c3
jmp 0x79758
jmp 0x796c5
jmp 0x796c7
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x79671
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x7974c
movq -0x38(%rbp), %rsi
movq -0x78(%rbp), %rdx
addq $0x1b8, %rdx            # imm = 0x1B8
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq -0x88(%rbp), %rdi
callq 0x79770
testb $0x1, %al
jne 0x7971a
jmp 0x7973c
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movq -0x38(%rbp), %rsi
movq 0x10(%rbp), %rdx
callq 0x88810
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7973a
jmp 0x79758
jmp 0x7973c
jmp 0x7973e
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x796e7
leaq -0x88(%rbp), %rdi
callq 0x795d0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xc40, %rsp            # imm = 0xC40
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
leaq -0xc3c(%rbp), %rdi
callq 0x15670
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0xc3c(%rbp), %r8
callq 0x76190
cmpl $0x0, -0xc3c(%rbp)
je 0x797e5
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
je 0x797eb
movb $0x0, -0x1(%rbp)
jmp 0x797ef
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc40, %rsp            # imm = 0xC40
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
imulq $0x68, 0x20(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rax
movq %rax, (%rsp)
callq 0x79870
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rsi
movq 0x18(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x77d80
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x79a7d
jmp 0x79b78
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq $0x10, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x79af5
movq -0x38(%rbp), %rsi
movq -0x80(%rbp), %rdx
addq $0x90, %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq -0x88(%rbp), %rdi
callq 0x79b90
testb $0x1, %al
jne 0x79ac4
jmp 0x79ae5
movq 0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq 0x18(%rbp), %rdx
callq 0x88810
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x79ae3
jmp 0x79b78
jmp 0x79ae5
jmp 0x79ae7
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x79a91
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x79b6c
movq -0x38(%rbp), %rsi
movq -0x78(%rbp), %rdx
addq $0x90, %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq -0x88(%rbp), %rdi
callq 0x79b90
testb $0x1, %al
jne 0x79b3a
jmp 0x79b5c
movq 0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x38(%rbp), %rsi
movq 0x18(%rbp), %rdx
callq 0x88810
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x79b5a
jmp 0x79b78
jmp 0x79b5c
jmp 0x79b5e
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x79b07
leaq -0x88(%rbp), %rdi
callq 0x795d0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xc40, %rsp            # imm = 0xC40
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0xc34(%rbp), %rdi
callq 0x15670
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x1, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0xc34(%rbp), %r8
callq 0x76190
xorl %eax, %eax
cmpl $0x0, -0xc34(%rbp)
movb %al, -0xc35(%rbp)
je 0x79c1e
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
setne %al
movb %al, -0xc35(%rbp)
movb -0xc35(%rbp), %al
andb $0x1, %al
addq $0xc40, %rsp            # imm = 0xC40
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x90(%rbp)
movq $0x0, -0x98(%rbp)
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x77d80
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x79c8b
jmp 0x79da5
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x4, -0x38(%rbp)
jbe 0x79ca2
movq $0x4, -0x38(%rbp)
jmp 0x79ca4
cmpq $0xa, -0x38(%rbp)
ja 0x79cfd
movq -0x38(%rbp), %rsi
movq -0x80(%rbp), %rdx
addq $0x90, %rdx
movq -0x10(%rbp), %rcx
leaq -0x88(%rbp), %rdi
callq 0x79db0
testb $0x1, %al
jne 0x79cd0
jmp 0x79ced
movq -0x38(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
orq -0x90(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x79cef
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x79ca4
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x4, -0x38(%rbp)
jbe 0x79d14
movq $0x4, -0x38(%rbp)
jmp 0x79d16
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0xc0(%rcx), %rcx
cmpq (%rcx), %rax
jae 0x79d7c
movq -0x38(%rbp), %rsi
movq -0x78(%rbp), %rdx
addq $0x90, %rdx
movq -0x10(%rbp), %rcx
leaq -0x88(%rbp), %rdi
callq 0x79db0
testb $0x1, %al
jne 0x79d4f
jmp 0x79d6c
movq -0x38(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
orq -0x98(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0x79d6e
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x79d16
movq -0x90(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x98(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq -0x88(%rbp), %rdi
callq 0x795d0
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0xf, -0x30(%rbp)
jae 0x7a068
movq -0x30(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
andq -0x18(%rbp), %rax
cmpq $0x0, %rax
je 0x7a058
movq -0x50(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x50(%rbp)
jmp 0x7a05a
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x7a02c
movq -0x8(%rbp), %rax
cmpq $0x0, 0xc0(%rax)
jne 0x7a095
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x32b0d(%rip), %rdx     # 0xacb93
movl $0x8c1, %ecx            # imm = 0x8C1
callq 0x158e0
jmp 0x7a193
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0xc0(%rcx), %rcx
cmpq (%rcx), %rax
jae 0x7a0e6
movq -0x30(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
andq -0x20(%rbp), %rax
cmpq $0x0, %rax
je 0x7a0d6
movq -0x50(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
jmp 0x7a0d8
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x7a09d
movq -0x10(%rbp), %rax
cmpq $0x4, 0x20(%rax)
jbe 0x7a167
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x4, %rcx
cmpq %rcx, %rax
jae 0x7a165
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x38(%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
imulq $0x68, -0x38(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x8, %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rax
movl 0x20(%rax), %ecx
addq %rdx, %rcx
movl %ecx, 0x20(%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x7a0f9
jmp 0x7a167
movq -0x10(%rbp), %rax
cmpq $0x4, 0x28(%rax)
jbe 0x7a193
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x7a3b1
movq 0x10(%rbp), %rdi
movl $0xf, %esi
leaq 0x327f1(%rip), %rdx     # 0xacb93
movl $0x2eb, %ecx            # imm = 0x2EB
callq 0x158e0
jmp 0x7a4bf
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x7a3ef
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x38(%rbp), %rcx
cmpq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
je 0x7a3df
jmp 0x7a3ef
jmp 0x7a3e1
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x7a3b9
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x3c(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x38(%rbp), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x7a458
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x7a456
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x7a458
movl -0x3c(%rbp), %edx
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
cmpq $-0x1, 0x60(%rax)
jne 0x7a483
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x7a4a2
movq -0x50(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x68, 0x60(%rcx), %rcx
addq %rcx, %rax
movq 0x58(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
movq -0x48(%rbp), %rdx
movl -0x3c(%rbp), %ecx
movq -0x30(%rbp), %r8
movq 0x10(%rbp), %r9
movl $0x1, %esi
callq 0x7a4d0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x88(%rcx), %rax
jne 0x7a570
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x40(%rbp), %rsi
shlq $0x5, %rsi
callq 0x121e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x7a555
movq -0x30(%rbp), %rdi
movl $0x1, %esi
leaq 0x3264a(%rip), %rdx     # 0xacb93
movl $0x1d3, %ecx            # imm = 0x1D3
callq 0x158e0
jmp 0x7a5c7
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x80(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x80(%rdx)
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7aa6d
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rdi
callq 0x12290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_arm_prespilt_calculate
static void prv_arm_prespilt_calculate(subtilis_arm_prespilt_offsets_t *off,
				       subtilis_bitset_t *int_save,
				       subtilis_bitset_t *real_save,
				       subtilis_error_t *err)
{
	off->int_offsets =
	    subtilis_bitset_values(int_save, &off->int_count, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	off->real_offsets =
	    subtilis_bitset_values(real_save, &off->real_count, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movq -0x20(%rbp), %rdx
callq 0x890c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7ab02
jmp 0x7ab22
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movq -0x20(%rbp), %rdx
callq 0x890c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_init_sub_section_links
static void prv_init_sub_section_links(subtilis_arm_reg_ud_t *ud,
				       subtilis_arm_ss_t *ss,
				       subtilis_arm_prespilt_offsets_t *offsets,
				       size_t ss_index, subtilis_error_t *err)
{
	subtilis_arm_ss_link_t *link;
	subtilis_arm_op_t *op;
	subtilis_arm_ccode_type_t ccode;

	if (ss->num_links == 0)
		return;

	if (ss->num_links == 1) {
		link = &ss->links[0];
		op = &ud->arm_s->op_pool->ops[link->op];
		ud->ss_terminators[ss_index] = op;
		ccode = SUBTILIS_ARM_CCODE_AL;
		prv_sub_section_int_links(ud, &link->int_save, ccode, offsets,
					  op, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;

		prv_sub_section_real_links(ud, &link->real_save, ccode, offsets,
					   op, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;

		return;
	}

	if (ss->num_links != 2) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	prv_init_two_links(ud, ss, offsets, ss_index, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x128(%rax)
jne 0x7ab5f
jmp 0x7ac52
movq -0x10(%rbp), %rax
cmpq $0x1, 0x128(%rax)
jne 0x7ac0f
movq -0x10(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
imulq $0x68, 0x68(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0xe, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x30, %rsi
movl -0x3c(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x28(%rbp), %r9
callq 0x7af90
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7abe2
jmp 0x7ac52
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x48, %rsi
movl -0x3c(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x28(%rbp), %r9
callq 0x7b0d0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7ac0d
jmp 0x7ac52
jmp 0x7ac52
movq -0x10(%rbp), %rax
cmpq $0x2, 0x128(%rax)
je 0x7ac39
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x31f66(%rip), %rdx     # 0xacb93
movl $0x6f1, %ecx            # imm = 0x6F1
callq 0x158e0
jmp 0x7ac52
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x7b270
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_sub_section_int_links
static void prv_sub_section_int_links(subtilis_arm_reg_ud_t *ud,
				      subtilis_bitset_t *int_save,
				      subtilis_arm_ccode_type_t ccode,
				      subtilis_arm_prespilt_offsets_t *offsets,
				      subtilis_arm_op_t *op,
				      subtilis_error_t *err)
{
	int j;
	int32_t offset;
	subtilis_arm_reg_t reg;

	for (j = 0; j <= int_save->max_value; j++) {
		if (!subtilis_bitset_isset(int_save, j))
			continue;
		offset = prv_arm_presplit_int_offset(offsets, j, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		offset += ud->arm_s->locals;

		if (offset > 4095 || offset < -4095) {
			reg = subtilis_arm_acquire_new_reg(ud->arm_s);
			subtilis_arm_insert_stran_spill_imm(
			    ud->arm_s, op, SUBTILIS_ARM_INSTR_STR, ccode, j, 11,
			    reg, offset, err);
		} else {
			subtilis_arm_insert_stran_imm(
			    ud->arm_s, op, SUBTILIS_ARM_INSTR_STR, ccode, j, 11,
			    offset, err);
		}
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jg 0x7b0c5
movq -0x10(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x88990
testb $0x1, %al
jne 0x7afdc
jmp 0x7b0b7
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x7b5e0
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7affe
jmp 0x7b0c5
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x30(%rax), %rcx
movslq -0x38(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x38(%rbp)
cmpl $0xfff, -0x38(%rbp)     # imm = 0xFFF
jg 0x7b026
cmpl $0xfffff001, -0x38(%rbp) # imm = 0xFFFFF001
jge 0x7b076
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6fe60
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movl -0x14(%rbp), %ecx
movslq -0x34(%rbp), %r8
movq -0x40(%rbp), %r11
movl -0x38(%rbp), %r10d
movq -0x30(%rbp), %rax
movl $0x13, %edx
movl $0xb, %r9d
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x72420
jmp 0x7b0aa
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movl -0x14(%rbp), %ecx
movslq -0x34(%rbp), %r8
movl -0x38(%rbp), %r10d
movq -0x30(%rbp), %rax
movl $0x13, %edx
movl $0xb, %r9d
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x72510
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7b0b5
jmp 0x7b0c5
jmp 0x7b0b7
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x7afb6
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_arm_presplit_int_offset
static size_t prv_arm_presplit_int_offset(subtilis_arm_prespilt_offsets_t *off,
					  size_t reg, subtilis_error_t *err)
{
	size_t i;

	for (i = 0; i < off->int_count; i++)
		if (off->int_offsets[i] == reg)
			return i * sizeof(int32_t);

	subtilis_error_set_assertion_failed(err);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x7b63d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x7b62d
movq -0x28(%rbp), %rax
shlq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x7b65f
jmp 0x7b62f
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7b5fc
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x31546(%rip), %rdx     # 0xacb93
movl $0x121, %ecx            # imm = 0x121
callq 0x158e0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)