LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: subtilis_riscos_arm_i32_to_dec
void subtilis_riscos_arm_i32_to_dec(subtilis_ir_section_t *s, size_t start,
				    void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t buffer;
	subtilis_arm_reg_t val;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *to_deci = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_arm_reg(to_deci->operands[0].reg);
	val = subtilis_arm_ir_to_arm_reg(to_deci->operands[1].reg);
	buffer = subtilis_arm_ir_to_arm_reg(to_deci->operands[2].reg);

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, 0, val,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, 1, buffer,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, 2, 12,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	/* OS_ConvertInteger4 */
	/* read_mask = 0x7 = r0, r1, r2 */
	/* write_mask = 0x7 = r0, r1, r2 */
	subtilis_arm_add_swi(arm_s, SUBTILIS_ARM_CCODE_AL, 0xdc, 0x7, 0x7, err);

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

	subtilis_arm_add_data_imm(arm_s, SUBTILIS_ARM_INSTR_RSB,
				  SUBTILIS_ARM_CCODE_AL, false, dest, 2, 12,
				  err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rax, (%rsp)
callq 0x71fa0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa652d
jmp 0xa65f8
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
movq %rax, (%rsp)
callq 0x71fa0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa6562
jmp 0xa65f8
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xf, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
movl $0x2, %r9d
movl $0xc, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71b10
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa659e
jmp 0xa65f8
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %r9
movl $0xe, %esi
movl $0xdc, %edx
movl $0x7, %r8d
movl %r8d, %ecx
callq 0x71f20
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa65c9
jmp 0xa65f8
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x20(%rbp), %rax
movl $0x3, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movl $0x2, %r9d
movl $0xc, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71cd0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: subtilis_riscos_arm_i32_to_hex
void subtilis_riscos_arm_i32_to_hex(subtilis_ir_section_t *s, size_t start,
				    void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t buffer;
	subtilis_arm_reg_t val;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *to_hexi = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_arm_reg(to_hexi->operands[0].reg);
	val = subtilis_arm_ir_to_arm_reg(to_hexi->operands[1].reg);
	buffer = subtilis_arm_ir_to_arm_reg(to_hexi->operands[2].reg);

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, 0, val,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, 1, buffer,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, 2, 11,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	/* OS_ConvertHex8 */
	/* read_mask = 0x7 = r0, r1, r2 */
	/* write_mask = 0x7 = r0, r1, r2 */
	subtilis_arm_add_swi(arm_s, SUBTILIS_ARM_CCODE_AL, 0xd4, 0x7, 0x7, err);

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

	subtilis_arm_add_data_imm(arm_s, SUBTILIS_ARM_INSTR_RSB,
				  SUBTILIS_ARM_CCODE_AL, false, dest, 2, 11,
				  err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rax, (%rsp)
callq 0x71fa0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa669d
jmp 0xa6768
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
movq %rax, (%rsp)
callq 0x71fa0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa66d2
jmp 0xa6768
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xf, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
movl $0x2, %r9d
movl $0xb, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71b10
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa670e
jmp 0xa6768
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %r9
movl $0xe, %esi
movl $0xd4, %edx
movl $0x7, %r8d
movl %r8d, %ecx
callq 0x71f20
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa6739
jmp 0xa6768
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x20(%rbp), %rax
movl $0x3, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movl $0x2, %r9d
movl $0xb, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71cd0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: subtilis_riscos_arm_heap_free_space
void subtilis_riscos_arm_heap_free_space(subtilis_ir_section_t *s, size_t start,
					 void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t heap_start;
	subtilis_arm_reg_t result;
	subtilis_arm_reg_t scratch;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *free_space = &s->ops[start]->op.instr;

	heap_start = subtilis_arm_ir_to_arm_reg(arm_s->reg_counter++);
	result = subtilis_arm_ir_to_arm_reg(free_space->operands[0].reg);
	scratch = subtilis_arm_ir_to_arm_reg(arm_s->reg_counter++);

	prv_load_heap_pointer(arm_s, scratch, heap_start, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_heap_free_space(arm_s, heap_start, result, err);
}

// 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
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x6fe90
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xa6830
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa680d
jmp 0xa6822
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x90bb0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: prv_load_heap_pointer
static void prv_load_heap_pointer(subtilis_arm_section_t *arm_s,
				  subtilis_arm_reg_t reg,
				  subtilis_arm_reg_t scratch,
				  subtilis_error_t *err)
{
	subtilis_arm_add_mov_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, reg,
				 arm_s->start_address, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_stran_imm(arm_s, SUBTILIS_ARM_INSTR_LDR,
				   SUBTILIS_ARM_CCODE_AL, scratch, reg, 4,
				   false, err);
}

// 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 -0x8(%rbp), %rdi
movq -0x10(%rbp), %r9
movq -0x8(%rbp), %rax
movl 0xb8(%rax), %r10d
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xf, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71b10
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa688a
jmp 0xa68be
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %r8
movq -0x20(%rbp), %rax
movl $0x12, %esi
movl $0xe, %edx
movl $0x4, %r9d
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x72030
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: subtilis_riscos_sys_check
bool subtilis_riscos_sys_check(size_t call_id, uint32_t *in_regs,
			       uint32_t *out_regs, bool *handle_errors,
			       const subtilis_arm_swi_t *swi_list,
			       size_t swi_count)
{
	subtilis_arm_swi_t *found;

	if (call_id & 0x20000) {
		*handle_errors = true;
		call_id &= ~0x20000;
	} else {
		*handle_errors = false;
	}

	if (call_id >= 0x100 && call_id <= 0x1ff) {
		*in_regs = 0;
		return true;
	}

	found = bsearch(&call_id, &swi_list[0], swi_count, sizeof(*found),
			prv_sys_num_lookup);

	if (!found)
		return false;

	*in_regs = found->in_regs;
	*out_regs = found->out_regs;

	return true;
}

// 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)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
andq $0x20000, %rax          # imm = 0x20000
cmpq $0x0, %rax
je 0xa6c27
movq -0x28(%rbp), %rax
movb $0x1, (%rax)
movq -0x10(%rbp), %rax
andq $-0x20001, %rax         # imm = 0xFFFDFFFF
movq %rax, -0x10(%rbp)
jmp 0xa6c2e
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x100, -0x10(%rbp)     # imm = 0x100
jb 0xa6c52
cmpq $0x1ff, -0x10(%rbp)     # imm = 0x1FF
ja 0xa6c52
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0xa6c9e
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x10(%rbp), %rdi
movl $0x18, %ecx
leaq 0x46(%rip), %r8         # 0xa6cb0
callq 0x12270
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xa6c80
movb $0x0, -0x1(%rbp)
jmp 0xa6c9e
movq -0x40(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: prv_sys_num_lookup
static int prv_sys_num_lookup(const void *av, const void *bv)
{
	size_t *a = (size_t *)av;
	subtilis_arm_swi_t *b = (subtilis_arm_swi_t *)bv;

	if (*a == b->num)
		return 0;
	if (*a < b->num)
		return -1;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jne 0xa6ce7
movl $0x0, -0x4(%rbp)
jmp 0xa6d09
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0xa6d02
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa6d09
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: prv_check_out_regs
static uint32_t prv_check_out_regs(size_t call_id,
				   const subtilis_arm_swi_t *swi_list,
				   size_t swi_count, subtilis_error_t *err)
{
	subtilis_arm_swi_t *found;

	if (call_id >= 0x100 && call_id <= 0x1ff)
		return 0;

	found = bsearch(&call_id, &swi_list[0], swi_count, sizeof(*found),
			prv_sys_num_lookup);

	if (!found) {
		subtilis_error_set_assertion_failed(err);
		return 0;
	}

	return found->out_regs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x100, -0x10(%rbp)     # imm = 0x100
jb 0xa6fc5
cmpq $0x1ff, -0x10(%rbp)     # imm = 0x1FF
ja 0xa6fc5
movl $0x0, -0x4(%rbp)
jmp 0xa701a
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x10(%rbp), %rdi
movl $0x18, %ecx
leaq -0x32d(%rip), %r8       # 0xa6cb0
callq 0x12270
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xa7010
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x9687(%rip), %rdx      # 0xb0684
movl $0x7f2, %ecx            # imm = 0x7F2
callq 0x158e0
movl $0x0, -0x4(%rbp)
jmp 0xa701a
movq -0x30(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: prv_open_file
static void prv_open_file(subtilis_ir_section_t *s, size_t start,
			  void *user_data, int32_t code, int32_t bits,
			  subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t buffer;
	subtilis_arm_reg_t one;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *openf = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_arm_reg(openf->operands[0].reg);
	buffer = subtilis_arm_ir_to_arm_reg(openf->operands[1].reg);

	subtilis_arm_add_mov_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, 0,
				 bits | code, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, 1, buffer,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	/* OS_Find */
	/* read_mask = 0x3 = r0, r1 */
	/* write_mask = 0x1 = r0 */
	subtilis_arm_add_swi(arm_s, SUBTILIS_ARM_CCODE_AL, 0x20000 + 0xd, 0x3,
			     0x1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	one = subtilis_arm_ir_to_arm_reg(arm_s->reg_counter++);
	subtilis_arm_gen_sete_load_reg(arm_s, s, SUBTILIS_ARM_CCODE_VS, one,
				       err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_VC, false, dest, 0,
				 err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rdi
movl -0x20(%rbp), %r10d
orl -0x1c(%rbp), %r10d
movq -0x28(%rbp), %rax
movl $0xd, %esi
movl $0xf, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71b10
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa7112
jmp 0xa71d7
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %r9
movq -0x28(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
movq %rax, (%rsp)
callq 0x71fa0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa7147
jmp 0xa71d7
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %r9
movl $0xe, %esi
movl $0x2000d, %edx          # imm = 0x2000D
movl $0x3, %ecx
movl $0x1, %r8d
callq 0x71f20
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa7174
jmp 0xa71d7
movq -0x48(%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x6fe90
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %r8
movl $0x6, %edx
callq 0x75ce0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa71b3
jmp 0xa71d7
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %r8
movq -0x28(%rbp), %rax
movl $0xd, %esi
movl $0x7, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0x71fa0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: subtilis_riscos_close
void subtilis_riscos_close(subtilis_ir_section_t *s, size_t start,
			   void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t handle;
	subtilis_arm_reg_t one;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *closef = &s->ops[start]->op.instr;

	handle = subtilis_arm_ir_to_arm_reg(closef->operands[0].reg);

	subtilis_arm_add_mov_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, 0, 0,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, 1, handle,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	/* OS_Find */
	/* read_mask = 0x3 = r0, r1 */
	/* write_mask = 0x1 = r0 */
	subtilis_arm_add_swi(arm_s, SUBTILIS_ARM_CCODE_AL, 0x20000 + 0xd, 0x3,
			     0x1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	one = subtilis_arm_ir_to_arm_reg(arm_s->reg_counter++);
	subtilis_arm_gen_sete_load_reg(arm_s, s, SUBTILIS_ARM_CCODE_VS, one,
				       err);
}

// 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
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xf, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71b10
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa72e5
jmp 0xa7378
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
movq %rax, (%rsp)
callq 0x71fa0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa7317
jmp 0xa7378
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %r9
movl $0xe, %esi
movl $0x2000d, %edx          # imm = 0x2000D
movl $0x3, %ecx
movl $0x1, %r8d
callq 0x71f20
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa7344
jmp 0xa7378
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x6, %edx
callq 0x75ce0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: subtilis_riscos_bget
void subtilis_riscos_bget(subtilis_ir_section_t *s, size_t start,
			  void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t handle;
	subtilis_arm_reg_t one;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *bget = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_arm_reg(bget->operands[0].reg);
	handle = subtilis_arm_ir_to_arm_reg(bget->operands[1].reg);

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, 1, handle,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	/* OS_BGet */
	/* read_mask = 0x2 = r1 */
	/* write_mask = 0x1 = r0 */
	subtilis_arm_add_swi(arm_s, SUBTILIS_ARM_CCODE_AL, 0xa, 0x2, 0x1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	one = subtilis_arm_ir_to_arm_reg(arm_s->reg_counter++);
	subtilis_arm_gen_sete_load_reg(arm_s, s, SUBTILIS_ARM_CCODE_CS, one,
				       err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_CC, false, dest, 0,
				 err);
}

// 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
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
movq %rax, (%rsp)
callq 0x71fa0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa740f
jmp 0xa749f
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %r9
movl $0xe, %esi
movl $0xa, %edx
movl $0x2, %ecx
movl $0x1, %r8d
callq 0x71f20
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa743c
jmp 0xa749f
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x6fe90
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x2, %edx
callq 0x75ce0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa747b
jmp 0xa749f
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0x3, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0x71fa0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: subtilis_riscos_bput
void subtilis_riscos_bput(subtilis_ir_section_t *s, size_t start,
			  void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t data;
	subtilis_arm_reg_t handle;
	subtilis_arm_reg_t one;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *bget = &s->ops[start]->op.instr;

	data = subtilis_arm_ir_to_arm_reg(bget->operands[0].reg);
	handle = subtilis_arm_ir_to_arm_reg(bget->operands[1].reg);

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, 0, data,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, 1, handle,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	/* OS_BPut */
	/* read_mask = 0x3 = r1 */
	/* write_mask = 0x0 = r0 */
	subtilis_arm_add_swi(arm_s, SUBTILIS_ARM_CCODE_AL, 0x20000 + 0xb, 0x3,
			     0x0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	one = subtilis_arm_ir_to_arm_reg(arm_s->reg_counter++);
	subtilis_arm_gen_sete_load_reg(arm_s, s, SUBTILIS_ARM_CCODE_VS, one,
				       err);
}

// 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
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rax, (%rsp)
callq 0x71fa0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa753c
jmp 0xa75cc
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
movq %rax, (%rsp)
callq 0x71fa0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa756e
jmp 0xa75cc
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %r9
movl $0xe, %esi
movl $0x2000b, %edx          # imm = 0x2000B
movl $0x3, %ecx
xorl %r8d, %r8d
callq 0x71f20
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa7598
jmp 0xa75cc
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x6fe90
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x6, %edx
callq 0x75ce0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: subtilis_riscos_ext
void subtilis_riscos_ext(subtilis_ir_section_t *s, size_t start,
			 void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t handle;
	subtilis_arm_reg_t one;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *bget = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_arm_reg(bget->operands[0].reg);
	handle = subtilis_arm_ir_to_arm_reg(bget->operands[1].reg);

	subtilis_arm_add_mov_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, 0, 2,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, 1, handle,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	/* OS_Args 2 */
	/* read_mask = 0x3 = r0, r1 */
	/* write_mask = 0x4 = r2 */
	subtilis_arm_add_swi(arm_s, SUBTILIS_ARM_CCODE_AL, 0x20000 + 0x9, 0x3,
			     0x4, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	one = subtilis_arm_ir_to_arm_reg(arm_s->reg_counter++);
	subtilis_arm_gen_sete_load_reg(arm_s, s, SUBTILIS_ARM_CCODE_VS, one,
				       err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_VC, false, dest, 2,
				 err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xf, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
movl $0x2, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71b10
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa7cd6
jmp 0xa7d9e
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
movq %rax, (%rsp)
callq 0x71fa0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa7d0b
jmp 0xa7d9e
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %r9
movl $0xe, %esi
movl $0x20009, %edx          # imm = 0x20009
movl $0x3, %ecx
movl $0x4, %r8d
callq 0x71f20
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa7d38
jmp 0xa7d9e
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x6fe90
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x6, %edx
callq 0x75ce0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa7d77
jmp 0xa7d9e
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0x7, %edx
xorl %ecx, %ecx
movl $0x2, %r9d
movq %rax, (%rsp)
callq 0x71fa0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: subtilis_riscos_get_ptr
void subtilis_riscos_get_ptr(subtilis_ir_section_t *s, size_t start,
			     void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t handle;
	subtilis_arm_reg_t one;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *bget = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_arm_reg(bget->operands[0].reg);
	handle = subtilis_arm_ir_to_arm_reg(bget->operands[1].reg);

	subtilis_arm_add_mov_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, 0, 0,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, 1, handle,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	/* OS_Args 2 */
	/* read_mask = 0x3 = r0, r1 */
	/* write_mask = 0x5 = r0, r2 */
	subtilis_arm_add_swi(arm_s, SUBTILIS_ARM_CCODE_AL, 0x20000 + 0x9, 0x3,
			     0x5, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	one = subtilis_arm_ir_to_arm_reg(arm_s->reg_counter++);
	subtilis_arm_gen_sete_load_reg(arm_s, s, SUBTILIS_ARM_CCODE_VS, one,
				       err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_VC, false, dest, 2,
				 err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xf, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71b10
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa7e46
jmp 0xa7f0e
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
movq %rax, (%rsp)
callq 0x71fa0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa7e7b
jmp 0xa7f0e
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %r9
movl $0xe, %esi
movl $0x20009, %edx          # imm = 0x20009
movl $0x3, %ecx
movl $0x5, %r8d
callq 0x71f20
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa7ea8
jmp 0xa7f0e
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x6fe90
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x6, %edx
callq 0x75ce0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa7ee7
jmp 0xa7f0e
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0x7, %edx
xorl %ecx, %ecx
movl $0x2, %r9d
movq %rax, (%rsp)
callq 0x71fa0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: subtilis_riscos_set_ptr
void subtilis_riscos_set_ptr(subtilis_ir_section_t *s, size_t start,
			     void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t handle;
	subtilis_arm_reg_t one;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *bget = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_arm_reg(bget->operands[0].reg);
	handle = subtilis_arm_ir_to_arm_reg(bget->operands[1].reg);

	subtilis_arm_add_mov_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, 0, 1,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, 1, handle,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_VC, false, 2, dest,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	/* OS_Args 2 */
	/* read_mask = 0x7 = r0, r1, r2 */
	/* write_mask = 0x0*/
	subtilis_arm_add_swi(arm_s, SUBTILIS_ARM_CCODE_AL, 0x20000 + 0x9, 0x3,
			     0x0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	one = subtilis_arm_ir_to_arm_reg(arm_s->reg_counter++);
	subtilis_arm_gen_sete_load_reg(arm_s, s, SUBTILIS_ARM_CCODE_VS, one,
				       err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xf, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71b10
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa7fb6
jmp 0xa807b
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
movq %rax, (%rsp)
callq 0x71fa0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa7feb
jmp 0xa807b
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0x7, %edx
xorl %ecx, %ecx
movl $0x2, %r8d
movq %rax, (%rsp)
callq 0x71fa0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa801d
jmp 0xa807b
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %r9
movl $0xe, %esi
movl $0x20009, %edx          # imm = 0x20009
movl $0x3, %ecx
xorl %r8d, %r8d
callq 0x71f20
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa8047
jmp 0xa807b
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x6fe90
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x6, %edx
callq 0x75ce0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: subtilis_riscos_signx8to32
void subtilis_riscos_signx8to32(subtilis_ir_section_t *s, size_t start,
				void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t src;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *signx = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_arm_reg(signx->operands[0].reg);
	src = subtilis_arm_ir_to_arm_reg(signx->operands[1].reg);

	subtilis_arm_gen_signx8to32_helper(arm_s, dest, src, err);
}

// 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 -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x75df0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: subtilis_riscos_oscli
void subtilis_riscos_oscli(subtilis_ir_section_t *s, size_t start,
			   void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t buffer;
	subtilis_arm_reg_t one;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *openf = &s->ops[start]->op.instr;

	buffer = subtilis_arm_ir_to_arm_reg(openf->operands[0].reg);

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, 0, buffer,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	/* OS_CLI */
	/* read_mask = 0x1 = r0 */
	/* write_mask = 0x1 = r0 */
	subtilis_arm_add_swi(arm_s, SUBTILIS_ARM_CCODE_AL, 0x20000 + 0x5, 0x1,
			     0x1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	one = subtilis_arm_ir_to_arm_reg(arm_s->reg_counter++);
	subtilis_arm_gen_sete_load_reg(arm_s, s, SUBTILIS_ARM_CCODE_VS, one,
				       err);
}

// 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
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rax, (%rsp)
callq 0x71fa0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa8188
jmp 0xa81e7
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %r9
movl $0xe, %esi
movl $0x20005, %edx          # imm = 0x20005
movl $0x1, %r8d
movl %r8d, %ecx
callq 0x71f20
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa81b3
jmp 0xa81e7
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x6, %edx
callq 0x75ce0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: subtilis_riscos_osargs
void subtilis_riscos_osargs(subtilis_ir_section_t *s, size_t start,
			    void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t buffer;
	subtilis_arm_reg_t one;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *osargs = &s->ops[start]->op.instr;

	buffer = subtilis_arm_ir_to_arm_reg(osargs->operands[0].reg);

	/* OS_GetEnv */
	/* read_mask = 0x0 = */
	/* write_mask = 0x7 = r0, r1, r2 */
	subtilis_arm_add_swi(arm_s, SUBTILIS_ARM_CCODE_AL, 0x20000 + 0x10, 0x0,
			     0x7, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	one = subtilis_arm_ir_to_arm_reg(arm_s->reg_counter++);
	subtilis_arm_gen_sete_load_reg(arm_s, s, SUBTILIS_ARM_CCODE_VS, one,
				       err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_VC, false, buffer, 0,
				 err);
}

// 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
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %r9
movl $0xe, %esi
movl $0x20010, %edx          # imm = 0x20010
xorl %ecx, %ecx
movl $0x7, %r8d
callq 0x71f20
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa8263
jmp 0xa82c6
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x6, %edx
callq 0x75ce0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa82a2
jmp 0xa82c6
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0x7, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0x71fa0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: prv_init_heap
static void prv_init_heap(subtilis_arm_section_t *arm_s, uint32_t stack_size,
			  subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *datai;

	/*
	 * On entry,
	 * R11 = heap start
	 * R13 is the top of the stack
	 */

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, 1, 11,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_sub_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, 3, 13,
				 stack_size, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	instr =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_SUB, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	datai = &instr->operands.data;
	datai->ccode = SUBTILIS_ARM_CCODE_AL;
	datai->status = false;
	datai->dest = 3;
	datai->op1 = 3;
	datai->op2.type = SUBTILIS_ARM_OP2_REG;
	datai->op2.op.reg = 1;

	subtilis_arm_heap_init(arm_s, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
movl $0xb, %r9d
movq %rax, (%rsp)
callq 0x71fa0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa863a
jmp 0xa86fb
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %r10d
movq -0x18(%rbp), %rax
movl $0x2, %esi
movl $0x4, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
movl $0x3, %r9d
movq $0xd, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x71640
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa8680
jmp 0xa86fb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x2, %esi
callq 0x70b50
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa86a1
jmp 0xa86fb
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0xe, (%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x28(%rbp), %rax
movq $0x3, 0x8(%rax)
movq -0x28(%rbp), %rax
movq $0x3, 0x10(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x28(%rbp), %rax
movq $0x1, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8d9e0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: prv_compute_sss
static void prv_compute_sss(subtilis_arm_section_t *arm_s,
			    subtilis_error_t *err)
{
	subtilis_arm_subsections_t sss;

	subtilis_arm_subsections_init(&sss);
	subtilis_arm_subsections_calculate(&sss, arm_s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

cleanup:

	subtilis_arm_subsections_free(&sss);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x891b0
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x89230
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa8745
jmp 0xa8747
jmp 0xa8747
leaq -0x70(%rbp), %rdi
callq 0x89c60
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/riscos_common/riscos_arm.c
// Function: prv_remove_escape_handler
static void prv_remove_escape_handler(subtilis_arm_section_t *arm_s,
				      subtilis_error_t *err)
{
	subtilis_arm_add_mov_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, 0, 9,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_stran_imm(arm_s, SUBTILIS_ARM_INSTR_LDR,
				   SUBTILIS_ARM_CCODE_AL, 1, 12,
				   RISCOS_ARM_GLOBAL_ESC_HANDLER, false, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_stran_imm(arm_s, SUBTILIS_ARM_INSTR_LDR,
				   SUBTILIS_ARM_CCODE_AL, 2, 12,
				   RISCOS_ARM_GLOBAL_ESC_R12, false, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	/* read_mask = 0x7 = R0, R1, R2 */
	/* write_mask = 0xe = R1, R2, R3 */
	subtilis_arm_add_swi(arm_s, SUBTILIS_ARM_CCODE_AL, 0x40, 0x7, 0xe, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl $0xd, %esi
movl $0xf, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
movl $0x9, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71b10
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa8d1c
jmp 0xa8dc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl $0x12, %esi
movl $0xe, %edx
movl $0x1, %ecx
movl $0xc, %r8d
movl $0xfffffff8, %r9d       # imm = 0xFFFFFFF8
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x72030
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa8d5e
jmp 0xa8dc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl $0x12, %esi
movl $0xe, %edx
movl $0x2, %ecx
movl $0xc, %r8d
movl $0xfffffff4, %r9d       # imm = 0xFFFFFFF4
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x72030
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa8da0
jmp 0xa8dc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %r9
movl $0xe, %r8d
movl $0x40, %edx
movl $0x7, %ecx
movl %r8d, %esi
callq 0x71f20
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/tests/integer.c
// Function: rand_int
struct tt_int *rand_int(int msb)
{
	struct tt_int *ti = tt_int_alloc();
	if (_tt_int_realloc(ti, msb))
		return NULL;

	ti->msb = msb;
#ifdef _TT_LP64_
	for (int i = 0; i < msb-1; i++) {
		ti->buf[i] = rand() & ~(1<<31);
		ti->buf[i] <<= 32;
		ti->buf[i] |= rand();
	}
	do {
		ti->buf[msb-1] = rand() & ~(1<<31);
	} while (ti->buf[msb-1] == 0);
	ti->buf[msb-1] <<= 32;
	ti->buf[msb-1] |= rand();
#else
	for (int i = 0; i < msb-1; i++)
		ti->buf[i] = rand() & ~(1<<31);
	do {
		ti->buf[msb-1] = rand() & ~(1<<31);
	} while (ti->buf[msb-1] == 0);
#endif

	return ti;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
callq 0x7a50
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x7b20
cmpl $0x0, %eax
je 0x2343
movq $0x0, 0x20(%rsp)
jmp 0x2456
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x23ca
callq 0x2200
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movslq %eax, %rdx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
shlq $0x20, %rdx
movq %rdx, (%rax,%rcx,8)
callq 0x2200
movslq %eax, %rdx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2357
jmp 0x23cc
callq 0x2200
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movslq %eax, %rdx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x23cc
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
shlq $0x20, %rdx
movq %rdx, (%rax,%rcx,8)
callq 0x2200
movslq %eax, %rdx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq