LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x49092(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x247bd(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x8670a
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x495c8(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x24794(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
leaq 0x27095(%rip), %rdi     # 0xad7b2
xorl %eax, %eax
callq 0x120f0
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0x38(%rbp)
subq $0x3, %rax
ja 0x86772
movq -0x38(%rbp), %rax
leaq 0x26768(%rip), %rcx     # 0xacea8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x24723(%rip), %rdi     # 0xaae73
movb $0x0, %al
callq 0x120f0
jmp 0x86783
movl $0x8, -0x2c(%rbp)
jmp 0x86772
movl $0x10, -0x2c(%rbp)
jmp 0x86772
movl $0x18, -0x2c(%rbp)
movl -0x2c(%rbp), %esi
leaq 0x27042(%rip), %rdi     # 0xad7be
movb $0x0, %al
callq 0x120f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x867ac
jmp 0x86856
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rsi
leaq 0x24b9e(%rip), %rdi     # 0xab36d
movb $0x0, %al
callq 0x120f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x84300
movq $0x1, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x86856
leaq 0x24673(%rip), %rdi     # 0xaae73
movb $0x0, %al
callq 0x120f0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x24b39(%rip), %rdi     # 0xab36d
movb $0x0, %al
callq 0x120f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x84300
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x867eb
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x86d75
jmp 0x86d6b
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x86d90
jmp 0x86da7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x26a35(%rip), %rdi     # 0xad7b9
movb $0x0, %al
callq 0x120f0
jmp 0x86e18
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x267f5(%rip), %rdi     # 0xad593
movb $0x0, %al
callq 0x120f0
jmp 0x86e18
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x86de5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %ecx
leaq 0x48f77(%rip), %rax     # 0xcfd40
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0x267bb(%rip), %rdi     # 0xad597
movb $0x0, %al
callq 0x120f0
jmp 0x86e16
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %ecx
leaq 0x48f43(%rip), %rax     # 0xcfd40
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
leaq 0x26796(%rip), %rdi     # 0xad5a5
movb $0x0, %al
callq 0x120f0
jmp 0x86e18
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x48911(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x2403c(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x28(%rbp), %rax
cmpl $0xe, (%rax)
je 0x86e8b
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x48e47(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x24013(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x86f40
movq %rax, %rsi
leaq 0x23ff5(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x86f90
movq %rax, %rsi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x267ba(%rip), %rdi     # 0xad681
movb $0x0, %al
callq 0x120f0
testb $0x1, -0x9(%rbp)
je 0x86eea
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x267a1(%rip), %rdi     # 0xad684
movb $0x0, %al
callq 0x120f0
movq -0x28(%rbp), %rax
testb $0x1, 0x20(%rax)
jne 0x86f0c
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rsi
leaq 0x267af(%rip), %rdi     # 0xad6b2
movb $0x0, %al
callq 0x120f0
jmp 0x86f27
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x86ff0
leaq 0x2679f(%rip), %rdi     # 0xad6bf
movb $0x1, %al
callq 0x120f0
leaq 0x23f45(%rip), %rdi     # 0xaae73
movb $0x0, %al
callq 0x120f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_fpa_size
static const char *prv_fpa_size(size_t size)
{
	switch (size) {
	case 4:
		return "s";
	case 10:
		return "e";
	}

	return "d";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
je 0x86f64
jmp 0x86f58
movq -0x18(%rbp), %rax
subq $0xa, %rax
je 0x86f71
jmp 0x86f7e
leaq 0x23f2d(%rip), %rax     # 0xaae98
movq %rax, -0x8(%rbp)
jmp 0x86f89
leaq 0x2360d(%rip), %rax     # 0xaa585
movq %rax, -0x8(%rbp)
jmp 0x86f89
leaq 0x236d7(%rip), %rax     # 0xaa65c
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_extract_rounding
static const char *prv_extract_rounding(subtilis_fpa_rounding_t rnd)
{
	const char *rounding = "";

	switch (rnd) {
	case SUBTILIS_FPA_ROUNDING_NEAREST:
		break;
	case SUBTILIS_FPA_ROUNDING_PLUS_INFINITY:
		rounding = "P";
		break;
	case SUBTILIS_FPA_ROUNDING_MINUS_INFINITY:
		rounding = "M";
		break;
	case SUBTILIS_FPA_ROUNDING_ZERO:
		rounding = "Z";
		break;
	}

	return rounding;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
leaq 0x242d8(%rip), %rax     # 0xab276
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x86fea
movq -0x18(%rbp), %rax
leaq 0x261ae(%rip), %rcx     # 0xad168
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x86fea
leaq 0x231e8(%rip), %rax     # 0xaa1b4
movq %rax, -0x10(%rbp)
jmp 0x86fea
leaq 0x26295(%rip), %rax     # 0xad26e
movq %rax, -0x10(%rbp)
jmp 0x86fea
leaq 0x230b4(%rip), %rax     # 0xaa09a
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x870ad
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
ucomisd -0x18(%rbp), %xmm0
jne 0x8709d
jp 0x8709d
jmp 0x870ad
jmp 0x8709f
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x8706d
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x870d8
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x8711a
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rcx)
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rdx
callq 0x72bc0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x87118
movq $0x0, -0x8(%rbp)
jmp 0x87122
jmp 0x8711a
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa.c
// Function: subtilis_fpa_encode_real
bool subtilis_fpa_encode_real(double real, uint8_t *encoded)
{
	/* clang-format off */

	subtilis_fpa_imm_enc_t encodings[] = {
		{0.0, 0x8}, {1.0, 0x9}, {2.0, 0xA}, {3.0, 0xB}, {4.0, 0xC},
		{5.0, 0xD}, {0.5, 0xE}, {10.0, 0xF}
	};

	/* clang-format on */

	size_t i;

	for (i = 0; i < sizeof(encodings) / sizeof(subtilis_fpa_imm_enc_t); i++)
		if (encodings[i].real == real)
			break;

	if (i == sizeof(encodings) / sizeof(subtilis_fpa_imm_enc_t))
		return false;

	*encoded = encodings[i].encoded;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movsd %xmm0, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
leaq 0x266be(%rip), %rsi     # 0xad810
movl $0x80, %edx
callq 0x12190
movq $0x0, -0xa8(%rbp)
cmpq $0x8, -0xa8(%rbp)
jae 0x871ab
movq -0xa8(%rbp), %rcx
leaq -0xa0(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
ucomisd -0x10(%rbp), %xmm0
jne 0x87195
jp 0x87195
jmp 0x871ab
jmp 0x87197
movq -0xa8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa8(%rbp)
jmp 0x87167
cmpq $0x8, -0xa8(%rbp)
jne 0x871bb
movb $0x0, -0x1(%rbp)
jmp 0x871dd
movq -0xa8(%rbp), %rcx
leaq -0xa0(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movb 0x8(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movb $0x0, -0x45(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x8724d
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0x8725d
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x44(%rbp)
movsd -0x40(%rbp), %xmm0
leaq -0x45(%rbp), %rdi
callq 0x87130
testb $0x1, %al
jne 0x8728a
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
movsd -0x28(%rbp), %xmm0
movq 0x10(%rbp), %rcx
callq 0x87300
jmp 0x872f2
movq -0x8(%rbp), %rdi
movl -0x44(%rbp), %esi
movq 0x10(%rbp), %rdx
callq 0x70b50
movq %rax, -0x30(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x872a9
jmp 0x872f2
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x38(%rbp), %rax
movq $0x8, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x20(%rax)
movb -0x45(%rbp), %cl
movq -0x38(%rbp), %rax
movb %cl, 0x28(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa.c
// Function: prv_add_real_ldr
static size_t prv_add_real_ldr(subtilis_arm_section_t *s,
			       subtilis_arm_ccode_type_t ccode,
			       subtilis_arm_reg_t dest, double op2,
			       subtilis_error_t *err)
{
	subtilis_fpa_ldrc_instr_t *ldrc;
	subtilis_arm_instr_t *instr;
	size_t label = subtilis_arm_get_real_label(s, op2, err);

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

	ldrc = &instr->operands.fpa_ldrc;
	ldrc->ccode = ccode;
	ldrc->dest = dest;
	ldrc->label = label;
	ldrc->size = 8;
	return label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movq -0x30(%rbp), %rsi
callq 0x87050
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl $0x20, %esi
callq 0x70b50
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x8735b
movq $0x0, -0x8(%rbp)
jmp 0x8739c
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq $0x8, 0x10(%rax)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movq 0x10(%rbp), %rdx
callq 0x70b50
movq %rax, -0x30(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x873f0
jmp 0x8743b
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x38(%rbp), %rax
movq $0x8, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
leaq -0x41(%rbp), %rdi
callq 0x87130
andb $0x1, %al
movb %al, -0x59(%rbp)
testb $0x1, -0x59(%rbp)
jne 0x874df
movq -0x8(%rbp), %rdi
callq 0x6ff00
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %r8d
movq -0x50(%rbp), %r9
movsd -0x30(%rbp), %xmm0
movq 0x10(%rbp), %rax
movl $0x21, %edx
movl $0x22, %ecx
movq %rax, (%rsp)
callq 0x871f0
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x874d5
jmp 0x87560
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x874e5
movb -0x41(%rbp), %al
movb %al, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq 0x10(%rbp), %rdx
callq 0x70b50
movq %rax, -0x38(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x87504
jmp 0x87560
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movl -0x10(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x40(%rbp), %rax
movq $0x8, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x18(%rax)
movb -0x59(%rbp), %cl
movq -0x40(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x28(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq 0x18(%rbp), %rdx
callq 0x70b50
movq %rax, -0x30(%rbp)
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x875b4
jmp 0x8760b
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x10(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x38(%rbp), %rax
movq $0x8, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x20(%rax)
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, -0x41(%rbp)
cmpl $0x3ff, -0x24(%rbp)     # imm = 0x3FF
jg 0x87658
cmpl $0xfffffc01, -0x24(%rbp) # imm = 0xFFFFFC01
jge 0x876b0
movq -0x8(%rbp), %rdi
callq 0x6fe60
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
movq -0x40(%rbp), %r8
movq -0x20(%rbp), %r9
movl -0x24(%rbp), %r10d
movq 0x10(%rbp), %rax
movl $0x4, %esi
xorl %ecx, %ecx
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71cd0
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x8769f
jmp 0x87751
movl $0x0, -0x24(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x876d0
cmpl $0x0, -0x24(%rbp)
jge 0x876c2
xorl %eax, %eax
subl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movb $0x1, -0x41(%rbp)
movl -0x24(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq 0x10(%rbp), %rdx
callq 0x70b50
movq %rax, -0x30(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x876ef
jmp 0x87751
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x10(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq $0x8, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x24(%rbp), %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0x20(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x21(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x22(%rax)
movb -0x41(%rbp), %cl
movq -0x38(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x23(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq 0x10(%rbp), %rdx
callq 0x70b50
movq %rax, -0x30(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x877a0
jmp 0x877eb
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x10(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x38(%rbp), %rax
movq $0x8, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movb $0x0, -0x61(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x87859
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x48(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x50(%rbp)
jmp 0x87869
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x50(%rbp)
movsd -0x48(%rbp), %xmm0
leaq -0x61(%rbp), %rdi
callq 0x87130
andb $0x1, %al
movb %al, -0x49(%rbp)
testb $0x1, -0x49(%rbp)
jne 0x878d4
movl -0xc(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6ff00
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x58(%rbp), %r9
movsd -0x28(%rbp), %xmm0
movq -0x30(%rbp), %rax
movl $0x21, %edx
movl $0x22, %ecx
xorl %r8d, %r8d
movq %rax, (%rsp)
callq 0x871f0
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x878ca
jmp 0x87933
movq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x878da
movb -0x61(%rbp), %al
movb %al, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movl -0x50(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x70b50
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x878f9
jmp 0x87933
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movb -0x49(%rbp), %cl
movq -0x40(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x10(%rax)
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x70b50
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x8797d
jmp 0x879b2
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x10(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x70b50
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x879f9
jmp 0x87a1a
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movl -0x10(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
movq 0x10(%rbp), %rcx
movl 0x18(%rbp), %r8d
movq 0x20(%rbp), %r9
callq 0x71060
movq 0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x87a73
jmp 0x87b63
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x20(%rbp), %rcx
movl $0x4, %edx
callq 0x70bc0
movq %rax, -0x30(%rbp)
movq 0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x87a9b
jmp 0x87b63
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movl -0x18(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movb $0x0, 0x4(%rax)
movq 0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq 0x20(%rbp), %rcx
callq 0x70bc0
movq %rax, -0x30(%rbp)
movq 0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x87b0a
jmp 0x87b63
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x18(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq $0x8, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x21(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x22(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x23(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movb $0x0, -0x39(%rbp)
cmpl $0x0, 0x10(%rbp)
jge 0x87bab
xorl %eax, %eax
subl 0x10(%rbp), %eax
movl %eax, 0x10(%rbp)
movb $0x1, -0x39(%rbp)
cmpl $0x3ff, 0x10(%rbp)      # imm = 0x3FF
jle 0x87bd3
movq 0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x25ccc(%rip), %rdx     # 0xad890
movl $0x1ba, %ecx            # imm = 0x1BA
callq 0x158e0
jmp 0x87c5b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq 0x18(%rbp), %rcx
callq 0x70bc0
movq %rax, -0x30(%rbp)
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x87bf6
jmp 0x87c5b
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x18(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq $0x8, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movl 0x10(%rbp), %eax
shrl $0x2, %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0x20(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x21(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x22(%rax)
movb -0x39(%rbp), %cl
movq -0x38(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x23(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa.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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x1f, %esi
callq 0x70b50
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x87ca8
jmp 0x87d01
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq $0x8, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq $0xd, 0x18(%rax)
movq -0x30(%rbp), %rax
movb $0x2, 0x20(%rax)
movq -0x30(%rbp), %rax
movb $0x1, 0x21(%rax)
movq -0x30(%rbp), %rax
movb $0x1, 0x22(%rax)
movq -0x30(%rbp), %rax
movb $0x1, 0x23(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x1e, %esi
callq 0x70b50
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x87d48
jmp 0x87da1
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq $0x8, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq $0xd, 0x18(%rax)
movq -0x30(%rbp), %rax
movb $0x2, 0x20(%rax)
movq -0x30(%rbp), %rax
movb $0x0, 0x21(%rax)
movq -0x30(%rbp), %rax
movb $0x1, 0x22(%rax)
movq -0x30(%rbp), %rax
movb $0x0, 0x23(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa.c
// Function: subtilis_fpa_extract_imm
double subtilis_fpa_extract_imm(subtilis_fpa_op2_t op2, subtilis_error_t *err)
{
	double imm = 0.0;

	switch (op2.imm) {
	case 0x8:
		imm = 0.0;
		break;
	case 0x9:
		imm = 1.0;
		break;
	case 0xA:
		imm = 2.0;
		break;
	case 0xB:
		imm = 3.0;
		break;
	case 0xC:
		imm = 4.0;
		break;
	case 0xD:
		imm = 5.0;
		break;
	case 0xE:
		imm = 0.5;
		break;
	case 0xF:
		imm = 10.0;
		break;
	default:
		subtilis_error_set_assertion_failed(err);
		break;
	}

	return imm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movzbl -0x8(%rbp), %eax
addl $-0x8, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x7, %eax
ja 0x87e68
movq -0x20(%rbp), %rax
leaq 0x25a07(%rip), %rcx     # 0xad7f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x87e82
movsd 0x245e9(%rip), %xmm0    # 0xac3f0
movsd %xmm0, -0x18(%rbp)
jmp 0x87e82
movsd 0x259d2(%rip), %xmm0    # 0xad7e8
movsd %xmm0, -0x18(%rbp)
jmp 0x87e82
movsd 0x259bb(%rip), %xmm0    # 0xad7e0
movsd %xmm0, -0x18(%rbp)
jmp 0x87e82
movsd 0x259a4(%rip), %xmm0    # 0xad7d8
movsd %xmm0, -0x18(%rbp)
jmp 0x87e82
movsd 0x2598d(%rip), %xmm0    # 0xad7d0
movsd %xmm0, -0x18(%rbp)
jmp 0x87e82
movsd 0x25976(%rip), %xmm0    # 0xad7c8
movsd %xmm0, -0x18(%rbp)
jmp 0x87e82
movsd 0x243cf(%rip), %xmm0    # 0xac230
movsd %xmm0, -0x18(%rbp)
jmp 0x87e82
movq -0x10(%rbp), %rdi
movl $0xf, %esi
leaq 0x25a18(%rip), %rdx     # 0xad890
movl $0x216, %ecx            # imm = 0x216
callq 0x158e0
movsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x70b50
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x87ecd
jmp 0x87efa
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp.c
// Function: prv_add_real_ldr
static size_t prv_add_real_ldr(subtilis_arm_section_t *s,
			       subtilis_arm_ccode_type_t ccode,
			       subtilis_arm_reg_t dest, double op2,
			       subtilis_error_t *err)
{
	subtilis_fpa_ldrc_instr_t *ldrc;
	subtilis_arm_instr_t *instr;
	size_t label = subtilis_arm_get_real_label(s, op2, err);

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

	ldrc = &instr->operands.vfp_ldrc;
	ldrc->ccode = ccode;
	ldrc->dest = dest;
	ldrc->label = label;
	return label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movq -0x30(%rbp), %rsi
callq 0x87050
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl $0x50, %esi
callq 0x70b50
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x87f9b
movq $0x0, -0x8(%rbp)
jmp 0x87fd0
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, -0x41(%rbp)
cmpl $0x3ff, -0x24(%rbp)     # imm = 0x3FF
jg 0x88018
cmpl $0xfffffc01, -0x24(%rbp) # imm = 0xFFFFFC01
jge 0x88070
movq -0x8(%rbp), %rdi
callq 0x6fe60
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
movq -0x40(%rbp), %r8
movq -0x20(%rbp), %r9
movl -0x24(%rbp), %r10d
movq 0x10(%rbp), %rax
movl $0x4, %esi
xorl %ecx, %ecx
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71cd0
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x8805f
jmp 0x88105
movl $0x0, -0x24(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x88090
cmpl $0x0, -0x24(%rbp)
jge 0x88082
xorl %eax, %eax
subl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movb $0x1, -0x41(%rbp)
movl -0x24(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq 0x10(%rbp), %rdx
callq 0x70b50
movq %rax, -0x30(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x880af
jmp 0x88105
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x10(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x24(%rbp), %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0x18(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x19(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x1a(%rax)
movb -0x41(%rbp), %cl
movq -0x38(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x1b(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)