LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movb 0x42(%rax), %dl
leaq 0x267ad(%rip), %rax     # 0xab276
leaq 0x25a0c(%rip), %rcx     # 0xaa4dc
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x4ac79(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x263a4(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x84b23
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4b1af(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x2637b(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
testb $0x1, 0x43(%rax)
je 0x84b3b
leaq 0x25688(%rip), %rdi     # 0xaa1bc
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x28c6e(%rip), %rdi     # 0xad7b8
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
testb $0x1, 0x40(%rax)
je 0x84baa
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x30(%rbp), %rdx
leaq 0x28a6d(%rip), %rdi     # 0xad5db
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x86d50
leaq 0x296c2(%rip), %rdi     # 0xae24b
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
testb $0x1, 0x41(%rax)
je 0x84ba8
leaq 0x2594a(%rip), %rdi     # 0xaa4eb
movb $0x0, %al
callq 0x120f0
jmp 0x84bd1
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x30(%rbp), %rdx
leaq 0x28a2a(%rip), %rdi     # 0xad5e7
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x86d50
leaq 0x2629b(%rip), %rdi     # 0xaae73
movb $0x0, %al
callq 0x120f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x70(%rbp), %rdi
leaq 0x4b15a(%rip), %rsi     # 0xcfd70
movl $0x40, %edx
callq 0x12190
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x4ab34(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x2625f(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x84c68
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4b06a(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x26236(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x70(%rbp,%rax,8), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x2891a(%rip), %rdi     # 0xad59d
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
testb $0x1, 0x1c(%rax)
je 0x84ca2
leaq 0x25850(%rip), %rdi     # 0xaa4eb
movb $0x0, %al
callq 0x120f0
leaq 0x28960(%rip), %rdi     # 0xad609
movb $0x0, %al
callq 0x120f0
movq $0x0, -0x30(%rbp)
cmpq $0xf, -0x30(%rbp)
jae 0x84d0c
movq -0x30(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
movq -0x20(%rbp), %rcx
andq 0x10(%rcx), %rax
cmpq $0x0, %rax
je 0x84cfc
movq -0x30(%rbp), %rsi
leaq 0x28ad2(%rip), %rdi     # 0xad7b9
movb $0x0, %al
callq 0x120f0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x84d0c
jmp 0x84cfe
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x84cb8
jmp 0x84d0e
cmpq $0xf, -0x30(%rbp)
jae 0x84d54
movq -0x30(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
movq -0x20(%rbp), %rcx
andq 0x10(%rcx), %rax
cmpq $0x0, %rax
je 0x84d44
movq -0x30(%rbp), %rsi
leaq 0x28a7a(%rip), %rdi     # 0xad7b7
movb $0x0, %al
callq 0x120f0
jmp 0x84d46
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x84d0e
leaq 0x258d0(%rip), %rdi     # 0xaa62b
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
testb $0x1, 0x1d(%rax)
je 0x84d7a
leaq 0x25ba6(%rip), %rdi     # 0xaa919
movb $0x0, %al
callq 0x120f0
leaq 0x260f2(%rip), %rdi     # 0xaae73
movb $0x0, %al
callq 0x120f0
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movb 0x4(%rax), %cl
leaq 0x253fb(%rip), %rsi     # 0xaa1bc
leaq 0x28d30(%rip), %rax     # 0xadaf8
testb $0x1, %cl
cmovneq %rax, %rsi
leaq 0x260c0(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x84e07
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4aecb(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x26097(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x84e7d
movq -0x20(%rbp), %rax
testb $0x1, 0x6(%rax)
je 0x84e33
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x287e3(%rip), %rdi     # 0xad60d
movb $0x0, %al
callq 0x120f0
jmp 0x84e7b
cmpq $0x0, -0x30(%rbp)
je 0x84e61
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x26514(%rip), %rdi     # 0xab36c
movb $0x0, %al
callq 0x120f0
jmp 0x84e79
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %esi
leaq 0x287a4(%rip), %rdi     # 0xad616
movb $0x0, %al
callq 0x120f0
jmp 0x84e7b
jmp 0x84eb6
cmpq $0x0, -0x30(%rbp)
je 0x84e9c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x2884e(%rip), %rdi     # 0xad6e1
movb $0x0, %al
callq 0x120f0
jmp 0x84eb4
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %esi
leaq 0x28769(%rip), %rdi     # 0xad616
movb $0x0, %al
callq 0x120f0
jmp 0x84eb6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x4a879(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x25fa4(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x84f23
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4adaf(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x25f7b(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x286e9(%rip), %rdi     # 0xad61b
movb $0x0, %al
callq 0x120f0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x4a7f9(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x25f24(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x84fa3
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4ad2f(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x25efb(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x28668(%rip), %rdi     # 0xad622
movb $0x0, %al
callq 0x120f0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x4a769(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x25e94(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x85033
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4ac9f(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x25e6b(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0x285e2(%rip), %rdi     # 0xad634
movb $0x0, %al
callq 0x120f0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x4a6d9(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x25e04(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x850c3
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4ac0f(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x25ddb(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x28548(%rip), %rdi     # 0xad622
movb $0x0, %al
callq 0x120f0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x4a649(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x25d74(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x85190
movq -0x20(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, %ecx
leaq 0x4ab7d(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
movq -0x20(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, %ecx
leaq 0x4ab69(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rdx
leaq 0x28562(%rip), %rdi     # 0xad6c4
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0x28441(%rip), %rdi     # 0xad5c8
movb $0x0, %al
callq 0x120f0
jmp 0x851bd
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %r8
leaq 0x2840c(%rip), %rdi     # 0xad5c2
movb $0x0, %al
callq 0x120f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movb 0x23(%rax), %dl
leaq 0x25e5d(%rip), %rax     # 0xab276
leaq 0x250bc(%rip), %rcx     # 0xaa4dc
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x4a329(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x25a54(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x85473
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4a85f(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x25a2b(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x86f40
movq %rax, %rsi
leaq 0x25a0d(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x28211(%rip), %rdi     # 0xad6b1
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
testb $0x1, 0x21(%rax)
je 0x854d8
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rax
movzbl 0x20(%rax), %ecx
shll $0x2, %ecx
leaq 0x281bc(%rip), %rdi     # 0xad68b
movb $0x0, %al
callq 0x120f0
jmp 0x854fd
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rax
movzbl 0x20(%rax), %ecx
shll $0x2, %ecx
leaq 0x281a5(%rip), %rdi     # 0xad69b
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
testb $0x1, 0x22(%rax)
je 0x85515
leaq 0x24fdd(%rip), %rdi     # 0xaa4eb
movb $0x0, %al
callq 0x120f0
leaq 0x25957(%rip), %rdi     # 0xaae73
movb $0x0, %al
callq 0x120f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x4a209(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x25934(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x85593
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4a73f(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x2590b(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
cmpl $0x3e, -0x14(%rbp)
jne 0x855b7
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x86f40
movq %rax, %rsi
leaq 0x258e7(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movl 0x28(%rax), %edi
callq 0x86f90
movq %rax, %rsi
leaq 0x258ca(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
cmpl $0x3e, -0x14(%rbp)
jne 0x8562f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x2809a(%rip), %rdi     # 0xad683
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x85617
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x86ff0
leaq 0x280b1(%rip), %rdi     # 0xad6bf
movb $0x1, %al
callq 0x120f0
jmp 0x8562d
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x28193(%rip), %rdi     # 0xad7b9
movb $0x0, %al
callq 0x120f0
jmp 0x8564d
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x28065(%rip), %rdi     # 0xad6ab
movb $0x0, %al
callq 0x120f0
leaq 0x2581f(%rip), %rdi     # 0xaae73
movb $0x0, %al
callq 0x120f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x4a0c9(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x257f4(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x856d3
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4a5ff(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x257cb(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x27fd5(%rip), %rdi     # 0xad6b7
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x85710
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x86ff0
leaq 0x27fb7(%rip), %rdi     # 0xad6be
movb $0x1, %al
callq 0x120f0
jmp 0x85726
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x27f92(%rip), %rdi     # 0xad6b1
movb $0x0, %al
callq 0x120f0
leaq 0x25746(%rip), %rdi     # 0xaae73
movb $0x0, %al
callq 0x120f0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x49ff9(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x86f40
movq -0x30(%rbp), %rsi
movq %rax, %rdx
leaq 0x27f39(%rip), %rdi     # 0xad6c3
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x857bb
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4a517(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x256e3(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x27ef7(%rip), %rdi     # 0xad6c9
movb $0x0, %al
callq 0x120f0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x49f59(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x25684(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x85843
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4a48f(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x2565b(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x27f3c(%rip), %rdi     # 0xad78e
movb $0x0, %al
callq 0x120f0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movb 0x1b(%rax), %dl
leaq 0x259ed(%rip), %rax     # 0xab276
leaq 0x24c4c(%rip), %rcx     # 0xaa4dc
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x30(%rbp)
leaq 0x248a6(%rip), %rax     # 0xaa148
movq %rax, -0x38(%rbp)
cmpl $0x46, -0x14(%rbp)
je 0x858b2
cmpl $0x47, -0x14(%rbp)
jne 0x858bd
leaq 0x246b1(%rip), %rax     # 0xa9f6a
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x49e97(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x255c2(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x85905
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4a3cd(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x25599(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x25987(%rip), %rdi     # 0xab29f
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
testb $0x1, 0x19(%rax)
je 0x85950
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rax
movzbl 0x18(%rax), %ecx
shll $0x2, %ecx
leaq 0x27d44(%rip), %rdi     # 0xad68b
movb $0x0, %al
callq 0x120f0
jmp 0x85975
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rax
movzbl 0x18(%rax), %ecx
shll $0x2, %ecx
leaq 0x27d2d(%rip), %rdi     # 0xad69b
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
testb $0x1, 0x1a(%rax)
je 0x8598d
leaq 0x24b65(%rip), %rdi     # 0xaa4eb
movb $0x0, %al
callq 0x120f0
leaq 0x254df(%rip), %rdi     # 0xaae73
movb $0x0, %al
callq 0x120f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x4a, %eax
je 0x859ec
jmp 0x859d8
movl -0x34(%rbp), %eax
subl $0x4c, %eax
je 0x859ec
jmp 0x859e2
movl -0x34(%rbp), %eax
subl $0x4e, %eax
jne 0x859f9
jmp 0x859ec
leaq 0x24577(%rip), %rax     # 0xa9f6a
movq %rax, -0x30(%rbp)
jmp 0x85a72
leaq 0x24748(%rip), %rax     # 0xaa148
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x49d50(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x2547b(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x85a4c
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4a286(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x25452(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %r8
leaq 0x27cfb(%rip), %rdi     # 0xad766
movb $0x0, %al
callq 0x120f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x49cb9(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x253e4(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x85ae3
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4a1ef(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x253bb(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x27be1(%rip), %rdi     # 0xad6db
movb $0x0, %al
callq 0x120f0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x49a99(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x251c4(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x85d03
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x49fcf(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x2519b(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movl -0x14(%rbp), %eax
addl $-0x7d, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3, %eax
ja 0x85ddf
movq -0x30(%rbp), %rax
leaq 0x27165(%rip), %rcx     # 0xace88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0x279a2(%rip), %rdi     # 0xad6ed
movb $0x0, %al
callq 0x120f0
jmp 0x85de1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0x2798a(%rip), %rdi     # 0xad700
movb $0x0, %al
callq 0x120f0
jmp 0x85de1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %r8
leaq 0x2796d(%rip), %rdi     # 0xad713
movb $0x0, %al
callq 0x120f0
jmp 0x85de1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %r8
leaq 0x27956(%rip), %rdi     # 0xad72c
movb $0x0, %al
callq 0x120f0
jmp 0x85de1
jmp 0x85de1
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x49949(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x25074(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x85e53
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x49e7f(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x2504b(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
cmpl $0x5d, -0x14(%rbp)
jne 0x85ea4
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x85e74
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x38(%rbp)
jmp 0x85e80
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x278aa(%rip), %rdi     # 0xad745
movb $0x0, %al
callq 0x120f0
jmp 0x85eed
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x85ebf
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
shlq %rax
movq %rax, -0x40(%rbp)
jmp 0x85ecb
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x30(%rbp), %rdx
leaq 0x2786c(%rip), %rdi     # 0xad752
movb $0x0, %al
callq 0x120f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x5f, %eax
je 0x85f78
jmp 0x85f28
movl -0x34(%rbp), %eax
subl $0x61, %eax
je 0x85f78
jmp 0x85f32
movl -0x34(%rbp), %eax
subl $0x63, %eax
je 0x85f78
jmp 0x85f3c
movl -0x34(%rbp), %eax
subl $0x65, %eax
je 0x85f78
jmp 0x85f46
movl -0x34(%rbp), %eax
subl $0x67, %eax
je 0x85f78
jmp 0x85f50
movl -0x34(%rbp), %eax
subl $0x69, %eax
je 0x85f78
jmp 0x85f5a
movl -0x34(%rbp), %eax
subl $0x6b, %eax
je 0x85f78
jmp 0x85f64
movl -0x34(%rbp), %eax
subl $0x6d, %eax
je 0x85f78
jmp 0x85f6e
movl -0x34(%rbp), %eax
subl $0x6f, %eax
jne 0x85f85
jmp 0x85f78
leaq 0x23feb(%rip), %rax     # 0xa9f6a
movq %rax, -0x30(%rbp)
jmp 0x85f90
leaq 0x241bc(%rip), %rax     # 0xaa148
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x497c4(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x24eef(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x85fd8
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x49cfa(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x24ec6(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %r8
movq -0x30(%rbp), %r9
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
leaq 0x2775c(%rip), %rdi     # 0xad75f
movq %rax, (%rsp)
movb $0x0, %al
callq 0x120f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq 0x24106(%rip), %rax     # 0xaa148
movq %rax, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x4970a(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x24e35(%rip), %rdi     # 0xaae96
xorl %eax, %eax
callq 0x120f0
movl -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
subl $0x71, %eax
je 0x860a7
jmp 0x86075
movl -0x38(%rbp), %eax
subl $0x72, %eax
je 0x860b8
jmp 0x8607f
movl -0x38(%rbp), %eax
subl $0x73, %eax
je 0x860a7
jmp 0x86089
movl -0x38(%rbp), %eax
subl $0x74, %eax
je 0x860b8
jmp 0x86093
movl -0x38(%rbp), %eax
subl $0x75, %eax
je 0x860be
jmp 0x8609d
movl -0x38(%rbp), %eax
subl $0x77, %eax
je 0x860be
jmp 0x860cb
leaq 0x23ebc(%rip), %rax     # 0xa9f6a
movq %rax, -0x30(%rbp)
movb $0x1, -0x31(%rbp)
jmp 0x860cd
movb $0x1, -0x31(%rbp)
jmp 0x860cd
leaq 0x23ea5(%rip), %rax     # 0xa9f6a
movq %rax, -0x30(%rbp)
jmp 0x860cd
jmp 0x860cd
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x860f7
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x49bdb(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x24da7(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x25195(%rip), %rdi     # 0xab29f
movb $0x0, %al
callq 0x120f0
testb $0x1, -0x31(%rbp)
je 0x86131
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x25174(%rip), %rdi     # 0xab29e
movb $0x0, %al
callq 0x120f0
leaq 0x24d3b(%rip), %rdi     # 0xaae73
movb $0x0, %al
callq 0x120f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %edx
leaq 0x23df5(%rip), %rax     # 0xa9f6a
leaq 0x23fcc(%rip), %rcx     # 0xaa148
cmpl $0x79, %edx
cmoveq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x495cd(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x24cf8(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x861cf
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x49b03(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x24ccf(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %r8
leaq 0x27578(%rip), %rdi     # 0xad766
movb $0x0, %al
callq 0x120f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x7c, -0x14(%rbp)
jne 0x86273
movq -0x20(%rbp), %rax
cmpq $0xf, 0x8(%rax)
jne 0x86273
movq -0x20(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x86273
leaq 0x27538(%rip), %rdi     # 0xad775
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x8626e
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x49a64(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x24c30(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
jmp 0x86361
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x86297
jmp 0x86283
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0x862a4
jmp 0x8628d
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x862b1
jmp 0x862be
leaq 0x27f4d(%rip), %rax     # 0xae1eb
movq %rax, -0x30(%rbp)
jmp 0x862dd
leaq 0x274d3(%rip), %rax     # 0xad77e
movq %rax, -0x30(%rbp)
jmp 0x862dd
leaq 0x274cc(%rip), %rax     # 0xad784
movq %rax, -0x30(%rbp)
jmp 0x862dd
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x26f3a(%rip), %rdx     # 0xad208
movl $0x3c4, %ecx            # imm = 0x3C4
callq 0x158e0
jmp 0x86361
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x49477(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x24ba2(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x86325
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x499ad(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x24b79(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
cmpl $0x7c, -0x14(%rbp)
jne 0x86347
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x30(%rbp), %rdx
leaq 0x27338(%rip), %rdi     # 0xad676
movb $0x0, %al
callq 0x120f0
jmp 0x86361
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x27430(%rip), %rdi     # 0xad78a
movb $0x0, %al
callq 0x120f0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x493c9(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x24af4(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x863d3
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x498ff(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x24acb(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
cmpl $0x81, -0x14(%rbp)
jne 0x863fc
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x273a2(%rip), %rdi     # 0xad795
movb $0x0, %al
callq 0x120f0
jmp 0x8641a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x2738f(%rip), %rdi     # 0xad7a2
movb $0x0, %al
callq 0x120f0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_dump.c
// Function: prv_dump_reg_only_instr
static void prv_dump_reg_only_instr(void *user_data, subtilis_arm_op_t *op,
				    subtilis_arm_instr_type_t type,
				    subtilis_arm_reg_only_instr_t *instr,
				    subtilis_error_t *err)
{
	printf("\t%s", instr_desc[type]);
	if (instr->ccode != SUBTILIS_ARM_CCODE_AL)
		printf("%s", ccode_desc[instr->ccode]);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x49129(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x24854(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x86673
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4965f(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x2482b(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0x26f36(%rip), %rdi     # 0xad5c8
movb $0x0, %al
callq 0x120f0
addq $0x30, %rsp
popq %rbp
retq
nop