LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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), %r14
cmpl $0x2, (%r14)
jne 0x68a1a
leaq 0xaaab(%rip), %rsi      # 0x734b9
movq %rax, %rdi
callq 0x12160
testl %eax, %eax
je 0x68a76
xorl %r14d, %r14d
movq (%rbx), %rdi
movl %r13d, %esi
movq %r12, %rdx
callq 0x4f73a
cmpl $0x0, (%r12)
jne 0x68a8c
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)
jmp 0x68a8c
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x12eda
cmpl $0x0, (%r12)
je 0x68a9b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r14b
jmp 0x68a1d
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
cmpl $0x2, (%rdi)
jne 0x68b1a
movq %rsi, %r15
callq 0x12ad0
movq %rax, %r12
leaq 0xdf5d(%rip), %rsi      # 0x76a29
movq %rax, %rdi
callq 0x12160
testl %eax, %eax
je 0x68b30
movq 0x8(%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xe225(%rip), %rax      # 0x76d10
leaq 0xe344(%rip), %rdx      # 0x76e36
movq %rbx, %rdi
movl $0x1d, %esi
movq %r12, %rcx
pushq $0x41c                  # imm = 0x41C
pushq %rax
callq 0x1442a
addq $0x10, %rsp
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x69921
movb $0x1, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x69a84
// File: /workspace/github_c_makefile_star2_O1/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 0x68ca9
movb $0x1, (%rcx)
xorl %eax, %eax
subl 0x8(%rsi), %eax
movl %eax, 0x8(%rdx)
cmpl $0x1000, %eax           # imm = 0x1000
jb 0x68ce8
pushq %rax
movl 0x8(%rsi), %edx
movq 0x8(%rdi), %rcx
movq 0x30(%rcx), %rax
movl 0x38(%rcx), %r9d
leaq 0xe046(%rip), %r10      # 0x76d10
movq %r8, %rdi
movl $0x5b, %esi
xorl %ecx, %ecx
movq %rax, %r8
pushq $0x433                  # imm = 0x433
pushq %r10
callq 0x144d6
addq $0x10, %rsp
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8(%rsi), %rax
movq %rax, 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 0x12eda
movl $0x3, %ebp
cmpl $0x0, (%rbx)
jne 0x68db4
movq 0x10(%r15), %rax
cmpl $0x1, (%rax)
jne 0x68d54
movl 0x8(%rax), %eax
addl $-0x27, %eax
cmpl $0x5, %eax
jae 0x68d80
movl %eax, %eax
leaq 0xdfad(%rip), %rcx      # 0x76cfc
movl (%rcx,%rax,4), %ebp
jmp 0x68db4
movq 0x8(%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xdfa9(%rip), %rax      # 0x76d10
leaq 0xb087(%rip), %rcx      # 0x73df5
movq %rbx, %rdi
movl $0x10, %esi
movq %r12, %rdx
pushq $0x3f5                  # imm = 0x3F5
jmp 0x68daa
movq 0x8(%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xdf7d(%rip), %rax      # 0x76d10
leaq 0xe0b3(%rip), %rdx      # 0x76e4d
movq %rbx, %rdi
movl $0x1d, %esi
movq %r12, %rcx
pushq $0x40b                  # imm = 0x40B
pushq %rax
callq 0x1442a
addq $0x10, %rsp
movl %ebp, 0x10(%r14)
cmpl $0x0, (%rbx)
jne 0x68dcd
movq %r15, %rdi
movq %rbx, %rsi
callq 0x69a84
cmpl $0x0, (%rbx)
je 0x68dd6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movl (%rax), %eax
cmpl $0x1, %eax
je 0x68df5
cmpl $0x6, %eax
jne 0x68e05
movb $0x0, 0x20(%r14)
movl 0x8(%r12), %eax
movl %eax, 0x18(%r14)
jmp 0x68e42
movb $0x1, 0x20(%r14)
movq 0x8(%r12), %rax
movq %rax, 0x18(%r14)
jmp 0x68e42
movq %r12, %rdi
callq 0x69abf
movq 0x8(%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0xdef0(%rip), %r10      # 0x76d10
leaq 0xdfd9(%rip), %rdx      # 0x76e00
movq %rbx, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0x44d                  # imm = 0x44D
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %r12, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x69167
// File: /workspace/github_c_makefile_star2_O1/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 0x68e64
cmpb $0x1, (%rsi)
jne 0x68e64
movl $0x0, (%rdi)
retq
cmpb $0x1, 0x3(%rsi)
jne 0x68e76
cmpb $0x1, (%rsi)
jne 0x68e83
movl $0x1, (%rdi)
retq
cmpb $0x1, 0x4(%rsi)
jne 0x68e8a
movl $0x3, (%rdi)
retq
movl $0x2, (%rdi)
retq
leaq 0xde7f(%rip), %rax      # 0x76d10
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x49a, %ecx            # imm = 0x49A
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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), %ebp
testl %ebp, %ebp
jns 0x68ebb
movb $0x1, (%rcx)
xorl %ebp, %ebp
subl 0x8(%rsi), %ebp
cmpl $0x100, %ebp            # imm = 0x100
jl 0x68ef6
movl 0x8(%rsi), %edx
movq 0x8(%rdi), %rcx
movq 0x30(%rcx), %rax
movl 0x38(%rcx), %r9d
leaq 0xde37(%rip), %r10      # 0x76d10
movq %r8, %rdi
movl $0x5b, %esi
xorl %ecx, %ecx
movq %rax, %r8
pushq $0x487                  # imm = 0x487
pushq %r10
callq 0x144d6
addq $0x10, %rsp
movb %bpl, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x12eda
movq $-0x1, %rbx
cmpl $0x0, (%r14)
jne 0x68fa2
movq 0x10(%r15), %rdi
callq 0x12ad0
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x693f8
cmpl $0x0, (%r14)
jne 0x68fa2
movq %rax, %r13
movq 0x8(%r15), %rdi
cmpq $-0x1, %rax
je 0x68f72
movq 0x10(%r15), %rsi
movq %r14, %rdx
callq 0x12eda
xorl %ebx, %ebx
cmpl (%r14), %ebx
sbbq %rbx, %rbx
orq %r13, %rbx
jmp 0x68fa2
movq 0x30(%rdi), %r8
movl 0x38(%rdi), %r9d
leaq 0xdd8f(%rip), %rax      # 0x76d10
leaq 0xae6d(%rip), %rcx      # 0x73df5
movq %r14, %rdi
movl $0x58, %esi
movq %r12, %rdx
pushq $0x2b6                  # imm = 0x2B6
pushq %rax
callq 0x1442a
addq $0x10, %rsp
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x68f00
cmpl $0x0, (%r15)
je 0x68fdd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpq %rbx, %rax
jbe 0x69009
incq %rbx
cmpq %rax, %rbx
ja 0x68fd1
movq (%r14), %rdx
movl $0x1, %esi
movl %ebx, %ecx
shll %cl, %esi
movslq %esi, %rcx
orq %rcx, %rdx
incq %rbx
cmpq %rax, %rbx
jbe 0x68fed
movq %rdx, (%r14)
jmp 0x68fd1
movq 0x8(%r12), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0xdcf3(%rip), %r10      # 0x76d10
movq %r15, %rdi
movl $0x5c, %esi
movl %ebx, %edx
movl %eax, %ecx
pushq $0x64e                  # imm = 0x64E
pushq %r10
callq 0x144d6
addq $0x18, %rsp
jmp 0x68fd5
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x18, %edi
callq 0x121d0
testq %rax, %rax
je 0x6905e
movl $0x6, (%rax)
movl %ebp, 0x8(%rax)
jmp 0x69079
leaq 0xdf2b(%rip), %rdx      # 0x76f90
movq %rbx, %rdi
movl $0x1, %esi
movl $0x32, %ecx
callq 0x145f4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
movl $0x18, %edi
callq 0x121d0
testq %rax, %rax
je 0x690b0
movl $0x7, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x690cb
leaq 0xded9(%rip), %rdx      # 0x76f90
movq %rbx, %rdi
movl $0x1, %esi
movl $0x41, %ecx
callq 0x145f4
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x69130
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 0x14a40
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x14bd4
cmpl $0x0, (%r14)
je 0x6914d
movq %rbx, %rdi
callq 0x69167
jmp 0x69149
leaq 0xde59(%rip), %rdx      # 0x76f90
movq %r14, %rdi
movl $0x1, %esi
movl $0x51, %ecx
callq 0x145f4
xorl %ebx, %ebx
jmp 0x69158
movq %r12, %rdi
movq %r14, %rsi
callq 0x14d4b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6918c
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
andl $-0x2, %eax
cmpl $0x8, %eax
jne 0x69183
leaq 0x8(%rbx), %rdi
callq 0x14da6
movq %rbx, %rdi
popq %rbx
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x691f7
movq %rax, %rbx
movl $0x8, (%rax)
movq %r15, %rdi
callq 0x14ba1
movq %rax, %r12
movq %rbx, %r13
addq $0x8, %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x14a40
movq 0x8(%r15), %rsi
addq $0x18, %rsi
movq %r13, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x14b32
cmpl $0x0, (%r14)
je 0x69212
movq %rbx, %rdi
callq 0x69167
jmp 0x69210
leaq 0xdd92(%rip), %rdx      # 0x76f90
movq %r14, %rdi
movl $0x1, %esi
movl $0x6c, %ecx
callq 0x145f4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x69295
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 0x14a40
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x14b32
cmpl $0x0, (%r14)
jne 0x6928b
movq %r12, %rdi
movq %r14, %rsi
callq 0x14d4b
cmpl $0x0, (%r14)
je 0x692b0
movq %rbx, %rdi
callq 0x69167
jmp 0x692ae
leaq 0xdcf4(%rip), %rdx      # 0x76f90
movq %r14, %rdi
movl $0x1, %esi
movl $0x83, %ecx
callq 0x145f4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x18, %edi
callq 0x121d0
testq %rax, %rax
je 0x692ea
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
jmp 0x69305
leaq 0xdc9f(%rip), %rdx      # 0x76f90
movq %rbx, %rdi
movl $0x1, %esi
movl $0x9f, %ecx
callq 0x145f4
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x693ce
leaq 0xdb4c(%rip), %rcx      # 0x76e9c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rdi
xorl %esi, %esi
jmp 0x693b9
movq 0x8(%rdi), %rdi
movl $0x4, %esi
jmp 0x693b9
addq $0x8, %rdi
callq 0x14dfb
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x6921f
movq 0x8(%rdi), %rdi
movl $0x2, %esi
jmp 0x693b9
movq 0x8(%rdi), %rdi
movl $0x3, %esi
jmp 0x693b9
movsd 0x8(%rdi), %xmm0
movq %rbx, %rdi
popq %rbx
jmp 0x69080
movq 0x8(%rdi), %rdi
movl $0x1, %esi
jmp 0x693b9
movq 0x8(%rdi), %rdi
movl $0x5, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x692c7
movl 0x8(%rdi), %edi
movq %rbx, %rsi
popq %rbx
jmp 0x6903c
leaq 0xdbbb(%rip), %rdx      # 0x76f90
movq %rbx, %rdi
movl $0xf, %esi
movl $0xea, %ecx
callq 0x145f4
xorl %eax, %eax
popq %rbx
retq
addq $0x8, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x6918d
// File: /workspace/github_c_makefile_star2_O1/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 0x694db
movzbl (%rbx), %edx
cmpl $0x72, %edx
je 0x69462
cmpl $0x52, %edx
je 0x69462
cmpl $0x50, %edx
jne 0x694db
movl $0xf, %eax
cmpb $0x43, (%r12)
je 0x694db
orl $0x20, %edx
movq $-0x1, %rax
cmpl $0x72, %edx
jne 0x694db
movb (%r12), %dl
leal -0x3a(%rdx), %esi
cmpb $-0xa, %sil
jb 0x6949a
addb $-0x30, %dl
movzbl %dl, %edx
cmpq $0x2, %rcx
jne 0x69497
movb 0x2(%rbx), %cl
leal -0x3a(%rcx), %esi
cmpb $-0xa, %sil
jb 0x6949a
leaq (%rdx,%rdx,4), %rax
addb $-0x30, %cl
movzbl %cl, %ecx
leaq (%rcx,%rax,2), %rax
jmp 0x6949a
movq %rdx, %rax
cmpq $0x10, %rax
jb 0x694db
movq 0x8(%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xdadd(%rip), %rax      # 0x76f90
leaq 0xa93b(%rip), %rcx      # 0x73df5
movq %r14, %rdi
movl $0x58, %esi
movq %rbx, %rdx
pushq $0x1dd                  # imm = 0x1DD
pushq %rax
callq 0x1442a
addq $0x10, %rsp
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x69566
movzbl (%r14), %eax
orl $0x20, %eax
cmpl $0x66, %eax
jne 0x69566
movb (%r13), %al
leal -0x38(%rax), %ecx
cmpb $-0x9, %cl
ja 0x69561
movq 0x8(%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xda52(%rip), %rax      # 0x76f90
leaq 0xa8b0(%rip), %rcx      # 0x73df5
movq %r15, %rdi
movl $0x58, %esi
movq %r14, %rdx
pushq $0x1f4                  # imm = 0x1F4
pushq %rax
callq 0x1442a
addq $0x10, %rsp
jmp 0x69566
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_O1/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 %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
movq $-0x1, %rax
cmpq $0x1, %rcx
jne 0x695fb
movb (%r12), %al
leal -0x3a(%rax), %ecx
addb $-0x30, %al
cmpb $-0xa, %cl
movzbl %al, %eax
movq $-0x1, %rcx
cmovbq %rcx, %rax
cmpq $0x10, %rax
jb 0x695fb
movq 0x8(%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xd9bd(%rip), %rax      # 0x76f90
leaq 0xa81b(%rip), %rcx      # 0x73df5
movq %r14, %rdi
movl $0x58, %esi
movq %rbx, %rdx
pushq $0x20a                  # imm = 0x20A
pushq %rax
callq 0x1442a
addq $0x10, %rsp
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %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
movq $-0x1, %rax
cmpq $0x1, %rcx
jne 0x6969a
movzbl (%rbx), %ecx
orl $0x20, %ecx
cmpl $0x73, %ecx
jne 0x6969a
movb (%r12), %al
leal -0x3a(%rax), %ecx
addb $-0x30, %al
cmpb $-0xa, %cl
movzbl %al, %eax
movq $-0x1, %rcx
cmovbq %rcx, %rax
cmpq $0x20, %rax
jb 0x6969a
movq 0x8(%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xd91e(%rip), %rax      # 0x76f90
leaq 0xa77c(%rip), %rcx      # 0x73df5
movq %r14, %rdi
movl $0x58, %esi
movq %rbx, %rdx
pushq $0x222                  # imm = 0x222
pushq %rax
callq 0x1442a
addq $0x10, %rsp
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd720(%rip), %rsi      # 0x76dd4
movq %rbx, %rdi
callq 0x12160
testl %eax, %eax
je 0x6972f
leaq 0xd8e5(%rip), %rsi      # 0x76fac
movq %rbx, %rdi
callq 0x12160
testl %eax, %eax
je 0x6972f
leaq 0xd0e1(%rip), %rsi      # 0x767bb
movq %rbx, %rdi
callq 0x12160
movl $0x1, %r14d
testl %eax, %eax
je 0x69732
leaq 0xd8bf(%rip), %rsi      # 0x76fb2
movq %rbx, %rdi
callq 0x12160
testl %eax, %eax
je 0x69732
leaq 0xd0bb(%rip), %rsi      # 0x767c1
movq %rbx, %rdi
callq 0x12160
testl %eax, %eax
je 0x6973d
leaq 0xd89f(%rip), %rsi      # 0x76fb8
movq %rbx, %rdi
callq 0x12160
xorl %r14d, %r14d
negl %eax
sbbq %r14, %r14
orq $0x2, %r14
jmp 0x69732
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x2, %r14d
jmp 0x69732
// File: /workspace/github_c_makefile_star2_O1/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 0xcf49(%rip), %rsi      # 0x7669c
movl $0x4, %edx
movq %rbx, %rdi
callq 0x12060
testl %eax, %eax
je 0x69791
leaq 0xd702(%rip), %rsi      # 0x76e6d
movl $0x4, %edx
movq %rbx, %rdi
callq 0x12060
movl %eax, %ecx
movq $-0x1, %rax
testl %ecx, %ecx
jne 0x69812
movl $0x1, %r14d
jmp 0x69794
xorl %r14d, %r14d
movzbl 0x4(%rbx), %eax
testl %eax, %eax
je 0x6980f
cmpl $0x5f, %eax
jne 0x69802
addq $0x5, %rbx
movq %rbx, %rdi
callq 0x120f0
movq %rax, %rcx
addq $-0x5, %rcx
movq $-0x1, %rax
cmpq $-0x4, %rcx
jb 0x69812
movzbl (%rbx), %edx
cmpl $0x72, %edx
jg 0x697df
movl $0x10000, %ecx          # imm = 0x10000
cmpl $0x63, %edx
je 0x697f5
cmpl $0x66, %edx
jne 0x6980b
movl $0x80000, %ecx          # imm = 0x80000
jmp 0x697f5
cmpl $0x73, %edx
je 0x697f0
cmpl $0x78, %edx
jne 0x69812
movl $0x20000, %ecx          # imm = 0x20000
jmp 0x697f5
movl $0x40000, %ecx          # imm = 0x40000
testl %r14d, %ecx
jne 0x69812
orq %rcx, %r14
incq %rbx
jmp 0x697c1
movq $-0x1, %rax
jmp 0x69812
testl %edx, %edx
jne 0x69812
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x693f8
cmpl $0x0, (%rbx)
je 0x6983a
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
cmpq $-0x1, %rax
je 0x69855
movq %rax, %rdi
movl $0x1, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x692c7
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x694e7
cmpl $0x0, (%rbx)
jne 0x69832
cmpq $-0x1, %rax
je 0x69875
movq %rax, %rdi
xorl %esi, %esi
jmp 0x69848
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x69607
cmpl $0x0, (%rbx)
jne 0x69832
cmpq $-0x1, %rax
je 0x69898
movq %rax, %rdi
movl $0x2, %esi
jmp 0x69848
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x69573
cmpl $0x0, (%rbx)
jne 0x69832
cmpq $-0x1, %rax
je 0x698bb
movq %rax, %rdi
movl $0x3, %esi
jmp 0x69848
movq %r14, %rsi
callq 0x696a6
cmpq $-0x1, %rax
je 0x698d6
movq %rax, %rdi
movl $0x4, %esi
jmp 0x69848
movq %r14, %rsi
callq 0x69745
cmpq $-0x1, %rax
je 0x698f1
movq %rax, %rdi
movl $0x5, %esi
jmp 0x69848
movq %r15, %rdi
movq %r14, %rsi
callq 0x63971
testq %rax, %rax
je 0x69911
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x69339
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6921f
// File: /workspace/github_c_makefile_star2_O1/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 0x699cf
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x69966
xorl %eax, %eax
movq %rax, %rdi
callq 0x69167
movq %rbx, %rdi
callq 0x69167
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        # 0x69a66
leaq 0x101(%rip), %r13       # 0x69a75
movq 0x10(%r15), %rsi
cmpl $0x1, (%rsi)
jne 0x69954
movl 0x8(%rsi), %eax
movq %r12, %rbp
cmpl $0xe, %eax
je 0x69990
cmpl $0x1b, %eax
jne 0x69954
movq %r13, %rbp
movq 0x8(%r15), %rdi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x69940
movq %r15, %rdi
movq %r14, %rsi
callq 0x699cf
cmpl $0x0, (%r14)
jne 0x69942
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq *%rbp
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x69974
jmp 0x69940
// File: /workspace/github_c_makefile_star2_O1/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 0x69ade
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x69a0e
xorl %eax, %eax
movq %rax, %rdi
callq 0x69167
movq %rbx, %rdi
callq 0x69167
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x523(%rip), %r12       # 0x69f38
movq 0x10(%r15), %rsi
cmpl $0x1, (%rsi)
jne 0x699ff
cmpl $0x7, 0x8(%rsi)
jne 0x699ff
movq 0x8(%r15), %rdi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x699eb
movq %r15, %rdi
movq %r14, %rsi
callq 0x69ade
cmpl $0x0, (%r14)
jne 0x699ed
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r12, %rcx
movq %r14, %r8
callq 0x69eb7
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x69a15
jmp 0x699eb
// File: /workspace/github_c_makefile_star2_O1/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 0x6b731
cmpl $0x0, (%r15)
jne 0x69f11
movl %eax, %ebp
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6b731
cmpl $0x0, (%r15)
jne 0x69f11
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 0x69f1e
movq %r14, %rdi
callq 0x69167
movq %rbx, %r14
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x69167
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_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x6a5c3
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x6a3d0
xorl %eax, %eax
movq %rax, %rdi
callq 0x69167
movq %rbx, %rdi
callq 0x69167
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9502(%rip), %r12      # 0x738d9
leaq 0x71a(%rip), %r13       # 0x6aaf8
leaq 0x741(%rip), %rbp       # 0x6ab26
movq 0x10(%r15), %rdi
cmpl $0x2, (%rdi)
jne 0x6a3be
callq 0x12ad0
movq %rax, %rdi
movq %r12, %rsi
callq 0x12160
testl %eax, %eax
jne 0x6a3be
movq 0x8(%r15), %rdi
movq 0x10(%r15), %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x6a3aa
movq %r15, %rdi
movq %r14, %rsi
callq 0x6a5c3
cmpl $0x0, (%r14)
jne 0x6a3ac
cmpl $0x6, (%rax)
jne 0x6a447
movl 0x8(%rax), %ecx
testl %ecx, %ecx
jns 0x6a447
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x8(%rax)
movl $0x7, (%rax)
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r13, %rcx
movq %rbp, %r8
movq %r14, %r9
callq 0x6a36e
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x6a3e5
jmp 0x6a3aa
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_div_int32_fn
static int32_t prv_div_int32_fn(subtilis_arm_ass_context_t *c, int32_t a,
				int32_t b, subtilis_error_t *err)
{
	if (b == 0) {
		subtilis_error_set_divide_by_zero(err, c->l->stream->name,
						  c->l->line);
		return 0;
	}

	return a / b;
}

// Assembly:
testl %edx, %edx
je 0x6a47e
movl %edx, %r8d
movl %esi, %eax
cltd
idivl %r8d
retq
pushq %rax
movq 0x8(%rdi), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %eax
leaq 0xcaff(%rip), %r8       # 0x76f90
movq %rcx, %rdi
movl $0x1a, %esi
movl %eax, %ecx
movl $0x679, %r9d            # imm = 0x679
callq 0x14618
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_binary_real
static subtilis_arm_exp_val_t *prv_binary_real(subtilis_arm_ass_context_t *c,
					       subtilis_arm_exp_val_t *e1,
					       subtilis_arm_exp_val_t *e2,
					       subtilis_ass_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_REAL;
	e1->val.real = 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r13
movq %r8, %rdx
callq 0x6bad3
cmpl $0x0, (%r15)
jne 0x6a55e
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movsd %xmm0, 0x8(%rsp)
callq 0x6bad3
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
cmpl $0x0, (%r15)
jne 0x6a55e
movl $0x7, (%rbx)
movq %r13, %rdi
movq %r15, %rsi
callq *%r12
movsd %xmm0, 0x8(%rbx)
cmpl $0x0, (%r15)
je 0x6a56b
movq %r14, %rdi
callq 0x69167
movq %rbx, %r14
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x69167
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_div_real_fn
static double prv_div_real_fn(subtilis_arm_ass_context_t *c, double a, double b,
			      subtilis_error_t *err)
{
	if (b == 0.0) {
		subtilis_error_set_divide_by_zero(err, c->l->stream->name,
						  c->l->line);
		return 0;
	}

	return a / b;
}

// Assembly:
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jne 0x6a5be
jp 0x6a5be
pushq %rax
movq 0x8(%rdi), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0xc9ed(%rip), %r8       # 0x76f90
movq %rsi, %rdi
movl $0x1a, %esi
movl $0x667, %r9d            # imm = 0x667
callq 0x14618
xorps %xmm0, %xmm0
addq $0x8, %rsp
retq
divsd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_pow_int32_fn
static int32_t prv_pow_int32_fn(subtilis_arm_ass_context_t *c, int32_t a,
				int32_t b, subtilis_error_t *err)
{
	int32_t accum;
	size_t i;

	if (b == 0)
		return 1;

	accum = a;
	for (i = 1; i < b; i++)
		accum *= a;

	return accum;
}

// Assembly:
testl %edx, %edx
je 0x6ab04
cmpl $0x1, %edx
jne 0x6ab0a
movl %esi, %eax
retq
movl $0x1, %eax
retq
cmpl $0x3, %edx
movl $0x2, %eax
cmovael %edx, %eax
movslq %eax, %rcx
decq %rcx
movl %esi, %eax
imull %esi, %eax
decq %rcx
jne 0x6ab1d
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_process_bktd_exp
static subtilis_arm_exp_val_t *
prv_process_bktd_exp(subtilis_arm_ass_context_t *c, subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_arm_exp_val_t *e;

	e = subtilis_arm_exp_val_get(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	tbuf = subtilis_token_get_text(c->t);
	if ((c->t->type != SUBTILIS_TOKEN_OPERATOR) || strcmp(tbuf, ")")) {
		subtilis_arm_exp_val_free(e);
		subtilis_error_set_right_bkt_expected(
		    err, tbuf, c->l->stream->name, c->l->line);
		return NULL;
	}

	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x69a84
cmpl $0x0, (%rbx)
jne 0x6abbf
movq %rax, %r14
movq 0x10(%r15), %rdi
callq 0x12ad0
movq %rax, %r12
movq 0x10(%r15), %rax
cmpl $0x2, (%rax)
jne 0x6ab83
leaq 0x8f76(%rip), %rsi      # 0x73aed
movq %r12, %rdi
callq 0x12160
testl %eax, %eax
je 0x6abc2
movq %r14, %rdi
callq 0x69167
movq 0x8(%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xc3f2(%rip), %rax      # 0x76f90
leaq 0x9250(%rip), %rcx      # 0x73df5
movq %rbx, %rdi
movl $0x16, %esi
movq %r12, %rdx
pushq $0x2ae                  # imm = 0x2AE
pushq %rax
callq 0x1442a
addq $0x10, %rsp
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_not
static subtilis_arm_exp_val_t *prv_not(subtilis_arm_ass_context_t *c,
				       subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *e;

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

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

	e->type = SUBTILIS_ARM_EXP_TYPE_INT;
	e->val.integer = ~prv_exp_to_int(c, e, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_arm_exp_val_free(e);
		return NULL;
	}

	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq 0x10(%r15), %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x6ac2d
movq %r15, %rdi
movq %r14, %rsi
callq 0x6a5c3
cmpl $0x0, (%r14)
jne 0x6ac2d
movq %rax, %rbx
movl $0x6, (%rax)
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x6b731
notl %eax
movl %eax, 0x8(%rbx)
cmpl $0x0, (%r14)
je 0x6ac2f
movq %rbx, %rdi
callq 0x69167
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq