LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_dbl_unary
static subtilis_arm_exp_val_t *prv_dbl_unary(subtilis_arm_ass_context_t *c,
					     double (*fn)(double),
					     subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;

	val = prv_real_bkt_exp(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	val->val.real = fn(val->val.real);

	return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9e4f0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d348
movq $0x0, -0x8(%rbp)
jmp 0x9d368
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
callq *%rax
movq -0x28(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_rad
static subtilis_arm_exp_val_t *prv_rad(subtilis_arm_ass_context_t *c,
				       subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;
	const double radian = ((22 / 7.0) / 180);

	val = prv_real_bkt_exp(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	val->val.real = val->val.real * radian;

	return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd 0xd638(%rip), %xmm0     # 0xaa9d0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9e4f0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d3c1
movq $0x0, -0x8(%rbp)
jmp 0x9d3e3
movq -0x20(%rbp), %rax
movsd 0xd603(%rip), %xmm0     # 0xaa9d0
mulsd 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_abs
static subtilis_arm_exp_val_t *prv_abs(subtilis_arm_ass_context_t *c,
				       subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;

	val = prv_bracketed_exp(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	switch (val->type) {
	case SUBTILIS_ARM_EXP_TYPE_INT:
		if (val->val.integer < 0)
			val->val.integer = -val->val.integer;
		break;
	case SUBTILIS_ARM_EXP_TYPE_REAL:
		if (val->val.real < 0)
			val->val.real = -val->val.real;
		break;
	default:
		subtilis_error_set_numeric_exp_expected(err, c->l->stream->name,
							c->l->line);
		goto cleanup;
	}

	return val;

cleanup:

	subtilis_arm_exp_val_free(val);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9e3c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d427
movq $0x0, -0x8(%rbp)
jmp 0x9d4e5
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x6, %eax
je 0x9d441
jmp 0x9d437
movl -0x24(%rbp), %eax
subl $0x7, %eax
je 0x9d45d
jmp 0x9d496
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0x9d45b
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
subl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x9d4ca
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd 0x8(%rax), %xmm0
jbe 0x9d494
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x9d4ca
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %ecx
movl $0x44, %esi
leaq 0x10f43(%rip), %r8      # 0xae400
movl $0x398, %r9d            # imm = 0x398
callq 0x15930
jmp 0x9d4d4
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9d4e5
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_sgn
static subtilis_arm_exp_val_t *prv_sgn(subtilis_arm_ass_context_t *c,
				       subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;

	val = prv_bracketed_exp(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	switch (val->type) {
	case SUBTILIS_ARM_EXP_TYPE_INT:
		if (val->val.integer < 0)
			val->val.integer = -1;
		else if (val->val.integer > 0)
			val->val.integer = 1;
		else
			val->val.integer = 0;
		break;
	case SUBTILIS_ARM_EXP_TYPE_REAL:
		val->type = SUBTILIS_ARM_EXP_TYPE_INT;
		if (val->val.real < 0)
			val->val.integer = -1;
		else if (val->val.real > 0)
			val->val.integer = 1;
		else
			val->val.integer = 0;
		break;
	default:
		subtilis_error_set_numeric_exp_expected(err, c->l->stream->name,
							c->l->line);
		goto cleanup;
	}

	return val;

cleanup:

	subtilis_arm_exp_val_free(val);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9e3c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d527
movq $0x0, -0x8(%rbp)
jmp 0x9d626
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x6, %eax
je 0x9d544
jmp 0x9d537
movl -0x24(%rbp), %eax
subl $0x7, %eax
je 0x9d584
jmp 0x9d5d7
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0x9d55b
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
jmp 0x9d57f
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x9d572
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
jmp 0x9d57d
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x9d57f
jmp 0x9d60b
movq -0x20(%rbp), %rax
movl $0x6, (%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd 0x8(%rax), %xmm0
jbe 0x9d5a9
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
jmp 0x9d5d5
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x9d5c8
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
jmp 0x9d5d3
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x9d5d5
jmp 0x9d60b
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %ecx
movl $0x44, %esi
leaq 0x10e02(%rip), %r8      # 0xae400
movl $0x412, %r9d            # imm = 0x412
callq 0x15930
jmp 0x9d615
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9d626
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_chr_str
static subtilis_arm_exp_val_t *prv_chr_str(subtilis_arm_ass_context_t *c,
					   subtilis_error_t *err)
{
	char c_str[2];
	subtilis_arm_exp_val_t *val;
	subtilis_arm_exp_val_t *val2 = NULL;

	val = prv_int_bkt_exp(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	c_str[0] = val->val.integer & 255;
	c_str[1] = 0;

	val2 = subtilis_arm_exp_new_str_str(c_str, err);

cleanup:

	subtilis_arm_exp_val_free(val);

	return val2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9e5c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d664
jmp 0x9d688
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0xff, %eax
movb %al, -0x12(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9a3f0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_asc
static subtilis_arm_exp_val_t *prv_asc(subtilis_arm_ass_context_t *c,
				       subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;
	subtilis_arm_exp_val_t *val2 = NULL;
	int32_t v;

	val = prv_bracketed_exp(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	if (val->type != SUBTILIS_ARM_EXP_TYPE_STRING) {
		subtilis_error_set_const_string_expected(
		    err, c->l->stream->name, c->l->line);
		goto cleanup;
	}

	if (subtilis_buffer_get_size(&val->val.buf) <= 1)
		v = -1;
	else
		v = subtilis_buffer_get_string(&val->val.buf)[0];

	val2 = subtilis_arm_exp_new_int32(v, err);

cleanup:

	subtilis_arm_exp_val_free(val);

	return val2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9e3c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d6df
movq $0x0, -0x8(%rbp)
jmp 0x9d76c
movq -0x20(%rbp), %rax
cmpl $0x8, (%rax)
je 0x9d71c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %ecx
movl $0x4a, %esi
leaq 0x10cf1(%rip), %r8      # 0xae400
movl $0x3c9, %r9d            # imm = 0x3C9
callq 0x15930
jmp 0x9d75b
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x16270
cmpq $0x1, %rax
ja 0x9d738
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
jmp 0x9d74b
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x16760
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x9a300
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_len
static subtilis_arm_exp_val_t *prv_len(subtilis_arm_ass_context_t *c,
				       subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;
	subtilis_arm_exp_val_t *val2 = NULL;

	val = prv_bracketed_exp(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	if (val->type != SUBTILIS_ARM_EXP_TYPE_STRING) {
		subtilis_error_set_const_string_expected(
		    err, c->l->stream->name, c->l->line);
		goto cleanup;
	}

	val2 = subtilis_arm_exp_new_int32(
	    subtilis_buffer_get_size(&val->val.buf) - 1, err);

cleanup:

	subtilis_arm_exp_val_free(val);

	return val2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9e3c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d7bc
movq $0x0, -0x8(%rbp)
jmp 0x9d82a
movq -0x20(%rbp), %rax
cmpl $0x8, (%rax)
je 0x9d7f9
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %ecx
movl $0x4a, %esi
leaq 0x10c14(%rip), %r8      # 0xae400
movl $0x3e7, %r9d            # imm = 0x3E7
callq 0x15930
jmp 0x9d819
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x16270
subq $0x1, %rax
movl %eax, %edi
movq -0x18(%rbp), %rsi
callq 0x9a300
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_left_str
static subtilis_arm_exp_val_t *prv_left_str(subtilis_arm_ass_context_t *c,
					    subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;
	int32_t start;
	int32_t len;

	val = prv_left_right(c, &start, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	len = subtilis_buffer_get_size(&val->val.buf) - 1;
	if (len == 0 || start < 0 || start >= len)
		return val;

	subtilis_buffer_delete(&val->val.buf, start, len - start, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	return val;

cleanup:

	subtilis_arm_exp_val_free(val);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x24(%rbp), %rsi
callq 0x9e690
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d878
movq $0x0, -0x8(%rbp)
jmp 0x9d8ee
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x16270
subq $0x1, %rax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x9d8a0
cmpl $0x0, -0x24(%rbp)
jl 0x9d8a0
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jl 0x9d8aa
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9d8ee
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0x24(%rbp), %rsi
movl -0x28(%rbp), %eax
subl -0x24(%rbp), %eax
movslq %eax, %rdx
movq -0x18(%rbp), %rcx
callq 0x16450
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d8d3
jmp 0x9d8dd
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9d8ee
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_right_str
static subtilis_arm_exp_val_t *prv_right_str(subtilis_arm_ass_context_t *c,
					     subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;
	int32_t start;
	int32_t len;

	val = prv_left_right(c, &start, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	len = subtilis_buffer_get_size(&val->val.buf) - 1;
	if (len == 0 || start < 0 || start >= len)
		return val;

	subtilis_buffer_delete(&val->val.buf, 0, len - start, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	subtilis_buffer_zero_terminate(&val->val.buf, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	return val;

cleanup:

	subtilis_arm_exp_val_free(val);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x24(%rbp), %rsi
callq 0x9e690
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d93b
movq $0x0, -0x8(%rbp)
jmp 0x9d9cd
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x16270
subq $0x1, %rax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x9d963
cmpl $0x0, -0x24(%rbp)
jl 0x9d963
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jl 0x9d96d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9d9cd
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movl -0x28(%rbp), %eax
subl -0x24(%rbp), %eax
movslq %eax, %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x16450
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d996
jmp 0x9d9bc
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x16560
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d9b2
jmp 0x9d9bc
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9d9cd
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_str_str
static subtilis_arm_exp_val_t *prv_str_str(subtilis_arm_ass_context_t *c,
					   subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;
	char buf[64];
	subtilis_arm_exp_val_t *val2 = NULL;

	val = prv_bracketed_exp(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	switch (val->type) {
	case SUBTILIS_ARM_EXP_TYPE_INT:
		sprintf(buf, "%" PRIi32, val->val.integer);
		break;
	case SUBTILIS_ARM_EXP_TYPE_REAL:
		sprintf(buf, "%f", val->val.real);
		break;
	default:
		subtilis_error_set_numeric_exp_expected(err, c->l->stream->name,
							c->l->line);
		goto cleanup;
	}

	val2 = subtilis_arm_exp_new_str_str(buf, err);

cleanup:

	subtilis_arm_exp_val_free(val);

	return val2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9e3c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9e26f
movq $0x0, -0x8(%rbp)
jmp 0x9e317
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
subl $0x6, %eax
je 0x9e289
jmp 0x9e27f
movl -0x6c(%rbp), %eax
subl $0x7, %eax
je 0x9e2a4
jmp 0x9e2c1
leaq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0xcc49(%rip), %rsi      # 0xaaee4
movb $0x0, %al
callq 0x12250
jmp 0x9e2f5
leaq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq 0xf408(%rip), %rsi      # 0xad6c0
movb $0x1, %al
callq 0x12250
jmp 0x9e2f5
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %ecx
movl $0x44, %esi
leaq 0x10118(%rip), %r8      # 0xae400
movl $0x580, %r9d            # imm = 0x580
callq 0x15930
jmp 0x9e306
leaq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9a3f0
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_exp_to_int
static int32_t prv_exp_to_int(subtilis_arm_ass_context_t *c,
			      subtilis_arm_exp_val_t *e1, subtilis_error_t *err)
{
	switch (e1->type) {
	case SUBTILIS_ARM_EXP_TYPE_INT:
		return e1->val.integer;
	case SUBTILIS_ARM_EXP_TYPE_REAL:
		return (int32_t)e1->val.real;
	default:
		subtilis_error_set_numeric_exp_expected(err, c->l->stream->name,
							c->l->line);
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x6, %eax
je 0x9e35e
jmp 0x9e354
movl -0x24(%rbp), %eax
subl $0x7, %eax
je 0x9e36a
jmp 0x9e378
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x9e3b1
movq -0x18(%rbp), %rax
cvttsd2si 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x9e3b1
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %ecx
movl $0x44, %esi
leaq 0x10061(%rip), %r8      # 0xae400
movl $0xf9, %r9d
callq 0x15930
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_bracketed_exp
static subtilis_arm_exp_val_t *prv_bracketed_exp(subtilis_arm_ass_context_t *c,
						 subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_arm_exp_val_t *e = NULL;

	subtilis_lexer_get(c->l, c->t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	tbuf = subtilis_token_get_text(c->t);
	if (strcmp(tbuf, "(")) {
		subtilis_error_set_expected(err, "( ", tbuf, c->l->stream->name,
					    c->l->line);
		return NULL;
	}

	e = prv_process_bktd_exp(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	subtilis_lexer_get(c->l, c->t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	return e;

cleanup:

	subtilis_arm_exp_val_free(e);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x133f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9e407
movq $0x0, -0x8(%rbp)
jmp 0x9e4de
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12d70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0xce79(%rip), %rsi      # 0xab29c
callq 0x12140
cmpl $0x0, %eax
je 0x9e47b
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0xc4a9(%rip), %rdx      # 0xaa902
leaq 0xffa0(%rip), %rax      # 0xae400
movq %rax, (%rsp)
movl $0x2f1, 0x8(%rsp)       # imm = 0x2F1
callq 0x156d0
movq $0x0, -0x8(%rbp)
jmp 0x9e4de
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9cf80
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9e49f
movq $0x0, -0x8(%rbp)
jmp 0x9e4de
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x133f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9e4c3
jmp 0x9e4cd
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9e4de
movq -0x28(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_real_bkt_exp
static subtilis_arm_exp_val_t *prv_real_bkt_exp(subtilis_arm_ass_context_t *c,
						subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;

	val = prv_bracketed_exp(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	switch (val->type) {
	case SUBTILIS_ARM_EXP_TYPE_INT:
		val->type = SUBTILIS_ARM_EXP_TYPE_REAL;
		val->val.real = (double)val->val.integer;
		break;
	case SUBTILIS_ARM_EXP_TYPE_REAL:
		break;
	default:
		subtilis_error_set_numeric_exp_expected(err, c->l->stream->name,
							c->l->line);
		goto cleanup;
	}

	return val;

cleanup:

	subtilis_arm_exp_val_free(val);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9e3c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9e527
movq $0x0, -0x8(%rbp)
jmp 0x9e5b0
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x6, %eax
je 0x9e541
jmp 0x9e537
movl -0x24(%rbp), %eax
subl $0x7, %eax
je 0x9e55f
jmp 0x9e561
movq -0x20(%rbp), %rax
movl $0x7, (%rax)
movq -0x20(%rbp), %rax
cvtsi2sdl 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x9e595
jmp 0x9e595
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %ecx
movl $0x44, %esi
leaq 0xfe78(%rip), %r8       # 0xae400
movl $0x318, %r9d            # imm = 0x318
callq 0x15930
jmp 0x9e59f
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9e5b0
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_int_bkt_exp
static subtilis_arm_exp_val_t *prv_int_bkt_exp(subtilis_arm_ass_context_t *c,
					       subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;

	val = prv_bracketed_exp(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	switch (val->type) {
	case SUBTILIS_ARM_EXP_TYPE_INT:
		break;
	case SUBTILIS_ARM_EXP_TYPE_REAL:
		val->type = SUBTILIS_ARM_EXP_TYPE_INT;
		val->val.integer = (int32_t)val->val.real;
		break;
	default:
		subtilis_error_set_numeric_exp_expected(err, c->l->stream->name,
							c->l->line);
		goto cleanup;
	}

	return val;

cleanup:

	subtilis_arm_exp_val_free(val);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9e3c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9e5f7
movq $0x0, -0x8(%rbp)
jmp 0x9e67e
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x6, %eax
je 0x9e611
jmp 0x9e607
movl -0x24(%rbp), %eax
subl $0x7, %eax
je 0x9e613
jmp 0x9e62f
jmp 0x9e663
movq -0x20(%rbp), %rax
movl $0x6, (%rax)
movq -0x20(%rbp), %rax
cvttsd2si 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x9e663
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %ecx
movl $0x44, %esi
leaq 0xfdaa(%rip), %r8       # 0xae400
movl $0x337, %r9d            # imm = 0x337
callq 0x15930
jmp 0x9e66d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9e67e
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_exp_to_real
static double prv_exp_to_real(subtilis_arm_ass_context_t *c,
			      subtilis_arm_exp_val_t *e1, subtilis_error_t *err)
{
	switch (e1->type) {
	case SUBTILIS_ARM_EXP_TYPE_INT:
		return (double)e1->val.integer;
	case SUBTILIS_ARM_EXP_TYPE_REAL:
		return e1->val.real;
	default:
		subtilis_error_set_numeric_exp_expected(err, c->l->stream->name,
							c->l->line);
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x6, %eax
je 0x9e9ce
jmp 0x9e9c4
movl -0x24(%rbp), %eax
subl $0x7, %eax
je 0x9e9de
jmp 0x9e9ee
movq -0x18(%rbp), %rax
cvtsi2sdl 0x8(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x9ea28
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x9ea28
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %ecx
movl $0x44, %esi
leaq 0xf9eb(%rip), %r8       # 0xae400
movl $0x108, %r9d            # imm = 0x108
callq 0x15930
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_logical_int
static subtilis_arm_exp_val_t *prv_logical_int(subtilis_arm_ass_context_t *c,
					       subtilis_arm_exp_val_t *e1,
					       subtilis_arm_exp_val_t *e2,
					       subtilis_ass_log_int_fn_t fn,
					       subtilis_error_t *err)
{
	int32_t val1;
	int32_t val2;

	val1 = prv_exp_to_int(c, e1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	val2 = prv_exp_to_int(c, e2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	e1->type = SUBTILIS_ARM_EXP_TYPE_INT;
	e1->val.integer = fn(val1, val2);

	subtilis_arm_exp_val_free(e2);
	return e1;

cleanup:

	subtilis_arm_exp_val_free(e2);
	subtilis_arm_exp_val_free(e1);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x9e330
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9ea7b
jmp 0x9eacc
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x9e330
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9ea9a
jmp 0x9eacc
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %edi
movl -0x38(%rbp), %esi
callq *%rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9eae6
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq -0x18(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_logical_real
static subtilis_arm_exp_val_t *prv_logical_real(subtilis_arm_ass_context_t *c,
						subtilis_arm_exp_val_t *e1,
						subtilis_arm_exp_val_t *e2,
						subtilis_ass_log_real_fn_t fn,
						subtilis_error_t *err)
{
	double val1;
	double val2;

	val1 = prv_exp_to_real(c, e1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	val2 = prv_exp_to_real(c, e2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	e1->type = SUBTILIS_ARM_EXP_TYPE_INT;
	e1->val.integer = fn(val1, val2);
	subtilis_arm_exp_val_free(e2);
	return e1;

cleanup:

	subtilis_arm_exp_val_free(e2);
	subtilis_arm_exp_val_free(e1);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x9e9a0
movsd %xmm0, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9eb2d
jmp 0x9eb84
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x9e9a0
movsd %xmm0, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9eb4e
jmp 0x9eb84
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
movq -0x28(%rbp), %rax
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
callq *%rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9eb9e
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq -0x18(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_movr
void subtilis_fpa_gen_movr(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_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;

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

	subtilis_fpa_add_mov(arm_s, SUBTILIS_ARM_CCODE_AL,
			     SUBTILIS_FPA_ROUNDING_NEAREST, dest, op2, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x70810
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x70810
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xe, %esi
movl $0x21, %edx
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x873b0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_movir
void subtilis_fpa_gen_movir(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;
	double op2 = instr->operands[1].real;

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

	subtilis_fpa_add_mov_imm(arm_s, SUBTILIS_ARM_CCODE_AL,
				 SUBTILIS_FPA_ROUNDING_NEAREST, dest, op2, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x70810
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %r9
movsd -0x40(%rbp), %xmm0
movq -0x20(%rbp), %rax
movl $0xe, %esi
movl $0x21, %edx
movl $0x22, %ecx
xorl %r8d, %r8d
movq %rax, (%rsp)
callq 0x871f0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_movri32
void subtilis_fpa_gen_movri32(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_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);
	op2 = subtilis_arm_ir_to_freg(instr->operands[1].reg);

	subtilis_fpa_add_tran(arm_s, SUBTILIS_FPA_INSTR_FIX,
			      SUBTILIS_ARM_CCODE_AL, SUBTILIS_FPA_ROUNDING_ZERO,
			      dest, op2, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x70810
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0x3f, %esi
movl $0xe, %edx
movl $0x3, %ecx
movq %rax, (%rsp)
callq 0x87760
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_movi32r
void subtilis_fpa_gen_movi32r(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_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;

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

	subtilis_fpa_add_tran(arm_s, SUBTILIS_FPA_INSTR_FLT,
			      SUBTILIS_ARM_CCODE_AL,
			      SUBTILIS_FPA_ROUNDING_NEAREST, dest, op2, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x70810
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0x3e, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x87760
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: prv_gen_callr
static void prv_gen_callr(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_REAL, indirect, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

	subtilis_fpa_add_mov(arm_s, SUBTILIS_ARM_CCODE_AL,
			     SUBTILIS_FPA_ROUNDING_NEAREST, dest, op1, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %al
movq -0x28(%rbp), %r9
movl $0x2, %ecx
andb $0x1, %al
movzbl %al, %r8d
callq 0x748f0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9ef6d
jmp 0x9efab
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x70810
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq -0x28(%rbp), %rax
movl $0xe, %esi
movl $0x21, %edx
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x873b0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_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_fpa_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.fpa_data;
	datai->ccode = ccode;
	datai->size = 8;
	datai->rounding = SUBTILIS_FPA_ROUNDING_NEAREST;
	datai->dest = subtilis_arm_ir_to_freg(ir_op->operands[0].reg);
	datai->op1 = subtilis_arm_ir_to_freg(ir_op->operands[1].reg);
	datai->immediate = false;
	datai->op2.reg = subtilis_arm_ir_to_freg(ir_op->operands[2].reg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x70b50
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9f09e
jmp 0x9f11a
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x20(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq $0x8, 0x8(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x70810
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x70810
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x70810
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: prv_data_simple_imm
static void prv_data_simple_imm(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 dest;
	subtilis_arm_reg_t op1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	double op2 = instr->operands[2].real;

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

	subtilis_fpa_add_data_imm(arm_s, itype, ccode,
				  SUBTILIS_FPA_ROUNDING_NEAREST, dest, op1, op2,
				  err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x70810
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x70810
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movsd -0x50(%rbp), %xmm0
movq -0x28(%rbp), %rax
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x87450
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_divr
void subtilis_fpa_gen_divr(subtilis_ir_section_t *s, size_t start,
			   void *user_data, subtilis_error_t *err)
{
	subtilis_arm_section_t *arm_s = user_data;

	prv_data_simple(s, start, user_data, SUBTILIS_FPA_INSTR_DVF,
			SUBTILIS_ARM_CCODE_AL, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	prv_check_divbyzero(arm_s, s, SUBTILIS_ERROR_CODE_DIV_BY_ZERO, 2, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %r9
movl $0x27, %ecx
movl $0xe, %r8d
callq 0x9f040
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9f38b
jmp 0x9f3a6
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %r8
movl $0x12, %edx
movl $0x2, %ecx
callq 0x9f3b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_rdivir
void subtilis_fpa_gen_rdivir(subtilis_ir_section_t *s, size_t start,
			     void *user_data, subtilis_error_t *err)
{
	subtilis_arm_section_t *arm_s = user_data;

	prv_data_simple_imm(s, start, user_data, SUBTILIS_FPA_INSTR_RDF,
			    SUBTILIS_ARM_CCODE_AL, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	prv_check_divbyzero(arm_s, s, SUBTILIS_ERROR_CODE_DIV_BY_ZERO, 2, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %r9
movl $0x28, %ecx
movl $0xe, %r8d
callq 0x9f160
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9f62b
jmp 0x9f646
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %r8
movl $0x12, %edx
movl $0x2, %ecx
callq 0x9f3b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_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, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t base;
	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;

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

	subtilis_fpa_add_stran(arm_s, itype, SUBTILIS_ARM_CCODE_AL, dest, base,
			       offset, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x70810
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movl -0x4(%rbp), %esi
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movl -0x4c(%rbp), %r9d
movq -0x28(%rbp), %rax
movl $0xe, %edx
movq %rax, (%rsp)
callq 0x87620
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_retr
void subtilis_fpa_gen_retr(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_freg(instr->operands[0].reg);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x70810
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x40(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xe, %esi
movl $0x21, %edx
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x873b0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9f7f1
jmp 0x9f806
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x75340
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_gen.c
// Function: subtilis_fpa_gen_retir
void subtilis_fpa_gen_retir(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;
	double op2 = instr->operands[0].real;

	dest = 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %r9
movsd -0x40(%rbp), %xmm0
movq -0x20(%rbp), %rax
movl $0xe, %esi
movl $0x21, %edx
movl $0x22, %ecx
xorl %r8d, %r8d
movq %rax, (%rsp)
callq 0x871f0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9f895
jmp 0x9f8aa
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x75340
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/fpa_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_freg(cmp->operands[1].reg);

	subtilis_fpa_add_cmf_imm(arm_s, SUBTILIS_ARM_CCODE_AL, op1,
				 cmp->operands[2].real, 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x70810
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %r8
movq -0x50(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x28(%rbp), %r9
movl $0x40, %esi
movl $0x41, %edx
movl $0xe, %ecx
callq 0x87800
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9f989
jmp 0x9f9e2
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x16, %esi
callq 0x70b50
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9f9aa
jmp 0x9f9e2
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)