LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x4c214
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4c214
movq %rbx, (%rsp)
pushq $0xe
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %r15, %rcx
movq %rax, %r8
movl %ebp, %r9d
callq 0x4d05b
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4c214
movq %rax, %r15
movq 0x18(%r13), %rdi
callq 0x4c214
movq %rax, %r12
movq 0x20(%r13), %rdi
callq 0x4c214
movq %rbx, (%rsp)
pushq $0xe
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %r15, %rcx
movq %r12, %r8
movq %rax, %r9
callq 0x4d2d0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: 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 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r15
movq %rdx, %rdi
movl %ecx, %esi
movq %r8, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x4e043
movq %rax, %rbx
movl $0xe, 0x8(%rax)
movq 0x10(%r15), %rdi
callq 0x4c214
movq %rax, 0x10(%rbx)
movq 0x18(%r15), %rdi
callq 0x4c214
movq %rax, 0x18(%rbx)
andl $0x0, 0x20(%rbx)
movq 0x20(%r15), %rdi
callq 0x4c214
movq %rax, 0x28(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %r8, (%rsp)
movq %rcx, %r15
movl %edi, %ebp
movq 0x48(%rsi), %rax
movq (%rax,%rdx,8), %rbx
movl 0x20(%rbx), %r12d
movq 0x10(%rbx), %rdi
callq 0x4c214
movq %rax, %r13
movq 0x18(%rbx), %rdi
callq 0x4c214
pushq $0xe
popq %rdx
movq %r15, %rdi
movl %ebp, %esi
movq %r13, %rcx
movq %rax, %r8
movl %r12d, %r9d
pushq %r14
pushq 0x8(%rsp)
callq 0x4d55b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_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 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r13
movq 0x8(%rax,%rsi,8), %r12
movq 0x18(%r13), %rdi
callq 0x4c214
movl 0x20(%r13), %r8d
pushq $0xa
popq %rsi
pushq $0xe
popq %rdx
movq %r15, %rdi
movq %rax, %rcx
movq %r14, %r9
callq 0x4d87e
cmpl $0x0, (%r14)
jne 0x4e198
pushq $0x16
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x4e198
movl %ebx, 0x8(%rax)
movb $0x0, 0xc(%rax)
andl $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_O2/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 0x48(%rdi), %rax
movq 0x8(%rax,%rsi,8), %r12
movq %r8, %rcx
callq 0x4f3b4
cmpl $0x0, (%r14)
jne 0x4e22c
pushq $0x16
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x4e22c
movl %ebx, 0x8(%rax)
movb $0x0, 0xc(%rax)
andl $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_O2/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
subq $0x10, %rsp
movq %r9, %r15
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movq 0x18(%r12), %rdi
callq 0x4c214
movl 0x20(%r12), %r8d
pushq $0xa
popq %rsi
pushq $0xe
popq %rdx
movq %r14, %rdi
movq %rax, %rcx
movq %r15, %r9
callq 0x4d87e
cmpl $0x0, (%r15)
jne 0x4e307
movq 0x10(%r12), %rdi
callq 0x4c214
movq %rax, %r12
movq %r15, 0x8(%rsp)
orl $-0x1, (%rsp)
pushq $0xd
popq %rsi
pushq $0xf
popq %rdx
movq %r14, %rdi
movl %ebp, %ecx
xorl %r8d, %r8d
movq %rax, %r9
callq 0x4d213
cmpl $0x0, (%r15)
jne 0x4e307
movq %r15, 0x8(%rsp)
andl $0x0, (%rsp)
pushq $0xd
popq %rsi
pushq $0xf
popq %rdx
movq %r14, %rdi
movl %ebx, %ecx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x4d213
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x10, %rsp
movq %r9, %r15
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movq %r9, %rcx
callq 0x4f3b4
cmpl $0x0, (%r15)
jne 0x4e3e7
movq 0x10(%r12), %rdi
callq 0x4c214
movq %rax, %r12
movq %r15, 0x8(%rsp)
orl $-0x1, (%rsp)
pushq $0xd
popq %rsi
pushq $0xf
popq %rdx
movq %r14, %rdi
movl %ebp, %ecx
xorl %r8d, %r8d
movq %rax, %r9
callq 0x4d213
cmpl $0x0, (%r15)
jne 0x4e3e7
movq %r15, 0x8(%rsp)
andl $0x0, (%rsp)
pushq $0xd
popq %rsi
pushq $0xf
popq %rdx
movq %r14, %rdi
movl %ebx, %ecx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x4d213
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x16
popq %rsi
movq %rdx, %rdi
movq %rcx, %rdx
callq 0x4c92b
cmpl $0x0, (%rbx)
jne 0x4e476
movl $0xe, 0x8(%rax)
movb $0x0, 0xc(%rax)
andl $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_O2/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 0x4c214
pushq $0xa
popq %rsi
pushq $0xe
popq %rdx
movq %r14, %rdi
movq %rax, %rcx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x4d87e
cmpl $0x0, (%rbx)
jne 0x4e4dd
pushq $0x16
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4c92b
cmpl $0x0, (%rbx)
jne 0x4e4dd
andl $0x0, 0x8(%rax)
movb $0x0, 0xc(%rax)
andl $0x0, 0x10(%rax)
movq 0x20(%r15), %rcx
movq %rcx, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_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 0x4c214
pushq $0xa
popq %rsi
pushq $0xe
popq %rdx
movq %r14, %rdi
movq %rax, %rcx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x4d87e
cmpl $0x0, (%rbx)
jne 0x4e545
pushq $0x16
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4c92b
cmpl $0x0, (%rbx)
jne 0x4e545
movl $0x1, 0x8(%rax)
movb $0x0, 0xc(%rax)
andl $0x0, 0x10(%rax)
movq 0x18(%r15), %rcx
movq %rcx, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_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 0x4c214
pushq $0xa
popq %rsi
pushq $0xe
popq %rdx
movq %r14, %rdi
movq %rax, %rcx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x4d87e
cmpl $0x0, (%rbx)
jne 0x4e5d4
pushq $0x16
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4c92b
cmpl $0x0, (%rbx)
jne 0x4e5d4
movl $0x1, 0x8(%rax)
movb $0x0, 0xc(%rax)
andl $0x0, 0x10(%rax)
movq 0x18(%r15), %rcx
movq %rcx, 0x18(%rax)
pushq $0x16
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4c92b
cmpl $0x0, (%rbx)
jne 0x4e5d4
andl $0x0, 0x8(%rax)
movb $0x0, 0xc(%rax)
andl $0x0, 0x10(%rax)
movq 0x20(%r15), %rcx
movq %rcx, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x48(%rdi), %rax
movq 0x8(%rax,%rsi,8), %r12
movq %r9, %rcx
callq 0x4f3b4
cmpl $0x0, (%r14)
jne 0x4e659
movq 0x10(%r12), %rdi
callq 0x4c214
movq %rax, 0x10(%rsp)
movq 0x20(%r12), %rdi
callq 0x4c214
movq %rax, %r13
movq 0x28(%r12), %rdi
callq 0x4c214
movq %r14, (%rsp)
movq %r15, %rdi
movq 0x10(%rsp), %rsi
movq %r13, %rdx
movq %rax, %rcx
movl %ebp, %r8d
movl %ebx, %r9d
callq 0x4d483
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_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 0x4c214
movq %rax, %r15
movq 0x18(%rbp), %rdi
callq 0x4c214
movq %rax, %r12
movq 0x20(%rbp), %rdi
callq 0x4c214
movq %rax, %r13
movq 0x28(%rbp), %rdi
callq 0x4c214
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 0x4d43b
// File: /workspace/github_c_makefile_star2_O2/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 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movq 0x10(%r12), %rdi
callq 0x4c214
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4c214
movl 0x20(%r12), %r10d
pushq $0xe
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
xorl %ecx, %ecx
movq %r15, %r8
movq %rax, %r9
pushq %rbx
pushq %r10
callq 0x4d357
popq %rax
popq %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rcx
movq %r14, %r9
callq 0x4e7c3
cmpl $0x0, (%r14)
jne 0x4ed72
movq 0x18(%r15), %rdi
callq 0x4c214
movq %r14, (%rsp)
pushq $0xd
popq %rsi
pushq $0xe
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x4d518
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_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
pushq $0x4
popq %rsi
movq %rdx, %rdi
movq %rcx, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x4ee02
movb $0x0, 0xc(%rax)
movl $0xe, 0x8(%rax)
pushq $0xd
popq %rcx
movq %rcx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movl $0x1, 0x20(%rax)
andl $0x0, 0x28(%rax)
movq 0x28(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4c4e7
cmpl $0x0, (%r14)
jne 0x4ee02
movq %r14, (%rsp)
pushq $0xd
popq %rsi
pushq $0xe
popq %rdx
pushq $0xf
popq %r8
pushq $0xe
popq %r9
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x4d518
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4c214
movq %rbx, (%rsp)
pushq $0xd
popq %rsi
pushq $0xe
popq %rdx
movq %r14, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rax, %r9
callq 0x4d518
cmpl $0x0, (%rbx)
je 0x4ee4c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4ed92
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0xd
popq %rsi
pushq $0xf
popq %rdx
pushq $0xe
popq %rcx
movq %r14, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rbx
pushq %rax
callq 0x4d213
popq %rax
popq %rcx
cmpl $0x0, (%rbx)
je 0x4ee9b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4ed92
// File: /workspace/github_c_makefile_star2_O2/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 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r13
movq 0x10(%r13), %rdi
callq 0x4c214
movq %rax, %r15
movq 0x18(%r13), %rdi
callq 0x4c214
movq %rax, %r12
movq 0x20(%r13), %rdi
callq 0x4c214
movq %rax, %r13
pushq $0xd
popq %rsi
movq %rbp, %rdi
movq %r14, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x4ef2c
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_O2/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 0x48(%rdi), %rax
movq (%rax,%rsi,8), %rbp
movq 0x10(%rbp), %rdi
callq 0x4c214
movq %rax, %r14
movq 0x18(%rbp), %rdi
callq 0x4c214
movq %rax, %r15
pushq $0xd
popq %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x4c92b
cmpl $0x0, (%r12)
jne 0x4efb1
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_O2/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 0x4c214
movq %rax, %rbx
movl 0x18(%r12), %ecx
pushq $0xe
popq %rsi
pushq $0x1
popq %r8
movq %r15, %rdi
movq %rax, %rdx
movq %r14, %r9
callq 0x4cc95
cmpl $0x0, (%r14)
jne 0x4f0c8
pushq $0x4
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x4c92b
cmpl $0x0, (%r14)
jne 0x4f0c8
movb $0x0, 0xc(%rax)
movl $0xe, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq $0xf, 0x18(%rax)
andl $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_O2/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 0x4c214
movq %rax, %r14
movq 0x18(%r13), %rcx
pushq $0xe
popq %rsi
movq %r15, %rdi
movq %rax, %rdx
movq %r12, %r8
movq %rbx, %r9
callq 0x4cd46
cmpl $0x0, (%rbx)
jne 0x4f153
pushq $0x4
popq %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x4c92b
cmpl $0x0, (%rbx)
jne 0x4f153
movb $0x0, 0xc(%rax)
movl $0xe, 0x8(%rax)
movq %r14, 0x10(%rax)
movq $0xf, 0x18(%rax)
andl $0x0, 0x20(%rax)
movq %r14, 0x28(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_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
subq $0x10, %rsp
movq %r9, 0x8(%rsp)
orl $-0x1, (%rsp)
pushq $0xd
popq %rsi
pushq $0xf
popq %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x4d213
popq %rax
popq %rcx
cmpl $0x0, (%rbx)
jne 0x4f1e6
movl 0x8c(%r12), %r9d
pushq $0x13
popq %rsi
pushq $0xc
popq %r8
movq %r15, %rdi
movl %ebp, %edx
movq %r14, %rcx
pushq %rbx
pushq $0x0
callq 0x4d55b
popq %rax
popq %rcx
cmpl $0x0, (%rbx)
jne 0x4f1e6
pushq $0xd
popq %rsi
pushq $0xf
popq %rdx
movq %r15, %rdi
movl %ebp, %ecx
xorl %r8d, %r8d
movq %r14, %r9
pushq %rbx
pushq %r13
callq 0x4d213
popq %rax
popq %rcx
cmpl $0x0, (%rbx)
je 0x4f1f5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x90(%r12), %r9d
pushq $0x13
popq %rsi
pushq $0xc
popq %r8
movq %r15, %rdi
movl %ebp, %edx
movq %r14, %rcx
pushq %rbx
pushq $0x0
callq 0x4d55b
addq $0x18, %rsp
jmp 0x4f1ea
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r15
movq %rcx, %r13
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movq %r8, 0x8(%rsp)
orl $-0x1, (%rsp)
pushq $0xd
popq %rsi
pushq $0xf
popq %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
movq %r13, %r9
callq 0x4d213
cmpl $0x0, (%r15)
jne 0x4f2ca
movl 0x8c(%r12), %r9d
movq %r15, 0x8(%rsp)
andl $0x0, (%rsp)
pushq $0x13
popq %rsi
pushq $0xc
popq %r8
movq %r14, %rdi
movl %ebx, %edx
movq %r13, %rcx
callq 0x4d55b
cmpl $0x0, (%r15)
jne 0x4f2ca
andl $0x0, (%rsp)
movq %r15, 0x8(%rsp)
pushq $0x12
popq %rsi
movq %r14, %rdi
movl %ebx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x4d55b
cmpl $0x0, (%r15)
jne 0x4f2ca
movl 0x90(%r12), %r9d
movq %r15, 0x8(%rsp)
andl $0x0, (%rsp)
pushq $0x13
popq %rsi
pushq $0xc
popq %r8
movq %r14, %rdi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x4d55b
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_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
pushq $0x8
popq %rsi
pushq $0xe
popq %rdx
movq %rbx, %rcx
movl $0x80, %r8d
movq %r15, %r9
callq 0x4d87e
cmpl $0x0, (%r15)
jne 0x4f3a8
subq $0x8, %rsp
pushq $0xd
popq %rsi
movq %r12, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
movq %rbx, %r9
pushq %r15
callq 0x4d518
popq %rax
popq %rcx
cmpl $0x0, (%r15)
jne 0x4f3a8
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
movq %r14, %r9
pushq %r15
pushq $0xff
callq 0x4d357
popq %rax
popq %rcx
cmpl $0x0, (%r15)
jne 0x4f3a8
pushq $0xf
popq %rsi
pushq $0xd
popq %rdx
pushq $0x1
popq %rcx
movq %r12, %rdi
xorl %r8d, %r8d
movq %r14, %r9
pushq %r15
pushq $0xff
callq 0x4d213
popq %rax
popq %rcx
cmpl $0x0, (%r15)
jne 0x4f3a8
pushq $0xc
popq %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x4c92b
cmpl $0x0, (%r15)
jne 0x4f3a8
movb $0x0, 0xc(%rax)
movl $0x1, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r14, 0x18(%rax)
andl $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_O2/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 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movq 0x18(%r12), %rdi
callq 0x4c214
movq %rax, %r15
movq 0x20(%r12), %rdi
callq 0x4c214
pushq $0xa
popq %rsi
pushq $0xe
popq %rdx
movq %r14, %rdi
movq %r15, %rcx
movq %rax, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4d921
nop
// File: /workspace/github_c_makefile_star2_O2/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:
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
pushq $0xf
popq %rbp
cmpq $-0x1, %rsi
je 0x4f4f7
movq 0x38(%r12), %rax
movq (%rax), %rax
imulq $0x68, %rsi, %rcx
leaq (%rax,%rcx), %r13
movl (%rax,%rcx), %eax
leal -0x2(%rax), %ecx
cmpl $0x8, %ecx
jae 0x4f467
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x4f483
movq (%r14), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq *%rax
jmp 0x4f4cb
testl %eax, %eax
je 0x4f496
cmpl $0x1, %eax
jne 0x4f4b5
movq (%r14), %rdi
movq 0x8(%r13), %rdx
movq %r13, %rsi
movq %rbx, %rcx
callq *0x10(%r14)
jmp 0x4f4cb
movq %rbx, %rdi
movl %ebp, %esi
leaq 0x20704(%rip), %rdx     # 0x6fb93
movl $0x23c, %ecx            # imm = 0x23C
jmp 0x4f4c6
movl 0x8(%r13), %eax
cmpq $0xac, %rax
jb 0x4f4de
movq %rbx, %rdi
movl %ebp, %esi
leaq 0x206e5(%rip), %rdx     # 0x6fb93
movl $0x21b, %ecx            # imm = 0x21B
jmp 0x4f4c6
movq %rbx, %rdi
movl %ebp, %esi
leaq 0x206d2(%rip), %rdx     # 0x6fb93
movl $0x242, %ecx            # imm = 0x242
callq 0x1429e
cmpq %r15, %r13
je 0x4f4f7
cmpl $0x0, (%rbx)
jne 0x4f4f7
movq 0x58(%r13), %rsi
jmp 0x4f42c
movq (%r14), %rsi
movq %r14, %rdi
movq %r13, %rdx
movq %rbx, %rcx
leaq 0x51d5f(%rip), %r8      # 0xa1250
callq *(%r8,%rax,8)
jmp 0x4f4cb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_walker.c
// Function: subtilis_arm_walk_from_to
void subtilis_arm_walk_from_to(subtilis_arm_section_t *arm_s,
			       subtlis_arm_walker_t *walker,
			       subtilis_arm_op_t *from, subtilis_arm_op_t *to,
			       subtilis_error_t *err)
{
	size_t ptr;

	if (from->next == SIZE_MAX)
		ptr = arm_s->last_op;
	else
		ptr = arm_s->op_pool->ops[from->next].prev;
	prv_arm_walk(arm_s, ptr, to, walker, err);
}

// Assembly:
movq %rsi, %rax
movq 0x58(%rdx), %rdx
cmpq $-0x1, %rdx
je 0x4f531
movq 0x38(%rdi), %rsi
movq (%rsi), %rsi
imulq $0x68, %rdx, %rdx
addq %rsi, %rdx
addq $0x60, %rdx
jmp 0x4f535
leaq 0x28(%rdi), %rdx
movq (%rdx), %rsi
movq %rcx, %rdx
movq %rax, %rcx
jmp 0x4f412
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_walker.c
// Function: prv_call_stran_misc_fn
static void prv_call_stran_misc_fn(subtlis_arm_walker_t *walker,
				   void *user_data, subtilis_arm_op_t *op,
				   subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr = &op->op.instr;

	if (!walker->stran_misc_fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	walker->stran_misc_fn(walker->user_data, op, instr->type,
			      &instr->operands.stran_misc, err);
}

// Assembly:
movq %rcx, %r8
movq 0x110(%rdi), %r9
testq %r9, %r9
je 0x4f93c
movq (%rdi), %rdi
movl 0x8(%rdx), %eax
leaq 0x10(%rdx), %rcx
movq %rdx, %rsi
movl %eax, %edx
jmpq *%r9
leaq 0x20250(%rip), %rdx     # 0x6fb93
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x139, %ecx            # imm = 0x139
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_walker.c
// Function: prv_call_simd_fn
static void prv_call_simd_fn(subtlis_arm_walker_t *walker, void *user_data,
			     subtilis_arm_op_t *op, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr = &op->op.instr;

	if (!walker->simd_fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	walker->simd_fn(walker->user_data, op, instr->type,
			&instr->operands.reg_only, err);
}

// Assembly:
movq %rcx, %r8
movq 0x118(%rdi), %r9
testq %r9, %r9
je 0x4f974
movq (%rdi), %rdi
movl 0x8(%rdx), %eax
leaq 0x10(%rdx), %rcx
movq %rdx, %rsi
movl %eax, %edx
jmpq *%r9
leaq 0x20218(%rip), %rdx     # 0x6fb93
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x147, %ecx            # imm = 0x147
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_walker.c
// Function: prv_call_signx_fn
static void prv_call_signx_fn(subtlis_arm_walker_t *walker, void *user_data,
			      subtilis_arm_op_t *op, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr = &op->op.instr;

	if (!walker->signx_fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	walker->signx_fn(walker->user_data, op, instr->type,
			 &instr->operands.signx, err);
}

// Assembly:
movq %rcx, %r8
movq 0x120(%rdi), %r9
testq %r9, %r9
je 0x4f9ac
movq (%rdi), %rdi
movl 0x8(%rdx), %eax
leaq 0x10(%rdx), %rcx
movq %rdx, %rsi
movl %eax, %edx
jmpq *%r9
leaq 0x201e0(%rip), %rdx     # 0x6fb93
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x155, %ecx            # imm = 0x155
jmp 0x1429e
nop
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: subtilis_arm_reg_alloc_calculate_dist
int subtilis_arm_reg_alloc_calculate_dist(subtilis_arm_reg_ud_t *ud,
					  size_t reg_num, subtilis_arm_op_t *op,
					  subtlis_arm_walker_t *walker,
					  subtilis_arm_reg_class_t *regs)
{
	subtilis_error_t err;
	subtilis_arm_op_t *to;

	subtilis_error_init(&err);

	if (op->next == SIZE_MAX)
		return -1;

	op = &ud->arm_s->op_pool->ops[op->next];

	/*
	 * If we're calculating the distance for a virtual register
	 * we only need to go to the end of the basic block and not
	 * to the end of the function.  For fixed registers we need
	 * to go to the end of the function as these registers aren't
	 * currently preserved and restored as we move between basic
	 * blocks, although perhaps they should be.
	 */

	if (ud->ss_terminators && !regs->is_fixed(reg_num))
		to = ud->ss_terminators[ud->current_ss];
	else
		to = NULL;
	ud->dist_data.reg_num = reg_num;
	ud->dist_data.last_used = ud->instr_count + 1;

	subtilis_arm_walk_from_to(ud->arm_s, walker, op, to, &err);
	if (err.type != SUBTILIS_ERROR_OK)
		return ud->dist_data.last_used;
	else
		return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc18, %rsp            # imm = 0xC18
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc(%rsp), %rdi
callq 0x140a4
movq 0x58(%r12), %rax
pushq $-0x1
popq %rbp
cmpq $-0x1, %rax
je 0x4fa85
movq 0x18(%rbx), %rcx
movq 0x38(%rcx), %rcx
imulq $0x68, %rax, %r12
addq (%rcx), %r12
cmpq $0x0, 0x38(%rbx)
je 0x4fa49
movq %r15, %rdi
callq *0x70(%r13)
testb %al, %al
je 0x4fa4d
xorl %ecx, %ecx
jmp 0x4fa59
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %rcx
movq (%rax,%rcx,8), %rcx
movq %r15, 0x28(%rbx)
movl 0x20(%rbx), %eax
incl %eax
movl %eax, 0x30(%rbx)
movq 0x18(%rbx), %rdi
leaq 0xc(%rsp), %r15
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %r8
callq 0x4f510
cmpl $0x0, (%r15)
je 0x4fa85
movl 0x30(%rbx), %ebp
movl %ebp, %eax
addq $0xc18, %rsp            # imm = 0xC18
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq