LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_vfp_sysreg_instr
static void prv_dump_vfp_sysreg_instr(void *user_data, subtilis_arm_op_t *op,
				      subtilis_arm_instr_type_t type,
				      subtilis_vfp_sysreg_instr_t *instr,
				      subtilis_error_t *err)
{
	const char *sysreg;

	if ((type == SUBTILIS_VFP_INSTR_FMRX) && (instr->arm_reg == 15) &&
	    (instr->sysreg == SUBTILIS_VFP_SYSREG_FPSCR)) {
		printf("\tFMSTAT\n");
		if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
			printf("%s", ccode_desc[instr->ccode]);
		return;
	}

	switch (instr->sysreg) {
	case SUBTILIS_VFP_SYSREG_FPSID:
		sysreg = "FPSID";
		break;
	case SUBTILIS_VFP_SYSREG_FPSCR:
		sysreg = "FPSCR";
		break;
	case SUBTILIS_VFP_SYSREG_FPEXC:
		sysreg = "FPEXC";
		break;
	default:
		subtilis_error_set_assertion_failed(err);
		return;
	}

	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);

	if (type == SUBTILIS_VFP_INSTR_FMRX)
		printf(" R%zu, %s\n", instr->arm_reg, sysreg);
	else
		printf(" %s, R%zu\n", sysreg, instr->arm_reg);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
