LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_preserve_update
void subtilis_vfp_preserve_update(subtilis_arm_section_t *arm_s,
				  subtilis_arm_call_site_t *call_site,
				  size_t real_regs_saved, size_t real_regs_used,
				  subtilis_error_t *err)
{
	subtilis_arm_op_t *op;
	size_t i;
	size_t vfp_reg_count;

	if (real_regs_saved > SUBTILIS_ARM_REG_MAX_ARGS)
		real_regs_saved = SUBTILIS_ARM_REG_MAX_VFP_DBL_REGS -
				  SUBTILIS_ARM_REG_MAX_ARGS;
	else
		real_regs_saved =
		    SUBTILIS_ARM_REG_MAX_VFP_DBL_REGS - real_regs_saved;

	vfp_reg_count = SUBTILIS_ARM_REG_MAX_VFP_DBL_REGS - real_regs_saved;
	op = &arm_s->op_pool->ops[call_site->stf_site];

	for (; vfp_reg_count < SUBTILIS_ARM_REG_MAX_VFP_DBL_REGS;
	     vfp_reg_count++) {
		if (real_regs_used & (1 << vfp_reg_count)) {
			op->op.instr.operands.vfp_stran.ccode =
			    SUBTILIS_ARM_CCODE_AL;
		}
		op = &arm_s->op_pool->ops[op->next];
	}

	vfp_reg_count = SUBTILIS_ARM_REG_MAX_VFP_DBL_REGS - 1;
	op = &arm_s->op_pool->ops[call_site->ldf_site];
	for (i = 0; i < real_regs_saved; i++) {
		if (real_regs_used & (1 << vfp_reg_count))
			op->op.instr.operands.vfp_stran.ccode =
			    SUBTILIS_ARM_CCODE_AL;
		op = &arm_s->op_pool->ops[op->next];
		vfp_reg_count--;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x4, -0x18(%rbp)
jbe 0xa0119
movq $0xc, -0x18(%rbp)
jmp 0xa0126
movl $0x10, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x10, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x68, 0x18(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpq $0x10, -0x40(%rbp)
jae 0xa01a6
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0xa017d
movq -0x30(%rbp), %rax
movl $0xe, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
imulq $0x68, 0x58(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xa014e
movq $0xf, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x68, 0x10(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xa0238
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0xa0203
movq -0x30(%rbp), %rax
movl $0xe, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
imulq $0x68, 0x58(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xa01d1
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_update_offsets
void subtilis_vfp_update_offsets(subtilis_arm_section_t *arm_s,
				 subtilis_arm_call_site_t *call_site,
				 size_t bytes_saved, subtilis_error_t *err)
{
	size_t i;
	size_t ptr;
	subtilis_arm_op_t *op;
	subtilis_vfp_stran_instr_t *ft;

	for (i = 0; i < call_site->real_args - 4; i++) {
		ptr = call_site->real_arg_ops[i];
		op = &arm_s->op_pool->ops[ptr];
		ft = &op->op.instr.operands.vfp_stran;
		ft->offset += bytes_saved / 4;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x4, %rcx
cmpq %rcx, %rax
jae 0xa02d0
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x98(%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
imulq $0x68, -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x8, %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdx
shrq $0x2, %rdx
movq -0x40(%rbp), %rax
movzbl 0x18(%rax), %ecx
addq %rdx, %rcx
movb %cl, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xa025c
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_store_double
void subtilis_vfp_store_double(subtilis_arm_section_t *arm_s,
			       subtilis_arm_reg_t dest, subtilis_arm_reg_t base,
			       size_t offset, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_stran_instr_t *fstran;

	instr =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_VFP_INSTR_FSTD, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	fstran = &instr->operands.vfp_stran;
	fstran->ccode = SUBTILIS_ARM_CCODE_AL;
	fstran->dest = dest;
	fstran->base = base;
	fstran->offset = offset / 4;
	fstran->pre_indexed = true;
	fstran->write_back = false;
	fstran->subtract = true;
}

// 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 -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x48, %esi
callq 0x6fb60
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa031d
jmp 0xa0374
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0xe, (%rax)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
shrq $0x2, %rax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0x18(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x19(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x1a(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x1b(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_arm_vfp_if_init
void subtilis_arm_vfp_if_init(subtilis_arm_fp_if_t *fp_if)
{
	fp_if->max_regs =
	    SUBTILIS_ARM_REG_MAX_VFP_DBL_REGS; /* TODO: needs constant */

	fp_if->max_offset = 1023;
	fp_if->store_type = SUBTILIS_VFP_INSTR_FSTD;
	fp_if->load_type = SUBTILIS_VFP_INSTR_FLDD;
	fp_if->reverse_fpa_consts = false;
	fp_if->preamble_fn = subtilis_vfp_gen_preamble;
	fp_if->preserve_regs_fn = subtilis_vfp_preserve_regs;
	fp_if->restore_regs_fn = subtilis_vfp_restore_regs;
	fp_if->update_regs_fn = subtilis_vfp_preserve_update;
	fp_if->update_offs_fn = subtilis_vfp_update_offsets;
	fp_if->store_dbl_fn = subtilis_vfp_store_double;
	fp_if->mov_reg_fn = subtilis_vfp_mov_reg;
	fp_if->spill_imm_fn = subtilis_vfp_insert_stran_spill_imm;
	fp_if->stran_imm_fn = subtilis_vfp_insert_stran_imm;
	fp_if->is_fixed_fn = subtilis_vfp_is_fixed;
	fp_if->init_dist_walker_fn = subtilis_init_vfp_dist_walker;
	fp_if->init_used_walker_fn = subtilis_init_vfp_used_walker;
	fp_if->init_real_alloc_fn = subtilis_vfp_alloc_init_walker;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x10, (%rax)
movq -0x8(%rbp), %rax
movl $0x3ff, 0x8(%rax)       # imm = 0x3FF
movq -0x8(%rbp), %rax
movl $0x48, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x49, 0x1c(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
leaq -0x767(%rip), %rcx      # 0x9fcc0
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
leaq -0x506(%rip), %rcx      # 0x9ff30
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
leaq -0x435(%rip), %rcx      # 0xa0010
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
leaq -0x364(%rip), %rcx      # 0xa00f0
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
leaq -0x223(%rip), %rcx      # 0xa0240
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
leaq -0x192(%rip), %rcx      # 0xa02e0
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
leaq -0x101(%rip), %rcx      # 0xa0380
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
leaq -0x19370(%rip), %rcx    # 0x87120
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
leaq -0x1923f(%rip), %rcx    # 0x87260
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
leaq -0xee(%rip), %rcx       # 0xa03c0
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
leaq 0x14c3(%rip), %rcx      # 0xa1980
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
leaq 0x2484(%rip), %rcx      # 0xa2950
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
leaq 0xd5(%rip), %rcx        # 0xa05b0
movq %rcx, 0x80(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: prv_cmp_simple
static void prv_cmp_simple(subtilis_ir_section_t *s, size_t start,
			   void *user_data, subtilis_arm_instr_type_t itype,
			   subtilis_arm_ccode_type_t ccode,
			   subtilis_error_t *err)
{
	subtilis_arm_reg_t op1;
	subtilis_arm_reg_t op2;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *ir_op = &s->ops[start]->op.instr;

	op1 = subtilis_arm_ir_to_dreg(ir_op->operands[1].reg);
	op2 = subtilis_arm_ir_to_dreg(ir_op->operands[2].reg);

	subtilis_vfp_add_cmp(arm_s, itype, SUBTILIS_ARM_CCODE_AL, op1, op2,
			     err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_vfp_add_sysreg(arm_s, SUBTILIS_VFP_INSTR_FMRX,
				SUBTILIS_ARM_CCODE_AL,
				SUBTILIS_VFP_SYSREG_FPSCR, 15, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6f840
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6f840
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x28(%rbp), %r9
movl $0xe, %edx
callq 0x874f0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa0579
jmp 0xa059b
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %r9
movl $0x7c, %esi
movl $0xe, %edx
movl $0x1, %ecx
movl $0xf, %r8d
callq 0x87630
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_alloc.c
// Function: subtilis_vfp_alloc_init_walker
void subtilis_vfp_alloc_init_walker(subtlis_arm_walker_t *walker,
				    void *user_data)
{
	walker->fpa_data_monadic_fn = prv_alloc_fpa_data_monadic_instr;
	walker->fpa_data_dyadic_fn = prv_alloc_fpa_data_dyadic_instr;
	walker->fpa_stran_fn = prv_alloc_fpa_stran_instr;
	walker->fpa_tran_fn = prv_alloc_fpa_tran_instr;
	walker->fpa_cmp_fn = prv_alloc_fpa_cmp_instr;
	walker->fpa_ldrc_fn = prv_alloc_fpa_ldrc_instr;
	walker->fpa_cptran_fn = prv_alloc_fpa_cptran_instr;
	walker->vfp_stran_fn = prv_alloc_vfp_stran_instr;
	walker->vfp_copy_fn = prv_alloc_vfp_copy_instr;
	walker->vfp_ldrc_fn = prv_alloc_vfp_ldrc_instr;
	walker->vfp_tran_fn = prv_alloc_vfp_tran_instr;
	walker->vfp_tran_dbl_fn = prv_alloc_vfp_tran_dbl_instr;
	walker->vfp_cptran_fn = prv_alloc_vfp_cptran_instr;
	walker->vfp_data_fn = prv_alloc_vfp_data_instr;
	walker->vfp_cmp_fn = prv_alloc_vfp_cmp_instr;
	walker->vfp_sqrt_fn = prv_alloc_vfp_sqrt_instr;
	walker->vfp_sysreg_fn = prv_alloc_vfp_sysreg_instr;
	walker->vfp_cvt_fn = prv_alloc_vfp_cvt_instr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
leaq 0x149(%rip), %rcx       # 0xa0710
movq %rcx, 0x80(%rax)
movq -0x8(%rbp), %rax
leaq 0x177(%rip), %rcx       # 0xa0750
movq %rcx, 0x88(%rax)
movq -0x8(%rbp), %rax
leaq 0x1a5(%rip), %rcx       # 0xa0790
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rax
leaq 0x1d3(%rip), %rcx       # 0xa07d0
movq %rcx, 0x98(%rax)
movq -0x8(%rbp), %rax
leaq 0x201(%rip), %rcx       # 0xa0810
movq %rcx, 0xa0(%rax)
movq -0x8(%rbp), %rax
leaq 0x22f(%rip), %rcx       # 0xa0850
movq %rcx, 0xa8(%rax)
movq -0x8(%rbp), %rax
leaq 0x25d(%rip), %rcx       # 0xa0890
movq %rcx, 0xb0(%rax)
movq -0x8(%rbp), %rax
leaq 0x28b(%rip), %rcx       # 0xa08d0
movq %rcx, 0xb8(%rax)
movq -0x8(%rbp), %rax
leaq 0x4a9(%rip), %rcx       # 0xa0b00
movq %rcx, 0xc0(%rax)
movq -0x8(%rbp), %rax
leaq 0x607(%rip), %rcx       # 0xa0c70
movq %rcx, 0xc8(%rax)
movq -0x8(%rbp), %rax
leaq 0x655(%rip), %rcx       # 0xa0cd0
movq %rcx, 0xd0(%rax)
movq -0x8(%rbp), %rax
leaq 0x7d3(%rip), %rcx       # 0xa0e60
movq %rcx, 0xd8(%rax)
movq -0x8(%rbp), %rax
leaq 0x911(%rip), %rcx       # 0xa0fb0
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rax
leaq 0xb2f(%rip), %rcx       # 0xa11e0
movq %rcx, 0xe8(%rax)
movq -0x8(%rbp), %rax
leaq 0xe2d(%rip), %rcx       # 0xa14f0
movq %rcx, 0xf0(%rax)
movq -0x8(%rbp), %rax
leaq 0x102b(%rip), %rcx      # 0xa1700
movq %rcx, 0xf8(%rax)
movq -0x8(%rbp), %rax
leaq 0x1149(%rip), %rcx      # 0xa1830
movq %rcx, 0x100(%rax)
movq -0x8(%rbp), %rax
leaq 0x1247(%rip), %rcx      # 0xa1940
movq %rcx, 0x108(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_alloc.c
// Function: prv_alloc_vfp_copy_instr
static void prv_alloc_vfp_copy_instr(void *user_data, subtilis_arm_op_t *op,
				     subtilis_arm_instr_type_t type,
				     subtilis_vfp_copy_instr_t *instr,
				     subtilis_error_t *err)
{
	int dist_src;
	size_t vreg_src;

	subtilis_arm_reg_ud_t *ud = user_data;

	switch (type) {
	case SUBTILIS_VFP_INSTR_FCPYS:
	case SUBTILIS_VFP_INSTR_FNEGS:
	case SUBTILIS_VFP_INSTR_FABSS:
		subtilis_error_set_assertion_failed(err);
		return;
	default:
		break;
	}

	vreg_src = instr->src;
	(void)subtilis_arm_reg_alloc_ensure(ud, op, ud->int_regs, ud->real_regs,
					    &instr->src, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	dist_src = subtilis_arm_reg_alloc_calculate_dist(
	    ud, vreg_src, op, &ud->real_regs->dist_walker, ud->real_regs);
	if (dist_src == -1)
		ud->real_regs->phys_to_virt[instr->src] = INT_MAX;

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

	/* Need to check for useless moves */

	if ((type != SUBTILIS_VFP_INSTR_FCPYD) || (instr->src != instr->dest))
		ud->real_regs->next[instr->src] = dist_src;

	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, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
subl $0x4a, %eax
je 0xa0b44
jmp 0xa0b30
movl -0x44(%rbp), %eax
subl $0x4c, %eax
je 0xa0b44
jmp 0xa0b3a
movl -0x44(%rbp), %eax
subl $0x4e, %eax
jne 0xa0b63
jmp 0xa0b44
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0xd932(%rip), %rdx      # 0xae486
movl $0xa3, %ecx
callq 0x148f0
jmp 0xa0c5b
jmp 0xa0b65
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %r8
addq $0x10, %r8
movq -0x28(%rbp), %r9
callq 0x764c0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa0ba8
jmp 0xa0c5b
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x90, %rcx
movq -0x40(%rbp), %rax
movq 0x10(%rax), %r8
callq 0x76020
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0xa0bf5
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x8, %rdx
movq -0x28(%rbp), %rcx
callq 0x76940
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa0c19
jmp 0xa0c5b
cmpl $0x4b, -0x14(%rbp)
jne 0xa0c31
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0xa0c4b
movl -0x2c(%rbp), %edx
movq -0x40(%rbp), %rax
movq 0x10(%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 $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_alloc.c
// Function: prv_alloc_vfp_ldrc_instr
static void prv_alloc_vfp_ldrc_instr(void *user_data, subtilis_arm_op_t *op,
				     subtilis_arm_instr_type_t type,
				     subtilis_vfp_ldrc_instr_t *instr,
				     subtilis_error_t *err)
{
	subtilis_arm_reg_ud_t *ud = user_data;

	subtilis_arm_reg_alloc_alloc_fp_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 0x76940
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa0cb7
jmp 0xa0cc7
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/vfp_alloc.c
// Function: prv_alloc_vfp_tran_dbl_instr
static void prv_alloc_vfp_tran_dbl_instr(void *user_data, subtilis_arm_op_t *op,
					 subtilis_arm_instr_type_t type,
					 subtilis_vfp_tran_dbl_instr_t *instr,
					 subtilis_error_t *err)
{
	size_t vreg_src;
	int dist_src;
	subtilis_arm_reg_ud_t *ud = user_data;

	if (type != SUBTILIS_VFP_INSTR_FMRRD) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	vreg_src = instr->src1;
	(void)subtilis_arm_reg_alloc_ensure(ud, op, ud->int_regs, ud->real_regs,
					    &instr->src1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	dist_src = subtilis_arm_reg_alloc_calculate_dist(
	    ud, vreg_src, op, &ud->real_regs->dist_walker, ud->real_regs);
	if (dist_src == -1)
		ud->real_regs->phys_to_virt[instr->src1] = INT_MAX;

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

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

	ud->real_regs->next[instr->src1] = dist_src;

	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, -0x40(%rbp)
cmpl $0x7e, -0x14(%rbp)
je 0xa0ea8
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0xd5ed(%rip), %rdx      # 0xae486
movl $0x105, %ecx            # imm = 0x105
callq 0x148f0
jmp 0xa0faa
movq -0x20(%rbp), %rax
movq 0x18(%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 0x10(%rax), %rcx
movq -0x20(%rbp), %r8
addq $0x18, %r8
movq -0x28(%rbp), %r9
callq 0x764c0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa0eeb
jmp 0xa0faa
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x90, %rcx
movq -0x40(%rbp), %rax
movq 0x10(%rax), %r8
callq 0x76020
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0xa0f38
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x8, %rdx
movq -0x28(%rbp), %rcx
callq 0x76810
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa0f5c
jmp 0xa0faa
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x10, %rdx
movq -0x28(%rbp), %rcx
callq 0x76810
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa0f80
jmp 0xa0faa
movl -0x34(%rbp), %edx
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%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
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_alloc.c
// Function: prv_alloc_vfp_sqrt_instr
static void prv_alloc_vfp_sqrt_instr(void *user_data, subtilis_arm_op_t *op,
				     subtilis_arm_instr_type_t type,
				     subtilis_vfp_sqrt_instr_t *instr,
				     subtilis_error_t *err)
{
	size_t vreg_op1;
	int dist_op1;
	subtilis_arm_reg_ud_t *ud = user_data;

	if (type == SUBTILIS_VFP_INSTR_FSQRTS) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	vreg_op1 = instr->op1;
	(void)subtilis_arm_reg_alloc_ensure(ud, op, ud->int_regs, ud->real_regs,
					    &instr->op1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	dist_op1 = subtilis_arm_reg_alloc_calculate_dist(
	    ud, vreg_op1, op, &ud->real_regs->dist_walker, ud->real_regs);
	if (dist_op1 == -1)
		ud->real_regs->phys_to_virt[instr->op1] = INT_MAX;

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

	ud->real_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)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x7a, -0x14(%rbp)
jne 0xa1748
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0xcd4d(%rip), %rdx      # 0xae486
movl $0x1ed, %ecx            # imm = 0x1ED
callq 0x148f0
jmp 0xa1826
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 0x10(%rax), %rcx
movq -0x20(%rbp), %r8
addq $0x10, %r8
movq -0x28(%rbp), %r9
callq 0x764c0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa178b
jmp 0xa1826
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x90, %rcx
movq -0x40(%rbp), %rax
movq 0x10(%rax), %r8
callq 0x76020
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0xa17d8
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x8, %rdx
movq -0x28(%rbp), %rcx
callq 0x76940
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa17fc
jmp 0xa1826
movl -0x34(%rbp), %edx
movq -0x40(%rbp), %rax
movq 0x10(%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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_alloc.c
// Function: prv_alloc_vfp_sysreg_instr
static void prv_alloc_vfp_sysreg_instr(void *user_data, subtilis_arm_op_t *op,
				       subtilis_arm_instr_type_t type,
				       subtilis_vfp_sysreg_instr_t *instr,
				       subtilis_error_t *err)
{
	size_t vreg_op1;
	int dist_op1;
	bool fixed_op1 = true;
	subtilis_arm_reg_ud_t *ud = user_data;

	if (type == SUBTILIS_VFP_INSTR_FMRX) {
		subtilis_arm_reg_alloc_alloc_dest(ud, op, &instr->arm_reg, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	} else {
		vreg_op1 = instr->arm_reg;
		fixed_op1 = subtilis_arm_reg_alloc_ensure(
		    ud, op, ud->int_regs, ud->int_regs, &instr->arm_reg, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		if (!fixed_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->arm_reg] =
				    INT_MAX;
		}
	}

	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)
movb $0x1, -0x35(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x7c, -0x14(%rbp)
jne 0xa1889
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x8, %rdx
movq -0x28(%rbp), %rcx
callq 0x76810
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa1884
jmp 0xa1935
jmp 0xa1925
movq -0x20(%rbp), %rax
movq 0x8(%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 $0x8, %r8
movq -0x28(%rbp), %r9
callq 0x764c0
andb $0x1, %al
movb %al, -0x35(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa18ce
jmp 0xa1935
testb $0x1, -0x35(%rbp)
jne 0xa1923
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 0x76020
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0xa1921
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
jmp 0xa1923
jmp 0xa1925
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_dist_vfp_stran_instr
static void prv_dist_vfp_stran_instr(void *user_data, subtilis_arm_op_t *op,
				     subtilis_arm_instr_type_t type,
				     subtilis_vfp_stran_instr_t *instr,
				     subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	if (type == SUBTILIS_VFP_INSTR_FSTS ||
	    type == SUBTILIS_VFP_INSTR_FLDS) {
		subtilis_error_set_assertion_failed(err);
	}

	/*
	 * The function calling code can generate LDFNV and STFNV when
	 * preserving fpa registers.  These instructions should be
	 * ignored for the purposes of register allocation.
	 */

	if (instr->ccode != SUBTILIS_ARM_CCODE_NV) {
		if (type == SUBTILIS_VFP_INSTR_FSTD) {
			if (instr->dest == ud->reg_num) {
				subtilis_error_set_walker_failed(err);
				return;
			}
		} else {
			if (instr->dest == ud->reg_num) {
				ud->last_used = -1;
				subtilis_error_set_walker_failed(err);
				return;
			}
		}
	}

	ud->last_used++;
}

// 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)
cmpl $0x46, -0x14(%rbp)
je 0xa20ef
cmpl $0x47, -0x14(%rbp)
jne 0xa2109
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0xc39e(%rip), %rdx      # 0xae49d
movl $0xed, %ecx
callq 0x148f0
movq -0x20(%rbp), %rax
cmpl $0xf, (%rax)
je 0xa2183
cmpl $0x48, -0x14(%rbp)
jne 0xa2147
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa2145
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xc364(%rip), %rdx      # 0xae49d
movl $0xf9, %ecx
callq 0x148f0
jmp 0xa2190
jmp 0xa2181
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa217f
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xc32a(%rip), %rdx      # 0xae49d
movl $0xff, %ecx
callq 0x148f0
jmp 0xa2190
jmp 0xa2181
jmp 0xa2183
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_dist_vfp_copy_instr
static void prv_dist_vfp_copy_instr(void *user_data, subtilis_arm_op_t *op,
				    subtilis_arm_instr_type_t type,
				    subtilis_vfp_copy_instr_t *instr,
				    subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	switch (type) {
	case SUBTILIS_VFP_INSTR_FCPYS:
	case SUBTILIS_VFP_INSTR_FNEGS:
	case SUBTILIS_VFP_INSTR_FABSS:
		subtilis_error_set_assertion_failed(err);
		return;
	default:
		break;
	}

	if (instr->src == ud->reg_num) {
		subtilis_error_set_walker_failed(err);
		return;
	}

	if (instr->dest == ud->reg_num) {
		ud->last_used = -1;
		subtilis_error_set_walker_failed(err);
		return;
	}

	ud->last_used++;
}

// 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, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x4a, %eax
je 0xa21e4
jmp 0xa21d0
movl -0x34(%rbp), %eax
subl $0x4c, %eax
je 0xa21e4
jmp 0xa21da
movl -0x34(%rbp), %eax
subl $0x4e, %eax
jne 0xa2200
jmp 0xa21e4
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0xc2a9(%rip), %rdx      # 0xae49d
movl $0x113, %ecx            # imm = 0x113
callq 0x148f0
jmp 0xa2274
jmp 0xa2202
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa222f
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xc27a(%rip), %rdx      # 0xae49d
movl $0x11a, %ecx            # imm = 0x11A
callq 0x148f0
jmp 0xa2274
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa2267
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xc242(%rip), %rdx      # 0xae49d
movl $0x120, %ecx            # imm = 0x120
callq 0x148f0
jmp 0xa2274
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_dist_vfp_ldrc_instr
static void prv_dist_vfp_ldrc_instr(void *user_data, subtilis_arm_op_t *op,
				    subtilis_arm_instr_type_t type,
				    subtilis_vfp_ldrc_instr_t *instr,
				    subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	if (instr->dest == ud->reg_num) {
		ud->last_used = -1;
		subtilis_error_set_walker_failed(err);
		return;
	}

	ud->last_used++;
}

// 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 -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa22db
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xc1ce(%rip), %rdx      # 0xae49d
movl $0x130, %ecx            # imm = 0x130
callq 0x148f0
jmp 0xa22e8
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_dist_vfp_tran_instr
static void prv_dist_vfp_tran_instr(void *user_data, subtilis_arm_op_t *op,
				    subtilis_arm_instr_type_t type,
				    subtilis_vfp_tran_instr_t *instr,
				    subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	switch (type) {
	case SUBTILIS_VFP_INSTR_FTOSIS:
	case SUBTILIS_VFP_INSTR_FTOUIS:
	case SUBTILIS_VFP_INSTR_FTOUIZS:
	case SUBTILIS_VFP_INSTR_FTOSIZS:
	case SUBTILIS_VFP_INSTR_FSITOS:
	case SUBTILIS_VFP_INSTR_FUITOS:
		subtilis_error_set_assertion_failed(err);
		return;
	default:
		break;
	}

	if (!instr->use_dregs) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	if (instr->src == ud->reg_num) {
		subtilis_error_set_walker_failed(err);
		return;
	}

	if (instr->dest == ud->reg_num) {
		ud->last_used = -1;
		subtilis_error_set_walker_failed(err);
		return;
	}

	ud->last_used++;
}

// 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, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
addl $-0x52, %eax
subl $0x2, %eax
jb 0xa234b
jmp 0xa2323
movl -0x34(%rbp), %eax
subl $0x55, %eax
je 0xa234b
jmp 0xa232d
movl -0x34(%rbp), %eax
subl $0x57, %eax
je 0xa234b
jmp 0xa2337
movl -0x34(%rbp), %eax
subl $0x59, %eax
je 0xa234b
jmp 0xa2341
movl -0x34(%rbp), %eax
subl $0x5c, %eax
jne 0xa236a
jmp 0xa234b
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0xc142(%rip), %rdx      # 0xae49d
movl $0x145, %ecx            # imm = 0x145
callq 0x148f0
jmp 0xa2404
jmp 0xa236c
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
jne 0xa2392
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0xc117(%rip), %rdx      # 0xae49d
movl $0x14c, %ecx            # imm = 0x14C
callq 0x148f0
jmp 0xa2404
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa23bf
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xc0ea(%rip), %rdx      # 0xae49d
movl $0x151, %ecx            # imm = 0x151
callq 0x148f0
jmp 0xa2404
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa23f7
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xc0b2(%rip), %rdx      # 0xae49d
movl $0x157, %ecx            # imm = 0x157
callq 0x148f0
jmp 0xa2404
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_dist_vfp_tran_dbl_instr
static void prv_dist_vfp_tran_dbl_instr(void *user_data, subtilis_arm_op_t *op,
					subtilis_arm_instr_type_t type,
					subtilis_vfp_tran_dbl_instr_t *instr,
					subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	if (type != SUBTILIS_VFP_INSTR_FMRRD) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	if (instr->src1 == ud->reg_num) {
		subtilis_error_set_walker_failed(err);
		return;
	}

	ud->last_used++;
}

// 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)
cmpl $0x7e, -0x14(%rbp)
je 0xa2455
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0xc054(%rip), %rdx      # 0xae49d
movl $0x166, %ecx            # imm = 0x166
callq 0x148f0
jmp 0xa248f
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa2482
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xc027(%rip), %rdx      # 0xae49d
movl $0x16b, %ecx            # imm = 0x16B
callq 0x148f0
jmp 0xa248f
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_dist_vfp_cptran_instr
static void prv_dist_vfp_cptran_instr(void *user_data, subtilis_arm_op_t *op,
				      subtilis_arm_instr_type_t type,
				      subtilis_vfp_cptran_instr_t *instr,
				      subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	if (!instr->use_dregs) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	if (type != SUBTILIS_VFP_INSTR_FMSR) {
		if (instr->src == ud->reg_num) {
			subtilis_error_set_walker_failed(err);
			return;
		}
	} else {
		if (instr->dest == ud->reg_num) {
			ud->last_used = -1;
			subtilis_error_set_walker_failed(err);
			return;
		}
	}

	ud->last_used++;
}

// 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 -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
jne 0xa24e9
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0xbfc0(%rip), %rdx      # 0xae49d
movl $0x17a, %ecx            # imm = 0x17A
callq 0x148f0
jmp 0xa2565
cmpl $0x5d, -0x14(%rbp)
je 0xa251e
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa251c
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xbf8d(%rip), %rdx      # 0xae49d
movl $0x180, %ecx            # imm = 0x180
callq 0x148f0
jmp 0xa2565
jmp 0xa2558
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa2556
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xbf53(%rip), %rdx      # 0xae49d
movl $0x186, %ecx            # imm = 0x186
callq 0x148f0
jmp 0xa2565
jmp 0xa2558
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_dist_vfp_cmp_instr
static void prv_dist_vfp_cmp_instr(void *user_data, subtilis_arm_op_t *op,
				   subtilis_arm_instr_type_t type,
				   subtilis_vfp_cmp_instr_t *instr,
				   subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	switch (type) {
	case SUBTILIS_VFP_INSTR_FCMPS:
	case SUBTILIS_VFP_INSTR_FCMPES:
	case SUBTILIS_VFP_INSTR_FCMPZS:
	case SUBTILIS_VFP_INSTR_FCMPEZS:
		subtilis_error_set_assertion_failed(err);
		return;
	default:
		break;
	}

	if (type == SUBTILIS_VFP_INSTR_FCMPED ||
	    type == SUBTILIS_VFP_INSTR_FCMPD) {
		if (instr->op2 == ud->reg_num) {
			subtilis_error_set_walker_failed(err);
			return;
		}
	}

	if (instr->op1 == ud->reg_num) {
		subtilis_error_set_walker_failed(err);
		return;
	}

	ud->last_used++;
}

// 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, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x71, %eax
je 0xa276e
jmp 0xa2750
movl -0x34(%rbp), %eax
subl $0x73, %eax
je 0xa276e
jmp 0xa275a
movl -0x34(%rbp), %eax
subl $0x75, %eax
je 0xa276e
jmp 0xa2764
movl -0x34(%rbp), %eax
subl $0x77, %eax
jne 0xa278a
jmp 0xa276e
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0xbd1f(%rip), %rdx      # 0xae49d
movl $0x1d1, %ecx            # imm = 0x1D1
callq 0x148f0
jmp 0xa2801
jmp 0xa278c
cmpl $0x74, -0x14(%rbp)
je 0xa2798
cmpl $0x72, -0x14(%rbp)
jne 0xa27c7
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa27c5
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xbce4(%rip), %rdx      # 0xae49d
movl $0x1da, %ecx            # imm = 0x1DA
callq 0x148f0
jmp 0xa2801
jmp 0xa27c7
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa27f4
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xbcb5(%rip), %rdx      # 0xae49d
movl $0x1e0, %ecx            # imm = 0x1E0
callq 0x148f0
jmp 0xa2801
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_dist_vfp_sqrt_instr
static void prv_dist_vfp_sqrt_instr(void *user_data, subtilis_arm_op_t *op,
				    subtilis_arm_instr_type_t type,
				    subtilis_vfp_sqrt_instr_t *instr,
				    subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	if (instr->op1 == ud->reg_num) {
		subtilis_error_set_walker_failed(err);
		return;
	}

	if (instr->dest == ud->reg_num) {
		ud->last_used = -1;
		subtilis_error_set_walker_failed(err);
		return;
	}

	ud->last_used++;
}

// 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 -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa2860
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xbc49(%rip), %rdx      # 0xae49d
movl $0x1ef, %ecx            # imm = 0x1EF
callq 0x148f0
jmp 0xa28a5
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa2898
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xbc11(%rip), %rdx      # 0xae49d
movl $0x1f5, %ecx            # imm = 0x1F5
callq 0x148f0
jmp 0xa28a5
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_used_vfp_tran_dbl_instr
static void prv_used_vfp_tran_dbl_instr(void *user_data, subtilis_arm_op_t *op,
					subtilis_arm_instr_type_t type,
					subtilis_vfp_tran_dbl_instr_t *instr,
					subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	if (type != SUBTILIS_VFP_INSTR_FMRRD) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	ud->last_used++;
}

// 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)
cmpl $0x7e, -0x14(%rbp)
je 0xa2e55
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0xb654(%rip), %rdx      # 0xae49d
movl $0x2a5, %ecx            # imm = 0x2A5
callq 0x148f0
jmp 0xa2e62
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_used_vfp_cptran_instr
static void prv_used_vfp_cptran_instr(void *user_data, subtilis_arm_op_t *op,
				      subtilis_arm_instr_type_t type,
				      subtilis_vfp_cptran_instr_t *instr,
				      subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	if (!instr->use_dregs) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	if ((type == SUBTILIS_VFP_INSTR_FMSR) && (instr->dest == ud->reg_num)) {
		ud->last_used = -1;
		subtilis_error_set_walker_failed(err);
		return;
	}

	ud->last_used++;
}

// 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 -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
jne 0xa2eb9
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0xb5f0(%rip), %rdx      # 0xae49d
movl $0x2b4, %ecx            # imm = 0x2B4
callq 0x148f0
jmp 0xa2f04
cmpl $0x5d, -0x14(%rbp)
jne 0xa2ef7
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa2ef7
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xb5b2(%rip), %rdx      # 0xae49d
movl $0x2ba, %ecx            # imm = 0x2BA
callq 0x148f0
jmp 0xa2f04
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_used_vfp_data_instr
static void prv_used_vfp_data_instr(void *user_data, subtilis_arm_op_t *op,
				    subtilis_arm_instr_type_t type,
				    subtilis_vfp_data_instr_t *instr,
				    subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	switch (type) {
	case SUBTILIS_VFP_INSTR_FMACS:
	case SUBTILIS_VFP_INSTR_FNMACS:
	case SUBTILIS_VFP_INSTR_FMSCS:
	case SUBTILIS_VFP_INSTR_FNMSCS:
	case SUBTILIS_VFP_INSTR_FMULS:
	case SUBTILIS_VFP_INSTR_FNMULS:
	case SUBTILIS_VFP_INSTR_FADDS:
	case SUBTILIS_VFP_INSTR_FSUBS:
	case SUBTILIS_VFP_INSTR_FDIVS:
		subtilis_error_set_assertion_failed(err);
		return;
	default:
		break;
	}

	if (instr->dest == ud->reg_num) {
		ud->last_used = -1;
		subtilis_error_set_walker_failed(err);
		return;
	}

	ud->last_used++;
}

// 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, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x5f, %eax
je 0xa2f90
jmp 0xa2f40
movl -0x34(%rbp), %eax
subl $0x61, %eax
je 0xa2f90
jmp 0xa2f4a
movl -0x34(%rbp), %eax
subl $0x63, %eax
je 0xa2f90
jmp 0xa2f54
movl -0x34(%rbp), %eax
subl $0x65, %eax
je 0xa2f90
jmp 0xa2f5e
movl -0x34(%rbp), %eax
subl $0x67, %eax
je 0xa2f90
jmp 0xa2f68
movl -0x34(%rbp), %eax
subl $0x69, %eax
je 0xa2f90
jmp 0xa2f72
movl -0x34(%rbp), %eax
subl $0x6b, %eax
je 0xa2f90
jmp 0xa2f7c
movl -0x34(%rbp), %eax
subl $0x6d, %eax
je 0xa2f90
jmp 0xa2f86
movl -0x34(%rbp), %eax
subl $0x6f, %eax
jne 0xa2fac
jmp 0xa2f90
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0xb4fd(%rip), %rdx      # 0xae49d
movl $0x2d2, %ecx            # imm = 0x2D2
callq 0x148f0
jmp 0xa2ff3
jmp 0xa2fae
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa2fe6
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xb4c3(%rip), %rdx      # 0xae49d
movl $0x2da, %ecx            # imm = 0x2DA
callq 0x148f0
jmp 0xa2ff3
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_used_vfp_cmp_instr
static void prv_used_vfp_cmp_instr(void *user_data, subtilis_arm_op_t *op,
				   subtilis_arm_instr_type_t type,
				   subtilis_vfp_cmp_instr_t *instr,
				   subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	switch (type) {
	case SUBTILIS_VFP_INSTR_FCMPS:
	case SUBTILIS_VFP_INSTR_FCMPES:
	case SUBTILIS_VFP_INSTR_FCMPZS:
	case SUBTILIS_VFP_INSTR_FCMPEZS:
		subtilis_error_set_assertion_failed(err);
		return;
	default:
		break;
	}

	ud->last_used++;
}

// 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, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x71, %eax
je 0xa304e
jmp 0xa3030
movl -0x34(%rbp), %eax
subl $0x73, %eax
je 0xa304e
jmp 0xa303a
movl -0x34(%rbp), %eax
subl $0x75, %eax
je 0xa304e
jmp 0xa3044
movl -0x34(%rbp), %eax
subl $0x77, %eax
jne 0xa306a
jmp 0xa304e
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0xb43f(%rip), %rdx      # 0xae49d
movl $0x2ed, %ecx            # imm = 0x2ED
callq 0x148f0
jmp 0xa3079
jmp 0xa306c
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_used_vfp_sqrt_instr
static void prv_used_vfp_sqrt_instr(void *user_data, subtilis_arm_op_t *op,
				    subtilis_arm_instr_type_t type,
				    subtilis_vfp_sqrt_instr_t *instr,
				    subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	if (instr->dest == ud->reg_num) {
		ud->last_used = -1;
		subtilis_error_set_walker_failed(err);
		return;
	}

	ud->last_used++;
}

// 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 -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa30db
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xb3ce(%rip), %rdx      # 0xae49d
movl $0x2ff, %ecx            # imm = 0x2FF
callq 0x148f0
jmp 0xa30e8
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop