LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_symbol_call
static int evaluate_symbol_call(struct expression *expr)
{
	struct expression *fn = expr->fn;
	struct symbol *ctype = fn->ctype;

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

	if (ctype->op && ctype->op->evaluate)
		return ctype->op->evaluate(expr);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x9, %eax
je 0x53c1d
movl $0x0, -0x4(%rbp)
jmp 0x53c55
movq -0x20(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x53c4e
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x53c4e
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x53c55
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: handle_scalar
static struct expression *handle_scalar(struct expression *e, int nested)
{
	struct expression *v = NULL, *p;
	int count = 0;

	/* normal case */
	if (e->type != EXPR_INITIALIZER)
		return e;

	FOR_EACH_PTR(e->expr_list, p) {
		if (!v)
			v = p;
		count++;
	} END_FOR_EACH_PTR(p);
	if (count != 1)
		return NULL;
	switch(v->type) {
	case EXPR_INITIALIZER:
	case EXPR_INDEX:
	case EXPR_IDENTIFIER:
		return NULL;
	default:
		break;
	}
	if (nested)
		warning(e->pos, "braces around scalar initializer");
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x18, %eax
je 0x5417b
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5427e
jmp 0x5417d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x541a5
jmp 0x5422d
jmp 0x541a7
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq -0x40(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x54215
movq -0x40(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x541f2
cmpq $0x0, -0x28(%rbp)
jne 0x541f2
jmp 0x5420a
cmpq $0x0, -0x20(%rbp)
jne 0x54201
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x541ae
jmp 0x54217
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq -0x38(%rbp), %rax
jne 0x541a7
cmpl $0x1, -0x2c(%rbp)
je 0x5423d
movq $0x0, -0x8(%rbp)
jmp 0x5427e
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
addl $-0x18, %eax
subl $0x2, %eax
ja 0x54258
jmp 0x5424e
movq $0x0, -0x8(%rbp)
jmp 0x5427e
jmp 0x5425a
cmpl $0x0, -0x14(%rbp)
je 0x54276
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x18229(%rip), %rsi     # 0x6c498
movb $0x0, %al
callq 0x16d80
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: is_string_type
static inline int is_string_type(struct symbol *type)
{
	if (type->type == SYM_NODE)
		type = type->ctype.base_type;
	if (type->type != SYM_ARRAY)
		return 0;
	type = type->ctype.base_type;
	return is_byte_type(type) || is_wchar_type(type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x542b8
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x6, %eax
je 0x542d1
movl $0x0, -0x4(%rbp)
jmp 0x5430f
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x54c00
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0x54304
movq -0x10(%rbp), %rdi
callq 0x54c40
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %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/evaluate.c
// Function: is_string_literal
static int is_string_literal(struct expression **v)
{
	struct expression *e = *v;
	while (e && e->type == EXPR_PREOP && e->op == '(')
		e = e->unop;
	if (!e || e->type != EXPR_STRING)
		return 0;
	if (e != *v && Wparen_string)
		warning(e->pos,
			"array initialized from parenthesized string constant");
	*v = e;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x54367
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0xff, %ecx
xorl %eax, %eax
cmpl $0x9, %ecx
movb %al, -0x19(%rbp)
jne 0x54367
movq -0x18(%rbp), %rax
cmpl $0x28, 0x4(%rax)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x54370
jmp 0x5437e
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x54337
cmpq $0x0, -0x18(%rbp)
je 0x54395
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x2, %eax
je 0x5439e
movl $0x0, -0x4(%rbp)
jmp 0x543df
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
je 0x543cd
leaq 0x38e46(%rip), %rax     # 0x8d1f8
cmpl $0x0, (%rax)
je 0x543cd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x180f3(%rip), %rsi     # 0x6c4b9
movb $0x0, %al
callq 0x16d80
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -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/evaluate.c
// Function: convert_designators
static void convert_designators(struct expression *e)
{
	while (e) {
		if (e->type == EXPR_INDEX)
			convert_index(e);
		else if (e->type == EXPR_IDENTIFIER)
			convert_ident(e);
		else
			break;
		e = e->init_expr;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x553fb
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1a, %eax
jne 0x553ce
movq -0x8(%rbp), %rdi
callq 0x55460
jmp 0x553ed
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x19, %eax
jne 0x553e9
movq -0x8(%rbp), %rdi
callq 0x554f0
jmp 0x553eb
jmp 0x553fb
jmp 0x553ed
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x553ac
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: convert_index
static void convert_index(struct expression *e)
{
	struct expression *child = e->idx_expression;
	unsigned from = e->idx_from;
	unsigned to = e->idx_to + 1;
	e->type = EXPR_POS;
	e->init_offset = from * bits_to_bytes(e->ctype->bit_size);
	e->init_nr = to - from;
	e->init_expr = child;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x1b, %ecx
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x50(%rax), %edi
callq 0x513e0
movl -0x1c(%rbp), %ecx
imull %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x18(%rbp), %ecx
subl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: convert_ident
static void convert_ident(struct expression *e)
{
	struct expression *child = e->ident_expression;
	int offset = e->offset;

	e->type = EXPR_POS;
	e->init_offset = offset;
	e->init_nr = 1;
	e->init_expr = child;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x1b, %ecx
movl %ecx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x24(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: check_case_type
static void check_case_type(struct expression *switch_expr,
			    struct expression *case_expr,
			    struct expression **enumcase)
{
	struct symbol *switch_type, *case_type;
	int sclass, cclass;

	if (!case_expr)
		return;

	switch_type = switch_expr->ctype;
	case_type = evaluate_expression(case_expr);

	if (!switch_type || !case_type)
		goto Bad;
	if (enumcase) {
		if (*enumcase)
			warn_for_different_enum_types(case_expr->pos, case_type, (*enumcase)->ctype);
		else if (is_enum_type(case_type))
			*enumcase = case_expr;
	}

	sclass = classify_type(switch_type, &switch_type);
	cclass = classify_type(case_type, &case_type);

	/* both should be arithmetic */
	if (!(sclass & cclass & TYPE_NUM))
		goto Bad;

	/* neither should be floating */
	if ((sclass | cclass) & TYPE_FLOAT)
		goto Bad;

	/* if neither is restricted, we are OK */
	if (!((sclass | cclass) & TYPE_RESTRICT))
		return;

	if (!restricted_binop_type(SPECIAL_EQUAL, case_expr, switch_expr,
				   cclass, sclass, case_type, switch_type)) {
		unrestrict(case_expr, cclass, &case_type);
		unrestrict(switch_expr, sclass, &switch_type);
	}
	return;

Bad:
	expression_error(case_expr, "incompatible types for 'case' statement");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x555b0
jmp 0x556d7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4bb70
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x555d7
cmpq $0x0, -0x28(%rbp)
jne 0x555dc
jmp 0x556c5
cmpq $0x0, -0x18(%rbp)
je 0x55628
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5560b
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rdx
movq 0x8(%rax), %rdi
callq 0x508b0
jmp 0x55626
movq -0x28(%rbp), %rdi
callq 0x55550
cmpl $0x0, %eax
je 0x55624
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x55626
jmp 0x55628
movq -0x20(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4bf20
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4bf20
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
andl -0x30(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x55658
jmp 0x556c5
movl -0x2c(%rbp), %eax
orl -0x30(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x55668
jmp 0x556c5
movl -0x2c(%rbp), %eax
orl -0x30(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x55678
jmp 0x556d7
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
movl -0x30(%rbp), %ecx
movl -0x2c(%rbp), %r8d
movq -0x28(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0x10a, %edi            # imm = 0x10A
movq %rax, (%rsp)
callq 0x510e0
cmpq $0x0, %rax
jne 0x556c3
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
leaq -0x28(%rbp), %rdx
callq 0x51240
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
leaq -0x20(%rbp), %rdx
callq 0x51240
jmp 0x556d7
movq -0x10(%rbp), %rdi
leaq 0x17013(%rip), %rsi     # 0x6c6e3
movb $0x0, %al
callq 0x17030
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: verify_output_constraint
static void verify_output_constraint(struct asm_operand *op)
{
	struct expression *expr = op->constraint;
	const char *constraint = expr->string->data;

	if (!op->is_assign)
		expression_error(expr, "output constraint is not an assignment constraint (\"%s\")", constraint);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movb 0x18(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x558df
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x16ec2(%rip), %rsi     # 0x6c79a
movb $0x0, %al
callq 0x17030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_asm_memop
static void evaluate_asm_memop(struct asm_operand *op)
{
	if (op->is_memory) {
		struct expression *expr = op->expr;
		struct expression *addr;

		// implicit addressof
		addr = alloc_expression(expr->pos, EXPR_PREOP);
		addr->op = '&';
		addr->unop = expr;

		evaluate_addressof(addr);
		op->expr = addr;
	} else {
		evaluate_expression(op->expr);
		degenerate(op->expr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb 0x18(%rax), %al
shrb $0x5, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x55960
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x9, %esi
callq 0x50ab0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x26, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rdi
callq 0x532e0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5597a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4bb70
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4c1c0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: verify_input_constraint
static void verify_input_constraint(struct asm_operand *op)
{
	struct expression *expr = op->constraint;
	const char *constraint = expr->string->data;

	if (op->is_assign)
		expression_error(expr, "input constraint with assignment (\"%s\")", constraint);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movb 0x18(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x559cf
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x16e0b(%rip), %rsi     # 0x6c7d3
movb $0x0, %al
callq 0x17030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expression.c
// Function: parens_expression
struct token *parens_expression(struct token *token, struct expression **expr, const char *where)
{
	struct token *p;

	token = expect(token, '(', where);
	p = token;
	if (match_op(token, '{')) {
		struct expression *e = alloc_expression(token->pos, EXPR_STATEMENT);
		struct statement *stmt = alloc_statement(token->pos, STMT_COMPOUND);
		*expr = e;
		e->statement = stmt;
		start_label_scope();
		token = compound_statement(token->next, stmt);
		end_label_scope();
		token = expect(token, '}', "at end of statement expression");
	} else
		token = parse_expression(token, expr);

	if (token == p)
		sparse_error(token->pos, "an expression is expected before ')'");
	return expect(token, ')', where);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x28, %esi
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x7b, %esi
callq 0x55c10
cmpl $0x0, %eax
je 0x55bc0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x13, %esi
callq 0x55c50
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x3, %esi
callq 0x23020
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
callq 0x321a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x237e0
movq %rax, -0x8(%rbp)
callq 0x32070
movq -0x8(%rbp), %rdi
movl $0x7d, %esi
leaq 0x16cb7(%rip), %rdx     # 0x6c86c
callq 0x22eb0
movq %rax, -0x8(%rbp)
jmp 0x55bd1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x55cb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x55bf0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x16ca2(%rip), %rsi     # 0x6c88b
movb $0x0, %al
callq 0x16f90
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x29, %esi
callq 0x22eb0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expression.c
// Function: string_expression
struct token *string_expression(struct token *token, struct expression **expr, const char *where)
{
	struct token *next = primary_expression(token, expr);

	if (!*expr || (*expr)->type != EXPR_STRING) {
		sparse_error(token->pos, "string literal expected for %s", where);
		*expr = NULL;
	}
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x55d50
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x55d22
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x2, %eax
je 0x55d46
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rdx
movq (%rax), %rdi
leaq 0x16b7c(%rip), %rsi     # 0x6c8b0
movb $0x0, %al
callq 0x16f90
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expression.c
// Function: builtin_types_compatible_p_expr
static struct token *builtin_types_compatible_p_expr(struct token *token,
						     struct expression **tree)
{
	struct expression *expr = alloc_expression(
		token->pos, EXPR_COMPARE);
	expr->op = SPECIAL_EQUAL;
	token = token->next;
	if (!match_op(token, '('))
		return expect(token, '(',
			      "after __builtin_types_compatible_p");
	token = token->next;
	token = parse_type(token, &expr->left);
	if (!match_op(token, ','))
		return expect(token, ',',
			      "in __builtin_types_compatible_p");
	token = token->next;
	token = parse_type(token, &expr->right);
	if (!match_op(token, ')'))
		return expect(token, ')',
			      "at end of __builtin_types_compatible_p");
	token = token->next;
	
	*tree = expr;
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x16, %esi
callq 0x55c50
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x10a, 0x4(%rax)       # imm = 0x10A
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x28, %esi
callq 0x55c10
cmpl $0x0, %eax
jne 0x5693d
movq -0x10(%rbp), %rdi
movl $0x28, %esi
leaq 0x16142(%rip), %rdx     # 0x6ca71
callq 0x22eb0
movq %rax, -0x8(%rbp)
jmp 0x569fe
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x20, %rsi
callq 0x57480
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0x55c10
cmpl $0x0, %eax
jne 0x5698c
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
leaq 0x16113(%rip), %rdx     # 0x6ca94
callq 0x22eb0
movq %rax, -0x8(%rbp)
jmp 0x569fe
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x20, %rsi
addq $0x8, %rsi
callq 0x57480
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x29, %esi
callq 0x55c10
cmpl $0x0, %eax
jne 0x569df
movq -0x10(%rbp), %rdi
movl $0x29, %esi
leaq 0x160e0(%rip), %rdx     # 0x6cab4
callq 0x22eb0
movq %rax, -0x8(%rbp)
jmp 0x569fe
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expression.c
// Function: conditional_expression
struct token *conditional_expression(struct token *token, struct expression **tree)
{
	token = logical_or_expression(token, tree);
	if (*tree && match_op(token, '?')) {
		struct expression *expr = alloc_expression(token->pos, EXPR_CONDITIONAL);
		expr->op = token->special;
		expr->conditional = *tree;
		*tree = expr;
		token = parse_expression(token->next, &expr->cond_true);
		token = expect(token, ':', "in conditional expression");
		token = conditional_expression(token, &expr->cond_false);
	}
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x57020
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x57012
movq -0x8(%rbp), %rdi
movl $0x3f, %esi
callq 0x55c10
cmpl $0x0, %eax
je 0x57012
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x11, %esi
callq 0x55c50
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
addq $0x8, %rsi
callq 0x55cb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3a, %esi
leaq 0x15909(%rip), %rdx     # 0x6c8f9
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
addq $0x10, %rsi
callq 0x56f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expression.c
// Function: assignment_expression
struct token *assignment_expression(struct token *token, struct expression **tree)
{
	token = conditional_expression(token, tree);
	if (*tree && token_type(token) == TOKEN_SPECIAL) {
		static const int assignments[] = {
			'=',
			SPECIAL_ADD_ASSIGN, SPECIAL_SUB_ASSIGN,
			SPECIAL_MUL_ASSIGN, SPECIAL_DIV_ASSIGN,
			SPECIAL_MOD_ASSIGN, SPECIAL_SHL_ASSIGN,
			SPECIAL_SHR_ASSIGN, SPECIAL_AND_ASSIGN,
			SPECIAL_OR_ASSIGN,  SPECIAL_XOR_ASSIGN };
		int i, op = token->special;
		for (i = 0; i < ARRAY_SIZE(assignments); i++)
			if (assignments[i] == op) {
				struct expression * expr = alloc_expression(token->pos, EXPR_ASSIGNMENT);
				struct token *next = token->next;
				expr->left = *tree;
				expr->op = op;
				*tree = expr;
				token = assignment_expression(next, &expr->right);
				if (token == next)
					expression_error(expr, "expression expected before '%s'", show_token(token));
				return token;
			}
	}
	return token;
}

// 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 0x56f40
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x57253
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x12, %eax
jne 0x57253
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq $0xb, %rax
jae 0x57251
movslq -0x1c(%rbp), %rcx
leaq 0x156a3(%rip), %rax     # 0x6c840
movl (%rax,%rcx,4), %eax
cmpl -0x20(%rbp), %eax
jne 0x57241
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x6, %esi
callq 0x55c50
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x20, %rsi
addq $0x8, %rsi
callq 0x57130
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x57237
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44420
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0xd7af(%rip), %rsi      # 0x649df
movb $0x0, %al
callq 0x17030
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5725b
jmp 0x57243
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x57184
jmp 0x57253
movq -0x10(%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/lucvoo[P]sparse-dev/expression.c
// Function: parse_type
static struct token *parse_type(struct token *token, struct expression **tree)
{
	struct symbol *sym;
	*tree = alloc_expression(token->pos, EXPR_TYPE);
	token = typename(token, &sym, NULL);
	if (sym->ident)
		sparse_error(token->pos,
			     "type expression should not include identifier "
			     "\"%s\"", sym->ident->name);
	(*tree)->symbol = sym;
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x4, %esi
callq 0x55c50
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x23160
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x574ec
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rdx
addq $0x12, %rdx
movq (%rax), %rdi
leaq 0x155f6(%rip), %rsi     # 0x6cadb
movb $0x0, %al
callq 0x16f90
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expression.c
// Function: cast_expression
static struct token *cast_expression(struct token *token, struct expression **tree)
{
	if (match_op(token, '(')) {
		struct token *next = token->next;
		if (lookup_type(next)) {
			struct expression *cast = alloc_expression(next->pos, EXPR_CAST);
			struct expression *v;
			struct symbol *sym;
			int is_force;

			token = typename(next, &sym, &is_force);
			cast->cast_type = sym;
			token = expect(token, ')', "at end of cast operator");
			if (match_op(token, '{')) {
				if (toplevel(block_scope))
					sym->ctype.modifiers |= MOD_TOPLEVEL;
				if (is_force)
					warning(sym->pos,
						"[force] in compound literal");
				token = initializer(&cast->cast_expression, token);
				return postfix_expression(token, tree, cast);
			}
			*tree = cast;
			if (is_force)
				cast->type = EXPR_FORCE_CAST;
			token = cast_expression(token, &v);
			if (!v)
				return token;
			cast->cast_expression = v;
			return token;
		}
	}
	return unary_expression(token, tree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x28, %esi
callq 0x55c10
cmpl $0x0, %eax
je 0x580a3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x56ec0
cmpl $0x0, %eax
je 0x580a1
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl $0xb, %esi
callq 0x55c50
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0x23160
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
movl $0x29, %esi
leaq 0x14c60(%rip), %rdx     # 0x6cc1b
callq 0x22eb0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x7b, %esi
callq 0x55c10
cmpl $0x0, %eax
je 0x58047
leaq 0x310ca(%rip), %rax     # 0x890a8
movq (%rax), %rdi
callq 0x580c0
cmpl $0x0, %eax
je 0x57ffb
movq -0x38(%rbp), %rax
movq 0x68(%rax), %rcx
orq $0x10, %rcx
movq %rcx, 0x68(%rax)
cmpl $0x0, -0x3c(%rbp)
je 0x58017
movq -0x38(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x14c23(%rip), %rsi     # 0x6cc33
movb $0x0, %al
callq 0x16d80
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x23980
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x58100
movq %rax, -0x8(%rbp)
jmp 0x580b4
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x0, -0x3c(%rbp)
je 0x58069
movq -0x28(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0xc, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x57f30
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5808b
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x580b4
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x580b4
jmp 0x580a3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x583f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expression.c
// Function: expression_list
static struct token *expression_list(struct token *token, struct expression_list **list)
{
	while (!match_op(token, ')')) {
		struct expression *expr = NULL;
		token = assignment_expression(token, &expr);
		if (!expr)
			break;
		add_expression(list, expr);
		if (!match_op(token, ','))
			break;
		token = token->next;
	}
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x29, %esi
callq 0x55c10
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5875c
jmp 0x587ae
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x57130
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5877e
jmp 0x587ae
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x587c0
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x55c10
cmpl $0x0, %eax
jne 0x587a0
jmp 0x587ae
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x58740
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expression.c
// Function: match_oplist
static int match_oplist(int op, ...)
{
	va_list args;
	int nextop;

	va_start(args, op);
	do {
		nextop = va_arg(args, int);
	} while (nextop != 0 && nextop != op);
	va_end(args);

	return nextop != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
testb %al, %al
je 0x589c8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movl %edi, -0x4(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x20(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0xe4(%rbp)
cmpl $0x28, %eax
ja 0x58a4d
movq -0xf0(%rbp), %rcx
movl -0xe4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xf8(%rbp)
jmp 0x58a6a
movq -0xf0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0xf9(%rbp)
je 0x58a93
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
setne %al
movb %al, -0xf9(%rbp)
movb -0xf9(%rbp), %al
testb $0x1, %al
jne 0x58a12
movl -0x24(%rbp), %eax
testl %eax, %eax
setne %al
movzbl %al, %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: simplify_branch_nodes
static int simplify_branch_nodes(struct entrypoint *ep)
{
	int changed = 0;
	struct basic_block *bb;

	FOR_EACH_PTR(ep->bbs, bb) {
		struct instruction *br = last_instruction(bb->insns);

		if (!br || br->opcode != OP_CBR)
			continue;
		changed |= simplify_one_branch(bb, br);
	} END_FOR_EACH_PTR(bb);
	return changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%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 0x58dbb
jmp 0x58e69
jmp 0x58dbd
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 0x58e51
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 0x58e08
cmpq $0x0, -0x18(%rbp)
jne 0x58e08
jmp 0x58e43
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x5a540
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x58e2e
movq -0x40(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x4, %eax
je 0x58e30
jmp 0x58e43
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x5aed0
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x58dc4
jmp 0x58e53
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x58dbd
movl -0xc(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: convert_instruction_target
void convert_instruction_target(struct instruction *insn, pseudo_t src)
{
	pseudo_t target;
	struct pseudo_user *pu;
	/*
	 * Go through the "insn->users" list and replace them all..
	 */
	target = insn->target;
	if (target == src)
		return;
	FOR_EACH_PTR(target->users, pu) {
		if (*pu->userp != VOID) {
			assert(*pu->userp == target);
			*pu->userp = src;
		}
	} END_FOR_EACH_PTR(pu);
	if (has_use_list(src))
		concat_user_list(target->users, &src->users);
	target->users = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x58eab
jmp 0x58fd2
jmp 0x58ead
movq -0x18(%rbp), %rax
movq 0x8(%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 0x58ed5
jmp 0x58fa3
jmp 0x58ed7
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 0x58f8b
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x58f26
cmpq $0x0, -0x20(%rbp)
jne 0x58f26
jmp 0x58f7d
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0x32e7b(%rip), %rcx     # 0x8bdb0
cmpq %rcx, (%rax)
je 0x58f7b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x58f4d
jmp 0x58f6c
leaq 0x13e1a(%rip), %rdi     # 0x6cd6e
leaq 0x13dca(%rip), %rsi     # 0x6cd25
movl $0x194, %edx            # imm = 0x194
leaq 0x13e1c(%rip), %rcx     # 0x6cd83
callq 0x11120
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
jmp 0x58f7d
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x58ede
jmp 0x58f8d
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x58ed7
movq -0x10(%rbp), %rdi
callq 0x58fe0
cmpl $0x0, %eax
je 0x58fc6
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x59030
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: dominates
int dominates(struct instruction *insn, struct instruction *dom, int local)
{
	switch (dom->opcode) {
	case OP_CALL: case OP_ENTRY:
		return local ? 0 : -1;
	case OP_LOAD: case OP_STORE:
		break;
	case OP_ASM:
		if (dom->clobber_memory)
			return -1;
		if (dom->output_memory)
			return -1;
		return 0;
	default:
		return 0;
	}

	if (dom->src != insn->src) {
		if (local)
			return 0;
		/* We don't think two explicitly different symbols ever alias */
		if (distinct_symbols(insn->src, dom->src))
			return 0;
		/* We could try to do some alias analysis here */
		return -1;
	}
	if (!same_memop(insn, dom)) {
		if (!overlapping_memop(insn, dom))
			return 0;
		return -1;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movl %eax, -0x20(%rbp)
subl $0x1, %eax
je 0x590a7
jmp 0x59086
movl -0x20(%rbp), %eax
addl $-0x43, %eax
subl $0x2, %eax
jb 0x590bf
jmp 0x59093
movl -0x20(%rbp), %eax
subl $0x4a, %eax
je 0x590a7
jmp 0x5909d
movl -0x20(%rbp), %eax
subl $0x4e, %eax
je 0x590c1
jmp 0x59109
movl -0x1c(%rbp), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x5919f
jmp 0x59115
movq -0x18(%rbp), %rax
movb 0x40(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x590de
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5919f
movq -0x18(%rbp), %rax
movb 0x40(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x590fd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5919f
movl $0x0, -0x4(%rbp)
jmp 0x5919f
movl $0x0, -0x4(%rbp)
jmp 0x5919f
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
je 0x59162
cmpl $0x0, -0x1c(%rbp)
je 0x59136
movl $0x0, -0x4(%rbp)
jmp 0x5919f
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x591b0
cmpl $0x0, %eax
je 0x59159
movl $0x0, -0x4(%rbp)
jmp 0x5919f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5919f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x59210
cmpl $0x0, %eax
jne 0x59198
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x59260
cmpl $0x0, %eax
jne 0x5918f
movl $0x0, -0x4(%rbp)
jmp 0x5919f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5919f
movl $0x1, -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/flow.c
// Function: distinct_symbols
static inline int distinct_symbols(pseudo_t a, pseudo_t b)
{
	if (a->type != PSEUDO_SYM)
		return 0;
	if (b->type != PSEUDO_SYM)
		return 0;
	return a->sym != b->sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x5, 0x4(%rax)
je 0x591cf
movl $0x0, -0x4(%rbp)
jmp 0x591fd
movq -0x18(%rbp), %rax
cmpl $0x5, 0x4(%rax)
je 0x591e2
movl $0x0, -0x4(%rbp)
jmp 0x591fd
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: overlapping_memop
static int overlapping_memop(struct instruction *a, struct instruction *b)
{
	unsigned int a_start = bytes_to_bits(a->offset);
	unsigned int b_start = bytes_to_bits(b->offset);
	unsigned int a_size = a->size;
	unsigned int b_size = b->size;

	if (a_size + a_start <= b_start)
		return 0;
	if (b_size + b_start <= a_start)
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl %eax, %edi
callq 0x59420
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl %eax, %edi
callq 0x59420
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
ja 0x592c0
movl $0x0, -0x4(%rbp)
jmp 0x592db
movl -0x28(%rbp), %eax
addl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
ja 0x592d4
movl $0x0, -0x4(%rbp)
jmp 0x592db
movl $0x1, -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/flow.c
// Function: check_access
void check_access(struct instruction *insn)
{
	pseudo_t pseudo = insn->src;

	if (insn->bb && pseudo->type == PSEUDO_SYM) {
		int offset = insn->offset, bit = bytes_to_bits(offset) + insn->size;
		struct symbol *sym = pseudo->sym;

		if (sym->bit_size > 0 && (offset < 0 || bit > sym->bit_size)) {
			if (insn->tainted)
				return;
			warning(insn->pos, "invalid access %s '%s' (%d %d)",
				offset < 0 ? "below" : "past the end of",
				show_ident(sym->ident), offset,
				bits_to_bytes(sym->bit_size));
			insn->tainted = 1;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5940e
movq -0x10(%rbp), %rax
cmpl $0x5, 0x4(%rax)
jne 0x5940e
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x59420
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
shrl $0x8, %ecx
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jle 0x5940c
cmpl $0x0, -0x14(%rbp)
jl 0x59376
movl -0x18(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jle 0x5940c
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x7, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5938c
jmp 0x5940e
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edx
leaq 0x13a4a(%rip), %rax     # 0x6cde8
leaq 0x13a3d(%rip), %rcx     # 0x6cde2
cmpl $0x0, %edx
cmovlq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44150
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl 0x50(%rax), %edi
callq 0x59440
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %r8d
movl %eax, %r9d
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x139d2(%rip), %rsi     # 0x6cdc3
movb $0x0, %al
callq 0x16d80
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
orl $0x80, %ecx
movl %ecx, (%rax)
jmp 0x5940e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: kill_dead_stores
void kill_dead_stores(struct entrypoint *ep, pseudo_t addr, int local)
{
	unsigned long generation;
	struct basic_block *bb;

	switch (pseudo_user_list_size(addr->users)) {
	case 0:
		return;
	case 1:
		if (local) {
			struct pseudo_user *pu = first_user(addr);
			struct instruction *insn = pu->insn;
			if (insn->opcode == OP_STORE) {
				kill_instruction_force(insn);
				return;
			}
		}
	default:
		break;
	}

	generation = ++bb_generation;
	FOR_EACH_PTR(ep->bbs, bb) {
		if (bb->children)
			continue;
		kill_dead_stores_bb(addr, generation, bb, local);
	} END_FOR_EACH_PTR(bb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x595d0
movl %eax, %ecx
movl %ecx, -0x58(%rbp)
testl %eax, %eax
je 0x594b5
jmp 0x594ab
movl -0x58(%rbp), %eax
subl $0x1, %eax
je 0x594ba
jmp 0x594f8
jmp 0x595c9
cmpl $0x0, -0x14(%rbp)
je 0x594f6
movq -0x10(%rbp), %rdi
callq 0x595f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x44, %eax
jne 0x594f4
movq -0x38(%rbp), %rdi
callq 0x596b0
jmp 0x595c9
jmp 0x594f6
jmp 0x594f8
jmp 0x594fa
movq 0x5ce57(%rip), %rax     # 0xb6358
addq $0x1, %rax
movq %rax, 0x5ce4c(%rip)     # 0xb6358
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%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 0x59538
jmp 0x595c9
jmp 0x5953a
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 0x595b1
movq -0x48(%rbp), %rax
movslq -0x54(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x59585
cmpq $0x0, -0x28(%rbp)
jne 0x59585
jmp 0x595a6
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x59592
jmp 0x595a6
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0x596d0
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x59541
jmp 0x595b3
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq -0x40(%rbp), %rax
jne 0x5953a
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: first_user
static struct pseudo_user *first_user(pseudo_t p)
{
	struct pseudo_user *pu;
	FOR_EACH_PTR(p->users, pu) {
		if (!pu)
			continue;
		return pu;
	} END_FOR_EACH_PTR(pu);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%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 0x5961d
jmp 0x5969c
jmp 0x5961f
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 0x59688
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 0x5966a
cmpq $0x0, -0x18(%rbp)
jne 0x5966a
jmp 0x5967d
cmpq $0x0, -0x18(%rbp)
jne 0x59673
jmp 0x5967d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x596a4
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x59626
jmp 0x5968a
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x5961f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: kill_defs
static void kill_defs(struct instruction *insn)
{
	pseudo_t target = insn->target;

	if (!has_use_list(target))
		return;
	if (target->def != insn)
		return;

	convert_instruction_target(insn, VOID);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x58fe0
cmpl $0x0, %eax
jne 0x59b68
jmp 0x59b88
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0x59b78
jmp 0x59b88
movq -0x8(%rbp), %rdi
leaq 0x3222d(%rip), %rsi     # 0x8bdb0
callq 0x58e80
addq $0x10, %rsp
popq %rbp
retq
nop