cmpl $0x7c, %edx
jne 0x586f1
cmpq $0xf, 0x8(%rbx)
jne 0x586f1
cmpl $0x1, 0x4(%rbx)
jne 0x586f1
leaq 0x180da(%rip), %rdi     # 0x707b5
callq 0x12080
movl (%rbx), %eax
cmpq $0xe, %rax
jne 0x58789
popq %rbx
popq %r14
popq %rbp
retq
movl 0x4(%rbx), %eax
cmpq $0x3, %rax
jae 0x58759
leaq 0x496bf(%rip), %rcx     # 0xa1dc0
movq (%rcx,%rax,8), %r14
movl %ebp, %eax
leaq 0x490a2(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x156c5(%rip), %rdi     # 0x6ddde
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x58741
leaq 0x495e1(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x156a5(%rip), %rdi     # 0x6dddf
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rdx
cmpl $0x7c, %ebp
jne 0x58774
leaq 0x17f1b(%rip), %rdi     # 0x7066c
movq %rdx, %rsi
movq %r14, %rdx
jmp 0x5877e
leaq 0x17a9e(%rip), %rdx     # 0x701fe
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x3c4, %ecx            # imm = 0x3C4
popq %rbx
popq %r14
popq %rbp
jmp 0x1429e
leaq 0x17ffc(%rip), %rdi     # 0x70777
movq %r14, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x12110
leaq 0x49580(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x15644(%rip), %rdi     # 0x6dddf
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_vfp_cvt_instr
static void prv_dump_vfp_cvt_instr(void *user_data, subtilis_arm_op_t *op,
				   subtilis_arm_instr_type_t type,
				   subtilis_vfp_cvt_instr_t *instr,
				   subtilis_error_t *err)
{
	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);

	if (type == SUBTILIS_VFP_INSTR_FCVTDS)
		printf(" D%zu, S%zu\n", instr->dest, instr->op1);
	else
		printf(" S%zu, D%zu\n", instr->dest, instr->op1);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movl %edx, %eax
leaq 0x48ff9(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x1561c(%rip), %rdi     # 0x6ddde
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x587ea
leaq 0x49538(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x155fc(%rip), %rdi     # 0x6dddf
xorl %eax, %eax
callq 0x12110
cmpl $0x81, %ebp
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x17f83(%rip), %rax     # 0x70782
leaq 0x17f89(%rip), %rdi     # 0x7078f
cmoveq %rax, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_stran_misc_instr
static void prv_dump_stran_misc_instr(void *user_data, subtilis_arm_op_t *op,
				      subtilis_arm_instr_type_t type,
				      subtilis_arm_stran_misc_instr_t *instr,
				      subtilis_error_t *err)
{
	const char *itype = "";
	const char *sub = instr->subtract ? "-" : "";

	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);
	switch (instr->type) {
	case SUBTILIS_ARM_STRAN_MISC_SB:
		itype = "SB";
		break;
	case SUBTILIS_ARM_STRAN_MISC_SH:
		itype = "SH";
		break;
	case SUBTILIS_ARM_STRAN_MISC_H:
		itype = "H";
		break;
	case SUBTILIS_ARM_STRAN_MISC_D:
		itype = "D";
		break;
	}
	printf("%s R%zu", itype, instr->dest);
	if (instr->pre_indexed) {
		printf(", [R%zu, %s", instr->base, sub);
		if (instr->reg_offset)
			printf("R%zu", instr->offset.reg);
		else
			printf("%d", instr->offset.imm);
		printf("]");
		if (instr->write_back)
			printf("!");
	} else {
		printf(", [R%zu], %s", instr->base, sub);
		if (instr->reg_offset)
			printf("R%zu", instr->offset.reg);
		else
			printf("%d", instr->offset.imm);
	}
	printf("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
leaq 0x181b3(%rip), %r14     # 0x709d9
leaq 0x15598(%rip), %r15     # 0x6ddc5
cmpb $0x0, 0x2a(%rcx)
cmoveq %r15, %r14
movl %edx, %eax
leaq 0x48f72(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x15595(%rip), %rdi     # 0x6ddde
xorl %eax, %eax
callq 0x12110
movl 0x4(%rbx), %eax
cmpq $0xe, %rax
je 0x58872
leaq 0x494b0(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x15574(%rip), %rdi     # 0x6dddf
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0x3, %rax
ja 0x58888
leaq 0x178f3(%rip), %rcx     # 0x70174
movslq (%rcx,%rax,4), %r15
addq %rcx, %r15
movq 0x8(%rbx), %rdx
leaq 0x17d00(%rip), %rdi     # 0x70593
movq %r15, %rsi
xorl %eax, %eax
callq 0x12110
movq 0x10(%rbx), %rsi
cmpb $0x1, 0x28(%rbx)
jne 0x588d2
leaq 0x17d23(%rip), %rdi     # 0x705d1
movq %r14, %rdx
xorl %eax, %eax
callq 0x12110
cmpb $0x1, 0x18(%rbx)
jne 0x588fd
movq 0x20(%rbx), %rsi
leaq 0x17edd(%rip), %rdi     # 0x707a6
xorl %eax, %eax
callq 0x12110
jmp 0x5890f
leaq 0x17d04(%rip), %rdi     # 0x705dd
movq %r14, %rdx
xorl %eax, %eax
callq 0x12110
cmpb $0x1, 0x18(%rbx)
jne 0x58927
movq 0x20(%rbx), %rsi
leaq 0x17eb2(%rip), %rdi     # 0x707a6
xorl %eax, %eax
callq 0x12110
jmp 0x58939
movsbl 0x20(%rbx), %esi
leaq 0x14d31(%rip), %rdi     # 0x6d639
xorl %eax, %eax
callq 0x12110
pushq $0x5d
popq %rdi
callq 0x12030
cmpb $0x1, 0x29(%rbx)
jne 0x58939
pushq $0x21
popq %rdi
callq 0x12030
jmp 0x58939
movsbl 0x20(%rbx), %esi
leaq 0x14d07(%rip), %rdi     # 0x6d639
xorl %eax, %eax
callq 0x12110
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x12030
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_reg_only_instr
static void prv_dump_reg_only_instr(void *user_data, subtilis_arm_op_t *op,
				    subtilis_arm_instr_type_t type,
				    subtilis_arm_reg_only_instr_t *instr,
				    subtilis_error_t *err)
{
	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);

	printf(" R%zu, R%zu, R%zu\n", instr->dest, instr->op1, instr->op2);
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
movl %edx, %eax
leaq 0x48e5d(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x15480(%rip), %rdi     # 0x6ddde
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x58986
leaq 0x4939c(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x15460(%rip), %rdi     # 0x6dddf
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x17c25(%rip), %rdi     # 0x705be
xorl %eax, %eax
popq %rbx
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_signx_instr
static void prv_dump_signx_instr(void *user_data, subtilis_arm_op_t *op,
				 subtilis_arm_instr_type_t type,
				 subtilis_arm_signx_instr_t *instr,
				 subtilis_error_t *err)
{
	int ror = 0;

	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);

	printf(" R%zu, R%zu", instr->dest, instr->op1);
	switch (instr->rotate) {
	case SUBTILIS_ARM_SIGNX_ROR_NONE:
		printf("\n");
		return;
	case SUBTILIS_ARM_SIGNX_ROR_8:
		ror = 8;
		break;
	case SUBTILIS_ARM_SIGNX_ROR_16:
		ror = 16;
		break;
	case SUBTILIS_ARM_SIGNX_ROR_24:
		ror = 24;
		break;
	}

	printf(", ROR %d\n", ror);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %eax
leaq 0x48dff(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x15422(%rip), %rdi     # 0x6ddde
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x12110
movl (%r14), %eax
cmpq $0xe, %rax
je 0x589e7
leaq 0x4933b(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x153ff(%rip), %rdi     # 0x6dddf
xorl %eax, %eax
callq 0x12110
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
leaq 0x17da9(%rip), %rdi     # 0x7079f
xorl %eax, %eax
callq 0x12110
movl 0x4(%r14), %eax
cmpq $0x3, %rax
ja 0x58a31
leaq 0x17442(%rip), %rcx     # 0x6fe50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12030
pushq $0x10
jmp 0x58a30
pushq $0x18
jmp 0x58a30
pushq $0x8
popq %rbx
leaq 0x17d73(%rip), %rdi     # 0x707ab
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: subtilis_arm_prog_dump
void subtilis_arm_prog_dump(subtilis_arm_prog_t *p)
{
	subtilis_arm_section_t *arm_s;
	size_t i;

	if (p->num_sections == 0)
		return;

	arm_s = p->sections[0];
	printf("%s\n", p->string_pool->strings[0]);
	subtilis_arm_section_dump(p, arm_s);

	for (i = 1; i < p->num_sections; i++) {
		printf("\n");
		arm_s = p->sections[i];
		printf("%s\n", p->string_pool->strings[i]);
		subtilis_arm_section_dump(p, arm_s);
	}
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x58abe
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x18(%rdi), %rcx
movq (%rax), %r14
movq (%rcx), %rax
movq (%rax), %rdi
callq 0x12080
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5727c
pushq $0x1
popq %r15
pushq $0xa
popq %rbp
cmpq 0x8(%rbx), %r15
jae 0x58ab4
movl %ebp, %edi
callq 0x12030
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rax,%r15,8), %r14
movq (%rcx), %rax
movq (%rax,%r15,8), %rdi
callq 0x12080
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5727c
incq %r15
jmp 0x58a80
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_op2
static void prv_dump_op2(subtilis_arm_op2_t *op2)
{
	switch (op2->type) {
	case SUBTILIS_ARM_OP2_REG:
		printf("R%zu", op2->op.reg);
		break;
	case SUBTILIS_ARM_OP2_I32:
		printf("#%" PRIu32, op2->op.integer);
		break;
	default:
		if (op2->op.shift.shift_reg)
			printf("R%zu, %s R%zu", op2->op.shift.reg,
			       shift_desc[op2->op.shift.type],
			       op2->op.shift.shift.reg);
		else
			printf("R%zu, %s #%" PRIi32, op2->op.shift.reg,
			       shift_desc[op2->op.shift.type],
			       op2->op.shift.shift.integer);

		break;
	}
}

// Assembly:
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x58c59
testl %eax, %eax
jne 0x58c6a
movq 0x8(%rdi), %rsi
leaq 0x17b54(%rip), %rdi     # 0x707a6
xorl %eax, %eax
jmp 0x12110
movl 0x8(%rdi), %esi
leaq 0x17926(%rip), %rdi     # 0x70589
xorl %eax, %eax
jmp 0x12110
movq 0x8(%rdi), %rsi
movl 0x10(%rdi), %eax
leaq 0x49118(%rip), %rcx     # 0xa1d90
movq (%rcx,%rax,8), %rdx
cmpb $0x1, 0x20(%rdi)
jne 0x58c94
movq 0x18(%rdi), %rcx
leaq 0x17900(%rip), %rdi     # 0x7058d
xorl %eax, %eax
jmp 0x12110
movl 0x18(%rdi), %ecx
leaq 0x178fd(%rip), %rdi     # 0x7059b
xorl %eax, %eax
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_fpa_data
static void prv_dump_fpa_data(void *user_data, bool dyadic,
			      subtilis_arm_op_t *op,
			      subtilis_arm_instr_type_t type,
			      subtilis_fpa_data_instr_t *instr,
			      subtilis_error_t *err)
{
	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);
	printf("%s", prv_fpa_size(instr->size));
	printf("%s F%zu, ", prv_extract_rounding(instr->rounding), instr->dest);
	if (dyadic)
		printf("F%zu, ", instr->op1);
	if (!instr->immediate)
		printf("F%zu", instr->op2.reg);
	else
		printf("#%f", prv_extract_imm(instr->op2));
	printf("\n");
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %edi, %ebp
movl %esi, %eax
leaq 0x48afa(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x1511d(%rip), %rdi     # 0x6ddde
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x58ce9
leaq 0x49039(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x150fd(%rip), %rdi     # 0x6dddf
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rax
cmpq $0xa, %rax
leaq 0x14876(%rip), %rcx     # 0x6d56e
leaq 0x1493b(%rip), %rdx     # 0x6d63a
cmoveq %rcx, %rdx
cmpq $0x4, %rax
leaq 0x150d2(%rip), %rsi     # 0x6dde0
cmovneq %rdx, %rsi
leaq 0x150c6(%rip), %rdi     # 0x6dddf
xorl %eax, %eax
callq 0x12110
movl 0x4(%rbx), %eax
decl %eax
cmpl $0x2, %eax
ja 0x58d39
movl %eax, %eax
leaq 0x490a5(%rip), %rcx     # 0xa1dd8
movq (%rcx,%rax,8), %rsi
jmp 0x58d40
leaq 0x15085(%rip), %rsi     # 0x6ddc5
movq 0x10(%rbx), %rdx
leaq 0x1792c(%rip), %rdi     # 0x70677
xorl %eax, %eax
callq 0x12110
testb %bpl, %bpl
je 0x58d69
movq 0x18(%rbx), %rsi
leaq 0x17918(%rip), %rdi     # 0x7067a
xorl %eax, %eax
callq 0x12110
movq 0x28(%rbx), %rsi
cmpb $0x0, 0x20(%rbx)
je 0x58d8b
movq %rsi, %rdi
callq 0x58da7
leaq 0x17933(%rip), %rdi     # 0x706b5
movb $0x1, %al
callq 0x12110
jmp 0x58d99
leaq 0x17916(%rip), %rdi     # 0x706a8
xorl %eax, %eax
callq 0x12110
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12030
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa.c
// Function: subtilis_arm_get_real_label
size_t subtilis_arm_get_real_label(subtilis_arm_section_t *s, double op2,
				   subtilis_error_t *err)
{
	size_t label;
	size_t i;

	for (i = 0; i < s->constants.real_count; i++)
		if (s->constants.real[i].real == op2)
			break;

	if (i < s->constants.real_count) {
		label = s->constants.real[i].label;
	} else {
		label = s->label_counter++;
		subtilis_arm_add_real_constant(s, label, op2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return 0;
	}

	return label;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x78(%rdi), %rcx
pushq $0x8
popq %rax
subq $0x1, %rcx
jb 0x58e0c
movq 0x70(%rdi), %rdx
movsd -0x8(%rdx,%rax), %xmm1
ucomisd %xmm0, %xmm1
jne 0x58e06
jnp 0x58e2e
addq $0x10, %rax
jmp 0x58dee
movq 0x10(%rdi), %r14
leaq 0x1(%r14), %rax
movq %rax, 0x10(%rdi)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4db6e
xorl %eax, %eax
cmpl $0x0, (%rbx)
cmoveq %r14, %rax
jmp 0x58e32
movq (%rdx,%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa.c
// Function: subtilis_fpa_add_mvfmnf_imm
void subtilis_fpa_add_mvfmnf_imm(subtilis_arm_section_t *s,
				 subtilis_arm_ccode_type_t ccode,
				 subtilis_arm_instr_type_t type,
				 subtilis_arm_instr_type_t alt_type,
				 subtilis_fpa_rounding_t rounding,
				 subtilis_arm_reg_t dest, double op2,
				 subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_fpa_data_instr_t *datai;
	double to_encode;
	subtilis_arm_instr_type_t itype;
	uint8_t encoded = 0;

	if (op2 < 0.0) {
		to_encode = -op2;
		itype = alt_type;
	} else {
		to_encode = op2;
		itype = type;
	}

	if (!subtilis_fpa_encode_real(to_encode, &encoded)) {
		(void)prv_add_real_ldr(s, ccode, dest, op2, err);
		return;
	}

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

	datai = &instr->operands.fpa_data;
	datai->ccode = ccode;
	datai->rounding = rounding;
	datai->size = 8;
	datai->dest = dest;
	datai->immediate = true;
	datai->op2.imm = encoded;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movapd %xmm0, %xmm1
movq %r9, 0x8(%rsp)
movl %r8d, %r15d
movl %ecx, %ebx
movl %edx, %r13d
movl %esi, %ebp
movq %rdi, %r12
movq 0x60(%rsp), %r14
leaq 0x7(%rsp), %rdi
movb $0x0, (%rdi)
movapd 0x16519(%rip), %xmm0    # 0x6f3c0
xorpd %xmm1, %xmm0
movapd %xmm1, 0x10(%rsp)
maxsd %xmm1, %xmm0
callq 0x58e3a
testb %al, %al
je 0x58f05
xorpd %xmm0, %xmm0
ucomisd 0x10(%rsp), %xmm0
cmoval %ebx, %r13d
movq %r12, %rdi
movl %r13d, %esi
movq %r14, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x58f45
movl %ebp, 0x8(%rax)
movl %r15d, 0xc(%rax)
movq $0x8, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x18(%rax)
movb $0x1, 0x28(%rax)
movb 0x7(%rsp), %cl
movb %cl, 0x30(%rax)
jmp 0x58f45
movq %r12, %rdi
movapd 0x10(%rsp), %xmm0
movq %r14, %rsi
callq 0x58de0
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x58f45
movl %ebp, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rbx, 0x20(%rax)
movq $0x8, 0x18(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa.c
// Function: subtilis_fpa_add_mvfmnf
void subtilis_fpa_add_mvfmnf(subtilis_arm_section_t *s,
			     subtilis_arm_ccode_type_t ccode,
			     subtilis_arm_instr_type_t type,
			     subtilis_fpa_rounding_t rounding,
			     subtilis_arm_reg_t dest, subtilis_arm_reg_t op2,
			     subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_fpa_data_instr_t *datai;

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

	datai = &instr->operands.fpa_data;
	datai->ccode = ccode;
	datai->rounding = rounding;
	datai->size = 8;
	datai->dest = dest;
	datai->immediate = false;
	datai->op2.reg = op2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movl %esi, %r15d
movq 0x30(%rsp), %r12
movl %edx, %esi
movq %r12, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x58f98
movl %r15d, 0x8(%rax)
movl %ebp, 0xc(%rax)
movq $0x8, 0x10(%rax)
movq %r14, 0x18(%rax)
movb $0x0, 0x28(%rax)
movq %rbx, 0x30(%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.c
// Function: subtilis_fpa_add_data_imm
void subtilis_fpa_add_data_imm(subtilis_arm_section_t *s,
			       subtilis_arm_instr_type_t itype,
			       subtilis_arm_ccode_type_t ccode,
			       subtilis_fpa_rounding_t rounding,
			       subtilis_arm_reg_t dest, subtilis_arm_reg_t op1,
			       double op2, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_fpa_data_instr_t *datai;
	uint8_t encoded;
	subtilis_arm_reg_t mov_dest;
	subtilis_fpa_op2_t data_opt2;
	bool immediate;

	immediate = subtilis_fpa_encode_real(op2, &encoded);
	if (!immediate) {
		mov_dest = subtilis_arm_acquire_new_freg(s);
		subtilis_fpa_add_mov_imm(s, ccode, rounding, mov_dest, op2,
					 err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		data_opt2.reg = mov_dest;
	} else {
		data_opt2.imm = encoded;
	}

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

	datai = &instr->operands.fpa_data;
	datai->ccode = ccode;
	datai->rounding = rounding;
	datai->size = 8;
	datai->dest = dest;
	datai->op1 = op1;
	datai->immediate = immediate;
	datai->op2 = data_opt2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl %ecx, %ebp
movl %edx, %r13d
movl %esi, 0x1c(%rsp)
movq %rdi, %r14
movq 0x70(%rsp), %rbx
leaq 0x13(%rsp), %rdi
movsd %xmm0, 0x30(%rsp)
callq 0x58e3a
movl %eax, %r12d
testb %al, %al
movl %ebp, 0x18(%rsp)
movl %r13d, 0x14(%rsp)
je 0x58ff1
movb 0x13(%rsp), %r15b
jmp 0x59029
movq %r14, %rdi
callq 0x4c233
movq %rax, %r15
movq %rbx, (%rsp)
pushq $0x21
popq %rdx
pushq $0x22
popq %rcx
movq %r14, %rdi
movl %r13d, %esi
movl %ebp, %r8d
movq %rax, %r9
movsd 0x30(%rsp), %xmm0
callq 0x58e6e
cmpl $0x0, (%rbx)
jne 0x59082
movq %r15, %rbp
shrq $0x8, %rbp
movq %r14, %rdi
movl 0x1c(%rsp), %esi
movq %rbx, %rdx
callq 0x4c92b
cmpl $0x0, (%rbx)
jne 0x59082
movl 0x14(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x18(%rsp), %ecx
movl %ecx, 0xc(%rax)
movq $0x8, 0x10(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x20(%rax)
movb %r12b, 0x28(%rax)
movb %r15b, 0x30(%rax)
movl %ebp, 0x31(%rax)
movq %rbp, %rcx
shrq $0x30, %rcx
movb %cl, 0x37(%rax)
shrq $0x20, %rbp
movw %bp, 0x35(%rax)
addq $0x38, %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.c
// Function: subtilis_fpa_add_data
void subtilis_fpa_add_data(subtilis_arm_section_t *s,
			   subtilis_arm_instr_type_t itype,
			   subtilis_arm_ccode_type_t ccode,
			   subtilis_fpa_rounding_t rounding,
			   subtilis_arm_reg_t dest, subtilis_arm_reg_t op1,
			   subtilis_arm_reg_t op2, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_fpa_data_instr_t *datai;

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

	datai = &instr->operands.fpa_data;
	datai->ccode = ccode;
	datai->rounding = rounding;
	datai->size = 8;
	datai->dest = dest;
	datai->op1 = op1;
	datai->immediate = false;
	datai->op2.reg = op2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %r15d
movq 0x38(%rsp), %r12
movq %r12, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x590dc
movq 0x30(%rsp), %rcx
movl %r15d, 0x8(%rax)
movl %ebp, 0xc(%rax)
movq $0x8, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movb $0x0, 0x28(%rax)
movq %rcx, 0x30(%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.c
// Function: subtilis_fpa_add_stran
void subtilis_fpa_add_stran(subtilis_arm_section_t *s,
			    subtilis_arm_instr_type_t itype,
			    subtilis_arm_ccode_type_t ccode,
			    subtilis_arm_reg_t dest, subtilis_arm_reg_t base,
			    int32_t offset, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_fpa_stran_instr_t *stran;
	subtilis_arm_reg_t mov_dest;
	bool subtract = false;

	if (offset > 1023 || offset < -1023) {
		mov_dest = subtilis_arm_acquire_new_reg(s);
		subtilis_arm_add_data_imm(s, SUBTILIS_ARM_INSTR_ADD, ccode,
					  false, mov_dest, base, offset, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		offset = 0;
		base = mov_dest;
	} else {
		if (offset < 0) {
			offset = -offset;
			subtract = true;
		}
		offset /= 4;
	}

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

	stran = &instr->operands.fpa_stran;
	stran->ccode = ccode;
	stran->size = 8;
	stran->dest = dest;
	stran->base = base;
	stran->offset = (uint8_t)offset;
	stran->pre_indexed = true;
	stran->write_back = false;
	stran->subtract = subtract;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r14d
movq %r8, %rbp
movq %rcx, 0x10(%rsp)
movq %rdi, %rbx
movq 0x50(%rsp), %r12
leal -0x400(%r14), %eax
cmpl $0xfffff800, %eax       # imm = 0xFFFFF800
movl %edx, 0xc(%rsp)
ja 0x59165
movl %edx, %r13d
movl %esi, 0x8(%rsp)
movq %rbx, %rdi
callq 0x4c202
movq %r12, %r10
movq %rax, %r12
pushq $0x4
popq %rsi
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r13d, %edx
xorl %ecx, %ecx
movq %rax, %r8
movq %rbp, %r9
movq %r10, %r13
pushq %r10
pushq %r14
callq 0x4d357
popq %rax
popq %rcx
cmpl $0x0, (%r13)
jne 0x591b3
movq %r12, %rbp
xorl %r14d, %r14d
movq %r13, %r12
movl 0x8(%rsp), %esi
jmp 0x59177
movl %r14d, %r15d
negl %r15d
cmovsl %r14d, %r15d
shrl $0x2, %r15d
shrl $0x1f, %r14d
movq %rbx, %rdi
movq %r12, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x591b3
movl 0xc(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq $0x8, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %rbp, 0x20(%rax)
movb %r15b, 0x28(%rax)
movw $0x1, 0x29(%rax)
movb %r14b, 0x2b(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa.c
// Function: subtilis_fpa_add_tran
void subtilis_fpa_add_tran(subtilis_arm_section_t *s,
			   subtilis_arm_instr_type_t itype,
			   subtilis_arm_ccode_type_t ccode,
			   subtilis_fpa_rounding_t rounding,
			   subtilis_arm_reg_t dest, subtilis_arm_reg_t op2,
			   subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_fpa_tran_instr_t *tran;

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

	tran = &instr->operands.fpa_tran;
	tran->ccode = ccode;
	tran->rounding = rounding;
	tran->size = 8;
	tran->dest = dest;
	tran->op2.reg = op2;
	tran->immediate = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %r15d
movq 0x30(%rsp), %r12
movq %r12, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x59204
movl %r15d, 0x8(%rax)
movl %ebp, 0x30(%rax)
movq $0x8, 0x28(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x20(%rax)
movb $0x0, 0x18(%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.c
// Function: subtilis_fpa_add_cmfcnf_imm
void subtilis_fpa_add_cmfcnf_imm(subtilis_arm_section_t *s,
				 subtilis_arm_instr_type_t type,
				 subtilis_arm_instr_type_t alt_type,
				 subtilis_arm_ccode_type_t ccode,
				 subtilis_arm_reg_t dest, double op2,
				 subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_fpa_cmp_instr_t *cmp;
	double to_encode;
	bool immediate;
	subtilis_arm_instr_type_t itype;
	subtilis_arm_reg_t mov_dest;
	subtilis_fpa_op2_t data_opt2;
	uint8_t encoded = 0;

	if (op2 < 0.0) {
		to_encode = -op2;
		itype = alt_type;
	} else {
		to_encode = op2;
		itype = type;
	}

	immediate = subtilis_fpa_encode_real(to_encode, &encoded);
	if (!immediate) {
		itype = type;
		mov_dest = subtilis_arm_acquire_new_freg(s);
		subtilis_fpa_add_mov_imm(s, ccode,
					 SUBTILIS_FPA_ROUNDING_NEAREST,
					 mov_dest, op2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		data_opt2.reg = mov_dest;
	} else {
		data_opt2.imm = encoded;
	}

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

	cmp = &instr->operands.fpa_cmp;
	cmp->ccode = ccode;
	cmp->dest = dest;
	cmp->immediate = immediate;
	cmp->op2 = data_opt2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r14
movapd %xmm0, %xmm1
movq %r8, 0x18(%rsp)
movl %ecx, %r12d
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r13
leaq 0x13(%rsp), %rdi
movb $0x0, (%rdi)
movapd 0x1617e(%rip), %xmm0    # 0x6f3c0
xorpd %xmm1, %xmm0
movapd %xmm1, 0x20(%rsp)
maxsd %xmm1, %xmm0
callq 0x58e3a
movb %al, 0x12(%rsp)
testb %al, %al
movl %r12d, 0x14(%rsp)
je 0x59277
xorpd %xmm0, %xmm0
ucomisd 0x20(%rsp), %xmm0
cmoval %ebx, %r15d
movb 0x13(%rsp), %bpl
jmp 0x592b0
movq %r13, %rdi
callq 0x4c233
movq %rax, %rbp
movq %r14, (%rsp)
pushq $0x21
popq %rdx
pushq $0x22
popq %rcx
movq %r13, %rdi
movl %r12d, %esi
xorl %r8d, %r8d
movq %rax, %r9
movapd 0x20(%rsp), %xmm0
callq 0x58e6e
cmpl $0x0, (%r14)
jne 0x592f4
movq %rbp, %rbx
shrq $0x8, %rbx
movq %r13, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x592f4
movl 0x14(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movb 0x12(%rsp), %cl
movb %cl, 0x18(%rax)
movb %bpl, 0x20(%rax)
movl %ebx, 0x21(%rax)
movq %rbx, %rcx
shrq $0x30, %rcx
movb %cl, 0x27(%rax)
shrq $0x20, %rbx
movw %bx, 0x25(%rax)
addq $0x38, %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.c
// Function: subtilis_fpa_add_cmp
void subtilis_fpa_add_cmp(subtilis_arm_section_t *s,
			  subtilis_arm_instr_type_t itype,
			  subtilis_arm_ccode_type_t ccode,
			  subtilis_arm_reg_t dest, subtilis_arm_reg_t op2,
			  subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_fpa_cmp_instr_t *tran;

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

	tran = &instr->operands.fpa_cmp;
	tran->ccode = ccode;
	tran->dest = dest;
	tran->op2.reg = op2;
	tran->immediate = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %r9, %rdx
callq 0x4c92b
cmpl $0x0, (%r15)
jne 0x59332
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x20(%rax)
movb $0x0, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa.c
// Function: subtilis_fpa_add_cptran
void subtilis_fpa_add_cptran(subtilis_arm_section_t *s,
			     subtilis_arm_instr_type_t itype,
			     subtilis_arm_ccode_type_t ccode,
			     subtilis_arm_reg_t dest, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_fpa_cptran_instr_t *cptran;

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

	cptran = &instr->operands.fpa_cptran;
	cptran->ccode = ccode;
	cptran->dest = dest;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %r8, %r14
movq %rcx, %rbx
movl %edx, %ebp
movq %r8, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x5935e
movl %ebp, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa.c
// Function: subtilis_fpa_insert_stran_spill_imm
void subtilis_fpa_insert_stran_spill_imm(subtilis_arm_section_t *s,
					 subtilis_arm_op_t *current,
					 subtilis_arm_instr_type_t itype,
					 subtilis_arm_ccode_type_t ccode,
					 subtilis_arm_reg_t dest,
					 subtilis_arm_reg_t base,
					 subtilis_arm_reg_t spill_reg,
					 int32_t offset, subtilis_error_t *err)
/* clang-format on */
{
	subtilis_arm_instr_t *instr;
	subtilis_fpa_stran_instr_t *stran;
	subtilis_arm_data_instr_t *datai;

	(void)subtilis_arm_insert_data_imm_ldr(s, current, ccode, spill_reg,
					       offset, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	instr = subtilis_arm_section_insert_instr(s, current,
						  SUBTILIS_ARM_INSTR_ADD, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	datai = &instr->operands.data;
	datai->ccode = ccode;
	datai->status = false;
	datai->dest = spill_reg;
	datai->op1 = spill_reg;
	datai->op2.type = SUBTILIS_ARM_OP2_REG;
	datai->op2.op.reg = base;

	instr = subtilis_arm_section_insert_instr(s, current, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	stran = &instr->operands.fpa_stran;
	stran->ccode = ccode;
	stran->size = 8;
	stran->dest = dest;
	stran->base = spill_reg;
	stran->offset = 0;
	stran->pre_indexed = false;
	stran->write_back = false;
	stran->subtract = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r13
movq %r8, (%rsp)
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movq 0x50(%rsp), %r15
movq 0x40(%rsp), %rcx
movl 0x48(%rsp), %r8d
movl %ebp, %edx
movq %r15, %r9
callq 0x4cb8b
cmpl $0x0, (%r15)
jne 0x59409
pushq $0x4
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x4c95b
cmpl $0x0, (%r15)
jne 0x59409
movl %ebp, 0x8(%rax)
movb $0x0, 0xc(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rcx, 0x18(%rax)
andl $0x0, 0x20(%rax)
movq %r13, 0x28(%rax)
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
movq %r15, %rcx
callq 0x4c95b
cmpl $0x0, (%r15)
jne 0x59409
movl %ebp, 0x8(%rax)
movq $0x8, 0x10(%rax)
movq (%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x20(%rax)
andl $0x0, 0x28(%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.c
// Function: subtilis_fpa_insert_stran_imm
void subtilis_fpa_insert_stran_imm(subtilis_arm_section_t *s,
				   subtilis_arm_op_t *current,
				   subtilis_arm_instr_type_t itype,
				   subtilis_arm_ccode_type_t ccode,
				   subtilis_arm_reg_t dest,
				   subtilis_arm_reg_t base, int32_t offset,
				   subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_fpa_stran_instr_t *stran;
	bool subtract = false;

	if (offset < 0) {
		offset = -offset;
		subtract = true;
	}

	if (offset > 1023) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	instr = subtilis_arm_section_insert_instr(s, current, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	stran = &instr->operands.fpa_stran;
	stran->ccode = ccode;
	stran->size = 8;
	stran->dest = dest;
	stran->base = base;
	stran->offset = (uint8_t)((uint32_t)offset / 4);
	stran->pre_indexed = true;
	stran->write_back = false;
	stran->subtract = subtract;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x48(%rsp), %r15
movl 0x40(%rsp), %r12d
movl %r12d, %r13d
negl %r13d
cmovsl %r12d, %r13d
cmpl $0x400, %r13d           # imm = 0x400
jb 0x59465
leaq 0x17459(%rip), %rdx     # 0x708a0
pushq $0xf
popq %rsi
movq %r15, %rdi
movl $0x1ba, %ecx            # imm = 0x1BA
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1429e
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movq %r15, %rcx
callq 0x4c95b
cmpl $0x0, (%r15)
jne 0x594a4
movl %ebp, 0x8(%rax)
movq $0x8, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
shrl $0x2, %r13d
movb %r13b, 0x28(%rax)
movw $0x1, 0x29(%rax)
shrl $0x1f, %r12d
movb %r12b, 0x2b(%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.c
// Function: subtilis_fpa_push_reg
void subtilis_fpa_push_reg(subtilis_arm_section_t *s,
			   subtilis_arm_ccode_type_t ccode,
			   subtilis_arm_reg_t dest, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_fpa_stran_instr_t *stran;

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

	stran = &instr->operands.fpa_stran;
	stran->ccode = ccode;
	stran->size = 8;
	stran->dest = dest;
	stran->base = 13;
	stran->offset = 2;
	stran->pre_indexed = true;
	stran->write_back = true;
	stran->subtract = true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
pushq $0x1f
popq %rsi
movq %rcx, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x594ee
movl %ebp, 0x8(%rax)
movq $0x8, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq $0xd, 0x20(%rax)
movl $0x1010102, 0x28(%rax)  # imm = 0x1010102
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/fpa.c
// Function: subtilis_fpa_pop_reg
void subtilis_fpa_pop_reg(subtilis_arm_section_t *s,
			  subtilis_arm_ccode_type_t ccode,
			  subtilis_arm_reg_t dest, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_fpa_stran_instr_t *stran;

	instr = subtilis_arm_section_add_instr(s, SUBTILIS_FPA_INSTR_LDF, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	stran = &instr->operands.fpa_stran;
	stran->ccode = ccode;
	stran->size = 8;
	stran->dest = dest;
	stran->base = 13;
	stran->offset = 2;
	stran->pre_indexed = false;
	stran->write_back = true;
	stran->subtract = false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
pushq $0x1e
popq %rsi
movq %rcx, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x5952e
movl %ebp, 0x8(%rax)
movq $0x8, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq $0xd, 0x20(%rax)
movl $0x10002, 0x28(%rax)    # imm = 0x10002
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/vfp.c
// Function: subtilis_vfp_add_copy
void subtilis_vfp_add_copy(subtilis_arm_section_t *s,
			   subtilis_arm_ccode_type_t ccode,
			   subtilis_arm_instr_type_t itype,
			   subtilis_arm_reg_t dest, subtilis_arm_reg_t src,
			   subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_copy_instr_t *copy;

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

	copy = &instr->operands.vfp_copy;
	copy->ccode = ccode;
	copy->dest = dest;
	copy->src = src;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %rbx
movq %rcx, %r14
movl %esi, %ebp
movl %edx, %esi
movq %r9, %rdx
callq 0x4c92b
cmpl $0x0, (%r15)
jne 0x5959d
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/vfp.c
// Function: subtilis_vfp_add_copy_imm
void subtilis_vfp_add_copy_imm(subtilis_arm_section_t *s,
			       subtilis_arm_ccode_type_t ccode,
			       subtilis_arm_reg_t dest, double src,
			       subtilis_error_t *err)
{
	/*
	 * TODO: If the immediate has no fractional part and it can be
	 * directly encoded, it might be better to mov it into an
	 * integer register and translate.  It's the same number of
	 * instructions and fewer bytes.
	 */

	(void)prv_add_real_ldr(s, ccode, dest, src, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r12
movq %rcx, %rsi
callq 0x58de0
movq %rax, %r14
pushq $0x50
popq %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x4c92b
cmpl $0x0, (%r15)
jne 0x595e5
movl %ebp, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r14, 0x20(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/vfp.c
// Function: subtilis_vfp_add_stran
void subtilis_vfp_add_stran(subtilis_arm_section_t *s,
			    subtilis_arm_instr_type_t itype,
			    subtilis_arm_ccode_type_t ccode,
			    subtilis_arm_reg_t dest, subtilis_arm_reg_t base,
			    int32_t offset, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_stran_instr_t *stran;
	subtilis_arm_reg_t mov_dest;
	bool subtract = false;

	if (offset > 1023 || offset < -1023) {
		mov_dest = subtilis_arm_acquire_new_reg(s);
		subtilis_arm_add_data_imm(s, SUBTILIS_ARM_INSTR_ADD, ccode,
					  false, mov_dest, base, offset, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		offset = 0;
		base = mov_dest;
	} else {
		if (offset < 0) {
			offset = -offset;
			subtract = true;
		}
		offset /= 4;
	}

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

	stran = &instr->operands.vfp_stran;
	stran->ccode = ccode;
	stran->dest = dest;
	stran->base = base;
	stran->offset = (uint8_t)offset;
	stran->pre_indexed = true;
	stran->write_back = false;
	stran->subtract = subtract;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r14d
movq %r8, %rbp
movq %rcx, 0x10(%rsp)
movq %rdi, %rbx
movq 0x50(%rsp), %r12
leal -0x400(%r14), %eax
cmpl $0xfffff800, %eax       # imm = 0xFFFFF800
movl %edx, 0xc(%rsp)
ja 0x5966e
movl %edx, %r13d
movl %esi, 0x8(%rsp)
movq %rbx, %rdi
callq 0x4c202
movq %r12, %r10
movq %rax, %r12
pushq $0x4
popq %rsi
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r13d, %edx
xorl %ecx, %ecx
movq %rax, %r8
movq %rbp, %r9
movq %r10, %r13
pushq %r10
pushq %r14
callq 0x4d357
popq %rax
popq %rcx
cmpl $0x0, (%r13)
jne 0x596b4
movq %r12, %rbp
xorl %r14d, %r14d
movq %r13, %r12
movl 0x8(%rsp), %esi
jmp 0x59680
movl %r14d, %r15d
negl %r15d
cmovsl %r14d, %r15d
shrl $0x2, %r15d
shrl $0x1f, %r14d
movq %rbx, %rdi
movq %r12, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x596b4
movl 0xc(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rbp, 0x18(%rax)
movb %r15b, 0x20(%rax)
movw $0x1, 0x21(%rax)
movb %r14b, 0x23(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/vfp.c
// Function: subtilis_vfp_insert_stran_spill_imm
void subtilis_vfp_insert_stran_spill_imm(subtilis_arm_section_t *s,
					 subtilis_arm_op_t *current,
					 subtilis_arm_instr_type_t itype,
					 subtilis_arm_ccode_type_t ccode,
					 subtilis_arm_reg_t dest,
					 subtilis_arm_reg_t base,
					 subtilis_arm_reg_t spill_reg,
					 int32_t offset, subtilis_error_t *err)
/* clang-format on */
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_stran_instr_t *stran;
	subtilis_arm_data_instr_t *datai;

	(void)subtilis_arm_insert_data_imm_ldr(s, current, ccode, spill_reg,
					       offset, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	instr = subtilis_arm_section_insert_instr(s, current,
						  SUBTILIS_ARM_INSTR_ADD, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	datai = &instr->operands.data;
	datai->ccode = ccode;
	datai->status = false;
	datai->dest = spill_reg;
	datai->op1 = spill_reg;
	datai->op2.type = SUBTILIS_ARM_OP2_REG;
	datai->op2.op.reg = base;

	instr = subtilis_arm_section_insert_instr(s, current, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	stran = &instr->operands.vfp_stran;
	stran->ccode = ccode;
	stran->dest = dest;
	stran->base = spill_reg;
	stran->offset = 0;
	stran->pre_indexed = false;
	stran->write_back = false;
	stran->subtract = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r13
movq %r8, (%rsp)
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movq 0x50(%rsp), %r15
movq 0x40(%rsp), %rcx
movl 0x48(%rsp), %r8d
movl %ebp, %edx
movq %r15, %r9
callq 0x4cb8b
cmpl $0x0, (%r15)
jne 0x59761
pushq $0x4
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x4c95b
cmpl $0x0, (%r15)
jne 0x59761
movl %ebp, 0x8(%rax)
movb $0x0, 0xc(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rcx, 0x18(%rax)
andl $0x0, 0x20(%rax)
movq %r13, 0x28(%rax)
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
movq %r15, %rcx
callq 0x4c95b
cmpl $0x0, (%r15)
jne 0x59761
movl %ebp, 0x8(%rax)
movq (%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x18(%rax)
andl $0x0, 0x20(%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/vfp.c
// Function: subtilis_vfp_insert_stran_imm
void subtilis_vfp_insert_stran_imm(subtilis_arm_section_t *s,
				   subtilis_arm_op_t *current,
				   subtilis_arm_instr_type_t itype,
				   subtilis_arm_ccode_type_t ccode,
				   subtilis_arm_reg_t dest,
				   subtilis_arm_reg_t base, int32_t offset,
				   subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_stran_instr_t *stran;
	bool subtract = false;

	if (offset < 0) {
		offset = -offset;
		subtract = true;
	}

	if (offset > 1023) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	instr = subtilis_arm_section_insert_instr(s, current, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	stran = &instr->operands.vfp_stran;
	stran->ccode = ccode;
	stran->dest = dest;
	stran->base = base;
	stran->offset = (uint8_t)((uint32_t)offset / 4);
	stran->pre_indexed = true;
	stran->write_back = false;
	stran->subtract = subtract;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x48(%rsp), %r15
movl 0x40(%rsp), %r12d
movl %r12d, %r13d
negl %r13d
cmovsl %r12d, %r13d
cmpl $0x400, %r13d           # imm = 0x400
jb 0x597bd
leaq 0x17112(%rip), %rdx     # 0x708b1
pushq $0xf
popq %rsi
movq %r15, %rdi
movl $0xb1, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1429e
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movq %r15, %rcx
callq 0x4c95b
cmpl $0x0, (%r15)
jne 0x597f4
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
shrl $0x2, %r13d
movb %r13b, 0x20(%rax)
movw $0x1, 0x21(%rax)
shrl $0x1f, %r12d
movb %r12b, 0x23(%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/vfp.c
// Function: subtilis_vfp_add_tran
void subtilis_vfp_add_tran(subtilis_arm_section_t *s,
			   subtilis_arm_instr_type_t itype,
			   subtilis_arm_ccode_type_t ccode, bool use_dregs,
			   subtilis_arm_reg_t dest, subtilis_arm_reg_t src,
			   subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_tran_instr_t *tran;

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

	tran = &instr->operands.vfp_tran;
	tran->ccode = ccode;
	tran->use_dregs = use_dregs;
	tran->dest = dest;
	tran->src = src;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %r15d
movq 0x30(%rsp), %r12
movq %r12, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x5983a
movl %r15d, 0x8(%rax)
movb %bpl, 0xc(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/vfp.c
// Function: subtilis_vfp_add_data
void subtilis_vfp_add_data(subtilis_arm_section_t *s,
			   subtilis_arm_instr_type_t itype,
			   subtilis_arm_ccode_type_t ccode,
			   subtilis_arm_reg_t dest, subtilis_arm_reg_t op1,
			   subtilis_arm_reg_t op2, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_data_instr_t *data;

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

	data = &instr->operands.vfp_data;
	data->ccode = ccode;
	data->dest = dest;
	data->op1 = op1;
	data->op2 = op2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movq 0x30(%rsp), %r12
movq %r12, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x598b9
movl %ebp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/vfp.c
// Function: subtilis_vfp_add_cmp
void subtilis_vfp_add_cmp(subtilis_arm_section_t *s,
			  subtilis_arm_instr_type_t itype,
			  subtilis_arm_ccode_type_t ccode,
			  subtilis_arm_reg_t op1, subtilis_arm_reg_t op2,
			  subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_cmp_instr_t *cmp;

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

	cmp = &instr->operands.vfp_cmp;
	cmp->ccode = ccode;
	cmp->op1 = op1;
	cmp->op2 = op2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %r9, %rdx
callq 0x4c92b
cmpl $0x0, (%r15)
jne 0x598ed
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/vfp.c
// Function: subtilis_vfp_add_cmpz
void subtilis_vfp_add_cmpz(subtilis_arm_section_t *s,
			   subtilis_arm_instr_type_t itype,
			   subtilis_arm_ccode_type_t ccode,
			   subtilis_arm_reg_t op1, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_cmp_instr_t *cmp;

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

	cmp = &instr->operands.vfp_cmp;
	cmp->ccode = ccode;
	cmp->op1 = op1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %r8, %r14
movq %rcx, %rbx
movl %edx, %ebp
movq %r8, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x59919
movl %ebp, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/vfp.c
// Function: subtilis_vfp_add_sqrt
void subtilis_vfp_add_sqrt(subtilis_arm_section_t *s,
			   subtilis_arm_instr_type_t itype,
			   subtilis_arm_ccode_type_t ccode,
			   subtilis_arm_reg_t dest, subtilis_arm_reg_t op1,
			   subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_sqrt_instr_t *sqrt;

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

	sqrt = &instr->operands.vfp_sqrt;
	sqrt->ccode = ccode;
	sqrt->dest = dest;
	sqrt->op1 = op1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %r9, %rdx
callq 0x4c92b
cmpl $0x0, (%r15)
jne 0x59949
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq