LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: prv_cmp_imm
static void prv_cmp_imm(subtilis_ir_section_t *s, size_t start, void *user_data,
			subtilis_arm_ccode_type_t ok,
			subtilis_arm_ccode_type_t nok, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *cmp = &s->ops[start]->op.instr;

	op1 = subtilis_arm_ir_to_freg(cmp->operands[1].reg);
	subtilis_fpa_add_cmf_imm(arm_s, SUBTILIS_ARM_CCODE_AL, op1,
				 cmp->operands[2].real, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	dest = subtilis_arm_ir_to_arm_reg(cmp->operands[0].reg);
	subtilis_arm_add_mov_imm(arm_s, ok, false, dest, -1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_arm_add_mov_imm(arm_s, nok, false, dest, 0, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %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 0x70810
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %r8
movq -0x48(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x28(%rbp), %r9
movl $0x40, %esi
movl $0x41, %edx
movl $0xe, %ecx
callq 0x87800
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9fe44
jmp 0x9feba
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %r9
movq -0x28(%rbp), %rax
movl $0xd, %esi
movl $0xf, %edx
xorl %r8d, %r8d
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
movq %rax, 0x8(%rsp)
callq 0x71b10
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9fe8d
jmp 0x9feba
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %ecx
movq -0x30(%rbp), %r9
movq -0x28(%rbp), %rax
movl $0xd, %esi
movl $0xf, %edx
xorl %r8d, %r8d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71b10
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: prv_data_monadic_simple
static void prv_data_monadic_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_instr_t *instr;
	subtilis_fpa_data_instr_t *datai;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *ir_op = &s->ops[start]->op.instr;

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

	datai = &instr->operands.fpa_data;
	datai->ccode = ccode;
	datai->size = 8;
	datai->rounding = SUBTILIS_FPA_ROUNDING_NEAREST;
	datai->dest = subtilis_arm_ir_to_freg(ir_op->operands[0].reg);
	datai->op1 = 0;
	datai->immediate = false;
	datai->op2.reg = subtilis_arm_ir_to_freg(ir_op->operands[1].reg);
}

// 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 -0x40(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x70b50
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa030e
jmp 0xa037e
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x20(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq $0x8, 0x8(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x70810
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x70810
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_log
void subtilis_fpa_gen_log(subtilis_ir_section_t *s, size_t start,
			  void *user_data, subtilis_error_t *err)
{
	subtilis_arm_section_t *arm_s = user_data;

	prv_data_monadic_simple(s, start, user_data, SUBTILIS_FPA_INSTR_LOG,
				SUBTILIS_ARM_CCODE_AL, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	prv_check_divbyzero(arm_s, s, SUBTILIS_ERROR_CODE_LOG_RANGE, 3, err);
}

// 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 -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %r9
movl $0x33, %ecx
movl $0xe, %r8d
callq 0xa02b0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa055b
jmp 0xa0576
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %r8
movl $0x16, %edx
movl $0x3, %ecx
callq 0x9f3b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_ln
void subtilis_fpa_gen_ln(subtilis_ir_section_t *s, size_t start,
			 void *user_data, subtilis_error_t *err)
{
	subtilis_arm_section_t *arm_s = user_data;

	prv_data_monadic_simple(s, start, user_data, SUBTILIS_FPA_INSTR_LGN,
				SUBTILIS_ARM_CCODE_AL, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	prv_check_divbyzero(arm_s, s, SUBTILIS_ERROR_CODE_LOG_RANGE, 3, err);
}

// 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 -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %r9
movl $0x34, %ecx
movl $0xe, %r8d
callq 0xa02b0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa05cb
jmp 0xa05e6
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %r8
movl $0x16, %edx
movl $0x3, %ecx
callq 0x9f3b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_preamble
void subtilis_fpa_gen_preamble(subtilis_arm_section_t *arm_s,
			       subtilis_error_t *err)
{
	subtilis_arm_reg_t mask;
	subtilis_arm_reg_t status;
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *datai;

	mask = subtilis_arm_ir_to_arm_reg(arm_s->reg_counter++);
	status = subtilis_arm_ir_to_arm_reg(arm_s->reg_counter++);

	subtilis_arm_add_mov_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, mask,
				 31 << 16, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mvn_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, mask,
				 mask, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_fpa_add_cptran(arm_s, SUBTILIS_FPA_INSTR_RFS,
				SUBTILIS_ARM_CCODE_AL, status, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

	datai = &instr->operands.data;
	datai->ccode = SUBTILIS_ARM_CCODE_AL;
	datai->dest = status;
	datai->op1 = status;
	datai->op2.type = SUBTILIS_ARM_OP2_REG;
	datai->op2.op.reg = mask;

	subtilis_fpa_add_cptran(arm_s, SUBTILIS_FPA_INSTR_WFS,
				SUBTILIS_ARM_CCODE_AL, status, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x6fe90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x6fe90
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %r9
movq -0x10(%rbp), %rax
movl $0xd, %esi
movl $0xf, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
movl $0x1f0000, (%rsp)       # imm = 0x1F0000
movq %rax, 0x8(%rsp)
callq 0x71b10
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa0731
jmp 0xa0808
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %r8
movq -0x18(%rbp), %r9
movq -0x10(%rbp), %rax
movl $0xf, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x71fa0
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa0764
jmp 0xa0808
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %r8
movl $0x45, %esi
movl $0xe, %edx
callq 0x879c0
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa078a
jmp 0xa0808
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x70b50
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa07a8
jmp 0xa0808
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0xe, (%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %r8
movl $0x44, %esi
movl $0xe, %edx
callq 0x879c0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_movi8tofp
void subtilis_fpa_gen_movi8tofp(subtilis_ir_section_t *s, size_t start,
				void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t src;
	subtilis_arm_reg_t tmp;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *signx = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_freg(signx->operands[0].reg);
	src = subtilis_arm_ir_to_arm_reg(signx->operands[1].reg);
	tmp = subtilis_arm_ir_to_arm_reg(arm_s->reg_counter++);

	subtilis_arm_gen_signx8to32_helper(arm_s, tmp, src, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_fpa_add_tran(arm_s, SUBTILIS_FPA_INSTR_FLT,
			      SUBTILIS_ARM_CCODE_AL,
			      SUBTILIS_FPA_ROUNDING_NEAREST, dest, tmp, 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 -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 0x8(%rax), %rdi
callq 0x70810
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x6fe90
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x75df0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa08a4
jmp 0xa08c9
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x38(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0x3e, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x87760
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_movfptoi32i32
void subtilis_fpa_gen_movfptoi32i32(subtilis_ir_section_t *s, size_t start,
				    void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest1;
	subtilis_arm_reg_t dest2;
	subtilis_arm_reg_t src;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *mov = &s->ops[start]->op.instr;

	dest1 = subtilis_arm_ir_to_arm_reg(mov->operands[0].reg);
	dest2 = subtilis_arm_ir_to_arm_reg(mov->operands[1].reg);
	src = subtilis_arm_ir_to_freg(mov->operands[2].reg);

	/*
	 * TOOD: Need to check for stack overflow.
	 */

	subtilis_fpa_add_stran(arm_s, SUBTILIS_FPA_INSTR_STF,
			       SUBTILIS_ARM_CCODE_AL, src, 13, -8, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_stran_imm(arm_s, SUBTILIS_ARM_INSTR_LDR,
				   SUBTILIS_ARM_CCODE_AL, dest2, 13, -4, false,
				   err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_stran_imm(arm_s, SUBTILIS_ARM_INSTR_LDR,
				   SUBTILIS_ARM_CCODE_AL, dest1, 13, -8, false,
				   err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%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 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x70810
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movl $0x1f, %esi
movl $0xe, %edx
movl $0xd, %r8d
movl $0xfffffff8, %r9d       # imm = 0xFFFFFFF8
movq %rax, (%rsp)
callq 0x87620
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa0971
jmp 0xa09e8
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movl $0x12, %esi
movl $0xe, %edx
movl $0xd, %r8d
movl $0xfffffffc, %r9d       # imm = 0xFFFFFFFC
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x72030
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa09b2
jmp 0xa09e8
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movl $0x12, %esi
movl $0xe, %edx
movl $0xd, %r8d
movl $0xfffffff8, %r9d       # imm = 0xFFFFFFF8
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x72030
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_preserve_regs
size_t subtilis_fpa_preserve_regs(subtilis_arm_section_t *arm_s,
				  int save_real_start, subtilis_error_t *err)
{
	int i;
	size_t stf_site = INT_MAX;

	for (i = save_real_start; i < SUBTILIS_ARM_REG_MAX_FPA_REGS; i++) {
		subtilis_fpa_push_reg(arm_s, SUBTILIS_ARM_CCODE_NV, i, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return INT_MAX;
		if (stf_site == INT_MAX)
			stf_site = arm_s->last_op;
	}

	return stf_site;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x7fffffff, -0x30(%rbp) # imm = 0x7FFFFFFF
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x8, -0x24(%rbp)
jge 0xa0a63
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0xf, %esi
callq 0x87c70
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa0a40
movq $0x7fffffff, -0x8(%rbp) # imm = 0x7FFFFFFF
jmp 0xa0a6b
cmpq $0x7fffffff, -0x30(%rbp) # imm = 0x7FFFFFFF
jne 0xa0a56
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xa0a58
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa0a11
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_restore_regs
size_t subtilis_fpa_restore_regs(subtilis_arm_section_t *arm_s,
				 int save_real_start, subtilis_error_t *err)
{
	int i;
	size_t ldf_site = INT_MAX;

	for (i = SUBTILIS_ARM_REG_MAX_FPA_REGS - 1; i >= save_real_start; i--) {
		subtilis_fpa_pop_reg(arm_s, SUBTILIS_ARM_CCODE_NV, i, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return INT_MAX;
		if (ldf_site == INT_MAX)
			ldf_site = arm_s->last_op;
	}

	return ldf_site;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x7fffffff, -0x30(%rbp) # imm = 0x7FFFFFFF
movl $0x7, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0xa0af6
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0xf, %esi
callq 0x87d10
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa0ad3
movq $0x7fffffff, -0x8(%rbp) # imm = 0x7FFFFFFF
jmp 0xa0afe
cmpq $0x7fffffff, -0x30(%rbp) # imm = 0x7FFFFFFF
jne 0xa0ae9
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xa0aeb
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa0aa2
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_preserve_update
void subtilis_fpa_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 fpa_reg_count;

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

	fpa_reg_count = SUBTILIS_ARM_REG_MAX_FPA_REGS - real_regs_saved;
	op = &arm_s->op_pool->ops[call_site->stf_site];

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

	fpa_reg_count = SUBTILIS_ARM_REG_MAX_FPA_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 << fpa_reg_count))
			op->op.instr.operands.fpa_stran.ccode =
			    SUBTILIS_ARM_CCODE_AL;
		op = &arm_s->op_pool->ops[op->next];
		fpa_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 0xa0b39
movq $0x4, -0x18(%rbp)
jmp 0xa0b46
movl $0x8, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x8, %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 $0x8, -0x40(%rbp)
jae 0xa0bc6
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 0xa0b9d
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 0xa0b6e
movq $0x7, -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 0xa0c58
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 0xa0c23
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 0xa0bf1
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_update_offsets
void subtilis_fpa_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_fpa_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.fpa_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 0xa0cf0
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 0x20(%rax), %ecx
addq %rdx, %rcx
movb %cl, 0x20(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xa0c7c
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_store_double
void subtilis_fpa_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_fpa_stran_instr_t *fstran;

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

	fstran = &instr->operands.fpa_stran;
	fstran->ccode = SUBTILIS_ARM_CCODE_AL;
	fstran->dest = dest;
	fstran->base = base;
	fstran->offset = offset / 4;
	fstran->size = 8;
	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 $0x1f, %esi
callq 0x70b50
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa0d3d
jmp 0xa0da0
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, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
shrq $0x2, %rax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0x20(%rax)
movq -0x38(%rbp), %rax
movq $0x8, 0x8(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x21(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x22(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x23(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_arm_fpa_if_init
void subtilis_arm_fpa_if_init(subtilis_arm_fp_if_t *fp_if)
{
	double dummy_float = 1.0;
	uint32_t *lower_word = (uint32_t *)((void *)&dummy_float);

	fp_if->max_regs = SUBTILIS_ARM_REG_MAX_FPA_REGS;
	fp_if->max_offset = 1023;
	fp_if->store_type = SUBTILIS_FPA_INSTR_STF;
	fp_if->load_type = SUBTILIS_FPA_INSTR_LDF;

	/* Slightly weird but on ARM FPA the words of a double are big endian */
	fp_if->reverse_fpa_consts = (*lower_word) == 0;
	fp_if->preamble_fn = subtilis_fpa_gen_preamble;
	fp_if->preserve_regs_fn = subtilis_fpa_preserve_regs;
	fp_if->restore_regs_fn = subtilis_fpa_restore_regs;
	fp_if->update_regs_fn = subtilis_fpa_preserve_update;
	fp_if->update_offs_fn = subtilis_fpa_update_offsets;
	fp_if->store_dbl_fn = subtilis_fpa_store_double;
	fp_if->mov_reg_fn = subtilis_fpa_mov_reg;
	fp_if->spill_imm_fn = subtilis_fpa_insert_stran_spill_imm;
	fp_if->stran_imm_fn = subtilis_fpa_insert_stran_imm;
	fp_if->is_fixed_fn = subtilis_fpa_is_fixed;
	fp_if->init_dist_walker_fn = subtilis_init_fpa_dist_walker;
	fp_if->init_used_walker_fn = subtilis_init_fpa_used_walker;
	fp_if->init_real_alloc_fn = subtilis_fpa_alloc_init_walker;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd 0xb5e0(%rip), %xmm0     # 0xac3f0
movsd %xmm0, -0x10(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x8, (%rax)
movq -0x8(%rbp), %rax
movl $0x3ff, 0x8(%rax)       # imm = 0x3FF
movq -0x8(%rbp), %rax
movl $0x1f, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x1e, 0x1c(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
sete %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0xc(%rax)
movq -0x8(%rbp), %rax
leaq -0x7b8(%rip), %rcx      # 0xa06b0
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
leaq -0x487(%rip), %rcx      # 0xa09f0
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
leaq -0x406(%rip), %rcx      # 0xa0a80
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
leaq -0x385(%rip), %rcx      # 0xa0b10
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
leaq -0x244(%rip), %rcx      # 0xa0c60
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
leaq -0x1b3(%rip), %rcx      # 0xa0d00
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
leaq -0x112(%rip), %rcx      # 0xa0db0
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
leaq -0x194b1(%rip), %rcx    # 0x87a20
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
leaq -0x19370(%rip), %rcx    # 0x87b70
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
leaq -0x19ebf(%rip), %rcx    # 0x87030
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
leaq 0xee2(%rip), %rcx       # 0xa1de0
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
leaq 0x1b73(%rip), %rcx      # 0xa2a80
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
leaq 0xa4(%rip), %rcx        # 0xa0fc0
movq %rcx, 0x80(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_alloc.c
// Function: subtilis_fpa_alloc_init_walker
void subtilis_fpa_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;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
leaq 0x129(%rip), %rcx       # 0xa1100
movq %rcx, 0x80(%rax)
movq -0x8(%rbp), %rax
leaq 0x257(%rip), %rcx       # 0xa1240
movq %rcx, 0x88(%rax)
movq -0x8(%rbp), %rax
leaq 0x425(%rip), %rcx       # 0xa1420
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rax
leaq 0x613(%rip), %rcx       # 0xa1620
movq %rcx, 0x98(%rax)
movq -0x8(%rbp), %rax
leaq 0x821(%rip), %rcx       # 0xa1840
movq %rcx, 0xa0(%rax)
movq -0x8(%rbp), %rax
leaq 0x9af(%rip), %rcx       # 0xa19e0
movq %rcx, 0xa8(%rax)
movq -0x8(%rbp), %rax
leaq 0x9fd(%rip), %rcx       # 0xa1a40
movq %rcx, 0xb0(%rax)
movq -0x8(%rbp), %rax
leaq 0xb0b(%rip), %rcx       # 0xa1b60
movq %rcx, 0xb8(%rax)
movq -0x8(%rbp), %rax
leaq 0xb39(%rip), %rcx       # 0xa1ba0
movq %rcx, 0xc0(%rax)
movq -0x8(%rbp), %rax
leaq 0xb67(%rip), %rcx       # 0xa1be0
movq %rcx, 0xc8(%rax)
movq -0x8(%rbp), %rax
leaq 0xb95(%rip), %rcx       # 0xa1c20
movq %rcx, 0xd0(%rax)
movq -0x8(%rbp), %rax
leaq 0xbc3(%rip), %rcx       # 0xa1c60
movq %rcx, 0xd8(%rax)
movq -0x8(%rbp), %rax
leaq 0xbf1(%rip), %rcx       # 0xa1ca0
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rax
leaq 0xc1f(%rip), %rcx       # 0xa1ce0
movq %rcx, 0xe8(%rax)
movq -0x8(%rbp), %rax
leaq 0xc4d(%rip), %rcx       # 0xa1d20
movq %rcx, 0xf0(%rax)
movq -0x8(%rbp), %rax
leaq 0xc7b(%rip), %rcx       # 0xa1d60
movq %rcx, 0xf8(%rax)
movq -0x8(%rbp), %rax
leaq 0xca9(%rip), %rcx       # 0xa1da0
movq %rcx, 0x100(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_alloc.c
// Function: prv_alloc_fpa_data_monadic_instr
static void prv_alloc_fpa_data_monadic_instr(void *user_data,
					     subtilis_arm_op_t *op,
					     subtilis_arm_instr_type_t type,
					     subtilis_fpa_data_instr_t *instr,
					     subtilis_error_t *err)
{
	size_t vreg_op2;
	int dist_op2 = -1;
	subtilis_arm_reg_ud_t *ud = user_data;

	if (!instr->immediate) {
		vreg_op2 = instr->op2.reg;
		(void)subtilis_arm_reg_alloc_ensure(
		    ud, op, ud->int_regs, ud->real_regs, &instr->op2.reg, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		dist_op2 = subtilis_arm_reg_alloc_calculate_dist(
		    ud, vreg_op2, op, &ud->real_regs->dist_walker,
		    ud->real_regs);
		if (dist_op2 == -1)
			ud->real_regs->phys_to_virt[instr->op2.reg] = 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 (!instr->immediate &&
	    ((type != SUBTILIS_FPA_INSTR_MVF) || instr->op2.reg != instr->dest))
		ud->real_regs->next[instr->op2.reg] = dist_op2;

	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, -0x34(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x20(%rax)
jne 0xa11ca
movq -0x20(%rbp), %rax
movq 0x28(%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 $0x28, %r8
movq -0x28(%rbp), %r9
callq 0x774b0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa117b
jmp 0xa123a
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 0x77010
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0xa11c8
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
jmp 0xa11ca
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x10, %rdx
movq -0x28(%rbp), %rcx
callq 0x77930
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa11ee
jmp 0xa123a
movq -0x20(%rbp), %rax
testb $0x1, 0x20(%rax)
jne 0xa122a
cmpl $0x21, -0x14(%rbp)
jne 0xa1210
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0xa122a
movl -0x34(%rbp), %edx
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x28(%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/fpa_alloc.c
// Function: prv_alloc_fpa_ldrc_instr
static void prv_alloc_fpa_ldrc_instr(void *user_data, subtilis_arm_op_t *op,
				     subtilis_arm_instr_type_t type,
				     subtilis_fpa_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 0x77930
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa1a27
jmp 0xa1a37
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/fpa_alloc.c
// Function: prv_alloc_fpa_cptran_instr
static void prv_alloc_fpa_cptran_instr(void *user_data, subtilis_arm_op_t *op,
				       subtilis_arm_instr_type_t type,
				       subtilis_fpa_cptran_instr_t *instr,
				       subtilis_error_t *err)
{
	subtilis_arm_reg_ud_t *ud = user_data;
	size_t vreg_dest;
	bool fixed_reg_dest;
	int dist_dest;

	if (type == SUBTILIS_FPA_INSTR_RFS) {
		subtilis_arm_reg_alloc_alloc_dest(ud, op, &instr->dest, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	} else {
		vreg_dest = instr->dest;
		fixed_reg_dest = subtilis_arm_reg_alloc_ensure(
		    ud, op, ud->int_regs, ud->int_regs, &instr->dest, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		if (!fixed_reg_dest) {
			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[instr->dest] =
				    INT_MAX;

			ud->int_regs->next[instr->dest] = dist_dest;
		}
	}

	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, -0x30(%rbp)
cmpl $0x45, -0x14(%rbp)
jne 0xa1a95
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 0xa1a90
jmp 0xa1b59
jmp 0xa1b49
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %r8
addq $0x8, %r8
movq -0x28(%rbp), %r9
callq 0x774b0
andb $0x1, %al
movb %al, -0x39(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa1ada
jmp 0xa1b59
testb $0x1, -0x39(%rbp)
jne 0xa1b47
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x90, %rcx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %r8
callq 0x77010
movl %eax, -0x40(%rbp)
cmpl $-0x1, -0x40(%rbp)
jne 0xa1b2d
movq -0x30(%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
movl -0x40(%rbp), %edx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xa1b49
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_fpa_dist.c
// Function: prv_dist_br_instr
static void prv_dist_br_instr(void *user_data, subtilis_arm_op_t *op,
			      subtilis_arm_instr_type_t type,
			      subtilis_arm_br_instr_t *instr,
			      subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	if ((instr->link_type == SUBTILIS_ARM_BR_LINK_REAL) &&
	    (ud->reg_num == 0)) {
		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
cmpl $0x2, 0x8(%rax)
jne 0xa221e
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xa221e
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xc266(%rip), %rdx      # 0xae478
movl $0x50, %ecx
callq 0x158e0
jmp 0xa222b
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_fpa_dist.c
// Function: prv_dist_fpa_data_monadic_instr
static void prv_dist_fpa_data_monadic_instr(void *user_data,
					    subtilis_arm_op_t *op,
					    subtilis_arm_instr_type_t type,
					    subtilis_fpa_data_instr_t *instr,
					    subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	if (!instr->immediate && ud->reg_num == instr->op2.reg) {
		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
testb $0x1, 0x20(%rax)
jne 0xa23ba
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jne 0xa23ba
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xc0ca(%rip), %rdx      # 0xae478
movl $0xc9, %ecx
callq 0x158e0
jmp 0xa23ff
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa23f2
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xc092(%rip), %rdx      # 0xae478
movl $0xcf, %ecx
callq 0x158e0
jmp 0xa23ff
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_fpa_dist.c
// Function: prv_dist_fpa_stran_instr
static void prv_dist_fpa_stran_instr(void *user_data, subtilis_arm_op_t *op,
				     subtilis_arm_instr_type_t type,
				     subtilis_fpa_stran_instr_t *instr,
				     subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	/*
	 * 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_FPA_INSTR_STF) {
			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)
movq -0x20(%rbp), %rax
cmpl $0xf, (%rax)
je 0xa258d
cmpl $0x1f, -0x14(%rbp)
jne 0xa2551
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa254f
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xbf35(%rip), %rdx      # 0xae478
movl $0xe6, %ecx
callq 0x158e0
jmp 0xa259a
jmp 0xa258b
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa2589
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xbefb(%rip), %rdx      # 0xae478
movl $0xec, %ecx
callq 0x158e0
jmp 0xa259a
jmp 0xa258b
jmp 0xa258d
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_fpa_dist.c
// Function: prv_dist_fpa_cmp_instr
static void prv_dist_fpa_cmp_instr(void *user_data, subtilis_arm_op_t *op,
				   subtilis_arm_instr_type_t type,
				   subtilis_fpa_cmp_instr_t *instr,
				   subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

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

	if (!instr->immediate && instr->op2.reg == 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)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa26a0
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xbde4(%rip), %rdx      # 0xae478
movl $0x114, %ecx            # imm = 0x114
callq 0x158e0
jmp 0xa26e4
movq -0x20(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0xa26d7
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa26d7
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xbdad(%rip), %rdx      # 0xae478
movl $0x119, %ecx            # imm = 0x119
callq 0x158e0
jmp 0xa26e4
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_fpa_dist.c
// Function: prv_dist_fpa_ldrc_instr
static void prv_dist_fpa_ldrc_instr(void *user_data, subtilis_arm_op_t *op,
				    subtilis_arm_instr_type_t type,
				    subtilis_fpa_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 0xa274b
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xbd39(%rip), %rdx      # 0xae478
movl $0x129, %ecx            # imm = 0x129
callq 0x158e0
jmp 0xa2758
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_fpa_dist.c
// Function: prv_used_fpa_data_monadic_instr
static void prv_used_fpa_data_monadic_instr(void *user_data,
					    subtilis_arm_op_t *op,
					    subtilis_arm_instr_type_t type,
					    subtilis_fpa_data_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 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa2d5b
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xb729(%rip), %rdx      # 0xae478
movl $0x1e6, %ecx            # imm = 0x1E6
callq 0x158e0
jmp 0xa2d68
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_fpa_dist.c
// Function: prv_used_fpa_data_dyadic_instr
static void prv_used_fpa_data_dyadic_instr(void *user_data,
					   subtilis_arm_op_t *op,
					   subtilis_arm_instr_type_t type,
					   subtilis_fpa_data_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 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa2dcb
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xb6b9(%rip), %rdx      # 0xae478
movl $0x1d5, %ecx            # imm = 0x1D5
callq 0x158e0
jmp 0xa2dd8
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_fpa_dist.c
// Function: prv_used_fpa_stran_instr
static void prv_used_fpa_stran_instr(void *user_data, subtilis_arm_op_t *op,
				     subtilis_arm_instr_type_t type,
				     subtilis_fpa_stran_instr_t *instr,
				     subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	/*
	 * 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_FPA_INSTR_STF) {
			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
cmpl $0xf, (%rax)
je 0xa2e4e
cmpl $0x1f, -0x14(%rbp)
je 0xa2e4c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa2e4a
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xb63a(%rip), %rdx      # 0xae478
movl $0x1fe, %ecx            # imm = 0x1FE
callq 0x158e0
jmp 0xa2e5b
jmp 0xa2e4c
jmp 0xa2e4e
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_fpa_dist.c
// Function: prv_used_fpa_cmp_instr
static void prv_used_fpa_cmp_instr(void *user_data, subtilis_arm_op_t *op,
				   subtilis_arm_instr_type_t type,
				   subtilis_fpa_cmp_instr_t *instr,
				   subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	if (!instr->immediate && instr->op2.reg == 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)
movq -0x20(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0xa2f4a
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa2f4a
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0xb53a(%rip), %rdx      # 0xae478
movl $0x221, %ecx            # imm = 0x221
callq 0x158e0
jmp 0xa2f57
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)