LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_core.c
// Function: subtilis_arm_add_signx
void subtilis_arm_add_signx(subtilis_arm_section_t *s,
			    subtilis_arm_instr_type_t itype,
			    subtilis_arm_ccode_type_t ccode,
			    subtilis_arm_reg_t dest, subtilis_arm_reg_t op1,
			    subtilis_arm_signx_rotate_t rotate,
			    subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_signx_instr_t *signx;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r12d
movq 0x40(%rsp), %r13
movq %r13, %rsi
callq 0x4f560
cmpl $0x0, (%r13)
jne 0x50ead
movl $0x0, (%rax)
movl %r12d, 0x8(%rax)
cmpl $0x0, (%r13)
jne 0x50ead
movl %ebp, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movl %ebx, 0x14(%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_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 0x4efba
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4efba
movq %rbx, (%rsp)
movq %r14, %rdi
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movq %r15, %r8
movq %rax, %r9
callq 0x504b3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4efba
movq %r14, %rdi
movl $0xd, %esi
movl $0xf, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
movq %rax, %r9
pushq %rbx
pushq %r15
callq 0x50130
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4efba
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4efba
subq $0x8, %rsp
movq %r14, %rdi
movl $0x4, %esi
movl $0x2, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
movq %r15, %r9
pushq %rbx
pushq %r13
pushq %rax
callq 0x4fd3f
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4efba
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4efba
subq $0x8, %rsp
movq %r14, %rdi
movl $0x2, %esi
movl $0x4, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
movq %r15, %r9
pushq %rbx
pushq %r13
pushq %rax
callq 0x4fd3f
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_rsubii32
void subtilis_arm_gen_rsubii32(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_rsub_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, dest,
				  op1, op2, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movl 0x20(%r12), %ebp
movq 0x10(%r12), %rdi
callq 0x4efba
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4efba
movq %rbx, (%rsp)
movq %r14, %rdi
movl $0xe, %esi
xorl %edx, %edx
movq %r15, %rcx
movq %rax, %r8
movl %ebp, %r9d
callq 0x4ff0c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_mulii32
void subtilis_arm_gen_mulii32(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_mul_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, dest, op1,
				 op2, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movl 0x20(%r12), %ebp
movq 0x10(%r12), %rdi
callq 0x4efba
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4efba
movq %rbx, (%rsp)
movq %r14, %rdi
movl $0xe, %esi
xorl %edx, %edx
movq %r15, %rcx
movq %rax, %r8
movl %ebp, %r9d
callq 0x50047
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_muli32
void subtilis_arm_gen_muli32(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_reg_t op2;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r13
movq 0x10(%r13), %rdi
callq 0x4efba
movq %rax, %r15
movq 0x18(%r13), %rdi
callq 0x4efba
movq %rax, %r12
movq 0x20(%r13), %rdi
callq 0x4efba
movq %rbx, (%rsp)
movq %r14, %rdi
movl $0xe, %esi
xorl %edx, %edx
movq %r15, %rcx
movq %r12, %r8
movq %rax, %r9
callq 0x501fd
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: prv_data_simple
static void prv_data_simple(subtilis_ir_section_t *s, size_t start,
			    void *user_data, subtilis_arm_instr_type_t itype,
			    subtilis_arm_ccode_type_t ccode,
			    subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *datai;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *ir_op = &s->ops[start]->op.instr;

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

	datai = &instr->operands.data;
	datai->ccode = ccode;
	datai->dest = subtilis_arm_ir_to_arm_reg(ir_op->operands[0].reg);
	datai->op1 = subtilis_arm_ir_to_arm_reg(ir_op->operands[1].reg);
	datai->op2.type = SUBTILIS_ARM_OP2_REG;
	datai->op2.op.reg = subtilis_arm_ir_to_arm_reg(ir_op->operands[2].reg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r14
movq (%rdi,%rsi,8), %r15
movq %rdx, %rdi
movl %ecx, %esi
movq %r8, %rdx
callq 0x4f6e2
cmpl $0x0, (%r14)
jne 0x511b2
movq %rax, %rbx
movl $0xe, 0x8(%rax)
movq 0x10(%r15), %rdi
callq 0x4efba
movq %rax, 0x10(%rbx)
movq 0x18(%r15), %rdi
callq 0x4efba
movq %rax, 0x18(%rbx)
movl $0x0, 0x20(%rbx)
movq 0x20(%r15), %rdi
callq 0x4efba
movq %rax, 0x28(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: prv_stran_instr
static void prv_stran_instr(subtilis_arm_instr_type_t itype,
			    subtilis_ir_section_t *s, size_t start,
			    void *user_data, bool byte, subtilis_error_t *err)
{
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	int32_t offset = instr->operands[2].integer;
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t base;

	dest = subtilis_arm_ir_to_arm_reg(instr->operands[0].reg);
	base = subtilis_arm_ir_to_arm_reg(instr->operands[1].reg);
	subtilis_arm_add_stran_imm(arm_s, itype, SUBTILIS_ARM_CCODE_AL, dest,
				   base, offset, byte, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, (%rsp)
movq %rcx, %r15
movl %edi, %ebp
movq (%rsi,%rdx,8), %r14
movl 0x20(%r14), %r12d
movq 0x10(%r14), %rdi
callq 0x4efba
movq %rax, %r13
movq 0x18(%r14), %rdi
callq 0x4efba
movq %r15, %rdi
movl %ebp, %esi
movl $0xe, %edx
movq %r13, %rcx
movq %rax, %r8
movl %r12d, %r9d
pushq %rbx
pushq 0x8(%rsp)
callq 0x50516
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_gen.c
// Function: prv_cmp_jmp_imm
static void prv_cmp_jmp_imm(subtilis_ir_section_t *s, size_t start,
			    void *user_data, subtilis_arm_ccode_type_t ccode,
			    subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_br_instr_t *br;
	subtilis_arm_reg_t op1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *cmp = &s->ops[start]->op.instr;
	subtilis_ir_inst_t *jmp = &s->ops[start + 1]->op.instr;

	op1 = subtilis_arm_ir_to_arm_reg(cmp->operands[1].reg);

	subtilis_arm_add_cmp_imm(arm_s, SUBTILIS_ARM_INSTR_CMP,
				 SUBTILIS_ARM_CCODE_AL, op1,
				 cmp->operands[2].integer, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	instr =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_B, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	br = &instr->operands.br;
	br->ccode = ccode;
	br->link = false;
	br->link_type = SUBTILIS_ARM_BR_LINK_VOID;
	br->target.label = jmp->operands[2].label;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movl %ecx, %ebx
movq %rdx, %r15
movq (%rdi,%rsi,8), %r13
movq 0x8(%rdi,%rsi,8), %r12
movq 0x18(%r13), %rdi
callq 0x4efba
movl 0x20(%r13), %r8d
movq %r15, %rdi
movl $0xa, %esi
movl $0xe, %edx
movq %rax, %rcx
movq %r14, %r9
callq 0x508d6
cmpl $0x0, (%r14)
jne 0x51325
movq %r15, %rdi
movl $0x16, %esi
movq %r14, %rdx
callq 0x4f6e2
cmpl $0x0, (%r14)
jne 0x51325
movl %ebx, 0x8(%rax)
movb $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movq 0x20(%r12), %rcx
movq %rcx, 0x18(%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_gen.c
// Function: prv_cmp_jmp
static void prv_cmp_jmp(subtilis_ir_section_t *s, size_t start, void *user_data,
			subtilis_arm_ccode_type_t ccode, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_br_instr_t *br;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *jmp = &s->ops[start + 1]->op.instr;

	prv_cmp_simple(s, start, user_data, SUBTILIS_ARM_INSTR_CMP,
		       SUBTILIS_ARM_CCODE_AL, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	instr =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_B, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	br = &instr->operands.br;
	br->ccode = ccode;
	br->link = false;
	br->link_type = SUBTILIS_ARM_BR_LINK_VOID;
	br->target.label = jmp->operands[2].label;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %ecx, %ebx
movq %rdx, %r15
movq 0x8(%rdi,%rsi,8), %r12
movq %r8, %rcx
callq 0x5270c
cmpl $0x0, (%r14)
jne 0x513df
movq %r15, %rdi
movl $0x16, %esi
movq %r14, %rdx
callq 0x4f6e2
cmpl $0x0, (%r14)
jne 0x513df
movl %ebx, 0x8(%rax)
movb $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movq 0x20(%r12), %rcx
movq %rcx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: prv_cmp_imm
static void prv_cmp_imm(subtilis_ir_section_t *s, size_t start, void *user_data,
			subtilis_arm_ccode_type_t ok,
			subtilis_arm_ccode_type_t nok, 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 *cmp = &s->ops[start]->op.instr;

	op1 = subtilis_arm_ir_to_arm_reg(cmp->operands[1].reg);
	subtilis_arm_add_cmp_imm(arm_s, SUBTILIS_ARM_INSTR_CMP,
				 SUBTILIS_ARM_CCODE_AL, op1,
				 cmp->operands[2].integer, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	dest = subtilis_arm_ir_to_arm_reg(cmp->operands[0].reg);
	subtilis_arm_add_mov_imm(arm_s, ok, false, dest, -1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_arm_add_mov_imm(arm_s, nok, false, dest, 0, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, %r14
movq (%rdi,%rsi,8), %r12
movq 0x18(%r12), %rdi
callq 0x4efba
movl 0x20(%r12), %r8d
movq %r14, %rdi
movl $0xa, %esi
movl $0xe, %edx
movq %rax, %rcx
movq %rbx, %r9
callq 0x508d6
cmpl $0x0, (%rbx)
jne 0x514e4
movq 0x10(%r12), %rdi
callq 0x4efba
movq %rax, %r12
movq %r14, %rdi
movl $0xd, %esi
movl $0xf, %edx
movl %r15d, %ecx
xorl %r8d, %r8d
movq %rax, %r9
pushq %rbx
pushq $-0x1
callq 0x50130
addq $0x10, %rsp
cmpl $0x0, (%rbx)
jne 0x514e4
movq %r14, %rdi
movl $0xd, %esi
movl $0xf, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
movq %r12, %r9
pushq %rbx
pushq $0x0
callq 0x50130
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: prv_cmp
static void prv_cmp(subtilis_ir_section_t *s, size_t start, void *user_data,
		    subtilis_arm_ccode_type_t ok, subtilis_arm_ccode_type_t nok,
		    subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *cmp = &s->ops[start]->op.instr;

	prv_cmp_simple(s, start, user_data, SUBTILIS_ARM_INSTR_CMP,
		       SUBTILIS_ARM_CCODE_AL, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	dest = subtilis_arm_ir_to_arm_reg(cmp->operands[0].reg);
	subtilis_arm_add_mov_imm(arm_s, ok, false, dest, -1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_arm_add_mov_imm(arm_s, nok, false, dest, 0, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, %r14
movq (%rdi,%rsi,8), %r12
movq %r9, %rcx
callq 0x5270c
cmpl $0x0, (%rbx)
jne 0x515e8
movq 0x10(%r12), %rdi
callq 0x4efba
movq %rax, %r12
movq %r14, %rdi
movl $0xd, %esi
movl $0xf, %edx
movl %r15d, %ecx
xorl %r8d, %r8d
movq %rax, %r9
pushq %rbx
pushq $-0x1
callq 0x50130
addq $0x10, %rsp
cmpl $0x0, (%rbx)
jne 0x515e8
movq %r14, %rdi
movl $0xd, %esi
movl $0xf, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
movq %r12, %r9
pushq %rbx
pushq $0x0
callq 0x50130
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_jump
void subtilis_arm_gen_jump(subtilis_ir_section_t *s, size_t start,
			   void *user_data, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_br_instr_t *br;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *jmp = &s->ops[start]->op.instr;

	instr =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_B, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	br = &instr->operands.br;
	br->ccode = SUBTILIS_ARM_CCODE_AL;
	br->link = false;
	br->link_type = SUBTILIS_ARM_BR_LINK_VOID;
	br->target.label = jmp->operands[0].label;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r14
movq %rdx, %rdi
movl $0x16, %esi
movq %rcx, %rdx
callq 0x4f6e2
cmpl $0x0, (%rbx)
jne 0x5169c
movl $0xe, 0x8(%rax)
movb $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_jmpc
void subtilis_arm_gen_jmpc(subtilis_ir_section_t *s, size_t start,
			   void *user_data, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_br_instr_t *br;
	subtilis_arm_reg_t op1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *jmp = &s->ops[start]->op.instr;

	op1 = subtilis_arm_ir_to_arm_reg(jmp->operands[0].reg);

	subtilis_arm_add_cmp_imm(arm_s, SUBTILIS_ARM_INSTR_CMP,
				 SUBTILIS_ARM_CCODE_AL, op1, 0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	instr =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_B, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	br = &instr->operands.br;
	br->ccode = SUBTILIS_ARM_CCODE_EQ;
	br->link = false;
	br->link_type = SUBTILIS_ARM_BR_LINK_VOID;
	br->target.label = jmp->operands[2].label;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r15
movq 0x10(%r15), %rdi
callq 0x4efba
movq %r14, %rdi
movl $0xa, %esi
movl $0xe, %edx
movq %rax, %rcx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x508d6
cmpl $0x0, (%rbx)
jne 0x51709
movq %r14, %rdi
movl $0x16, %esi
movq %rbx, %rdx
callq 0x4f6e2
cmpl $0x0, (%rbx)
jne 0x51709
xorl %ecx, %ecx
movl %ecx, 0x8(%rax)
movb $0x0, 0xc(%rax)
movl %ecx, 0x10(%rax)
movq 0x20(%r15), %rcx
movq %rcx, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_jmpc_rev
void subtilis_arm_gen_jmpc_rev(subtilis_ir_section_t *s, size_t start,
			       void *user_data, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_br_instr_t *br;
	subtilis_arm_reg_t op1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *jmp = &s->ops[start]->op.instr;

	op1 = subtilis_arm_ir_to_arm_reg(jmp->operands[0].reg);

	subtilis_arm_add_cmp_imm(arm_s, SUBTILIS_ARM_INSTR_CMP,
				 SUBTILIS_ARM_CCODE_AL, op1, 0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	instr =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_B, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	br = &instr->operands.br;
	br->ccode = SUBTILIS_ARM_CCODE_NE;
	br->link = false;
	br->link_type = SUBTILIS_ARM_BR_LINK_VOID;
	br->target.label = jmp->operands[1].label;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r15
movq 0x10(%r15), %rdi
callq 0x4efba
movq %r14, %rdi
movl $0xa, %esi
movl $0xe, %edx
movq %rax, %rcx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x508d6
cmpl $0x0, (%rbx)
jne 0x5177a
movq %r14, %rdi
movl $0x16, %esi
movq %rbx, %rdx
callq 0x4f6e2
cmpl $0x0, (%rbx)
jne 0x5177a
movl $0x1, 0x8(%rax)
movb $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movq 0x18(%r15), %rcx
movq %rcx, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_jmpc_no_label
void subtilis_arm_gen_jmpc_no_label(subtilis_ir_section_t *s, size_t start,
				    void *user_data, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_br_instr_t *br;
	subtilis_arm_reg_t op1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *jmp = &s->ops[start]->op.instr;

	op1 = subtilis_arm_ir_to_arm_reg(jmp->operands[0].reg);

	subtilis_arm_add_cmp_imm(arm_s, SUBTILIS_ARM_INSTR_CMP,
				 SUBTILIS_ARM_CCODE_AL, op1, 0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	instr =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_B, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	br = &instr->operands.br;
	br->ccode = SUBTILIS_ARM_CCODE_NE;
	br->link = false;
	br->link_type = SUBTILIS_ARM_BR_LINK_VOID;
	br->target.label = jmp->operands[1].label;

	instr =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_B, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	br = &instr->operands.br;
	br->ccode = SUBTILIS_ARM_CCODE_EQ;
	br->link = false;
	br->link_type = SUBTILIS_ARM_BR_LINK_VOID;
	br->target.label = jmp->operands[2].label;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r15
movq 0x10(%r15), %rdi
callq 0x4efba
movq %r14, %rdi
movl $0xa, %esi
movl $0xe, %edx
movq %rax, %rcx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x508d6
cmpl $0x0, (%rbx)
jne 0x51814
movq %r14, %rdi
movl $0x16, %esi
movq %rbx, %rdx
callq 0x4f6e2
cmpl $0x0, (%rbx)
jne 0x51814
movl $0x1, 0x8(%rax)
movb $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movq 0x18(%r15), %rcx
movq %rcx, 0x18(%rax)
movq %r14, %rdi
movl $0x16, %esi
movq %rbx, %rdx
callq 0x4f6e2
cmpl $0x0, (%rbx)
jne 0x51814
xorl %ecx, %ecx
movl %ecx, 0x8(%rax)
movb $0x0, 0xc(%rax)
movl %ecx, 0x10(%rax)
movq 0x20(%r15), %rcx
movq %rcx, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: prv_cmovi32_fused
static void prv_cmovi32_fused(subtilis_ir_section_t *s, size_t start,
			      void *user_data,
			      subtilis_arm_ccode_type_t true_cond,
			      subtilis_arm_ccode_type_t false_cond,
			      subtilis_error_t *err)
{
	subtilis_arm_reg_t op0;
	subtilis_arm_reg_t op2;
	subtilis_arm_reg_t op3;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *cmov = &s->ops[start + 1]->op.instr;

	prv_cmp_simple(s, start, user_data, SUBTILIS_ARM_INSTR_CMP,
		       SUBTILIS_ARM_CCODE_AL, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	op0 = subtilis_arm_ir_to_arm_reg(cmov->operands[0].reg);
	op2 = subtilis_arm_ir_to_arm_reg(cmov->operands[2].reg);
	op3 = subtilis_arm_ir_to_arm_reg(cmov->operands[3].reg);

	subtilis_arm_add_cmov_fused(arm_s, op0, op2, op3, false_cond, true_cond,
				    err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movl %r8d, %ebp
movl %ecx, %ebx
movq %rdx, %r15
movq 0x8(%rdi,%rsi,8), %r12
movq %r9, %rcx
callq 0x5270c
cmpl $0x0, (%r14)
jne 0x5189d
movq 0x10(%r12), %rdi
callq 0x4efba
movq %rax, 0x10(%rsp)
movq 0x20(%r12), %rdi
callq 0x4efba
movq %rax, %r13
movq 0x28(%r12), %rdi
callq 0x4efba
movq %r14, (%rsp)
movq %r15, %rdi
movq 0x10(%rsp), %rsi
movq %r13, %rdx
movq %rax, %rcx
movl %ebp, %r8d
movl %ebx, %r9d
callq 0x503fc
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_gen.c
// Function: subtilis_arm_gen_cmovi32
void subtilis_arm_gen_cmovi32(subtilis_ir_section_t *s, size_t start,
			      void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t op0;
	subtilis_arm_reg_t op1;
	subtilis_arm_reg_t op2;
	subtilis_arm_reg_t op3;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *cmov = &s->ops[start]->op.instr;

	op0 = subtilis_arm_ir_to_arm_reg(cmov->operands[0].reg);
	op1 = subtilis_arm_ir_to_arm_reg(cmov->operands[1].reg);
	op2 = subtilis_arm_ir_to_arm_reg(cmov->operands[2].reg);
	op3 = subtilis_arm_ir_to_arm_reg(cmov->operands[3].reg);

	subtilis_arm_add_cmov(arm_s, op0, op1, op2, op3, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %rbp
movq 0x10(%rbp), %rdi
callq 0x4efba
movq %rax, %r15
movq 0x18(%rbp), %rdi
callq 0x4efba
movq %rax, %r12
movq 0x20(%rbp), %rdi
callq 0x4efba
movq %rax, %r13
movq 0x28(%rbp), %rdi
callq 0x4efba
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rax, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x503a3
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: prv_data_imm
static void prv_data_imm(subtilis_ir_section_t *s, size_t start,
			 void *user_data, subtilis_arm_instr_type_t itype,
			 subtilis_arm_ccode_type_t ccode, bool status,
			 subtilis_error_t *err)
{
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *ir_op = &s->ops[start]->op.instr;
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op1;

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

	subtilis_arm_add_data_imm(arm_s, itype, ccode, status, dest, op1,
				  ir_op->operands[2].integer, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq (%rdi,%rsi,8), %r12
movq 0x10(%r12), %rdi
callq 0x4efba
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4efba
movl 0x20(%r12), %r10d
movq %r14, %rdi
movl %ebp, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movq %r15, %r8
movq %rax, %r9
pushq %rbx
pushq %r10
callq 0x50297
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: prv_gen_calli32
static void prv_gen_calli32(subtilis_ir_section_t *s, size_t start,
			    void *user_data, bool indirect,
			    subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_call_t *call = &s->ops[start]->op.call;

	subtilis_arm_gen_call_gen(s, start, user_data, SUBTILIS_ARM_BR_LINK_INT,
				  indirect, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	dest = subtilis_arm_ir_to_arm_reg(call->reg);
	op1 = 0;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movl %ecx, %r8d
movq %rdx, %rbx
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r15
movl $0x1, %ecx
movq %r14, %r9
callq 0x51a33
cmpl $0x0, (%r14)
jne 0x5205d
movq 0x18(%r15), %rdi
callq 0x4efba
movq %r14, (%rsp)
movq %rbx, %rdi
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x504b3
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_ret
void subtilis_arm_gen_ret(subtilis_ir_section_t *s, size_t start,
			  void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op2;
	subtilis_arm_instr_t *stack_add;
	subtilis_arm_data_instr_t *datai;
	subtilis_arm_section_t *arm_s = user_data;

	stack_add =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_ADD, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	datai = &stack_add->operands.data;
	datai->status = false;
	datai->ccode = SUBTILIS_ARM_CCODE_AL;
	datai->dest = 13;
	datai->op1 = datai->dest;
	datai->op2.type = SUBTILIS_ARM_OP2_I32;
	datai->op2.op.integer = 0;

	subtilis_arm_section_add_ret_site(arm_s, arm_s->last_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	dest = 15;
	op2 = 14;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rdx, %rdi
movl $0x4, %esi
movq %rcx, %rdx
callq 0x4f6e2
cmpl $0x0, (%r14)
jne 0x52100
movb $0x0, 0xc(%rax)
movl $0xe, 0x8(%rax)
movl $0xd, %ecx
movq %rcx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movl $0x1, 0x20(%rax)
movl $0x0, 0x28(%rax)
movq 0x28(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4f27d
cmpl $0x0, (%r14)
jne 0x52100
movq %r14, (%rsp)
movl $0xf, %r8d
movl $0xe, %r9d
movq %rbx, %rdi
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
callq 0x504b3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_reti32
void subtilis_arm_gen_reti32(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 = 0;
	op2 = subtilis_arm_ir_to_arm_reg(instr->operands[0].reg);

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, dest, op2,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_arm_gen_ret(s, start, user_data, err);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %rax
movq 0x10(%rax), %rdi
callq 0x4efba
movq %rbx, (%rsp)
movq %r14, %rdi
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rax, %r9
callq 0x504b3
cmpl $0x0, (%rbx)
je 0x5214e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x52081
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_retii32
void subtilis_arm_gen_retii32(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[0].integer;

	dest = 0;

	subtilis_arm_add_mov_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, dest, op2,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_arm_gen_ret(s, start, user_data, err);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %rax
movl 0x10(%rax), %eax
movq %rdx, %rdi
movl $0xd, %esi
movl $0xf, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rbx
pushq %rax
callq 0x50130
addq $0x10, %rsp
cmpl $0x0, (%rbx)
je 0x521a5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x52081
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: prv_gen_shift
static void prv_gen_shift(subtilis_ir_section_t *s, size_t start,
			  void *user_data, subtilis_arm_shift_type_t type,
			  subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *mov;
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op1;
	subtilis_arm_reg_t op2;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *ir_op = &s->ops[start]->op.instr;

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

	instr =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_MOV, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	mov = &instr->operands.data;

	mov->status = false;
	mov->ccode = SUBTILIS_ARM_CCODE_AL;
	mov->dest = dest;
	mov->op2.type = SUBTILIS_ARM_OP2_SHIFTED;
	mov->op2.op.shift.type = type;
	mov->op2.op.shift.reg = op1;
	mov->op2.op.shift.shift_reg = true;
	mov->op2.op.shift.shift.reg = op2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %ecx, %ebx
movq %rdx, %rbp
movq (%rdi,%rsi,8), %r13
movq 0x10(%r13), %rdi
callq 0x4efba
movq %rax, %r15
movq 0x18(%r13), %rdi
callq 0x4efba
movq %rax, %r12
movq 0x20(%r13), %rdi
callq 0x4efba
movq %rax, %r13
movq %rbp, %rdi
movl $0xd, %esi
movq %r14, %rdx
callq 0x4f6e2
cmpl $0x0, (%r14)
jne 0x52238
movb $0x0, 0xc(%rax)
movl $0xe, 0x8(%rax)
movq %r15, 0x10(%rax)
movl $0x2, 0x20(%rax)
movl %ebx, 0x30(%rax)
movq %r12, 0x28(%rax)
movb $0x1, 0x40(%rax)
movq %r13, 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_gen.c
// Function: prv_gen_shift_i32
static void prv_gen_shift_i32(subtilis_ir_section_t *s, size_t start,
			      void *user_data, subtilis_arm_shift_type_t type,
			      subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *mov;
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *ir_op = &s->ops[start]->op.instr;

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

	instr =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_MOV, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	mov = &instr->operands.data;

	mov->status = false;
	mov->ccode = SUBTILIS_ARM_CCODE_AL;
	mov->dest = dest;
	mov->op2.type = SUBTILIS_ARM_OP2_SHIFTED;
	mov->op2.op.shift.type = type;
	mov->op2.op.shift.reg = op1;
	mov->op2.op.shift.shift_reg = false;
	mov->op2.op.shift.shift.integer = ir_op->operands[2].integer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movl %ecx, %ebx
movq %rdx, %r13
movq (%rdi,%rsi,8), %rbp
movq 0x10(%rbp), %rdi
callq 0x4efba
movq %rax, %r14
movq 0x18(%rbp), %rdi
callq 0x4efba
movq %rax, %r15
movq %r13, %rdi
movl $0xd, %esi
movq %r12, %rdx
callq 0x4f6e2
cmpl $0x0, (%r12)
jne 0x522bf
xorl %ecx, %ecx
movb %cl, 0xc(%rax)
movl $0xe, 0x8(%rax)
movq %r14, 0x10(%rax)
movl $0x2, 0x20(%rax)
movl %ebx, 0x30(%rax)
movq %r15, 0x28(%rax)
movb %cl, 0x40(%rax)
movl 0x20(%rbp), %ecx
movl %ecx, 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_gen.c
// Function: subtilis_arm_gen_lca
void subtilis_arm_gen_lca(subtilis_ir_section_t *s, size_t start,
			  void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_instr_t *add;
	subtilis_arm_data_instr_t *datai;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *ir_op = &s->ops[start]->op.instr;

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

	(void)subtilis_add_explicit_ldr(arm_s, SUBTILIS_ARM_CCODE_AL, dest,
					ir_op->operands[1].integer, true, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	add =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_ADD, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	datai = &add->operands.data;
	datai->status = false;
	datai->ccode = SUBTILIS_ARM_CCODE_AL;
	datai->dest = dest;
	datai->op1 = 15;
	datai->op2.type = SUBTILIS_ARM_OP2_REG;
	datai->op2.op.reg = dest;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movq 0x10(%r12), %rdi
callq 0x4efba
movq %rax, %rbx
movl 0x18(%r12), %ecx
movq %r15, %rdi
movl $0xe, %esi
movq %rax, %rdx
movl $0x1, %r8d
movq %r14, %r9
callq 0x4fa8b
cmpl $0x0, (%r14)
jne 0x523fb
movq %r15, %rdi
movl $0x4, %esi
movq %r14, %rdx
callq 0x4f6e2
cmpl $0x0, (%r14)
jne 0x523fb
movb $0x0, 0xc(%rax)
movl $0xe, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq $0xf, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_get_proc_addr
void subtilis_arm_gen_get_proc_addr(subtilis_ir_section_t *s, size_t start,
				    void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_instr_t *add;
	subtilis_arm_data_instr_t *datai;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *ir_op = &s->ops[start]->op.instr;
	size_t label = arm_s->label_counter++;

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

	subtilis_add_ldrp(arm_s, SUBTILIS_ARM_CCODE_AL, dest,
			  ir_op->operands[1].label, label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	add =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_ADD, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	datai = &add->operands.data;
	datai->status = false;
	datai->ccode = SUBTILIS_ARM_CCODE_AL;
	datai->dest = dest;
	datai->op1 = 15;
	datai->op2.type = SUBTILIS_ARM_OP2_REG;
	datai->op2.op.reg = dest;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r13
movq 0x10(%rdx), %r12
leaq 0x1(%r12), %rax
movq %rax, 0x10(%rdx)
movq 0x10(%r13), %rdi
callq 0x4efba
movq %rax, %r14
movq 0x18(%r13), %rcx
movq %r15, %rdi
movl $0xe, %esi
movq %rax, %rdx
movq %r12, %r8
movq %rbx, %r9
callq 0x4fb5d
cmpl $0x0, (%rbx)
jne 0x5248d
movq %r15, %rdi
movl $0x4, %esi
movq %rbx, %rdx
callq 0x4f6e2
cmpl $0x0, (%rbx)
jne 0x5248d
movb $0x0, 0xc(%rax)
movl $0xe, 0x8(%rax)
movq %r14, 0x10(%rax)
movq $0xf, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq %r14, 0x28(%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_gen.c
// Function: subtilis_arm_gen_sete
void subtilis_arm_gen_sete(subtilis_arm_section_t *arm_s,
			   subtilis_ir_section_t *s,
			   subtilis_arm_ccode_type_t ccode, size_t reg,
			   int32_t error_code, subtilis_error_t *err)
{
	subtilis_arm_add_mov_imm(arm_s, ccode, false, reg, -1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_stran_imm(arm_s, SUBTILIS_ARM_INSTR_STR, ccode, reg,
				   12, s->eflag_offset, false, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_imm(arm_s, ccode, false, reg, error_code, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_stran_imm(arm_s, SUBTILIS_ARM_INSTR_STR, ccode, reg,
				   12, s->error_offset, false, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %r13d
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r15
movl $0xd, %esi
movl $0xf, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
movq %r14, %r9
pushq %rbx
pushq $-0x1
callq 0x50130
addq $0x10, %rsp
cmpl $0x0, (%rbx)
jne 0x52528
movl 0x8c(%r12), %r9d
movl $0xc, %r8d
movq %r15, %rdi
movl $0x13, %esi
movl %ebp, %edx
movq %r14, %rcx
pushq %rbx
pushq $0x0
callq 0x50516
addq $0x10, %rsp
cmpl $0x0, (%rbx)
jne 0x52528
movq %r15, %rdi
movl $0xd, %esi
movl $0xf, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
movq %r14, %r9
pushq %rbx
pushq %r13
callq 0x50130
addq $0x10, %rsp
cmpl $0x0, (%rbx)
je 0x52537
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x90(%r12), %r9d
movl $0xc, %r8d
movq %r15, %rdi
movl $0x13, %esi
movl %ebp, %edx
movq %r14, %rcx
pushq %rbx
pushq $0x0
callq 0x50516
addq $0x18, %rsp
jmp 0x5252c
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_sete_load_reg
void subtilis_arm_gen_sete_load_reg(subtilis_arm_section_t *arm_s,
				    subtilis_ir_section_t *s,
				    subtilis_arm_ccode_type_t ccode, size_t reg,
				    subtilis_error_t *err)
{
	subtilis_arm_add_mov_imm(arm_s, ccode, false, reg, -1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_stran_imm(arm_s, SUBTILIS_ARM_INSTR_STR, ccode, reg,
				   12, s->eflag_offset, false, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_stran_imm(arm_s, SUBTILIS_ARM_INSTR_LDR, ccode, 0, 0,
				   0, false, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_stran_imm(arm_s, SUBTILIS_ARM_INSTR_STR, ccode, 0, 12,
				   s->error_offset, false, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movl $0xd, %esi
movl $0xf, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
movq %r12, %r9
pushq %rbx
pushq $-0x1
callq 0x50130
addq $0x10, %rsp
cmpl $0x0, (%rbx)
jne 0x5260c
movl 0x8c(%r15), %r9d
movl $0xc, %r8d
movq %r14, %rdi
movl $0x13, %esi
movl %ebp, %edx
movq %r12, %rcx
pushq %rbx
pushq $0x0
callq 0x50516
addq $0x10, %rsp
cmpl $0x0, (%rbx)
jne 0x5260c
movq %r14, %rdi
movl $0x12, %esi
movl %ebp, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rbx
pushq $0x0
callq 0x50516
addq $0x10, %rsp
cmpl $0x0, (%rbx)
jne 0x5260c
movl 0x90(%r15), %r9d
movl $0xc, %r8d
movq %r14, %rdi
movl $0x13, %esi
movl %ebp, %edx
xorl %ecx, %ecx
pushq %rbx
pushq $0x0
callq 0x50516
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_signx8to32_helper
void subtilis_arm_gen_signx8to32_helper(subtilis_arm_section_t *arm_s,
					subtilis_arm_reg_t dest,
					subtilis_arm_reg_t src,
					subtilis_error_t *err)

{
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *datai;

	subtilis_arm_add_cmp_imm(arm_s, SUBTILIS_ARM_INSTR_TST,
				 SUBTILIS_ARM_CCODE_AL, src, 1 << 7, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

	subtilis_arm_add_data_imm(arm_s, SUBTILIS_ARM_INSTR_AND,
				  SUBTILIS_ARM_CCODE_EQ, false, dest, dest,
				  0xff, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mvn_imm(arm_s, SUBTILIS_ARM_CCODE_NE, false, dest, 255,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	instr =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_ORR, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	datai = &instr->operands.data;
	datai->status = false;
	datai->ccode = SUBTILIS_ARM_CCODE_NE;
	datai->dest = dest;
	datai->op1 = dest;
	datai->op2.type = SUBTILIS_ARM_OP2_REG;
	datai->op2.op.reg = src;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movl $0x8, %esi
movl $0xe, %edx
movq %rbx, %rcx
movl $0x80, %r8d
movq %r15, %r9
callq 0x508d6
cmpl $0x0, (%r15)
jne 0x52700
subq $0x8, %rsp
movq %r12, %rdi
movl $0xd, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
movq %rbx, %r9
pushq %r15
callq 0x504b3
addq $0x10, %rsp
cmpl $0x0, (%r15)
jne 0x52700
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
movq %r14, %r9
pushq %r15
pushq $0xff
callq 0x50297
addq $0x10, %rsp
cmpl $0x0, (%r15)
jne 0x52700
movq %r12, %rdi
movl $0xf, %esi
movl $0xd, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
movq %r14, %r9
pushq %r15
pushq $0xff
callq 0x50130
addq $0x10, %rsp
cmpl $0x0, (%r15)
jne 0x52700
movq %r12, %rdi
movl $0xc, %esi
movq %r15, %rdx
callq 0x4f6e2
cmpl $0x0, (%r15)
jne 0x52700
movb $0x0, 0xc(%rax)
movl $0x1, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r14, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: prv_cmp_simple
static void prv_cmp_simple(subtilis_ir_section_t *s, size_t start,
			   void *user_data, subtilis_arm_instr_type_t itype,
			   subtilis_arm_ccode_type_t ccode,
			   subtilis_error_t *err)
{
	subtilis_arm_reg_t op1;
	subtilis_arm_reg_t op2;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *ir_op = &s->ops[start]->op.instr;

	op1 = subtilis_arm_ir_to_arm_reg(ir_op->operands[1].reg);
	op2 = subtilis_arm_ir_to_arm_reg(ir_op->operands[2].reg);

	subtilis_arm_add_cmp(arm_s, itype, ccode, op1, op2, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq (%rdi,%rsi,8), %r12
movq 0x18(%r12), %rdi
callq 0x4efba
movq %rax, %r15
movq 0x20(%r12), %rdi
callq 0x4efba
movq %r14, %rdi
movl $0xa, %esi
movl $0xe, %edx
movq %r15, %rcx
movq %rax, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5099c
nop
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_walker.c
// Function: prv_arm_walk
static void prv_arm_walk(subtilis_arm_section_t *arm_s, size_t ptr,
			 subtilis_arm_op_t *to, subtlis_arm_walker_t *walker,
			 subtilis_error_t *err)
{
	subtilis_arm_op_t *op;

	while (ptr != SIZE_MAX) {
		op = &arm_s->op_pool->ops[ptr];

		switch (op->type) {
		case SUBTILIS_ARM_OP_LABEL:
			walker->label_fn(walker->user_data, op, op->op.label,
					 err);
			break;
		case SUBTILIS_ARM_OP_INSTR:
			prv_walk_instr(walker, op, err);
			break;
		case SUBTILIS_ARM_OP_ALIGN:
		case SUBTILIS_ARM_OP_BYTE:
		case SUBTILIS_ARM_OP_TWO_BYTE:
		case SUBTILIS_ARM_OP_FOUR_BYTE:
		case SUBTILIS_ARM_OP_DOUBLE:
		case SUBTILIS_ARM_OP_DOUBLER:
		case SUBTILIS_ARM_OP_FLOAT:
		case SUBTILIS_ARM_OP_STRING:
			if (!walker->directive_fn) {
				subtilis_error_set_assertion_failed(err);
				break;
			}
			walker->directive_fn(walker->user_data, op, err);
			break;
		default:
			subtilis_error_set_assertion_failed(err);
			break;
		}
		if (err->type != SUBTILIS_ERROR_OK)
			return;

		if (op == to)
			break;

		ptr = op->next;
	}
}

// Assembly:
cmpq $-0x1, %rsi
je 0x52864
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
leaq 0x23471(%rip), %r13     # 0x75c03
movq 0x38(%r12), %rax
movq (%rax), %rax
imulq $0x68, %rsi, %rcx
leaq (%rax,%rcx), %rbp
movl (%rax,%rcx), %eax
leal -0x2(%rax), %ecx
cmpl $0x8, %ecx
jae 0x527c3
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x527df
movq (%r14), %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq *%rax
jmp 0x52823
testl %eax, %eax
je 0x527f1
cmpl $0x1, %eax
jne 0x5280e
movq (%r14), %rdi
movq 0x8(%rbp), %rdx
movq %rbp, %rsi
movq %rbx, %rcx
callq *0x10(%r14)
jmp 0x52823
movq %rbx, %rdi
movl $0xf, %esi
movq %r13, %rdx
movl $0x23c, %ecx            # imm = 0x23C
jmp 0x5281e
movl 0x8(%rbp), %eax
cmpq $0xac, %rax
jb 0x5283d
movq %rbx, %rdi
movl $0xf, %esi
movq %r13, %rdx
movl $0x21b, %ecx            # imm = 0x21B
jmp 0x5281e
movq %rbx, %rdi
movl $0xf, %esi
movq %r13, %rdx
movl $0x242, %ecx            # imm = 0x242
callq 0x145a4
cmpq %r15, %rbp
je 0x52856
cmpl $0x0, (%rbx)
jne 0x52856
movq 0x58(%rbp), %rsi
cmpq $-0x1, %rsi
jne 0x52792
jmp 0x52856
movq (%r14), %rsi
movq %r14, %rdi
movq %rbp, %rdx
movq %rbx, %rcx
leaq 0x4ea00(%rip), %r8      # 0xa1250
callq *(%r8,%rax,8)
jmp 0x52823
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq