LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_branch
static void prv_parse_branch(subtilis_arm_ass_context_t *c, const char *name,
			     subtilis_arm_instr_type_t itype,
			     subtilis_arm_ccode_type_t ccode,
			     subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_br_instr_t *br;
	size_t index;
	subtilis_arm_exp_val_t *val;
	size_t name_len = strlen(name);
	bool link = ((name_len == 2) || (name_len == 4)) &&
		    (name[1] == 'l' || name[1] == 'L');

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

	if (val->type != SUBTILIS_ARM_EXP_TYPE_ID) {
		subtilis_error_set_expected(err, "label", name,
					    c->l->stream->name, c->l->line);
		goto cleanup;
	}

	name = subtilis_buffer_get_string(&val->val.buf);
	if (!subtilis_string_pool_find(c->label_pool, name, &index)) {
		index = subtilis_string_pool_register(c->label_pool, name, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		subtilis_bitset_set(&c->pending_labels, index, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

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

	br = &instr->operands.br;
	br->ccode = ccode;
	br->link = link;
	br->local = true;
	br->link_type = SUBTILIS_ARM_BR_LINK_VOID;
	br->target.label = index;

cleanup:

	subtilis_arm_exp_val_free(val);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r15
movq %rsi, %rdi
callq 0x120f0
cmpq $0x4, %rax
je 0x674a1
cmpq $0x2, %rax
jne 0x674b5
movb 0x1(%r12), %al
movb $0x1, %r13b
cmpb $0x6c, %al
je 0x674b8
cmpb $0x4c, %al
sete %r13b
jmp 0x674b8
xorl %r13d, %r13d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x69632
cmpl $0x0, (%rbx)
jne 0x67563
movq %rax, %r14
cmpl $0x9, (%rax)
jne 0x67527
movq %r14, %rdi
addq $0x8, %rdi
callq 0x14db1
movq %rax, %r12
movq 0x30(%r15), %rdi
movq %rsp, %rdx
movq %rax, %rsi
callq 0x2ef1a
testb %al, %al
je 0x67572
movq (%r15), %rdi
movl $0x16, %esi
movq %rbx, %rdx
callq 0x4f6e2
cmpl $0x0, (%rbx)
jne 0x6755b
movl %ebp, 0x8(%rax)
movb %r13b, 0xc(%rax)
movb $0x1, 0xd(%rax)
movl $0x0, 0x10(%rax)
movq (%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x6755b
movq 0x8(%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xf836(%rip), %rax      # 0x76d70
leaq 0xf8fb(%rip), %rdx      # 0x76e3c
movq %rbx, %rdi
movl $0x1d, %esi
movq %r12, %rcx
pushq $0x2d4                  # imm = 0x2D4
pushq %rax
callq 0x143da
addq $0x10, %rsp
movq %r14, %rdi
callq 0x68d41
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x30(%r15), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2ef6e
movq %rax, (%rsp)
cmpl $0x0, (%rbx)
jne 0x67563
leaq 0x38(%r15), %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x5db68
cmpl $0x0, (%rbx)
jne 0x67563
jmp 0x674f6
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_swi
static void prv_parse_swi(subtilis_arm_ass_context_t *c,
			  subtilis_arm_ccode_type_t ccode,
			  subtilis_error_t *err)
{
	const char *swi_name;
	subtilis_arm_exp_val_t *val;
	size_t code;

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

	if (val->type == SUBTILIS_ARM_EXP_TYPE_INT) {
		code = (size_t)val->val.integer;
	} else if (val->type == SUBTILIS_ARM_EXP_TYPE_STRING) {
		swi_name = subtilis_buffer_get_string(&val->val.buf);
		code = c->sys_trans(swi_name);
		if (code == SIZE_MAX) {
			subtilis_error_set_sys_call_unknown(
			    err, swi_name, c->l->stream->name, c->l->line);
			goto cleanup;
		}
	} else {
		subtilis_error_set_expected(err, "string or integer expected",
					    subtilis_arm_exp_type_name(val),
					    c->l->stream->name, c->l->line);
		goto cleanup;
	}

	subtilis_arm_add_swi(c->arm_s, ccode, code, 0, 0, err);

cleanup:

	subtilis_arm_exp_val_free(val);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rdx, %rsi
callq 0x69632
cmpl $0x0, (%r14)
je 0x675ca
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl (%rax), %eax
cmpl $0x8, %eax
je 0x675df
cmpl $0x6, %eax
jne 0x67612
movslq 0x8(%rbx), %rdx
jmp 0x675fe
movq %rbx, %rdi
addq $0x8, %rdi
callq 0x14db1
movq %rax, %r12
movq %rax, %rdi
callq *0x28(%r15)
movq %rax, %rdx
cmpq $-0x1, %rax
je 0x67648
movq (%r15), %rdi
movl %ebp, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x50463
jmp 0x6767c
movq %rbx, %rdi
callq 0x6966d
movq 0x8(%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0xf743(%rip), %r10      # 0x76d70
leaq 0xf842(%rip), %rdx      # 0x76e76
movq %r14, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0x3de                  # imm = 0x3DE
pushq %r10
jmp 0x67673
movq 0x8(%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xf715(%rip), %rax      # 0x76d70
leaq 0xc7b3(%rip), %rcx      # 0x73e15
movq %r14, %rdi
movl $0x5a, %esi
movq %r12, %rdx
pushq $0x3d8                  # imm = 0x3D8
pushq %rax
callq 0x143da
addq $0x10, %rsp
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x68d41
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_mrs
static void prv_parse_mrs(subtilis_arm_ass_context_t *c,
			  subtilis_arm_ccode_type_t ccode,
			  subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op1;
	const char *tbuf;

	dest = prv_get_reg(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

	op1 = prv_get_src_flagsreg(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_flags(c->arm_s, SUBTILIS_ARM_INSTR_MRS, ccode, op1, 0,
			       dest, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movq %rdx, %rsi
callq 0x66be3
cmpl $0x0, (%rbx)
je 0x6788f
addq $0x8, %rsp
jmp 0x678e4
movq %rax, %r14
movq 0x10(%r15), %rdi
callq 0x12ad0
movq 0x10(%r15), %rcx
cmpl $0x2, (%rcx)
jne 0x678af
cmpb $0x2c, (%rax)
jne 0x678af
cmpb $0x0, 0x1(%rax)
je 0x678ef
movq 0x8(%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0xf4ae(%rip), %r10      # 0x76d70
leaq 0xbcc9(%rip), %rdx      # 0x73592
movq %rbx, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0x742                  # imm = 0x742
pushq %r10
callq 0x143da
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %rbx, %rsi
callq 0x69632
cmpl $0x0, (%rbx)
jne 0x67889
movq %rax, %r12
cmpl $0x5, (%rax)
jne 0x67912
movq 0x8(%r12), %r13
cmpq $0x2, %r13
jb 0x67956
movq %r12, %rdi
callq 0x6966d
movq 0x8(%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0xf443(%rip), %r10      # 0x76d70
leaq 0xf593(%rip), %rdx      # 0x76ec7
movq %rbx, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0x29a                  # imm = 0x29A
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq $-0x1, %r13
movq %r12, %rdi
callq 0x68d41
cmpl $0x0, (%rbx)
jne 0x67889
movq (%r15), %rdi
subq $0x8, %rsp
movl $0x1d, %esi
movl %ebp, %edx
movl %r13d, %ecx
xorl %r8d, %r8d
movq %r14, %r9
pushq %rbx
callq 0x50cc4
jmp 0x678e0
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_stran_pre_off
static void prv_parse_stran_pre_off(subtilis_arm_ass_context_t *c,
				    subtilis_arm_instr_type_t itype,
				    subtilis_arm_ccode_type_t ccode,
				    subtilis_arm_reg_t dest,
				    subtilis_arm_reg_t base, bool byte,
				    subtilis_arm_op2_t offset, bool subtract,
				    subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_arm_instr_t *instr;
	subtilis_arm_stran_instr_t *stran;
	bool write_back = false;

	tbuf = subtilis_token_get_text(c->t);
	if ((c->t->type == SUBTILIS_TOKEN_OPERATOR) && (!strcmp(tbuf, "!"))) {
		write_back = true;

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

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

	stran = &instr->operands.stran;
	stran->ccode = ccode;
	stran->dest = dest;
	stran->base = base;
	stran->offset = offset;
	stran->pre_indexed = true;
	stran->write_back = write_back;
	stran->byte = byte;
	stran->subtract = subtract;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r13d
movq %rdi, %rbx
movq 0x80(%rsp), %r12
movq 0x10(%rdi), %rdi
callq 0x12ad0
movq 0x10(%rbx), %rsi
cmpl $0x2, (%rsi)
jne 0x6861d
cmpb $0x21, (%rax)
jne 0x6861d
cmpb $0x0, 0x1(%rax)
je 0x68686
xorl %r14d, %r14d
movq (%rbx), %rdi
movl %r13d, %esi
movq %r12, %rdx
callq 0x4f6e2
cmpl $0x0, (%r12)
jne 0x68677
leaq 0x50(%rsp), %rcx
movb 0x78(%rsp), %dl
movl %ebp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq 0x10(%rsp), %rsi
movq %rsi, 0x18(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm0, 0x20(%rax)
movups %xmm1, 0x30(%rax)
movq 0x20(%rcx), %rcx
movq %rcx, 0x40(%rax)
movb $0x1, 0x48(%rax)
movb %r14b, 0x49(%rax)
movl 0xc(%rsp), %ecx
movb %cl, 0x4b(%rax)
movb %dl, 0x4a(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rdi
movq %r12, %rdx
callq 0x12edc
cmpl $0x0, (%r12)
jne 0x68677
movb $0x1, %r14b
jmp 0x68620
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_get_offset
static subtilis_arm_exp_val_t *prv_get_offset(subtilis_arm_ass_context_t *c,
					      bool *subtract,
					      subtilis_error_t *err)
{
	const char *tbuf;

	if (c->t->type == SUBTILIS_TOKEN_OPERATOR) {
		tbuf = subtilis_token_get_text(c->t);
		if (strcmp(tbuf, "-")) {
			subtilis_error_set_expected(
			    err, "-, register or integer", tbuf,
			    c->l->stream->name, c->l->line);
			return NULL;
		}
		*subtract = true;
		return subtilis_arm_exp_val_get(c, err);
	}
	return subtilis_arm_exp_pri7(c, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
cmpl $0x2, (%rdi)
jne 0x68702
movq %rsi, %r15
callq 0x12ad0
cmpb $0x2d, (%rax)
jne 0x686c5
cmpb $0x0, 0x1(%rax)
je 0x68712
movq 0x8(%r14), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0xe698(%rip), %r10      # 0x76d70
leaq 0xe7b9(%rip), %rdx      # 0x76e98
movq %rbx, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0x41c                  # imm = 0x41C
pushq %r10
callq 0x143da
addq $0x10, %rsp
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x694cf
movb $0x1, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x69632
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_int_offset
static void prv_parse_int_offset(subtilis_arm_ass_context_t *c,
				 subtilis_arm_exp_val_t *val,
				 subtilis_arm_op2_t *offset, bool *subtract,
				 subtilis_error_t *err)
{
	offset->type = SUBTILIS_ARM_OP2_I32;
	if (val->val.integer < 0) {
		*subtract = true;
		offset->op.integer = -val->val.integer;
	} else {
		offset->op.integer = val->val.integer;
	}
	if (offset->op.integer > 4095)
		subtilis_error_set_ass_bad_offset(
		    err, val->val.integer, c->l->stream->name, c->l->line);
}

// Assembly:
movl $0x1, (%rdx)
movl 0x8(%rsi), %eax
testl %eax, %eax
jns 0x68885
movb $0x1, (%rcx)
xorl %eax, %eax
subl 0x8(%rsi), %eax
movl %eax, 0x8(%rdx)
cmpl $0x1000, %eax           # imm = 0x1000
jb 0x688c4
pushq %rax
movl 0x8(%rsi), %edx
movq 0x8(%rdi), %rcx
movq 0x30(%rcx), %rax
movl 0x38(%rcx), %r9d
leaq 0xe4ca(%rip), %r10      # 0x76d70
movq %r8, %rdi
movl $0x5b, %esi
xorl %ecx, %ecx
movq %rax, %r8
pushq $0x433                  # imm = 0x433
pushq %r10
callq 0x14486
addq $0x10, %rsp
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_shift_offset
static void prv_parse_shift_offset(subtilis_arm_ass_context_t *c,
				   subtilis_arm_exp_val_t *val,
				   subtilis_arm_op2_t *offset,
				   subtilis_error_t *err)
{
	offset->op.shift.reg = val->val.reg;
	offset->type = SUBTILIS_ARM_OP2_SHIFTED;
	offset->op.shift.type = prv_get_st_shift(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	val = subtilis_arm_exp_val_get(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	if (val->type == SUBTILIS_ARM_EXP_TYPE_INT) {
		offset->op.shift.shift_reg = false;
		offset->op.shift.shift.integer = val->val.integer;
	} else if (val->type == SUBTILIS_ARM_EXP_TYPE_REG) {
		offset->op.shift.shift_reg = true;
		offset->op.shift.shift.reg = val->val.reg;
	} else {
		subtilis_error_set_expected(err, "integer or register",
					    subtilis_arm_exp_type_name(val),
					    c->l->stream->name, c->l->line);
	}

	subtilis_arm_exp_val_free(val);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq %rsi, 0x8(%rdx)
movl $0x2, (%rdx)
movq 0x10(%rdi), %rdi
callq 0x12ad0
movq %rax, %r12
movq 0x8(%r15), %rdi
movq 0x10(%r15), %rsi
movq %rbx, %rdx
callq 0x12edc
movl $0x3, %ebp
cmpl $0x0, (%rbx)
jne 0x6898c
movq 0x10(%r15), %rax
cmpl $0x1, (%rax)
jne 0x6892c
movl 0x8(%rax), %eax
addl $-0x27, %eax
cmpl $0x5, %eax
jae 0x68958
movl %eax, %eax
leaq 0xe415(%rip), %rcx      # 0x76d3c
movl (%rcx,%rax,4), %ebp
jmp 0x6898c
movq 0x8(%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xe431(%rip), %rax      # 0x76d70
leaq 0xb4cf(%rip), %rcx      # 0x73e15
movq %rbx, %rdi
movl $0x10, %esi
movq %r12, %rdx
pushq $0x3f5                  # imm = 0x3F5
jmp 0x68982
movq 0x8(%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xe405(%rip), %rax      # 0x76d70
leaq 0xe53d(%rip), %rdx      # 0x76eaf
movq %rbx, %rdi
movl $0x1d, %esi
movq %r12, %rcx
pushq $0x40b                  # imm = 0x40B
pushq %rax
callq 0x143da
addq $0x10, %rsp
movl %ebp, 0x10(%r14)
cmpl $0x0, (%rbx)
jne 0x689a5
movq %r15, %rdi
movq %rbx, %rsi
callq 0x69632
cmpl $0x0, (%rbx)
je 0x689ae
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movl (%rax), %eax
cmpl $0x1, %eax
je 0x689cd
cmpl $0x6, %eax
jne 0x689dd
movb $0x0, 0x20(%r14)
movl 0x8(%r12), %eax
movl %eax, 0x18(%r14)
jmp 0x68a1a
movb $0x1, 0x20(%r14)
movq 0x8(%r12), %rax
movq %rax, 0x18(%r14)
jmp 0x68a1a
movq %r12, %rdi
callq 0x6966d
movq 0x8(%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0xe378(%rip), %r10      # 0x76d70
leaq 0xe463(%rip), %rdx      # 0x76e62
movq %rbx, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0x44d                  # imm = 0x44D
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %r12, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x68d41
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_stran_misc_set_type
static void
prv_stran_misc_set_type(subtilis_arm_stran_misc_instr_t *stran_misc,
			const subtilis_arm_ass_modifiers_t *modifiers,
			subtilis_error_t *err)
{
	if (modifiers->byte && modifiers->status) {
		stran_misc->type = SUBTILIS_ARM_STRAN_MISC_SB;
	} else if (modifiers->hword) {
		if (modifiers->status)
			stran_misc->type = SUBTILIS_ARM_STRAN_MISC_SH;
		else
			stran_misc->type = SUBTILIS_ARM_STRAN_MISC_H;
	} else if (modifiers->dword) {
		stran_misc->type = SUBTILIS_ARM_STRAN_MISC_D;
	} else {
		subtilis_error_set_assertion_failed(err);
	}
}

// Assembly:
cmpb $0x1, 0x1(%rsi)
jne 0x68a3c
cmpb $0x1, (%rsi)
jne 0x68a3c
movl $0x0, (%rdi)
retq
cmpb $0x1, 0x3(%rsi)
jne 0x68a4e
cmpb $0x1, (%rsi)
jne 0x68a5b
movl $0x1, (%rdi)
retq
cmpb $0x1, 0x4(%rsi)
jne 0x68a62
movl $0x3, (%rdi)
retq
movl $0x2, (%rdi)
retq
leaq 0xe307(%rip), %rax      # 0x76d70
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x49a, %ecx            # imm = 0x49A
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_stran_misc_int_offset
static void prv_parse_stran_misc_int_offset(subtilis_arm_ass_context_t *c,
					    subtilis_arm_exp_val_t *val,
					    int8_t *offset, bool *subtract,
					    subtilis_error_t *err)
{
	int32_t off;

	if (val->val.integer < 0) {
		*subtract = true;
		off = -val->val.integer;
	} else {
		off = val->val.integer;
	}
	if (off > 255)
		subtilis_error_set_ass_bad_offset(
		    err, val->val.integer, c->l->stream->name, c->l->line);
	*offset = off;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl 0x8(%rsi), %edx
movl %edx, %ebp
testl %edx, %edx
jns 0x68a97
movb $0x1, (%rcx)
movl 0x8(%rsi), %edx
movl %edx, %ebp
negl %ebp
cmpl $0x100, %ebp            # imm = 0x100
jl 0x68acf
movq 0x8(%rdi), %rcx
movq 0x30(%rcx), %rax
movl 0x38(%rcx), %r9d
leaq 0xe2be(%rip), %r10      # 0x76d70
movq %r8, %rdi
movl $0x5b, %esi
xorl %ecx, %ecx
movq %rax, %r8
pushq $0x487                  # imm = 0x487
pushq %r10
callq 0x14486
addq $0x10, %rsp
movb %bpl, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_reg
static subtilis_arm_reg_t prv_parse_reg(subtilis_arm_ass_context_t *c,
					subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_arm_reg_t reg;

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

	tbuf = subtilis_token_get_text(c->t);
	reg = subtilis_arm_exp_parse_reg(c, tbuf, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return SIZE_MAX;

	if (reg == SIZE_MAX) {
		subtilis_error_set_ass_bad_reg(err, tbuf, c->l->stream->name,
					       c->l->line);
		return SIZE_MAX;
	}

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

	return reg;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq 0x10(%r15), %rsi
movq %r14, %rdx
callq 0x12edc
movq $-0x1, %rbx
cmpl $0x0, (%r14)
jne 0x68b7b
movq 0x10(%r15), %rdi
callq 0x12ad0
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x68fdf
cmpl $0x0, (%r14)
jne 0x68b7b
movq %rax, %r13
movq 0x8(%r15), %rdi
cmpq $-0x1, %rax
je 0x68b4b
movq 0x10(%r15), %rsi
movq %r14, %rdx
callq 0x12edc
xorl %ebx, %ebx
cmpl (%r14), %ebx
sbbq %rbx, %rbx
orq %r13, %rbx
jmp 0x68b7b
movq 0x30(%rdi), %r8
movl 0x38(%rdi), %r9d
leaq 0xe216(%rip), %rax      # 0x76d70
leaq 0xb2b4(%rip), %rcx      # 0x73e15
movq %r14, %rdi
movl $0x58, %esi
movq %r12, %rdx
pushq $0x2b6                  # imm = 0x2B6
pushq %rax
callq 0x143da
addq $0x10, %rsp
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_mtran_range
static void prv_parse_mtran_range(subtilis_arm_ass_context_t *c, size_t reg1,
				  size_t *reg_list, subtilis_error_t *err)
{
	subtilis_arm_reg_t reg2;
	size_t i;

	reg2 = prv_parse_reg(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (reg1 >= reg2) {
		subtilis_error_set_ass_bad_range(
		    err, reg1, reg2, c->l->stream->name, c->l->line);
		return;
	}

	for (i = reg1 + 1; i <= reg2; i++)
		*reg_list |= 1 << i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movq %rcx, %rsi
callq 0x68ad9
cmpl $0x0, (%r15)
jne 0x68bcf
cmpq %rbx, %rax
jbe 0x68bdb
incq %rbx
movq (%r14), %rdx
movl $0x1, %esi
movl %ebx, %ecx
shll %cl, %esi
movslq %esi, %rcx
orq %rcx, %rdx
incq %rbx
cmpq %rax, %rbx
jbe 0x68bb5
movq %rdx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%r12), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0xe181(%rip), %r10      # 0x76d70
movq %r15, %rdi
movl $0x5c, %esi
movl %ebx, %edx
movl %eax, %ecx
pushq $0x64e                  # imm = 0x64E
pushq %r10
callq 0x14486
addq $0x18, %rsp
jmp 0x68bd3
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: subtilis_arm_exp_new_int32
subtilis_arm_exp_val_t *subtilis_arm_exp_new_int32(int32_t val,
						   subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *e = malloc(sizeof(*e));

	if (!e) {
		subtilis_error_set_oom(err);
		return NULL;
	}
	e->type = SUBTILIS_ARM_EXP_TYPE_INT;
	e->val.integer = val;

	return e;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebp
movl $0x18, %edi
callq 0x121d0
movq %rax, %rbx
testq %rax, %rax
je 0x68c36
movl $0x6, (%rbx)
movl %ebp, 0x8(%rbx)
jmp 0x68c4f
leaq 0xe3b7(%rip), %rdx      # 0x76ff4
movq %r14, %rdi
movl $0x1, %esi
movl $0x32, %ecx
callq 0x145a4
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: subtilis_arm_exp_new_real
subtilis_arm_exp_val_t *subtilis_arm_exp_new_real(double val,
						  subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *e = malloc(sizeof(*e));

	if (!e) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	e->type = SUBTILIS_ARM_EXP_TYPE_REAL;
	e->val.real = val;

	return e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movsd %xmm0, (%rsp)
movl $0x18, %edi
callq 0x121d0
movq %rax, %rbx
testq %rax, %rax
je 0x68c87
movl $0x7, (%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0x68ca0
leaq 0xe366(%rip), %rdx      # 0x76ff4
movq %r14, %rdi
movl $0x1, %esi
movl $0x41, %ecx
callq 0x145a4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: subtilis_arm_exp_new_str_str
subtilis_arm_exp_val_t *subtilis_arm_exp_new_str_str(const char *str,
						     subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *e = malloc(sizeof(*e));

	if (!e) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	e->type = SUBTILIS_ARM_EXP_TYPE_STRING;
	subtilis_buffer_init(&e->val.buf, strlen(str) + 1);
	subtilis_buffer_append_string(&e->val.buf, str, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_buffer_zero_terminate(&e->val.buf, err);

	return e;

cleanup:
	subtilis_arm_exp_val_free(e);

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x121d0
testq %rax, %rax
je 0x68d0a
movq %rax, %rbx
movl $0x8, (%rax)
movq %rax, %r12
addq $0x8, %r12
movq %r15, %rdi
callq 0x120f0
leaq 0x1(%rax), %rsi
movq %r12, %rdi
callq 0x149f4
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x14b8a
cmpl $0x0, (%r14)
je 0x68d27
movq %rbx, %rdi
callq 0x68d41
jmp 0x68d23
leaq 0xe2e3(%rip), %rdx      # 0x76ff4
movq %r14, %rdi
movl $0x1, %esi
movl $0x51, %ecx
callq 0x145a4
xorl %ebx, %ebx
jmp 0x68d32
movq %r12, %rdi
movq %r14, %rsi
callq 0x14d01
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: subtilis_arm_exp_val_free
void subtilis_arm_exp_val_free(subtilis_arm_exp_val_t *val)
{
	if (!val)
		return;

	if ((val->type == SUBTILIS_ARM_EXP_TYPE_STRING) ||
	    (val->type == SUBTILIS_ARM_EXP_TYPE_ID))
		subtilis_buffer_free(&val->val.buf);

	free(val);
}

// Assembly:
testq %rdi, %rdi
je 0x68d66
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
andl $-0x2, %eax
cmpl $0x8, %eax
jne 0x68d5d
leaq 0x8(%rbx), %rdi
callq 0x14d5c
movq %rbx, %rdi
popq %rbx
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: subtilis_arm_exp_new_str
subtilis_arm_exp_val_t *subtilis_arm_exp_new_str(subtilis_buffer_t *buf,
						 subtilis_error_t *err)
{
	size_t len;
	subtilis_arm_exp_val_t *e = malloc(sizeof(*e));

	if (!e) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	e->type = SUBTILIS_ARM_EXP_TYPE_STRING;
	len = subtilis_buffer_get_size(buf);
	subtilis_buffer_init(&e->val.buf, len);
	subtilis_buffer_append(&e->val.buf, buf->buffer->data, len, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_arm_exp_val_free(e);
		return NULL;
	}

	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x121d0
testq %rax, %rax
je 0x68dd1
movq %rax, %rbx
movl $0x8, (%rax)
movq %r15, %rdi
callq 0x14b57
movq %rax, %r12
movq %rbx, %r13
addq $0x8, %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x149f4
movq 0x8(%r15), %rsi
addq $0x18, %rsi
movq %r13, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x14ae8
cmpl $0x0, (%r14)
je 0x68dec
movq %rbx, %rdi
callq 0x68d41
jmp 0x68dea
leaq 0xe21c(%rip), %rdx      # 0x76ff4
movq %r14, %rdi
movl $0x1, %esi
movl $0x6c, %ecx
callq 0x145a4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: subtilis_arm_exp_new_id
subtilis_arm_exp_val_t *subtilis_arm_exp_new_id(const char *id,
						subtilis_error_t *err)
{
	size_t len;
	subtilis_arm_exp_val_t *e = malloc(sizeof(*e));

	if (!e) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	e->type = SUBTILIS_ARM_EXP_TYPE_ID;
	len = strlen(id);
	subtilis_buffer_init(&e->val.buf, len);
	subtilis_buffer_append(&e->val.buf, id, len, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_arm_exp_val_free(e);
		return NULL;
	}
	subtilis_buffer_zero_terminate(&e->val.buf, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_arm_exp_val_free(e);
		return NULL;
	}

	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x121d0
testq %rax, %rax
je 0x68e6f
movq %rax, %rbx
movl $0x9, (%rax)
movq %r15, %rdi
callq 0x120f0
movq %rax, %r13
movq %rbx, %r12
addq $0x8, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x149f4
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x14ae8
cmpl $0x0, (%r14)
jne 0x68e65
movq %r12, %rdi
movq %r14, %rsi
callq 0x14d01
cmpl $0x0, (%r14)
je 0x68e8a
movq %rbx, %rdi
callq 0x68d41
jmp 0x68e88
leaq 0xe17e(%rip), %rdx      # 0x76ff4
movq %r14, %rdi
movl $0x1, %esi
movl $0x83, %ecx
callq 0x145a4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_new_reg
static subtilis_arm_exp_val_t *prv_new_reg(subtilis_arm_reg_t reg,
					   subtilis_arm_exp_type_t type,
					   subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *e = malloc(sizeof(*e));

	if (!e) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	e->type = type;
	e->val.reg = reg;

	return e;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl $0x18, %edi
callq 0x121d0
movq %rax, %rbx
testq %rax, %rax
je 0x68eca
movl %ebp, (%rbx)
movq %r15, 0x8(%rbx)
jmp 0x68ee3
leaq 0xe123(%rip), %rdx      # 0x76ff4
movq %r14, %rdi
movl $0x1, %esi
movl $0x9f, %ecx
callq 0x145a4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: subtilis_arm_exp_dup
subtilis_arm_exp_val_t *subtilis_arm_exp_dup(subtilis_arm_exp_val_t *val,
					     subtilis_error_t *err)
{
	const char *id;

	switch (val->type) {
	case SUBTILIS_ARM_EXP_TYPE_FREG:
		return subtilis_arm_exp_new_freg(val->val.reg, err);
	case SUBTILIS_ARM_EXP_TYPE_REG:
		return subtilis_arm_exp_new_reg(val->val.reg, err);
	case SUBTILIS_ARM_EXP_TYPE_SREG:
		return subtilis_arm_exp_new_sreg(val->val.reg, err);
	case SUBTILIS_ARM_EXP_TYPE_DREG:
		return subtilis_arm_exp_new_dreg(val->val.reg, err);
	case SUBTILIS_ARM_EXP_TYPE_SYSREG:
		return subtilis_arm_exp_new_sysreg(val->val.reg, err);
	case SUBTILIS_ARM_EXP_TYPE_FLAGS_REG:
		return subtilis_arm_exp_new_flagsreg(val->val.reg, err);
	case SUBTILIS_ARM_EXP_TYPE_INT:
		return subtilis_arm_exp_new_int32(val->val.integer, err);
	case SUBTILIS_ARM_EXP_TYPE_REAL:
		return subtilis_arm_exp_new_real(val->val.real, err);
	case SUBTILIS_ARM_EXP_TYPE_STRING:
		return subtilis_arm_exp_new_str(&val->val.buf, err);
	case SUBTILIS_ARM_EXP_TYPE_ID:
		id = subtilis_buffer_get_string(&val->val.buf);
		return subtilis_arm_exp_new_id(id, err);
	}

	subtilis_error_set_assertion_failed(err);

	return NULL;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl (%rdi), %eax
cmpq $0x9, %rax
ja 0x68fb5
leaq 0xdfc9(%rip), %rcx      # 0x76f00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rdi
xorl %esi, %esi
jmp 0x68fa0
movq 0x8(%rdi), %rdi
movl $0x4, %esi
jmp 0x68fa0
addq $0x8, %rdi
callq 0x14db1
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x68df9
movq 0x8(%rdi), %rdi
movl $0x2, %esi
jmp 0x68fa0
movq 0x8(%rdi), %rdi
movl $0x3, %esi
jmp 0x68fa0
movsd 0x8(%rdi), %xmm0
movq %rbx, %rdi
popq %rbx
jmp 0x68c57
movq 0x8(%rdi), %rdi
movl $0x1, %esi
jmp 0x68fa0
movq 0x8(%rdi), %rdi
movl $0x5, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x68ea1
movl 0x8(%rdi), %edi
movq %rbx, %rsi
popq %rbx
jmp 0x68c10
leaq 0xe038(%rip), %rdx      # 0x76ff4
movq %rbx, %rdi
movl $0xf, %esi
movl $0xea, %ecx
callq 0x145a4
xorl %eax, %eax
popq %rbx
retq
addq $0x8, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x68d67
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: subtilis_arm_exp_parse_reg
subtilis_arm_reg_t subtilis_arm_exp_parse_reg(subtilis_arm_ass_context_t *c,
					      const char *id,
					      subtilis_error_t *err)
{
	size_t reg;
	size_t name_len;

	name_len = strlen(&id[1]);
	if (name_len != 1 && name_len != 2)
		return SIZE_MAX;

	if ((id[0] == 'P') && (id[1] == 'C'))
		return (subtilis_arm_reg_t)15;

	if ((id[0] != 'R') && (id[0] != 'r'))
		return SIZE_MAX;

	reg = prv_parse_reg_num(id, name_len);

	if (reg > 15) {
		subtilis_error_set_ass_bad_reg(err, id, c->l->stream->name,
					       c->l->line);
		return SIZE_MAX;
	}

	return (subtilis_arm_reg_t)reg;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x1(%rsi), %r12
movq %r12, %rdi
callq 0x120f0
movq %rax, %rcx
leaq -0x3(%rax), %rdx
movq $-0x1, %rax
cmpq $-0x2, %rdx
jb 0x690b0
movzbl (%rbx), %edx
cmpl $0x72, %edx
je 0x6903d
cmpl $0x52, %edx
je 0x6903d
cmpl $0x50, %edx
jne 0x690b0
xorl %eax, %eax
cmpb $0x43, (%r12)
setne %al
negq %rax
orq $0xf, %rax
jmp 0x690b0
movb (%r12), %al
leal -0x3a(%rax), %edx
cmpb $-0xa, %dl
jae 0x69086
movq 0x8(%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xdf98(%rip), %rax      # 0x76ff4
leaq 0xadb2(%rip), %rcx      # 0x73e15
movq %r14, %rdi
movl $0x58, %esi
movq %rbx, %rdx
pushq $0x1dd                  # imm = 0x1DD
pushq %rax
callq 0x143da
addq $0x10, %rsp
movq $-0x1, %rax
jmp 0x690b0
addb $-0x30, %al
movzbl %al, %eax
cmpq $0x2, %rcx
jne 0x690b0
movb 0x2(%rbx), %cl
leal -0x3a(%rcx), %edx
cmpb $-0xa, %dl
jb 0x69049
leaq (%rax,%rax,4), %rax
addb $-0x30, %cl
movzbl %cl, %ecx
leaq (%rcx,%rax,2), %rax
cmpq $0x10, %rax
jae 0x69049
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: subtilis_arm_exp_parse_freg
subtilis_arm_reg_t subtilis_arm_exp_parse_freg(subtilis_arm_ass_context_t *c,
					       const char *id,
					       subtilis_error_t *err)
{
	size_t reg;
	size_t name_len;

	name_len = strlen(&id[1]);
	if (name_len != 1)
		return SIZE_MAX;

	if ((id[0] != 'F') && (id[0] != 'f'))
		return SIZE_MAX;

	if (id[1] < '0' || id[1] > '7') {
		subtilis_error_set_ass_bad_reg(err, id, c->l->stream->name,
					       c->l->line);
		return SIZE_MAX;
	}
	reg = id[1] - '0';

	return (subtilis_arm_reg_t)reg;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x1(%rsi), %r13
movq %r13, %rdi
callq 0x120f0
movq $-0x1, %rbx
cmpq $0x1, %rax
jne 0x6913b
movzbl (%r14), %eax
orl $0x20, %eax
cmpl $0x66, %eax
jne 0x6913b
movb (%r13), %al
leal -0x38(%rax), %ecx
cmpb $-0x9, %cl
ja 0x69136
movq 0x8(%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xdee1(%rip), %rax      # 0x76ff4
leaq 0xacfb(%rip), %rcx      # 0x73e15
movq %r15, %rdi
movl $0x58, %esi
movq %r14, %rdx
pushq $0x1f4                  # imm = 0x1F4
pushq %rax
callq 0x143da
addq $0x10, %rsp
jmp 0x6913b
addb $-0x30, %al
movzbl %al, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: subtilis_arm_exp_parse_dreg
subtilis_arm_reg_t subtilis_arm_exp_parse_dreg(subtilis_arm_ass_context_t *c,
					       const char *id,
					       subtilis_error_t *err)
{
	size_t reg;
	size_t name_len;

	name_len = strlen(&id[1]);
	if (name_len != 1)
		return SIZE_MAX;

	reg = prv_parse_reg_num(id, name_len);
	if (reg > 15) {
		subtilis_error_set_ass_bad_reg(err, id, c->l->stream->name,
					       c->l->line);
		return SIZE_MAX;
	}

	return (subtilis_arm_reg_t)reg;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x1(%rsi), %r13
movq %r13, %rdi
callq 0x120f0
movq $-0x1, %rbx
cmpq $0x1, %rax
jne 0x691bb
movb (%r13), %al
leal -0x3a(%rax), %ecx
cmpb $-0xa, %cl
jae 0x691b6
movq 0x8(%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xde61(%rip), %rax      # 0x76ff4
leaq 0xac7b(%rip), %rcx      # 0x73e15
movq %r15, %rdi
movl $0x58, %esi
movq %r14, %rdx
pushq $0x20a                  # imm = 0x20A
pushq %rax
callq 0x143da
addq $0x10, %rsp
jmp 0x691bb
addb $-0x30, %al
movzbl %al, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: subtilis_arm_exp_parse_sreg
subtilis_arm_reg_t subtilis_arm_exp_parse_sreg(subtilis_arm_ass_context_t *c,
					       const char *id,
					       subtilis_error_t *err)
{
	size_t reg;
	size_t name_len;

	name_len = strlen(&id[1]);
	if (name_len != 1)
		return SIZE_MAX;

	if ((id[0] != 'S') && (id[0] != 's'))
		return SIZE_MAX;

	reg = prv_parse_reg_num(id, name_len);
	if (reg > 31) {
		subtilis_error_set_ass_bad_reg(err, id, c->l->stream->name,
					       c->l->line);
		return SIZE_MAX;
	}

	return (subtilis_arm_reg_t)reg;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x1(%rsi), %r13
movq %r13, %rdi
callq 0x120f0
movq $-0x1, %rbx
cmpq $0x1, %rax
jne 0x69247
movzbl (%r14), %eax
orl $0x20, %eax
cmpl $0x73, %eax
jne 0x69247
movb (%r13), %al
leal -0x3a(%rax), %ecx
cmpb $-0xa, %cl
jae 0x69242
movq 0x8(%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xddd5(%rip), %rax      # 0x76ff4
leaq 0xabef(%rip), %rcx      # 0x73e15
movq %r15, %rdi
movl $0x58, %esi
movq %r14, %rdx
pushq $0x222                  # imm = 0x222
pushq %rax
callq 0x143da
addq $0x10, %rsp
jmp 0x69247
addb $-0x30, %al
movzbl %al, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: subtilis_arm_exp_parse_sysreg
subtilis_arm_reg_t subtilis_arm_exp_parse_sysreg(subtilis_arm_ass_context_t *c,
						 const char *id)
{
	size_t reg;

	if (!strcmp(id, "FPSID") || !strcmp(id, "fpsid"))
		reg = SUBTILIS_VFP_SYSREG_FPSID;
	else if (!strcmp(id, "FPSCR") || !strcmp(id, "fpscr"))
		reg = SUBTILIS_VFP_SYSREG_FPSCR;
	else if (!strcmp(id, "FPEXC") || !strcmp(id, "fpexc"))
		reg = SUBTILIS_VFP_SYSREG_FPEXC;
	else
		reg = SIZE_MAX;

	return (subtilis_arm_reg_t)reg;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xdbd4(%rip), %rsi      # 0x76e36
movq %rbx, %rdi
callq 0x12160
testl %eax, %eax
je 0x692dd
leaq 0xdd9b(%rip), %rsi      # 0x77010
movq %rbx, %rdi
callq 0x12160
testl %eax, %eax
je 0x692dd
leaq 0xd573(%rip), %rsi      # 0x767fb
movq %rbx, %rdi
callq 0x12160
movl $0x1, %r14d
testl %eax, %eax
je 0x692e0
leaq 0xdd75(%rip), %rsi      # 0x77016
movq %rbx, %rdi
callq 0x12160
testl %eax, %eax
je 0x692e0
leaq 0xd54d(%rip), %rsi      # 0x76801
movq %rbx, %rdi
callq 0x12160
testl %eax, %eax
je 0x692eb
leaq 0xdd55(%rip), %rsi      # 0x7701c
movq %rbx, %rdi
callq 0x12160
xorl %r14d, %r14d
negl %eax
sbbq %r14, %r14
orq $0x2, %r14
jmp 0x692e0
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x2, %r14d
jmp 0x692e0
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: subtilis_arm_exp_parse_flagsreg
subtilis_arm_reg_t
subtilis_arm_exp_parse_flagsreg(subtilis_arm_ass_context_t *c, const char *id)
{
	subtilis_arm_reg_t reg;
	subtilis_arm_reg_t flag;

	if (!strncmp(id, "CPSR", 4))
		reg = SUBTILIS_ARM_EXP_CPSR_REG;
	else if (!strncmp(id, "SPSR", 4))
		reg = SUBTILIS_ARM_EXP_SPSR_REG;
	else
		return SIZE_MAX;

	id += 4;
	if (!*id)
		return reg;

	if (*id != '_')
		return SIZE_MAX;

	id++;
	if ((strlen(id) == 0) || (strlen(id) > 4))
		return SIZE_MAX;

	for (; *id; id++) {
		switch (*id) {
		case 'c':
			flag = SUBTILIS_ARM_EXP_CONTROL_REG;
			break;
		case 'x':
			flag = SUBTILIS_ARM_EXP_EXT_REG;
			break;
		case 's':
			flag = SUBTILIS_ARM_EXP_STATUS_REG;
			break;
		case 'f':
			flag = SUBTILIS_ARM_EXP_FLAGS_REG;
			break;
		default:
			return SIZE_MAX;
		}

		if (reg & flag)
			return SIZE_MAX;

		reg |= flag;
	}

	return reg;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xd3db(%rip), %rsi      # 0x766dc
movl $0x4, %edx
movq %rbx, %rdi
callq 0x12060
testl %eax, %eax
je 0x6933f
leaq 0xdbb6(%rip), %rsi      # 0x76ecf
movl $0x4, %edx
movq %rbx, %rdi
callq 0x12060
movl %eax, %ecx
movq $-0x1, %rax
testl %ecx, %ecx
jne 0x693c0
movl $0x1, %r14d
jmp 0x69342
xorl %r14d, %r14d
movzbl 0x4(%rbx), %eax
testl %eax, %eax
je 0x693bd
cmpl $0x5f, %eax
jne 0x693b0
addq $0x5, %rbx
movq %rbx, %rdi
callq 0x120f0
movq %rax, %rcx
addq $-0x5, %rcx
movq $-0x1, %rax
cmpq $-0x4, %rcx
jb 0x693c0
movzbl (%rbx), %edx
cmpl $0x72, %edx
jg 0x6938d
movl $0x10000, %ecx          # imm = 0x10000
cmpl $0x63, %edx
je 0x693a3
cmpl $0x66, %edx
jne 0x693b9
movl $0x80000, %ecx          # imm = 0x80000
jmp 0x693a3
cmpl $0x73, %edx
je 0x6939e
cmpl $0x78, %edx
jne 0x693c0
movl $0x20000, %ecx          # imm = 0x20000
jmp 0x693a3
movl $0x40000, %ecx          # imm = 0x40000
testl %r14d, %ecx
jne 0x693c0
orq %rcx, %r14
incq %rbx
jmp 0x6936f
movq $-0x1, %rax
jmp 0x693c0
testl %edx, %edx
jne 0x693c0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: subtilis_arm_exp_process_id
subtilis_arm_exp_val_t *subtilis_arm_exp_process_id(
	subtilis_arm_ass_context_t *c, const char *id, subtilis_error_t *err)
/* clang-format on */

{
	subtilis_arm_reg_t reg;
	subtilis_arm_exp_val_t *val;

	reg = subtilis_arm_exp_parse_reg(c, id, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	if (reg != SIZE_MAX)
		return subtilis_arm_exp_new_reg(reg, err);

	reg = subtilis_arm_exp_parse_freg(c, id, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	if (reg != SIZE_MAX)
		return subtilis_arm_exp_new_freg(reg, err);

	reg = subtilis_arm_exp_parse_sreg(c, id, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	if (reg != SIZE_MAX)
		return subtilis_arm_exp_new_sreg(reg, err);

	reg = subtilis_arm_exp_parse_dreg(c, id, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	if (reg != SIZE_MAX)
		return subtilis_arm_exp_new_dreg(reg, err);

	reg = subtilis_arm_exp_parse_sysreg(c, id);
	if (reg != SIZE_MAX)
		return subtilis_arm_exp_new_sysreg(reg, err);

	reg = subtilis_arm_exp_parse_flagsreg(c, id);
	if (reg != SIZE_MAX)
		return subtilis_arm_exp_new_flagsreg(reg, err);

	val = subtilis_arm_asm_find_def(c, id);
	if (val)
		return subtilis_arm_exp_dup(val, err);

	return subtilis_arm_exp_new_id(id, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x68fdf
cmpl $0x0, (%rbx)
je 0x693e8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
cmpq $-0x1, %rax
je 0x69403
movq %rax, %rdi
movl $0x1, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x68ea1
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x690bc
cmpl $0x0, (%rbx)
jne 0x693e0
cmpq $-0x1, %rax
je 0x69423
movq %rax, %rdi
xorl %esi, %esi
jmp 0x693f6
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x691c8
cmpl $0x0, (%rbx)
jne 0x693e0
cmpq $-0x1, %rax
je 0x69446
movq %rax, %rdi
movl $0x2, %esi
jmp 0x693f6
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x69148
cmpl $0x0, (%rbx)
jne 0x693e0
cmpq $-0x1, %rax
je 0x69469
movq %rax, %rdi
movl $0x3, %esi
jmp 0x693f6
movq %r14, %rsi
callq 0x69254
cmpq $-0x1, %rax
je 0x69484
movq %rax, %rdi
movl $0x4, %esi
jmp 0x693f6
movq %r14, %rsi
callq 0x692f3
cmpq $-0x1, %rax
je 0x6949f
movq %rax, %rdi
movl $0x5, %esi
jmp 0x693f6
movq %r15, %rdi
movq %r14, %rsi
callq 0x6399a
testq %rax, %rax
je 0x694bf
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x68f20
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x68df9
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: subtilis_arm_exp_pri7
subtilis_arm_exp_val_t *subtilis_arm_exp_pri7(subtilis_arm_ass_context_t *c,
					      subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *e1 = NULL;
	subtilis_arm_exp_val_t *e2 = NULL;

	/* clang-format off */
	subtilis_arm_exp_val_t *(*fn)(
	    subtilis_arm_ass_context_t *c, subtilis_arm_exp_val_t *e1,
	    subtilis_arm_exp_val_t *e2, subtilis_error_t *err);
	/* clang-format on */

	e1 = prv_priority6(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	while (c->t->type == SUBTILIS_TOKEN_KEYWORD) {
		if (c->t->tok.keyword.type == SUBTILIS_ARM_KEYWORD_EOR)
			fn = prv_eor;
		else if (c->t->tok.keyword.type == SUBTILIS_ARM_KEYWORD_OR)
			fn = prv_or;
		else
			break;
		subtilis_lexer_get(c->l, c->t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		e2 = prv_priority6(c, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		e1 = fn(c, e1, e2, err);
		e2 = NULL;
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	return e1;

cleanup:

	subtilis_arm_exp_val_free(e2);
	subtilis_arm_exp_val_free(e1);
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x6957d
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x69514
xorl %eax, %eax
movq %rax, %rdi
callq 0x68d41
movq %rbx, %rdi
callq 0x68d41
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf9(%rip), %r12        # 0x69614
leaq 0x101(%rip), %r13       # 0x69623
movq 0x10(%r15), %rsi
cmpl $0x1, (%rsi)
jne 0x69502
movl 0x8(%rsi), %eax
movq %r12, %rbp
cmpl $0xe, %eax
je 0x6953e
cmpl $0x1b, %eax
jne 0x69502
movq %r13, %rbp
movq 0x8(%r15), %rdi
movq %r14, %rdx
callq 0x12edc
cmpl $0x0, (%r14)
jne 0x694ee
movq %r15, %rdi
movq %r14, %rsi
callq 0x6957d
cmpl $0x0, (%r14)
jne 0x694f0
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq *%rbp
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x69522
jmp 0x694ee
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_priority6
static subtilis_arm_exp_val_t *prv_priority6(subtilis_arm_ass_context_t *c,
					     subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *e1 = NULL;
	subtilis_arm_exp_val_t *e2 = NULL;

	e1 = prv_priority5(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	while (c->t->type == SUBTILIS_TOKEN_KEYWORD &&
	       c->t->tok.keyword.type == SUBTILIS_ARM_KEYWORD_AND) {
		subtilis_lexer_get(c->l, c->t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		e2 = prv_priority5(c, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		e1 = prv_binary_int(c, e1, e2, prv_and_fn, err);
		e2 = NULL;
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	return e1;

cleanup:

	subtilis_arm_exp_val_free(e2);
	subtilis_arm_exp_val_free(e1);
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x6968c
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x695bc
xorl %eax, %eax
movq %rax, %rdi
callq 0x68d41
movq %rbx, %rdi
callq 0x68d41
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x502(%rip), %r12       # 0x69ac5
movq 0x10(%r15), %rsi
cmpl $0x1, (%rsi)
jne 0x695ad
cmpl $0x7, 0x8(%rsi)
jne 0x695ad
movq 0x8(%r15), %rdi
movq %r14, %rdx
callq 0x12edc
cmpl $0x0, (%r14)
jne 0x69599
movq %r15, %rdi
movq %r14, %rsi
callq 0x6968c
cmpl $0x0, (%r14)
jne 0x6959b
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r12, %rcx
movq %r14, %r8
callq 0x69a44
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x695c3
jmp 0x69599
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_binary_int
static subtilis_arm_exp_val_t *prv_binary_int(subtilis_arm_ass_context_t *c,
					      subtilis_arm_exp_val_t *e1,
					      subtilis_arm_exp_val_t *e2,
					      subtilis_ass_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(c, val1, val2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r13
movq %r8, %rdx
callq 0x6b2c1
cmpl $0x0, (%r15)
jne 0x69a9e
movl %eax, %ebp
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6b2c1
cmpl $0x0, (%r15)
jne 0x69a9e
movl $0x6, (%rbx)
movq %r13, %rdi
movl %ebp, %esi
movl %eax, %edx
movq %r15, %rcx
callq *%r12
movl %eax, 0x8(%rbx)
cmpl $0x0, (%r15)
je 0x69aab
movq %r14, %rdi
callq 0x68d41
movq %rbx, %r14
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x68d41
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_priority2
static subtilis_arm_exp_val_t *prv_priority2(subtilis_arm_ass_context_t *c,
					     subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_arm_exp_val_t *e1 = NULL;
	subtilis_arm_exp_val_t *e2 = NULL;

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

	while (c->t->type == SUBTILIS_TOKEN_OPERATOR) {
		tbuf = subtilis_token_get_text(c->t);
		if (strcmp(tbuf, "^"))
			break;

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

		if ((e2->type == SUBTILIS_ARM_EXP_TYPE_INT) &&
		    (e2->val.integer < 0)) {
			e2->val.real = (double)e2->val.integer;
			e2->type = SUBTILIS_ARM_EXP_TYPE_REAL;
		}

		e1 = prv_binary_numeric(c, e1, e2, prv_pow_int32_fn,
					prv_pow_real_fn, err);

		e2 = NULL;
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	return e1;

cleanup:

	subtilis_arm_exp_val_free(e2);
	subtilis_arm_exp_val_free(e1);
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x6a13d
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x69f59
xorl %eax, %eax
movq %rax, %rdi
callq 0x68d41
movq %rbx, %rdi
callq 0x68d41
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x6a3(%rip), %r12       # 0x6a603
leaq 0x7af(%rip), %r13       # 0x6a716
movq 0x10(%r15), %rdi
cmpl $0x2, (%rdi)
jne 0x69f4c
callq 0x12ad0
cmpb $0x5e, (%rax)
jne 0x69f4c
cmpb $0x0, 0x1(%rax)
jne 0x69f4c
movq 0x8(%r15), %rdi
movq 0x10(%r15), %rsi
movq %r14, %rdx
callq 0x12edc
cmpl $0x0, (%r14)
jne 0x69f38
movq %r15, %rdi
movq %r14, %rsi
callq 0x6a13d
cmpl $0x0, (%r14)
jne 0x69f3a
cmpl $0x6, (%rax)
jne 0x69fc5
movl 0x8(%rax), %ecx
testl %ecx, %ecx
jns 0x69fc5
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x8(%rax)
movl $0x7, (%rax)
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r12, %rcx
movq %r13, %r8
movq %r14, %r9
callq 0x69efe
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x69f67
jmp 0x69f38