LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x18, %edi
callq 0x121b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9a61c
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x13dfb(%rip), %rdx     # 0xae400
movl $0x83, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x9a6ae
movq -0x28(%rbp), %rax
movl $0x9, (%rax)
movq -0x10(%rbp), %rdi
callq 0x120d0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x15f80
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x16200
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9a679
movq -0x28(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
jmp 0x9a6ae
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x16560
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9a6a6
movq -0x28(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
jmp 0x9a6ae
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x18, %edi
callq 0x121b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9a73c
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x13cd8(%rip), %rdx     # 0xae400
movl $0x9f, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x9a759
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x9, %rax
ja 0x9a99d
movq -0x28(%rbp), %rax
leaq 0x13a25(%rip), %rcx     # 0xae2b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9a770
movq %rax, -0x8(%rbp)
jmp 0x9a9bf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9a6c0
movq %rax, -0x8(%rbp)
jmp 0x9a9bf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9a7d0
movq %rax, -0x8(%rbp)
jmp 0x9a9bf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9a7a0
movq %rax, -0x8(%rbp)
jmp 0x9a9bf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9a800
movq %rax, -0x8(%rbp)
jmp 0x9a9bf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9a830
movq %rax, -0x8(%rbp)
jmp 0x9a9bf
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x18(%rbp), %rsi
callq 0x9a300
movq %rax, -0x8(%rbp)
jmp 0x9a9bf
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rdi
callq 0x9a370
movq %rax, -0x8(%rbp)
jmp 0x9a9bf
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x9a510
movq %rax, -0x8(%rbp)
jmp 0x9a9bf
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x16760
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9a5d0
movq %rax, -0x8(%rbp)
jmp 0x9a9bf
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x13a53(%rip), %rdx     # 0xae400
movl $0xea, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x120d0
movq %rax, -0x30(%rbp)
cmpq $0x1, -0x30(%rbp)
je 0x9aa10
cmpq $0x2, -0x30(%rbp)
je 0x9aa10
movq $-0x1, -0x8(%rbp)
jmp 0x9aac6
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x50, %eax
jne 0x9aa36
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x43, %eax
jne 0x9aa36
movq $0xf, -0x8(%rbp)
jmp 0x9aac6
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x52, %eax
je 0x9aa58
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
je 0x9aa58
movq $-0x1, -0x8(%rbp)
jmp 0x9aac6
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9aad0
movq %rax, -0x28(%rbp)
cmpq $0xf, -0x28(%rbp)
jbe 0x9aabe
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x58, %esi
leaq 0x107da(%rip), %rcx     # 0xab276
leaq 0x1395d(%rip), %rax     # 0xae400
movq %rax, (%rsp)
movl $0x1dd, 0x8(%rsp)       # imm = 0x1DD
callq 0x156d0
movq $-0x1, -0x8(%rbp)
jmp 0x9aac6
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x30, %eax
jl 0x9aaf6
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x39, %eax
jle 0x9ab00
movq $-0x1, -0x8(%rbp)
jmp 0x9ab62
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
subl $0x30, %eax
cltq
movq %rax, -0x20(%rbp)
cmpq $0x2, -0x18(%rbp)
jne 0x9ab5a
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x30, %eax
jl 0x9ab32
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x39, %eax
jle 0x9ab3c
movq $-0x1, -0x8(%rbp)
jmp 0x9ab62
imulq $0xa, -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
subl $0x30, %eax
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x120d0
movq %rax, -0x30(%rbp)
cmpq $0x1, -0x30(%rbp)
je 0x9aba9
movq $-0x1, -0x8(%rbp)
jmp 0x9ac4f
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x46, %eax
je 0x9abce
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x66, %eax
je 0x9abce
movq $-0x1, -0x8(%rbp)
jmp 0x9ac4f
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x30, %eax
jl 0x9abe8
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x37, %eax
jle 0x9ac36
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x58, %esi
leaq 0x10662(%rip), %rcx     # 0xab276
leaq 0x137e5(%rip), %rax     # 0xae400
movq %rax, (%rsp)
movl $0x1f4, 0x8(%rsp)       # imm = 0x1F4
callq 0x156d0
movq $-0x1, -0x8(%rbp)
jmp 0x9ac4f
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
subl $0x30, %eax
cltq
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x120d0
movq %rax, -0x30(%rbp)
cmpq $0x1, -0x30(%rbp)
je 0x9ac96
movq $-0x1, -0x8(%rbp)
jmp 0x9ad04
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9aad0
movq %rax, -0x28(%rbp)
cmpq $0xf, -0x28(%rbp)
jbe 0x9acfc
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x58, %esi
leaq 0x1059c(%rip), %rcx     # 0xab276
leaq 0x1371f(%rip), %rax     # 0xae400
movq %rax, (%rsp)
movl $0x20a, 0x8(%rsp)       # imm = 0x20A
callq 0x156d0
movq $-0x1, -0x8(%rbp)
jmp 0x9ad04
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x120d0
movq %rax, -0x30(%rbp)
cmpq $0x1, -0x30(%rbp)
je 0x9ad49
movq $-0x1, -0x8(%rbp)
jmp 0x9add9
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x53, %eax
je 0x9ad6b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x73, %eax
je 0x9ad6b
movq $-0x1, -0x8(%rbp)
jmp 0x9add9
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9aad0
movq %rax, -0x28(%rbp)
cmpq $0x1f, -0x28(%rbp)
jbe 0x9add1
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x58, %esi
leaq 0x104c7(%rip), %rcx     # 0xab276
leaq 0x1364a(%rip), %rax     # 0xae400
movq %rax, (%rsp)
movl $0x222, 0x8(%rsp)       # imm = 0x222
callq 0x156d0
movq $-0x1, -0x8(%rbp)
jmp 0x9add9
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x133e0(%rip), %rsi     # 0xae1eb
callq 0x12140
cmpl $0x0, %eax
je 0x9ae2a
movq -0x10(%rbp), %rdi
leaq 0x135fc(%rip), %rsi     # 0xae41c
callq 0x12140
cmpl $0x0, %eax
jne 0x9ae34
movq $0x0, -0x18(%rbp)
jmp 0x9aea8
movq -0x10(%rbp), %rdi
leaq 0x1293f(%rip), %rsi     # 0xad77e
callq 0x12140
cmpl $0x0, %eax
je 0x9ae5e
movq -0x10(%rbp), %rdi
leaq 0x135ce(%rip), %rsi     # 0xae422
callq 0x12140
cmpl $0x0, %eax
jne 0x9ae68
movq $0x1, -0x18(%rbp)
jmp 0x9aea6
movq -0x10(%rbp), %rdi
leaq 0x12911(%rip), %rsi     # 0xad784
callq 0x12140
cmpl $0x0, %eax
je 0x9ae92
movq -0x10(%rbp), %rdi
leaq 0x135a0(%rip), %rsi     # 0xae428
callq 0x12140
cmpl $0x0, %eax
jne 0x9ae9c
movq $0x2, -0x18(%rbp)
jmp 0x9aea4
movq $-0x1, -0x18(%rbp)
jmp 0x9aea6
jmp 0x9aea8
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1277b(%rip), %rsi     # 0xad656
movl $0x4, %edx
callq 0x12050
cmpl $0x0, %eax
jne 0x9aef4
movq $0x0, -0x20(%rbp)
jmp 0x9af27
movq -0x18(%rbp), %rdi
leaq 0x13385(%rip), %rsi     # 0xae284
movl $0x4, %edx
callq 0x12050
cmpl $0x0, %eax
jne 0x9af18
movq $0x1, -0x20(%rbp)
jmp 0x9af25
movq $-0x1, -0x8(%rbp)
jmp 0x9b040
jmp 0x9af27
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x9af49
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9b040
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
je 0x9af62
movq $-0x1, -0x8(%rbp)
jmp 0x9b040
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x120d0
cmpq $0x0, %rax
je 0x9af8c
movq -0x18(%rbp), %rdi
callq 0x120d0
cmpq $0x4, %rax
jbe 0x9af99
movq $-0x1, -0x8(%rbp)
jmp 0x9b040
jmp 0x9af9b
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x9b038
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
addl $-0x63, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x15, %eax
ja 0x9aff9
movq -0x30(%rbp), %rax
leaq 0x13314(%rip), %rcx     # 0xae2dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x10000, -0x28(%rbp)   # imm = 0x10000
jmp 0x9b003
movq $0x20000, -0x28(%rbp)   # imm = 0x20000
jmp 0x9b003
movq $0x40000, -0x28(%rbp)   # imm = 0x40000
jmp 0x9b003
movq $0x80000, -0x28(%rbp)   # imm = 0x80000
jmp 0x9b003
movq $-0x1, -0x8(%rbp)
jmp 0x9b040
movq -0x20(%rbp), %rax
andq -0x28(%rbp), %rax
cmpq $0x0, %rax
je 0x9b01b
movq $-0x1, -0x8(%rbp)
jmp 0x9b040
movq -0x28(%rbp), %rax
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9af9b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9b350
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9b25f
jmp 0x9b328
jmp 0x9b261
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x1, (%rax)
jne 0x9b31e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0xe, 0x8(%rax)
jne 0x9b28d
leaq 0x1e9(%rip), %rax       # 0x9b470
movq %rax, -0x30(%rbp)
jmp 0x9b2ac
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x1b, 0x8(%rax)
jne 0x9b2a8
leaq 0x20e(%rip), %rax       # 0x9b4b0
movq %rax, -0x30(%rbp)
jmp 0x9b2aa
jmp 0x9b31e
jmp 0x9b2ac
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x133f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9b2d0
jmp 0x9b328
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9b350
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9b2ec
jmp 0x9b328
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq *%rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9b319
jmp 0x9b328
jmp 0x9b261
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9b342
movq -0x28(%rbp), %rdi
callq 0x9a4c0
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9b620
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9b38f
jmp 0x9b440
jmp 0x9b391
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
xorl %eax, %eax
cmpl $0x1, (%rcx)
movb %al, -0x29(%rbp)
jne 0x9b3b5
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x7, 0x8(%rax)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x9b3be
jmp 0x9b436
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x133f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9b3e2
jmp 0x9b440
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9b620
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9b3fe
jmp 0x9b440
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %r8
leaq 0x64b(%rip), %rcx       # 0x9ba60
callq 0x9b990
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9b431
jmp 0x9b440
jmp 0x9b391
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9b45a
movq -0x28(%rbp), %rdi
callq 0x9a4c0
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: subtilis_arm_exp_val_get
subtilis_arm_exp_val_t *subtilis_arm_exp_val_get(subtilis_arm_ass_context_t *c,
						 subtilis_error_t *err)
{
	subtilis_lexer_get(c->l, c->t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	return subtilis_arm_exp_pri7(c, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x133f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9b52c
movq $0x0, -0x8(%rbp)
jmp 0x9b53d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9b220
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: subtilis_arm_exp_type_name
const char *subtilis_arm_exp_type_name(subtilis_arm_exp_val_t *val)
{
	switch (val->type) {
	case SUBTILIS_ARM_EXP_TYPE_FREG:
		return "floating point register";
	case SUBTILIS_ARM_EXP_TYPE_REG:
		return "register";
	case SUBTILIS_ARM_EXP_TYPE_SREG:
		return "vfp S register";
	case SUBTILIS_ARM_EXP_TYPE_DREG:
		return "vfp D register";
	case SUBTILIS_ARM_EXP_TYPE_SYSREG:
		return "vfp SYSREG register";
	case SUBTILIS_ARM_EXP_TYPE_FLAGS_REG:
		return "flags register";
	case SUBTILIS_ARM_EXP_TYPE_INT:
		return "integer";
	case SUBTILIS_ARM_EXP_TYPE_REAL:
		return "real";
	case SUBTILIS_ARM_EXP_TYPE_STRING:
		return "string";
	case SUBTILIS_ARM_EXP_TYPE_ID:
		return "identifier";
	default:
		return "unknown";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x9, %rax
ja 0x9b605
movq -0x18(%rbp), %rax
leaq 0x12dbd(%rip), %rcx     # 0xae334
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x12bec(%rip), %rax     # 0xae173
movq %rax, -0x8(%rbp)
jmp 0x9b610
leaq 0x12c39(%rip), %rax     # 0xae1d0
movq %rax, -0x8(%rbp)
jmp 0x9b610
leaq 0x12c17(%rip), %rax     # 0xae1bb
movq %rax, -0x8(%rbp)
jmp 0x9b610
leaq 0x12c19(%rip), %rax     # 0xae1ca
movq %rax, -0x8(%rbp)
jmp 0x9b610
leaq 0x12e70(%rip), %rax     # 0xae42e
movq %rax, -0x8(%rbp)
jmp 0x9b610
leaq 0x12e77(%rip), %rax     # 0xae442
movq %rax, -0x8(%rbp)
jmp 0x9b610
leaq 0x113ec(%rip), %rax     # 0xac9c4
movq %rax, -0x8(%rbp)
jmp 0x9b610
leaq 0x10ab7(%rip), %rax     # 0xac09c
movq %rax, -0x8(%rbp)
jmp 0x9b610
leaq 0x10ace(%rip), %rax     # 0xac0c0
movq %rax, -0x8(%rbp)
jmp 0x9b610
leaq 0x12b43(%rip), %rax     # 0xae142
movq %rax, -0x8(%rbp)
jmp 0x9b610
leaq 0x10a82(%rip), %rax     # 0xac08e
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x9e330
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9b9cb
jmp 0x9ba2f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x9e330
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9b9ea
jmp 0x9ba2f
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
movl -0x38(%rbp), %edx
movq -0x30(%rbp), %rcx
callq *%rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9ba1c
jmp 0x9ba2f
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9ba49
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq -0x18(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_logical_str
static subtilis_arm_exp_val_t *prv_logical_str(subtilis_arm_ass_context_t *c,
					       subtilis_arm_exp_val_t *e1,
					       subtilis_arm_exp_val_t *e2,
					       subtilis_ass_log_str_fn_t fn,
					       subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *e;
	const char *str1 = subtilis_buffer_get_string(&e1->val.buf);
	const char *str2 = subtilis_buffer_get_string(&e2->val.buf);

	e = subtilis_arm_exp_new_int32(fn(str1, str2), err);
	subtilis_arm_exp_val_free(e1);
	subtilis_arm_exp_val_free(e2);
	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x16760
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x16760
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq *%rax
movl %eax, %edi
movq -0x28(%rbp), %rsi
callq 0x9a300
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9a4c0
movq -0x18(%rbp), %rdi
callq 0x9a4c0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_logical_numeric
static subtilis_arm_exp_val_t *
prv_logical_numeric(subtilis_arm_ass_context_t *c, subtilis_arm_exp_val_t *e1,
		    subtilis_arm_exp_val_t *e2,
		    subtilis_ass_log_int_fn_t int_fn,
		    subtilis_ass_log_real_fn_t rfn, subtilis_error_t *err)
{
	if ((e1->type == SUBTILIS_ARM_EXP_TYPE_INT) &&
	    (e2->type == SUBTILIS_ARM_EXP_TYPE_INT)) {
		return prv_logical_int(c, e1, e2, int_fn, err);
	}

	return prv_logical_real(c, e1, e2, rfn, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x9c151
movq -0x20(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x9c151
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x9ea40
movq %rax, -0x8(%rbp)
jmp 0x9c16e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x9eaf0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_strcat
static subtilis_arm_exp_val_t *prv_strcat(subtilis_arm_exp_val_t *e1,
					  subtilis_arm_exp_val_t *e2,
					  subtilis_error_t *err)

{
	subtilis_buffer_remove_terminator(&e1->val.buf);
	subtilis_buffer_append_buffer(&e1->val.buf, &e2->val.buf, err);
	subtilis_arm_exp_val_free(e2);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_arm_exp_val_free(e1);
		return NULL;
	}

	return e1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x165d0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
callq 0x162b0
movq -0x18(%rbp), %rdi
callq 0x9a4c0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9c4cf
movq -0x10(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
jmp 0x9c4d7
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_binary_numeric
static subtilis_arm_exp_val_t *
prv_binary_numeric(subtilis_arm_ass_context_t *c, subtilis_arm_exp_val_t *e1,
		   subtilis_arm_exp_val_t *e2, subtilis_ass_int_fn_t int_fn,
		   subtilis_ass_real_fn_t real_fn, subtilis_error_t *err)
{
	if ((e1->type == SUBTILIS_ARM_EXP_TYPE_INT) &&
	    (e2->type == SUBTILIS_ARM_EXP_TYPE_INT)) {
		return prv_binary_int(c, e1, e2, int_fn, err);
	}

	return prv_binary_real(c, e1, e2, real_fn, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x9c541
movq -0x20(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x9c541
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x9b990
movq %rax, -0x8(%rbp)
jmp 0x9c55e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x9c800
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9c950
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9c5af
jmp 0x9c6a8
jmp 0x9c5b1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
jne 0x9c69e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12d70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0xe33b(%rip), %rsi      # 0xaa919
callq 0x12140
cmpl $0x0, %eax
je 0x9c5ed
jmp 0x9c69e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x133f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9c614
jmp 0x9c6a8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9c950
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9c630
jmp 0x9c6a8
movq -0x30(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x9c65f
movq -0x30(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0x9c65f
movq -0x30(%rbp), %rax
cvtsi2sdl 0x8(%rax), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x30(%rbp), %rax
movl $0x7, (%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %r9
leaq 0x84a(%rip), %rcx       # 0x9cec0
leaq 0x8a3(%rip), %r8        # 0x9cf20
callq 0x9c4f0
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9c699
jmp 0x9c6a8
jmp 0x9c5b1
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9c6c2
movq -0x30(%rbp), %rdi
callq 0x9a4c0
movq -0x28(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x9c727
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %ecx
movl $0x1a, %esi
leaq 0x11ced(%rip), %r8      # 0xae400
movl $0x679, %r9d            # imm = 0x679
callq 0x15930
movl $0x0, -0x4(%rbp)
jmp 0x9c731
movl -0x14(%rbp), %eax
cltd
idivl -0x18(%rbp)
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x9e9a0
movsd %xmm0, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9c83d
jmp 0x9c8a7
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x9e9a0
movsd %xmm0, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9c85e
jmp 0x9c8a7
movq -0x18(%rbp), %rax
movl $0x7, (%rax)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
movq -0x30(%rbp), %rsi
callq *%rax
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9c894
jmp 0x9c8a7
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9c8c1
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq -0x18(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x9c936
jp 0x9c936
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %ecx
movl $0x1a, %esi
leaq 0x11adf(%rip), %r8      # 0xae400
movl $0x667, %r9d            # imm = 0x667
callq 0x15930
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x9c945
movsd -0x18(%rbp), %xmm0
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x9cee1
movl $0x1, -0x4(%rbp)
jmp 0x9cf1a
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq $0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jae 0x9cf14
movl -0x14(%rbp), %eax
imull -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x9ceef
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9b4f0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9cfb7
movq $0x0, -0x8(%rbp)
jmp 0x9d049
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12d70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
jne 0x9cfea
movq -0x20(%rbp), %rdi
leaq 0xdb71(%rip), %rsi      # 0xaab51
callq 0x12140
cmpl $0x0, %eax
je 0x9d041
movq -0x28(%rbp), %rdi
callq 0x9a4c0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x16, %esi
leaq 0xe257(%rip), %rcx      # 0xab276
leaq 0x113da(%rip), %rax     # 0xae400
movq %rax, (%rsp)
movl $0x2ae, 0x8(%rsp)       # imm = 0x2AE
callq 0x156d0
movq $0x0, -0x8(%rbp)
jmp 0x9d049
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_unary_minus_exp
static subtilis_arm_exp_val_t *
prv_unary_minus_exp(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;

	if (e->type == SUBTILIS_ARM_EXP_TYPE_REAL)
		e->val.real = -e->val.real;
	else if (e->type == SUBTILIS_ARM_EXP_TYPE_INT)
		e->val.integer = -e->val.integer;
	else
		subtilis_error_set_numeric_exp_expected(err, c->l->stream->name,
							c->l->line);

	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x133f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d09f
movq $0x0, -0x8(%rbp)
jmp 0x9d151
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9c950
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d0c6
movq $0x0, -0x8(%rbp)
jmp 0x9d151
movq -0x20(%rbp), %rax
cmpl $0x7, (%rax)
jne 0x9d0fa
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x9d149
movq -0x20(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x9d115
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
subl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x9d147
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %ecx
movl $0x44, %esi
leaq 0x112c4(%rip), %r8      # 0xae400
movl $0x2c8, %r9d            # imm = 0x2C8
callq 0x15930
jmp 0x9d149
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x133f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d19c
movq $0x0, -0x8(%rbp)
jmp 0x9d20b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9c950
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d1c0
movq $0x0, -0x8(%rbp)
jmp 0x9d20b
movq -0x20(%rbp), %rax
movl $0x6, (%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x9e330
movl %eax, %ecx
xorl $-0x1, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d203
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
jmp 0x9d20b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: prv_int
static subtilis_arm_exp_val_t *prv_int(subtilis_arm_ass_context_t *c,
				       subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;

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

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

	return val;

cleanup:

	subtilis_arm_exp_val_free(val);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9e3c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9d257
movq $0x0, -0x8(%rbp)
jmp 0x9d305
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x2, %eax
jb 0x9d299
jmp 0x9d267
movl -0x24(%rbp), %eax
subl $0x6, %eax
je 0x9d27b
jmp 0x9d271
movl -0x24(%rbp), %eax
subl $0x7, %eax
je 0x9d27d
jmp 0x9d2b6
jmp 0x9d2ea
movq -0x20(%rbp), %rax
movl $0x6, (%rax)
movq -0x20(%rbp), %rax
cvttsd2si 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x9d2ea
movq -0x20(%rbp), %rax
movl $0x6, (%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x9d2ea
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %ecx
movl $0x44, %esi
leaq 0x11123(%rip), %r8      # 0xae400
movl $0x35b, %r9d            # imm = 0x35B
callq 0x15930
jmp 0x9d2f4
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9d305
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop