LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_directive
static void prv_dump_directive(void *user_data, subtilis_arm_op_t *op,
			       subtilis_error_t *err)
{
	switch (op->type) {
	case SUBTILIS_ARM_OP_ALIGN:
		printf("\tALIGN %" PRIu32 "\n", op->op.alignment);
		break;
	case SUBTILIS_ARM_OP_BYTE:
		printf("\tEQUB %d\n", op->op.byte);
		break;
	case SUBTILIS_ARM_OP_TWO_BYTE:
		printf("\tEQUW %d\n", op->op.two_bytes);
		break;
	case SUBTILIS_ARM_OP_FOUR_BYTE:
		printf("\tEQUD %" PRIu32 "\n", op->op.four_bytes);
		break;
	case SUBTILIS_ARM_OP_DOUBLE:
		printf("\tEQUDBL %f\n", op->op.dbl);
		break;
	case SUBTILIS_ARM_OP_DOUBLER:
		printf("\tEQUDBLR %f\n", op->op.dbl);
		break;
	case SUBTILIS_ARM_OP_FLOAT:
		printf("\tEQUF %f\n", op->op.flt);
		break;
	case SUBTILIS_ARM_OP_STRING:
		printf("\tEQUS \"%s\"\n", op->op.str);
		break;
	default:
		subtilis_error_set_assertion_failed(err);
	}
}

// Assembly:
movl (%rsi), %eax
addl $-0x2, %eax
cmpl $0x7, %eax
ja 0x5b620
leaq 0x1a911(%rip), %rcx     # 0x75eb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl 0x8(%rsi), %esi
leaq 0x1ac8e(%rip), %rdi     # 0x76241
jmp 0x5b5f4
movsd 0x8(%rsi), %xmm0
leaq 0x1acaa(%rip), %rdi     # 0x7626b
jmp 0x5b607
movl 0x8(%rsi), %esi
leaq 0x1ac88(%rip), %rdi     # 0x76255
jmp 0x5b5f4
movsd 0x8(%rsi), %xmm0
leaq 0x1ac84(%rip), %rdi     # 0x7625f
jmp 0x5b607
movl 0x8(%rsi), %esi
leaq 0x1ac4f(%rip), %rdi     # 0x76236
jmp 0x5b5f4
movzwl 0x8(%rsi), %esi
leaq 0x1ac57(%rip), %rdi     # 0x7624b
xorl %eax, %eax
jmp 0x12110
cvtss2sd 0x8(%rsi), %xmm0
leaq 0x1ac71(%rip), %rdi     # 0x76278
movb $0x1, %al
jmp 0x12110
movq 0x8(%rsi), %rsi
leaq 0x1ac69(%rip), %rdi     # 0x76282
xorl %eax, %eax
jmp 0x12110
leaq 0x1ac67(%rip), %rax     # 0x7628e
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x2b9, %ecx            # imm = 0x2B9
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_data_instr
static void prv_dump_data_instr(void *user_data, subtilis_arm_op_t *op,
				subtilis_arm_instr_type_t type,
				subtilis_arm_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]);
	if (instr->status)
		printf("S");
	printf(" R%zu, R%zu, ", instr->dest, instr->op1);
	prv_dump_op2(&instr->op2);
	printf("\n");
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
movl %edx, %eax
leaq 0x46167(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x187da(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5b67c
leaq 0x466a6(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x187ba(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
cmpb $0x1, 0x4(%rbx)
jne 0x5b68c
movl $0x53, %edi
callq 0x12030
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x1ac09(%rip), %rdi     # 0x762a4
xorl %eax, %eax
callq 0x12110
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x5cd3b
movl $0xa, %edi
popq %rbx
jmp 0x12030
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_mul_instr
static void prv_dump_mul_instr(void *user_data, subtilis_arm_op_t *op,
			       subtilis_arm_instr_type_t type,
			       subtilis_arm_mul_instr_t *instr,
			       subtilis_error_t *err)
{
	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);
	if (instr->status)
		printf("S");
	if (type == SUBTILIS_ARM_INSTR_MLA)
		printf(" R%zu, R%zu, R%zu, R%zu\n", instr->dest, instr->rm,
		       instr->rs, instr->rn);
	else
		printf(" R%zu, R%zu, R%zu\n", instr->dest, instr->rm,
		       instr->rs);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movl %edx, %eax
leaq 0x460e6(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x18759(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5b6fd
leaq 0x46625(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x18739(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
cmpb $0x1, 0x4(%rbx)
jne 0x5b70d
movl $0x53, %edi
callq 0x12030
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
cmpl $0x11, %ebp
jne 0x5b736
movq 0x20(%rbx), %r8
leaq 0x1af1f(%rip), %rdi     # 0x76648
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12110
leaq 0x1af11(%rip), %rdi     # 0x7664e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_cmp_instr
static void prv_dump_cmp_instr(void *user_data, subtilis_arm_op_t *op,
			       subtilis_arm_instr_type_t type,
			       subtilis_arm_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]);
	if ((instr->dest == 15) && (type == SUBTILIS_ARM_INSTR_TEQ))
		printf("P");
	printf(" R%zu, ", instr->op1);
	prv_dump_op2(&instr->op2);
	printf("\n");
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movl %edx, %eax
leaq 0x46055(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x186c8(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5b78e
leaq 0x46594(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x186a8(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
cmpl $0x9, %ebp
jne 0x5b7a4
cmpq $0xf, 0x8(%rbx)
jne 0x5b7a4
movl $0x50, %edi
callq 0x12030
movq 0x10(%rbx), %rsi
leaq 0x1aafb(%rip), %rdi     # 0x762aa
xorl %eax, %eax
callq 0x12110
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x5cd3b
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12030
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_mov_instr
static void prv_dump_mov_instr(void *user_data, subtilis_arm_op_t *op,
			       subtilis_arm_instr_type_t type,
			       subtilis_arm_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]);
	if (instr->status)
		printf("S");
	printf(" R%zu, ", instr->dest);
	prv_dump_op2(&instr->op2);
	printf("\n");
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
movl %edx, %eax
leaq 0x45fd1(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x18644(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5b812
leaq 0x46510(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x18624(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
cmpb $0x1, 0x4(%rbx)
jne 0x5b822
movl $0x53, %edi
callq 0x12030
movq 0x8(%rbx), %rsi
leaq 0x1aa7d(%rip), %rdi     # 0x762aa
xorl %eax, %eax
callq 0x12110
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x5cd3b
movl $0xa, %edi
popq %rbx
jmp 0x12030
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_stran_instr
static void prv_dump_stran_instr(void *user_data, subtilis_arm_op_t *op,
				 subtilis_arm_instr_type_t type,
				 subtilis_arm_stran_instr_t *instr,
				 subtilis_error_t *err)
{
	const char *sub = instr->subtract ? "-" : "";

	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);
	if (instr->byte)
		printf("B");
	printf(" R%zu", instr->dest);
	if (instr->pre_indexed) {
		printf(", [R%zu, %s", instr->base, sub);
		prv_dump_op2(&instr->offset);
		printf("]");
		if (instr->write_back)
			printf("!");
	} else {
		printf(", [R%zu], %s", instr->base, sub);
		prv_dump_op2(&instr->offset);
	}
	printf("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
leaq 0x1b20f(%rip), %rax     # 0x76a69
leaq 0x185b4(%rip), %r14     # 0x73e15
cmpb $0x0, 0x42(%rcx)
cmovneq %rax, %r14
movl %edx, %eax
leaq 0x45f3e(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x185b1(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5b8a5
leaq 0x4647d(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x18591(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
cmpb $0x1, 0x43(%rbx)
jne 0x5b8b5
movl $0x42, %edi
callq 0x12030
movq 0x8(%rbx), %rsi
leaq 0x1af75(%rip), %rdi     # 0x76835
xorl %eax, %eax
callq 0x12110
movq 0x10(%rbx), %rsi
leaq 0x18(%rbx), %r15
cmpb $0x1, 0x40(%rbx)
jne 0x5b90a
leaq 0x1ad85(%rip), %rdi     # 0x76661
movq %r14, %rdx
xorl %eax, %eax
callq 0x12110
movq %r15, %rdi
callq 0x5cd3b
movl $0x5d, %edi
callq 0x12030
cmpb $0x1, 0x41(%rbx)
jne 0x5b923
movl $0x21, %edi
callq 0x12030
jmp 0x5b923
leaq 0x1ad5c(%rip), %rdi     # 0x7666d
movq %r14, %rdx
xorl %eax, %eax
callq 0x12110
movq %r15, %rdi
callq 0x5cd3b
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x12030
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_mtran_instr
static void prv_dump_mtran_instr(void *user_data, subtilis_arm_op_t *op,
				 subtilis_arm_instr_type_t type,
				 subtilis_arm_mtran_instr_t *instr,
				 subtilis_error_t *err)
{
	size_t i;
	const char *const direction[] = {
	    "IA", "IB", "DA", "DB", "FA", "FD", "EA", "ED",
	};

	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);
	printf("%s R%zu", direction[(size_t)instr->type], instr->op0);
	if (instr->write_back)
		printf("!");
	printf(", {");

	for (i = 0; i < 15; i++) {
		if (1 << i & instr->reg_list) {
			printf("R%zu", i);
			i++;
			break;
		}
	}

	for (; i < 15; i++) {
		if ((1 << i) & instr->reg_list)
			printf(", R%zu", i);
	}
	printf("}");
	if (instr->status)
		printf("^");
	printf("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl %edx, %eax
leaq 0x45e6d(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x184e0(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5b976
leaq 0x463ac(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x184c0(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movl 0x18(%rbx), %eax
leaq 0x1a820(%rip), %rcx     # 0x761a0
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq 0x8(%rbx), %rdx
leaq 0x1ac91(%rip), %rdi     # 0x76623
xorl %eax, %eax
callq 0x12110
cmpb $0x1, 0x1c(%rbx)
jne 0x5b9a9
movl $0x21, %edi
callq 0x12030
leaq 0x1acdf(%rip), %rdi     # 0x7668f
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x12110
movq 0x10(%rbx), %rax
btq %r14, %rax
jb 0x5b9cf
incq %r14
cmpq $0xf, %r14
jne 0x5b9be
jmp 0x5ba0f
leaq 0x1ae60(%rip), %rdi     # 0x76836
movq %r14, %rsi
xorl %eax, %eax
callq 0x12110
cmpq $0xd, %r14
ja 0x5ba0f
incq %r14
leaq 0x1ae44(%rip), %r15     # 0x76834
movl 0x10(%rbx), %eax
btl %r14d, %eax
jae 0x5ba06
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x12110
incq %r14
cmpq $0xf, %r14
jne 0x5b9f0
movl $0x7d, %edi
callq 0x12030
cmpb $0x1, 0x1d(%rbx)
jne 0x5ba29
movl $0x5e, %edi
callq 0x12030
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x12030
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_br_instr
static void prv_dump_br_instr(void *user_data, subtilis_arm_op_t *op,
			      subtilis_arm_instr_type_t type,
			      subtilis_arm_br_instr_t *instr,
			      subtilis_error_t *err)
{
	subtilis_arm_prog_t *p = user_data;

	printf("\t%s", (instr->link) ? "BL" : "B");
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);
	if (instr->link) {
		if (instr->indirect)
			printf(" [R%zu]\n", instr->target.reg);
		else if (p)
			printf(" %s\n",
			       p->string_pool->strings[instr->target.label]);
		else
			printf(" %" PRIi32 "\n", (int32_t)instr->target.label);
	} else if (p) {
		printf(" label_%zu\n", instr->target.label);
	} else {
		printf(" %" PRIi32 "\n", (int32_t)instr->target.label);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x1b04f(%rip), %rax     # 0x76a98
leaq 0x17739(%rip), %rsi     # 0x73189
cmpb $0x0, 0x4(%rcx)
cmovneq %rax, %rsi
leaq 0x183cf(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5ba87
leaq 0x4629b(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x183af(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
cmpb $0x1, 0x4(%rbx)
jne 0x5baa0
cmpb $0x1, 0x6(%rbx)
jne 0x5bab2
movq 0x10(%rbx), %rsi
leaq 0x1abf5(%rip), %rdi     # 0x76693
jmp 0x5bacd
movq 0x10(%rbx), %rsi
testq %r14, %r14
je 0x5badb
leaq 0x1acb7(%rip), %rdi     # 0x76767
jmp 0x5bacd
testq %r14, %r14
je 0x5bae4
movq 0x18(%r14), %rax
movq (%rax), %rax
movq 0x10(%rbx), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x1885b(%rip), %rdi     # 0x74328
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12110
leaq 0x1abba(%rip), %rdi     # 0x7669c
jmp 0x5baee
movl 0x10(%rbx), %esi
leaq 0x1abae(%rip), %rdi     # 0x7669c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_swi_instr
static void prv_dump_swi_instr(void *user_data, subtilis_arm_op_t *op,
			       subtilis_arm_instr_type_t type,
			       subtilis_arm_swi_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(" &%zx\n", instr->code);
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
movl %edx, %eax
leaq 0x45ca7(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x1831a(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5bb3c
leaq 0x461e6(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x182fa(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rsi
leaq 0x1ab5a(%rip), %rdi     # 0x766a1
xorl %eax, %eax
popq %rbx
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_ldrc_instr
static void prv_dump_ldrc_instr(void *user_data, subtilis_arm_op_t *op,
				subtilis_arm_instr_type_t type,
				subtilis_arm_ldrc_instr_t *instr,
				subtilis_error_t *err)
{
	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);
	printf(" R%zu, label_%zu\n", instr->dest, instr->label);
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
movl %edx, %eax
leaq 0x45c54(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x182c7(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5bb8f
leaq 0x46193(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x182a7(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x1ab0a(%rip), %rdi     # 0x766a8
xorl %eax, %eax
popq %rbx
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_ldrp_instr
static void prv_dump_ldrp_instr(void *user_data, subtilis_arm_op_t *op,
				subtilis_arm_instr_type_t type,
				subtilis_arm_ldrp_instr_t *instr,
				subtilis_error_t *err)
{
	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);
	printf(" R%zu, section_%zu via label_%zu\n", instr->dest,
	       instr->section_label, instr->constant_label);
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
movl %edx, %eax
leaq 0x45bfd(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x18270(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5bbe6
leaq 0x4613c(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x18250(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x1aac1(%rip), %rdi     # 0x766ba
xorl %eax, %eax
popq %rbx
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_adr_instr
static void prv_dump_adr_instr(void *user_data, subtilis_arm_op_t *op,
			       subtilis_arm_instr_type_t type,
			       subtilis_arm_adr_instr_t *instr,
			       subtilis_error_t *err)
{
	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);
	printf(" R%zu, label_%zu\n", instr->dest, instr->label);
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
movl %edx, %eax
leaq 0x45ba2(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x18215(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5bc41
leaq 0x460e1(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x181f5(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x1aa58(%rip), %rdi     # 0x766a8
xorl %eax, %eax
popq %rbx
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_cmov_instr
static void prv_dump_cmov_instr(void *user_data, subtilis_arm_op_t *op,
				subtilis_arm_instr_type_t type,
				subtilis_arm_cmov_instr_t *instr,
				subtilis_error_t *err)
{
	printf("\t%s", instr_desc[type]);
	if (instr->fused) {
		printf("%s%s", ccode_desc[instr->false_cond],
		       ccode_desc[instr->true_cond]);
		printf(" R%zu, R%zu, R%zu\n", instr->dest, instr->op2,
		       instr->op3);

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

// Assembly:
pushq %rbx
movq %rcx, %rbx
movl %edx, %eax
leaq 0x45b4b(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x181be(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
cmpb $0x1, 0x20(%rbx)
jne 0x5bcba
movl 0x24(%rbx), %eax
movl 0x28(%rbx), %ecx
leaq 0x46086(%rip), %rdx     # 0xa1d10
movq (%rdx,%rcx,8), %rsi
movq (%rdx,%rax,8), %rdx
leaq 0x1aab1(%rip), %rdi     # 0x7674a
xorl %eax, %eax
callq 0x12110
movq (%rbx), %rsi
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x1a99c(%rip), %rdi     # 0x7664e
xorl %eax, %eax
popq %rbx
jmp 0x12110
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %r8
leaq 0x1a978(%rip), %rdi     # 0x76648
xorl %eax, %eax
popq %rbx
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_flags_instr
static void prv_dump_flags_instr(void *user_data, subtilis_arm_op_t *op,
				 subtilis_arm_instr_type_t type,
				 subtilis_arm_flags_instr_t *instr,
				 subtilis_error_t *err)
{
	const char *flags_reg;
	char fields[5];
	size_t field_count = 0;

	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);
	flags_reg =
	    instr->flag_reg == SUBTILIS_ARM_FLAGS_CPSR ? "CPSR" : "SPSR";

	if (type == SUBTILIS_ARM_INSTR_MSR) {
		if (instr->fields & SUBTILIS_ARM_FLAGS_FIELD_CONTROL)
			fields[field_count++] = 'c';
		if (instr->fields & SUBTILIS_ARM_FLAGS_FIELD_EXTENSION)
			fields[field_count++] = 'x';
		if (instr->fields & SUBTILIS_ARM_FLAGS_FIELD_STATUS)
			fields[field_count++] = 's';
		if (instr->fields & SUBTILIS_ARM_FLAGS_FIELD_FLAGS)
			fields[field_count++] = 'f';
		fields[field_count] = 0;
		if (instr->op2_reg)
			printf(" %s_%s, R%zu\n", flags_reg, fields,
			       instr->op.reg);
		else
			printf(" %s_%s, #%" PRIu32 "\n", flags_reg, fields,
			       instr->op.integer);
	} else {
		printf(" R%zu, %s\n", instr->op.reg, flags_reg);
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movl %edx, %eax
leaq 0x45ac7(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x1813a(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5bd1c
leaq 0x46006(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x1811a(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
cmpl $0x0, 0x4(%rbx)
leaq 0x1a9b5(%rip), %rax     # 0x766dc
leaq 0x1b1a1(%rip), %rdx     # 0x76ecf
cmoveq %rax, %rdx
cmpl $0x1c, %ebp
jne 0x5bd44
movl 0x8(%rbx), %ecx
btl $0x10, %ecx
jb 0x5bd5c
xorl %eax, %eax
jmp 0x5bd66
movq 0x10(%rbx), %rsi
leaq 0x1a9ad(%rip), %rdi     # 0x766fc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12110
movb $0x63, 0x3(%rsp)
movl $0x1, %eax
btl $0x11, %ecx
jae 0x5bd74
movb $0x78, 0x3(%rsp,%rax)
incq %rax
btl $0x12, %ecx
jae 0x5bd82
movb $0x73, 0x3(%rsp,%rax)
incq %rax
btl $0x13, %ecx
jae 0x5bd90
movb $0x66, 0x3(%rsp,%rax)
incq %rax
movb $0x0, 0x3(%rsp,%rax)
cmpb $0x1, 0xc(%rbx)
jne 0x5bdba
movq 0x10(%rbx), %rcx
leaq 0x1a93b(%rip), %rdi     # 0x766e1
leaq 0x3(%rsp), %rax
movq %rdx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x12110
jmp 0x5bdd6
movl 0x10(%rbx), %ecx
leaq 0x1a92b(%rip), %rdi     # 0x766ef
leaq 0x3(%rsp), %rax
movq %rdx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x12110
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_fpa_stran_instr
static void prv_dump_fpa_stran_instr(void *user_data, subtilis_arm_op_t *op,
				     subtilis_arm_instr_type_t type,
				     subtilis_fpa_stran_instr_t *instr,
				     subtilis_error_t *err)
{
	const char *sub = instr->subtract ? "-" : "";

	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(" F%zu", instr->dest);
	if (instr->pre_indexed)
		printf(", [R%zu, %s#%d]", instr->base, sub, instr->offset * 4);
	else
		printf(", [R%zu], %s#%d", instr->base, sub, instr->offset * 4);
	if (instr->write_back)
		printf("!");
	printf("\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
leaq 0x1ac63(%rip), %rax     # 0x76a69
leaq 0x18008(%rip), %r14     # 0x73e15
cmpb $0x0, 0x23(%rcx)
cmovneq %rax, %r14
movl %edx, %eax
leaq 0x45992(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x18005(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5be51
leaq 0x45ed1(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x17fe5(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rax
cmpq $0xa, %rax
leaq 0x1770e(%rip), %rcx     # 0x7356e
leaq 0x17816(%rip), %rdx     # 0x7367d
cmoveq %rcx, %rdx
cmpq $0x4, %rax
leaq 0x17fba(%rip), %rsi     # 0x73e30
cmovneq %rdx, %rsi
leaq 0x17fae(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movq 0x10(%rbx), %rsi
leaq 0x1a8a4(%rip), %rdi     # 0x76737
xorl %eax, %eax
callq 0x12110
movq 0x18(%rbx), %rsi
movzbl 0x20(%rbx), %ecx
shll $0x2, %ecx
leaq 0x1a865(%rip), %rax     # 0x76711
leaq 0x1a86e(%rip), %rdi     # 0x76721
cmpb $0x0, 0x21(%rbx)
cmovneq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x12110
cmpb $0x1, 0x22(%rbx)
jne 0x5bed5
movl $0x21, %edi
callq 0x12030
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12030
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_fpa_tran_instr
static void prv_dump_fpa_tran_instr(void *user_data, subtilis_arm_op_t *op,
				    subtilis_arm_instr_type_t type,
				    subtilis_fpa_tran_instr_t *instr,
				    subtilis_error_t *err)
{
	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);
	if (type == SUBTILIS_FPA_INSTR_FLT)
		printf("%s", prv_fpa_size(instr->size));
	printf("%s", prv_extract_rounding(instr->rounding));
	if (type == SUBTILIS_FPA_INSTR_FLT) {
		printf(" F%zu, ", instr->dest);
		if (instr->immediate)
			printf("#%f", prv_extract_imm(instr->op2));
		else
			printf("R%zu", instr->op2.reg);
	} else {
		printf(" R%zu, F%zu", instr->dest, instr->op2.reg);
	}
	printf("\n");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xc10, %rsp            # imm = 0xC10
movq %rcx, %rbx
movl %edx, %ebp
movl %edx, %eax
leaq 0x458b1(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x17f24(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5bf32
leaq 0x45df0(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x17f04(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
cmpl $0x3e, %ebp
jne 0x5bf87
movq 0x20(%rbx), %rax
cmpq $0xa, %rax
leaq 0x17628(%rip), %rcx     # 0x7356e
leaq 0x17730(%rip), %rdx     # 0x7367d
cmoveq %rcx, %rdx
cmpq $0x4, %rax
leaq 0x17ed4(%rip), %rsi     # 0x73e30
cmovneq %rdx, %rsi
leaq 0x17ec8(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movl 0x28(%rbx), %eax
decl %eax
cmpl $0x2, %eax
ja 0x5bfa0
movl %eax, %eax
leaq 0x45e57(%rip), %rcx     # 0xa1dd8
movq (%rcx,%rax,8), %rsi
jmp 0x5bfa7
movl 0x28(%rbx), %eax
decl %eax
cmpl $0x2, %eax
ja 0x5bff9
movl %eax, %eax
leaq 0x45e3e(%rip), %rcx     # 0xa1dd8
movq (%rcx,%rax,8), %rsi
jmp 0x5c000
leaq 0x17e6e(%rip), %rsi     # 0x73e15
leaq 0x17e81(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rsi
leaq 0x1a749(%rip), %rdi     # 0x76709
xorl %eax, %eax
callq 0x12110
movq 0x18(%rbx), %r14
cmpb $0x1, 0x10(%rbx)
jne 0x5c026
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
callq 0x143b4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5d650
leaq 0x1a755(%rip), %rdi     # 0x76745
movb $0x1, %al
callq 0x12110
jmp 0x5c037
leaq 0x17e15(%rip), %rsi     # 0x73e15
leaq 0x17e28(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdx
leaq 0x1a714(%rip), %rdi     # 0x76731
xorl %eax, %eax
callq 0x12110
jmp 0x5c037
leaq 0x1a809(%rip), %rdi     # 0x76836
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
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_fpa_cmp_instr
static void prv_dump_fpa_cmp_instr(void *user_data, subtilis_arm_op_t *op,
				   subtilis_arm_instr_type_t type,
				   subtilis_fpa_cmp_instr_t *instr,
				   subtilis_error_t *err)
{
	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);
	printf(" F%zu,", instr->dest);
	if (instr->immediate)
		printf(" #%f", prv_extract_imm(instr->op2));
	else
		printf(" F%zu", instr->op2.reg);
	printf("\n");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc18, %rsp            # imm = 0xC18
movq %rcx, %rbx
movl %edx, %eax
leaq 0x4574d(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x17dc0(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5c096
leaq 0x45c8c(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x17da0(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rsi
leaq 0x1a69c(%rip), %rdi     # 0x7673d
xorl %eax, %eax
callq 0x12110
movq 0x18(%rbx), %r14
cmpb $0x1, 0x10(%rbx)
jne 0x5c0da
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
callq 0x143b4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5d650
leaq 0x1a673(%rip), %rdi     # 0x76744
movb $0x1, %al
callq 0x12110
jmp 0x5c0eb
leaq 0x1a656(%rip), %rdi     # 0x76737
movq %r14, %rsi
xorl %eax, %eax
callq 0x12110
movl $0xa, %edi
callq 0x12030
addq $0xc18, %rsp            # imm = 0xC18
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_fpa_ldrc_instr
static void prv_dump_fpa_ldrc_instr(void *user_data, subtilis_arm_op_t *op,
				    subtilis_arm_instr_type_t type,
				    subtilis_fpa_ldrc_instr_t *instr,
				    subtilis_error_t *err)
{
	printf("\t%s%s", instr_desc[type], prv_fpa_size(instr->size));
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);
	printf(" F%zu, label_%zu\n", instr->dest, instr->label);
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
movl %edx, %eax
leaq 0x456a3(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
movq 0x10(%rbx), %rax
cmpq $0xa, %rax
leaq 0x1744e(%rip), %rcx     # 0x7356e
leaq 0x17556(%rip), %rdi     # 0x7367d
cmoveq %rcx, %rdi
cmpq $0x4, %rax
leaq 0x17cfa(%rip), %rdx     # 0x73e30
cmovneq %rdi, %rdx
leaq 0x1a608(%rip), %rdi     # 0x76749
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5c169
leaq 0x45bb9(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x17ccd(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdx
leaq 0x1a5d7(%rip), %rdi     # 0x7674f
xorl %eax, %eax
popq %rbx
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_fpa_cptran_instr
static void prv_dump_fpa_cptran_instr(void *user_data, subtilis_arm_op_t *op,
				      subtilis_arm_instr_type_t type,
				      subtilis_fpa_cptran_instr_t *instr,
				      subtilis_error_t *err)
{
	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);
	printf(" R%zu\n", instr->dest);
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
movl %edx, %eax
leaq 0x45623(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x17c96(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5c1c0
leaq 0x45b62(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x17c76(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rsi
leaq 0x1a640(%rip), %rdi     # 0x7680b
xorl %eax, %eax
popq %rbx
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_vfp_stran_instr
static void prv_dump_vfp_stran_instr(void *user_data, subtilis_arm_op_t *op,
				     subtilis_arm_instr_type_t type,
				     subtilis_vfp_stran_instr_t *instr,
				     subtilis_error_t *err)
{
	const char *sub = instr->subtract ? "-" : "";
	const char *reg_type = "D";

	if (type == SUBTILIS_VFP_INSTR_FSTS || type == SUBTILIS_VFP_INSTR_FLDS)
		reg_type = "S";

	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);
	printf(" %s%zu", reg_type, instr->dest);
	if (instr->pre_indexed)
		printf(", [R%zu, %s#%d]", instr->base, sub, instr->offset * 4);
	else
		printf(", [R%zu], %s#%d", instr->base, sub, instr->offset * 4);
	if (instr->write_back)
		printf("!");
	printf("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
leaq 0x1a887(%rip), %rax     # 0x76a69
cmpb $0x0, 0x1b(%rcx)
leaq 0x17c28(%rip), %r14     # 0x73e15
cmovneq %rax, %r14
movl %edx, %eax
andl $-0x2, %edx
cmpl $0x46, %edx
leaq 0x16d3a(%rip), %rcx     # 0x72f3a
leaq 0x16f0e(%rip), %r15     # 0x73115
cmoveq %rcx, %r15
leaq 0x4559e(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x17c11(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5c245
leaq 0x45add(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x17bf1(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rdx
leaq 0x17fe5(%rip), %rdi     # 0x74235
movq %r15, %rsi
xorl %eax, %eax
callq 0x12110
movq 0x10(%rbx), %rsi
movzbl 0x18(%rbx), %ecx
shll $0x2, %ecx
leaq 0x1a4a5(%rip), %rax     # 0x76711
leaq 0x1a4ae(%rip), %rdi     # 0x76721
cmpb $0x0, 0x19(%rbx)
cmovneq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x12110
cmpb $0x1, 0x1a(%rbx)
jne 0x5c295
movl $0x21, %edi
callq 0x12030
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x12030
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_vfp_copy_instr
static void prv_dump_vfp_copy_instr(void *user_data, subtilis_arm_op_t *op,
				    subtilis_arm_instr_type_t type,
				    subtilis_vfp_copy_instr_t *instr,
				    subtilis_error_t *err)
{
	const char *reg_type;

	switch (type) {
	case SUBTILIS_VFP_INSTR_FCPYS:
	case SUBTILIS_VFP_INSTR_FNEGS:
	case SUBTILIS_VFP_INSTR_FABSS:
		reg_type = "S";
		return;
	default:
		reg_type = "D";
		break;
	}

	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);
	printf(" %s%zu, %s%zu\n", reg_type, instr->dest, reg_type, instr->src);
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
leal -0x4a(%rdx), %eax
cmpl $0x4, %eax
ja 0x5c2bc
movl $0x15, %ecx
btl %eax, %ecx
jae 0x5c2bc
popq %rbx
retq
movl %edx, %eax
leaq 0x454eb(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x17b5e(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5c2f8
leaq 0x45a2a(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x17b3e(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %r8
leaq 0x1a4e5(%rip), %rdi     # 0x767ec
leaq 0x16e07(%rip), %rcx     # 0x73115
movq %rcx, %rsi
xorl %eax, %eax
popq %rbx
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_vfp_ldrc_instr
static void prv_dump_vfp_ldrc_instr(void *user_data, subtilis_arm_op_t *op,
				    subtilis_arm_instr_type_t type,
				    subtilis_vfp_ldrc_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(" D%zu, label_%zu\n", instr->dest, instr->label);
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
movl %edx, %eax
leaq 0x4548a(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x17afd(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5c359
leaq 0x459c9(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x17add(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdx
leaq 0x1a3f9(%rip), %rdi     # 0x76761
xorl %eax, %eax
popq %rbx
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_vfp_tran_instr
static void prv_dump_vfp_tran_instr(void *user_data, subtilis_arm_op_t *op,
				    subtilis_arm_instr_type_t type,
				    subtilis_vfp_tran_instr_t *instr,
				    subtilis_error_t *err)
{
	const char *dest_reg_type = "S";
	const char *src_reg_type = "S";
	subtilis_arm_reg_t src_reg = instr->src;
	subtilis_arm_reg_t dest_reg = instr->dest;

	switch (type) {
	case SUBTILIS_VFP_INSTR_FTOSIS:
	case SUBTILIS_VFP_INSTR_FTOUIS:
	case SUBTILIS_VFP_INSTR_FTOUIZS:
	case SUBTILIS_VFP_INSTR_FTOSIZS:
	case SUBTILIS_VFP_INSTR_FSITOS:
	case SUBTILIS_VFP_INSTR_FUITOS:
		break;
	case SUBTILIS_VFP_INSTR_FSITOD:
	case SUBTILIS_VFP_INSTR_FUITOD:
		dest_reg_type = "D";
		if (instr->use_dregs)
			src_reg *= 2;
		break;
	case SUBTILIS_VFP_INSTR_FTOSID:
	case SUBTILIS_VFP_INSTR_FTOUID:
	case SUBTILIS_VFP_INSTR_FTOSIZD:
	case SUBTILIS_VFP_INSTR_FTOUIZD:
		src_reg_type = "D";
		if (instr->use_dregs)
			dest_reg *= 2;
		break;
	default:
		subtilis_error_set_assertion_failed(err);
		return;
	}

	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);
	printf(" %s%zu, %s%zu\n", dest_reg_type, dest_reg, src_reg_type,
	       src_reg);
}

// Assembly:
leal -0x51(%rdx), %eax
cmpl $0xb, %eax
ja 0x5c434
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq 0x8(%rcx), %r14
movq 0x10(%rcx), %rbx
leaq 0x16ba3(%rip), %r15     # 0x72f3a
movl $0x956, %ecx            # imm = 0x956
btl %eax, %ecx
jae 0x5c3a6
movq %r15, %r13
jmp 0x5c3d3
movl $0x2a8, %ecx            # imm = 0x2A8
btl %eax, %ecx
jae 0x5c3c4
movb 0x4(%r12), %cl
shlq %cl, %r14
movq %r15, %r13
leaq 0x16d53(%rip), %r15     # 0x73115
jmp 0x5c3d3
movb 0x4(%r12), %cl
shlq %cl, %rbx
leaq 0x16d42(%rip), %r13     # 0x73115
movl %edx, %eax
leaq 0x453d4(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x17a47(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%r12), %eax
cmpq $0xe, %rax
je 0x5c411
leaq 0x45911(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x17a25(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
leaq 0x1a3d4(%rip), %rdi     # 0x767ec
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %rbx, %r8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x12110
leaq 0x19e53(%rip), %rdx     # 0x7628e
movq %r8, %rdi
movl $0xf, %esi
movl $0x319, %ecx            # imm = 0x319
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_vfp_tran_dbl_instr
static void prv_dump_vfp_tran_dbl_instr(void *user_data, subtilis_arm_op_t *op,
					subtilis_arm_instr_type_t type,
					subtilis_vfp_tran_dbl_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]);

	switch (type) {
	case SUBTILIS_VFP_INSTR_FMDRR:
		printf(" D%zu, R%zu, R%zu\n", instr->dest1, instr->src1,
		       instr->src2);
		break;
	case SUBTILIS_VFP_INSTR_FMRRD:
		printf(" R%zu, R%zu, D%zu\n", instr->dest1, instr->dest2,
		       instr->src1);
		break;
	case SUBTILIS_VFP_INSTR_FMSRR:
		printf(" S%zu, S%zu, R%zu, R%zu\n", instr->dest1, instr->dest2,
		       instr->src1, instr->src2);
		break;
	case SUBTILIS_VFP_INSTR_FMRRS:
		printf(" R%zu, R%zu, S%zu, S%zu\n", instr->dest1, instr->dest2,
		       instr->src1, instr->src2);
		break;
	default:
		break;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movl %edx, %eax
leaq 0x45350(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x179c3(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5c493
leaq 0x4588f(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x179a3(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
addl $-0x7d, %r14d
cmpl $0x3, %r14d
ja 0x5c525
leaq 0x19a28(%rip), %rax     # 0x75ed0
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq 0x20(%rbx), %rcx
leaq 0x1a2af(%rip), %rdi     # 0x76773
jmp 0x5c517
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
movq 0x20(%rbx), %r8
leaq 0x1a2bc(%rip), %rdi     # 0x76799
jmp 0x5c4f6
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
movq 0x20(%rbx), %r8
leaq 0x1a2bc(%rip), %rdi     # 0x767b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12110
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x1a26f(%rip), %rdi     # 0x76786
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12110
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_vfp_cptran_instr
static void prv_dump_vfp_cptran_instr(void *user_data, subtilis_arm_op_t *op,
				      subtilis_arm_instr_type_t type,
				      subtilis_vfp_cptran_instr_t *instr,
				      subtilis_error_t *err)
{
	subtilis_arm_reg_t reg;

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

	if (type == SUBTILIS_VFP_INSTR_FMSR) {
		reg = instr->use_dregs ? instr->dest * 2 : instr->dest;
		printf(" S%zu, R%zu\n", reg, instr->src);
	} else {
		reg = instr->use_dregs ? instr->src * 2 : instr->src;
		printf(" R%zu, S%zu\n", instr->dest, reg);
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movl %edx, %eax
leaq 0x45272(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x178e5(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5c571
leaq 0x457b1(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x178c5(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movzbl 0x4(%rbx), %ecx
cmpl $0x5d, %ebp
jne 0x5c58e
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
shlq %cl, %rsi
leaq 0x1a23f(%rip), %rdi     # 0x767cb
jmp 0x5c5a0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
shlq %cl, %rdx
leaq 0x1a238(%rip), %rdi     # 0x767d8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_vfp_data_instr
static void prv_dump_vfp_data_instr(void *user_data, subtilis_arm_op_t *op,
				    subtilis_arm_instr_type_t type,
				    subtilis_vfp_data_instr_t *instr,
				    subtilis_error_t *err)
{
	const char *reg;

	switch (type) {
	case SUBTILIS_VFP_INSTR_FMACS:
	case SUBTILIS_VFP_INSTR_FNMACS:
	case SUBTILIS_VFP_INSTR_FMSCS:
	case SUBTILIS_VFP_INSTR_FNMSCS:
	case SUBTILIS_VFP_INSTR_FMULS:
	case SUBTILIS_VFP_INSTR_FNMULS:
	case SUBTILIS_VFP_INSTR_FADDS:
	case SUBTILIS_VFP_INSTR_FSUBS:
	case SUBTILIS_VFP_INSTR_FDIVS:
		reg = "S";
		break;
	default:
		reg = "D";
		break;
	}

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
leal -0x5f(%rdx), %eax
cmpl $0x10, %eax
ja 0x5c5ce
movl %eax, %eax
leaq 0x19bfb(%rip), %rcx     # 0x761c0
movslq (%rcx,%rax,4), %rbx
addq %rcx, %rbx
jmp 0x5c5d5
leaq 0x16b40(%rip), %rbx     # 0x73115
movl %edx, %eax
leaq 0x451d2(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x17845(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%r14), %eax
cmpq $0xe, %rax
je 0x5c612
leaq 0x45710(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x17824(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movq 0x8(%r14), %rdx
movq 0x10(%r14), %r8
movq 0x18(%r14), %rax
movq %rax, (%rsp)
leaq 0x1a1bc(%rip), %rdi     # 0x767e5
movq %rbx, %rsi
movq %rbx, %rcx
movq %rbx, %r9
xorl %eax, %eax
callq 0x12110
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_vfp_cmp_instr
static void prv_dump_vfp_cmp_instr(void *user_data, subtilis_arm_op_t *op,
				   subtilis_arm_instr_type_t type,
				   subtilis_vfp_cmp_instr_t *instr,
				   subtilis_error_t *err)
{
	const char *reg = "D";
	bool op2 = false;

	printf("\t%s", instr_desc[type]);

	switch (type) {
	case SUBTILIS_VFP_INSTR_FCMPES:
	case SUBTILIS_VFP_INSTR_FCMPS:
		reg = "S";
		op2 = true;
		break;
	case SUBTILIS_VFP_INSTR_FCMPD:
	case SUBTILIS_VFP_INSTR_FCMPED:
		op2 = true;
		break;
	case SUBTILIS_VFP_INSTR_FCMPZS:
	case SUBTILIS_VFP_INSTR_FCMPEZS:
		reg = "S";
		break;
	default:
		break;
	}

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

	printf(" %s%zu", reg, instr->op1);
	if (op2)
		printf(", %s%zu", reg, instr->op2);
	printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movl %edx, %eax
leaq 0x4515a(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x177cd(%rip), %rdi     # 0x73e2e
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x12110
leaq 0x16aa3(%rip), %r14     # 0x73115
addl $-0x71, %ebp
cmpl $0x6, %ebp
ja 0x5c6b3
movl $0x5, %eax
btl %ebp, %eax
jb 0x5c6a9
movl $0xa, %eax
btl %ebp, %eax
jb 0x5c6a4
movl $0x50, %eax
btl %ebp, %eax
jae 0x5c6b3
leaq 0x1689b(%rip), %r14     # 0x72f3a
xorl %r15d, %r15d
jmp 0x5c6b3
movb $0x1, %r15b
jmp 0x5c6b3
movb $0x1, %r15b
leaq 0x16887(%rip), %r14     # 0x72f3a
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5c6d4
leaq 0x4564e(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x17762(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rdx
leaq 0x17b56(%rip), %rdi     # 0x74235
movq %r14, %rsi
xorl %eax, %eax
callq 0x12110
testb %r15b, %r15b
je 0x5c703
movq 0x10(%rbx), %rdx
leaq 0x17b3b(%rip), %rdi     # 0x74234
movq %r14, %rsi
xorl %eax, %eax
callq 0x12110
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12030
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_vfp_sqrt_instr
static void prv_dump_vfp_sqrt_instr(void *user_data, subtilis_arm_op_t *op,
				    subtilis_arm_instr_type_t type,
				    subtilis_vfp_sqrt_instr_t *instr,
				    subtilis_error_t *err)
{
	const char *reg = (type == SUBTILIS_VFP_INSTR_FSQRTD) ? "D" : "S";

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

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movl %edx, %eax
leaq 0x45088(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x176fb(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5c75b
leaq 0x455c7(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x176db(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
cmpl $0x79, %ebp
leaq 0x169b0(%rip), %rax     # 0x73115
leaq 0x167ce(%rip), %rcx     # 0x72f3a
cmoveq %rax, %rcx
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %r8
leaq 0x1a06d(%rip), %rdi     # 0x767ec
movq %rcx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_vfp_sysreg_instr
static void prv_dump_vfp_sysreg_instr(void *user_data, subtilis_arm_op_t *op,
				      subtilis_arm_instr_type_t type,
				      subtilis_vfp_sysreg_instr_t *instr,
				      subtilis_error_t *err)
{
	const char *sysreg;

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

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

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
cmpl $0x7c, %edx
jne 0x5c7c7
cmpq $0xf, 0x8(%rbx)
jne 0x5c7c7
cmpl $0x1, 0x4(%rbx)
jne 0x5c7c7
leaq 0x1a094(%rip), %rdi     # 0x76845
callq 0x12080
movl (%rbx), %eax
cmpq $0xe, %rax
jne 0x5c861
popq %rbx
popq %r14
popq %rbp
retq
movl 0x4(%rbx), %eax
cmpq $0x3, %rax
jae 0x5c82f
leaq 0x455e9(%rip), %rcx     # 0xa1dc0
movq (%rcx,%rax,8), %r14
movl %ebp, %eax
leaq 0x44fcc(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x1763f(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5c817
leaq 0x4550b(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x1761f(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
movq 0x8(%rbx), %rdx
cmpl $0x7c, %ebp
jne 0x5c84c
leaq 0x19ed5(%rip), %rdi     # 0x766fc
movq %rdx, %rsi
movq %r14, %rdx
jmp 0x5c856
leaq 0x19a58(%rip), %rdx     # 0x7628e
movq %r8, %rdi
movl $0xf, %esi
movl $0x3c4, %ecx            # imm = 0x3C4
popq %rbx
popq %r14
popq %rbp
jmp 0x145a4
leaq 0x19fb4(%rip), %rdi     # 0x76807
movq %r14, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x12110
leaq 0x454a8(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x175bc(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_vfp_cvt_instr
static void prv_dump_vfp_cvt_instr(void *user_data, subtilis_arm_op_t *op,
				   subtilis_arm_instr_type_t type,
				   subtilis_vfp_cvt_instr_t *instr,
				   subtilis_error_t *err)
{
	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movl %edx, %eax
leaq 0x44f21(%rip), %rcx     # 0xa17b0
movq (%rcx,%rax,8), %rsi
leaq 0x17594(%rip), %rdi     # 0x73e2e
xorl %eax, %eax
callq 0x12110
movl (%rbx), %eax
cmpq $0xe, %rax
je 0x5c8c2
leaq 0x45460(%rip), %rcx     # 0xa1d10
movq (%rcx,%rax,8), %rsi
leaq 0x17574(%rip), %rdi     # 0x73e2f
xorl %eax, %eax
callq 0x12110
cmpl $0x81, %ebp
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x19f3b(%rip), %rax     # 0x76812
leaq 0x19f41(%rip), %rdi     # 0x7681f
cmoveq %rax, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12110