LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_add_data_imm_ldr_datai
size_t subtilis_add_data_imm_ldr_datai(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_data_instr_t *datai;
	subtilis_arm_instr_t *instr;
	subtilis_arm_reg_t ldr_dest;
	size_t label;

	ldr_dest = subtilis_arm_acquire_new_reg(s);

	label = prv_add_data_imm_ldr(s, ccode, ldr_dest, op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return 0;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movl %ecx, %r14d
movl %edx, %ebp
movl %esi, 0x4(%rsp)
movq %rdi, %r15
movq 0x58(%rsp), %rbx
movl 0x50(%rsp), %r12d
callq 0x4c202
movq %rax, %r13
movq %r15, %rdi
movl %ebp, %esi
movq %rax, %rdx
movl %r12d, %ecx
movq %rbx, %r8
callq 0x4ce48
cmpl $0x0, (%rbx)
jne 0x4ce10
movq %rax, %r12
movq %r15, %rdi
movl 0x4(%rsp), %esi
movq %rbx, %rdx
callq 0x4c92b
cmpl $0x0, (%rbx)
je 0x4ce25
xorl %r12d, %r12d
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb %r14b, 0xc(%rax)
andl $0x0, 0x20(%rax)
movl %ebp, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %r13, 0x28(%rax)
jmp 0x4ce13
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x8
popq %rax
subq $0x1, %rdx
jb 0x4ce78
movq 0x58(%r15), %rsi
cmpl %ecx, -0x8(%rsi,%rax)
je 0x4ce9f
addq $0x18, %rax
jmp 0x4ce62
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 0x4cc02
cmpl $0x0, (%r14)
jne 0x4ceb7
jmp 0x4cea3
movq (%rsi,%rax), %r12
pushq $0x18
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
je 0x4cebc
xorl %r12d, %r12d
jmp 0x4cecb
movl %ebp, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r12, 0x18(%rax)
movb $0x0, 0x20(%rax)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_rsub_imm
void subtilis_arm_add_rsub_imm(subtilis_arm_section_t *s,
			       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;
	bool can_encode;
	uint32_t encoded;
	subtilis_arm_reg_t neg_dest;
	subtilis_arm_instr_type_t itype = SUBTILIS_ARM_INSTR_RSB;

	can_encode = subtilis_arm_encode_imm(op2, &encoded);
	if ((!can_encode) && (op2 < 0) &&
	    !(status && (ccode != SUBTILIS_ARM_CCODE_AL))) {
		can_encode = subtilis_arm_encode_imm(-op2, &encoded);
		if (can_encode) {
			neg_dest = subtilis_arm_acquire_new_reg(s);
			subtilis_arm_add_rsub_imm(s, ccode, false, neg_dest,
						  op1, 0, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
			op1 = neg_dest;
			op2 = -op2;
			itype = SUBTILIS_ARM_INSTR_SUB;
		}
	}

	if (!can_encode) {
		(void)subtilis_add_data_imm_ldr_datai(s, itype, ccode, status,
						      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->status = status;
	datai->op2.type = SUBTILIS_ARM_OP2_I32;
	datai->ccode = ccode;
	datai->dest = dest;
	datai->op1 = op1;
	datai->op2.op.integer = encoded;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r12d
movq %r8, %r14
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r13
leaq 0x4(%rsp), %rsi
movl %r9d, %edi
callq 0x4caab
testl %r12d, %r12d
setns %cl
cmpl $0xe, %ebp
setne %dl
andb %r15b, %dl
orb %al, %cl
orb %dl, %cl
je 0x4d0a6
testb %al, %al
je 0x4d12c
pushq $0x3
popq %rsi
jmp 0x4d0f2
movl %r12d, %edi
negl %edi
leaq 0x4(%rsp), %rsi
callq 0x4caab
testb %al, %al
je 0x4d12c
movq %r13, %rdi
callq 0x4c202
movq %rax, %r12
subq $0x8, %rsp
movq %r13, %rdi
movl %ebp, %esi
xorl %edx, %edx
movq %rax, %rcx
movq %r14, %r8
xorl %r9d, %r9d
movq 0x48(%rsp), %r14
pushq %r14
callq 0x4d05b
popq %rax
popq %rcx
cmpl $0x0, (%r14)
jne 0x4d126
pushq $0x2
popq %rsi
movq %r12, %r14
movq %r13, %rdi
movq 0x40(%rsp), %r12
movq %r12, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x4d126
movb %r15b, 0xc(%rax)
movl $0x1, 0x20(%rax)
movl %ebp, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r14, 0x18(%rax)
movl 0x4(%rsp), %ecx
movl %ecx, 0x28(%rax)
addq $0x8, %rsp
jmp 0x4d14d
movzbl %r15b, %ecx
pushq $0x3
popq %rsi
movq %r13, %rdi
movl %ebp, %edx
movq %rbx, %r8
movq %r14, %r9
pushq 0x40(%rsp)
pushq %r12
callq 0x4cdab
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq 0x50(%rsp), %r12
cmpq %rcx, %r8
jne 0x4d195
leaq 0x229f1(%rip), %rdx     # 0x6fb68
pushq $0xf
popq %rsi
movq %r12, %rdi
movl $0x3f3, %ecx            # imm = 0x3F3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1429e
movl %r9d, %r13d
movq %r8, %rbx
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl %edx, 0xc(%rsp)
callq 0x4c202
pushq $0xd
popq %rsi
pushq $0xf
popq %rdx
movq %r15, %rdi
movl %ebp, %ecx
xorl %r8d, %r8d
movq %rax, 0x10(%rsp)
movq %rax, %r9
pushq %r12
pushq %r13
callq 0x4d213
popq %rax
popq %rcx
cmpl $0x0, (%r12)
jne 0x4d204
pushq $0x10
popq %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x4d204
movl 0xc(%rsp), %ecx
movb %cl, 0xc(%rax)
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x20(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14d
movq %rdi, %r12
movq 0x58(%rsp), %r15
movl 0x50(%rsp), %r13d
leaq 0x8(%rsp), %rsi
andl $0x0, (%rsi)
movl %r13d, %edi
callq 0x4caab
testb %al, %al
jne 0x4d269
movl %r13d, %edi
notl %edi
leaq 0x8(%rsp), %rsi
callq 0x4caab
movl %ebx, %r14d
testb %al, %al
je 0x4d2ad
movq %r12, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x4c92b
cmpl $0x0, (%r15)
jne 0x4d29e
movl 0xc(%rsp), %ecx
movb %cl, 0xc(%rax)
movl $0x1, 0x20(%rax)
movl %ebp, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl 0x8(%rsp), %ecx
movl %ecx, 0x28(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movl %ebp, %esi
movq 0x10(%rsp), %rdx
movl %r13d, %ecx
movq %r15, %r8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4ce48
// File: /workspace/github_c_makefile_star2_O2/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 0x4d31d
movq %r14, %r13
cmpq %rbx, %r14
jne 0x4d323
leaq 0x22869(%rip), %rdx     # 0x6fb68
pushq $0xf
popq %rsi
movq %r12, %rdi
movl $0x415, %ecx            # imm = 0x415
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1429e
movq %rbx, %r13
movq %r8, %rbx
pushq $0x10
popq %rsi
movq %r12, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x4d348
movb %r15b, 0xc(%rax)
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %r13, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r13d
movq %rdi, %rbx
movq 0x68(%rsp), %r12
movl 0x60(%rsp), %r15d
leaq 0x14(%rsp), %rsi
movl %r15d, %edi
callq 0x4caab
testb %al, %al
je 0x4d3a7
pushq $0x1
popq %rax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %r14d
xorl %r15d, %r15d
jmp 0x4d3ea
movq %rbx, %rdi
callq 0x4c202
movq %rax, %r14
pushq $0xd
popq %rsi
pushq $0xf
popq %rdx
movl $0x0, 0xc(%rsp)
movq %rbx, %rdi
movl %ebp, %ecx
xorl %r8d, %r8d
movq %rax, %r9
pushq %r12
pushq %r15
callq 0x4d213
popq %rax
popq %rcx
cmpl $0x0, (%r12)
jne 0x4d42c
movabsq $-0x100000000, %r15     # imm = 0xFFFFFFFF00000000
andq %r14, %r15
movq %rbx, %rdi
movl %r13d, %esi
movq %r12, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x4d42c
movl 0x10(%rsp), %ecx
movb %cl, 0xc(%rax)
movl %ebp, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rax)
movl 0xc(%rsp), %ecx
movl %ecx, 0x20(%rax)
movl %r14d, %ecx
orq %rcx, %r15
movq %r15, 0x28(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1a
popq %rsi
movq %r9, %rdx
callq 0x4c92b
cmpl $0x0, (%r13)
jne 0x4d479
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movb $0x0, 0x28(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1a
popq %rsi
movq %r13, %rdx
callq 0x4c92b
cmpl $0x0, (%r13)
jne 0x4d4ca
movq %r12, 0x8(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movb $0x1, 0x28(%rax)
movl %ebp, 0x2c(%rax)
movl %ebx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x17
popq %rsi
movq %r9, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x4d50f
movl %r15d, 0x8(%rax)
movq %r14, 0x10(%rax)
movl %ebp, 0x18(%rax)
movl %ebx, 0x1c(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %r15d
movl %edx, %ebp
movq 0x30(%rsp), %r12
movq %r12, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x4d552
movb %r15b, 0xc(%rax)
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
andl $0x0, 0x20(%rax)
movq %rbx, 0x28(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15d
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdi, %r14
movq 0x68(%rsp), %r13
movl %r9d, %ebx
negl %ebx
cmovsl %r9d, %ebx
cmpl $0x1000, %ebx           # imm = 0x1000
movl %edx, 0x14(%rsp)
jb 0x4d5dc
movl %edx, %r12d
movl %esi, 0x10(%rsp)
movq %r14, %rdi
callq 0x4c202
movq %rax, %rbp
movq %r14, %rdi
movl %r12d, %esi
movq %rax, %rdx
movl %ebx, %ecx
movq %r13, %r8
callq 0x4ce48
cmpl $0x0, (%r13)
jne 0x4d636
movabsq $-0x100000000, %r12     # imm = 0xFFFFFFFF00000000
andq %rbp, %r12
movl $0x0, 0xc(%rsp)
movl %ebp, %ebx
movl 0x10(%rsp), %esi
jmp 0x4d5e6
pushq $0x1
popq %rax
movl %eax, 0xc(%rsp)
xorl %r12d, %r12d
movq %r14, %rdi
movq %r13, %rdx
callq 0x4c92b
cmpl $0x0, (%r13)
jne 0x4d636
movb 0x60(%rsp), %cl
movl 0x14(%rsp), %edx
movl %edx, 0x8(%rax)
movq 0x18(%rsp), %rdx
movq %rdx, 0x10(%rax)
movq 0x20(%rsp), %rdx
movq %rdx, 0x18(%rax)
movl 0xc(%rsp), %edx
movl %edx, 0x20(%rax)
movl %ebx, %edx
orq %rdx, %r12
movq %r12, 0x28(%rax)
movw $0x1, 0x48(%rax)
movb %cl, 0x4b(%rax)
shrl $0x1f, %r15d
movb %r15b, 0x4a(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x13
popq %rsi
movq %rcx, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x4d686
movl %ebp, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq $0xd, 0x18(%rax)
movl $0x1, 0x20(%rax)
movl $0x4, 0x28(%rax)
movl $0x10101, 0x48(%rax)    # imm = 0x10101
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x12
popq %rsi
movq %rcx, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x4d6cc
movl %ebp, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq $0xd, 0x18(%rax)
movl $0x1, 0x20(%rax)
movl $0x4, 0x28(%rax)
movl $0x100, 0x48(%rax)      # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x12
popq %rdx
movq %r8, %rcx
callq 0x4c95b
cmpl $0x0, (%r14)
jne 0x4d758
movl %ebp, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq $0xd, 0x18(%rax)
movl $0x1, 0x20(%rax)
movl $0x4, 0x28(%rax)
movl $0x100, 0x48(%rax)      # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4cb8b
cmpl $0x0, (%r12)
jne 0x4d7d5
movq %r15, %rdi
movq %rbx, %rsi
movl %r13d, %edx
movq %r12, %rcx
callq 0x4c95b
cmpl $0x0, (%r12)
jne 0x4d7d5
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq (%rsp), %rcx
movq %rcx, 0x18(%rax)
andl $0x0, 0x20(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x28(%rax)
movl $0x1, 0x48(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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), %r12d
movl %r12d, %r13d
negl %r13d
cmovsl %r12d, %r13d
cmpl $0x1000, %r13d          # imm = 0x1000
jb 0x4d831
leaq 0x22355(%rip), %rdx     # 0x6fb68
pushq $0xf
popq %rsi
movq %r15, %rdi
movl $0x57c, %ecx            # imm = 0x57C
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1429e
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movq %r15, %rcx
callq 0x4c95b
cmpl $0x0, (%r15)
jne 0x4d86f
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movl $0x1, 0x20(%rax)
movl %r13d, 0x28(%rax)
movw $0x1, 0x48(%rax)
shrl $0x1f, %r12d
movb %r12b, 0x4a(%rax)
movb $0x0, 0x4b(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %r9, %r14
movl %r8d, %r15d
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r13
leaq 0x4(%rsp), %rsi
andl $0x0, (%rsi)
movl %r8d, %edi
callq 0x4caab
testb %al, %al
jne 0x4d8c5
movl %r15d, %edi
negl %edi
leaq 0x4(%rsp), %rsi
callq 0x4caab
testb %al, %al
je 0x4d8f8
pushq $0xb
popq %r12
movq %r13, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x4d8f2
movl %ebp, 0x8(%rax)
movq %rbx, 0x18(%rax)
movl $0x1, 0x20(%rax)
movl 0x4(%rsp), %ecx
movl %ecx, 0x28(%rax)
movb $0x1, 0xc(%rax)
addq $0x8, %rsp
jmp 0x4d916
pushq $0x1
popq %rcx
movq %r13, %rdi
movl %r12d, %esi
movl %ebp, %edx
xorl %r8d, %r8d
movq %rbx, %r9
pushq %r14
pushq %r15
callq 0x4cdab
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %r9, %r15
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %r9, %rdx
callq 0x4c92b
cmpl $0x0, (%r15)
jne 0x4d954
movl %ebp, 0x8(%rax)
movq %r14, 0x18(%rax)
andl $0x0, 0x20(%rax)
movq %rbx, 0x28(%rax)
movb $0x1, 0xc(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movq 0x40(%rsp), %r12
movq %r12, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x4d9a2
movb 0x38(%rsp), %cl
movb 0x30(%rsp), %dl
movl %ebp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movl %ebx, 0x20(%rax)
movb %dl, 0x24(%rax)
movb %cl, 0x25(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4c7af
cmpl $0x0, (%r14)
jne 0x4d9cb
movl $0x2, (%rax)
movb %bl, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4c7af
cmpl $0x0, (%r14)
jne 0x4d9f4
movl $0x3, (%rax)
movw %bx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4c7af
cmpl $0x0, (%r14)
jne 0x4da1c
movl $0x4, (%rax)
movl %ebx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4c7af
cmpl $0x0, (%rbx)
jne 0x4da4d
movl $0x5, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4c7af
cmpl $0x0, (%rbx)
jne 0x4da7c
movl $0x6, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4c7af
cmpl $0x0, (%rbx)
jne 0x4daab
movl $0x7, (%rax)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rsi, %r14
movq %rdx, %rsi
callq 0x4c7af
cmpl $0x0, (%rbx)
je 0x4dacf
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movl $0x8, (%rax)
movq %r14, %rdi
callq 0x120f0
leaq 0x1(%rax), %rdi
callq 0x121d0
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x4db02
movq %rax, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x12070
leaq 0x2205f(%rip), %rdx     # 0x6fb68
pushq $0x1
popq %rsi
movq %rbx, %rdi
movl $0x638, %ecx            # imm = 0x638
popq %rbx
popq %r14
popq %r15
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 0x4c7af
cmpl $0x0, (%r14)
jne 0x4db3e
movl $0x9, (%rax)
movl %ebx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x78(%rdi), %r12
cmpq 0x80(%rdi), %r12
jne 0x4dbc0
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 0x4dbe8
movq %r12, 0x80(%r14)
movq %rax, 0x70(%r14)
movq 0x78(%r14), %r12
movsd (%rsp), %xmm0
jmp 0x4dbc4
movq 0x70(%r14), %rax
leaq 0x1(%r12), %rcx
movq %rcx, 0x78(%r14)
shlq $0x4, %r12
movsd %xmm0, (%rax,%r12)
movq %rbx, 0x8(%rax,%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x21f79(%rip), %rdx     # 0x6fb68
pushq $0x1
popq %rsi
movq %r15, %rdi
movl $0x666, %ecx            # imm = 0x666
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movq 0x30(%rsp), %r12
movq %r12, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x4dc45
movl %r15d, 0x8(%rax)
movl %r14d, 0xc(%rax)
movl %ebp, 0x10(%rax)
movb $0x1, 0x14(%rax)
movq %rbx, 0x18(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movl %r9d, %r15d
movl %r8d, %r13d
movl %ecx, %r14d
movl %edx, %ebp
movq %rdi, %r12
movq 0x40(%rsp), %rbx
movq %rbx, %rdx
callq 0x4c92b
cmpl $0x0, (%rbx)
jne 0x4dce2
movq %rax, %rbx
movl %ebp, 0x8(%rax)
movl %r14d, 0xc(%rax)
movl %r13d, 0x10(%rax)
leaq 0x4(%rsp), %rsi
movq %r15, %r14
movl %r14d, %edi
callq 0x4caab
testb %al, %al
je 0x4dca8
movb $0x0, 0x14(%rbx)
movl 0x4(%rsp), %eax
movl %eax, 0x18(%rbx)
jmp 0x4dce2
movq %r12, %rdi
callq 0x4c202
movq %rax, %r13
pushq $0xd
popq %rsi
pushq $0xf
popq %rdx
movq %r12, %rdi
movl %ebp, %ecx
xorl %r8d, %r8d
movq %rax, %r9
movq 0x40(%rsp), %r15
pushq %r15
pushq %r14
callq 0x4d213
popq %rax
popq %rcx
cmpl $0x0, (%r15)
jne 0x4dce2
movb $0x1, 0x14(%rbx)
movq %r13, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movq 0x30(%rsp), %r12
movq %r12, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x4dd27
movl %ebp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movq 0x30(%rsp), %r12
movq %r12, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x4dd65
movl %ebp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movl %ebx, 0xc(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x4c214
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4c214
movq %rbx, (%rsp)
pushq $0xd
popq %rsi
pushq $0xe
popq %rdx
movq %r14, %rdi
xorl %ecx, %ecx
movq %r15, %r8
movq %rax, %r9
callq 0x4d518
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4c214
pushq $0xd
popq %rsi
pushq $0xf
popq %rdx
pushq $0xe
popq %rcx
movq %r14, %rdi
xorl %r8d, %r8d
movq %rax, %r9
pushq %rbx
pushq %r15
callq 0x4d213
popq %rax
popq %rcx
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4c214
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4c214
subq $0x8, %rsp
pushq $0x4
popq %rsi
pushq $0x2
popq %rdx
pushq $0xe
popq %rcx
movq %r14, %rdi
xorl %r8d, %r8d
movq %r15, %r9
pushq %rbx
pushq %r13
pushq %rax
callq 0x4ced7
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4c214
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4c214
subq $0x8, %rsp
pushq $0x2
popq %rsi
pushq $0x4
popq %rdx
pushq $0xe
popq %rcx
movq %r14, %rdi
xorl %r8d, %r8d
movq %r15, %r9
pushq %rbx
pushq %r13
pushq %rax
callq 0x4ced7
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq