LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_context_free
static void prv_context_free(subtilis_arm_ass_context_t *c)
{
	size_t i;

	prv_free_defs(c);
	subtilis_bitset_free(&c->pending_labels);
	subtilis_string_pool_delete(c->label_pool);

	for (i = 0; i < c->num_blocks; i++)
		subtilis_arm_exp_val_free(c->blocks[i].upto);
	free(c->blocks);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9a280
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
callq 0x89020
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3d790
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x70(%rcx), %rax
jae 0x9152f
movq -0x8(%rbp), %rax
movq 0x68(%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 0x914f7
movq -0x8(%rbp), %rax
movq 0x68(%rax), %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/assembler.c
// Function: subtilis_arm_asm_find_def
subtilis_arm_exp_val_t *subtilis_arm_asm_find_def(subtilis_arm_ass_context_t *c,
						  const char *name)
{
	size_t i;

	for (i = 0; i < c->def_count; i++)
		if (!strcmp(c->defs[i].name, name))
			return c->defs[i].val;

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x58(%rcx), %rax
jae 0x915c7
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x12140
cmpl $0x0, %eax
jne 0x915b7
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x915cf
jmp 0x915b9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x91568
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_keyword
static void prv_parse_keyword(subtilis_arm_ass_context_t *c, const char *name,
			      const subtilis_token_keyword_t *keyword,
			      subtilis_error_t *err)
{
	switch (keyword->type) {
	/*
	 * We can't call functions or procedures inside a block of
	 * assembler. So we'll just treat these as identifiers.
	 */
	case SUBTILIS_KEYWORD_FN:
	case SUBTILIS_KEYWORD_PROC:
	case SUBTILIS_KEYWORD_REC:
		prv_parse_identifier(c, err);
		break;
	case SUBTILIS_ARM_KEYWORD_ALIGN:
		prv_parse_align(c, err);
		break;
	case SUBTILIS_ARM_KEYWORD_DEF:
		prv_parse_def(c, err);
		break;
	case SUBTILIS_ARM_KEYWORD_EQUB:
		prv_parse_equb(c, err);
		break;
	case SUBTILIS_ARM_KEYWORD_EQUD:
		prv_parse_equd(c, err);
		break;
	case SUBTILIS_ARM_KEYWORD_EQUDBL:
		prv_parse_equdbl(c, err);
		break;
	case SUBTILIS_ARM_KEYWORD_EQUF:
		prv_parse_equf(c, err);
		break;
	case SUBTILIS_ARM_KEYWORD_EQUDBLR:
		prv_parse_equdblr(c, err);
		break;
	case SUBTILIS_ARM_KEYWORD_EQUS:
		prv_parse_equs(c, err);
		break;
	case SUBTILIS_ARM_KEYWORD_EQUW:
		prv_parse_equw(c, err);
		break;
	case SUBTILIS_ARM_KEYWORD_FOR:
		prv_parse_for(c, err);
		break;
	case SUBTILIS_ARM_KEYWORD_NEXT:
		prv_parse_next(c, err);
		break;
	default:
		subtilis_error_set_ass_keyword_bad_use(
		    err, name, c->l->stream->name, c->l->line);
		break;
	}
}

// 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 -0x18(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x33, %rax
ja 0x916ec
movq -0x28(%rbp), %rax
leaq 0x1c539(%rip), %rcx     # 0xadb50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x91740
jmp 0x91730
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x91df0
jmp 0x91730
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x91f30
jmp 0x91730
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x922a0
jmp 0x91730
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x92340
jmp 0x91730
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x923e0
jmp 0x91730
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x92470
jmp 0x91730
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x92500
jmp 0x91730
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x92590
jmp 0x91730
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x92660
jmp 0x91730
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x92700
jmp 0x91730
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x92b30
jmp 0x91730
movq -0x20(%rbp), %rdi
movq -0x10(%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 $0x5e, %esi
leaq 0x19b5e(%rip), %rcx     # 0xab276
leaq 0x1ca01(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x109c, 0x8(%rsp)      # imm = 0x109C
callq 0x156d0
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_align
static void prv_parse_align(subtilis_arm_ass_context_t *c,
			    subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;
	int32_t align;

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

	if (val->type == SUBTILIS_ARM_EXP_TYPE_INT) {
		align = val->val.integer;
	} else if (val->type == SUBTILIS_ARM_EXP_TYPE_REAL) {
		align = (int32_t)val->val.real;
	} else {
		subtilis_error_set_numeric_expected(
		    err, subtilis_arm_exp_type_name(val), c->l->stream->name,
		    c->l->line);
		goto cleanup;
	}

	if (align <= 0 || ((align - 1) & align) != 0 || align > 1024) {
		subtilis_error_set_ass_bad_align(err, align, c->l->stream->name,
						 c->l->line);
		goto cleanup;
	}

	subtilis_arm_add_align(c->arm_s, (uint32_t)align, err);

cleanup:

	subtilis_arm_exp_val_free(val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9b4f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x91e1f
jmp 0x91f1c
movq -0x18(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x91e34
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x91ea3
movq -0x18(%rbp), %rax
cmpl $0x7, (%rax)
jne 0x91e4b
movq -0x18(%rbp), %rax
cvttsd2si 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x91ea1
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9b550
movq -0x28(%rbp), %rdi
movq %rax, %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 $0x2c, %esi
leaq 0x193ef(%rip), %rcx     # 0xab276
leaq 0x1c292(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0xf6f, 0x8(%rsp)       # imm = 0xF6F
callq 0x156d0
jmp 0x91f13
jmp 0x91ea3
cmpl $0x0, -0x1c(%rbp)
jle 0x91ec0
movl -0x1c(%rbp), %eax
subl $0x1, %eax
andl -0x1c(%rbp), %eax
cmpl $0x0, %eax
jne 0x91ec0
cmpl $0x400, -0x1c(%rbp)     # imm = 0x400
jle 0x91f00
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %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 $0x62, %esi
xorl %ecx, %ecx
leaq 0x1c233(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0xf75, 0x8(%rsp)       # imm = 0xF75
callq 0x157b0
jmp 0x91f13
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x72af0
movq -0x18(%rbp), %rdi
callq 0x9a4c0
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_equb
static void prv_parse_equb(subtilis_arm_ass_context_t *c, subtilis_error_t *err)
{
	int32_t *nums;
	size_t i;
	size_t num_count = 0;

	nums = prv_get_uint32_list(c, &num_count, prv_check_equb, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	for (i = 0; i < num_count; i++) {
		subtilis_arm_add_byte(c->arm_s, (uint8_t)nums[i], err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

cleanup:

	free(nums);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq -0x28(%rbp), %rsi
leaq 0xd15(%rip), %rdx       # 0x92fe0
callq 0x92db0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x922df
jmp 0x92335
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x9232a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rdx
movzbl %al, %esi
callq 0x72870
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9231a
jmp 0x9232c
jmp 0x9231c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x922e7
jmp 0x9232c
movq -0x18(%rbp), %rdi
callq 0x12290
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_equd
static void prv_parse_equd(subtilis_arm_ass_context_t *c, subtilis_error_t *err)
{
	int32_t *nums;
	size_t i;
	size_t num_count = 0;

	nums = prv_get_uint32_list(c, &num_count, NULL, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	for (i = 0; i < num_count; i++) {
		subtilis_arm_add_four_bytes(c->arm_s, nums[i], err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

cleanup:

	free(nums);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x92db0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9237c
jmp 0x923cf
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x923c4
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movq -0x10(%rbp), %rdx
callq 0x72910
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x923b4
jmp 0x923c6
jmp 0x923b6
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x92384
jmp 0x923c6
movq -0x18(%rbp), %rdi
callq 0x12290
addq $0x30, %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_equdbl
static void prv_parse_equdbl(subtilis_arm_ass_context_t *c,
			     subtilis_error_t *err)
{
	double *nums;
	size_t num_count;
	size_t i;

	nums = prv_get_double_list(c, &num_count, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	for (i = 0; i < num_count; i++) {
		subtilis_arm_add_double(c->arm_s, nums[i], err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

cleanup:

	free(nums);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x20(%rbp), %rsi
callq 0x93010
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x92410
jmp 0x92465
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x9245a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rsi
callq 0x72960
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9244a
jmp 0x9245c
jmp 0x9244c
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x92418
jmp 0x9245c
movq -0x18(%rbp), %rdi
callq 0x12290
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_equf
static void prv_parse_equf(subtilis_arm_ass_context_t *c, subtilis_error_t *err)
{
	double *nums;
	size_t num_count;
	size_t i;

	nums = prv_get_double_list(c, &num_count, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	for (i = 0; i < num_count; i++) {
		subtilis_arm_add_float(c->arm_s, (float)nums[i], err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

cleanup:

	free(nums);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x20(%rbp), %rsi
callq 0x93010
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x924a0
jmp 0x924f9
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x924ee
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x10(%rbp), %rsi
callq 0x72a00
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x924de
jmp 0x924f0
jmp 0x924e0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x924a8
jmp 0x924f0
movq -0x18(%rbp), %rdi
callq 0x12290
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_equdblr
static void prv_parse_equdblr(subtilis_arm_ass_context_t *c,
			      subtilis_error_t *err)
{
	double *nums;
	size_t num_count;
	size_t i;

	nums = prv_get_double_list(c, &num_count, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	for (i = 0; i < num_count; i++) {
		subtilis_arm_add_doubler(c->arm_s, nums[i], err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

cleanup:

	free(nums);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x20(%rbp), %rsi
callq 0x93010
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x92530
jmp 0x92585
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x9257a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rsi
callq 0x729b0
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9256a
jmp 0x9257c
jmp 0x9256c
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x92538
jmp 0x9257c
movq -0x18(%rbp), %rdi
callq 0x12290
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_equs
static void prv_parse_equs(subtilis_arm_ass_context_t *c, subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val;
	const char *str;

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

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

	str = subtilis_buffer_get_string(&val->val.buf);
	subtilis_arm_add_string(c->arm_s, str, err);

cleanup:

	subtilis_arm_exp_val_free(val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9b4f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x925bf
jmp 0x9264c
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
je 0x9261e
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%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 0x19abc(%rip), %rdx     # 0xac0c0
leaq 0x1bb15(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0xf52, 0x8(%rsp)       # imm = 0xF52
callq 0x156d0
jmp 0x92643
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x16760
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x72a50
movq -0x18(%rbp), %rdi
callq 0x9a4c0
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_equw
static void prv_parse_equw(subtilis_arm_ass_context_t *c, subtilis_error_t *err)
{
	int32_t *nums;
	size_t i;
	size_t num_count = 0;

	nums = prv_get_uint32_list(c, &num_count, prv_check_equw, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	for (i = 0; i < num_count; i++) {
		subtilis_arm_add_two_bytes(c->arm_s, (uint16_t)nums[i], err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

cleanup:

	free(nums);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq -0x28(%rbp), %rsi
leaq 0xb65(%rip), %rdx       # 0x931f0
callq 0x92db0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9269f
jmp 0x926f5
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x926ea
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rdx
movzwl %ax, %esi
callq 0x728c0
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x926da
jmp 0x926ec
jmp 0x926dc
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x926a7
jmp 0x926ec
movq -0x18(%rbp), %rdi
callq 0x12290
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_possible_vfp
static void prv_parse_possible_vfp(subtilis_arm_ass_context_t *c,
				   subtilis_arm_instr_type_t itype,
				   const char *tbuf, const char *flags,
				   size_t flags_len, subtilis_error_t *err)
{
	size_t i;
	subtilis_arm_ccode_type_t ccode = SUBTILIS_ARM_CCODE_AL;
	size_t ptr = 0;

	/*
	 * TODO: Need to do store multiple
	 */

	if (flags_len >= 2) {
		for (i = 0; i < sizeof(condition_codes) / sizeof(const char *);
		     i++)
			if ((flags[ptr] == condition_codes[i][0]) &&
			    (flags[ptr + 1] == condition_codes[i][1]))
				break;

		if (i < sizeof(condition_codes) / sizeof(const char *)) {
			ptr += 2;
			ccode = (subtilis_arm_ccode_type_t)i;
		}
	}

	if (ptr == flags_len) {
		prv_parse_vfp_instruction(c, tbuf, itype, ccode, err);
		return;
	}

	prv_parse_label(c, tbuf, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0xe, -0x3c(%rbp)
movq $0x0, -0x48(%rbp)
cmpq $0x2, -0x28(%rbp)
jb 0x937ac
movq $0x0, -0x38(%rbp)
cmpq $0x10, -0x38(%rbp)
jae 0x93790
movq -0x20(%rbp), %rax
movq -0x48(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x38(%rbp), %rdx
leaq 0x3cf21(%rip), %rcx     # 0xd0670
movq (%rcx,%rdx,8), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x93780
movq -0x20(%rbp), %rax
movq -0x48(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %eax
movq -0x38(%rbp), %rdx
leaq 0x3cefe(%rip), %rcx     # 0xd0670
movq (%rcx,%rdx,8), %rcx
movsbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jne 0x93780
jmp 0x93790
jmp 0x93782
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x93731
cmpq $0x10, -0x38(%rbp)
jae 0x937aa
movq -0x48(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movl %eax, -0x3c(%rbp)
jmp 0x937ac
movq -0x48(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x937cf
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x3c(%rbp), %ecx
movq -0x30(%rbp), %r8
callq 0x94cb0
jmp 0x937e0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x93220
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_fpa_flt
static void prv_parse_fpa_flt(subtilis_arm_ass_context_t *c,
			      subtilis_arm_instr_type_t itype,
			      subtilis_arm_ccode_type_t ccode,
			      subtilis_fpa_rounding_t rnd, size_t size,
			      subtilis_error_t *err)
{
	subtilis_fpa_tran_instr_t *tran;
	subtilis_arm_instr_t *instr;
	const char *tbuf;

	instr = subtilis_arm_section_add_instr(c->arm_s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	tran = &instr->operands.fpa_tran;

	tran->dest = prv_get_fpa_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;
	}

	tran->op2.reg = prv_get_reg(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	tran->immediate = false;
	tran->ccode = ccode;
	tran->size = size;
	tran->rounding = rnd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x70b50
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x94032
jmp 0x94127
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x94420
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x94064
jmp 0x94127
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12d70
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
jne 0x94097
movq -0x40(%rbp), %rdi
leaq 0x1651c(%rip), %rsi     # 0xaa5a9
callq 0x12140
cmpl $0x0, %eax
je 0x940dd
movq -0x28(%rbp), %rdi
movq -0x40(%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 0x164e6(%rip), %rdx     # 0xaa5a9
leaq 0x1a056(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x8c9, 0x8(%rsp)       # imm = 0x8C9
callq 0x156d0
jmp 0x94127
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x94690
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x94100
jmp 0x94127
movq -0x30(%rbp), %rax
movb $0x0, 0x10(%rax)
movl -0x10(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x28(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_fpa_fix
static void prv_parse_fpa_fix(subtilis_arm_ass_context_t *c,
			      subtilis_arm_instr_type_t itype,
			      subtilis_arm_ccode_type_t ccode,
			      subtilis_fpa_rounding_t rnd,
			      subtilis_error_t *err)
{
	subtilis_fpa_tran_instr_t *tran;
	subtilis_arm_instr_t *instr;
	const char *tbuf;

	instr = subtilis_arm_section_add_instr(c->arm_s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	tran = &instr->operands.fpa_tran;

	tran->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;
	}

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

	tran->ccode = ccode;
	tran->size = 0;
	tran->rounding = rnd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x70b50
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9416e
jmp 0x94264
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x94690
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x941a0
jmp 0x94264
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12d70
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
jne 0x941d3
movq -0x38(%rbp), %rdi
leaq 0x163e0(%rip), %rsi     # 0xaa5a9
callq 0x12140
cmpl $0x0, %eax
je 0x94219
movq -0x20(%rbp), %rdi
movq -0x38(%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 0x163aa(%rip), %rdx     # 0xaa5a9
leaq 0x19f1a(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x8ed, 0x8(%rsp)       # imm = 0x8ED
callq 0x156d0
jmp 0x94264
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x18, %rsi
movq -0x20(%rbp), %rdx
callq 0x944f0
movb %al, %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x10(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x94245
jmp 0x94264
movl -0x10(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x20(%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x28(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_fpa_cmp
static void prv_parse_fpa_cmp(subtilis_arm_ass_context_t *c,
			      subtilis_arm_instr_type_t itype,
			      subtilis_arm_ccode_type_t ccode,
			      subtilis_error_t *err)
{
	subtilis_fpa_cmp_instr_t *cmpi;
	subtilis_arm_instr_t *instr;
	const char *tbuf;

	instr = subtilis_arm_section_add_instr(c->arm_s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	cmpi = &instr->operands.fpa_cmp;

	cmpi->dest = prv_get_fpa_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;
	}

	cmpi->immediate = prv_get_fpa_op2(c, &cmpi->op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	cmpi->ccode = ccode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x70b50
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x942ab
jmp 0x9438b
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x94420
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x942dd
jmp 0x9438b
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 0x94310
movq -0x30(%rbp), %rdi
leaq 0x162a3(%rip), %rsi     # 0xaa5a9
callq 0x12140
cmpl $0x0, %eax
je 0x94356
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 0x1626d(%rip), %rdx     # 0xaa5a9
leaq 0x19ddd(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x8a9, 0x8(%rsp)       # imm = 0x8A9
callq 0x156d0
jmp 0x9438b
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x18, %rsi
movq -0x18(%rbp), %rdx
callq 0x944f0
movb %al, %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x94382
jmp 0x9438b
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%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_fpa_cptran
static void prv_parse_fpa_cptran(subtilis_arm_ass_context_t *c,
				 subtilis_arm_instr_type_t itype,
				 subtilis_arm_ccode_type_t ccode,
				 subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_fpa_cptran_instr_t *cptran;
	subtilis_arm_instr_t *instr;

	dest = prv_get_reg(c, 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;

	cptran = &instr->operands.fpa_cptran;
	cptran->ccode = ccode;
	cptran->dest = dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x94690
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x943d2
jmp 0x94415
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x70b50
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x943f4
jmp 0x94415
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_get_fpa_reg
static subtilis_arm_reg_t prv_get_fpa_reg(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_FREG) {
		subtilis_error_set_expected(err, "floating point 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 0x94457
movq $-0x1, -0x8(%rbp)
jmp 0x944db
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x944be
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 0x19cd7(%rip), %rdx     # 0xae173
leaq 0x19c7d(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x220, 0x8(%rsp)       # imm = 0x220
callq 0x156d0
movq $-0x1, -0x28(%rbp)
jmp 0x944ca
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_reg
static subtilis_arm_reg_t prv_get_reg(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_REG) {
		subtilis_error_set_expected(err, "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 0x946c7
movq $-0x1, -0x8(%rbp)
jmp 0x9474b
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
je 0x9472e
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 0x19ac4(%rip), %rdx     # 0xae1d0
leaq 0x19a0d(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x208, 0x8(%rsp)       # imm = 0x208
callq 0x156d0
movq $-0x1, -0x28(%rbp)
jmp 0x9473a
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_fpa_stran_offset
static uint8_t prv_get_fpa_stran_offset(subtilis_arm_ass_context_t *c,
					bool *subtract, subtilis_error_t *err)
{
	subtilis_arm_exp_val_t *val = NULL;
	uint32_t absv = 0;
	bool sub = false;

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

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

	if (val->val.integer < 0) {
		sub = true;
		absv = -val->val.integer;
	} else {
		absv = val->val.integer;
	}

	if (absv > 1020 || ((absv & 3) != 0)) {
		subtilis_error_set_ass_bad_offset(
		    err, val->val.integer, c->l->stream->name, c->l->line);
		goto cleanup;
	}

	*subtract = sub;
	absv >>= 2;

cleanup:

	subtilis_arm_exp_val_free(val);

	return absv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movb $0x0, -0x2d(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9b4f0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x94b9a
movb $0x0, -0x1(%rbp)
jmp 0x94c9e
movq -0x28(%rbp), %rax
cmpl $0x6, (%rax)
je 0x94bfc
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x9b550
movq -0x38(%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 0x17de5(%rip), %rdx     # 0xac9c4
leaq 0x1953a(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x908, 0x8(%rsp)       # imm = 0x908
callq 0x156d0
jmp 0x94c8f
movq -0x28(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0x94c18
movb $0x1, -0x2d(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
subl 0x8(%rcx), %eax
movl %eax, -0x2c(%rbp)
jmp 0x94c22
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x3fc, -0x2c(%rbp)     # imm = 0x3FC
ja 0x94c36
movl -0x2c(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x94c7a
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edx
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 $0x5b, %esi
xorl %ecx, %ecx
leaq 0x194b9(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x915, 0x8(%rsp)       # imm = 0x915
callq 0x157b0
jmp 0x94c8f
movb -0x2d(%rbp), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x9a4c0
movl -0x2c(%rbp), %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_vfp_copy
static void prv_parse_vfp_copy(subtilis_arm_ass_context_t *c, const char *name,
			       subtilis_arm_instr_type_t itype,
			       subtilis_arm_ccode_type_t ccode,
			       subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t src;
	const char *tbuf;

	switch (itype) {
	case SUBTILIS_VFP_INSTR_FCPYS:
	case SUBTILIS_VFP_INSTR_FNEGS:
	case SUBTILIS_VFP_INSTR_FABSS:
		dest = prv_get_vfp_sreg(c, err);
		break;
	default:
		dest = prv_get_vfp_dreg(c, err);
		break;
	}
	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;
	}
	switch (itype) {
	case SUBTILIS_VFP_INSTR_FCPYS:
	case SUBTILIS_VFP_INSTR_FNEGS:
	case SUBTILIS_VFP_INSTR_FABSS:
		src = prv_get_vfp_sreg(c, err);
		break;
	default:
		src = prv_get_vfp_dreg(c, err);
		break;
	}
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_vfp_add_copy(c->arm_s, ccode, itype, dest, src, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
subl $0x4a, %eax
je 0x94e5b
jmp 0x94e47
movl -0x3c(%rbp), %eax
subl $0x4c, %eax
je 0x94e5b
jmp 0x94e51
movl -0x3c(%rbp), %eax
subl $0x4e, %eax
jne 0x94e6e
jmp 0x94e5b
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x963a0
movq %rax, -0x28(%rbp)
jmp 0x94e7f
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x96470
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x94e8d
jmp 0x94f74
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12d70
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
jne 0x94ec0
movq -0x38(%rbp), %rdi
leaq 0x156f3(%rip), %rsi     # 0xaa5a9
callq 0x12140
cmpl $0x0, %eax
je 0x94f06
movq -0x20(%rbp), %rdi
movq -0x38(%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 0x156bd(%rip), %rdx     # 0xaa5a9
leaq 0x1922d(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0xaa1, 0x8(%rsp)       # imm = 0xAA1
callq 0x156d0
jmp 0x94f74
movl -0x14(%rbp), %eax
movl %eax, -0x40(%rbp)
subl $0x4a, %eax
je 0x94f27
jmp 0x94f13
movl -0x40(%rbp), %eax
subl $0x4c, %eax
je 0x94f27
jmp 0x94f1d
movl -0x40(%rbp), %eax
subl $0x4e, %eax
jne 0x94f3a
jmp 0x94f27
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x963a0
movq %rax, -0x30(%rbp)
jmp 0x94f4b
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x96470
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x94f56
jmp 0x94f74
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x20(%rbp), %r9
callq 0x87e90
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_vfp_tran
static void prv_parse_vfp_tran(subtilis_arm_ass_context_t *c, const char *name,
			       subtilis_arm_instr_type_t itype,
			       subtilis_arm_ccode_type_t ccode,
			       subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t src;
	const char *tbuf;

	switch (itype) {
	case SUBTILIS_VFP_INSTR_FSITOD:
	case SUBTILIS_VFP_INSTR_FUITOD:
		dest = prv_get_vfp_dreg(c, err);
		break;
	default:
		dest = prv_get_vfp_sreg(c, err);
		break;
	}
	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;
	}

	switch (itype) {
	case SUBTILIS_VFP_INSTR_FTOUID:
	case SUBTILIS_VFP_INSTR_FTOUIZD:
	case SUBTILIS_VFP_INSTR_FTOSID:
	case SUBTILIS_VFP_INSTR_FTOSIZD:
		src = prv_get_vfp_dreg(c, err);
		break;
	default:
		src = prv_get_vfp_sreg(c, err);
		break;
	}
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_vfp_add_tran(c->arm_s, itype, ccode, false, dest, src, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
subl $0x51, %eax
je 0x94fb1
jmp 0x94fa7
movl -0x3c(%rbp), %eax
subl $0x5b, %eax
jne 0x94fc4
jmp 0x94fb1
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x96470
movq %rax, -0x28(%rbp)
jmp 0x94fd5
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x963a0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x94fe3
jmp 0x950da
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12d70
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
jne 0x95016
movq -0x38(%rbp), %rdi
leaq 0x1559d(%rip), %rsi     # 0xaa5a9
callq 0x12140
cmpl $0x0, %eax
je 0x9505c
movq -0x20(%rbp), %rdi
movq -0x38(%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 0x15567(%rip), %rdx     # 0xaa5a9
leaq 0x190d7(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0xacc, 0x8(%rsp)       # imm = 0xACC
callq 0x156d0
jmp 0x950da
movl -0x14(%rbp), %eax
movl %eax, -0x40(%rbp)
subl $0x54, %eax
je 0x95087
jmp 0x95069
movl -0x40(%rbp), %eax
subl $0x56, %eax
je 0x95087
jmp 0x95073
movl -0x40(%rbp), %eax
subl $0x58, %eax
je 0x95087
jmp 0x9507d
movl -0x40(%rbp), %eax
subl $0x5a, %eax
jne 0x9509a
jmp 0x95087
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x96470
movq %rax, -0x30(%rbp)
jmp 0x950ab
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x963a0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x950b6
jmp 0x950da
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x88340
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/assembler.c
// Function: prv_parse_vfp_cptran
static void prv_parse_vfp_cptran(subtilis_arm_ass_context_t *c,
				 const char *name,
				 subtilis_arm_instr_type_t itype,
				 subtilis_arm_ccode_type_t ccode,
				 subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t src;

	if (itype == SUBTILIS_VFP_INSTR_FMSR) {
		dest = prv_get_vfp_sreg(c, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		src = prv_get_reg(c, err);
	} else {
		dest = prv_get_reg(c, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		src = prv_get_vfp_sreg(c, err);
	}
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_vfp_add_cptran(c->arm_s, itype, ccode, false, dest, src, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
cmpl $0x5d, -0x14(%rbp)
jne 0x9512f
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x963a0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9511c
jmp 0x9518b
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x94690
movq %rax, -0x30(%rbp)
jmp 0x9515c
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x94690
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9514b
jmp 0x9518b
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x963a0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x95167
jmp 0x9518b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x883d0
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_vfp_sqrt
static void prv_parse_vfp_sqrt(subtilis_arm_ass_context_t *c, const char *name,
			       subtilis_arm_instr_type_t itype,
			       subtilis_arm_ccode_type_t ccode,
			       subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op1;
	const char *tbuf;

	if (itype == SUBTILIS_VFP_INSTR_FSQRTD)
		dest = prv_get_vfp_dreg(c, err);
	else
		dest = prv_get_vfp_sreg(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;
	}

	if (itype == SUBTILIS_VFP_INSTR_FSQRTD)
		op1 = prv_get_vfp_dreg(c, err);
	else
		op1 = prv_get_vfp_sreg(c, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_vfp_add_sqrt(c->arm_s, itype, ccode, dest, op1, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
cmpl $0x79, -0x14(%rbp)
jne 0x957c3
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x96470
movq %rax, -0x28(%rbp)
jmp 0x957d4
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x963a0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x957e2
jmp 0x958ae
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12d70
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
jne 0x95815
movq -0x38(%rbp), %rdi
leaq 0x14d9e(%rip), %rsi     # 0xaa5a9
callq 0x12140
cmpl $0x0, %eax
je 0x9585b
movq -0x20(%rbp), %rdi
movq -0x38(%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 0x14d68(%rip), %rdx     # 0xaa5a9
leaq 0x188d8(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0xbb7, 0x8(%rsp)       # imm = 0xBB7
callq 0x156d0
jmp 0x958ae
cmpl $0x79, -0x14(%rbp)
jne 0x95874
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x96470
movq %rax, -0x30(%rbp)
jmp 0x95885
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x963a0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x95890
jmp 0x958ae
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x20(%rbp), %r9
callq 0x885b0
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_get_vfp_sreg
static subtilis_arm_reg_t prv_get_vfp_sreg(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_SREG) {
		subtilis_error_set_expected(err, "vfp S 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 0x963d7
movq $-0x1, -0x8(%rbp)
jmp 0x9645b
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
je 0x9643e
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 0x17d9f(%rip), %rdx     # 0xae1bb
leaq 0x17cfd(%rip), %rax     # 0xae120
movq %rax, (%rsp)
movl $0x238, 0x8(%rsp)       # imm = 0x238
callq 0x156d0
movq $-0x1, -0x28(%rbp)
jmp 0x9644a
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)