LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x63aad
movq %rsi, %r15
callq 0x12a25
cmpb $0x2d, (%rax)
jne 0x63a74
cmpb $0x0, 0x1(%rax)
je 0x63abd
movq 0x8(%r14), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0xd259(%rip), %r10      # 0x70ce0
leaq 0xd37a(%rip), %rdx      # 0x70e08
pushq $0x1d
popq %rsi
movq %rbx, %rdi
movq %rax, %rcx
pushq $0x41c                  # imm = 0x41C
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6463f
movb $0x1, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x647a2
// File: /workspace/github_c_makefile_star2_O2/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 0x63ae6
movb $0x1, (%rcx)
xorl %eax, %eax
subl 0x8(%rsi), %eax
movl %eax, 0x8(%rdx)
cmpl $0x1000, %eax           # imm = 0x1000
jb 0x63b21
pushq %rax
movl 0x8(%rsi), %edx
movq 0x8(%rdi), %rcx
movq 0x30(%rcx), %rax
movl 0x38(%rcx), %r9d
leaq 0xd1d9(%rip), %r10      # 0x70ce0
pushq $0x5b
popq %rsi
movq %r8, %rdi
xorl %ecx, %ecx
movq %rax, %r8
pushq $0x433                  # imm = 0x433
pushq %r10
callq 0x14179
popq %rax
popq %rcx
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12a25
movq %rax, %r12
movq 0x8(%r15), %rdi
movq 0x10(%r15), %rsi
movq %rbx, %rdx
callq 0x12e0e
pushq $0x3
popq %rbp
cmpl $0x0, (%rbx)
jne 0x63be1
movq 0x10(%r15), %rax
cmpl $0x1, (%rax)
jne 0x63b87
movl 0x8(%rax), %eax
addl $-0x27, %eax
cmpl $0x5, %eax
jae 0x63bb1
movl %eax, %eax
leaq 0xd12a(%rip), %rcx      # 0x70cac
movl (%rcx,%rax,4), %ebp
jmp 0x63be1
movq 0x8(%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xd146(%rip), %rax      # 0x70ce0
leaq 0xa224(%rip), %rcx      # 0x6ddc5
pushq $0x10
popq %rsi
movq %rbx, %rdi
movq %r12, %rdx
pushq $0x3f5                  # imm = 0x3F5
jmp 0x63bd9
movq 0x8(%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xd11c(%rip), %rax      # 0x70ce0
leaq 0xd254(%rip), %rdx      # 0x70e1f
pushq $0x1d
popq %rsi
movq %rbx, %rdi
movq %r12, %rcx
pushq $0x40b                  # imm = 0x40B
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
movl %ebp, 0x10(%r14)
cmpl $0x0, (%rbx)
jne 0x63bfa
movq %r15, %rdi
movq %rbx, %rsi
callq 0x647a2
cmpl $0x0, (%rbx)
je 0x63c03
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movl (%rax), %eax
cmpl $0x1, %eax
je 0x63c22
cmpl $0x6, %eax
jne 0x63c32
movb $0x0, 0x20(%r14)
movl 0x8(%r12), %eax
movl %eax, 0x18(%r14)
jmp 0x63c6b
movb $0x1, 0x20(%r14)
movq 0x8(%r12), %rax
movq %rax, 0x18(%r14)
jmp 0x63c6b
movq %r12, %rdi
callq 0x647dd
movq 0x8(%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0xd093(%rip), %r10      # 0x70ce0
leaq 0xd17e(%rip), %rdx      # 0x70dd2
pushq $0x1d
popq %rsi
movq %rbx, %rdi
movq %rax, %rcx
pushq $0x44d                  # imm = 0x44D
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %r12, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x63ee7
// File: /workspace/github_c_makefile_star2_O2/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 0x63c8a
cmpb $0x1, (%rsi)
jne 0x63c8a
andl $0x0, (%rdi)
retq
cmpb $0x1, 0x3(%rsi)
jne 0x63c9c
cmpb $0x1, (%rsi)
jne 0x63ca9
movl $0x1, (%rdi)
retq
cmpb $0x1, 0x4(%rsi)
jne 0x63cb0
movl $0x3, (%rdi)
retq
movl $0x2, (%rdi)
retq
leaq 0xd029(%rip), %rax      # 0x70ce0
pushq $0xf
popq %rsi
movq %rdx, %rdi
movq %rax, %rdx
movl $0x49a, %ecx            # imm = 0x49A
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 0x63ce3
movb $0x1, (%rcx)
movl 0x8(%rsi), %edx
movl %edx, %ebp
negl %ebp
cmpl $0x100, %ebp            # imm = 0x100
jl 0x63d17
movq 0x8(%rdi), %rcx
movq 0x30(%rcx), %rax
movl 0x38(%rcx), %r9d
leaq 0xcfe2(%rip), %r10      # 0x70ce0
pushq $0x5b
popq %rsi
movq %r8, %rdi
xorl %ecx, %ecx
movq %rax, %r8
pushq $0x487                  # imm = 0x487
pushq %r10
callq 0x14179
popq %rax
popq %rcx
movb %bpl, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12e0e
pushq $-0x1
popq %rbx
cmpl $0x0, (%r14)
jne 0x63dbb
movq 0x10(%r15), %rdi
callq 0x12a25
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x64173
cmpl $0x0, (%r14)
jne 0x63dbb
movq %rax, %r13
movq 0x8(%r15), %rdi
cmpq $-0x1, %rax
je 0x63d8f
movq 0x10(%r15), %rsi
movq %r14, %rdx
callq 0x12e0e
xorl %ebx, %ebx
cmpl (%r14), %ebx
sbbq %rbx, %rbx
orq %r13, %rbx
jmp 0x63dbb
movq 0x30(%rdi), %r8
movl 0x38(%rdi), %r9d
leaq 0xcf42(%rip), %rax      # 0x70ce0
leaq 0xa020(%rip), %rcx      # 0x6ddc5
pushq $0x58
popq %rsi
movq %r14, %rdi
movq %r12, %rdx
pushq $0x2b6                  # imm = 0x2B6
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_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
pushq $0x18
popq %rdi
callq 0x121d0
movq %rax, %rbx
testq %rax, %rax
je 0x63dec
movl $0x6, (%rbx)
movl %ebp, 0x8(%rbx)
jmp 0x63e01
leaq 0xd171(%rip), %rdx      # 0x70f64
pushq $0x1
popq %rsi
pushq $0x32
popq %rcx
movq %r14, %rdi
callq 0x1429e
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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)
pushq $0x18
popq %rdi
callq 0x121d0
movq %rax, %rbx
testq %rax, %rax
je 0x63e37
movl $0x7, (%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0x63e4c
leaq 0xd126(%rip), %rdx      # 0x70f64
pushq $0x1
popq %rsi
pushq $0x41
popq %rcx
movq %r14, %rdi
callq 0x1429e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x63eb4
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 0x146a8
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x14837
cmpl $0x0, (%r14)
je 0x63ecd
movq %rbx, %rdi
callq 0x63ee7
jmp 0x63ec9
leaq 0xd0a9(%rip), %rdx      # 0x70f64
pushq $0x1
popq %rsi
pushq $0x51
popq %rcx
movq %r14, %rdi
callq 0x1429e
xorl %ebx, %ebx
jmp 0x63ed8
movq %r12, %rdi
movq %r14, %rsi
callq 0x149a8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_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 0x63f0c
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
andl $-0x2, %eax
cmpl $0x8, %eax
jne 0x63f03
leaq 0x8(%rbx), %rdi
callq 0x14a01
movq %rbx, %rdi
popq %rbx
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x63f75
movq %rax, %rbx
movl $0x8, (%rax)
movq %r15, %rdi
callq 0x14804
movq %rax, %r12
movq %rbx, %r13
addq $0x8, %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x146a8
movq 0x8(%r15), %rsi
addq $0x18, %rsi
movq %r13, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x14795
cmpl $0x0, (%r14)
je 0x63f8c
movq %rbx, %rdi
callq 0x63ee7
jmp 0x63f8a
leaq 0xcfe8(%rip), %rdx      # 0x70f64
pushq $0x1
popq %rsi
pushq $0x6c
popq %rcx
movq %r14, %rdi
callq 0x1429e
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_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
pushq $0x18
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x6400d
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 0x146a8
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x14795
cmpl $0x0, (%r14)
jne 0x64003
movq %r12, %rdi
movq %r14, %rsi
callq 0x149a8
cmpl $0x0, (%r14)
je 0x64026
movq %rbx, %rdi
callq 0x63ee7
jmp 0x64024
leaq 0xcf50(%rip), %rdx      # 0x70f64
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x83, %ecx
callq 0x1429e
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_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
pushq $0x18
popq %rdi
callq 0x121d0
movq %rax, %rbx
testq %rax, %rax
je 0x64062
movl %ebp, (%rbx)
movq %r15, 0x8(%rbx)
jmp 0x64079
leaq 0xcefb(%rip), %rdx      # 0x70f64
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x9f, %ecx
callq 0x1429e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6414b
leaq 0xcdab(%rip), %rcx      # 0x70e70
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x64087
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x6409e
addq $0x8, %rdi
callq 0x14a53
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x63f99
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x64096
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x6408e
movsd 0x8(%rdi), %xmm0
movq %rbx, %rdi
popq %rbx
jmp 0x63e09
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x64033
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x640a6
movl 0x8(%rdi), %edi
movq %rbx, %rsi
popq %rbx
jmp 0x63dc8
leaq 0xce12(%rip), %rdx      # 0x70f64
pushq $0xf
popq %rsi
movq %rbx, %rdi
movl $0xea, %ecx
callq 0x1429e
xorl %eax, %eax
popq %rbx
retq
addq $0x8, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x63f0d
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x1(%rsi), %r12
movq %r12, %rdi
callq 0x120f0
leaq -0x3(%rax), %rcx
pushq $-0x1
popq %r13
cmpq $-0x2, %rcx
jae 0x641ac
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movzbl (%rbx), %ecx
cmpl $0x72, %ecx
je 0x641d4
cmpl $0x52, %ecx
je 0x641d4
movq %r13, %rax
cmpl $0x50, %ecx
jne 0x641a2
xorl %eax, %eax
cmpb $0x43, (%r12)
setne %al
negq %rax
orq $0xf, %rax
jmp 0x641a2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x64217
cmpq $0x10, %rax
jb 0x641a2
movq 0x8(%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xcd6c(%rip), %rax      # 0x70f64
leaq 0x9bc6(%rip), %rcx      # 0x6ddc5
pushq $0x58
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
pushq $0x1dd                  # imm = 0x1DD
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
jmp 0x6419f
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_parse_reg_num
static size_t prv_parse_reg_num(const char *id, size_t name_len)
{
	size_t reg;

	if (id[1] < '0' || id[1] > '9')
		return SIZE_MAX;
	reg = id[1] - '0';
	if (name_len == 2) {
		if (id[2] < '0' || id[2] > '9')
			return SIZE_MAX;
		reg *= 10;
		reg += id[2] - '0';
	}

	return reg;
}

// Assembly:
movb 0x1(%rdi), %cl
leal -0x3a(%rcx), %edx
pushq $-0x1
popq %rax
cmpb $-0xa, %dl
jae 0x64226
retq
addb $-0x30, %cl
movzbl %cl, %ecx
cmpq $0x2, %rsi
jne 0x6424c
movb 0x2(%rdi), %dl
leal -0x3a(%rdx), %esi
cmpb $-0xa, %sil
jb 0x64225
imulq $0xa, %rcx, %rcx
addb $-0x30, %dl
movzbl %dl, %eax
addq %rcx, %rax
retq
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rbx
cmpq $0x1, %rax
jne 0x642c7
movzbl (%r14), %eax
orl $0x20, %eax
cmpl $0x66, %eax
jne 0x642c7
movb (%r13), %al
leal -0x38(%rax), %ecx
cmpb $-0x9, %cl
ja 0x642c2
movq 0x8(%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xccc1(%rip), %rax      # 0x70f64
leaq 0x9b1b(%rip), %rcx      # 0x6ddc5
pushq $0x58
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
pushq $0x1f4                  # imm = 0x1F4
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
jmp 0x642c7
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_O2/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
pushq $-0x1
popq %rbx
cmpq $0x1, %rax
jne 0x6433f
movb (%r13), %al
leal -0x3a(%rax), %ecx
cmpb $-0xa, %cl
jae 0x6433a
movq 0x8(%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xcc49(%rip), %rax      # 0x70f64
leaq 0x9aa3(%rip), %rcx      # 0x6ddc5
pushq $0x58
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
pushq $0x20a                  # imm = 0x20A
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
jmp 0x6433f
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_O2/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
pushq $-0x1
popq %rbx
cmpq $0x1, %rax
jne 0x643c3
movzbl (%r14), %eax
orl $0x20, %eax
cmpl $0x73, %eax
jne 0x643c3
movb (%r13), %al
leal -0x3a(%rax), %ecx
cmpb $-0xa, %cl
jae 0x643be
movq 0x8(%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xcbc5(%rip), %rax      # 0x70f64
leaq 0x9a1f(%rip), %rcx      # 0x6ddc5
pushq $0x58
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
pushq $0x222                  # imm = 0x222
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
jmp 0x643c3
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_O2/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 0xc9c8(%rip), %rsi      # 0x70da6
movq %rbx, %rdi
callq 0x12160
testl %eax, %eax
je 0x64457
leaq 0xcb8f(%rip), %rsi      # 0x70f80
movq %rbx, %rdi
callq 0x12160
testl %eax, %eax
je 0x64457
leaq 0xc367(%rip), %rsi      # 0x7076b
movq %rbx, %rdi
callq 0x12160
pushq $0x1
popq %r14
testl %eax, %eax
je 0x6445a
leaq 0xcb6b(%rip), %rsi      # 0x70f86
movq %rbx, %rdi
callq 0x12160
testl %eax, %eax
je 0x6445a
leaq 0xc343(%rip), %rsi      # 0x70771
movq %rbx, %rdi
callq 0x12160
testl %eax, %eax
je 0x64465
leaq 0xcb4b(%rip), %rsi      # 0x70f8c
movq %rbx, %rdi
callq 0x12160
xorl %r14d, %r14d
negl %eax
sbbq %r14, %r14
orq $0x2, %r14
jmp 0x6445a
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x2
popq %r14
jmp 0x6445a
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
leaq 0xc1d2(%rip), %rsi      # 0x7064c
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x12060
pushq $-0x1
popq %rbx
testl %eax, %eax
je 0x644a8
leaq 0xc9ac(%rip), %rsi      # 0x70e3f
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x12060
testl %eax, %eax
jne 0x64515
pushq $0x1
popq %r15
jmp 0x644ab
xorl %r15d, %r15d
movzbl 0x4(%r14), %eax
testl %eax, %eax
je 0x64512
cmpl $0x5f, %eax
jne 0x64515
addq $0x5, %r14
movq %r14, %rdi
callq 0x120f0
addq $-0x5, %rax
cmpq $-0x4, %rax
jb 0x64515
movzbl (%r14), %eax
cmpl $0x63, %eax
je 0x644fc
cmpl $0x66, %eax
je 0x644ee
cmpl $0x73, %eax
je 0x644f5
cmpl $0x78, %eax
jne 0x6450e
movl $0x20000, %eax          # imm = 0x20000
jmp 0x64501
movl $0x80000, %eax          # imm = 0x80000
jmp 0x64501
movl $0x40000, %eax          # imm = 0x40000
jmp 0x64501
movl $0x10000, %eax          # imm = 0x10000
testl %r15d, %eax
jne 0x64515
orq %rax, %r15
incq %r14
jmp 0x644cf
testl %eax, %eax
jne 0x64515
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x64173
cmpl $0x0, (%rbx)
je 0x6453e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
cmpq $-0x1, %rax
je 0x64554
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x64033
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x64250
cmpl $0x0, (%rbx)
jne 0x64536
cmpq $-0x1, %rax
je 0x6457d
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x64087
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6434c
cmpl $0x0, (%rbx)
jne 0x64536
cmpq $-0x1, %rax
je 0x645a6
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x64096
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x642d4
cmpl $0x0, (%rbx)
jne 0x64536
cmpq $-0x1, %rax
je 0x645d3
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6408e
movq %r14, %rsi
callq 0x643d0
cmpq $-0x1, %rax
je 0x645f1
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6409e
movq %r14, %rsi
callq 0x6446b
cmpq $-0x1, %rax
je 0x6460f
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x640a6
movq %r15, %rdi
movq %r14, %rsi
callq 0x5f0b6
testq %rax, %rax
je 0x6462f
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x640ae
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x63f99
// File: /workspace/github_c_makefile_star2_O2/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 0x646ed
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x64684
xorl %eax, %eax
movq %rax, %rdi
callq 0x63ee7
movq %rbx, %rdi
callq 0x63ee7
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        # 0x64784
leaq 0x101(%rip), %r13       # 0x64793
movq 0x10(%r15), %rsi
cmpl $0x1, (%rsi)
jne 0x64672
movl 0x8(%rsi), %eax
movq %r12, %rbp
cmpl $0xe, %eax
je 0x646ae
cmpl $0x1b, %eax
jne 0x64672
movq %r13, %rbp
movq 0x8(%r15), %rdi
movq %r14, %rdx
callq 0x12e0e
cmpl $0x0, (%r14)
jne 0x6465e
movq %r15, %rdi
movq %r14, %rsi
callq 0x646ed
cmpl $0x0, (%r14)
jne 0x64660
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq *%rbp
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x64692
jmp 0x6465e
// File: /workspace/github_c_makefile_star2_O2/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 0x647fc
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x6472c
xorl %eax, %eax
movq %rax, %rdi
callq 0x63ee7
movq %rbx, %rdi
callq 0x63ee7
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x502(%rip), %r12       # 0x64c35
movq 0x10(%r15), %rsi
cmpl $0x1, (%rsi)
jne 0x6471d
cmpl $0x7, 0x8(%rsi)
jne 0x6471d
movq 0x8(%r15), %rdi
movq %r14, %rdx
callq 0x12e0e
cmpl $0x0, (%r14)
jne 0x64709
movq %r15, %rdi
movq %r14, %rsi
callq 0x647fc
cmpl $0x0, (%r14)
jne 0x6470b
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r12, %rcx
movq %r14, %r8
callq 0x64bb4
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x64733
jmp 0x64709
// File: /workspace/github_c_makefile_star2_O2/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 0x660a6
cmpl $0x0, (%r15)
jne 0x64c0e
movl %eax, %ebp
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x660a6
cmpl $0x0, (%r15)
jne 0x64c0e
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 0x64c1b
movq %r14, %rdi
callq 0x63ee7
movq %rbx, %r14
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x63ee7
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_O2/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 0x652a0
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x650c3
xorl %eax, %eax
movq %rax, %rdi
callq 0x63ee7
movq %rbx, %rdi
callq 0x63ee7
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xee8(%rip), %r12       # 0x65fb2
leaq 0xefc(%rip), %r13       # 0x65fcd
movq 0x10(%r15), %rdi
cmpl $0x2, (%rdi)
jne 0x650b6
callq 0x12a25
cmpb $0x5e, (%rax)
jne 0x650b6
cmpb $0x0, 0x1(%rax)
jne 0x650b6
movq 0x8(%r15), %rdi
movq 0x10(%r15), %rsi
movq %r14, %rdx
callq 0x12e0e
cmpl $0x0, (%r14)
jne 0x650a2
movq %r15, %rdi
movq %r14, %rsi
callq 0x652a0
cmpl $0x0, (%r14)
jne 0x650a4
cmpl $0x6, (%rax)
jne 0x6512c
movl 0x8(%rax), %ecx
testl %ecx, %ecx
jns 0x6512c
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 0x65068
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x650d1
jmp 0x650a2
// File: /workspace/github_c_makefile_star2_O2/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 0x6515f
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 0xbdf2(%rip), %r8       # 0x70f64
pushq $0x1a
popq %rsi
movq %rcx, %rdi
movl %eax, %ecx
movl $0x679, %r9d            # imm = 0x679
callq 0x142c0
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x663fb
cmpl $0x0, (%r15)
jne 0x6523b
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movsd %xmm0, 0x8(%rsp)
callq 0x663fb
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
cmpl $0x0, (%r15)
jne 0x6523b
movl $0x7, (%rbx)
movq %r13, %rdi
movq %r15, %rsi
callq *%r12
movsd %xmm0, 0x8(%rbx)
cmpl $0x0, (%r15)
je 0x65248
movq %r14, %rdi
callq 0x63ee7
movq %rbx, %r14
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x63ee7
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_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 0x6529b
jp 0x6529b
pushq %rax
movq 0x8(%rdi), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0xbce4(%rip), %r8       # 0x70f64
pushq $0x1a
popq %rax
movq %rsi, %rdi
movl %eax, %esi
movl $0x667, %r9d            # imm = 0x667
callq 0x142c0
xorps %xmm0, %xmm0
addq $0x8, %rsp
retq
divsd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x647a2
cmpl $0x0, (%rbx)
jne 0x6605e
movq %rax, %r14
movq 0x10(%r15), %rdi
callq 0x12a25
movq %rax, %r12
movq 0x10(%r15), %rax
cmpl $0x2, (%rax)
jne 0x66026
cmpb $0x29, (%r12)
jne 0x66026
cmpb $0x0, 0x1(%r12)
je 0x66061
movq %r14, %rdi
callq 0x63ee7
movq 0x8(%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0xaf23(%rip), %rax      # 0x70f64
leaq 0x7d7d(%rip), %rcx      # 0x6ddc5
pushq $0x16
popq %rsi
movq %rbx, %rdi
movq %r12, %rdx
pushq $0x2ae                  # imm = 0x2AE
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_dbl_unary
static subtilis_arm_exp_val_t *prv_dbl_unary(subtilis_arm_ass_context_t *c,
					     double (*fn)(double),
					     subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;

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

	return val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdx, %rsi
callq 0x6618d
cmpl $0x0, (%r15)
je 0x6608d
xorl %ebx, %ebx
jmp 0x6609d
movq %rax, %rbx
movsd 0x8(%rax), %xmm0
callq *%r14
movsd %xmm0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_exp_to_int
static int32_t prv_exp_to_int(subtilis_arm_ass_context_t *c,
			      subtilis_arm_exp_val_t *e1, subtilis_error_t *err)
{
	switch (e1->type) {
	case SUBTILIS_ARM_EXP_TYPE_INT:
		return e1->val.integer;
	case SUBTILIS_ARM_EXP_TYPE_REAL:
		return (int32_t)e1->val.real;
	default:
		subtilis_error_set_numeric_exp_expected(err, c->l->stream->name,
							c->l->line);
		return 0;
	}
}

// Assembly:
movl (%rsi), %eax
cmpl $0x7, %eax
je 0x660b6
cmpl $0x6, %eax
jne 0x660bc
movl 0x8(%rsi), %eax
retq
cvttsd2si 0x8(%rsi), %eax
retq
pushq %rax
movq 0x8(%rdi), %rcx
movq 0x30(%rcx), %rax
movl 0x38(%rcx), %ecx
leaq 0xae95(%rip), %r8       # 0x70f64
pushq $0x44
popq %rsi
movq %rdx, %rdi
movq %rax, %rdx
movl $0xf9, %r9d
callq 0x142c0
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_bracketed_exp
static subtilis_arm_exp_val_t *prv_bracketed_exp(subtilis_arm_ass_context_t *c,
						 subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_arm_exp_val_t *e = NULL;

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

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

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

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

	return e;

cleanup:

	subtilis_arm_exp_val_free(e);

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rsi
movq %rbx, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
jne 0x6614f
movq 0x10(%r14), %rdi
callq 0x12a25
cmpb $0x28, (%rax)
jne 0x6611e
cmpb $0x0, 0x1(%rax)
je 0x6615b
movq 0x8(%r14), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0xae33(%rip), %r10      # 0x70f64
leaq 0x777a(%rip), %rdx      # 0x6d8b2
pushq $0x1d
popq %rsi
movq %rbx, %rdi
movq %rax, %rcx
pushq $0x2f1                  # imm = 0x2F1
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x65fe7
cmpl $0x0, (%rbx)
jne 0x6614f
movq %rax, %r15
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rsi
movq %rbx, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
je 0x66152
movq %r15, %rdi
callq 0x63ee7
jmp 0x6614f
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_real_bkt_exp
static subtilis_arm_exp_val_t *prv_real_bkt_exp(subtilis_arm_ass_context_t *c,
						subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;

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

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

	return val;

cleanup:

	subtilis_arm_exp_val_free(val);

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x660ea
cmpl $0x0, (%r14)
je 0x661ae
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl (%rax), %eax
cmpl $0x7, %eax
je 0x661a5
cmpl $0x6, %eax
jne 0x661cf
movl $0x7, (%rbx)
cvtsi2sdl 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0x661a5
movq 0x8(%r15), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0xad83(%rip), %r8       # 0x70f64
pushq $0x44
popq %rsi
movq %r14, %rdi
movl $0x318, %r9d            # imm = 0x318
callq 0x142c0
movq %rbx, %rdi
callq 0x63ee7
jmp 0x661a3
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_exp_to_real
static double prv_exp_to_real(subtilis_arm_ass_context_t *c,
			      subtilis_arm_exp_val_t *e1, subtilis_error_t *err)
{
	switch (e1->type) {
	case SUBTILIS_ARM_EXP_TYPE_INT:
		return (double)e1->val.integer;
	case SUBTILIS_ARM_EXP_TYPE_REAL:
		return e1->val.real;
	default:
		subtilis_error_set_numeric_exp_expected(err, c->l->stream->name,
							c->l->line);
		return 0;
	}
}

// Assembly:
movl (%rsi), %eax
cmpl $0x7, %eax
je 0x6640d
cmpl $0x6, %eax
jne 0x66413
cvtsi2sdl 0x8(%rsi), %xmm0
retq
movsd 0x8(%rsi), %xmm0
retq
pushq %rax
movq 0x8(%rdi), %rcx
movq 0x30(%rcx), %rax
movl 0x38(%rcx), %ecx
leaq 0xab3e(%rip), %r8       # 0x70f64
pushq $0x44
popq %rsi
movq %rdx, %rdi
movq %rax, %rdx
movl $0x108, %r9d            # imm = 0x108
callq 0x142c0
xorps %xmm0, %xmm0
addq $0x8, %rsp
retq