LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: prv_add_data_imm_ldr
static size_t prv_add_data_imm_ldr(subtilis_arm_section_t *s,
				   subtilis_arm_ccode_type_t ccode,
				   subtilis_arm_reg_t dest, int32_t op2,
				   subtilis_error_t *err)
{
	subtilis_arm_ldrc_instr_t *ldrc;
	subtilis_arm_instr_t *instr;
	size_t label;
	size_t i;

	for (i = 0; i < s->constants.ui32_count; i++)
		if (s->constants.ui32[i].integer == op2)
			break;

	if (i < s->constants.ui32_count) {
		label = s->constants.ui32[i].label;
	} else {
		label = s->label_counter++;
		prv_add_ui32_constant(s, label, (uint32_t)op2, false, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return 0;
	}

	instr = subtilis_arm_section_add_instr(s, SUBTILIS_ARM_INSTR_LDRC, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return 0;

	ldrc = &instr->operands.ldrc;
	ldrc->ccode = ccode;
	ldrc->dest = dest;
	ldrc->label = label;
	ldrc->link_time = false;
	return label;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movq 0x60(%rdi), %rdx
testq %rdx, %rdx
setne %dil
je 0x4fd9f
movq 0x58(%r15), %rsi
cmpl %ecx, (%rsi)
jne 0x4fd67
xorl %eax, %eax
jmp 0x4fd8b
addq $0x18, %rsi
leaq -0x1(%rdx), %rdi
xorl %eax, %eax
cmpq %rax, %rdi
je 0x4fd9f
leaq 0x18(%rsi), %r8
incq %rax
cmpl %ecx, (%rsi)
movq %r8, %rsi
jne 0x4fd71
cmpq %rdx, %rax
setb %dil
testb %dil, %dil
je 0x4fd9f
movq 0x58(%r15), %rcx
leaq (%rax,%rax,2), %rax
movq 0x8(%rcx,%rax,8), %r12
jmp 0x4fdc4
movq 0x10(%r15), %r12
leaq 0x1(%r12), %rax
movq %rax, 0x10(%r15)
movq %r15, %rdi
movq %r12, %rsi
movl %ecx, %edx
xorl %ecx, %ecx
movq %r14, %r8
callq 0x4fa5a
cmpl $0x0, (%r14)
jne 0x4fdf3
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f5b7
cmpl $0x0, (%r14)
je 0x4fdd9
xorl %ecx, %ecx
jmp 0x4fded
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl $0x18, 0x8(%rax)
cmpl $0x0, (%r14)
je 0x4fe02
xorl %r12d, %r12d
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, 0x8(%rcx)
movq %rbx, 0x10(%rcx)
movq %r12, 0x18(%rcx)
movb $0x0, 0x20(%rcx)
jmp 0x4fdf6
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_mul_imm
void subtilis_arm_add_mul_imm(subtilis_arm_section_t *s,
			      subtilis_arm_ccode_type_t ccode, bool status,
			      subtilis_arm_reg_t dest, subtilis_arm_reg_t rm,
			      int32_t rs, subtilis_error_t *err)
{
	subtilis_arm_reg_t mov_dest;
	subtilis_arm_instr_t *instr;
	subtilis_arm_mul_instr_t *mul;

	if (rm == dest) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	mov_dest = subtilis_arm_acquire_new_reg(s);
	subtilis_arm_add_mov_imm(s, ccode, false, mov_dest, rs, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	/* TODO: A whole pile of optimisations here */

	instr = subtilis_arm_section_add_instr(s, SUBTILIS_ARM_INSTR_MUL, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	mul = &instr->operands.mul;
	mul->status = status;
	mul->ccode = ccode;
	mul->dest = dest;
	mul->rm = rm;
	mul->rs = mov_dest;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x40(%rsp), %r13
cmpq %rcx, %r8
jne 0x50191
leaq 0x25a27(%rip), %rdx     # 0x75b98
movq %r13, %rdi
movl $0xf, %esi
movl $0x3f3, %ecx            # imm = 0x3F3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x145f4
movl %r9d, %eax
movq %r8, %rbx
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq (%rdi), %r12
leaq 0x1(%r12), %rcx
movq %rcx, (%rdi)
leaq -0x1(%r12), %rcx
cmpq $0x3, %rcx
movl %edx, 0x4(%rsp)
jae 0x501c7
leaq 0x259c0(%rip), %rcx     # 0x75b80
movq -0x8(%rcx,%r12,8), %r12
jmp 0x501cb
addq $0xc, %r12
movq %r15, %rdi
movl $0xd, %esi
movl $0xf, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
movq %r12, %r9
pushq %r13
pushq %rax
callq 0x50249
addq $0x10, %rsp
cmpl $0x0, (%r13)
jne 0x5023a
movq %r15, %rdi
movq %r13, %rsi
callq 0x4f5b7
cmpl $0x0, (%r13)
je 0x50209
xorl %ecx, %ecx
jmp 0x5021d
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl $0x10, 0x8(%rax)
cmpl $0x0, (%r13)
jne 0x5023a
movl 0x4(%rsp), %eax
movb %al, 0xc(%rcx)
movl %ebp, 0x8(%rcx)
movq %r14, 0x10(%rcx)
movq %rbx, 0x18(%rcx)
movq %r12, 0x20(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_movmvn_imm
void subtilis_arm_add_movmvn_imm(subtilis_arm_section_t *s,
				 subtilis_arm_instr_type_t itype,
				 subtilis_arm_instr_type_t alt_type,
				 subtilis_arm_ccode_type_t ccode, bool status,
				 subtilis_arm_reg_t dest, int32_t op2,
				 subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *datai;
	uint32_t encoded = 0;

	if (!subtilis_arm_encode_imm(op2, &encoded)) {
		if (subtilis_arm_encode_imm(~op2, &encoded)) {
			itype = alt_type;
		} else {
			(void)prv_add_data_imm_ldr(s, ccode, dest, op2, err);
			return;
		}
	}

	instr = subtilis_arm_section_add_instr(s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	datai = &instr->operands.data;
	datai->status = status;
	datai->op2.type = SUBTILIS_ARM_OP2_I32;
	datai->ccode = ccode;
	datai->dest = dest;
	datai->op2.op.integer = encoded;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movl %ecx, %ebp
movl %edx, %ebx
movl %esi, %r12d
movq %rdi, %r13
movq 0x58(%rsp), %r15
movl 0x50(%rsp), %r14d
leaq 0x8(%rsp), %rsi
movl $0x0, (%rsi)
movl %r14d, %edi
callq 0x4f8d1
testb %al, %al
jne 0x502a2
movl %r14d, %edi
notl %edi
leaq 0x8(%rsp), %rsi
callq 0x4f8d1
movl %ebx, %r12d
testb %al, %al
je 0x502fe
movq %r13, %rdi
movq %r15, %rsi
callq 0x4f5b7
cmpl $0x0, (%r15)
je 0x502b7
xorl %ecx, %ecx
jmp 0x502c8
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl %r12d, 0x8(%rax)
cmpl $0x0, (%r15)
jne 0x502ef
movl 0xc(%rsp), %eax
movb %al, 0xc(%rcx)
movl $0x1, 0x20(%rcx)
movl %ebp, 0x8(%rcx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rcx)
movl 0x8(%rsp), %eax
movl %eax, 0x28(%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
movl %ebp, %esi
movq 0x10(%rsp), %rdx
movl %r14d, %ecx
movq %r15, %r8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4fd3b
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_mul
void subtilis_arm_add_mul(subtilis_arm_section_t *s,
			  subtilis_arm_ccode_type_t ccode, bool status,
			  subtilis_arm_reg_t dest, subtilis_arm_reg_t rm,
			  subtilis_arm_reg_t rs, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_reg_t tmp_reg;
	subtilis_arm_mul_instr_t *mul;

	if (dest == rm) {
		if (dest == rs) {
			subtilis_error_set_assertion_failed(err);
			return;
		}
		tmp_reg = rs;
		rs = rm;
		rm = tmp_reg;
	}

	instr = subtilis_arm_section_add_instr(s, SUBTILIS_ARM_INSTR_MUL, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	mul = &instr->operands.mul;
	mul->status = status;
	mul->ccode = ccode;
	mul->dest = dest;
	mul->rm = rm;
	mul->rs = rs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rcx, %r14
movl %edx, %r15d
movl %esi, %ebp
movq 0x40(%rsp), %r12
cmpq %r8, %rcx
jne 0x50370
movq %r8, %r13
cmpq %rbx, %r14
jne 0x50376
leaq 0x25848(%rip), %rdx     # 0x75b98
movq %r12, %rdi
movl $0xf, %esi
movl $0x415, %ecx            # imm = 0x415
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x145f4
movq %rbx, %r13
movq %r8, %rbx
movq %r12, %rsi
callq 0x4f5b7
cmpl $0x0, (%r12)
je 0x50389
xorl %ecx, %ecx
jmp 0x5039d
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl $0x10, 0x8(%rax)
cmpl $0x0, (%r12)
jne 0x503b7
movb %r15b, 0xc(%rcx)
movl %ebp, 0x8(%rcx)
movq %r14, 0x10(%rcx)
movq %rbx, 0x18(%rcx)
movq %r13, 0x20(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_data_imm
void subtilis_arm_add_data_imm(subtilis_arm_section_t *s,
			       subtilis_arm_instr_type_t itype,
			       subtilis_arm_ccode_type_t ccode, bool status,
			       subtilis_arm_reg_t dest, subtilis_arm_reg_t op1,
			       int32_t op2, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *datai;
	uint32_t encoded;
	subtilis_arm_reg_t mov_dest;
	subtilis_arm_op2_t data_opt2;

	if (!subtilis_arm_encode_imm(op2, &encoded)) {
		mov_dest = subtilis_arm_acquire_new_reg(s);
		subtilis_arm_add_mov_imm(s, ccode, false, mov_dest, op2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		data_opt2.type = SUBTILIS_ARM_OP2_REG;
		data_opt2.op.reg = mov_dest;
	} else {
		data_opt2.type = SUBTILIS_ARM_OP2_I32;
		data_opt2.op.integer = encoded;
	}

	instr = subtilis_arm_section_add_instr(s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	datai = &instr->operands.data;
	datai->status = status;
	datai->ccode = ccode;
	datai->dest = dest;
	datai->op1 = op1;
	datai->op2 = data_opt2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movl %ecx, 0x10(%rsp)
movl %edx, %ebp
movl %esi, 0xc(%rsp)
movq %rdi, %r14
movq 0x68(%rsp), %r12
movl 0x60(%rsp), %r15d
leaq 0x14(%rsp), %rsi
movl %r15d, %edi
callq 0x4f8d1
testb %al, %al
je 0x50415
movl $0x1, %ebx
movl 0x14(%rsp), %r13d
xorl %r15d, %r15d
jmp 0x50473
movq (%r14), %r13
leaq 0x1(%r13), %rax
movq %rax, (%r14)
leaq -0x1(%r13), %rax
cmpq $0x3, %rax
jae 0x50437
leaq 0x25750(%rip), %rax     # 0x75b80
movq -0x8(%rax,%r13,8), %r13
jmp 0x5043b
addq $0xc, %r13
xorl %ebx, %ebx
movq %r14, %rdi
movl $0xd, %esi
movl $0xf, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
movq %r13, %r9
pushq %r12
pushq %r15
callq 0x50249
addq $0x10, %rsp
cmpl $0x0, (%r12)
jne 0x504cd
movabsq $-0x100000000, %r15     # imm = 0xFFFFFFFF00000000
andq %r13, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x4f5b7
cmpl $0x0, (%r12)
je 0x50489
xorl %ecx, %ecx
jmp 0x5049d
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl 0xc(%rsp), %edx
movl %edx, 0x8(%rax)
cmpl $0x0, (%r12)
jne 0x504cd
movl 0x10(%rsp), %eax
movb %al, 0xc(%rcx)
movl %ebp, 0x8(%rcx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rcx)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rcx)
movl %ebx, 0x20(%rcx)
movl %r13d, %eax
orq %rax, %r15
movq %r15, 0x28(%rcx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_cmov
void subtilis_arm_add_cmov(subtilis_arm_section_t *s, subtilis_arm_reg_t dest,
			   subtilis_arm_reg_t op1, subtilis_arm_reg_t op2,
			   subtilis_arm_reg_t op3, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_cmov_instr_t *cmov;

	instr = subtilis_arm_section_add_instr(s, SUBTILIS_ARM_INSTR_CMOV, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	cmov = &instr->operands.cmov;
	cmov->dest = dest;
	cmov->op1 = op1;
	cmov->op2 = op2;
	cmov->op3 = op3;
	cmov->fused = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r13
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %r9, %rsi
callq 0x4f5b7
cmpl $0x0, (%r13)
je 0x50507
xorl %ecx, %ecx
jmp 0x5051b
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl $0x1a, 0x8(%rax)
cmpl $0x0, (%r13)
jne 0x50536
movq %r12, 0x8(%rcx)
movq %r15, 0x10(%rcx)
movq %r14, 0x18(%rcx)
movq %rbx, 0x20(%rcx)
movb $0x0, 0x28(%rcx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_cmov_fused
void subtilis_arm_add_cmov_fused(subtilis_arm_section_t *s,
				 subtilis_arm_reg_t dest,
				 subtilis_arm_reg_t op2, subtilis_arm_reg_t op3,
				 subtilis_arm_ccode_type_t true_cond,
				 subtilis_arm_ccode_type_t false_cond,
				 subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_cmov_instr_t *cmov;

	instr = subtilis_arm_section_add_instr(s, SUBTILIS_ARM_INSTR_CMOV, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	cmov = &instr->operands.cmov;
	cmov->dest = dest;
	cmov->op2 = op2;
	cmov->op3 = op3;
	cmov->fused = true;
	cmov->true_cond = true_cond;
	cmov->false_cond = false_cond;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x40(%rsp), %r13
movq %r13, %rsi
callq 0x4f5b7
cmpl $0x0, (%r13)
je 0x50572
xorl %ecx, %ecx
jmp 0x50586
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl $0x1a, 0x8(%rax)
cmpl $0x0, (%r13)
jne 0x505a3
movq %r12, 0x8(%rcx)
movq %r15, 0x18(%rcx)
movq %r14, 0x20(%rcx)
movb $0x1, 0x28(%rcx)
movl %ebp, 0x2c(%rcx)
movl %ebx, 0x30(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_swi
void subtilis_arm_add_swi(subtilis_arm_section_t *s,
			  subtilis_arm_ccode_type_t ccode, size_t code,
			  uint32_t read_mask, uint32_t write_mask,
			  subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_swi_instr_t *swi;

	instr = subtilis_arm_section_add_instr(s, SUBTILIS_ARM_INSTR_SWI, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	swi = &instr->operands.swi;
	swi->ccode = ccode;
	swi->code = code;
	swi->reg_read_mask = read_mask;
	swi->reg_write_mask = write_mask;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %r12
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movq %r9, %rsi
callq 0x4f5b7
cmpl $0x0, (%r12)
je 0x505db
xorl %ecx, %ecx
jmp 0x505ef
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl $0x17, 0x8(%rax)
cmpl $0x0, (%r12)
jne 0x50604
movl %r15d, 0x8(%rcx)
movq %r14, 0x10(%rcx)
movl %ebp, 0x18(%rcx)
movl %ebx, 0x1c(%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_movmvn_reg
void subtilis_arm_add_movmvn_reg(subtilis_arm_section_t *s,
				 subtilis_arm_instr_type_t itype,
				 subtilis_arm_ccode_type_t ccode, bool status,
				 subtilis_arm_reg_t dest,
				 subtilis_arm_reg_t op2, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *datai;

	instr = subtilis_arm_section_add_instr(s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	datai = &instr->operands.data;
	datai->status = status;
	datai->ccode = ccode;
	datai->dest = dest;
	datai->op2.type = SUBTILIS_ARM_OP2_REG;
	datai->op2.op.reg = op2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r13d
movq 0x40(%rsp), %r12
movq %r12, %rsi
callq 0x4f5b7
cmpl $0x0, (%r12)
je 0x5063e
xorl %ecx, %ecx
jmp 0x5064f
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl %r13d, 0x8(%rax)
cmpl $0x0, (%r12)
jne 0x5066c
movb %r15b, 0xc(%rcx)
movl %ebp, 0x8(%rcx)
movq %r14, 0x10(%rcx)
movl $0x0, 0x20(%rcx)
movq %rbx, 0x28(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_stran_imm
void subtilis_arm_add_stran_imm(subtilis_arm_section_t *s,
				subtilis_arm_instr_type_t itype,
				subtilis_arm_ccode_type_t ccode,
				subtilis_arm_reg_t dest,
				subtilis_arm_reg_t base, int32_t offset,
				bool byte, subtilis_error_t *err)
{
	subtilis_arm_op2_t op2;
	subtilis_arm_instr_t *instr;
	subtilis_arm_stran_instr_t *stran;
	bool subtract = false;

	if (offset < 0) {
		offset = -offset;
		subtract = true;
	}

	if (offset > 4095) {
		op2.op.reg = subtilis_arm_acquire_new_reg(s);
		(void)prv_add_data_imm_ldr(s, ccode, op2.op.reg, offset, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		op2.type = SUBTILIS_ARM_OP2_REG;
	} else {
		op2.type = SUBTILIS_ARM_OP2_I32;
		op2.op.integer = offset;
	}

	instr = subtilis_arm_section_add_instr(s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	stran = &instr->operands.stran;
	stran->ccode = ccode;
	stran->dest = dest;
	stran->base = base;
	stran->offset = op2;
	stran->pre_indexed = true;
	stran->write_back = false;
	stran->byte = byte;
	stran->subtract = subtract;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebx
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %esi, %r14d
movq %rdi, %r15
movq 0x68(%rsp), %r12
movl %r9d, %r13d
negl %r13d
cmovsl %r9d, %r13d
cmpl $0x1000, %r13d          # imm = 0x1000
movl %edx, 0x14(%rsp)
jb 0x506df
movl %r14d, 0x10(%rsp)
movq (%r15), %r14
leaq 0x1(%r14), %rax
movq %rax, (%r15)
leaq -0x1(%r14), %rax
cmpq $0x3, %rax
jae 0x506eb
leaq 0x254a8(%rip), %rax     # 0x75b80
movq -0x8(%rax,%r14,8), %r14
jmp 0x506ef
movl $0x1, 0xc(%rsp)
xorl %ebp, %ebp
jmp 0x5072a
addq $0xc, %r14
movq %r15, %rdi
movl %edx, %esi
movq %r14, %rdx
movl %r13d, %ecx
movq %r12, %r8
callq 0x4fd3b
cmpl $0x0, (%r12)
jne 0x50795
movabsq $-0x100000000, %rbp     # imm = 0xFFFFFFFF00000000
andq %r14, %rbp
movl $0x0, 0xc(%rsp)
movl %r14d, %r13d
movl 0x10(%rsp), %r14d
movq %r15, %rdi
movq %r12, %rsi
callq 0x4f5b7
cmpl $0x0, (%r12)
je 0x50740
xorl %ecx, %ecx
jmp 0x50751
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl %r14d, 0x8(%rax)
cmpl $0x0, (%r12)
jne 0x50795
movb 0x60(%rsp), %al
movl 0x14(%rsp), %edx
movl %edx, 0x8(%rcx)
movq 0x18(%rsp), %rdx
movq %rdx, 0x10(%rcx)
movq 0x20(%rsp), %rdx
movq %rdx, 0x18(%rcx)
movl 0xc(%rsp), %edx
movl %edx, 0x20(%rcx)
movl %r13d, %edx
orq %rdx, %rbp
movq %rbp, 0x28(%rcx)
movw $0x1, 0x48(%rcx)
movb %al, 0x4b(%rcx)
shrl $0x1f, %ebx
movb %bl, 0x4a(%rcx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_push
void subtilis_arm_add_push(subtilis_arm_section_t *s,
			   subtilis_arm_ccode_type_t ccode, size_t reg_num,
			   subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_stran_instr_t *stran;

	instr = subtilis_arm_section_add_instr(s, SUBTILIS_ARM_INSTR_STR, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	stran = &instr->operands.stran;
	stran->ccode = ccode;
	stran->dest = reg_num;
	stran->base = 13;
	stran->offset.type = SUBTILIS_ARM_OP2_I32;
	stran->offset.op.integer = 4;
	stran->pre_indexed = true;
	stran->write_back = true;
	stran->subtract = true;
	stran->byte = false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rcx, %rsi
callq 0x4f5b7
cmpl $0x0, (%r14)
je 0x507c2
xorl %ecx, %ecx
jmp 0x507d6
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl $0x13, 0x8(%rax)
cmpl $0x0, (%r14)
jne 0x50800
movl %ebp, 0x8(%rcx)
movq %rbx, 0x10(%rcx)
movq $0xd, 0x18(%rcx)
movl $0x1, 0x20(%rcx)
movl $0x4, 0x28(%rcx)
movl $0x10101, 0x48(%rcx)    # imm = 0x10101
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_pop
void subtilis_arm_add_pop(subtilis_arm_section_t *s,
			  subtilis_arm_ccode_type_t ccode, size_t reg_num,
			  subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_stran_instr_t *stran;

	instr = subtilis_arm_section_add_instr(s, SUBTILIS_ARM_INSTR_LDR, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	stran = &instr->operands.stran;
	stran->ccode = ccode;
	stran->dest = reg_num;
	stran->base = 13;
	stran->offset.type = SUBTILIS_ARM_OP2_I32;
	stran->offset.op.integer = 4;
	stran->pre_indexed = false;
	stran->write_back = true;
	stran->subtract = false;
	stran->byte = false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rcx, %rsi
callq 0x4f5b7
cmpl $0x0, (%r14)
je 0x50823
xorl %ecx, %ecx
jmp 0x50837
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl $0x12, 0x8(%rax)
cmpl $0x0, (%r14)
jne 0x50861
movl %ebp, 0x8(%rcx)
movq %rbx, 0x10(%rcx)
movq $0xd, 0x18(%rcx)
movl $0x1, 0x20(%rcx)
movl $0x4, 0x28(%rcx)
movl $0x100, 0x48(%rcx)      # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_insert_pop
void subtilis_arm_insert_pop(subtilis_arm_section_t *s,
			     subtilis_arm_op_t *current,
			     subtilis_arm_ccode_type_t ccode, size_t reg_num,
			     subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_stran_instr_t *stran;

	instr = subtilis_arm_section_insert_instr(s, current,
						  SUBTILIS_ARM_INSTR_LDR, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	stran = &instr->operands.stran;
	stran->ccode = ccode;
	stran->dest = reg_num;
	stran->base = 13;
	stran->offset.type = SUBTILIS_ARM_OP2_I32;
	stran->offset.op.integer = 4;
	stran->pre_indexed = false;
	stran->write_back = true;
	stran->subtract = false;
	stran->byte = false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %r8, %r14
movq %rcx, %rbx
movl %edx, %ebp
movq %r8, %rdx
callq 0x4f67c
cmpl $0x0, (%r14)
je 0x508e5
xorl %ecx, %ecx
jmp 0x508f9
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl $0x12, 0x8(%rax)
cmpl $0x0, (%r14)
jne 0x50923
movl %ebp, 0x8(%rcx)
movq %rbx, 0x10(%rcx)
movq $0xd, 0x18(%rcx)
movl $0x1, 0x20(%rcx)
movl $0x4, 0x28(%rcx)
movl $0x100, 0x48(%rcx)      # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_insert_stran_spill_imm
void subtilis_arm_insert_stran_spill_imm(subtilis_arm_section_t *s,
					 subtilis_arm_op_t *current,
					 subtilis_arm_instr_type_t itype,
					 subtilis_arm_ccode_type_t ccode,
					 subtilis_arm_reg_t dest,
					 subtilis_arm_reg_t base,
					 subtilis_arm_reg_t spill_reg,
					 int32_t offset, subtilis_error_t *err)
/* clang-format on */
{
	subtilis_arm_op2_t op2;
	subtilis_arm_instr_t *instr;
	subtilis_arm_stran_instr_t *stran;

	op2.op.reg = spill_reg;
	(void)subtilis_arm_insert_data_imm_ldr(s, current, ccode, op2.op.reg,
					       offset, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	op2.type = SUBTILIS_ARM_OP2_REG;

	instr = subtilis_arm_section_insert_instr(s, current, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	stran = &instr->operands.stran;
	stran->ccode = ccode;
	stran->dest = dest;
	stran->base = base;
	stran->offset = op2;
	stran->pre_indexed = true;
	stran->write_back = false;
	stran->subtract = false;
	stran->byte = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x50(%rsp), %r12
movq 0x40(%rsp), %rcx
movl 0x48(%rsp), %r8d
movl %ebp, %edx
movq %r12, %r9
callq 0x4f9c8
cmpl $0x0, (%r12)
jne 0x509bc
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x4f67c
cmpl $0x0, (%r12)
je 0x5097e
xorl %ecx, %ecx
jmp 0x5098f
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl %r13d, 0x8(%rax)
cmpl $0x0, (%r12)
jne 0x509bc
movl %ebp, 0x8(%rcx)
movq %r14, 0x10(%rcx)
movq (%rsp), %rax
movq %rax, 0x18(%rcx)
movl $0x0, 0x20(%rcx)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rcx)
movl $0x1, 0x48(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_insert_stran_imm
void subtilis_arm_insert_stran_imm(subtilis_arm_section_t *s,
				   subtilis_arm_op_t *current,
				   subtilis_arm_instr_type_t itype,
				   subtilis_arm_ccode_type_t ccode,
				   subtilis_arm_reg_t dest,
				   subtilis_arm_reg_t base, int32_t offset,
				   subtilis_error_t *err)
{
	subtilis_arm_op2_t op2;
	subtilis_arm_instr_t *instr;
	subtilis_arm_stran_instr_t *stran;
	bool subtract = false;

	if (offset < 0) {
		offset = -offset;
		subtract = true;
	}

	if (offset > 4095) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	op2.type = SUBTILIS_ARM_OP2_I32;
	op2.op.integer = offset;

	instr = subtilis_arm_section_insert_instr(s, current, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	stran = &instr->operands.stran;
	stran->ccode = ccode;
	stran->dest = dest;
	stran->base = base;
	stran->offset = op2;
	stran->pre_indexed = true;
	stran->write_back = false;
	stran->subtract = subtract;
	stran->byte = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x48(%rsp), %r15
movl 0x40(%rsp), %ebx
movl %ebx, %r13d
negl %r13d
cmovsl %ebx, %r13d
cmpl $0x1000, %r13d          # imm = 0x1000
jb 0x50a19
leaq 0x2519f(%rip), %rdx     # 0x75b98
movq %r15, %rdi
movl $0xf, %esi
movl $0x57c, %ecx            # imm = 0x57C
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x145f4
movl %ecx, %ebp
movl %edx, %r12d
movq %r8, (%rsp)
movq %r9, %r14
movq %r15, %rdx
callq 0x4f67c
cmpl $0x0, (%r15)
je 0x50a37
xorl %ecx, %ecx
jmp 0x50a48
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl %r12d, 0x8(%rax)
cmpl $0x0, (%r15)
jne 0x50a78
movl %ebp, 0x8(%rcx)
movq (%rsp), %rax
movq %rax, 0x10(%rcx)
movq %r14, 0x18(%rcx)
movl $0x1, 0x20(%rcx)
movl %r13d, 0x28(%rcx)
movw $0x1, 0x48(%rcx)
shrl $0x1f, %ebx
movb %bl, 0x4a(%rcx)
movb $0x0, 0x4b(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_cmp_imm
void subtilis_arm_add_cmp_imm(subtilis_arm_section_t *s,
			      subtilis_arm_instr_type_t itype,
			      subtilis_arm_ccode_type_t ccode,
			      subtilis_arm_reg_t op1, int32_t op2,
			      subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *datai;
	subtilis_arm_reg_t dest;
	uint32_t encoded = 0;

	if (!subtilis_arm_encode_imm(op2, &encoded)) {
		if (subtilis_arm_encode_imm(-op2, &encoded)) {
			itype = SUBTILIS_ARM_INSTR_CMN;
		} else {
			dest = 0;
			(void)subtilis_add_data_imm_ldr_datai(
			    s, itype, ccode, true, dest, op1, op2, err);
			return;
		}
	}

	instr = subtilis_arm_section_add_instr(s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	datai = &instr->operands.data;
	datai->ccode = ccode;
	datai->op1 = op1;
	datai->op2.type = SUBTILIS_ARM_OP2_I32;
	datai->op2.op.integer = encoded;
	datai->status = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movl %r8d, %r15d
movq %rcx, 0x10(%rsp)
movl %edx, %ebp
movl %esi, %r13d
movq %rdi, %r12
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
movl %r8d, %edi
callq 0x4f8d1
testb %al, %al
je 0x50ac4
movl %r13d, %ebx
jmp 0x50adc
movl %r15d, %edi
negl %edi
leaq 0xc(%rsp), %rsi
callq 0x4f8d1
movl $0xb, %ebx
testb %al, %al
je 0x50b2b
movq %r12, %rdi
movq %r14, %rsi
callq 0x4f5b7
cmpl $0x0, (%r14)
je 0x50af1
xorl %ecx, %ecx
jmp 0x50b01
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl %ebx, 0x8(%rax)
cmpl $0x0, (%r14)
jne 0x50b25
movl %ebp, 0x8(%rcx)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rcx)
movl $0x1, 0x20(%rcx)
movl 0xc(%rsp), %eax
movl %eax, 0x28(%rcx)
movb $0x1, 0xc(%rcx)
addq $0x18, %rsp
jmp 0x50b4d
movq %r12, %rdi
movl %r13d, %esi
movl %ebp, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
movq 0x10(%rsp), %r9
pushq %r14
pushq %r15
callq 0x4fc61
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_cmp
void subtilis_arm_add_cmp(subtilis_arm_section_t *s,
			  subtilis_arm_instr_type_t itype,
			  subtilis_arm_ccode_type_t ccode,
			  subtilis_arm_reg_t op1, subtilis_arm_reg_t op2,
			  subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *datai;

	instr = subtilis_arm_section_add_instr(s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	datai = &instr->operands.data;
	datai->ccode = ccode;
	datai->op1 = op1;
	datai->op2.type = SUBTILIS_ARM_OP2_REG;
	datai->op2.op.reg = op2;
	datai->status = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %r15
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r12d
movq %r9, %rsi
callq 0x4f5b7
cmpl $0x0, (%r15)
je 0x50b80
xorl %ecx, %ecx
jmp 0x50b91
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl %r12d, 0x8(%rax)
cmpl $0x0, (%r15)
jne 0x50bad
movl %ebp, 0x8(%rcx)
movq %r14, 0x18(%rcx)
movl $0x0, 0x20(%rcx)
movq %rbx, 0x28(%rcx)
movb $0x1, 0xc(%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_mtran
void subtilis_arm_add_mtran(subtilis_arm_section_t *s,
			    subtilis_arm_instr_type_t itype,
			    subtilis_arm_ccode_type_t ccode,
			    subtilis_arm_reg_t op0, size_t reg_list,
			    subtilis_arm_mtran_type_t type, bool write_back,
			    bool status, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_mtran_instr_t *mtran;

	instr = subtilis_arm_section_add_instr(s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	mtran = &instr->operands.mtran;
	mtran->ccode = ccode;
	mtran->op0 = op0;
	mtran->reg_list = reg_list;
	mtran->type = type;
	mtran->write_back = write_back;
	mtran->status = status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r13d
movq 0x50(%rsp), %r12
movq %r12, %rsi
callq 0x4f5b7
cmpl $0x0, (%r12)
je 0x50be7
xorl %ecx, %ecx
jmp 0x50bf8
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl %r13d, 0x8(%rax)
cmpl $0x0, (%r12)
jne 0x50c1b
movb 0x48(%rsp), %al
movb 0x40(%rsp), %dl
movl %ebp, 0x8(%rcx)
movq %r15, 0x10(%rcx)
movq %r14, 0x18(%rcx)
movl %ebx, 0x20(%rcx)
movb %dl, 0x24(%rcx)
movb %al, 0x25(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_byte
void subtilis_arm_add_byte(subtilis_arm_section_t *s, uint8_t byte,
			   subtilis_error_t *err)
{
	subtilis_arm_op_t *op;

	op = prv_append_op(s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	op->type = SUBTILIS_ARM_OP_BYTE;
	op->op.byte = byte;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdx, %rsi
callq 0x4f5b7
cmpl $0x0, (%r14)
jne 0x50c4a
movl $0x2, (%rax)
movb %bl, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_two_bytes
void subtilis_arm_add_two_bytes(subtilis_arm_section_t *s, uint16_t two_bytes,
				subtilis_error_t *err)
{
	subtilis_arm_op_t *op;

	op = prv_append_op(s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	op->type = SUBTILIS_ARM_OP_TWO_BYTE;
	op->op.two_bytes = two_bytes;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdx, %rsi
callq 0x4f5b7
cmpl $0x0, (%r14)
jne 0x50c73
movl $0x3, (%rax)
movw %bx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_four_bytes
void subtilis_arm_add_four_bytes(subtilis_arm_section_t *s, uint32_t four_bytes,
				 subtilis_error_t *err)
{
	subtilis_arm_op_t *op;

	op = prv_append_op(s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	op->type = SUBTILIS_ARM_OP_FOUR_BYTE;
	op->op.four_bytes = four_bytes;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdx, %rsi
callq 0x4f5b7
cmpl $0x0, (%r14)
jne 0x50c9b
movl $0x4, (%rax)
movl %ebx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_double
void subtilis_arm_add_double(subtilis_arm_section_t *s, double dbl,
			     subtilis_error_t *err)
{
	subtilis_arm_op_t *op;

	op = prv_append_op(s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	op->type = SUBTILIS_ARM_OP_DOUBLE;
	op->op.dbl = dbl;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movsd %xmm0, 0x8(%rsp)
callq 0x4f5b7
cmpl $0x0, (%rbx)
jne 0x50ccc
movl $0x5, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_doubler
void subtilis_arm_add_doubler(subtilis_arm_section_t *s, double dbl,
			      subtilis_error_t *err)
{
	subtilis_arm_op_t *op;

	op = prv_append_op(s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	op->type = SUBTILIS_ARM_OP_DOUBLER;
	op->op.dbl = dbl;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movsd %xmm0, 0x8(%rsp)
callq 0x4f5b7
cmpl $0x0, (%rbx)
jne 0x50cfb
movl $0x6, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_float
void subtilis_arm_add_float(subtilis_arm_section_t *s, float f,
			    subtilis_error_t *err)
{
	subtilis_arm_op_t *op;

	op = prv_append_op(s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	op->type = SUBTILIS_ARM_OP_FLOAT;
	op->op.flt = f;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movss %xmm0, 0xc(%rsp)
callq 0x4f5b7
cmpl $0x0, (%rbx)
jne 0x50d2a
movl $0x7, (%rax)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_string
void subtilis_arm_add_string(subtilis_arm_section_t *s, const char *str,
			     subtilis_error_t *err)
{
	subtilis_arm_op_t *op;

	op = prv_append_op(s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	op->type = SUBTILIS_ARM_OP_STRING;
	op->op.str = malloc(strlen(str) + 1);
	if (!op->op.str) {
		subtilis_error_set_oom(err);
		return;
	}
	strcpy(op->op.str, str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdx, %rsi
callq 0x4f5b7
cmpl $0x0, (%r14)
je 0x50d4f
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movl $0x8, (%rax)
movq %rbx, %rdi
callq 0x120f0
leaq 0x1(%rax), %rdi
callq 0x121d0
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x50d82
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x12070
leaq 0x24e0f(%rip), %rdx     # 0x75b98
movq %r14, %rdi
movl $0x1, %esi
movl $0x638, %ecx            # imm = 0x638
popq %rbx
popq %r14
popq %r15
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_align
void subtilis_arm_add_align(subtilis_arm_section_t *s, uint32_t align,
			    subtilis_error_t *err)
{
	subtilis_arm_op_t *op;

	op = prv_append_op(s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	op->type = SUBTILIS_ARM_OP_ALIGN;
	op->op.alignment = align;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdx, %rsi
callq 0x4f5b7
cmpl $0x0, (%r14)
jne 0x50dc0
movl $0x9, (%rax)
movl %ebx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_restore_stack
void subtilis_arm_restore_stack(subtilis_arm_section_t *arm_s,
				size_t stack_space, subtilis_error_t *err)
{
	size_t i;
	size_t rs;
	subtilis_arm_data_instr_t *datai;

	for (i = 0; i < arm_s->ret_site_count; i++) {
		rs = arm_s->ret_sites[i];
		datai = &arm_s->op_pool->ops[rs].op.instr.operands.data;
		datai->op2.op.integer = stack_space;
	}
}

// Assembly:
cmpq $0x0, 0x88(%rdi)
je 0x50df7
xorl %eax, %eax
movq 0x38(%rdi), %rcx
movq 0x98(%rdi), %rdx
movq (%rcx), %rcx
imulq $0x68, (%rdx,%rax,8), %rdx
movl %esi, 0x30(%rcx,%rdx)
incq %rax
cmpq 0x88(%rdi), %rax
jb 0x50dd4
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_real_constant
void subtilis_arm_add_real_constant(subtilis_arm_section_t *s, size_t label,
				    double num, subtilis_error_t *err)
{
	subtilis_arm_real_constant_t *c;
	subtilis_arm_real_constant_t *new_constants;
	size_t new_max;

	if (s->constants.real_count == s->constants.max_real) {
		new_max = s->constants.max_real + 64;
		new_constants =
		    realloc(s->constants.real,
			    new_max * sizeof(subtilis_arm_real_constant_t));
		if (!new_constants) {
			subtilis_error_set_oom(err);
			return;
		}
		s->constants.max_real = new_max;
		s->constants.real = new_constants;
	}
	c = &s->constants.real[s->constants.real_count++];
	c->real = num;
	c->label = label;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x80(%rdi), %r12
cmpq %r12, 0x78(%rdi)
jne 0x50e44
movq %rdx, %r15
movsd %xmm0, (%rsp)
addq $0x40, %r12
movq 0x70(%r14), %rdi
movq %r12, %rsi
shlq $0x4, %rsi
callq 0x12210
testq %rax, %rax
je 0x50e6e
movq %r12, 0x80(%r14)
movq %rax, 0x70(%r14)
movsd (%rsp), %xmm0
movq 0x70(%r14), %rax
movq 0x78(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x78(%r14)
shlq $0x4, %rcx
movsd %xmm0, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x24d23(%rip), %rdx     # 0x75b98
movq %r15, %rdi
movl $0x1, %esi
movl $0x666, %ecx            # imm = 0x666
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_flags
void subtilis_arm_add_flags(subtilis_arm_section_t *s,
			    subtilis_arm_instr_type_t itype,
			    subtilis_arm_ccode_type_t ccode,
			    subtilis_arm_flags_t flag_reg, uint32_t fields,
			    subtilis_arm_reg_t reg, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_flags_instr_t *flags;

	instr = subtilis_arm_section_add_instr(s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	flags = &instr->operands.flags;
	flags->ccode = ccode;
	flags->flag_reg = flag_reg;
	flags->fields = fields;
	flags->op2_reg = true;
	flags->op.reg = reg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r13d
movq 0x40(%rsp), %r12
movq %r12, %rsi
callq 0x4f5b7
cmpl $0x0, (%r12)
je 0x50ec4
xorl %ecx, %ecx
jmp 0x50ed5
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl %r13d, 0x8(%rax)
cmpl $0x0, (%r12)
jne 0x50eef
movl %r15d, 0x8(%rcx)
movl %r14d, 0xc(%rcx)
movl %ebp, 0x10(%rcx)
movb $0x1, 0x14(%rcx)
movq %rbx, 0x18(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_flags_imm
void subtilis_arm_add_flags_imm(subtilis_arm_section_t *s,
				subtilis_arm_instr_type_t itype,
				subtilis_arm_ccode_type_t ccode,
				subtilis_arm_flags_t flag_reg, uint32_t fields,
				int32_t imm, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_flags_instr_t *flags;
	uint32_t encoded;
	subtilis_arm_reg_t mov_dest;

	instr = subtilis_arm_section_add_instr(s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	flags = &instr->operands.flags;
	flags->ccode = ccode;
	flags->flag_reg = flag_reg;
	flags->fields = fields;

	if (!subtilis_arm_encode_imm(imm, &encoded)) {
		mov_dest = subtilis_arm_acquire_new_reg(s);
		subtilis_arm_add_mov_imm(s, ccode, false, mov_dest, imm, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		flags->op2_reg = true;
		flags->op.reg = mov_dest;
	} else {
		flags->op2_reg = false;
		flags->op.integer = encoded;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movl %r8d, %r12d
movl %ecx, %r13d
movl %edx, 0x8(%rsp)
movl %esi, %ebx
movq %rdi, %r15
movq 0x50(%rsp), %r14
movq %r14, %rsi
callq 0x4f5b7
cmpl $0x0, (%r14)
je 0x50f37
xorl %ebp, %ebp
jmp 0x50f47
movl $0x0, (%rax)
movq %rax, %rbp
addq $0x8, %rbp
movl %ebx, 0x8(%rax)
cmpl $0x0, (%r14)
jne 0x50fdb
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rbp)
movl %r13d, 0xc(%rbp)
movl %r12d, 0x10(%rbp)
leaq 0xc(%rsp), %rsi
movq 0x10(%rsp), %rbx
movl %ebx, %edi
callq 0x4f8d1
testb %al, %al
je 0x50f82
movb $0x0, 0x14(%rbp)
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rbp)
jmp 0x50fdb
movq (%r15), %r12
leaq 0x1(%r12), %rax
movq %rax, (%r15)
leaq -0x1(%r12), %rax
cmpq $0x3, %rax
jae 0x50fa6
leaq 0x24be1(%rip), %rax     # 0x75b80
movq -0x8(%rax,%r12,8), %r12
jmp 0x50faa
addq $0xc, %r12
movq %r15, %rdi
movl $0xd, %esi
movl $0xf, %edx
movl 0x8(%rsp), %ecx
xorl %r8d, %r8d
movq %r12, %r9
pushq %r14
pushq %rbx
callq 0x50249
addq $0x10, %rsp
cmpl $0x0, (%r14)
jne 0x50fdb
movb $0x1, 0x14(%rbp)
movq %r12, 0x18(%rbp)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_reg_only
void subtilis_arm_add_reg_only(subtilis_arm_section_t *s,
			       subtilis_arm_instr_type_t itype,
			       subtilis_arm_ccode_type_t ccode,
			       subtilis_arm_reg_t dest, subtilis_arm_reg_t op1,
			       subtilis_arm_reg_t op2, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_reg_only_instr_t *reg_only;

	instr = subtilis_arm_section_add_instr(s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	reg_only = &instr->operands.reg_only;
	reg_only->ccode = ccode;
	reg_only->dest = dest;
	reg_only->op1 = op1;
	reg_only->op2 = op2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r13d
movq 0x40(%rsp), %r12
movq %r12, %rsi
callq 0x4f5b7
cmpl $0x0, (%r12)
je 0x5101b
xorl %ecx, %ecx
jmp 0x5102c
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl %r13d, 0x8(%rax)
cmpl $0x0, (%r12)
jne 0x51042
movl %ebp, 0x8(%rcx)
movq %r15, 0x10(%rcx)
movq %r14, 0x18(%rcx)
movq %rbx, 0x20(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_signx
void subtilis_arm_add_signx(subtilis_arm_section_t *s,
			    subtilis_arm_instr_type_t itype,
			    subtilis_arm_ccode_type_t ccode,
			    subtilis_arm_reg_t dest, subtilis_arm_reg_t op1,
			    subtilis_arm_signx_rotate_t rotate,
			    subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_signx_instr_t *signx;

	instr = subtilis_arm_section_add_instr(s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	signx = &instr->operands.signx;
	signx->ccode = ccode;
	signx->dest = dest;
	signx->op1 = op1;
	signx->rotate = rotate;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r13d
movq 0x40(%rsp), %r12
movq %r12, %rsi
callq 0x4f5b7
cmpl $0x0, (%r12)
je 0x51082
xorl %ecx, %ecx
jmp 0x51093
movl $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl %r13d, 0x8(%rax)
cmpl $0x0, (%r12)
jne 0x510a8
movl %ebp, 0x8(%rcx)
movq %r15, 0x10(%rcx)
movq %r14, 0x18(%rcx)
movl %ebx, 0xc(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_mov
void subtilis_arm_gen_mov(subtilis_ir_section_t *s, size_t start,
			  void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	subtilis_arm_reg_t op2;

	dest = subtilis_arm_ir_to_arm_reg(instr->operands[0].reg);
	op2 = subtilis_arm_ir_to_arm_reg(instr->operands[1].reg);

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, dest, op2,
				 err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movq 0x10(%r12), %rdi
callq 0x4eff7
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4eff7
movq %rbx, (%rsp)
movq %r14, %rdi
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movq %r15, %r8
movq %rax, %r9
callq 0x5060d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_movii32
void subtilis_arm_gen_movii32(subtilis_ir_section_t *s, size_t start,
			      void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	int32_t op2 = instr->operands[1].integer;

	dest = subtilis_arm_ir_to_arm_reg(instr->operands[0].reg);

	subtilis_arm_add_mov_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, dest, op2,
				 err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %rax
movl 0x18(%rax), %r15d
movq 0x10(%rax), %rdi
callq 0x4eff7
movq %r14, %rdi
movl $0xd, %esi
movl $0xf, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
movq %rax, %r9
pushq %rbx
pushq %r15
callq 0x50249
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_addii32
void subtilis_arm_gen_addii32(subtilis_ir_section_t *s, size_t start,
			      void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	int32_t op2 = instr->operands[2].integer;

	dest = subtilis_arm_ir_to_arm_reg(instr->operands[0].reg);
	op1 = subtilis_arm_ir_to_arm_reg(instr->operands[1].reg);

	subtilis_arm_add_add_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, dest, op1,
				 op2, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movl 0x20(%r12), %r13d
movq 0x10(%r12), %rdi
callq 0x4eff7
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4eff7
subq $0x8, %rsp
movq %r14, %rdi
movl $0x4, %esi
movl $0x2, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
movq %r15, %r9
pushq %rbx
pushq %r13
pushq %rax
callq 0x4fe13
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_subii32
void subtilis_arm_gen_subii32(subtilis_ir_section_t *s, size_t start,
			      void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	int32_t op2 = instr->operands[2].integer;

	dest = subtilis_arm_ir_to_arm_reg(instr->operands[0].reg);
	op1 = subtilis_arm_ir_to_arm_reg(instr->operands[1].reg);

	subtilis_arm_add_sub_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, dest, op1,
				 op2, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movl 0x20(%r12), %r13d
movq 0x10(%r12), %rdi
callq 0x4eff7
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4eff7
subq $0x8, %rsp
movq %r14, %rdi
movl $0x2, %esi
movl $0x4, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
movq %r15, %r9
pushq %rbx
pushq %r13
pushq %rax
callq 0x4fe13
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq