LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_add_adr
void subtilis_add_adr(subtilis_arm_section_t *s,
		      subtilis_arm_ccode_type_t ccode, subtilis_arm_reg_t dest,
		      size_t label, subtilis_error_t *err)
{
	subtilis_arm_adr_instr_t *adr;
	subtilis_arm_instr_t *instr;

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

	adr = &instr->operands.adr;
	adr->ccode = ccode;
	adr->dest = dest;
	adr->label = label;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %r8, %rsi
callq 0x4f560
cmpl $0x0, (%r15)
jne 0x4fb52
movl $0x0, (%rax)
movl $0x1b, 0x8(%rax)
cmpl $0x0, (%r15)
jne 0x4fb52
movl %ebp, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_add_ldrp
void subtilis_add_ldrp(subtilis_arm_section_t *s,
		       subtilis_arm_ccode_type_t ccode, subtilis_arm_reg_t dest,
		       size_t section_label, size_t constant_label,
		       subtilis_error_t *err)
{
	subtilis_arm_ldrp_instr_t *ldrp;
	subtilis_arm_instr_t *instr;

	prv_add_ui32_constant(s, constant_label, (uint32_t)0, false, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

	ldrp = &instr->operands.ldrp;
	ldrp->ccode = ccode;
	ldrp->dest = dest;
	ldrp->section_label = section_label;
	ldrp->constant_label = constant_label;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r13
movq %r8, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r9, %r8
callq 0x4f9e7
cmpl $0x0, (%r12)
jne 0x4fbc4
movq %r13, %rdi
movq %r12, %rsi
callq 0x4f560
cmpl $0x0, (%r12)
jne 0x4fbc4
movl $0x0, (%rax)
movl $0x19, 0x8(%rax)
cmpl $0x0, (%r12)
jne 0x4fbc4
movl %ebp, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x4(%rsp)
movl %edx, %ebp
movl %esi, %r13d
movq %rdi, %r15
movq 0x58(%rsp), %rbx
movl 0x50(%rsp), %ecx
movq (%rdi), %r12
leaq 0x1(%r12), %rax
movq %rax, (%rdi)
leaq -0x1(%r12), %rax
cmpq $0x3, %rax
jae 0x4fc24
leaq 0x25fa3(%rip), %rax     # 0x75bc0
movq -0x8(%rax,%r12,8), %r12
jmp 0x4fc28
addq $0xc, %r12
movq %r15, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %rbx, %r8
callq 0x4fc9d
cmpl $0x0, (%rbx)
jne 0x4fc5f
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4f560
cmpl $0x0, (%rbx)
jne 0x4fc5f
movl $0x0, (%rax)
movl %r13d, 0x8(%rax)
cmpl $0x0, (%rbx)
je 0x4fc74
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%rsp), %ecx
movb %cl, 0x14(%rax)
movl $0x0, 0x28(%rax)
movl %ebp, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq %r12, 0x30(%rax)
jmp 0x4fc62
// File: /workspace/github_c_makefile_star2_O3/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, %r12
movq 0x60(%rdi), %rax
testq %rax, %rax
je 0x4fcd0
movq 0x58(%r12), %rdx
addq $0x8, %rdx
cmpl %ecx, -0x8(%rdx)
je 0x4fcf8
addq $0x18, %rdx
decq %rax
jne 0x4fcc2
movq 0x10(%r12), %r15
leaq 0x1(%r15), %rax
movq %rax, 0x10(%r12)
movq %r12, %rdi
movq %r15, %rsi
movl %ecx, %edx
xorl %ecx, %ecx
movq %r14, %r8
callq 0x4f9e7
cmpl $0x0, (%r14)
jne 0x4fd1f
jmp 0x4fcfb
movq (%rdx), %r15
movq %r12, %rdi
movq %r14, %rsi
callq 0x4f560
cmpl $0x0, (%r14)
jne 0x4fd1f
movl $0x0, (%rax)
movl $0x18, 0x8(%rax)
cmpl $0x0, (%r14)
je 0x4fd2e
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %r15, 0x20(%rax)
movb $0x0, 0x28(%rax)
jmp 0x4fd22
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
movl %r9d, %r13d
movq %r8, %r15
movq %rcx, 0x10(%rsp)
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %r12
leaq 0xc(%rsp), %rsi
movl %r9d, %edi
callq 0x4f87d
testl %r13d, %r13d
setns %cl
cmpl $0xe, %ebp
setne %dl
andb %r14b, %dl
orb %al, %cl
orb %dl, %cl
je 0x4ff65
movl $0x3, %ebx
testb %al, %al
je 0x4ff9c
movq %r15, %r13
movq 0x50(%rsp), %r15
jmp 0x4fff6
movl %r13d, %edi
negl %edi
leaq 0xc(%rsp), %rsi
callq 0x4f87d
testb %al, %al
je 0x4ff9c
movq (%r12), %r13
leaq 0x1(%r13), %rax
movq %rax, (%r12)
leaq -0x1(%r13), %rax
cmpq $0x3, %rax
jae 0x4ffc3
leaq 0x25c2b(%rip), %rax     # 0x75bc0
movq -0x8(%rax,%r13,8), %r13
jmp 0x4ffc7
movzbl %r14b, %ecx
movq %r12, %rdi
movl $0x3, %esi
movl %ebp, %edx
movq 0x10(%rsp), %r8
movq %r15, %r9
pushq 0x50(%rsp)
pushq %r13
callq 0x4fbd3
addq $0x28, %rsp
jmp 0x5003c
addq $0xc, %r13
subq $0x8, %rsp
movq %r12, %rdi
movl %ebp, %esi
xorl %edx, %edx
movq %r13, %rcx
movq %r15, %r8
xorl %r9d, %r9d
movq 0x58(%rsp), %r15
pushq %r15
callq 0x4ff0c
addq $0x10, %rsp
cmpl $0x0, (%r15)
jne 0x50038
movl $0x2, %ebx
movq %r12, %rdi
movq %r15, %rsi
callq 0x4f560
cmpl $0x0, (%r15)
jne 0x50038
movl $0x0, (%rax)
movl %ebx, 0x8(%rax)
cmpl $0x0, (%r15)
jne 0x50038
movb %r14b, 0x14(%rax)
movl $0x1, 0x28(%rax)
movl %ebp, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %r13, 0x20(%rax)
movl 0xc(%rsp), %ecx
movl %ecx, 0x30(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x50083
leaq 0x25b75(%rip), %rdx     # 0x75bd8
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 0x145a4
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 0x500b9
leaq 0x25b0e(%rip), %rcx     # 0x75bc0
movq -0x8(%rcx,%r12,8), %r12
jmp 0x500bd
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 0x50130
addq $0x10, %rsp
cmpl $0x0, (%r13)
jne 0x50121
movq %r15, %rdi
movq %r13, %rsi
callq 0x4f560
cmpl $0x0, (%r13)
jne 0x50121
movl $0x0, (%rax)
movl $0x10, 0x8(%rax)
cmpl $0x0, (%r13)
jne 0x50121
movl 0x4(%rsp), %ecx
movb %cl, 0x14(%rax)
movl %ebp, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movq %r12, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r13d
movq %rdi, %r12
movq 0x58(%rsp), %r15
movl 0x50(%rsp), %r14d
leaq 0x8(%rsp), %rsi
movl $0x0, (%rsi)
movl %r14d, %edi
callq 0x4f87d
testb %al, %al
jne 0x50189
movl %r14d, %edi
notl %edi
leaq 0x8(%rsp), %rsi
callq 0x4f87d
movl %ebx, %r13d
testb %al, %al
je 0x501da
movq %r12, %rdi
movq %r15, %rsi
callq 0x4f560
cmpl $0x0, (%r15)
jne 0x501cb
movl $0x0, (%rax)
movl %r13d, 0x8(%rax)
cmpl $0x0, (%r15)
jne 0x501cb
movl 0xc(%rsp), %ecx
movb %cl, 0x14(%rax)
movl $0x1, 0x28(%rax)
movl %ebp, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
movl 0x8(%rsp), %ecx
movl %ecx, 0x30(%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 %r14d, %ecx
movq %r15, %r8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4fc9d
// File: /workspace/github_c_makefile_star2_O3/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 0x5024c
movq %r14, %r13
cmpq %rbx, %r14
jne 0x50252
leaq 0x259ac(%rip), %rdx     # 0x75bd8
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 0x145a4
movq %rbx, %r13
movq %r8, %rbx
movq %r12, %rsi
callq 0x4f560
cmpl $0x0, (%r12)
jne 0x50288
movl $0x0, (%rax)
movl $0x10, 0x8(%rax)
cmpl $0x0, (%r12)
jne 0x50288
movb %r15b, 0x14(%rax)
movl %ebp, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movq %r13, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0xc(%rsp)
movl %edx, %ebp
movl %esi, 0x10(%rsp)
movq %rdi, %r14
movq 0x68(%rsp), %r13
movl 0x60(%rsp), %r15d
leaq 0x14(%rsp), %rsi
movl %r15d, %edi
callq 0x4f87d
testb %al, %al
je 0x502e6
movl $0x1, %r12d
movl 0x14(%rsp), %ebx
xorl %r15d, %r15d
jmp 0x50345
movq (%r14), %rbx
leaq 0x1(%rbx), %rax
movq %rax, (%r14)
leaq -0x1(%rbx), %rax
cmpq $0x3, %rax
jae 0x50308
leaq 0x258bf(%rip), %rax     # 0x75bc0
movq -0x8(%rax,%rbx,8), %rbx
jmp 0x5030c
addq $0xc, %rbx
xorl %r12d, %r12d
movq %r14, %rdi
movl $0xd, %esi
movl $0xf, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
pushq %r13
pushq %r15
callq 0x50130
addq $0x10, %rsp
cmpl $0x0, (%r13)
jne 0x50394
movabsq $-0x100000000, %r15     # imm = 0xFFFFFFFF00000000
andq %rbx, %r15
movq %r14, %rdi
movq %r13, %rsi
callq 0x4f560
cmpl $0x0, (%r13)
jne 0x50394
movl $0x0, (%rax)
movl 0x10(%rsp), %ecx
movl %ecx, 0x8(%rax)
cmpl $0x0, (%r13)
jne 0x50394
movl 0xc(%rsp), %ecx
movb %cl, 0x14(%rax)
movl %ebp, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x20(%rax)
movl %r12d, 0x28(%rax)
movl %ebx, %ecx
orq %rcx, %r15
movq %r15, 0x30(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f560
cmpl $0x0, (%r13)
jne 0x503f2
movl $0x0, (%rax)
movl $0x1a, 0x8(%rax)
cmpl $0x0, (%r13)
jne 0x503f2
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
movb $0x0, 0x30(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f560
cmpl $0x0, (%r13)
jne 0x50454
movl $0x0, (%rax)
movl $0x1a, 0x8(%rax)
cmpl $0x0, (%r13)
jne 0x50454
movq %r12, 0x10(%rax)
movq %r15, 0x20(%rax)
movq %r14, 0x28(%rax)
movb $0x1, 0x30(%rax)
movl %ebp, 0x34(%rax)
movl %ebx, 0x38(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f560
cmpl $0x0, (%r12)
jne 0x504aa
movl $0x0, (%rax)
movl $0x17, 0x8(%rax)
cmpl $0x0, (%r12)
jne 0x504aa
movl %r15d, 0x10(%rax)
movq %r14, 0x18(%rax)
movl %ebp, 0x20(%rax)
movl %ebx, 0x24(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r12d
movq 0x40(%rsp), %r13
movq %r13, %rsi
callq 0x4f560
cmpl $0x0, (%r13)
jne 0x50507
movl $0x0, (%rax)
movl %r12d, 0x8(%rax)
cmpl $0x0, (%r13)
jne 0x50507
movb %r15b, 0x14(%rax)
movl %ebp, 0x10(%rax)
movq %r14, 0x18(%rax)
movl $0x0, 0x28(%rax)
movq %rbx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x18, %rsp
movl %r9d, %r14d
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq %rdi, %r15
movq 0x58(%rsp), %r13
movl %r9d, %ebx
negl %ebx
cmovsl %r9d, %ebx
cmpl $0x1000, %ebx           # imm = 0x1000
movl %edx, (%rsp)
jb 0x50575
movq (%r15), %r12
leaq 0x1(%r12), %rax
movq %rax, (%r15)
leaq -0x1(%r12), %rax
cmpq $0x3, %rax
jae 0x5057f
leaq 0x25652(%rip), %rax     # 0x75bc0
movq -0x8(%rax,%r12,8), %r12
jmp 0x50583
movl $0x1, %r12d
xorl %ebp, %ebp
jmp 0x505af
addq $0xc, %r12
movq %r15, %rdi
movl %edx, %esi
movq %r12, %rdx
movl %ebx, %ecx
movq %r13, %r8
callq 0x4fc9d
cmpl $0x0, (%r13)
jne 0x5060f
movabsq $-0x100000000, %rbp     # imm = 0xFFFFFFFF00000000
andq %r12, %rbp
movl %r12d, %ebx
xorl %r12d, %r12d
movq %r15, %rdi
movq %r13, %rsi
callq 0x4f560
cmpl $0x0, (%r13)
jne 0x5060f
movl $0x0, (%rax)
movl 0x4(%rsp), %ecx
movl %ecx, 0x8(%rax)
cmpl $0x0, (%r13)
jne 0x5060f
movb 0x50(%rsp), %cl
movl (%rsp), %edx
movl %edx, 0x10(%rax)
movq 0x8(%rsp), %rdx
movq %rdx, 0x18(%rax)
movq 0x10(%rsp), %rdx
movq %rdx, 0x20(%rax)
movl %r12d, 0x28(%rax)
movl %ebx, %edx
orq %rdx, %rbp
movq %rbp, 0x30(%rax)
movw $0x1, 0x50(%rax)
movb %cl, 0x53(%rax)
shrl $0x1f, %r14d
movb %r14b, 0x52(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f560
cmpl $0x0, (%r14)
jne 0x5066f
movl $0x0, (%rax)
movl $0x13, 0x8(%rax)
cmpl $0x0, (%r14)
jne 0x5066f
movl %ebp, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq $0xd, 0x20(%rax)
movl $0x1, 0x28(%rax)
movl $0x4, 0x30(%rax)
movl $0x10101, 0x50(%rax)    # imm = 0x10101
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f560
cmpl $0x0, (%r14)
jne 0x506c5
movl $0x0, (%rax)
movl $0x12, 0x8(%rax)
cmpl $0x0, (%r14)
jne 0x506c5
movl %ebp, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq $0xd, 0x20(%rax)
movl $0x1, 0x28(%rax)
movl $0x4, 0x30(%rax)
movl $0x100, 0x50(%rax)      # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x60(%rsi), %rsi
movq %r8, %rdx
callq 0x4f62a
cmpl $0x0, (%r14)
jne 0x50779
movl $0x0, (%rax)
movl $0x12, 0x8(%rax)
cmpl $0x0, (%r14)
jne 0x50779
movl %ebp, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq $0xd, 0x20(%rax)
movl $0x1, 0x28(%rax)
movl $0x4, 0x30(%rax)
movl $0x100, 0x50(%rax)      # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movq 0x60(%rsp), %r13
movq 0x50(%rsp), %r15
movl 0x58(%rsp), %r8d
movl %ecx, %edx
movq %r15, %rcx
movq %r13, %r9
callq 0x4f95f
cmpl $0x0, (%r13)
jne 0x50812
movq 0x60(%r14), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x4f62a
cmpl $0x0, (%r13)
jne 0x50812
movl $0x0, (%rax)
movl %r12d, 0x8(%rax)
cmpl $0x0, (%r13)
jne 0x50812
movl %ebp, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x20(%rax)
movl $0x0, 0x28(%rax)
movq %r15, 0x30(%rax)
movl $0x1, 0x50(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5086f
leaq 0x25389(%rip), %rdx     # 0x75bd8
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 0x145a4
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %r12d
movq %r9, (%rsp)
movq 0x60(%rsi), %rsi
movq %r15, %rdx
callq 0x4f62a
cmpl $0x0, (%r15)
jne 0x508c7
movl $0x0, (%rax)
movl %r12d, 0x8(%rax)
cmpl $0x0, (%r15)
jne 0x508c7
movl %ebp, 0x10(%rax)
movq %r14, 0x18(%rax)
movq (%rsp), %rcx
movq %rcx, 0x20(%rax)
movl $0x1, 0x28(%rax)
movl %r13d, 0x30(%rax)
movw $0x1, 0x50(%rax)
shrl $0x1f, %ebx
movb %bl, 0x52(%rax)
movb $0x0, 0x53(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f87d
testb %al, %al
je 0x50913
movl %r13d, %ebx
jmp 0x5092b
movl %r15d, %edi
negl %edi
leaq 0xc(%rsp), %rsi
callq 0x4f87d
movl $0xb, %ebx
testb %al, %al
je 0x5096f
movq %r12, %rdi
movq %r14, %rsi
callq 0x4f560
cmpl $0x0, (%r14)
jne 0x50969
movl $0x0, (%rax)
movl %ebx, 0x8(%rax)
cmpl $0x0, (%r14)
jne 0x50969
movl %ebp, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x20(%rax)
movl $0x1, 0x28(%rax)
movl 0xc(%rsp), %ecx
movl %ecx, 0x30(%rax)
movb $0x1, 0x14(%rax)
addq $0x18, %rsp
jmp 0x50991
movq %r12, %rdi
movl %r13d, %esi
movl %ebp, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
movq 0x10(%rsp), %r9
pushq %r14
pushq %r15
callq 0x4fbd3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f560
cmpl $0x0, (%r15)
jne 0x509e6
movl $0x0, (%rax)
movl %r12d, 0x8(%rax)
cmpl $0x0, (%r15)
jne 0x509e6
movl %ebp, 0x10(%rax)
movq %r14, 0x20(%rax)
movl $0x0, 0x28(%rax)
movq %rbx, 0x30(%rax)
movb $0x1, 0x14(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r12d
movq 0x50(%rsp), %r13
movq %r13, %rsi
callq 0x4f560
cmpl $0x0, (%r13)
jne 0x50a49
movl $0x0, (%rax)
movl %r12d, 0x8(%rax)
cmpl $0x0, (%r13)
jne 0x50a49
movb 0x48(%rsp), %cl
movb 0x40(%rsp), %dl
movl %ebp, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movl %ebx, 0x28(%rax)
movb %dl, 0x2c(%rax)
movb %cl, 0x2d(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f560
cmpl $0x0, (%r14)
jne 0x50a78
movl $0x2, (%rax)
movb %bl, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f560
cmpl $0x0, (%r14)
jne 0x50aa1
movl $0x3, (%rax)
movw %bx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f560
cmpl $0x0, (%r14)
jne 0x50ac9
movl $0x4, (%rax)
movl %ebx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f560
cmpl $0x0, (%rbx)
jne 0x50afa
movl $0x5, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f560
cmpl $0x0, (%rbx)
jne 0x50b29
movl $0x6, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f560
cmpl $0x0, (%rbx)
jne 0x50b58
movl $0x7, (%rax)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f560
cmpl $0x0, (%r14)
je 0x50b7d
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 0x50bb0
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x12070
leaq 0x25021(%rip), %rdx     # 0x75bd8
movq %r14, %rdi
movl $0x1, %esi
movl $0x638, %ecx            # imm = 0x638
popq %rbx
popq %r14
popq %r15
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/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 0x4f560
cmpl $0x0, (%r14)
jne 0x50bee
movl $0x9, (%rax)
movl %ebx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x50c25
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 0x50c02
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x50c78
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 0x50ca0
movq %r12, 0x80(%r14)
movq %rax, 0x70(%r14)
movq 0x78(%r14), %r12
movsd (%rsp), %xmm0
jmp 0x50c7c
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 0x24f31(%rip), %rdx     # 0x75bd8
movq %r15, %rdi
movl $0x1, %esi
movl $0x666, %ecx            # imm = 0x666
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/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, %r12d
movq 0x40(%rsp), %r13
movq %r13, %rsi
callq 0x4f560
cmpl $0x0, (%r13)
jne 0x50d16
movl $0x0, (%rax)
movl %r12d, 0x8(%rax)
cmpl $0x0, (%r13)
jne 0x50d16
movl %r15d, 0x10(%rax)
movl %r14d, 0x14(%rax)
movl %ebp, 0x18(%rax)
movb $0x1, 0x1c(%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, (%rsp)
movl %esi, %ebp
movq %rdi, %r12
movq 0x40(%rsp), %rbx
movq %rbx, %rsi
callq 0x4f560
movq %rbx, %rcx
cmpl $0x0, (%rbx)
jne 0x50df6
movq %rax, %rbx
movl $0x0, (%rax)
movl %ebp, 0x8(%rax)
cmpl $0x0, (%rcx)
jne 0x50df6
movq %rcx, %rbp
movl (%rsp), %eax
movl %eax, 0x10(%rbx)
movl %r14d, 0x14(%rbx)
movl %r13d, 0x18(%rbx)
leaq 0x4(%rsp), %rsi
movl %r15d, %edi
callq 0x4f87d
testb %al, %al
je 0x50d9e
movb $0x0, 0x1c(%rbx)
movl 0x4(%rsp), %eax
movl %eax, 0x20(%rbx)
jmp 0x50df6
movq (%r12), %r13
leaq 0x1(%r13), %rax
movq %rax, (%r12)
leaq -0x1(%r13), %rax
cmpq $0x3, %rax
jae 0x50dc2
leaq 0x24e05(%rip), %rax     # 0x75bc0
movq -0x8(%rax,%r13,8), %r13
jmp 0x50dc6
addq $0xc, %r13
movq %r12, %rdi
movl $0xd, %esi
movl $0xf, %edx
movl (%rsp), %ecx
xorl %r8d, %r8d
movq %r13, %r9
pushq %rbp
pushq %r15
callq 0x50130
addq $0x10, %rsp
cmpl $0x0, (%rbp)
jne 0x50df6
movb $0x1, 0x1c(%rbx)
movq %r13, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r12d
movq 0x40(%rsp), %r13
movq %r13, %rsi
callq 0x4f560
cmpl $0x0, (%r13)
jne 0x50e52
movl $0x0, (%rax)
movl %r12d, 0x8(%rax)
cmpl $0x0, (%r13)
jne 0x50e52
movl %ebp, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq