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

	dest = subtilis_arm_ir_to_freg(instr->operands[0].reg);
	op2 = subtilis_arm_ir_to_freg(instr->operands[1].reg);

	subtilis_fpa_add_mov(arm_s, SUBTILIS_ARM_CCODE_AL,
			     SUBTILIS_FPA_ROUNDING_NEAREST, dest, op2, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movq 0x10(%r12), %rdi
callq 0x4c775
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4c775
movq %rbx, (%rsp)
pushq $0xe
popq %rsi
pushq $0x21
popq %rdx
movq %r14, %rdi
xorl %ecx, %ecx
movq %r15, %r8
movq %rax, %r9
callq 0x58f54
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_movir
void subtilis_fpa_gen_movir(subtilis_ir_section_t *s, size_t start,
			    void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	double op2 = instr->operands[1].real;

	dest = subtilis_arm_ir_to_freg(instr->operands[0].reg);

	subtilis_fpa_add_mov_imm(arm_s, SUBTILIS_ARM_CCODE_AL,
				 SUBTILIS_FPA_ROUNDING_NEAREST, dest, op2, err);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x10(%rax), %rdi
callq 0x4c775
movq %rbx, (%rsp)
pushq $0xe
popq %rsi
pushq $0x21
popq %rdx
pushq $0x22
popq %rcx
movq %r14, %rdi
xorl %r8d, %r8d
movq %rax, %r9
movsd 0x10(%rsp), %xmm0
callq 0x58e6e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_movri32
void subtilis_fpa_gen_movri32(subtilis_ir_section_t *s, size_t start,
			      void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op2;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_arm_reg(instr->operands[0].reg);
	op2 = subtilis_arm_ir_to_freg(instr->operands[1].reg);

	subtilis_fpa_add_tran(arm_s, SUBTILIS_FPA_INSTR_FIX,
			      SUBTILIS_ARM_CCODE_AL, SUBTILIS_FPA_ROUNDING_ZERO,
			      dest, op2, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movq 0x10(%r12), %rdi
callq 0x4c214
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4c775
movq %rbx, (%rsp)
pushq $0x3f
popq %rsi
pushq $0xe
popq %rdx
pushq $0x3
popq %rcx
movq %r14, %rdi
movq %r15, %r8
movq %rax, %r9
callq 0x591c2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_movi32r
void subtilis_fpa_gen_movi32r(subtilis_ir_section_t *s, size_t start,
			      void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op2;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_freg(instr->operands[0].reg);
	op2 = subtilis_arm_ir_to_arm_reg(instr->operands[1].reg);

	subtilis_fpa_add_tran(arm_s, SUBTILIS_FPA_INSTR_FLT,
			      SUBTILIS_ARM_CCODE_AL,
			      SUBTILIS_FPA_ROUNDING_NEAREST, dest, op2, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movq 0x10(%r12), %rdi
callq 0x4c775
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4c214
movq %rbx, (%rsp)
pushq $0x3e
popq %rsi
pushq $0xe
popq %rdx
movq %r14, %rdi
xorl %ecx, %ecx
movq %r15, %r8
movq %rax, %r9
callq 0x591c2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: prv_gen_callr
static void prv_gen_callr(subtilis_ir_section_t *s, size_t start,
			  void *user_data, bool indirect, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_call_t *call = &s->ops[start]->op.call;

	subtilis_arm_gen_call_gen(s, start, user_data,
				  SUBTILIS_ARM_BR_LINK_REAL, indirect, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	dest = subtilis_arm_ir_to_freg(call->reg);
	op1 = 0;

	subtilis_fpa_add_mov(arm_s, SUBTILIS_ARM_CCODE_AL,
			     SUBTILIS_FPA_ROUNDING_NEAREST, dest, op1, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movl %ecx, %r8d
movq %rdx, %rbx
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r15
pushq $0x2
popq %rcx
movq %r14, %r9
callq 0x4e7c3
cmpl $0x0, (%r14)
jne 0x66641
movq 0x18(%r15), %rdi
callq 0x4c775
movq %r14, (%rsp)
pushq $0xe
popq %rsi
pushq $0x21
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x58f54
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: prv_data_simple
static void prv_data_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 = subtilis_arm_ir_to_freg(ir_op->operands[1].reg);
	datai->immediate = false;
	datai->op2.reg = subtilis_arm_ir_to_freg(ir_op->operands[2].reg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r15
movq %rdx, %rdi
movl %ecx, %esi
movq %r8, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x666bc
movq %rax, %rbx
movq $0xe, 0x8(%rax)
movq $0x8, 0x10(%rax)
movq 0x10(%r15), %rdi
callq 0x4c775
movq %rax, 0x18(%rbx)
movq 0x18(%r15), %rdi
callq 0x4c775
movq %rax, 0x20(%rbx)
movb $0x0, 0x28(%rbx)
movq 0x20(%r15), %rdi
callq 0x4c775
movq %rax, 0x30(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: prv_data_simple_imm
static void prv_data_simple_imm(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 dest;
	subtilis_arm_reg_t op1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	double op2 = instr->operands[2].real;

	dest = subtilis_arm_ir_to_freg(instr->operands[0].reg);
	op1 = subtilis_arm_ir_to_freg(instr->operands[1].reg);

	subtilis_fpa_add_data_imm(arm_s, itype, ccode,
				  SUBTILIS_FPA_ROUNDING_NEAREST, dest, op1, op2,
				  err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movsd 0x20(%r12), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%r12), %rdi
callq 0x4c775
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4c775
movq %rbx, (%rsp)
pushq $0xe
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
xorl %ecx, %ecx
movq %r15, %r8
movq %rax, %r9
movsd 0x8(%rsp), %xmm0
callq 0x58fa1
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: prv_stran_instr
static void prv_stran_instr(subtilis_arm_instr_type_t itype,
			    subtilis_ir_section_t *s, size_t start,
			    void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t base;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	int32_t offset = instr->operands[2].integer;

	dest = subtilis_arm_ir_to_freg(instr->operands[0].reg);
	base = subtilis_arm_ir_to_arm_reg(instr->operands[1].reg);

	subtilis_fpa_add_stran(arm_s, itype, SUBTILIS_ARM_CCODE_AL, dest, base,
			       offset, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movl %edi, %ebp
movq 0x48(%rsi), %rax
movq (%rax,%rdx,8), %r13
movl 0x20(%r13), %r15d
movq 0x10(%r13), %rdi
callq 0x4c775
movq %rax, %r12
movq 0x18(%r13), %rdi
callq 0x4c214
movq %rbx, (%rsp)
pushq $0xe
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rcx
movq %rax, %r8
movl %r15d, %r9d
callq 0x590e5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_retr
void subtilis_fpa_gen_retr(subtilis_ir_section_t *s, size_t start,
			   void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	subtilis_arm_reg_t op2;

	dest = 0;
	op2 = subtilis_arm_ir_to_freg(instr->operands[0].reg);

	subtilis_fpa_add_mov(arm_s, SUBTILIS_ARM_CCODE_AL,
			     SUBTILIS_FPA_ROUNDING_NEAREST, dest, op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_arm_gen_ret(s, start, user_data, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %rax
movq 0x10(%rax), %rdi
callq 0x4c775
movq %rbx, (%rsp)
pushq $0xe
popq %rsi
pushq $0x21
popq %rdx
movq %r14, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rax, %r9
callq 0x58f54
cmpl $0x0, (%rbx)
je 0x669f9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4ed92
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_retir
void subtilis_fpa_gen_retir(subtilis_ir_section_t *s, size_t start,
			    void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	double op2 = instr->operands[0].real;

	dest = 0;

	subtilis_fpa_add_mov_imm(arm_s, SUBTILIS_ARM_CCODE_AL,
				 SUBTILIS_FPA_ROUNDING_NEAREST, dest, op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_arm_gen_ret(s, start, user_data, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %rax
movsd 0x10(%rax), %xmm0
movq %rcx, (%rsp)
pushq $0xe
popq %rsi
pushq $0x21
popq %rdx
pushq $0x22
popq %rcx
movq %r14, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x58e6e
cmpl $0x0, (%rbx)
je 0x66a62
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4ed92
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: prv_cmp_jmp_imm
static void prv_cmp_jmp_imm(subtilis_ir_section_t *s, size_t start,
			    void *user_data, subtilis_arm_ccode_type_t ccode,
			    subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_br_instr_t *br;
	subtilis_arm_reg_t op1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *cmp = &s->ops[start]->op.instr;
	subtilis_ir_inst_t *jmp = &s->ops[start + 1]->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;

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

	br = &instr->operands.br;
	br->ccode = ccode;
	br->link = false;
	br->link_type = SUBTILIS_ARM_BR_LINK_VOID;
	br->target.label = jmp->operands[2].label;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movl %ecx, %ebx
movq %rdx, %r15
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r13
movq 0x8(%rax,%rsi,8), %r12
movq 0x18(%r13), %rdi
callq 0x4c775
movsd 0x20(%r13), %xmm0
pushq $0x40
popq %rsi
pushq $0x41
popq %rdx
pushq $0xe
popq %rcx
movq %r15, %rdi
movq %rax, %r8
movq %r14, %r9
callq 0x5920d
cmpl $0x0, (%r14)
jne 0x66af8
pushq $0x16
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x66af8
movl %ebx, 0x8(%rax)
movb $0x0, 0xc(%rax)
andl $0x0, 0x10(%rax)
movq 0x20(%r12), %rcx
movq %rcx, 0x18(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: prv_cmp_jmp
static void prv_cmp_jmp(subtilis_ir_section_t *s, size_t start, void *user_data,
			subtilis_arm_ccode_type_t ccode, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_br_instr_t *br;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *jmp = &s->ops[start + 1]->op.instr;

	prv_cmp_simple(s, start, user_data, SUBTILIS_FPA_INSTR_CMF,
		       SUBTILIS_ARM_CCODE_AL, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

	br = &instr->operands.br;
	br->ccode = ccode;
	br->link = false;
	br->link_type = SUBTILIS_ARM_BR_LINK_VOID;
	br->target.label = jmp->operands[2].label;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %ecx, %ebx
movq %rdx, %r15
movq 0x48(%rdi), %rax
movq 0x8(%rax,%rsi,8), %r12
movq %r8, %rcx
callq 0x6739e
cmpl $0x0, (%r14)
jne 0x66b8f
pushq $0x16
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x66b8f
movl %ebx, 0x8(%rax)
movb $0x0, 0xc(%rax)
andl $0x0, 0x10(%rax)
movq 0x20(%r12), %rcx
movq %rcx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %r15
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movq 0x18(%r12), %rdi
callq 0x4c775
movsd 0x20(%r12), %xmm0
pushq $0x40
popq %rsi
pushq $0x41
popq %rdx
pushq $0xe
popq %rcx
movq %r14, %rdi
movq %rax, %r8
movq %r15, %r9
callq 0x5920d
cmpl $0x0, (%r15)
jne 0x66c6f
movq 0x10(%r12), %rdi
callq 0x4c214
movq %rax, %r12
movq %r15, 0x8(%rsp)
orl $-0x1, (%rsp)
pushq $0xd
popq %rsi
pushq $0xf
popq %rdx
movq %r14, %rdi
movl %ebp, %ecx
xorl %r8d, %r8d
movq %rax, %r9
callq 0x4d213
cmpl $0x0, (%r15)
jne 0x66c6f
movq %r15, 0x8(%rsp)
andl $0x0, (%rsp)
pushq $0xd
popq %rsi
pushq $0xf
popq %rdx
movq %r14, %rdi
movl %ebx, %ecx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x4d213
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %r8, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r15
movq %rdx, %rdi
movl %ecx, %esi
movq %r8, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x66e06
movq %rax, %rbx
movq $0xe, 0x8(%rax)
movq $0x8, 0x10(%rax)
movq 0x10(%r15), %rdi
callq 0x4c775
movq %rax, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
movb $0x0, 0x28(%rbx)
movq 0x18(%r15), %rdi
callq 0x4c775
movq %rax, 0x30(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x1(%rdi), %rax
movq %rax, (%r14)
callq 0x4c214
movq %rax, %r15
movq (%r14), %rdi
leaq 0x1(%rdi), %rax
movq %rax, (%r14)
callq 0x4c214
movq %rax, %r12
pushq $0xd
popq %rsi
pushq $0xf
popq %rdx
pushq $0xe
popq %rcx
movq %r14, %rdi
xorl %r8d, %r8d
movq %r15, %r9
pushq %rbx
pushq $0x1f0000               # imm = 0x1F0000
callq 0x4d213
popq %rax
popq %rcx
cmpl $0x0, (%rbx)
jne 0x66f80
subq $0x8, %rsp
pushq $0xf
popq %rsi
pushq $0xe
popq %rdx
movq %r14, %rdi
xorl %ecx, %ecx
movq %r15, %r8
movq %r15, %r9
pushq %rbx
callq 0x4d518
popq %rax
popq %rcx
cmpl $0x0, (%rbx)
jne 0x66f80
pushq $0x45
popq %rsi
pushq $0xe
popq %rdx
movq %r14, %rdi
movq %r12, %rcx
movq %rbx, %r8
callq 0x5933d
cmpl $0x0, (%rbx)
jne 0x66f80
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x4c92b
cmpl $0x0, (%rbx)
je 0x66f8c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0xe, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %r12, 0x18(%rax)
andl $0x0, 0x20(%rax)
movq %r15, 0x28(%rax)
pushq $0x44
popq %rsi
pushq $0xe
popq %rdx
movq %r14, %rdi
movq %r12, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5933d
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movq 0x10(%r12), %rdi
callq 0x4c775
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4c214
movq %rax, %r13
movq (%rbx), %rdi
leaq 0x1(%rdi), %rax
movq %rax, (%rbx)
callq 0x4c214
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x4f2d8
cmpl $0x0, (%r14)
jne 0x6703a
movq %r14, (%rsp)
pushq $0x3e
popq %rsi
pushq $0xe
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
movq %r15, %r8
movq %r12, %r9
callq 0x591c2
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r13
movq 0x10(%r13), %rdi
callq 0x4c214
movq %rax, %r15
movq 0x18(%r13), %rdi
callq 0x4c214
movq %rax, %r12
movq 0x20(%r13), %rdi
callq 0x4c775
subq $0x8, %rsp
pushq $0x1f
popq %rsi
pushq $0xe
popq %rdx
pushq $0xd
popq %r8
pushq $-0x8
popq %r9
movq %r14, %rdi
movq %rax, %rcx
pushq %rbx
callq 0x590e5
popq %rax
popq %rcx
cmpl $0x0, (%rbx)
jne 0x670e6
pushq $0x12
popq %rsi
pushq $0xe
popq %rdx
pushq $0xd
popq %r8
pushq $-0x4
popq %r9
movq %r14, %rdi
movq %r12, %rcx
pushq %rbx
pushq $0x0
callq 0x4d55b
popq %rax
popq %rcx
cmpl $0x0, (%rbx)
jne 0x670e6
pushq $0x12
popq %rsi
pushq $0xe
popq %rdx
pushq $0xd
popq %r8
pushq $-0x8
popq %r9
movq %r14, %rdi
movq %r15, %rcx
pushq %rbx
pushq $0x0
callq 0x4d55b
popq %rax
popq %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %r15
movslq %esi, %r12
movl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
pushq $0xf
popq %rbp
cmpq $0x7, %r12
jg 0x6713c
movq %r15, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %r14, %rcx
callq 0x594b3
cmpl $0x0, (%r14)
jne 0x67137
cmpq $0x7fffffff, %rbx       # imm = 0x7FFFFFFF
jne 0x67132
movq 0x28(%r15), %rbx
incq %r12
jmp 0x67109
movl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %r15
movslq %esi, %r13
movl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
pushq $0x7
popq %r12
pushq $0xf
popq %rbp
cmpq %r13, %r12
jl 0x6719a
movq %r15, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %r14, %rcx
callq 0x594f3
cmpl $0x0, (%r14)
jne 0x67195
cmpq $0x7fffffff, %rbx       # imm = 0x7FFFFFFF
jne 0x67190
movq 0x28(%r15), %rbx
decq %r12
jmp 0x67168
movl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/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:
movq %rcx, %rax
pushq $0x8
popq %rcx
movq %rcx, %r9
subq %rdx, %r9
cmpq $0x5, %rdx
pushq $0x4
popq %r8
cmovaeq %r8, %r9
subq %r9, %rcx
movq 0x38(%rdi), %r9
movq (%r9), %r9
imulq $0x68, 0x18(%rsi), %r10
addq %r9, %r10
cmpq $0x7, %rcx
ja 0x671fe
btq %rcx, %rax
jae 0x671f1
movl $0xe, 0x10(%r10)
movq 0x38(%rdi), %r9
movq (%r9), %r9
imulq $0x68, 0x58(%r10), %r10
addq %r9, %r10
incq %rcx
jmp 0x671d6
imulq $0x68, 0x10(%rsi), %rsi
addq %r9, %rsi
cmpq $0x5, %rdx
movq %r8, %rcx
cmovaeq %rdx, %rcx
subq %rcx, %rdx
pushq $0x1
popq %r10
cmpq %r8, %rdx
je 0x6724a
leaq 0x3(%r8), %rcx
movl %r10d, %r11d
shll %cl, %r11d
movslq %r11d, %rcx
testq %rax, %rcx
je 0x6723d
movl $0xe, 0x10(%rsi)
movq 0x38(%rdi), %rcx
movq (%rcx), %r9
imulq $0x68, 0x58(%rsi), %rsi
addq %r9, %rsi
decq %r8
jmp 0x67218
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
pushq $0x1f
popq %rsi
movq %r8, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x672c5
movl $0xe, 0x8(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
shrl $0x2, %ebx
movb %bl, 0x28(%rax)
movq $0x8, 0x10(%rax)
movw $0x1, 0x29(%rax)
movb $0x1, 0x2b(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq $0x8, (%rdi)
movl $0x3ff, 0x8(%rdi)       # imm = 0x3FF
movabsq $0x1e0000001f, %rax     # imm = 0x1E0000001F
movq %rax, 0x18(%rdi)
movb $0x1, 0xc(%rdi)
leaq -0x435(%rip), %rax      # 0x66edd
movq %rax, 0x20(%rdi)
leaq -0x22d(%rip), %rax      # 0x670f0
movq %rax, 0x28(%rdi)
leaq -0x1e0(%rip), %rax      # 0x67148
movq %rax, 0x30(%rdi)
leaq -0x187(%rip), %rax      # 0x671ac
movq %rax, 0x38(%rdi)
leaq -0xf3(%rip), %rax       # 0x6724b
movq %rax, 0x40(%rdi)
leaq -0xd1(%rip), %rax       # 0x67278
movq %rax, 0x48(%rdi)
leaq -0x83(%rip), %rax       # 0x672d1
movq %rax, 0x50(%rdi)
leaq -0xdffc(%rip), %rax     # 0x59363
movq %rax, 0x58(%rdi)
leaq -0xdf52(%rip), %rax     # 0x59418
movq %rax, 0x60(%rdi)
leaq -0xe59d(%rip), %rax     # 0x58dd8
movq %rax, 0x68(%rdi)
leaq 0x918(%rip), %rax       # 0x67c98
movq %rax, 0x70(%rdi)
leaq 0xdf3(%rip), %rax       # 0x6817e
movq %rax, 0x78(%rdi)
leaq 0x5a(%rip), %rax        # 0x673f0
movq %rax, 0x80(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa_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_freg(ir_op->operands[1].reg);
	op2 = subtilis_arm_ir_to_freg(ir_op->operands[2].reg);

	subtilis_fpa_add_cmp(arm_s, itype, ccode, op1, op2, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movq 0x18(%r12), %rdi
callq 0x4c775
movq %rax, %r15
movq 0x20(%r12), %rdi
callq 0x4c775
pushq $0x40
popq %rsi
pushq $0xe
popq %rdx
movq %r14, %rdi
movq %r15, %rcx
movq %rax, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x59303
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0xe8(%rip), %rax        # 0x674df
movq %rax, 0x80(%rdi)
leaq 0x1bc(%rip), %rax       # 0x675c1
movq %rax, 0x88(%rdi)
leaq 0x2f3(%rip), %rax       # 0x67706
movq %rax, 0x90(%rdi)
leaq 0x459(%rip), %rax       # 0x6787a
movq %rax, 0x98(%rdi)
leaq 0x5bb(%rip), %rax       # 0x679ea
movq %rax, 0xa0(%rdi)
leaq 0x6a6(%rip), %rax       # 0x67ae3
movq %rax, 0xa8(%rdi)
leaq 0x6c0(%rip), %rax       # 0x67b0b
movq %rax, 0xb0(%rdi)
leaq 0x759(%rip), %rax       # 0x67bb2
movq %rax, 0xb8(%rdi)
leaq 0x762(%rip), %rax       # 0x67bc9
movq %rax, 0xc0(%rdi)
leaq 0x76b(%rip), %rax       # 0x67be0
movq %rax, 0xc8(%rdi)
leaq 0x774(%rip), %rax       # 0x67bf7
movq %rax, 0xd0(%rdi)
leaq 0x77d(%rip), %rax       # 0x67c0e
movq %rax, 0xd8(%rdi)
leaq 0x786(%rip), %rax       # 0x67c25
movq %rax, 0xe0(%rdi)
leaq 0x78f(%rip), %rax       # 0x67c3c
movq %rax, 0xe8(%rdi)
leaq 0x798(%rip), %rax       # 0x67c53
movq %rax, 0xf0(%rdi)
leaq 0x7a1(%rip), %rax       # 0x67c6a
movq %rax, 0xf8(%rdi)
leaq 0x7aa(%rip), %rax       # 0x67c81
movq %rax, 0x100(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r14
movl %edx, 0x4(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
pushq $-0x1
popq %r13
cmpb $0x0, 0x20(%rcx)
je 0x67549
leaq 0x10(%r14), %rbp
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x4fed3
cmpl $0x0, (%r15)
jne 0x67570
cmpb $0x0, 0x20(%r14)
jne 0x67543
movq 0x28(%r14), %rax
cmpl $0x21, 0x4(%rsp)
jne 0x67537
cmpq (%rbp), %rax
je 0x67543
movq 0x10(%rbx), %rcx
movq 0x10(%rcx), %rcx
movl %r13d, (%rcx,%rax,4)
incq 0x20(%rbx)
jmp 0x67570
leaq 0x28(%r14), %rbp
movq 0x28(%r14), %r13
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %r8
movq %r15, %r9
callq 0x4fc53
cmpl $0x0, (%r15)
je 0x6757f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rbx), %r8
leaq 0x90(%r8), %rcx
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x4f9f0
movl %eax, %r13d
cmpl $-0x1, %eax
jne 0x67504
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rbp), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
pushq $-0x1
popq %r13
jmp 0x67504
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa_alloc.c
// Function: prv_alloc_fpa_data_dyadic_instr
static void prv_alloc_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)
{
	int dist_op1;
	int dist_op2 = -1;
	size_t vreg_op1;
	size_t vreg_op2;
	subtilis_arm_reg_ud_t *ud = user_data;

	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;

	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;
	}

	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;
	if (!instr->immediate)
		ud->real_regs->next[instr->op2.reg] = dist_op2;

	ud->instr_count++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x18(%rcx), %r13
movq 0x18(%rcx), %rbp
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
movq %r13, %r8
movq %r15, %r9
callq 0x4fc53
cmpl $0x0, (%r15)
jne 0x676b1
movq 0x10(%rbx), %r8
pushq $-0x1
popq %rax
movl %eax, 0x4(%rsp)
cmpb $0x0, 0x20(%r14)
je 0x67681
leaq 0x90(%r8), %rcx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x4f9f0
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x67642
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rax
movq (%r13), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
leaq 0x10(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x4fed3
cmpl $0x0, (%r15)
jne 0x676b1
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x18(%r14), %rcx
movl %ebp, (%rax,%rcx,4)
cmpb $0x0, 0x20(%r14)
jne 0x6767b
movq 0x28(%r14), %rcx
movl 0x4(%rsp), %edx
movl %edx, (%rax,%rcx,4)
incq 0x20(%rbx)
jmp 0x676b1
leaq 0x28(%r14), %r9
movq 0x28(%r14), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %r12, %rsi
movq %r8, %rcx
movq %r9, 0x8(%rsp)
movq %r9, %r8
movq %r15, %r9
callq 0x4fc53
cmpl $0x0, (%r15)
je 0x676c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rbx), %r8
leaq 0x90(%r8), %rcx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
callq 0x4f9f0
movq 0x10(%rbx), %r8
cmpl $-0x1, %eax
je 0x676ed
movl %eax, 0x4(%rsp)
jmp 0x67612
movq 0x8(%r8), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
jmp 0x67612
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa_alloc.c
// Function: prv_alloc_fpa_cmp_instr
static void prv_alloc_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)
{
	int dist_dest;
	int dist_op2;
	size_t vreg_dest;
	size_t vreg_op2;
	subtilis_arm_reg_ud_t *ud = user_data;

	vreg_dest = instr->dest;
	(void)subtilis_arm_reg_alloc_ensure(ud, op, ud->int_regs, ud->real_regs,
					    &instr->dest, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	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;
		ud->real_regs->next[instr->op2.reg] = dist_op2;
	}

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

	ud->instr_count++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbp
movq %rcx, %r13
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rcx), %r14
movq 0x8(%rcx), %r12
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
movq %r14, %r8
movq %rbp, %r9
callq 0x4fc53
cmpl $0x0, (%rbp)
jne 0x67ad4
movq 0x10(%rbx), %r8
cmpb $0x0, 0x10(%r13)
jne 0x67a99
movq 0x18(%r13), %rax
movq %rax, (%rsp)
addq $0x18, %r13
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r8, %rcx
movq %r13, %r8
movq %rbp, %r9
callq 0x4fc53
cmpl $0x0, (%rbp)
jne 0x67ad4
movq 0x10(%rbx), %r8
leaq 0x90(%r8), %rcx
movq %rbx, %rdi
movq (%rsp), %rsi
movq %r15, %rdx
callq 0x4f9f0
movq 0x10(%rbx), %r8
cmpl $-0x1, %eax
jne 0x67a8e
movq 0x8(%r8), %rcx
movq (%r13), %rdx
movq $0x7fffffff, (%rcx,%rdx,8) # imm = 0x7FFFFFFF
movq 0x10(%r8), %rcx
movq (%r13), %rdx
movl %eax, (%rcx,%rdx,4)
leaq 0x90(%r8), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4f9f0
movq 0x10(%rbx), %rcx
cmpl $-0x1, %eax
jne 0x67ac6
movq 0x8(%rcx), %rdx
movq (%r14), %rsi
movq $0x7fffffff, (%rdx,%rsi,8) # imm = 0x7FFFFFFF
movq 0x10(%rcx), %rcx
movq (%r14), %rdx
movl %eax, (%rcx,%rdx,4)
incq 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x8, %r14
cmpl $0x45, %edx
jne 0x67b43
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x4fe30
cmpl $0x0, (%r12)
jne 0x67ba8
jmp 0x67ba4
movq (%r14), %r13
movq 0x8(%rbx), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %rcx, %rdx
movq %r14, %r8
movq %r12, %r9
callq 0x4fc53
cmpl $0x0, (%r12)
jne 0x67ba8
testb %al, %al
jne 0x67ba4
movq 0x8(%rbx), %r8
leaq 0x90(%r8), %rcx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x4f9f0
movq 0x8(%rbx), %rcx
cmpl $-0x1, %eax
jne 0x67b9a
movq 0x8(%rcx), %rdx
movq (%r14), %rsi
movq $0x7fffffff, (%rdx,%rsi,8) # imm = 0x7FFFFFFF
movq 0x10(%rcx), %rcx
movq (%r14), %rdx
movl %eax, (%rcx,%rdx,4)
incq 0x20(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_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:
movq (%rdi), %rax
cmpb $0x0, 0x20(%rcx)
jne 0x67ed9
cmpq 0x28(%rcx), %rax
jne 0x67ed9
leaq 0x9113(%rip), %rdx      # 0x70fdc
pushq $0x1f
popq %rsi
movq %r8, %rdi
movl $0xc9, %ecx
jmp 0x1429e
cmpq %rax, 0x10(%rcx)
jne 0x67efa
orl $-0x1, 0x8(%rdi)
leaq 0x90f2(%rip), %rdx      # 0x70fdc
pushq $0x1f
popq %rsi
movq %r8, %rdi
movl $0xcf, %ecx
jmp 0x1429e
incl 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq (%rdi), %rax
cmpq %rax, 0x8(%rcx)
jne 0x6802a
leaq 0x8fc2(%rip), %rdx      # 0x70fdc
pushq $0x1f
popq %rsi
movq %r8, %rdi
movl $0x114, %ecx            # imm = 0x114
jmp 0x1429e
cmpb $0x0, 0x10(%rcx)
jne 0x6804d
cmpq %rax, 0x18(%rcx)
jne 0x6804d
leaq 0x8f9f(%rip), %rdx      # 0x70fdc
pushq $0x1f
popq %rsi
movq %r8, %rdi
movl $0x119, %ecx            # imm = 0x119
jmp 0x1429e
incl 0x8(%rdi)
retq