LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: expand_binop
static int expand_binop(struct expression *expr)
{
	int cost;

	cost = expand_expression(expr->left);
	cost += expand_expression(expr->right);
	if (simplify_int_binop(expr, expr->ctype))
		return 0;
	if (simplify_float_binop(expr))
		return 0;
	return cost + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x11b30
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x11b30
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x13080
cmpl $0x0, %eax
je 0x1243e
movl $0x0, -0x4(%rbp)
jmp 0x1245e
movq -0x10(%rbp), %rdi
callq 0x134d0
cmpl $0x0, %eax
je 0x12455
movl $0x0, -0x4(%rbp)
jmp 0x1245e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: expand_comma
static int expand_comma(struct expression *expr)
{
	int cost;

	cost = expand_expression(expr->left);
	cost += expand_expression(expr->right);
	if (expr->left->type == EXPR_VALUE || expr->left->type == EXPR_FVALUE) {
		unsigned flags = expr->flags;
		unsigned taint;
		taint = expr->left->type == EXPR_VALUE ? expr->left->taint : 0;
		*expr = *expr->right;
		expr->flags = flags;
		if (expr->type == EXPR_VALUE)
			expr->taint |= Taint_comma | taint;
	}
	return cost;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x11b30
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x11b30
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
je 0x1265b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1c, %eax
jne 0x126f1
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0xff, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
jne 0x12690
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x28(%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x12697
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x12697
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movl $0x40, %edx
callq 0x111d0
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xff, %edx
shll $0x8, %edx
andl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
jne 0x126ef
movl -0x14(%rbp), %ecx
orl $0x1, %ecx
movq -0x8(%rbp), %rax
orl 0x28(%rax), %ecx
movl %ecx, 0x28(%rax)
jmp 0x126f1
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: expand_compare
static int expand_compare(struct expression *expr)
{
	struct expression *left = expr->left, *right = expr->right;
	int cost;

	cost = expand_expression(left);
	cost += expand_expression(right);

	if (left && right) {
		/* Type comparison? */
		if (left->type == EXPR_TYPE && right->type == EXPR_TYPE) {
			int op = expr->op;
			expr->type = EXPR_VALUE;
			expr->value = compare_types(op, left->symbol, right->symbol);
			expr->taint = 0;
			return 0;
		}
		if (simplify_cmp_binop(expr, left->ctype))
			return 0;
		if (simplify_float_cmp(expr, left->ctype))
			return 0;
	}
	return cost + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11b30
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11b30
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12807
cmpq $0x0, -0x20(%rbp)
je 0x12807
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x4, %eax
jne 0x127c7
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x4, %eax
jne 0x127c7
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x1, %ecx
movl %ecx, (%rax)
movl -0x28(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x138f0
movslq %eax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x12810
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x13a70
cmpl $0x0, %eax
je 0x127e6
movl $0x0, -0x4(%rbp)
jmp 0x12810
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x13d50
cmpl $0x0, %eax
je 0x12805
movl $0x0, -0x4(%rbp)
jmp 0x12810
jmp 0x12807
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: expand_assignment
static int expand_assignment(struct expression *expr)
{
	expand_expression(expr->left);
	expand_expression(expr->right);

	if (!conservative)
		check_assignment(expr);
	return SIDE_EFFECTS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x11b30
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x11b30
cmpl $0x0, 0x79023(%rip)     # 0x8b870
jne 0x12858
movq -0x8(%rbp), %rdi
callq 0x13f10
movl $0x2710, %eax           # imm = 0x2710
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: expand_preop
static int expand_preop(struct expression *expr)
{
	int cost;

	switch (expr->op) {
	case '*':
		return expand_dereference(expr);

	case '&':
		return expand_addressof(expr);

	case SPECIAL_INCREMENT:
	case SPECIAL_DECREMENT:
		/*
		 * From a type evaluation standpoint the preops are
		 * the same as the postops
		 */
		return expand_postop(expr);

	default:
		break;
	}
	cost = expand_expression(expr->unop);

	if (simplify_preop(expr))
		return 0;
	if (simplify_float_preop(expr))
		return 0;
	return cost + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x26, %eax
je 0x128bd
jmp 0x1288d
movl -0x18(%rbp), %eax
subl $0x2a, %eax
je 0x128af
jmp 0x12897
movl -0x18(%rbp), %eax
subl $0x101, %eax            # imm = 0x101
je 0x128cb
jmp 0x128a3
movl -0x18(%rbp), %eax
subl $0x103, %eax            # imm = 0x103
je 0x128cb
jmp 0x128d9
movq -0x10(%rbp), %rdi
callq 0x13f60
movl %eax, -0x4(%rbp)
jmp 0x12922
movq -0x10(%rbp), %rdi
callq 0x14190
movl %eax, -0x4(%rbp)
jmp 0x12922
movq -0x10(%rbp), %rdi
callq 0x12930
movl %eax, -0x4(%rbp)
jmp 0x12922
jmp 0x128db
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x11b30
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x141b0
cmpl $0x0, %eax
je 0x12902
movl $0x0, -0x4(%rbp)
jmp 0x12922
movq -0x10(%rbp), %rdi
callq 0x14320
cmpl $0x0, %eax
je 0x12919
movl $0x0, -0x4(%rbp)
jmp 0x12922
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: expand_cast
static int expand_cast(struct expression *expr)
{
	int cost;
	struct expression *target = expr->cast_expression;

	cost = expand_expression(target);

	/* Simplify normal integer casts.. */
	if (target->type == EXPR_VALUE || target->type == EXPR_FVALUE) {
		cast_value(expr, expr->ctype, target);
		return 0;
	}
	return cost + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11b30
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
je 0x129a4
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1c, %eax
jne 0x129c2
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x11640
movl $0x0, -0x4(%rbp)
jmp 0x129cb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: expand_call
static int expand_call(struct expression *expr)
{
	int cost;
	struct symbol *sym;
	struct expression *fn = expr->fn;

	cost = expand_arguments(expr->args);
	sym = fn->ctype;
	if (!sym) {
		expression_error(expr, "function has no type");
		return SIDE_EFFECTS;
	}
	if (sym->type == SYM_NODE)
		return expand_symbol_call(expr, cost);

	return SIDE_EFFECTS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x147d0
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x12a36
movq -0x10(%rbp), %rdi
leaq 0x4f824(%rip), %rsi     # 0x6224a
movb $0x0, %al
callq 0x17030
movl $0x2710, -0x4(%rbp)     # imm = 0x2710
jmp 0x12a5e
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x12a57
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x14890
movl %eax, -0x4(%rbp)
jmp 0x12a5e
movl $0x2710, -0x4(%rbp)     # imm = 0x2710
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: expand_conditional
static int expand_conditional(struct expression *expr)
{
	struct expression *cond = expr->conditional;
	struct expression *valt = expr->cond_true;
	struct expression *valf = expr->cond_false;
	int cost, cond_cost;

	cond_cost = expand_expression(cond);
	if (cond->type == EXPR_VALUE) {
		unsigned flags = expr->flags;
		if (!cond->value)
			valt = valf;
		if (!valt)
			valt = cond;
		cost = expand_expression(valt);
		*expr = *valt;
		expr->flags = flags;
		if (expr->type == EXPR_VALUE)
			expr->taint |= cond->taint;
		return cost;
	}

	cost = expand_expression(valt);
	cost += expand_expression(valf);

	if (cost < SELECT_COST) {
		expr->type = EXPR_SELECT;
		cost -= BRANCH_COST - 1;
	}

	return cost + cond_cost + BRANCH_COST;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11b30
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
jne 0x12b56
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0xff, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x12ae4
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x12af3
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11b30
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x40, %edx
callq 0x111d0
movl -0x34(%rbp), %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xff, %edx
shll $0x8, %edx
andl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
jne 0x12b4e
movq -0x18(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x10(%rbp), %rax
orl 0x28(%rax), %ecx
movl %ecx, 0x28(%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12b9d
movq -0x20(%rbp), %rdi
callq 0x11b30
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x11b30
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x14, -0x2c(%rbp)
jge 0x12b91
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x12, %ecx
movl %ecx, (%rax)
movl -0x2c(%rbp), %eax
subl $0x9, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addl -0x30(%rbp), %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: expand_expression_list
static int expand_expression_list(struct expression_list *list)
{
	int cost = 0;
	struct expression *expr;

	FOR_EACH_PTR(list, expr) {
		cost += expand_expression(expr);
	} END_FOR_EACH_PTR(expr);
	return cost;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x12de4
jmp 0x12e5f
jmp 0x12de6
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x12e4b
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x12e31
cmpq $0x0, -0x18(%rbp)
jne 0x12e31
jmp 0x12e40
movq -0x18(%rbp), %rdi
callq 0x11b30
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x12ded
jmp 0x12e4d
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x12de6
movl -0xc(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: check_shift_count
static bool check_shift_count(struct expression *expr, struct expression *right)
{
	struct symbol *ctype = expr->ctype;
	long long count = get_longlong(right);

	if (count >= 0 && count < ctype->bit_size)
		return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x119c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jl 0x138d7
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq 0x50(%rcx), %rcx
cmpq %rcx, %rax
jge 0x138d7
movb $0x1, -0x1(%rbp)
jmp 0x138db
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: compare_types
static int compare_types(int op, struct symbol *left, struct symbol *right)
{
	struct ctype c1 = {.base_type = left};
	struct ctype c2 = {.base_type = right};
	switch (op) {
	case SPECIAL_EQUAL:
		return !type_difference(&c1, &c2, MOD_IGN, MOD_IGN);
	case SPECIAL_NOTEQUAL:
		return type_difference(&c1, &c2, MOD_IGN, MOD_IGN) != NULL;
	case '<':
		return left->bit_size < right->bit_size;
	case '>':
		return left->bit_size > right->bit_size;
	case SPECIAL_LTE:
		return left->bit_size <= right->bit_size;
	case SPECIAL_GTE:
		return left->bit_size >= right->bit_size;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x74(%rbp)
subl $0x3c, %eax
je 0x139e4
jmp 0x1394a
movl -0x74(%rbp), %eax
subl $0x3e, %eax
je 0x139ff
jmp 0x13958
movl -0x74(%rbp), %eax
subl $0x108, %eax            # imm = 0x108
je 0x13a1a
jmp 0x13968
movl -0x74(%rbp), %eax
subl $0x109, %eax            # imm = 0x109
je 0x13a35
jmp 0x13978
movl -0x74(%rbp), %eax
subl $0x10a, %eax            # imm = 0x10A
je 0x13993
jmp 0x13984
movl -0x74(%rbp), %eax
subl $0x10b, %eax            # imm = 0x10B
je 0x139be
jmp 0x13a50
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0xe00, %ecx            # imm = 0xE00
movq %rcx, %rdx
callq 0x4ad70
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13a57
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0xe00, %ecx            # imm = 0xE00
movq %rcx, %rdx
callq 0x4ad70
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13a57
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x50(%rcx), %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13a57
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x50(%rcx), %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13a57
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x50(%rcx), %eax
setle %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13a57
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x50(%rcx), %eax
setge %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13a57
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: check_assignment
static void check_assignment(struct expression *expr)
{
	struct expression *right;

	switch (expr->op) {
	case SPECIAL_SHL_ASSIGN:
	case SPECIAL_SHR_ASSIGN:
		right = expr->right;
		if (right->type != EXPR_VALUE)
			break;
		check_shift_count(expr, right);
		break;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
addl $0xfffffeeb, %eax       # imm = 0xFFFFFEEB
subl $0x1, %eax
ja 0x13f5a
jmp 0x13f2f
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
je 0x13f4d
jmp 0x13f5a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13890
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: simplify_preop
static int simplify_preop(struct expression *expr)
{
	struct expression *op = expr->unop;
	unsigned long long v, mask;

	if (op->type != EXPR_VALUE)
		return 0;

	mask = 1ULL << (expr->ctype->bit_size-1);
	v = op->value;
	switch (expr->op) {
	case '+': break;
	case '-':
		if (v == mask && !(expr->ctype->ctype.modifiers & MOD_UNSIGNED))
			goto Overflow;
		v = -v;
		break;
	case '!': v = !v; break;
	case '~': v = ~v; break;
	default: return 0;
	}
	mask = mask | (mask-1);
	expr->value = v & mask;
	expr->type = EXPR_VALUE;
	expr->taint = op->taint;
	return 1;

Overflow:
	if (!conservative)
		warning(expr->pos, "constant integer operation overflow");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
je 0x141e4
movl $0x0, -0x4(%rbp)
jmp 0x1430c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movb 0x50(%rax), %cl
decb %cl
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x21, %eax
je 0x1426d
jmp 0x1421a
movl -0x2c(%rbp), %eax
subl $0x2b, %eax
je 0x14238
jmp 0x14224
movl -0x2c(%rbp), %eax
subl $0x2d, %eax
je 0x1423a
jmp 0x1422e
movl -0x2c(%rbp), %eax
subl $0x7e, %eax
je 0x14284
jmp 0x14292
jmp 0x1429b
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x14261
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x68(%rax), %rax
andq $0x4000, %rax           # imm = 0x4000
cmpq $0x0, %rax
jne 0x14261
jmp 0x142e6
xorl %eax, %eax
subq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1429b
cmpq $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x20(%rbp)
jmp 0x1429b
movq -0x20(%rbp), %rax
xorq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1429b
movl $0x0, -0x4(%rbp)
jmp 0x1430c
movq -0x28(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
andq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x1430c
cmpl $0x0, 0x77583(%rip)     # 0x8b870
jne 0x14305
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x4df06(%rip), %rsi     # 0x62204
movb $0x0, %al
callq 0x16d80
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: simplify_float_preop
static int simplify_float_preop(struct expression *expr)
{
	struct expression *op = expr->unop;
	long double v;

	if (op->type != EXPR_FVALUE)
		return 0;
	v = op->fvalue;
	switch (expr->op) {
	case '+': break;
	case '-': v = -v; break;
	default: return 0;
	}
	expr->fvalue = v;
	expr->type = EXPR_FVALUE;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1c, %eax
je 0x1434d
movl $0x0, -0x4(%rbp)
jmp 0x143a9
movq -0x18(%rbp), %rax
fldt 0x20(%rax)
fstpt -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x2b, %eax
je 0x14372
jmp 0x14368
movl -0x34(%rbp), %eax
subl $0x2d, %eax
je 0x14374
jmp 0x1437e
jmp 0x14387
fldt -0x30(%rbp)
fchs
fstpt -0x30(%rbp)
jmp 0x14387
movl $0x0, -0x4(%rbp)
jmp 0x143a9
fldt -0x30(%rbp)
movq -0x10(%rbp), %rax
fstpt 0x20(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x1c, %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: constant_symbol_value
static struct expression *constant_symbol_value(struct symbol *sym, int offset)
{
	struct expression *value;

	if (sym->ctype.modifiers & MOD_ACCESS)
		return NULL;
	value = sym->initializer;
	if (!value)
		return NULL;
	if (value->type == EXPR_INITIALIZER) {
		struct expression *entry;
		FOR_EACH_PTR(value->expr_list, entry) {
			if (entry->type != EXPR_POS) {
				if (offset)
					continue;
				return entry;
			}
			if (entry->init_offset < offset)
				continue;
			if (entry->init_offset > offset)
				break;
			return entry->init_expr;
		} END_FOR_EACH_PTR(entry);

		value = default_initializer(sym, offset);
	}
	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x180, %rax            # imm = 0x180
cmpq $0x0, %rax
je 0x143e0
movq $0x0, -0x8(%rbp)
jmp 0x1451c
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x14403
movq $0x0, -0x8(%rbp)
jmp 0x1451c
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x18, %eax
jne 0x14514
jmp 0x14419
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x14441
jmp 0x14504
jmp 0x14443
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x38(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x144ec
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x14492
cmpq $0x0, -0x28(%rbp)
jne 0x14492
jmp 0x144de
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1b, %eax
je 0x144b4
cmpl $0x0, -0x14(%rbp)
je 0x144aa
jmp 0x144de
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1451c
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x14(%rbp), %eax
jae 0x144c2
jmp 0x144de
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x14(%rbp), %eax
jbe 0x144d0
jmp 0x144ec
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1451c
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1444a
jmp 0x144ee
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x14443
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x14600
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/./symbol.h
// Function: is_integral_type
static inline bool is_integral_type(struct symbol *type)
{
	if (type->type == SYM_NODE)
		type = type->ctype.base_type;
	switch (type->type) {
	case SYM_ENUM:
	case SYM_PTR:
	case SYM_RESTRICT:	// OK, always integer types
	case SYM_FOULED:	// idem
		return 1;
	default:
		break;
	}
	if (type->ctype.base_type == &int_type)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x14554
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x4, %eax
je 0x1457c
jmp 0x14565
movl -0x14(%rbp), %eax
subl $0x9, %eax
je 0x1457c
jmp 0x1456f
movl -0x14(%rbp), %eax
addl $-0xd, %eax
subl $0x1, %eax
ja 0x14582
jmp 0x1457c
movb $0x1, -0x1(%rbp)
jmp 0x1459f
jmp 0x14584
movq -0x10(%rbp), %rax
leaq 0x7ccc9(%rip), %rcx     # 0x91258
cmpq %rcx, 0x60(%rax)
jne 0x1459b
movb $0x1, -0x1(%rbp)
jmp 0x1459f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/./symbol.h
// Function: get_sym_type
static inline int get_sym_type(struct symbol *type)
{
	if (type->type == SYM_NODE)
		type = type->ctype.base_type;
	if (type->type == SYM_ENUM)
		type = type->ctype.base_type;
	return type->type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x145d4
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x9, %eax
jne 0x145f0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: default_initializer
static struct expression *default_initializer(struct symbol *sym, int offset)
{
	static struct expression value;
	struct symbol *type;

redo:
	switch (sym->type) {
	case SYM_NODE:
		sym = sym->ctype.base_type;
		goto redo;
	case SYM_STRUCT:
		type = find_member(sym, offset);
		if (!type)
			return NULL;
		break;
	case SYM_ARRAY:
		type = sym->ctype.base_type;
		break;
	default:
		return NULL;
	}

	if (is_integral_type(type))
		value.type = EXPR_VALUE;
	else if (is_float_type(type))
		value.type = EXPR_FVALUE;
	else
		return NULL;

	value.ctype = type;
	return &value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x3, %eax
je 0x14634
jmp 0x14620
movl -0x24(%rbp), %eax
subl $0x6, %eax
je 0x14668
jmp 0x1462a
movl -0x24(%rbp), %eax
subl $0x7, %eax
je 0x14642
jmp 0x14676
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1460f
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x14700
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x14666
movq $0x0, -0x8(%rbp)
jmp 0x146eb
jmp 0x14680
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x14680
movq $0x0, -0x8(%rbp)
jmp 0x146eb
movq -0x20(%rbp), %rdi
callq 0x14530
testb $0x1, %al
jne 0x1468f
jmp 0x146a5
movl 0x771eb(%rip), %eax     # 0x8b880
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
orl $0x1, %eax
movl %eax, 0x771dd(%rip)     # 0x8b880
jmp 0x146d5
movq -0x20(%rbp), %rdi
callq 0x11980
cmpl $0x0, %eax
je 0x146c9
movl 0x771c7(%rip), %eax     # 0x8b880
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
orl $0x1c, %eax
movl %eax, 0x771b9(%rip)     # 0x8b880
jmp 0x146d3
movq $0x0, -0x8(%rbp)
jmp 0x146eb
jmp 0x146d5
movq -0x20(%rbp), %rax
movq %rax, 0x771b0(%rip)     # 0x8b890
leaq 0x77199(%rip), %rax     # 0x8b880
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: find_member
static struct symbol *find_member(struct symbol *sym, int offset)
{
	struct ptr_list *head, *list;

	head = (struct ptr_list *) sym->symbol_list;
	list = head;
	if (!head)
		return NULL;
	do {
		int nr = list->nr;
		int i;
		for (i = 0; i < nr; i++) {
			struct symbol *ent = (struct symbol *) list->list[i];
			int curr = ent->offset;
			if (curr == offset)
				return ent;
			if (curr > offset)
				return NULL;
		}
	} while ((list = list->next) != head);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x14736
movq $0x0, -0x8(%rbp)
jmp 0x147c7
jmp 0x14738
movq -0x28(%rbp), %rax
movw (%rax), %ax
shlw $0x8, %ax
sarw $0x8, %ax
cwtl
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x147a7
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x14788
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x147c7
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x1479a
movq $0x0, -0x8(%rbp)
jmp 0x147c7
jmp 0x1479c
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x14752
jmp 0x147a9
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x14738
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: expand_arguments
static int expand_arguments(struct expression_list *head)
{
	int cost = 0;
	struct expression *expr;

	FOR_EACH_PTR (head, expr) {
		cost += expand_expression(expr);
	} END_FOR_EACH_PTR(expr);
	return cost;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x14804
jmp 0x1487f
jmp 0x14806
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x1486b
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x14851
cmpq $0x0, -0x18(%rbp)
jne 0x14851
jmp 0x14860
movq -0x18(%rbp), %rdi
callq 0x11b30
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1480d
jmp 0x1486d
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x14806
movl -0xc(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: expand_symbol_call
static int expand_symbol_call(struct expression *expr, int cost)
{
	struct expression *fn = expr->fn;
	struct symbol *ctype = fn->ctype;

	expand_expression(fn);

	if (fn->type != EXPR_PREOP)
		return SIDE_EFFECTS;

	if (ctype->ctype.modifiers & MOD_INLINE) {
		struct symbol *def;

		def = ctype->definition ? ctype->definition : ctype;
		if (inline_function(expr, def)) {
			struct symbol *fn = def->ctype.base_type;
			struct symbol *curr = current_fn;

			current_fn = def;
			evaluate_statement(expr->statement);
			current_fn = curr;

			fn->expanding = 1;
			cost = expand_expression(expr);
			fn->expanding = 0;
			return cost;
		}
	}

	if (ctype->op && ctype->op->expand)
		return ctype->op->expand(expr, cost);

	if (ctype->ctype.modifiers & MOD_PURE)
		return cost + 1;

	return SIDE_EFFECTS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11b30
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x9, %eax
je 0x148dc
movl $0x2710, -0x4(%rbp)     # imm = 0x2710
jmp 0x14a13
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x40, %rax
cmpq $0x0, %rax
je 0x149b9
movq -0x28(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x14911
movq -0x28(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x14919
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x15050
cmpl $0x0, %eax
je 0x149b7
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x38(%rbp)
leaq 0xa1a06(%rip), %rax     # 0xb6350
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rcx
leaq 0xa19f4(%rip), %rax     # 0xb6350
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x4f0b0
movq -0x40(%rbp), %rcx
leaq 0xa19d9(%rip), %rax     # 0xb6350
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movl 0x54(%rax), %ecx
andl $0xffffefff, %ecx       # imm = 0xFFFFEFFF
orl $0x1000, %ecx           # imm = 0x1000
movl %ecx, 0x54(%rax)
movq -0x10(%rbp), %rdi
callq 0x11b30
movl %eax, -0x14(%rbp)
movq -0x38(%rbp), %rax
movl 0x54(%rax), %ecx
andl $0xffffefff, %ecx       # imm = 0xFFFFEFFF
orl $0x0, %ecx
movl %ecx, 0x54(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x14a13
jmp 0x149b9
movq -0x28(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x149ed
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x149ed
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x14a13
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x1000000, %rax        # imm = 0x1000000
cmpq $0x0, %rax
je 0x14a0c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x14a13
movl $0x2710, -0x4(%rbp)     # imm = 0x2710
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: compare_expressions
static int compare_expressions(const void *_a, const void *_b)
{
	const struct expression *a = _a;
	const struct expression *b = _b;
	unsigned long a_pos = bit_offset(a);
	unsigned long b_pos = bit_offset(b);

	return (a_pos < b_pos) ? -1 : (a_pos == b_pos) ? 0 : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x14a90
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x14a90
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x14a6e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x34(%rbp)
jmp 0x14a86
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rsi
movl $0x1, %eax
xorl %ecx, %ecx
cmpq %rsi, %rdx
cmovel %ecx, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: bit_offset
static unsigned long bit_offset(const struct expression *expr)
{
	unsigned long offset = 0;
	while (expr->type == EXPR_POS) {
		offset += bytes_to_bits(expr->init_offset);
		expr = expr->init_expr;
	}
	if (expr && expr->ctype)
		offset += expr->ctype->bit_offset;
	return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1b, %eax
jne 0x14ad8
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edi
callq 0x14b10
cltq
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x14aa4
cmpq $0x0, -0x8(%rbp)
je 0x14b04
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x14b04
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x54(%rax), %eax
andl $0xff, %eax
movl %eax, %eax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: bit_range
static unsigned long bit_range(const struct expression *expr)
{
	unsigned long range = 0;
	unsigned long size = 0;
	while (expr->type == EXPR_POS) {
		unsigned long nr = expr->init_nr;
		size = expr->ctype->bit_size;
		range += (nr - 1) * size;
		expr = expr->init_expr;
	}
	range += size;
	return range;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1b, %eax
jne 0x14b96
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
subq $0x1, %rax
imulq -0x18(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x14b48
movq -0x18(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/./expression.h
// Function: alloc_expression
static inline struct expression *alloc_expression(struct position pos, int type)
{
	struct expression *expr = __alloc_expression(0);
	expr->type = type;
	expr->pos = pos;
	expr->flags = CEF_NONE;
	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %edi, %edi
callq 0x46d40
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0xff, %edx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
orl $0x0, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: expand_compound
static int expand_compound(struct statement *stmt)
{
	struct statement *s, *last;
	int cost, statements;

	if (stmt->ret)
		expand_symbol(stmt->ret);

	last = stmt->args;
	cost = expand_statement(last);
	statements = last != NULL;
	FOR_EACH_PTR(stmt->stmts, s) {
		statements++;
		last = s;
		cost += expand_statement(s);
	} END_FOR_EACH_PTR(s);

	if (statements == 1 && !stmt->ret)
		*stmt = *last;

	return cost;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x14c54
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x11aa0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11d80
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x14ca4
jmp 0x14d34
jmp 0x14ca6
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x30(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x14d1c
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x14cf1
cmpq $0x0, -0x10(%rbp)
jne 0x14cf1
jmp 0x14d11
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11d80
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x14cad
jmp 0x14d1e
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x14ca6
cmpl $0x1, -0x20(%rbp)
jne 0x14d57
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x14d57
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x50, %edx
callq 0x111d0
movl -0x1c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: expand_if_statement
static int expand_if_statement(struct statement *stmt)
{
	struct expression *expr = stmt->if_conditional;

	if (!expr || !expr->ctype || expr->ctype == &bad_ctype)
		return UNSAFE;

	expand_expression(expr);

/* This is only valid if nobody jumps into the "dead" side */
#if 0
	/* Simplify constant conditionals without even evaluating the false side */
	if (expr->type == EXPR_VALUE) {
		struct statement *simple;
		simple = expr->value ? stmt->if_true : stmt->if_false;

		/* Nothing? */
		if (!simple) {
			stmt->type = STMT_NONE;
			return 0;
		}
		expand_statement(simple);
		*stmt = *simple;
		return SIDE_EFFECTS;
	}
#endif
	expand_statement(stmt->if_true);
	expand_statement(stmt->if_false);
	return SIDE_EFFECTS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x14d9b
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x14d9b
movq -0x18(%rbp), %rax
leaq 0x7df03(%rip), %rcx     # 0x92c98
cmpq %rcx, 0x10(%rax)
jne 0x14da4
movl $0x64, -0x4(%rbp)
jmp 0x14dce
movq -0x18(%rbp), %rdi
callq 0x11b30
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x11d80
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x11d80
movl $0x2710, -0x4(%rbp)     # imm = 0x2710
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: expand_const_expression
static void expand_const_expression(struct expression *expr, const char *where)
{
	if (expr) {
		expand_expression(expr);
		if (expr->type != EXPR_VALUE) {
			expression_error(expr, "Expected constant expression in %s", where);
			expr->ctype = &int_ctype;
			expr->type = EXPR_VALUE;
			expr->value = 0;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x14e54
movq -0x8(%rbp), %rdi
callq 0x11b30
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
je 0x14e52
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x4d474(%rip), %rsi     # 0x62293
movb $0x0, %al
callq 0x17030
movq -0x8(%rbp), %rax
leaq 0x7cce7(%rip), %rcx     # 0x91b18
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
jmp 0x14e54
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: expand_asm_statement
static int expand_asm_statement(struct statement *stmt)
{
	struct asm_operand *op;
	int cost = 0;

	FOR_EACH_PTR(stmt->asm_outputs, op) {
		cost += expand_expression(op->expr);
	} END_FOR_EACH_PTR(op);

	FOR_EACH_PTR(stmt->asm_inputs, op) {
		cost += expand_expression(op->expr);
	} END_FOR_EACH_PTR(op);

	return cost;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x14e98
jmp 0x14f17
jmp 0x14e9a
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x14f03
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x14ee5
cmpq $0x0, -0x10(%rbp)
jne 0x14ee5
jmp 0x14ef8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x11b30
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x14ea1
jmp 0x14f05
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x14e9a
jmp 0x14f19
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x14f3e
jmp 0x14fbd
jmp 0x14f40
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
movq -0x48(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x14fa9
movq -0x48(%rbp), %rax
movslq -0x54(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x48(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x14f8b
cmpq $0x0, -0x10(%rbp)
jne 0x14f8b
jmp 0x14f9e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x11b30
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x14f47
jmp 0x14fab
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq -0x40(%rbp), %rax
jne 0x14f40
movl -0x14(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: bad_integer_constant_expression
static inline int bad_integer_constant_expression(struct expression *expr)
{
	if (!(expr->flags & CEF_ICE))
		return 1;
	if (expr->taint & Taint_comma)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0xff, %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x14ff7
movl $0x1, -0x4(%rbp)
jmp 0x15016
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1500f
movl $0x1, -0x4(%rbp)
jmp 0x15016
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/inline.c
// Function: create_symbol_list
static struct symbol_list *create_symbol_list(struct symbol_list *src)
{
	struct symbol_list *dst = NULL;
	struct symbol *sym;

	FOR_EACH_PTR(src, sym) {
		struct symbol *newsym = create_copy_symbol(sym);
		add_symbol(&dst, newsym);
	} END_FOR_EACH_PTR(sym);
	return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x15408
jmp 0x15492
jmp 0x1540a
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x1547a
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x15455
cmpq $0x0, -0x18(%rbp)
jne 0x15455
jmp 0x1546f
movq -0x18(%rbp), %rdi
callq 0x157e0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x15020
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x15411
jmp 0x1547c
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x1540a
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)