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

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

	if (val->type != SUBTILIS_ARM_EXP_TYPE_DREG) {
		subtilis_error_set_expected(err, "vfp D register",
					    subtilis_arm_exp_type_name(val),
					    c->l->stream->name, c->l->line);
		reg = SIZE_MAX;
	} else {
		reg = val->val.reg;
	}

	subtilis_arm_exp_val_free(val);

	return reg;
}

// 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, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x964a7
movq $-0x1, -0x8(%rbp)
jmp 0x9652b
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
je 0x9650e
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9b550
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x17cde(%rip), %rdx     # 0xae1ca
leaq 0x17c2d(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x250, 0x8(%rsp)       # imm = 0x250
callq 0x156d0
movq $-0x1, -0x28(%rbp)
jmp 0x9651a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9a4c0
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/assembler.c
// Function: prv_get_data_reg
static subtilis_arm_reg_t prv_get_data_reg(subtilis_arm_ass_context_t *c,
					   subtilis_arm_instr_type_t itype,
					   subtilis_error_t *err)
{
	switch (itype) {
	case SUBTILIS_VFP_INSTR_FMACS:
	case SUBTILIS_VFP_INSTR_FNMACS:
	case SUBTILIS_VFP_INSTR_FMSCS:
	case SUBTILIS_VFP_INSTR_FNMSCS:
	case SUBTILIS_VFP_INSTR_FMULS:
	case SUBTILIS_VFP_INSTR_FNMULS:
	case SUBTILIS_VFP_INSTR_FADDS:
	case SUBTILIS_VFP_INSTR_FSUBS:
	case SUBTILIS_VFP_INSTR_FDIVS:
		return prv_get_vfp_sreg(c, err);
	default:
		return prv_get_vfp_dreg(c, err);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x5f, %eax
je 0x965b0
jmp 0x96560
movl -0x24(%rbp), %eax
subl $0x61, %eax
je 0x965b0
jmp 0x9656a
movl -0x24(%rbp), %eax
subl $0x63, %eax
je 0x965b0
jmp 0x96574
movl -0x24(%rbp), %eax
subl $0x65, %eax
je 0x965b0
jmp 0x9657e
movl -0x24(%rbp), %eax
subl $0x67, %eax
je 0x965b0
jmp 0x96588
movl -0x24(%rbp), %eax
subl $0x69, %eax
je 0x965b0
jmp 0x96592
movl -0x24(%rbp), %eax
subl $0x6b, %eax
je 0x965b0
jmp 0x9659c
movl -0x24(%rbp), %eax
subl $0x6d, %eax
je 0x965b0
jmp 0x965a6
movl -0x24(%rbp), %eax
subl $0x6f, %eax
jne 0x965c3
jmp 0x965b0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x963a0
movq %rax, -0x8(%rbp)
jmp 0x965d4
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x96470
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_get_vfp_sysreg
static subtilis_arm_reg_t prv_get_vfp_sysreg(subtilis_arm_ass_context_t *c,
					     subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;
	subtilis_arm_reg_t reg;

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

	if (val->type != SUBTILIS_ARM_EXP_TYPE_SYSREG) {
		subtilis_error_set_expected(err, "FPSCR or FPEXC or FPSID",
					    subtilis_arm_exp_type_name(val),
					    c->l->stream->name, c->l->line);
		reg = SIZE_MAX;
	} else {
		reg = val->val.reg;
	}

	subtilis_arm_exp_val_free(val);

	return reg;
}

// 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, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x96617
movq $-0x1, -0x8(%rbp)
jmp 0x9669b
movq -0x20(%rbp), %rax
cmpl $0x4, (%rax)
je 0x9667e
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9b550
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x17b7d(%rip), %rdx     # 0xae1d9
leaq 0x17abd(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x268, 0x8(%rsp)       # imm = 0x268
callq 0x156d0
movq $-0x1, -0x28(%rbp)
jmp 0x9668a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9a4c0
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/assembler.c
// Function: prv_parse_arm_2_arg
static void prv_parse_arm_2_arg(subtilis_arm_ass_context_t *c,
				subtilis_arm_instr_type_t itype,
				subtilis_arm_ccode_type_t ccode, bool status,
				subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_op2_t op2;
	const char *tbuf;
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *datai;

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

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

	prv_get_op2(c, &op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

	datai = &instr->operands.data;
	datai->ccode = ccode;
	datai->dest = dest;
	datai->op1 = dest;
	datai->op2 = op2;
	datai->status = status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x94690
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x96c7f
jmp 0x96d89
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12d70
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
jne 0x96cb2
movq -0x58(%rbp), %rdi
leaq 0x13901(%rip), %rsi     # 0xaa5a9
callq 0x12140
cmpl $0x0, %eax
je 0x96cfb
movq -0x20(%rbp), %rdi
movq -0x58(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x138cb(%rip), %rdx     # 0xaa5a9
leaq 0x1743b(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x388, 0x8(%rsp)       # imm = 0x388
callq 0x156d0
jmp 0x96d89
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x50(%rbp), %rsi
callq 0x987a0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x96d17
jmp 0x96d89
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x70b50
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x96d39
jmp 0x96d89
movq -0x60(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x68(%rbp)
movl -0x10(%rbp), %ecx
movq -0x68(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x68(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x68(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
leaq -0x50(%rbp), %rsi
movl $0x28, %edx
callq 0x12190
movb -0x11(%rbp), %cl
movq -0x68(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x4(%rax)
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_cmp
static void prv_parse_cmp(subtilis_arm_ass_context_t *c,
			  subtilis_arm_instr_type_t itype,
			  subtilis_arm_ccode_type_t ccode, bool status,
			  bool teqp, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_op2_t op2;
	const char *tbuf;
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *datai;

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

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

	prv_get_op2(c, &op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

	datai = &instr->operands.data;
	datai->ccode = ccode;
	if (teqp)
		datai->dest = 15;
	else
		datai->dest = 0;
	datai->op1 = dest;
	datai->op2 = op2;
	datai->status = status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq %r9, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x94690
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x97346
jmp 0x97467
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12d70
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
je 0x973c2
movq -0x58(%rbp), %rdi
leaq 0x1323a(%rip), %rsi     # 0xaa5a9
callq 0x12140
cmpl $0x0, %eax
je 0x973c2
movq -0x20(%rbp), %rdi
movq -0x58(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x13204(%rip), %rdx     # 0xaa5a9
leaq 0x16d74(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x3ae, 0x8(%rsp)       # imm = 0x3AE
callq 0x156d0
jmp 0x97467
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x50(%rbp), %rsi
callq 0x987a0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x973e1
jmp 0x97467
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x70b50
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x97403
jmp 0x97467
movq -0x60(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x68(%rbp)
movl -0x10(%rbp), %ecx
movq -0x68(%rbp), %rax
movl %ecx, (%rax)
testb $0x1, -0x12(%rbp)
je 0x9742c
movq -0x68(%rbp), %rax
movq $0xf, 0x8(%rax)
jmp 0x97438
movq -0x68(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x68(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
leaq -0x50(%rbp), %rsi
movl $0x28, %edx
callq 0x12190
movb -0x11(%rbp), %cl
movq -0x68(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x4(%rax)
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_swi
static void prv_parse_swi(subtilis_arm_ass_context_t *c,
			  subtilis_arm_ccode_type_t ccode,
			  subtilis_error_t *err)
{
	const char *swi_name;
	subtilis_arm_exp_val_t *val;
	size_t code;

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

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

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

cleanup:

	subtilis_arm_exp_val_free(val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9b4f0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x974a2
jmp 0x975b5
movq -0x28(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x974bc
movq -0x28(%rbp), %rax
movslq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x9758f
movq -0x28(%rbp), %rax
cmpl $0x8, (%rax)
jne 0x97537
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x16760
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
jne 0x97535
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x5a, %esi
leaq 0x13d5b(%rip), %rcx     # 0xab276
leaq 0x16bfe(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x3d8, 0x8(%rsp)       # imm = 0x3D8
callq 0x156d0
jmp 0x975ac
jmp 0x9758d
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x9b550
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x16cb8(%rip), %rdx     # 0xae22b
leaq 0x16ba6(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x3de, 0x8(%rsp)       # imm = 0x3DE
callq 0x156d0
jmp 0x975ac
jmp 0x9758f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %r9
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x71f20
movq -0x28(%rbp), %rdi
callq 0x9a4c0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_mrs
static void prv_parse_mrs(subtilis_arm_ass_context_t *c,
			  subtilis_arm_ccode_type_t ccode,
			  subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op1;
	const char *tbuf;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x94690
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x98052
jmp 0x98110
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12d70
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
jne 0x98085
movq -0x30(%rbp), %rdi
leaq 0x1252e(%rip), %rsi     # 0xaa5a9
callq 0x12140
cmpl $0x0, %eax
je 0x980cb
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x124f8(%rip), %rdx     # 0xaa5a9
leaq 0x16068(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x742, 0x8(%rsp)       # imm = 0x742
callq 0x156d0
jmp 0x98110
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9a0e0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x980e7
jmp 0x98110
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %edx
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %r9
movq -0x18(%rbp), %rax
movl $0x1d, %esi
xorl %r8d, %r8d
movq %rax, (%rsp)
callq 0x72ca0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_stran_misc_zero
static void prv_stran_misc_zero(subtilis_arm_ass_context_t *c,
				subtilis_arm_instr_type_t itype,
				subtilis_arm_ccode_type_t ccode,
				subtilis_arm_reg_t dest,
				const subtilis_arm_ass_modifiers_t *modifiers,
				subtilis_arm_reg_t base, subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_arm_instr_t *instr;
	subtilis_arm_stran_misc_instr_t *stran_misc;
	bool write_back = false;

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

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

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

	stran_misc = &instr->operands.stran_misc;

	prv_stran_misc_set_type(stran_misc, modifiers, err);
	if (err->type)
		return;

	stran_misc->ccode = ccode;
	stran_misc->dest = dest;
	stran_misc->base = base;
	stran_misc->reg_offset = false;
	stran_misc->offset.imm = 0;
	stran_misc->pre_indexed = true;
	stran_misc->write_back = write_back;
	stran_misc->subtract = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movb $0x0, -0x41(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12d70
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
jne 0x99346
movq -0x30(%rbp), %rdi
leaq 0x111dc(%rip), %rsi     # 0xaa4eb
callq 0x12140
cmpl $0x0, %eax
jne 0x99346
movb $0x1, -0x41(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0x10(%rbp), %rdx
callq 0x133f0
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x99344
jmp 0x993df
jmp 0x99346
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq 0x10(%rbp), %rdx
callq 0x70b50
movq %rax, -0x38(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x99368
jmp 0x993df
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq 0x10(%rbp), %rdx
callq 0x99990
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x99390
jmp 0x993df
movl -0x10(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
movb $0x0, 0x18(%rax)
movq -0x40(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x40(%rbp), %rax
movb $0x1, 0x28(%rax)
movb -0x41(%rbp), %cl
movq -0x40(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x29(%rax)
movq -0x40(%rbp), %rax
movb $0x0, 0x2a(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_stran_pre_off
static void prv_parse_stran_pre_off(subtilis_arm_ass_context_t *c,
				    subtilis_arm_instr_type_t itype,
				    subtilis_arm_ccode_type_t ccode,
				    subtilis_arm_reg_t dest,
				    subtilis_arm_reg_t base, bool byte,
				    subtilis_arm_op2_t offset, bool subtract,
				    subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_arm_instr_t *instr;
	subtilis_arm_stran_instr_t *stran;
	bool write_back = false;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %r9d, %eax
movq %rcx, -0x60(%rbp)
movl %edx, %ecx
movq -0x60(%rbp), %rdx
movl %ecx, -0x58(%rbp)
movl %esi, %ecx
movl -0x58(%rbp), %esi
movl %ecx, -0x54(%rbp)
movq %rdi, %r9
movl -0x54(%rbp), %edi
movb %al, %cl
movq 0x40(%rbp), %rax
movb 0x38(%rbp), %al
leaq 0x10(%rbp), %r10
movq %r10, -0x50(%rbp)
movq %r9, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
andb $0x1, %cl
movb %cl, -0x21(%rbp)
andb $0x1, %al
movb %al, -0x22(%rbp)
movb $0x0, -0x41(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12d70
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
jne 0x994a8
movq -0x30(%rbp), %rdi
leaq 0x1107a(%rip), %rsi     # 0xaa4eb
callq 0x12140
cmpl $0x0, %eax
jne 0x994a8
movb $0x1, -0x41(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0x40(%rbp), %rdx
callq 0x133f0
movq 0x40(%rbp), %rax
cmpl $0x0, (%rax)
je 0x994a6
jmp 0x9953c
jmp 0x994a8
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq 0x40(%rbp), %rdx
callq 0x70b50
movq %rax, -0x38(%rbp)
movq 0x40(%rbp), %rax
cmpl $0x0, (%rax)
je 0x994ca
jmp 0x9953c
movq -0x50(%rbp), %rsi
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movl -0x10(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movl $0x28, %edx
callq 0x12190
movq -0x40(%rbp), %rax
movb $0x1, 0x40(%rax)
movb -0x41(%rbp), %cl
movq -0x40(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x41(%rax)
movb -0x21(%rbp), %cl
movq -0x40(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x43(%rax)
movb -0x22(%rbp), %cl
movq -0x40(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x42(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
jne 0x99603
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12d70
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x10f4b(%rip), %rsi     # 0xaa4dc
callq 0x12140
cmpl $0x0, %eax
je 0x995e9
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x14c86(%rip), %rdx     # 0xae24d
leaq 0x14b52(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x41c, 0x8(%rsp)       # imm = 0x41C
callq 0x156d0
movq $0x0, -0x8(%rbp)
jmp 0x99614
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9b4f0
movq %rax, -0x8(%rbp)
jmp 0x99614
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9b220
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/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:
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 -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0x99809
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
subl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x99817
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpl $0xfff, 0x8(%rax)       # imm = 0xFFF
jbe 0x99866
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x5b, %esi
xorl %ecx, %ecx
leaq 0x148cb(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x433, 0x8(%rsp)       # imm = 0x433
callq 0x157b0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x99ae0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x998c6
jmp 0x99988
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9b4f0
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x998e5
jmp 0x99988
movq -0x10(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x99906
movq -0x18(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
jmp 0x9997f
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x99929
movq -0x18(%rbp), %rax
movb $0x1, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x9997d
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9b550
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x148b2(%rip), %rdx     # 0xae217
leaq 0x147b4(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x44d, 0x8(%rsp)       # imm = 0x44D
callq 0x156d0
jmp 0x9997f
movq -0x10(%rbp), %rdi
callq 0x9a4c0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x1(%rax)
je 0x999c3
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0x999c3
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
jmp 0x99a22
movq -0x10(%rbp), %rax
testb $0x1, 0x3(%rax)
je 0x999ee
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0x999e2
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
jmp 0x999ec
movq -0x8(%rbp), %rax
movl $0x2, (%rax)
jmp 0x99a20
movq -0x10(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x99a04
movq -0x8(%rbp), %rax
movl $0x3, (%rax)
jmp 0x99a1e
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x1470c(%rip), %rdx     # 0xae120
movl $0x49a, %ecx            # imm = 0x49A
callq 0x158e0
jmp 0x99a20
jmp 0x99a22
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
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), %rax
cmpl $0x0, 0x8(%rax)
jge 0x99a6b
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subl 0x8(%rcx), %eax
movl %eax, -0x2c(%rbp)
jmp 0x99a75
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0xff, -0x2c(%rbp)
jle 0x99ac0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x5b, %esi
xorl %ecx, %ecx
leaq 0x14671(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x487, 0x8(%rsp)       # imm = 0x487
callq 0x157b0
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_get_st_shift
static subtilis_arm_shift_type_t prv_get_st_shift(subtilis_arm_ass_context_t *c,
						  subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_arm_shift_type_t st = SUBTILIS_ARM_SHIFT_ASR;

	tbuf = subtilis_token_get_text(c->t);
	subtilis_lexer_get(c->l, c->t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return st;
	if (c->t->type != SUBTILIS_TOKEN_KEYWORD) {
		subtilis_error_set_keyword_expected(
		    err, tbuf, c->l->stream->name, c->l->line);
		return st;
	}

	switch (c->t->tok.keyword.type) {
	case SUBTILIS_ARM_KEYWORD_ASR:
		st = SUBTILIS_ARM_SHIFT_ASR;
		break;
	case SUBTILIS_ARM_KEYWORD_LSL:
		st = SUBTILIS_ARM_SHIFT_LSL;
		break;
	case SUBTILIS_ARM_KEYWORD_LSR:
		st = SUBTILIS_ARM_SHIFT_LSR;
		break;
	case SUBTILIS_ARM_KEYWORD_ROR:
		st = SUBTILIS_ARM_SHIFT_ROR;
		break;
	case SUBTILIS_ARM_KEYWORD_RRX:
		st = SUBTILIS_ARM_SHIFT_RRX;
		break;
	default:
		subtilis_error_set_expected(err, "shift keyword", tbuf,
					    c->l->stream->name, c->l->line);
	}

	return st;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x3, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12d70
movq %rax, -0x20(%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 0x99b35
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x99c35
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x1, (%rax)
je 0x99b91
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 $0x10, %esi
leaq 0x11708(%rip), %rcx     # 0xab276
leaq 0x145ab(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x3f5, 0x8(%rsp)       # imm = 0x3F5
callq 0x156d0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x99c35
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x8(%rax), %eax
addl $-0x27, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x4, %eax
ja 0x99beb
movq -0x30(%rbp), %rax
leaq 0x14557(%rip), %rcx     # 0xae10c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, -0x24(%rbp)
jmp 0x99c2f
movl $0x0, -0x24(%rbp)
jmp 0x99c2f
movl $0x2, -0x24(%rbp)
jmp 0x99c2f
movl $0x4, -0x24(%rbp)
jmp 0x99c2f
movl $0x5, -0x24(%rbp)
jmp 0x99c2f
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x1464d(%rip), %rdx     # 0xae264
leaq 0x14502(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x40b, 0x8(%rsp)       # imm = 0x40B
callq 0x156d0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %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 0x99f3f
movq $-0x1, -0x8(%rbp)
jmp 0x9a004
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12d70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x9a9d0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x99f7b
movq $-0x1, -0x8(%rbp)
jmp 0x9a004
cmpq $-0x1, -0x28(%rbp)
jne 0x99fd0
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 $0x58, %esi
leaq 0x112c8(%rip), %rcx     # 0xab276
leaq 0x1416b(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x2b6, 0x8(%rsp)       # imm = 0x2B6
callq 0x156d0
movq $-0x1, -0x8(%rbp)
jmp 0x9a004
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 0x99ffc
movq $-0x1, -0x8(%rbp)
jmp 0x9a004
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/assembler.c
// Function: prv_parse_mtran_range
static void prv_parse_mtran_range(subtilis_arm_ass_context_t *c, size_t reg1,
				  size_t *reg_list, subtilis_error_t *err)
{
	subtilis_arm_reg_t reg2;
	size_t i;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x99f00
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9a047
jmp 0x9a0d6
movq -0x10(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x9a098
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %edx
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x5c, %esi
leaq 0x1409b(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x64e, 0x8(%rsp)       # imm = 0x64E
callq 0x157b0
jmp 0x9a0d6
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0x9a0d6
movq -0x30(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rcx
movq -0x18(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x9a0a4
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_get_src_flagsreg
static subtilis_arm_reg_t prv_get_src_flagsreg(subtilis_arm_ass_context_t *c,
					       subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;
	subtilis_arm_reg_t reg;

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

	if (val->type != SUBTILIS_ARM_EXP_TYPE_FLAGS_REG ||
	    val->val.reg > SUBTILIS_ARM_EXP_SPSR_REG) {
		subtilis_error_set_expected(err, "CPSR or SPSR",
					    subtilis_arm_exp_type_name(val),
					    c->l->stream->name, c->l->line);
		reg = SIZE_MAX;
	} else {
		reg = val->val.reg;
	}

	subtilis_arm_exp_val_free(val);

	return reg;
}

// 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, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9a117
movq $-0x1, -0x8(%rbp)
jmp 0x9a1a6
movq -0x20(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x9a12b
movq -0x20(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jbe 0x9a189
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9b550
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x14115(%rip), %rdx     # 0xae27c
leaq 0x13fb2(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x29a, 0x8(%rsp)       # imm = 0x29A
callq 0x156d0
movq $-0x1, -0x28(%rbp)
jmp 0x9a195
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9a4c0
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/assembler.c
// Function: prv_get_dest_flagsreg
static subtilis_arm_reg_t prv_get_dest_flagsreg(subtilis_arm_ass_context_t *c,
						subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;
	subtilis_arm_reg_t reg;

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

	if (val->type != SUBTILIS_ARM_EXP_TYPE_FLAGS_REG ||
	    val->val.reg <= SUBTILIS_ARM_EXP_SPSR_REG) {
		subtilis_error_set_expected(err, "CPSR_[cxfs] or SPSR_[cxfs]",
					    subtilis_arm_exp_type_name(val),
					    c->l->stream->name, c->l->line);
		reg = SIZE_MAX;
	} else {
		reg = val->val.reg;
	}

	subtilis_arm_exp_val_free(val);

	return reg;
}

// 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, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9a1e7
movq $-0x1, -0x8(%rbp)
jmp 0x9a276
movq -0x20(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x9a1fb
movq -0x20(%rbp), %rax
cmpq $0x1, 0x8(%rax)
ja 0x9a259
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9b550
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x14052(%rip), %rdx     # 0xae289
leaq 0x13ee2(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x281, 0x8(%rsp)       # imm = 0x281
callq 0x156d0
movq $-0x1, -0x28(%rbp)
jmp 0x9a265
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9a4c0
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/assembler.c
// Function: prv_free_defs
static void prv_free_defs(subtilis_arm_ass_context_t *c)
{
	size_t i;

	for (i = 0; i < c->def_count; i++) {
		free(c->defs[i].name);
		subtilis_arm_exp_val_free(c->defs[i].val);
	}
	free(c->defs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x58(%rcx), %rax
jae 0x9a2e7
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x9a4c0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x9a294
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x12290
addq $0x10, %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_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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x18, %edi
callq 0x121b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9a348
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x140cc(%rip), %rdx     # 0xae400
movl $0x32, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x9a364
movq -0x20(%rbp), %rax
movl $0x6, (%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl $0x18, %edi
callq 0x121b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9a3ba
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x1405a(%rip), %rdx     # 0xae400
movl $0x41, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x9a3da
movq -0x20(%rbp), %rax
movl $0x7, (%rax)
movsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
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: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x18, %edi
callq 0x121b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9a439
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x13fdb(%rip), %rdx     # 0xae400
movl $0x51, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x9a4b4
movq -0x20(%rbp), %rax
movl $0x8, (%rax)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x120d0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x15f80
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x16310
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9a488
jmp 0x9a4a3
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x16560
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9a4b4
movq -0x20(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_expression.c
// Function: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x9a4d5
jmp 0x9a4fd
movq -0x8(%rbp), %rax
cmpl $0x8, (%rax)
je 0x9a4e7
movq -0x8(%rbp), %rax
cmpl $0x9, (%rax)
jne 0x9a4f4
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x16650
movq -0x8(%rbp), %rdi
callq 0x12290
addq $0x10, %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_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 %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 0x9a559
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x13ebb(%rip), %rdx     # 0xae400
movl $0x6c, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x9a5c6
movq -0x28(%rbp), %rax
movl $0x8, (%rax)
movq -0x10(%rbp), %rdi
callq 0x16270
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), %rax
movq 0x8(%rax), %rsi
addq $0x18, %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x16200
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9a5be
movq -0x28(%rbp), %rdi
callq 0x9a4c0
movq $0x0, -0x8(%rbp)
jmp 0x9a5c6
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq