LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x44dbf(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x17412(%rip), %rdi     # 0x73e0e
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x12110
movl (%r14), %eax
cmpq $0xe, %rax
je 0x5ca27
leaq 0x452fb(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x173ef(%rip), %rdi     # 0x73e0f
xorl %eax, %eax
callq 0x12110
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
leaq 0x19db9(%rip), %rdi     # 0x767ef
xorl %eax, %eax
callq 0x12110
movl 0x4(%r14), %eax
cmpq $0x3, %rax
ja 0x5ca7b
leaq 0x19452(%rip), %rcx     # 0x75ea0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12030
movl $0x10, %ebx
jmp 0x5ca7b
movl $0x18, %ebx
jmp 0x5ca7b
movl $0x8, %ebx
leaq 0x19d79(%rip), %rdi     # 0x767fb
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O1/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 0x5cb08
pushq %r15
pushq %r14
pushq %rbx
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 0x5b224
cmpq $0x2, 0x8(%rbx)
jb 0x5cb03
movl $0x1, %r15d
movl $0xa, %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 0x5b224
incq %r15
cmpq 0x8(%rbx), %r15
jb 0x5cace
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5ccba
testl %eax, %eax
jne 0x5cccb
movq 0x8(%rdi), %rsi
leaq 0x19b43(%rip), %rdi     # 0x767f6
xorl %eax, %eax
jmp 0x12110
movl 0x8(%rdi), %esi
leaq 0x19915(%rip), %rdi     # 0x765d9
xorl %eax, %eax
jmp 0x12110
movq 0x8(%rdi), %rsi
movl 0x10(%rdi), %eax
leaq 0x450b7(%rip), %rcx     # 0xa1d90
movq (%rcx,%rax,8), %rdx
cmpb $0x1, 0x20(%rdi)
jne 0x5ccf5
movq 0x18(%rdi), %rcx
leaq 0x198ef(%rip), %rdi     # 0x765dd
xorl %eax, %eax
jmp 0x12110
movl 0x18(%rdi), %ecx
leaq 0x198ec(%rip), %rdi     # 0x765eb
xorl %eax, %eax
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0xc10, %rsp            # imm = 0xC10
movq %rdx, %rbx
movl %edi, %ebp
movl %esi, %eax
leaq 0x44a91(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x170e4(%rip), %rdi     # 0x73e0e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5cd52
leaq 0x44fd0(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x170c4(%rip), %rdi     # 0x73e0f
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rax
cmpq $0xa, %rax
leaq 0x16813(%rip), %rcx     # 0x73574
leaq 0x168e4(%rip), %rdx     # 0x7364c
cmoveq %rcx, %rdx
cmpq $0x4, %rax
leaq 0x17099(%rip), %rsi     # 0x73e10
cmovneq %rdx, %rsi
leaq 0x1708d(%rip), %rdi     # 0x73e0f
xorl %eax, %eax
callq 0x12110
movl 0x4(%rbx), %eax
decl %eax
cmpl $0x2, %eax
ja 0x5cda2
movl %eax, %eax
leaq 0x4503c(%rip), %rcx     # 0xa1dd8
movq (%rcx,%rax,8), %rsi
jmp 0x5cda9
leaq 0x1704c(%rip), %rsi     # 0x73df5
movq 0x10(%rbx), %rdx
leaq 0x19913(%rip), %rdi     # 0x766c7
xorl %eax, %eax
callq 0x12110
testb %bpl, %bpl
je 0x5cdd2
movq 0x18(%rbx), %rsi
leaq 0x198ff(%rip), %rdi     # 0x766ca
xorl %eax, %eax
callq 0x12110
movq 0x28(%rbx), %r14
cmpb $0x0, 0x20(%rbx)
je 0x5ce04
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
callq 0x14404
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5d649
leaq 0x1990a(%rip), %rdi     # 0x76705
movb $0x1, %al
callq 0x12110
jmp 0x5ce15
leaq 0x198ed(%rip), %rdi     # 0x766f8
movq %r14, %rsi
xorl %eax, %eax
callq 0x12110
movl $0xa, %edi
callq 0x12030
addq $0xc10, %rsp            # imm = 0xC10
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
testq %rcx, %rcx
setne %sil
je 0x5ce99
movq 0x70(%rdi), %rdx
movsd (%rdx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x5ce5c
jp 0x5ce5c
xorl %eax, %eax
jmp 0x5ce85
addq $0x10, %rdx
leaq -0x1(%rcx), %rsi
xorl %eax, %eax
cmpq %rax, %rsi
je 0x5ce99
movsd (%rdx), %xmm1
addq $0x10, %rdx
incq %rax
ucomisd %xmm0, %xmm1
jne 0x5ce66
jp 0x5ce66
cmpq %rcx, %rax
setb %sil
testb %sil, %sil
je 0x5ce99
movq 0x70(%rdi), %rcx
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %rax
jmp 0x5ceb9
movq 0x10(%rdi), %r14
leaq 0x1(%r14), %rax
movq %rax, 0x10(%rdi)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x50df8
xorl %eax, %eax
cmpl $0x0, (%rbx)
cmoveq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %r9, %rbx
movl %r8d, %r14d
movl %esi, %ebp
movapd 0x184cb(%rip), %xmm1    # 0x753f0
xorpd %xmm0, %xmm1
ucomisd %xmm0, %xmm1
movq %rdi, %r12
cmoval %ecx, %edx
movq 0x40(%rsp), %r15
maxsd %xmm0, %xmm1
leaq 0x198ed(%rip), %rcx     # 0x76830
xorl %eax, %eax
movsd (%rcx), %xmm2
ucomisd %xmm1, %xmm2
jne 0x5cf51
jnp 0x5cf63
incq %rax
addq $0x10, %rcx
cmpq $0x8, %rax
jne 0x5cf45
movl $0x8, %eax
cmpq $0x8, %rax
jne 0x5cf6e
xorl %r13d, %r13d
jmp 0x5cf81
movq %rax, %rcx
shlq $0x4, %rcx
leaq 0x198b4(%rip), %rsi     # 0x76830
movb 0x8(%rcx,%rsi), %r13b
cmpq $0x8, %rax
jne 0x5cfc0
movq %r12, %rdi
movq %r15, %rsi
callq 0x5ce34
movq %rax, %r14
movq %r12, %rdi
movl $0x20, %esi
movq %r15, %rdx
callq 0x4f73a
cmpl $0x0, (%r15)
jne 0x5cfee
movl %ebp, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r14, 0x20(%rax)
movq $0x8, 0x18(%rax)
jmp 0x5cfee
movq %r12, %rdi
movl %edx, %esi
movq %r15, %rdx
callq 0x4f73a
cmpl $0x0, (%r15)
jne 0x5cfee
movl %ebp, 0x8(%rax)
movl %r14d, 0xc(%rax)
movq $0x8, 0x10(%rax)
movq %rbx, 0x18(%rax)
movb $0x1, 0x28(%rax)
movb %r13b, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4f73a
cmpl $0x0, (%r12)
jne 0x5d041
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_O1/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 $0x28, %rsp
movq %r9, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movl %ecx, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl %esi, %r13d
movq %rdi, %rbx
leaq 0x197b9(%rip), %rcx     # 0x76830
movq 0x60(%rsp), %r12
xorl %eax, %eax
movsd (%rcx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x5d08a
jnp 0x5d09c
incq %rax
addq $0x10, %rcx
cmpq $0x8, %rax
jne 0x5d07e
movl $0x8, %eax
cmpq $0x8, %rax
je 0x5d0b5
movq %rax, %rcx
shlq $0x4, %rcx
leaq 0x19780(%rip), %rdx     # 0x76830
movb 0x8(%rcx,%rdx), %r15b
cmpq $0x8, %rax
setne %bpl
jne 0x5d106
movq %rbx, %rdi
movsd %xmm0, 0x10(%rsp)
callq 0x4f016
movq %rax, %r15
movq %r12, (%rsp)
movq %rbx, %rdi
movl 0x8(%rsp), %esi
movl $0x21, %edx
movl $0x22, %ecx
movl 0xc(%rsp), %r8d
movq %rax, %r9
movsd 0x10(%rsp), %xmm0
callq 0x5cf0a
cmpl $0x0, (%r12)
jne 0x5d162
movq %r15, %r14
shrq $0x8, %r14
movq %rbx, %rdi
movl %r13d, %esi
movq %r12, %rdx
callq 0x4f73a
cmpl $0x0, (%r12)
jne 0x5d162
movl 0x8(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0xc(%rsp), %ecx
movl %ecx, 0xc(%rax)
movq $0x8, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x20(%rax)
movb %bpl, 0x28(%rax)
movb %r15b, 0x30(%rax)
movl %r14d, 0x31(%rax)
movq %r14, %rcx
shrq $0x30, %rcx
movb %cl, 0x37(%rax)
shrq $0x20, %r14
movw %r14w, 0x35(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4f73a
cmpl $0x0, (%r12)
jne 0x5d1bc
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_O1/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 0x5d249
movl %edx, %r13d
movl %esi, 0x8(%rsp)
movq %rbx, %rdi
callq 0x4efd1
movq %r12, %r10
movq %rax, %r12
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x4, %esi
movl %r13d, %edx
xorl %ecx, %ecx
movq %rax, %r8
movq %rbp, %r9
movq %r10, %r13
pushq %r10
pushq %r14
callq 0x503c6
addq $0x10, %rsp
cmpl $0x0, (%r13)
jne 0x5d297
movq %r12, %rbp
xorl %r14d, %r14d
movq %r13, %r12
movl 0x8(%rsp), %esi
jmp 0x5d25b
movl %r14d, %r15d
negl %r15d
cmovsl %r14d, %r15d
shrl $0x2, %r15d
shrl $0x1f, %r14d
movq %rbx, %rdi
movq %r12, %rdx
callq 0x4f73a
cmpl $0x0, (%r12)
jne 0x5d297
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_O1/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 0x4f73a
cmpl $0x0, (%r12)
jne 0x5d2e8
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_O1/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
movq %r8, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movapd 0x180dd(%rip), %xmm2    # 0x753f0
xorpd %xmm0, %xmm2
ucomisd %xmm0, %xmm2
movl %esi, %r12d
cmovbel %esi, %edx
movq %rdi, %r15
maxsd %xmm0, %xmm2
leaq 0x19501(%rip), %rcx     # 0x76830
xorl %eax, %eax
movsd (%rcx), %xmm1
ucomisd %xmm2, %xmm1
jne 0x5d33d
jnp 0x5d34f
incq %rax
addq $0x10, %rcx
cmpq $0x8, %rax
jne 0x5d331
movl $0x8, %eax
cmpq $0x8, %rax
je 0x5d36a
movq %rax, %rcx
shlq $0x4, %rcx
leaq 0x194cd(%rip), %rsi     # 0x76830
movb 0x8(%rcx,%rsi), %r13b
jmp 0x5d36d
xorl %r13d, %r13d
cmpq $0x8, %rax
setne %bl
jne 0x5d3bd
movq %r15, %rdi
movapd %xmm0, 0x20(%rsp)
callq 0x4f016
movq %rax, %r13
movq %r14, (%rsp)
movq %r15, %rdi
movl 0x14(%rsp), %esi
movl $0x21, %edx
movl $0x22, %ecx
xorl %r8d, %r8d
movq %rax, %r9
movapd 0x20(%rsp), %xmm0
callq 0x5cf0a
cmpl $0x0, (%r14)
jne 0x5d3fc
movq %r13, %rbp
shrq $0x8, %rbp
movl %r12d, %edx
movq %r15, %rdi
movl %edx, %esi
movq %r14, %rdx
callq 0x4f73a
cmpl $0x0, (%r14)
jne 0x5d3fc
movl 0x14(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movb %bl, 0x18(%rax)
movb %r13b, 0x20(%rax)
movl %ebp, 0x21(%rax)
movq %rbp, %rcx
shrq $0x30, %rcx
movb %cl, 0x27(%rax)
shrq $0x20, %rbp
movw %bp, 0x25(%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4f73a
cmpl $0x0, (%r15)
jne 0x5d43a
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_O1/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 0x4f73a
cmpl $0x0, (%r14)
jne 0x5d466
movl %ebp, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4f9c8
cmpl $0x0, (%r15)
jne 0x5d519
movq %r14, %rdi
movq %rbx, %rsi
movl $0x4, %edx
movq %r15, %rcx
callq 0x4f76d
cmpl $0x0, (%r15)
jne 0x5d519
movl %ebp, 0x8(%rax)
movb $0x0, 0xc(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq %r13, 0x28(%rax)
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
movq %r15, %rcx
callq 0x4f76d
cmpl $0x0, (%r15)
jne 0x5d519
movl %ebp, 0x8(%rax)
movq $0x8, 0x10(%rax)
movq (%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x20(%rax)
movl $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_O1/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 0x5d577
leaq 0x19399(%rip), %rdx     # 0x768f0
movq %r15, %rdi
movl $0xf, %esi
movl $0x1ba, %ecx            # imm = 0x1BA
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x145f4
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movq %r15, %rcx
callq 0x4f76d
cmpl $0x0, (%r15)
jne 0x5d5b6
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_O1/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
movl $0x1f, %esi
movq %rcx, %rdx
callq 0x4f73a
cmpl $0x0, (%r14)
jne 0x5d602
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_O1/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
movl $0x1e, %esi
movq %rcx, %rdx
callq 0x4f73a
cmpl $0x0, (%r14)
jne 0x5d644
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_O1/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 0x4f73a
cmpl $0x0, (%r15)
jne 0x5d6b5
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_O1/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 0x5ce34
movq %rax, %r14
movq %r12, %rdi
movl $0x50, %esi
movq %r15, %rdx
callq 0x4f73a
cmpl $0x0, (%r15)
jne 0x5d6ff
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_O1/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 0x5d78c
movl %edx, %r13d
movl %esi, 0x8(%rsp)
movq %rbx, %rdi
callq 0x4efd1
movq %r12, %r10
movq %rax, %r12
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x4, %esi
movl %r13d, %edx
xorl %ecx, %ecx
movq %rax, %r8
movq %rbp, %r9
movq %r10, %r13
pushq %r10
pushq %r14
callq 0x503c6
addq $0x10, %rsp
cmpl $0x0, (%r13)
jne 0x5d7d2
movq %r12, %rbp
xorl %r14d, %r14d
movq %r13, %r12
movl 0x8(%rsp), %esi
jmp 0x5d79e
movl %r14d, %r15d
negl %r15d
cmovsl %r14d, %r15d
shrl $0x2, %r15d
shrl $0x1f, %r14d
movq %rbx, %rdi
movq %r12, %rdx
callq 0x4f73a
cmpl $0x0, (%r12)
jne 0x5d7d2
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_O1/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 0x5d8e5
leaq 0x1903c(%rip), %rdx     # 0x76901
movq %r15, %rdi
movl $0xf, %esi
movl $0xb1, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x145f4
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movq %r15, %rcx
callq 0x4f76d
cmpl $0x0, (%r15)
jne 0x5d91c
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_O1/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 0x4f73a
cmpl $0x0, (%r12)
jne 0x5d962
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_O1/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 0x4f73a
cmpl $0x0, (%r12)
jne 0x5d9e1
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_O1/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 0x4f73a
cmpl $0x0, (%r15)
jne 0x5da15
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_O1/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 0x4f73a
cmpl $0x0, (%r14)
jne 0x5da41
movl %ebp, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4f73a
cmpl $0x0, (%r15)
jne 0x5da71
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_O1/markdryan[P]subtilis/arch/arm32/vfp.c
// Function: subtilis_vfp_add_sysreg
void subtilis_vfp_add_sysreg(subtilis_arm_section_t *s,
			     subtilis_arm_instr_type_t itype,
			     subtilis_arm_ccode_type_t ccode,
			     subtilis_vfp_sysreg_t sysreg,
			     subtilis_arm_reg_t reg, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_sysreg_instr_t *sysregi;

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

	sysregi = &instr->operands.vfp_sysreg;
	sysregi->ccode = ccode;
	sysregi->sysreg = sysreg;
	sysregi->arm_reg = reg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r14d
movq %r9, %rdx
callq 0x4f73a
cmpl $0x0, (%r15)
jne 0x5daa7
movl %r14d, 0x8(%rax)
movl %ebp, 0xc(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/vfp.c
// Function: subtilis_vfp_add_tran_dbl
void subtilis_vfp_add_tran_dbl(subtilis_arm_section_t *s,
			       subtilis_arm_instr_type_t itype,
			       subtilis_arm_ccode_type_t ccode,
			       subtilis_arm_reg_t dest1,
			       subtilis_arm_reg_t dest2,
			       subtilis_arm_reg_t src1, subtilis_arm_reg_t src2,
			       subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_tran_dbl_instr_t *tran;

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

	tran = &instr->operands.vfp_tran_dbl;
	tran->ccode = ccode;
	tran->dest1 = dest1;
	tran->dest2 = dest2;
	tran->src1 = src1;
	tran->src2 = src2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movq 0x38(%rsp), %r12
movq %r12, %rdx
callq 0x4f73a
cmpl $0x0, (%r12)
jne 0x5daf1
movq 0x30(%rsp), %rcx
movl %ebp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movq %rcx, 0x28(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/bitset.c
// Function: subtilis_bitset_reset
void subtilis_bitset_reset(subtilis_bitset_t *bs)
{
	size_t i;

	bs->max_value = -1;

	for (i = 0; i < bs->allocated; i++)
		bs->bits[i] = 0;
}

// Assembly:
movl $0xffffffff, 0x8(%rdi)  # imm = 0xFFFFFFFF
movq 0x10(%rdi), %rdx
testq %rdx, %rdx
je 0x5db5f
movq (%rdi), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
jmp 0x12140
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/bitset.c
// Function: subtilis_bitset_set
void subtilis_bitset_set(subtilis_bitset_t *bs, size_t bit,
			 subtilis_error_t *err)
{
	size_t cell;
	size_t offset;

	if (bit > INT_MAX) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	prv_ensure(bs, bit, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	cell = bit / (sizeof(unsigned int) * 8);
	offset = bit - (cell * (sizeof(unsigned int) * 8));
	bs->bits[cell] |= 1 << offset;
	if ((int)bit > bs->max_value)
		bs->max_value = (int)bit;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rax
shrq $0x1f, %rax
je 0x5db8f
leaq 0x18d9a(%rip), %rdx     # 0x76912
movq %r15, %rdi
movl $0xf, %esi
movl $0x42, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x145f4
movq %rsi, %rbx
movq %rdi, %r14
movq %r15, %rdx
callq 0x5dbc9
cmpl $0x0, (%r15)
jne 0x5dbc3
movl $0x1, %eax
movl %ebx, %ecx
shll %cl, %eax
movq (%r14), %rcx
movq %rbx, %rdx
shrq $0x5, %rdx
orl %eax, (%rcx,%rdx,4)
cmpl %ebx, 0x8(%r14)
jge 0x5dbc3
movl %ebx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/bitset.c
// Function: prv_ensure
static void prv_ensure(subtilis_bitset_t *bs, size_t bit, subtilis_error_t *err)
{
	unsigned int *new_bits;
	size_t needed = (bit / (sizeof(unsigned int) * 8)) + 1;

	if (needed <= bs->allocated)
		return;

	new_bits = realloc(bs->bits, needed * sizeof(unsigned int));
	if (!new_bits) {
		subtilis_error_set_oom(err);
		return;
	}
	bs->bits = new_bits;
	memset(&bs->bits[bs->allocated], 0,
	       sizeof(unsigned int) * (needed - bs->allocated));
	bs->allocated = needed;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
shrq $0x5, %rbx
cmpq 0x10(%rdi), %rbx
jb 0x5dc19
movq %rdx, %r15
movq %rdi, %r14
incq %rbx
movq (%rdi), %rdi
leaq (,%rbx,4), %rsi
callq 0x12210
testq %rax, %rax
je 0x5dc1f
movq %rax, (%r14)
movq 0x10(%r14), %rcx
leaq (%rax,%rcx,4), %rdi
movq %rbx, %rdx
subq %rcx, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x12140
movq %rbx, 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x18cec(%rip), %rdx     # 0x76912
movq %r15, %rdi
movl $0x1, %esi
movl $0x32, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/bitset.c
// Function: subtilis_bitset_clear
void subtilis_bitset_clear(subtilis_bitset_t *bs, size_t bit)
{
	size_t cell;
	size_t offset;

	if (bit > bs->max_value)
		return;

	cell = bit / (sizeof(unsigned int) * 8);
	offset = bit - (cell * (sizeof(unsigned int) * 8));
	bs->bits[cell] &= ~((unsigned int)(1 << offset));
	if (bit == (size_t)bs->max_value)
		prv_set_max(bs, cell);
}

// Assembly:
movslq 0x8(%rdi), %rax
cmpq %rsi, %rax
jb 0x5dc9a
movq %rsi, %rax
shrq $0x5, %rax
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
movl %esi, %ecx
roll %cl, %edx
movq (%rdi), %rcx
andl %edx, (%rcx,%rax,4)
movslq 0x8(%rdi), %rcx
cmpq %rsi, %rcx
jne 0x5dc9a
movq %rax, %rsi
jmp 0x5dc9b
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/bitset.c
// Function: prv_set_max
static void prv_set_max(subtilis_bitset_t *bs, size_t block)
{
	size_t i;
	size_t byte;
	unsigned int mask;

	do {
		if (bs->bits[block] != 0)
			break;
		if (block == 0) {
			bs->max_value = -1;
			return;
		}
		block--;
	} while (true);

	byte = sizeof(unsigned int);
	while (byte > 0) {
		byte--;
		mask = 0xff << (byte * 8);
		if (mask & bs->bits[block])
			break;
	}

	i = 8;
	while (i > 0) {
		i--;
		mask = 1 << (i + (byte * 8));
		if (mask & bs->bits[block])
			break;
	}
	bs->max_value = (block * sizeof(unsigned int) * 8) + (byte * 8) + i;
}

// Assembly:
movq (%rdi), %rcx
movl (%rcx,%rsi,4), %eax
testl %eax, %eax
jne 0x5dcb2
subq $0x1, %rsi
jae 0x5dc9e
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
jmp 0x5dd09
shll $0x5, %esi
xorl %edx, %edx
movl $0x18, %ecx
movl $0xff, %r8d
shll %cl, %r8d
addl $0x8, %edx
testq %rcx, %rcx
je 0x5dcd9
andl %eax, %r8d
addq $-0x8, %rcx
testl %r8d, %r8d
je 0x5dcbc
movl $0x27, %ecx
subl %edx, %ecx
subl %edx, %esi
addl $0x28, %esi
movq $-0x7, %rdx
movl $0x1, %r8d
shll %cl, %r8d
decl %esi
testq %rdx, %rdx
je 0x5dd09
andl %eax, %r8d
incq %rdx
decl %ecx
testl %r8d, %r8d
je 0x5dcec
movl %esi, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/bitset.c
// Function: subtilis_bitset_and
void subtilis_bitset_and(subtilis_bitset_t *bs, subtilis_bitset_t *bs1)
{
	size_t i;
	size_t limit;

	if (bs->max_value < 0)
		return;

	if (bs1->max_value < bs->max_value)
		bs->max_value = bs1->max_value;

	if (bs->max_value >= 0 && bs1->max_value >= 0)
		limit = (bs->max_value / (sizeof(unsigned int) * 8)) + 1;
	else
		limit = 0;

	for (i = 0; i < limit; i++)
		bs->bits[i] &= bs1->bits[i];

	for (i = limit; i < bs->allocated; i++)
		bs->bits[i] = 0;

	if (limit > 0)
		prv_set_max(bs, limit - 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
testl %eax, %eax
js 0x5dd94
movq %rdi, %rbx
movl 0x8(%rsi), %ecx
cmpl %eax, %ecx
jge 0x5dd25
movl %ecx, 0x8(%rbx)
movl 0x8(%rbx), %r14d
testl %r14d, %r14d
js 0x5dd3d
cmpl $0x0, 0x8(%rsi)
js 0x5dd3d
shrl $0x5, %r14d
incq %r14
jmp 0x5dd40
xorl %r14d, %r14d
testq %r14, %r14
je 0x5dd5b
movq (%rsi), %rax
movq (%rbx), %rcx
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
andl %esi, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %r14
jne 0x5dd4d
movq 0x10(%rbx), %rdx
subq %r14, %rdx
jbe 0x5dd7a
leal (,%r14,4), %edi
addq (%rbx), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x12140
testq %r14, %r14
je 0x5dd94
decq %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5dc9b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/bitset.c
// Function: subtilis_bitset_or
void subtilis_bitset_or(subtilis_bitset_t *bs, subtilis_bitset_t *bs1,
			subtilis_error_t *err)
{
	size_t i;
	size_t limit;

	if (bs1->max_value < 0)
		return;

	prv_ensure(bs, bs1->max_value, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	limit = (bs1->max_value / (sizeof(unsigned int) * 8)) + 1;
	for (i = 0; i < limit; i++)
		bs->bits[i] |= bs1->bits[i];

	if (bs->max_value < bs1->max_value)
		bs->max_value = bs1->max_value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movslq 0x8(%rsi), %rsi
testq %rsi, %rsi
js 0x5ddeb
movq %rdx, %r15
movq %rdi, %rbx
callq 0x5dbc9
cmpl $0x0, (%r15)
jne 0x5ddeb
movslq 0x8(%r14), %rax
shrq $0x5, %rax
movq (%r14), %rcx
movq (%rbx), %rdx
incq %rax
xorl %esi, %esi
movl (%rcx,%rsi,4), %edi
orl %edi, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %rax
jne 0x5ddd1
movl 0x8(%r14), %eax
cmpl %eax, 0x8(%rbx)
jge 0x5ddeb
movl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq