LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_encode_vfp_ldrc_instr
static void prv_encode_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)
{
	subtilis_vfp_stran_instr_t stran;
	subtilis_arm_encode_ud_t *ud = user_data;

	/*
	 * adj is the number of additional bytes that can be written
	 * without causing a pool flush.  8 for the double and 4
	 * for the ldr instruction.
	 */

	size_t adj = 12;

	prv_check_pool_adj(ud, adj, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (ud->ldrc_real == SIZE_MAX)
		ud->ldrc_real = ud->bytes_written;

	prv_add_const(ud, instr->label, ud->bytes_written,
		      SUBTILIS_ARM_ENCODE_BP_LDRF, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	stran.ccode = instr->ccode;
	stran.dest = instr->dest;
	stran.base = 15;
	stran.offset = 0;
	stran.pre_indexed = true;
	stran.write_back = false;
	stran.subtract = false;
	prv_encode_vfp_stran_instr(user_data, op, SUBTILIS_VFP_INSTR_FLDD,
				   &stran, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %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, -0x50(%rbp)
movq $0xc, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x81c40
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x8001a
jmp 0x800af
movq -0x50(%rbp), %rax
cmpq $-0x1, 0x88(%rax)
jne 0x8003b
movq -0x50(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x50(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x28(%rbp), %r8
movl $0x2, %ecx
callq 0x82080
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x80068
jmp 0x800af
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq $0xf, -0x38(%rbp)
movb $0x0, -0x30(%rbp)
movb $0x1, -0x2f(%rbp)
movb $0x0, -0x2e(%rbp)
movb $0x0, -0x2d(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %r8
movl $0x49, %edx
leaq -0x48(%rbp), %rcx
callq 0x7fd40
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_encode_vfp_cptran_instr
static void prv_encode_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)
{
	uint32_t word;
	subtilis_arm_reg_t src = instr->src;
	subtilis_arm_reg_t dest = instr->dest;
	subtilis_arm_encode_ud_t *ud = user_data;

	prv_check_pool(ud, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (type == SUBTILIS_VFP_INSTR_FMSR) {
		if (instr->use_dregs)
			dest *= 2;
		word = 0xe000a10;
		word |= (src & 0xf) << 12;
		word |= ((dest >> 1) & 0xf) << 16;
		word |= (dest & 1) << 7;
	} else {
		if (instr->use_dregs)
			src *= 2;
		word = 0xe100a10;
		word |= (dest & 0xf) << 12;
		word |= ((src >> 1) & 0xf) << 16;
		word |= (src & 1) << 7;
	}

	word |= instr->ccode << 28;

	prv_ensure_code(ud, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	prv_add_word(ud, word, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x819a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x805f6
jmp 0x806f1
cmpl $0x5d, -0x14(%rbp)
jne 0x8065c
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x80611
movq -0x40(%rbp), %rax
shlq %rax
movq %rax, -0x40(%rbp)
movl $0xe000a10, -0x2c(%rbp) # imm = 0xE000A10
movq -0x38(%rbp), %rcx
andq $0xf, %rcx
shlq $0xc, %rcx
movl -0x2c(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %rcx
shrq %rcx
andq $0xf, %rcx
shlq $0x10, %rcx
movl -0x2c(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %rcx
andq $0x1, %rcx
shlq $0x7, %rcx
movl -0x2c(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x2c(%rbp)
jmp 0x806ba
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x80671
movq -0x38(%rbp), %rax
shlq %rax
movq %rax, -0x38(%rbp)
movl $0xe100a10, -0x2c(%rbp) # imm = 0xE100A10
movq -0x40(%rbp), %rcx
andq $0xf, %rcx
shlq $0xc, %rcx
movl -0x2c(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
shrq %rcx
andq $0xf, %rcx
shlq $0x10, %rcx
movl -0x2c(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
andq $0x1, %rcx
shlq $0x7, %rcx
movl -0x2c(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
shll $0x1c, %eax
orl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x81b90
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x806e1
jmp 0x806f1
movq -0x48(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x81bc0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_encode_vfp_sqrt_instr
static void prv_encode_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)
{
	uint32_t word;
	subtilis_arm_encode_ud_t *ud = user_data;

	prv_check_pool(ud, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (type == SUBTILIS_VFP_INSTR_FSQRTD) {
		word = 0xeb10bc0;
		word |= instr->op1 & 0xf;
		word |= (instr->dest & 0xf) << 12;
	} else {
		word = 0xeb10ac0;
		word |= (instr->op1 >> 1) & 0xf;
		word |= (instr->op1 & 1) << 5;
		word |= ((instr->dest >> 1) & 0xf) << 12;
		word |= (instr->dest & 1) << 22;
	}

	word |= instr->ccode << 28;

	prv_ensure_code(ud, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	prv_add_word(ud, word, err);
}

// 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 -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x819a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x80c3e
jmp 0x80d1f
cmpl $0x79, -0x14(%rbp)
jne 0x80c7b
movl $0xeb10bc0, -0x2c(%rbp) # imm = 0xEB10BC0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
andq $0xf, %rcx
movl -0x2c(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0xf, %rcx
shlq $0xc, %rcx
movl -0x2c(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x2c(%rbp)
jmp 0x80ce8
movl $0xeb10ac0, -0x2c(%rbp) # imm = 0xEB10AC0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
shrq %rcx
andq $0xf, %rcx
movl -0x2c(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
andq $0x1, %rcx
shlq $0x5, %rcx
movl -0x2c(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
shrq %rcx
andq $0xf, %rcx
shlq $0xc, %rcx
movl -0x2c(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0x1, %rcx
shlq $0x16, %rcx
movl -0x2c(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
shll $0x1c, %eax
orl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x81b90
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x80d0f
jmp 0x80d1f
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x81bc0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_encode_vfp_sysreg_instr
static void prv_encode_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)
{
	uint32_t word;
	subtilis_arm_encode_ud_t *ud = user_data;

	prv_check_pool(ud, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (type == SUBTILIS_VFP_INSTR_FMRX)
		word = 0xef00a10;
	else
		word = 0xee00a10;

	word |= (instr->arm_reg & 0xf) << 12;
	switch (instr->sysreg) {
	case SUBTILIS_VFP_SYSREG_FPSID:
		break;
	case SUBTILIS_VFP_SYSREG_FPSCR:
		word |= 1 << 16;
		break;
	case SUBTILIS_VFP_SYSREG_FPEXC:
		word |= 8 << 16;
		break;
	}

	word |= instr->ccode << 28;

	prv_ensure_code(ud, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	prv_add_word(ud, word, err);
}

// 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 -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x819a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x80d6e
jmp 0x80e0e
cmpl $0x7c, -0x14(%rbp)
jne 0x80d7d
movl $0xef00a10, -0x2c(%rbp) # imm = 0xEF00A10
jmp 0x80d84
movl $0xee00a10, -0x2c(%rbp) # imm = 0xEE00A10
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
andl $0xf, %ecx
shll $0xc, %ecx
movl -0x2c(%rbp), %eax
orl %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x3c(%rbp)
testl %eax, %eax
je 0x80dbd
jmp 0x80da9
movl -0x3c(%rbp), %eax
subl $0x1, %eax
je 0x80dbf
jmp 0x80db3
movl -0x3c(%rbp), %eax
subl $0x2, %eax
je 0x80dcc
jmp 0x80dd7
jmp 0x80dd7
movl -0x2c(%rbp), %eax
orl $0x10000, %eax          # imm = 0x10000
movl %eax, -0x2c(%rbp)
jmp 0x80dd7
movl -0x2c(%rbp), %eax
orl $0x80000, %eax          # imm = 0x80000
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
shll $0x1c, %eax
orl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x81b90
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x80dfe
jmp 0x80e0e
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x81bc0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_encode_vfp_cvt_instr
static void prv_encode_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)
{
	uint32_t word;
	subtilis_arm_encode_ud_t *ud = user_data;

	prv_check_pool(ud, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (type == SUBTILIS_VFP_INSTR_FCVTDS) {
		word = 0xeb70ac0;
		word |= (instr->dest << 12);
		word |= (instr->op1 >> 1) | ((instr->op1 & 1) << 5);
	} else {
		word = 0xeb70bc0;
		word |= instr->op1 & 0xf;
		word |=
		    ((instr->dest & 0x1e) << 11) | ((instr->dest & 1) << 22);
	}
	word |= instr->ccode << 28;

	prv_ensure_code(ud, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	prv_add_word(ud, word, err);
}

// 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 -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x819a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x80e5e
jmp 0x80f2b
cmpl $0x81, -0x14(%rbp)
jne 0x80eac
movl $0xeb70ac0, -0x2c(%rbp) # imm = 0xEB70AC0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
shlq $0xc, %rcx
movl -0x2c(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
shrq %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
shlq $0x5, %rax
orq %rax, %rcx
movl -0x2c(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x2c(%rbp)
jmp 0x80ef4
movl $0xeb70bc0, -0x2c(%rbp) # imm = 0xEB70BC0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
andq $0xf, %rcx
movl -0x2c(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0x1e, %rcx
shlq $0xb, %rcx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
andq $0x1, %rax
shlq $0x16, %rax
orq %rax, %rcx
movl -0x2c(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
shll $0x1c, %eax
orl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x81b90
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x80f1b
jmp 0x80f2b
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x81bc0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_add_word
static void prv_add_word(subtilis_arm_encode_ud_t *ud, uint32_t word,
			 subtilis_error_t *err)
{
	uint32_t *code_ptr;

	if (ud->bytes_written & 3) {
		subtilis_error_set_ass_bad_alignment(err);
		return;
	}

	code_ptr = (uint32_t *)&ud->code[ud->bytes_written];
	*code_ptr = word;
	ud->bytes_written += 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0x81c01
movq -0x18(%rbp), %rdi
movl $0x5d, %esi
leaq 0x2b23b(%rip), %rdx     # 0xace30
movl $0xfb, %ecx
callq 0x158e0
jmp 0x81c2e
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
addq 0x30(%rcx), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_add_back_patch
static void prv_add_back_patch(subtilis_arm_encode_ud_t *ud,
			       subtilis_arm_encode_bp_type_t type, size_t label,
			       size_t code_index, subtilis_error_t *err)
{
	size_t new_max;
	subtilis_arm_encode_bp_t *new_bp;

	if (ud->back_patch_count == ud->max_patch_count) {
		new_max = ud->max_patch_count + SUBTILIS_ENCODER_BACKPATCH_GRAN;
		new_bp = realloc(ud->back_patches,
				 new_max * sizeof(subtilis_arm_encode_bp_t));
		if (!new_bp) {
			subtilis_error_set_oom(err);
			return;
		}
		ud->max_patch_count = new_max;
		ud->back_patches = new_bp;
	}
	new_bp = &ud->back_patches[ud->back_patch_count++];
	new_bp->type = type;
	new_bp->label = label;
	new_bp->code_index = code_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jne 0x81e60
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
addq $0x80, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
imulq $0x18, -0x30(%rbp), %rsi
callq 0x121e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x81e48
movq -0x28(%rbp), %rdi
movl $0x1, %esi
leaq 0x2aff4(%rip), %rdx     # 0xace30
movl $0x19a, %ecx            # imm = 0x19A
callq 0x158e0
jmp 0x81ea7
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x70(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x70(%rdx)
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_convert_shift
static uint32_t prv_convert_shift(subtilis_arm_shift_type_t type,
				  subtilis_error_t *err)
{
	switch (type) {
	case SUBTILIS_ARM_SHIFT_LSL:
		return 0;
	case SUBTILIS_ARM_SHIFT_RRX:
		subtilis_error_set_assertion_failed(err);
		return 0;
	default:
		return ((uint32_t)type) - 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x81ed5
jmp 0x81ecb
movl -0x14(%rbp), %eax
subl $0x5, %eax
je 0x81ede
jmp 0x81f01
movl $0x0, -0x4(%rbp)
jmp 0x81f0a
movq -0x10(%rbp), %rdi
movl $0xf, %esi
leaq 0x2af42(%rip), %rdx     # 0xace30
movl $0x224, %ecx            # imm = 0x224
callq 0x158e0
movl $0x0, -0x4(%rbp)
jmp 0x81f0a
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_encode_stran_op2
static void prv_encode_stran_op2(subtilis_arm_op2_t *op2, uint32_t *word,
				 subtilis_error_t *err)
{
	uint32_t shift;

	if (op2->type == SUBTILIS_ARM_OP2_REG) {
		if (op2->op.reg > 15) {
			subtilis_error_set_assertion_failed(err);
			return;
		}
		*word |= 1 << 25;
		*word |= op2->op.reg;
	} else if (op2->type == SUBTILIS_ARM_OP2_I32) {
		if (op2->op.integer > 4095) {
			subtilis_error_set_assertion_failed(err);
			return;
		}
		*word |= op2->op.integer;
	} else if (op2->type == SUBTILIS_ARM_OP2_SHIFTED) {
		if (op2->op.shift.reg > 15) {
			subtilis_error_set_assertion_failed(err);
			return;
		}

		*word |= op2->op.shift.reg;
		*word |= 1 << 25;
		*word |= (op2->op.shift.shift.integer & 31) << 7;
		shift = prv_convert_shift(op2->op.shift.type, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		*word |= shift << 5;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x81f8d
movq -0x8(%rbp), %rax
cmpq $0xf, 0x8(%rax)
jbe 0x81f67
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x2aed8(%rip), %rdx     # 0xace30
movl $0x2b1, %ecx            # imm = 0x2B1
callq 0x158e0
jmp 0x82070
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x2000000, %ecx        # imm = 0x2000000
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orq %rdx, %rcx
movl %ecx, (%rax)
jmp 0x82070
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x81fd6
movq -0x8(%rbp), %rax
cmpl $0xfff, 0x8(%rax)       # imm = 0xFFF
jbe 0x81fc2
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x2ae7d(%rip), %rdx     # 0xace30
movl $0x2b8, %ecx            # imm = 0x2B8
callq 0x158e0
jmp 0x82070
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x8206e
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x8206c
movq -0x8(%rbp), %rax
cmpq $0xf, 0x8(%rax)
jbe 0x8200a
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x2ae32(%rip), %rdx     # 0xace30
movl $0x2be, %ecx            # imm = 0x2BE
callq 0x158e0
jmp 0x82070
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orq %rdx, %rcx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x2000000, %ecx        # imm = 0x2000000
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
andl $0x1f, %ecx
shll $0x7, %ecx
movq -0x10(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
movq -0x18(%rbp), %rsi
callq 0x81eb0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x8205e
jmp 0x82070
movl -0x1c(%rbp), %ecx
shll $0x5, %ecx
movq -0x10(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x8206e
jmp 0x82070
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_add_const
static void prv_add_const(subtilis_arm_encode_ud_t *ud, size_t label,
			  size_t code_index,
			  subtilis_arm_encode_const_type_t type,
			  subtilis_error_t *err)
{
	size_t new_max;
	subtilis_arm_encode_const_t *new_const;

	if (ud->const_count == ud->max_const_count) {
		new_max = ud->max_const_count + SUBTILIS_ENCODER_BACKPATCH_GRAN;
		new_const =
		    realloc(ud->constants,
			    new_max * sizeof(subtilis_arm_encode_const_t));
		if (!new_const) {
			subtilis_error_set_oom(err);
			return;
		}
		ud->max_const_count = new_max;
		ud->constants = new_const;
	}
	if (type != SUBTILIS_ARM_ENCODE_BP_LDRF)
		ud->int_const_count++;
	else
		ud->real_const_count++;
	new_const = &ud->constants[ud->const_count++];
	new_const->label = label;
	new_const->code_index = code_index;
	new_const->type = type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jne 0x82116
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
addq $0x80, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x30(%rbp), %rsi
shlq $0x5, %rsi
callq 0x121e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x820fe
movq -0x28(%rbp), %rdi
movl $0x1, %esi
leaq 0x2ad41(%rip), %rdx     # 0xace30
movl $0x1f3, %ecx            # imm = 0x1F3
callq 0x158e0
jmp 0x82185
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
cmpl $0x2, -0x1c(%rbp)
je 0x8212e
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rax)
jmp 0x8213e
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x48(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x48(%rdx)
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_encode_fpa_rounding
static void prv_encode_fpa_rounding(subtilis_fpa_rounding_t rounding,
				    uint32_t *word)
{
	switch (rounding) {
	case SUBTILIS_FPA_ROUNDING_NEAREST:
		break;
	case SUBTILIS_FPA_ROUNDING_PLUS_INFINITY:
		*word |= 1 << 5;
		break;
	case SUBTILIS_FPA_ROUNDING_MINUS_INFINITY:
		*word |= 1 << 6;
		break;
	case SUBTILIS_FPA_ROUNDING_ZERO:
		*word |= 3 << 5;
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x82433
movq -0x18(%rbp), %rax
leaq 0x2a981(%rip), %rcx     # 0xacd84
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x82433
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x20, %ecx
movl %ecx, (%rax)
jmp 0x82433
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x40, %ecx
movl %ecx, (%rax)
jmp 0x82433
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x60, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_encode_src_dest
static uint32_t prv_encode_src_dest(subtilis_arm_reg_t src,
				    subtilis_arm_reg_t dest, bool float32_src,
				    bool float32_dest)
{
	uint32_t word = 0;

	if (float32_src) {
		word |= (src >> 1) & 0xf;
		word |= (src & 1) << 5;
	} else {
		word |= src & 0xf;
	}
	if (float32_dest) {
		word |= ((dest >> 1) & 0xf) << 12;
		word |= (dest & 1) << 22;
	} else {
		word |= (dest & 0xf) << 12;
	}

	return word;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movl $0x0, -0x18(%rbp)
testb $0x1, -0x11(%rbp)
je 0x82493
movq -0x8(%rbp), %rcx
shrq %rcx
andq $0xf, %rcx
movl -0x18(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
andq $0x1, %rcx
shlq $0x5, %rcx
movl -0x18(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x18(%rbp)
jmp 0x824a4
movq -0x8(%rbp), %rcx
andq $0xf, %rcx
movl -0x18(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x18(%rbp)
testb $0x1, -0x12(%rbp)
je 0x824d9
movq -0x10(%rbp), %rcx
shrq %rcx
andq $0xf, %rcx
shlq $0xc, %rcx
movl -0x18(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
andq $0x1, %rcx
shlq $0x16, %rcx
movl -0x18(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x18(%rbp)
jmp 0x824ee
movq -0x10(%rbp), %rcx
andq $0xf, %rcx
shlq $0xc, %rcx
movl -0x18(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_apply_constants
static void prv_apply_constants(subtilis_arm_encode_ud_t *ud,
				subtilis_error_t *err)
{
	subtilis_arm_encode_const_t *cnst;
	size_t i;
	int32_t dist;
	uint32_t *code_ptr;

	for (i = 0; i < ud->const_count; i++) {
		cnst = &ud->constants[i];
		dist = (ud->label_offsets[cnst->label] - cnst->code_index) - 8;
		switch (cnst->type) {
		case SUBTILIS_ARM_ENCODE_BP_LDR:
		case SUBTILIS_ARM_ENCODE_BP_LDRP:
			if (dist < 0)
				dist = -dist;
			if (dist > 4096) {
				subtilis_error_set_assertion_failed(err);
				return;
			}
			break;
		case SUBTILIS_ARM_ENCODE_BP_LDRF:
			if (dist < 0)
				dist = -dist;
			if (dist > 1024) {
				subtilis_error_set_assertion_failed(err);
				return;
			}
			dist /= 4;
			break;
		}
		code_ptr = prv_get_word_ptr(ud, cnst->code_index, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		*code_ptr |= dist;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x82632
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movl (%rax,%rdx,8), %eax
movl 0x10(%rcx), %ecx
subl %ecx, %eax
addl $-0x8, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x2, %eax
jb 0x82579
jmp 0x8256f
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x825b1
jmp 0x825f2
cmpl $0x0, -0x24(%rbp)
jge 0x82587
xorl %eax, %eax
subl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x1000, -0x24(%rbp)    # imm = 0x1000
jle 0x825af
movq -0x10(%rbp), %rdi
movl $0xf, %esi
leaq 0x2a890(%rip), %rdx     # 0xace30
movl $0x115, %ecx            # imm = 0x115
callq 0x158e0
jmp 0x82632
jmp 0x825f2
cmpl $0x0, -0x24(%rbp)
jge 0x825bf
xorl %eax, %eax
subl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x400, -0x24(%rbp)     # imm = 0x400
jle 0x825e4
movq -0x10(%rbp), %rdi
movl $0xf, %esi
leaq 0x2a858(%rip), %rdx     # 0xace30
movl $0x11d, %ecx            # imm = 0x11D
callq 0x158e0
jmp 0x82632
movl -0x24(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x82640
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x82616
jmp 0x82632
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x82518
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_get_word_ptr
static uint32_t *prv_get_word_ptr(subtilis_arm_encode_ud_t *ud, size_t index,
				  subtilis_error_t *err)
{
	if (index & 3) {
		subtilis_error_set_ass_bad_alignment(err);
		return NULL;
	}

	return (uint32_t *)&ud->code[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0x82686
movq -0x20(%rbp), %rdi
movl $0x5d, %esi
leaq 0x2a7be(%rip), %rdx     # 0xace30
movl $0xee, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x82696
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_compute_dist
static int32_t prv_compute_dist(size_t first, size_t second, size_t limit,
				subtilis_error_t *err)
{
	size_t tmp;
	int32_t mul = 1;
	size_t diff;

	if (first < second) {
		tmp = first;
		first = second;
		second = tmp;
		mul = -1;
	}

	diff = first - second;
	if (diff > limit) {
		subtilis_error_set_assertion_failed(err);
		return 0;
	}

	return (int32_t)(diff * mul);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x1, -0x34(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x826e8
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x82721
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x2a722(%rip), %rdx     # 0xace30
movl $0x91b, %ecx            # imm = 0x91B
callq 0x158e0
movl $0x0, -0x4(%rbp)
jmp 0x82730
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_link.c
// Function: subtilis_arm_link_new
subtilis_arm_link_t *subtilis_arm_link_new(size_t sections,
					   subtilis_error_t *err)
{
	size_t i;
	subtilis_arm_link_t *link = calloc(1, sizeof(*link));

	if (!link) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	link->sections = malloc(sections * sizeof(*link->sections));
	if (!link->sections) {
		free(link);
		subtilis_error_set_oom(err);
		return NULL;
	}
	link->num_sections = sections;

	for (i = 0; i < sections; i++)
		link->sections[i] = SIZE_MAX;

	return link;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x58, %esi
callq 0x12130
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x82791
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x2a6ce(%rip), %rdx     # 0xace48
movl $0x1c, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x82829
movq -0x10(%rbp), %rdi
shlq $0x3, %rdi
callq 0x121b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x827e1
movq -0x28(%rbp), %rdi
callq 0x12290
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x2a67b(%rip), %rdx     # 0xace48
movl $0x23, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x82829
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x82821
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq $-0x1, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x827f5
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_link.c
// Function: subtilis_arm_link_add
void subtilis_arm_link_add(subtilis_arm_link_t *link, size_t offset,
			   subtilis_error_t *err)
{
	size_t new_max;
	size_t *new_ext;

	if (link->num_externals == link->max_externals) {
		new_max = link->num_externals + SUBTILIS_CONFIG_PROC_GRAN;
		new_ext = realloc(link->externals, new_max * sizeof(*new_ext));
		if (!new_ext) {
			subtilis_error_set_oom(err);
			return;
		}
		link->externals = new_ext;
		link->max_externals = new_max;
	}

	link->externals[link->num_externals++] = offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x828c8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x40, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
shlq $0x3, %rsi
callq 0x121e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x828b1
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x2a5a3(%rip), %rdx     # 0xace48
movl $0x38, %ecx
callq 0x158e0
jmp 0x828ea
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_link.c
// Function: subtilis_arm_link_constant_add
void subtilis_arm_link_constant_add(subtilis_arm_link_t *link,
				    size_t code_index, size_t constant_offset,
				    size_t constant_index,
				    subtilis_error_t *err)
{
	prv_ensure_const_arr(&link->constants, link->num_constants,
			     &link->max_constants, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	link->constants[link->num_constants].index = constant_index;
	link->constants[link->num_constants].constant_offset = constant_offset;
	link->constants[link->num_constants++].code_index = code_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x8(%rbp), %rdx
addq $0x38, %rdx
movq -0x28(%rbp), %rcx
callq 0x829a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x82938
jmp 0x82999
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0x18, 0x30(%rdx), %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0x18, 0x30(%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x30(%rsi), %rdx
movq %rdx, %rdi
addq $0x1, %rdi
movq %rdi, 0x30(%rsi)
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_link.c
// Function: prv_ensure_const_arr
static void prv_ensure_const_arr(subtilis_arm_link_constant_t **arr,
				 size_t num_constants, size_t *max_constants,
				 subtilis_error_t *err)
{
	size_t new_max;
	subtilis_arm_link_constant_t *new_constants;

	if (num_constants == *max_constants) {
		new_max = num_constants + SUBTILIS_CONFIG_PROC_GRAN;
		new_constants = realloc(*arr, new_max * sizeof(**arr));
		if (!new_constants) {
			subtilis_error_set_oom(err);
			return;
		}
		*arr = new_constants;
		*max_constants = new_max;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x82a1f
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
imulq $0x18, -0x28(%rbp), %rsi
callq 0x121e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x82a09
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x2a44b(%rip), %rdx     # 0xace48
movl $0x4d, %ecx
callq 0x158e0
jmp 0x82a1f
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_link.c
// Function: subtilis_arm_link_extref_add
void subtilis_arm_link_extref_add(subtilis_arm_link_t *link, size_t code_index,
				  size_t constant_offset, size_t section_index,
				  subtilis_error_t *err)
{
	prv_ensure_const_arr(&link->extrefs, link->num_extrefs,
			     &link->max_extrefs, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	link->extrefs[link->num_extrefs].index = section_index;
	link->extrefs[link->num_extrefs].constant_offset = constant_offset;
	link->extrefs[link->num_extrefs++].code_index = code_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rsi
movq -0x8(%rbp), %rdx
addq $0x50, %rdx
movq -0x28(%rbp), %rcx
callq 0x829a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x82a78
jmp 0x82ad9
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0x18, 0x48(%rdx), %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0x18, 0x48(%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x48(%rsi), %rdx
movq %rdx, %rdi
addq $0x1, %rdi
movq %rdi, 0x48(%rsi)
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_link.c
// Function: prv_get_word_ptr
static uint32_t *prv_get_word_ptr(uint8_t *buf, size_t index,
				  subtilis_error_t *err)
{
	if (index & 3) {
		subtilis_error_set_ass_bad_alignment(err);
		return NULL;
	}

	return (uint32_t *)&buf[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0x82e86
movq -0x20(%rbp), %rdi
movl $0x5d, %esi
leaq 0x29fd6(%rip), %rdx     # 0xace48
movl $0x7a, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x82e92
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_link.c
// Function: subtilis_arm_link_delete
void subtilis_arm_link_delete(subtilis_arm_link_t *link)
{
	if (!link)
		return;

	free(link->extrefs);
	free(link->constants);
	free(link->externals);
	free(link->sections);
	free(link);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x82eb5
jmp 0x82ef1
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rdi
callq 0x12290
addq $0x10, %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_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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x7, %eax
ja 0x84751
movq -0x20(%rbp), %rax
leaq 0x287f1(%rip), %rcx     # 0xace68
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x28b22(%rip), %rdi     # 0xad1b0
movb $0x0, %al
callq 0x120f0
jmp 0x8476b
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %esi
leaq 0x28b12(%rip), %rdi     # 0xad1bb
movb $0x0, %al
callq 0x120f0
jmp 0x8476b
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %esi
leaq 0x28b01(%rip), %rdi     # 0xad1c5
movb $0x0, %al
callq 0x120f0
jmp 0x8476b
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x28af1(%rip), %rdi     # 0xad1cf
movb $0x0, %al
callq 0x120f0
jmp 0x8476b
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq 0x28adf(%rip), %rdi     # 0xad1d9
movb $0x1, %al
callq 0x120f0
jmp 0x8476b
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq 0x28ad2(%rip), %rdi     # 0xad1e5
movb $0x1, %al
callq 0x120f0
jmp 0x8476b
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x28ac2(%rip), %rdi     # 0xad1f2
movb $0x1, %al
callq 0x120f0
jmp 0x8476b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x28ab4(%rip), %rdi     # 0xad1fc
movb $0x0, %al
callq 0x120f0
jmp 0x8476b
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x28aa7(%rip), %rdx     # 0xad208
movl $0x2b9, %ecx            # imm = 0x2B9
callq 0x158e0
addq $0x20, %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_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 %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 0x4afb9(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x266e4(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x847e3
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4b4ef(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x266bb(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x847fb
leaq 0x25776(%rip), %rdi     # 0xa9f6a
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x28a0c(%rip), %rdi     # 0xad21e
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x86d50
leaq 0x26646(%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_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
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 0x4aef9(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x26624(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x848a3
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4b42f(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x265fb(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x848bb
leaq 0x256b6(%rip), %rdi     # 0xa9f6a
movb $0x0, %al
callq 0x120f0
cmpl $0x11, -0x14(%rbp)
jne 0x848f1
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 0x28cda(%rip), %rdi     # 0xad5c2
movb $0x0, %al
callq 0x120f0
jmp 0x84917
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 0x28cb8(%rip), %rdi     # 0xad5c8
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_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
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 0x4ae19(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x26544(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x84983
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4b34f(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x2651b(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpq $0xf, 0x8(%rax)
jne 0x849a2
cmpl $0x9, -0x14(%rbp)
jne 0x849a2
leaq 0x25819(%rip), %rdi     # 0xaa1b4
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x28873(%rip), %rdi     # 0xad224
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x86d50
leaq 0x264a7(%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_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 %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 0x4ad59(%rip), %rax     # 0xcf760
movq (%rax,%rcx,8), %rsi
leaq 0x26484(%rip), %rdi     # 0xaae96
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0x84a43
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4b28f(%rip), %rax     # 0xcfcc0
movq (%rax,%rcx,8), %rsi
leaq 0x2645b(%rip), %rdi     # 0xaae97
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x84a5b
leaq 0x25516(%rip), %rdi     # 0xa9f6a
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x287ba(%rip), %rdi     # 0xad224
movb $0x0, %al
callq 0x120f0
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x86d50
leaq 0x263ee(%rip), %rdi     # 0xaae73
movb $0x0, %al
callq 0x120f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)