LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_int_dist.c
// Function: prv_used_vfp_cptran_instr
static void prv_used_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_dist_data_t *ud = user_data;

	if ((type != SUBTILIS_VFP_INSTR_FMSR) && (instr->dest == ud->reg_num)) {
		ud->last_used = -1;
		subtilis_error_set_walker_failed(err);
		return;
	}

	ud->last_used++;
}

// 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)
cmpl $0x5d, -0x14(%rbp)
je 0x7d631
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x7d631
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0x2f589(%rip), %rdx     # 0xacbae
movl $0x349, %ecx            # imm = 0x349
callq 0x158e0
jmp 0x7d63e
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_int_dist.c
// Function: prv_used_vfp_sysreg_instr
static void prv_used_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)
{
	subtilis_dist_data_t *ud = user_data;

	if (type == SUBTILIS_VFP_INSTR_FMRX) {
		if (instr->arm_reg == ud->reg_num) {
			ud->last_used = -1;
			subtilis_error_set_walker_failed(err);
			return;
		}
	}

	ud->last_used++;
}

// 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)
cmpl $0x7c, -0x14(%rbp)
jne 0x7d6b3
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x7d6b1
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0x2f509(%rip), %rdx     # 0xacbae
movl $0x35a, %ecx            # imm = 0x35A
callq 0x158e0
jmp 0x7d6c0
jmp 0x7d6b3
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_int_dist.c
// Function: prv_used_signx_instr
static void prv_used_signx_instr(void *user_data, subtilis_arm_op_t *op,
				 subtilis_arm_instr_type_t type,
				 subtilis_arm_signx_instr_t *instr,
				 subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	if (instr->dest == ud->reg_num) {
		ud->last_used = -1;
		subtilis_error_set_walker_failed(err);
		return;
	}

	ud->last_used++;
}

// 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
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x7d72b
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl $0x1f, %esi
leaq 0x2f48f(%rip), %rdx     # 0xacbae
movl $0x36b, %ecx            # imm = 0x36B
callq 0x158e0
jmp 0x7d738
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_int_dist.c
// Function: prv_dist_handle_op2
static void prv_dist_handle_op2(subtilis_dist_data_t *ud,
				subtilis_arm_op2_t *op2, subtilis_error_t *err)
{
	if (op2->type == SUBTILIS_ARM_OP2_REG) {
		if (op2->op.reg == ud->reg_num) {
			subtilis_error_set_walker_failed(err);
			return;
		}
	} else if (op2->type == SUBTILIS_ARM_OP2_SHIFTED) {
		if (op2->op.shift.reg == ud->reg_num) {
			subtilis_error_set_walker_failed(err);
			return;
		}

		if (op2->op.shift.shift_reg &&
		    op2->op.shift.shift.reg == ud->reg_num) {
			subtilis_error_set_walker_failed(err);
			return;
		}
	}
}

// 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
cmpl $0x0, (%rax)
jne 0x7d78c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x7d78a
movq -0x18(%rbp), %rdi
movl $0x1f, %esi
leaq 0x2f430(%rip), %rdx     # 0xacbae
movl $0x19, %ecx
callq 0x158e0
jmp 0x7d7fd
jmp 0x7d7fd
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x7d7fb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x7d7c2
movq -0x18(%rbp), %rdi
movl $0x1f, %esi
leaq 0x2f3f8(%rip), %rdx     # 0xacbae
movl $0x1e, %ecx
callq 0x158e0
jmp 0x7d7fd
movq -0x10(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x7d7f9
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x7d7f9
movq -0x18(%rbp), %rdi
movl $0x1f, %esi
leaq 0x2f3c1(%rip), %rdx     # 0xacbae
movl $0x24, %ecx
callq 0x158e0
jmp 0x7d7fd
jmp 0x7d7fb
jmp 0x7d7fd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: subtilis_arm_encode
void subtilis_arm_encode(subtilis_arm_prog_t *arm_p, const char *fname,
			 subtilis_arm_encode_plat_t plat, subtilis_error_t *err)
{
	subtilis_arm_encode_ud_t ud;

	prv_init_encode_ud(&ud, arm_p, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	prv_encode_prog(arm_p, &ud, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	if (plat) {
		plat(ud.code, ud.bytes_written, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	prv_write_file(&ud, fname, err);

cleanup:

	prv_free_encode_ud(&ud);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0xb8(%rbp), %rdi
callq 0x7d8c0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7d84a
jmp 0x7d8a9
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0xb8(%rbp), %rsi
callq 0x7da90
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7d869
jmp 0x7d8a9
cmpq $0x0, -0x18(%rbp)
je 0x7d895
movq -0x18(%rbp), %rax
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7d893
jmp 0x7d8a9
jmp 0x7d895
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0xb8(%rbp), %rdi
callq 0x7dcb0
leaq -0xb8(%rbp), %rdi
callq 0x7dd90
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_write_file
static void prv_write_file(subtilis_arm_encode_ud_t *ud, const char *fname,
			   subtilis_error_t *err)
{
	FILE *fp;

	fp = fopen(fname, "w");
	if (!fp) {
		subtilis_error_set_file_open(err, fname);
		return;
	}

	if (fwrite(ud->code, 1, ud->bytes_written, fp) < ud->bytes_written) {
		subtilis_error_set_file_write(err);
		goto fail;
	}

	if (fclose(fp) != 0)
		subtilis_error_set_file_close(err);

	return;

fail:

	(void)fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x313f3(%rip), %rsi     # 0xaf0c2
callq 0x12210
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7dd03
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x2, %esi
leaq 0x2f13d(%rip), %rcx     # 0xace30
movl $0x20a, %r8d            # imm = 0x20A
callq 0x15990
jmp 0x7dd8a
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x12260
movq -0x8(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x7dd4f
movq -0x18(%rbp), %rdi
movl $0x4, %esi
leaq 0x2d53b(%rip), %rdx     # 0xab276
leaq 0x2f0ee(%rip), %rcx     # 0xace30
movl $0x20f, %r8d            # imm = 0x20F
callq 0x15990
jmp 0x7dd81
movq -0x20(%rbp), %rdi
callq 0x120c0
cmpl $0x0, %eax
je 0x7dd7f
movq -0x18(%rbp), %rdi
movl $0x5, %esi
leaq 0x2d509(%rip), %rdx     # 0xab276
leaq 0x2f0bc(%rip), %rcx     # 0xace30
movl $0x214, %r8d            # imm = 0x214
callq 0x15990
jmp 0x7dd8a
movq -0x20(%rbp), %rdi
callq 0x120c0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_free_encode_ud
static void prv_free_encode_ud(subtilis_arm_encode_ud_t *ud)
{
	subtilis_arm_link_delete(ud->link);
	free(ud->back_patches);
	free(ud->constants);
	free(ud->code);
	free(ud->label_offsets);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x82ea0
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x12290
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 0x10(%rax), %rdi
callq 0x12290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: subtilis_arm_encode_buf
uint8_t *subtilis_arm_encode_buf(subtilis_arm_prog_t *arm_p,
				 size_t *bytes_written, subtilis_error_t *err)
{
	subtilis_arm_encode_ud_t ud;
	uint8_t *retval = NULL;

	prv_init_encode_ud(&ud, arm_p, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	prv_encode_prog(arm_p, &ud, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	*bytes_written = ud.bytes_written;
	retval = ud.code;
	ud.code = NULL;

cleanup:

	prv_free_encode_ud(&ud);

	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0xb8(%rbp)
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0xb0(%rbp), %rdi
callq 0x7d8c0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7de31
jmp 0x7de74
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0xb0(%rbp), %rsi
callq 0x7da90
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7de50
jmp 0x7de74
movq -0x80(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x88(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq $0x0, -0x88(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x7dd90
movq -0xb8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_reset_encode_ud
static void prv_reset_encode_ud(subtilis_arm_encode_ud_t *ud,
				subtilis_arm_section_t *arm_s)
{
	ud->arm_s = arm_s;
	ud->max_labels = arm_s->label_counter;
	ud->back_patch_count = 0;
	prv_reset_pool_state(ud);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x8(%rbp), %rdi
callq 0x7e390
addq $0x10, %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_ensure_code_size
static void prv_ensure_code_size(subtilis_arm_encode_ud_t *ud, size_t bytes,
				 subtilis_error_t *err)
{
	size_t new_max_bytes;
	uint8_t *new_code;

	if (ud->bytes_written + bytes < ud->max_bytes)
		return;

	if (bytes < SUBTILIS_ENCODER_CODE_GRAN)
		new_max_bytes = SUBTILIS_ENCODER_CODE_GRAN + ud->max_bytes;
	else
		new_max_bytes = bytes + ud->max_bytes;
	new_code = realloc(ud->code, new_max_bytes);
	if (!new_code) {
		subtilis_error_set_oom(err);
		return;
	}

	ud->max_bytes = new_max_bytes;
	ud->code = new_code;
}

// 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 0x30(%rax), %rax
addq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x7e17c
jmp 0x7e1fa
cmpq $0x1000, -0x10(%rbp)    # imm = 0x1000
jae 0x7e19a
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x20(%rbp)
jmp 0x7e1aa
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
addq 0x38(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x121e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7e1e2
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x2ec5a(%rip), %rdx     # 0xace30
movl $0xc2, %ecx
callq 0x158e0
jmp 0x7e1fa
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_copy_constant_to_buf
static void prv_copy_constant_to_buf(subtilis_arm_prog_t *arm_p,
				     subtilis_arm_encode_ud_t *ud,
				     subtilis_constant_data_t *data,
				     subtilis_error_t *err)
{
	size_t i;
	uint32_t *word;
	uint32_t *ptr;
	size_t null_bytes_needed;
	uint8_t *bptr;

	if (data->dbl && arm_p->fp_if && arm_p->fp_if->reverse_fpa_consts) {
		ptr = prv_get_word_ptr(ud, ud->bytes_written, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		for (i = 0; i < data->data_size / sizeof(double); i++) {
			word = (uint32_t *)&data->data[i * sizeof(double)];
			*ptr++ = word[1];
			*ptr++ = word[0];
		}
	} else {
		memcpy(&ud->code[ud->bytes_written], data->data,
		       data->data_size);
		if (data->data_size & 3) {
			null_bytes_needed = 4 - (data->data_size & 3);
			bptr = &ud->code[ud->bytes_written] + data->data_size;
			for (i = 0; i < null_bytes_needed; i++)
				*bptr++ = 0;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x7e2e3
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x7e2e3
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
testb $0x1, 0xc(%rax)
je 0x7e2e3
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x82640
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7e26e
jmp 0x7e380
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x3, %rcx
cmpq %rcx, %rax
jae 0x7e2de
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x38(%rbp)
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl (%rax), %ecx
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x38(%rbp)
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7e276
jmp 0x7e380
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
addq 0x30(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
callq 0x12190
movq -0x18(%rbp), %rax
movq (%rax), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0x7e37e
movq -0x18(%rbp), %rax
movq (%rax), %rcx
andq $0x3, %rcx
movl $0x4, %eax
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x30(%rcx), %rax
movq -0x18(%rbp), %rcx
addq (%rcx), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x7e37c
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x48(%rbp)
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7e352
jmp 0x7e37e
jmp 0x7e380
addq $0x50, %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_reset_pool_state
static void prv_reset_pool_state(subtilis_arm_encode_ud_t *ud)
{
	ud->const_count = 0;
	ud->int_const_count = 0;
	ud->real_const_count = 0;
	ud->ldrc_real = SIZE_MAX;
	ud->ldrc_int = SIZE_MAX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x8(%rbp), %rax
movq $-0x1, 0x88(%rax)
movq -0x8(%rbp), %rax
movq $-0x1, 0x90(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_encode_label
static void prv_encode_label(void *user_data, subtilis_arm_op_t *op,
			     size_t label, subtilis_error_t *err)
{
	subtilis_arm_encode_ud_t *ud = user_data;
	size_t new_max_label_offsets;
	size_t *new_label_offsets;

	if (label > ud->max_labels) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	if ((label == ud->max_labels) && (label >= ud->max_label_offsets)) {
		new_max_label_offsets = label + SUBTILIS_ENCODER_BACKPATCH_GRAN;
		new_label_offsets = realloc(
		    ud->label_offsets, sizeof(size_t) * new_max_label_offsets);
		if (!new_label_offsets) {
			subtilis_error_set_oom(err);
			return;
		}
		ud->label_offsets = new_label_offsets;
		ud->max_label_offsets = new_max_label_offsets;
	}

	ud->label_offsets[label] = ud->bytes_written;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jbe 0x7e42d
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x2ea12(%rip), %rdx     # 0xace30
movl $0xd7, %ecx
callq 0x158e0
jmp 0x7e4c3
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x7e4ab
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x7e4ab
movq -0x18(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x30(%rbp), %rsi
shlq $0x3, %rsi
callq 0x121e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x7e493
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x2e9a9(%rip), %rdx     # 0xace30
movl $0xe0, %ecx
callq 0x158e0
jmp 0x7e4c3
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
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_encode_data_instr
static void prv_encode_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)
{
	subtilis_arm_encode_ud_t *ud = user_data;
	uint32_t word = 0;

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

	if ((instr->dest > 15) || (instr->op1 > 15)) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	word |= instr->ccode << 28;
	word |= type << 21;
	if (instr->status)
		word |= 1 << 20;
	word |= instr->op1 << 16;
	word |= instr->dest << 12;
	prv_encode_data_op2(&instr->op2, &word, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	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, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x819a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7e885
jmp 0x7e95c
movq -0x20(%rbp), %rax
cmpq $0xf, 0x8(%rax)
ja 0x7e89b
movq -0x20(%rbp), %rax
cmpq $0xf, 0x10(%rax)
jbe 0x7e8ba
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x2e585(%rip), %rdx     # 0xace30
movl $0x263, %ecx            # imm = 0x263
callq 0x158e0
jmp 0x7e95c
movq -0x20(%rbp), %rax
movl (%rax), %eax
shll $0x1c, %eax
orl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %eax
shll $0x15, %eax
orl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x7e8ea
movl -0x34(%rbp), %eax
orl $0x100000, %eax         # imm = 0x100000
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
shlq $0x10, %rcx
movl -0x34(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
shlq $0xc, %rcx
movl -0x34(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movq -0x28(%rbp), %rdx
leaq -0x34(%rbp), %rsi
callq 0x819d0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7e934
jmp 0x7e95c
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x81b90
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7e94c
jmp 0x7e95c
movq -0x30(%rbp), %rdi
movl -0x34(%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_mul_instr
static void prv_encode_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)
{
	subtilis_arm_encode_ud_t *ud = user_data;
	uint32_t word = 0x90;

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

	if ((instr->dest > 15) || (instr->rm > 15) || (instr->rs > 15)) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	if (type == SUBTILIS_ARM_INSTR_MLA) {
		word |= 1 << 21;
		word |= instr->rn << 12;
	}

	word |= instr->ccode << 28;
	if (instr->status)
		word |= 1 << 20;
	word |= instr->dest << 16;
	word |= instr->rs << 8;
	word |= instr->rm;

	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, -0x30(%rbp)
movl $0x90, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x819a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7e9b5
jmp 0x7eaa2
movq -0x20(%rbp), %rax
cmpq $0xf, 0x8(%rax)
ja 0x7e9d6
movq -0x20(%rbp), %rax
cmpq $0xf, 0x10(%rax)
ja 0x7e9d6
movq -0x20(%rbp), %rax
cmpq $0xf, 0x18(%rax)
jbe 0x7e9f5
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x2e44a(%rip), %rdx     # 0xace30
movl $0x285, %ecx            # imm = 0x285
callq 0x158e0
jmp 0x7eaa2
cmpl $0x11, -0x14(%rbp)
jne 0x7ea1b
movl -0x34(%rbp), %eax
orl $0x200000, %eax         # imm = 0x200000
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
shlq $0xc, %rcx
movl -0x34(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
shll $0x1c, %eax
orl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x7ea3f
movl -0x34(%rbp), %eax
orl $0x100000, %eax         # imm = 0x100000
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
shlq $0x10, %rcx
movl -0x34(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
shlq $0x8, %rcx
movl -0x34(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movl -0x34(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x81b90
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7ea92
jmp 0x7eaa2
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x81bc0
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_cmp_instr
static void prv_encode_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)
{
	subtilis_arm_encode_ud_t *ud = user_data;

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

	prv_encode_data_instr(user_data, op, type, instr, err);
}

// 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 -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x819a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7eaeb
jmp 0x7eb03
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x7e840
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_encode_br_instr
static void prv_encode_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_encode_ud_t *ud = user_data;
	uint32_t word = 0;

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

	word |= instr->ccode << 28;
	if (instr->indirect) {
		/*
		 * We're going to do a mov pc, reg.  There's no need to do
		 * any linking stuff as the address is computed at runtime.
		 */

		word |= SUBTILIS_ARM_INSTR_MOV << 21;
		word |= 15 << 12;
		word |= instr->target.reg & 0xf;
	} else {
		word |= 0x5 << 25;
		if (instr->link)
			word |= 1 << 24;
		if (instr->link && !instr->local) {
			subtilis_arm_link_add(ud->link, ud->bytes_written, err);
			word |= instr->target.label;
		} else {
			prv_add_back_patch(
			    ud, SUBTILIS_ARM_ENCODE_BP_TYPE_BRANCH,
			    instr->target.label, ud->bytes_written, err);
		}
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

	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, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x819a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7ef35
jmp 0x7f035
movq -0x20(%rbp), %rax
movl (%rax), %eax
shll $0x1c, %eax
orl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x6(%rax)
je 0x7ef7e
movl -0x34(%rbp), %eax
orl $0x1a00000, %eax        # imm = 0x1A00000
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
orl $0xf000, %eax           # imm = 0xF000
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
andq $0xf, %rcx
movl -0x34(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x34(%rbp)
jmp 0x7f00d
movl -0x34(%rbp), %eax
orl $0xa000000, %eax        # imm = 0xA000000
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x7ef9e
movl -0x34(%rbp), %eax
orl $0x1000000, %eax        # imm = 0x1000000
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x7efe1
movq -0x20(%rbp), %rax
testb $0x1, 0x5(%rax)
jne 0x7efe1
movq -0x30(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x82840
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movl -0x34(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x34(%rbp)
jmp 0x7f000
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x28(%rbp), %r8
xorl %esi, %esi
callq 0x81dd0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7f00b
jmp 0x7f035
jmp 0x7f00d
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x81b90
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7f025
jmp 0x7f035
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x81bc0
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_swi_instr
static void prv_encode_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)
{
	subtilis_arm_encode_ud_t *ud = user_data;
	uint32_t word = 0;

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

	word |= instr->ccode << 28;
	word |= 0xf << 24;
	word |= 0x0fffffff & instr->code;

	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, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x819a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7f082
jmp 0x7f0dc
movq -0x20(%rbp), %rax
movl (%rax), %eax
shll $0x1c, %eax
orl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
orl $0xf000000, %eax        # imm = 0xF000000
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0xfffffff, %rcx        # imm = 0xFFFFFFF
movl -0x34(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x81b90
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7f0cc
jmp 0x7f0dc
movq -0x30(%rbp), %rdi
movl -0x34(%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_ldrp_instr
static void prv_encode_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)
{
	subtilis_arm_encode_ud_t *ud = user_data;
	subtilis_arm_stran_instr_t stran;

	/*
	 * We need to make sure we have enough room for one PC relative load and
	 * an add and the constant.
	 */

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

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

	ud->constants[ud->const_count - 1].section_label = instr->section_label;

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

	stran.ccode = instr->ccode;
	stran.dest = instr->dest;
	stran.base = 15;
	stran.offset.type = SUBTILIS_ARM_OP2_I32;
	stran.offset.op.integer = 0;
	stran.pre_indexed = true;
	stran.write_back = false;
	stran.subtract = false;
	stran.byte = false;
	prv_encode_stran_instr(user_data, op, SUBTILIS_ARM_INSTR_LDR, &stran,
			       err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %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 -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0xc, %esi
callq 0x81c40
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7f246
jmp 0x7f313
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x28(%rbp), %r8
movl $0x1, %ecx
callq 0x82080
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7f276
jmp 0x7f313
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x30(%rbp), %rdx
movq 0x48(%rdx), %rdx
subq $0x1, %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
cmpq $-0x1, 0x90(%rax)
jne 0x7f2be
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
movq $0xf, -0x68(%rbp)
movl $0x1, -0x60(%rbp)
movl $0x0, -0x58(%rbp)
movb $0x1, -0x38(%rbp)
movb $0x0, -0x37(%rbp)
movb $0x0, -0x36(%rbp)
movb $0x0, -0x35(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %r8
movl $0x12, %edx
leaq -0x78(%rbp), %rcx
callq 0x7eb70
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_encode_adr_instr
static void prv_encode_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)
{
	subtilis_arm_data_instr_t data;
	subtilis_arm_encode_ud_t *ud = user_data;

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

	data.ccode = instr->ccode;
	data.status = false;
	data.dest = instr->dest;
	data.op1 = 15;
	data.op2.type = SUBTILIS_ARM_OP2_I32;
	data.op2.op.integer = 0;

	prv_encode_data_instr(user_data, op, SUBTILIS_ARM_INSTR_ADD, &data,
			      err);
}

// 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)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x70(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x28(%rbp), %r8
movl $0x1, %esi
callq 0x81dd0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7f370
jmp 0x7f3b9
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x68(%rbp)
movb $0x0, -0x64(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
movq $0xf, -0x58(%rbp)
movl $0x1, -0x50(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %r8
movl $0x4, %edx
leaq -0x68(%rbp), %rcx
callq 0x7e840
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_encode_flags_instr
static void prv_encode_flags_instr(void *user_data, subtilis_arm_op_t *op,
				   subtilis_arm_instr_type_t type,
				   subtilis_arm_flags_instr_t *instr,
				   subtilis_error_t *err)
{
	subtilis_arm_encode_ud_t *ud = user_data;
	uint32_t word;

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

	if (type == SUBTILIS_ARM_INSTR_MRS) {
		word = 0x01000000;
		word |= (instr->op.reg & 0xf) << 12;
	} else {
		word = 0x01200000;
		if (instr->op2_reg) {
			word |= instr->op.reg & 0xf;
		} else {
			word |= 1 << 25;
			word |= (instr->op.integer & 0xfff);
		}
		word |= instr->fields;
	}

	if (instr->flag_reg == SUBTILIS_ARM_FLAGS_SPSR)
		word |= 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, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x819a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7f57e
jmp 0x7f644
cmpl $0x1d, -0x14(%rbp)
jne 0x7f5a6
movl $0x1000000, -0x34(%rbp) # imm = 0x1000000
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
andq $0xf, %rcx
shlq $0xc, %rcx
movl -0x34(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x34(%rbp)
jmp 0x7f5f8
movl $0x1200000, -0x34(%rbp) # imm = 0x1200000
movq -0x20(%rbp), %rax
testb $0x1, 0xc(%rax)
je 0x7f5ce
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
andq $0xf, %rcx
movl -0x34(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x34(%rbp)
jmp 0x7f5eb
movl -0x34(%rbp), %eax
orl $0x2000000, %eax        # imm = 0x2000000
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
andl $0xfff, %eax            # imm = 0xFFF
orl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
orl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x7f60d
movl -0x34(%rbp), %eax
orl $0x400000, %eax         # imm = 0x400000
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
shll $0x1c, %eax
orl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x81b90
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7f634
jmp 0x7f644
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x81bc0
addq $0x40, %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_fpa_data_dyadic_instr
static void prv_encode_fpa_data_dyadic_instr(void *user_data,
					     subtilis_arm_op_t *op,
					     subtilis_arm_instr_type_t type,
					     subtilis_fpa_data_instr_t *instr,
					     subtilis_error_t *err)
{
	subtilis_arm_encode_ud_t *ud = user_data;

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

	prv_encode_fpa_data_instr(user_data, op, type, instr, true, err);
}

// 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 -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x819a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7f6eb
jmp 0x7f709
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r9
movl $0x1, %r8d
callq 0x82190
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_encode_fpa_stran_instr
static void prv_encode_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)
{
	subtilis_arm_encode_ud_t *ud = user_data;
	uint32_t word = 0;

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

	word |= instr->ccode << 28;
	word |= (0xC | (instr->pre_indexed ? 1 : 0)) << 24;
	if (!instr->subtract)
		word |= 1 << 23;

	if (instr->size == 8)
		word |= 1 << 15;
	else if (instr->size == 12)
		word |= 1 << 22;

	if (instr->write_back)
		word |= 1 << 21;

	if (type == SUBTILIS_FPA_INSTR_LDF)
		word |= 1 << 20;

	word |= instr->base << 16;
	word |= instr->dest << 12;
	word |= 1 << 8;
	word |= instr->offset;

	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, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x819a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7f755
jmp 0x7f85a
movq -0x20(%rbp), %rax
movl (%rax), %eax
shll $0x1c, %eax
orl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movb 0x21(%rax), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
orl $0xc, %eax
shll $0x18, %eax
orl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x23(%rax)
jne 0x7f799
movl -0x34(%rbp), %eax
orl $0x800000, %eax         # imm = 0x800000
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x8, 0x8(%rax)
jne 0x7f7b1
movl -0x34(%rbp), %eax
orl $0x8000, %eax           # imm = 0x8000
movl %eax, -0x34(%rbp)
jmp 0x7f7c9
movq -0x20(%rbp), %rax
cmpq $0xc, 0x8(%rax)
jne 0x7f7c7
movl -0x34(%rbp), %eax
orl $0x400000, %eax         # imm = 0x400000
movl %eax, -0x34(%rbp)
jmp 0x7f7c9
movq -0x20(%rbp), %rax
testb $0x1, 0x22(%rax)
je 0x7f7de
movl -0x34(%rbp), %eax
orl $0x200000, %eax         # imm = 0x200000
movl %eax, -0x34(%rbp)
cmpl $0x1e, -0x14(%rbp)
jne 0x7f7ef
movl -0x34(%rbp), %eax
orl $0x100000, %eax         # imm = 0x100000
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
shlq $0x10, %rcx
movl -0x34(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
shlq $0xc, %rcx
movl -0x34(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x20(%rax), %eax
orl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x81b90
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7f84a
jmp 0x7f85a
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x81bc0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_encode.c
// Function: prv_encode_fpa_ldrc_instr
static void prv_encode_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)
{
	subtilis_fpa_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.size = instr->size;
	stran.dest = instr->dest;
	stran.base = 15;
	stran.offset = 0;
	stran.pre_indexed = true;
	stran.write_back = false;
	stran.subtract = false;
	prv_encode_fpa_stran_instr(user_data, op, SUBTILIS_FPA_INSTR_LDF,
				   &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, -0x58(%rbp)
movq $0xc, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x81c40
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7fbba
jmp 0x7fc5b
movq -0x58(%rbp), %rax
cmpq $-0x1, 0x88(%rax)
jne 0x7fbdb
movq -0x58(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x58(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x28(%rbp), %r8
movl $0x2, %ecx
callq 0x82080
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7fc08
jmp 0x7fc5b
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -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 $0x1e, %edx
leaq -0x50(%rbp), %rcx
callq 0x7f710
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_fpa_cptran_instr
static void prv_encode_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)
{
	subtilis_arm_encode_ud_t *ud = user_data;
	uint32_t word = 0;

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

	word |= instr->ccode << 28;
	word |= 0xE << 24;
	if (type == SUBTILIS_FPA_INSTR_WFS)
		word |= 2 << 20;
	else
		word |= 3 << 20;
	word |= instr->dest << 12;
	word |= (1 << 8 | 1 << 4);

	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, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x819a0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7fcb5
jmp 0x7fd35
movq -0x20(%rbp), %rax
movl (%rax), %eax
shll $0x1c, %eax
orl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
orl $0xe000000, %eax        # imm = 0xE000000
movl %eax, -0x34(%rbp)
cmpl $0x44, -0x14(%rbp)
jne 0x7fce2
movl -0x34(%rbp), %eax
orl $0x200000, %eax         # imm = 0x200000
movl %eax, -0x34(%rbp)
jmp 0x7fced
movl -0x34(%rbp), %eax
orl $0x300000, %eax         # imm = 0x300000
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
shlq $0xc, %rcx
movl -0x34(%rbp), %eax
orq %rcx, %rax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
orl $0x110, %eax            # imm = 0x110
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x81b90
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7fd25
jmp 0x7fd35
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x81bc0
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_vfp_copy_instr
static void prv_encode_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)
{
	uint32_t word;
	bool float32 = false;
	subtilis_arm_encode_ud_t *ud = user_data;

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

	switch (type) {
	case SUBTILIS_VFP_INSTR_FCPYS:
		word = 0xeb00a40;
		float32 = true;
		break;
	case SUBTILIS_VFP_INSTR_FCPYD:
		word = 0xeb00b40;
		break;
	case SUBTILIS_VFP_INSTR_FNEGS:
		word = 0xeb10a40;
		float32 = true;
		break;
	case SUBTILIS_VFP_INSTR_FNEGD:
		word = 0xeb10b40;
		break;
	case SUBTILIS_VFP_INSTR_FABSS:
		word = 0xeb00ac0;
		float32 = true;
		break;
	case SUBTILIS_VFP_INSTR_FABSD:
		word = 0xeb00bc0;
		break;
	default:
		subtilis_error_set_assertion_failed(err);
		return;
	}

	word |= instr->ccode << 28;
	word |= prv_encode_src_dest(instr->src, instr->dest, float32, float32);

	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)
movb $0x0, -0x2d(%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 0x7fee2
jmp 0x7ffc8
movl -0x14(%rbp), %eax
addl $-0x4a, %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x5, %eax
ja 0x7ff49
movq -0x40(%rbp), %rax
leaq 0x2cd32(%rip), %rcx     # 0xacc30
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xeb00a40, -0x2c(%rbp) # imm = 0xEB00A40
movb $0x1, -0x2d(%rbp)
jmp 0x7ff65
movl $0xeb00b40, -0x2c(%rbp) # imm = 0xEB00B40
jmp 0x7ff65
movl $0xeb10a40, -0x2c(%rbp) # imm = 0xEB10A40
movb $0x1, -0x2d(%rbp)
jmp 0x7ff65
movl $0xeb10b40, -0x2c(%rbp) # imm = 0xEB10B40
jmp 0x7ff65
movl $0xeb00ac0, -0x2c(%rbp) # imm = 0xEB00AC0
movb $0x1, -0x2d(%rbp)
jmp 0x7ff65
movl $0xeb00bc0, -0x2c(%rbp) # imm = 0xEB00BC0
jmp 0x7ff65
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x2ced7(%rip), %rdx     # 0xace30
movl $0x641, %ecx            # imm = 0x641
callq 0x158e0
jmp 0x7ffc8
movq -0x20(%rbp), %rax
movl (%rax), %eax
shll $0x1c, %eax
orl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movb -0x2d(%rbp), %cl
movb -0x2d(%rbp), %al
andb $0x1, %cl
andb $0x1, %al
movzbl %cl, %edx
movzbl %al, %ecx
callq 0x82440
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 0x7ffb8
jmp 0x7ffc8
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x81bc0
addq $0x40, %rsp
popq %rbp
retq
nop