LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/dominate.c
// Function: idf_dump
void idf_dump(struct entrypoint *ep)
{
	struct basic_block *bb;

	domtree_build(ep);

	printf("%s's IDF:\n", show_ident(ep->name->ident));
	FOR_EACH_PTR(ep->bbs, bb) {
		struct basic_block_list *alpha = NULL;
		struct basic_block_list *idf = NULL;
		struct basic_block *df;

		add_bb(&alpha, bb);
		idf_compute(ep, &idf, alpha);

		printf("\t%s\t<-", show_label(bb));
		FOR_EACH_PTR(idf, df) {
			printf(" %s", show_label(df));
		} END_FOR_EACH_PTR(df);
		printf("\n");

		free_ptr_list(&idf);
		free_ptr_list(&alpha);
	} END_FOR_EACH_PTR(bb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5c640
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdi
callq 0x44150
movq %rax, %rsi
leaq 0x20ac5(%rip), %rdi     # 0x6b5e4
movb $0x0, %al
callq 0x110f0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4ab4e
jmp 0x4ace2
jmp 0x4ab50
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x4acca
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x4aba2
cmpq $0x0, -0x10(%rbp)
jne 0x4aba2
jmp 0x4acbc
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x4acf0
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq -0x40(%rbp), %rsi
callq 0x4a560
movq -0x10(%rbp), %rdi
callq 0x17e00
movq %rax, %rsi
leaq 0x20a0c(%rip), %rdi     # 0x6b5ef
movb $0x0, %al
callq 0x110f0
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x4ac0e
jmp 0x4ac98
jmp 0x4ac10
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
movq -0x58(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x4ac80
movq -0x58(%rbp), %rax
movslq -0x64(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
movq -0x58(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x4ac5b
cmpq $0x0, -0x48(%rbp)
jne 0x4ac5b
jmp 0x4ac75
movq -0x48(%rbp), %rdi
callq 0x17e00
movq %rax, %rsi
leaq 0x1f7f7(%rip), %rdi     # 0x6a465
movb $0x0, %al
callq 0x110f0
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x4ac17
jmp 0x4ac82
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq -0x50(%rbp), %rax
jne 0x4ac10
leaq 0x1d394(%rip), %rdi     # 0x68033
movb $0x0, %al
callq 0x110f0
leaq -0x40(%rbp), %rdi
callq 0x31cd0
jmp 0x4acb1
leaq -0x38(%rbp), %rdi
callq 0x31cd0
jmp 0x4acbc
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4ab57
jmp 0x4accc
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x4ab50
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: classify_type
static inline int classify_type(struct symbol *type, struct symbol **base)
{
	static int type_class[SYM_BAD + 1] = {
		[SYM_PTR] = TYPE_PTR,
		[SYM_FN] = TYPE_PTR | TYPE_FN,
		[SYM_ARRAY] = TYPE_PTR | TYPE_COMPOUND,
		[SYM_STRUCT] = TYPE_COMPOUND,
		[SYM_UNION] = TYPE_COMPOUND,
		[SYM_BITFIELD] = TYPE_NUM | TYPE_BITFIELD,
		[SYM_RESTRICT] = TYPE_NUM | TYPE_RESTRICT,
		[SYM_FOULED] = TYPE_NUM | TYPE_RESTRICT | TYPE_FOULED,
	};
	if (type->type == SYM_NODE)
		type = type->ctype.base_type;
	if (type->type == SYM_TYPEOF) {
		type = examine_symbol_type(type);
		if (type->type == SYM_NODE)
			type = type->ctype.base_type;
	}
	if (type->type == SYM_ENUM)
		type = type->ctype.base_type;
	*base = type;
	if (type->type == SYM_BASETYPE) {
		if (type->ctype.base_type == &int_type)
			return TYPE_NUM;
		if (type->ctype.base_type == &fp_type)
			return TYPE_NUM | TYPE_FLOAT;
	}
	return type_class[type->type];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x4bf4c
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0xa, %eax
jne 0x4bf87
movq -0x10(%rbp), %rdi
callq 0x3f650
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x4bf85
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4bf87
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x9, %eax
jne 0x4bfa3
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x2, %eax
jne 0x4bff4
movq -0x10(%rbp), %rax
leaq 0x4528f(%rip), %rcx     # 0x91258
cmpq %rcx, 0x60(%rax)
jne 0x4bfd8
movl $0x1, -0x4(%rbp)
jmp 0x4c010
movq -0x10(%rbp), %rax
leaq 0x45355(%rip), %rcx     # 0x91338
cmpq %rcx, 0x60(%rax)
jne 0x4bff2
movl $0x9, -0x4(%rbp)
jmp 0x4c010
jmp 0x4bff4
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x3f6e6(%rip), %rax     # 0x8b6f0
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: cast_to
static struct expression * cast_to(struct expression *old, struct symbol *type)
{
	struct expression *expr;

	warn_for_different_enum_types (old->pos, old->ctype, type);

	if (old->ctype != &null_ctype && is_same_type(old, type))
		return old;

	expr = alloc_expression(old->pos, EXPR_IMPLIED_CAST);
	expr->ctype = type;
	expr->cast_type = type;
	expr->cast_expression = old;
	expr->flags = cast_flags(expr, old);

	if (is_bool_type(type))
		cast_to_bool(expr);

	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq -0x18(%rbp), %rdx
movq 0x8(%rax), %rdi
callq 0x508b0
movq -0x10(%rbp), %rax
leaq 0x46d24(%rip), %rcx     # 0x92d78
cmpq %rcx, 0x10(%rax)
je 0x4c079
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x50990
cmpl $0x0, %eax
je 0x4c079
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4c0fa
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0xd, %esi
callq 0x50ab0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x50b10
movl %eax, %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0xff, %edx
shll $0x8, %edx
andl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x50bf0
cmpl $0x0, %eax
je 0x4c0f2
movq -0x20(%rbp), %rdi
callq 0x50c30
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: integer_promotion
static inline struct symbol *integer_promotion(struct symbol *type)
{
	unsigned long mod =  type->ctype.modifiers;
	int width = type->bit_size;

	/*
	 * Bitfields always promote to the base type,
	 * even if the bitfield might be bigger than
	 * an "int".
	 */
	if (type->type == SYM_BITFIELD) {
		type = type->ctype.base_type;
	}
	mod = type->ctype.modifiers;
	if (width < bits_in_int)
		return &int_ctype;

	/* If char/short has as many bits as int, it still gets "promoted" */
	if (type->rank < 0) {
		if (mod & MOD_UNSIGNED)
			return &uint_ctype;
		return &int_ctype;
	}
	return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0xb, %eax
jne 0x4c14a
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
leaq 0x3e578(%rip), %rcx     # 0x8a6d8
cmpl (%rcx), %eax
jge 0x4c171
leaq 0x459ad(%rip), %rax     # 0x91b18
movq %rax, -0x8(%rbp)
jmp 0x4c1b5
movq -0x10(%rbp), %rax
movl 0x54(%rax), %eax
shll $0x6, %eax
sarl $0x1d, %eax
cmpl $0x0, %eax
jge 0x4c1ad
movq -0x18(%rbp), %rax
andq $0x4000, %rax           # imm = 0x4000
cmpq $0x0, %rax
je 0x4c1a0
leaq 0x45b3e(%rip), %rax     # 0x91cd8
movq %rax, -0x8(%rbp)
jmp 0x4c1b5
leaq 0x45971(%rip), %rax     # 0x91b18
movq %rax, -0x8(%rbp)
jmp 0x4c1b5
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_symbol_expression
static struct symbol *evaluate_symbol_expression(struct expression *expr)
{
	struct expression *addr;
	struct symbol *sym = expr->symbol;
	struct symbol *base_type;

	if (!sym) {
		expression_error(expr, "undefined identifier '%s'", show_ident(expr->symbol_name));
		return NULL;
	}

	examine_symbol_type(sym);

	base_type = get_base_type(sym);
	if (!base_type) {
		expression_error(expr, "identifier '%s' has no type", show_ident(expr->symbol_name));
		return NULL;
	}

	addr = alloc_expression(expr->pos, EXPR_SYMBOL);
	addr->symbol = sym;
	addr->symbol_name = expr->symbol_name;
	addr->ctype = &lazy_ptr_ctype;	/* Lazy evaluation: we need to do a proper job if somebody does &sym */
	addr->flags = expr->flags;
	expr->type = EXPR_PREOP;
	expr->op = '*';
	expr->unop = addr;
	expr->flags = CEF_NONE;

	/* The type of a symbol is the symbol itself! */
	expr->ctype = sym;
	return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4c846
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x44150
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x1f479(%rip), %rsi     # 0x6bcab
movb $0x0, %al
callq 0x17030
movq $0x0, -0x8(%rbp)
jmp 0x4c950
movq -0x20(%rbp), %rdi
callq 0x3f650
movq -0x20(%rbp), %rdi
callq 0x51e40
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4c89a
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x44150
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x1f43f(%rip), %rsi     # 0x6bcc5
movb $0x0, %al
callq 0x17030
movq $0x0, -0x8(%rbp)
jmp 0x4c950
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x3, %esi
callq 0x50ab0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
leaq 0x46121(%rip), %rcx     # 0x929f8
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %edx
shrl $0x8, %edx
andl $0xff, %edx
movq -0x18(%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), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x9, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl $0x2a, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
orl $0x0, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_logical
static struct symbol *evaluate_logical(struct expression *expr)
{
	if (!evaluate_conditional(expr->left, 0))
		return NULL;
	if (!evaluate_conditional(expr->right, 0))
		return NULL;

	/* the result is int [6.5.13(3), 6.5.14(3)] */
	expr->ctype = &int_ctype;
	expr->flags = expr->left->flags & expr->right->flags;
	expr->flags &= ~(CEF_CONST_MASK | CEF_ADDR);
	return &int_ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
xorl %esi, %esi
callq 0x526c0
cmpq $0x0, %rax
jne 0x4cd8e
movq $0x0, -0x8(%rbp)
jmp 0x4ce31
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
xorl %esi, %esi
callq 0x526c0
cmpq $0x0, %rax
jne 0x4cdb0
movq $0x0, -0x8(%rbp)
jmp 0x4ce31
movq -0x10(%rbp), %rax
leaq 0x44d5d(%rip), %rcx     # 0x91b18
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl (%rax), %edx
shrl $0x8, %edx
andl $0xff, %edx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0xff, %eax
andl %eax, %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), %edx
shrl $0x8, %edx
andl $0xff, %edx
andl $-0x4c, %edx
movl (%rax), %ecx
andl $0xff, %edx
shll $0x8, %edx
andl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
orl %edx, %ecx
movl %ecx, (%rax)
leaq 0x44ceb(%rip), %rax     # 0x91b18
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_comma
static struct symbol *evaluate_comma(struct expression *expr)
{
	expr->ctype = unqualify_type(degenerate(expr->right));
	if (expr->ctype == &null_ctype)
		expr->ctype = &ptr_ctype;
	expr->flags &= expr->left->flags & expr->right->flags;
	return expr->ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x4c1c0
movq %rax, %rdi
callq 0x50150
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
leaq 0x45f01(%rip), %rcx     # 0x92d78
cmpq %rcx, 0x10(%rax)
jne 0x4ce8c
movq -0x8(%rbp), %rax
leaq 0x45a90(%rip), %rcx     # 0x92918
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl (%rax), %ecx
shrl $0x8, %ecx
andl $0xff, %ecx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0xff, %eax
andl %eax, %ecx
movq -0x8(%rbp), %rax
movl (%rax), %edx
shrl $0x8, %edx
andl $0xff, %edx
andl %ecx, %edx
movl (%rax), %ecx
andl $0xff, %edx
shll $0x8, %edx
andl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_assignment
static struct symbol *evaluate_assignment(struct expression *expr)
{
	struct expression *left = expr->left;
	struct symbol *ltype;

	if (!lvalue_expression(left)) {
		expression_error(expr, "not an lvalue");
		return NULL;
	}

	ltype = left->ctype;

	if (expr->op != '=') {
		if (!evaluate_assign_op(expr))
			return NULL;
	} else {
		if (!compatible_assignment_types(expr, ltype, &expr->right, "assignment"))
			return NULL;
	}

	evaluate_assign_to(left, ltype);

	expr->ctype = ltype;
	return ltype;
}

// 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), %rdi
callq 0x52a10
cmpl $0x0, %eax
jne 0x4d3e5
movq -0x10(%rbp), %rdi
leaq 0x1f348(%rip), %rsi     # 0x6c719
movb $0x0, %al
callq 0x17030
movq $0x0, -0x8(%rbp)
jmp 0x4d467
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3d, 0x4(%rax)
je 0x4d415
movq -0x10(%rbp), %rdi
callq 0x52a50
cmpl $0x0, %eax
jne 0x4d413
movq $0x0, -0x8(%rbp)
jmp 0x4d467
jmp 0x4d446
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x20, %rdx
addq $0x8, %rdx
leaq 0x1eacf(%rip), %rcx     # 0x6beff
callq 0x51790
cmpl $0x0, %eax
jne 0x4d444
movq $0x0, -0x8(%rbp)
jmp 0x4d467
jmp 0x4d446
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x52e10
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_postop
static struct symbol *evaluate_postop(struct expression *expr)
{
	struct expression *op = expr->unop;
	struct symbol *ctype = op->ctype;
	int class = classify_type(ctype, &ctype);
	int multiply = 0;

	if (!class || class & TYPE_COMPOUND) {
		expression_error(expr, "need scalar for ++/--");
		return NULL;
	}
	if (!lvalue_expression(expr->unop)) {
		expression_error(expr, "need lvalue expression for ++/--");
		return NULL;
	}

	unrestrict(expr, class, &ctype);

	if (class & TYPE_NUM) {
		multiply = 1;
	} else if (class == TYPE_PTR) {
		struct symbol *target = examine_pointer_target(ctype);
		if (!is_function(target))
			multiply = bits_to_bytes(target->bit_size);
	}

	if (multiply) {
		evaluate_assign_to(op, op->ctype);
		expr->op_value = multiply;
		expr->ctype = ctype;
		return ctype;
	}

	expression_error(expr, "bad argument type for ++/--");
	return NULL;
}

// 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
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4bf20
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x4d73c
movl -0x24(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x4d75b
movq -0x10(%rbp), %rdi
leaq 0x1e8a1(%rip), %rsi     # 0x6bfe8
movb $0x0, %al
callq 0x17030
movq $0x0, -0x8(%rbp)
jmp 0x4d837
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x52a10
cmpl $0x0, %eax
jne 0x4d78c
movq -0x10(%rbp), %rdi
leaq 0x1e886(%rip), %rsi     # 0x6bffe
movb $0x0, %al
callq 0x17030
movq $0x0, -0x8(%rbp)
jmp 0x4d837
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
leaq -0x20(%rbp), %rdx
callq 0x51240
movl -0x24(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4d7b0
movl $0x1, -0x28(%rbp)
jmp 0x4d7e4
cmpl $0x10, -0x24(%rbp)
jne 0x4d7e2
movq -0x20(%rbp), %rdi
callq 0x40260
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x525f0
cmpl $0x0, %eax
jne 0x4d7e0
movq -0x30(%rbp), %rax
movl 0x50(%rax), %edi
callq 0x513e0
movl %eax, -0x28(%rbp)
jmp 0x4d7e2
jmp 0x4d7e4
cmpl $0x0, -0x28(%rbp)
je 0x4d81d
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x52e10
movslq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4d837
movq -0x10(%rbp), %rdi
leaq 0x1e7f7(%rip), %rsi     # 0x6c01f
movb $0x0, %al
callq 0x17030
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_ptrsizeof
static struct symbol *evaluate_ptrsizeof(struct expression *expr)
{
	struct symbol *type;
	int size;

	type = evaluate_type_information(expr);
	if (!type)
		return NULL;

	if (type->type == SYM_NODE)
		type = type->ctype.base_type;
	if (!type)
		return NULL;
	switch (type->type) {
	case SYM_ARRAY:
		break;
	case SYM_PTR:
		type = get_base_type(type);
		if (type)
			break;
	default:
		expression_error(expr, "expected pointer expression");
		return NULL;
	}
	size = type->bit_size;
	if (size & (bits_in_char-1))
		size = 0;
	expr->type = EXPR_VALUE;
	expr->value = bits_to_bytes(size);
	expr->taint = 0;
	expr->ctype = size_t_ctype;
	return size_t_ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x536e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4e27d
movq $0x0, -0x8(%rbp)
jmp 0x4e374
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x4e299
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4e2ad
movq $0x0, -0x8(%rbp)
jmp 0x4e374
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x20(%rbp)
subl $0x4, %eax
je 0x4e2ca
jmp 0x4e2be
movl -0x20(%rbp), %eax
subl $0x6, %eax
jne 0x4e2e2
jmp 0x4e2c8
jmp 0x4e2fe
movq -0x18(%rbp), %rdi
callq 0x51e40
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4e2e0
jmp 0x4e2fe
jmp 0x4e2e2
movq -0x10(%rbp), %rdi
leaq 0x1def6(%rip), %rsi     # 0x6c1e3
movb $0x0, %al
callq 0x17030
movq $0x0, -0x8(%rbp)
jmp 0x4e374
movq -0x18(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0x3c3be(%rip), %rcx     # 0x8a6d0
movl (%rcx), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x4e325
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x1, %ecx
movl %ecx, (%rax)
movl -0x1c(%rbp), %edi
callq 0x513e0
movslq %eax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
leaq 0x3c295(%rip), %rax     # 0x8a5f0
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq 0x3c283(%rip), %rax     # 0x8a5f0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_alignof
static struct symbol *evaluate_alignof(struct expression *expr)
{
	struct symbol *type;

	type = evaluate_type_information(expr);
	if (!type)
		return NULL;

	expr->type = EXPR_VALUE;
	expr->value = type->ctype.alignment;
	expr->taint = 0;
	expr->ctype = size_t_ctype;
	return size_t_ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x536e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4e3aa
movq $0x0, -0x8(%rbp)
jmp 0x4e3f6
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
leaq 0x3c213(%rip), %rax     # 0x8a5f0
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq 0x3c201(%rip), %rax     # 0x8a5f0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: check_label_declaration
static void check_label_declaration(struct position pos, struct symbol *label)
{
	switch (label->namespace) {
	case NS_LABEL:
		if (label->stmt)
			break;
		sparse_error(pos, "label '%s' was not declared", show_ident(label->ident));
		/* fallthrough */
	case NS_NONE:
		current_fn->bogus_linear = 1;
	default:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0x1ff, %eax            # imm = 0x1FF
movl %eax, -0x14(%rbp)
je 0x4f461
jmp 0x4f425
movl -0x14(%rbp), %eax
subl $0x8, %eax
jne 0x4f47a
jmp 0x4f42f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x4f43f
jmp 0x4f47c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44150
movq %rax, %rdx
movq -0x8(%rbp), %rdi
leaq 0x1ceaa(%rip), %rsi     # 0x6c304
movb $0x0, %al
callq 0x16f90
movq 0x66ee8(%rip), %rax     # 0xb6350
movl 0x54(%rax), %ecx
andl $0xfffffeff, %ecx       # imm = 0xFFFFFEFF
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x54(%rax)
jmp 0x4f47c
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_symbol
static struct symbol *evaluate_symbol(struct symbol *sym)
{
	struct symbol *base_type;

	if (!sym)
		return sym;
	if (sym->evaluated)
		return sym;
	sym->evaluated = 1;

	sym = examine_symbol_type(sym);
	base_type = get_base_type(sym);
	if (!base_type)
		return NULL;

	/* Evaluate the initializers */
	if (sym->initializer)
		evaluate_initializer(sym, &sym->initializer);

	/* And finally, evaluate the body of the symbol too */
	if (base_type->type == SYM_FN) {
		struct symbol *curr = current_fn;

		if (sym->definition && sym->definition != sym)
			return evaluate_symbol(sym->definition);

		current_fn = sym;

		examine_fn_arguments(base_type);
		if (!base_type->stmt && base_type->inline_stmt && sym->definition)
			uninline(sym);
		if (base_type->stmt)
			evaluate_statement(base_type->stmt);

		current_fn = curr;
	}

	return base_type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4f4b0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4f602
movq -0x10(%rbp), %rax
movl 0x54(%rax), %eax
shrl $0xd, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4f4cf
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4f602
movq -0x10(%rbp), %rax
movl 0x54(%rax), %ecx
andl $0xffffdfff, %ecx       # imm = 0xFFFFDFFF
orl $0x2000, %ecx           # imm = 0x2000
movl %ecx, 0x54(%rax)
movq -0x10(%rbp), %rdi
callq 0x3f650
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x51e40
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4f513
movq $0x0, -0x8(%rbp)
jmp 0x4f602
movq -0x10(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
je 0x4f536
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
addq $0x68, %rsi
callq 0x53cd0
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x5, %eax
jne 0x4f5fa
movq 0x66dff(%rip), %rax     # 0xb6350
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x4f58a
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x4f58a
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rdi
callq 0x4f490
movq %rax, -0x8(%rbp)
jmp 0x4f602
movq -0x10(%rbp), %rax
movq %rax, 0x66dbb(%rip)     # 0xb6350
movq -0x18(%rbp), %rdi
callq 0x4b650
movq -0x18(%rbp), %rax
cmpq $0x0, 0x90(%rax)
jne 0x4f5d1
movq -0x18(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x4f5d1
movq -0x10(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x4f5d1
movq -0x10(%rbp), %rdi
callq 0x156a0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x4f5ef
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x4f0b0
movq -0x20(%rbp), %rax
movq %rax, 0x66d56(%rip)     # 0xb6350
movq -0x18(%rbp), %rax
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/evaluate.c
// Function: evaluate_symbol_list
void evaluate_symbol_list(struct symbol_list *list)
{
	struct symbol *sym;

	FOR_EACH_PTR(list, sym) {
		has_error &= ~ERROR_CURR_PHASE;
		evaluate_symbol(sym);
		check_duplicates(sym);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4ff60
jmp 0x4fff7
jmp 0x4ff62
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x4ffdf
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x4ffad
cmpq $0x0, -0x10(%rbp)
jne 0x4ffad
jmp 0x4ffd4
leaq 0x3d1b0(%rip), %rax     # 0x8d164
movl (%rax), %ecx
andl $-0x2, %ecx
leaq 0x3d1a4(%rip), %rax     # 0x8d164
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x4f490
movq -0x10(%rbp), %rdi
callq 0x4fcf0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4ff69
jmp 0x4ffe1
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x4ff62
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_return_expression
static struct symbol *evaluate_return_expression(struct statement *stmt)
{
	struct expression *expr = stmt->expression;
	struct symbol *fntype, *rettype;

	evaluate_expression(expr);
	fntype = current_fn->ctype.base_type;
	rettype = fntype->ctype.base_type;
	if (!rettype || rettype == &void_ctype) {
		if (expr && expr->ctype && !is_void_type(expr->ctype))
			expression_error(expr, "return expression in %s function", rettype?"void":"typeless");
		if (expr && Wreturn_void)
			warning(stmt->pos, "returning void-valued expression");
		return NULL;
	}

	if (!expr) {
		sparse_error(stmt->pos, "return with no return value");
		return NULL;
	}
	if (!expr->ctype)
		return NULL;
	compatible_assignment_types(expr, rettype, &stmt->expression, "return expression");
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4bb70
movq 0x66328(%rip), %rax     # 0xb6350
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x50054
leaq 0x414ae(%rip), %rax     # 0x914f8
cmpq %rax, -0x28(%rbp)
jne 0x500d7
cmpq $0x0, -0x18(%rbp)
je 0x500a4
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x500a4
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x52630
cmpl $0x0, %eax
jne 0x500a4
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rcx
leaq 0x1c604(%rip), %rdx     # 0x6c68b
leaq 0x146c8(%rip), %rax     # 0x64756
cmpq $0x0, %rcx
cmovneq %rax, %rdx
leaq 0x1c5cd(%rip), %rsi     # 0x6c66a
movb $0x0, %al
callq 0x17030
cmpq $0x0, -0x18(%rbp)
je 0x500cd
leaq 0x3d15a(%rip), %rax     # 0x8d20c
cmpl $0x0, (%rax)
je 0x500cd
movq -0x10(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x1c5ce(%rip), %rsi     # 0x6c694
movb $0x0, %al
callq 0x16d80
movq $0x0, -0x8(%rbp)
jmp 0x50137
cmpq $0x0, -0x18(%rbp)
jne 0x500fe
movq -0x10(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x1c5c8(%rip), %rsi     # 0x6c6b5
movb $0x0, %al
callq 0x16f90
movq $0x0, -0x8(%rbp)
jmp 0x50137
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x50113
movq $0x0, -0x8(%rbp)
jmp 0x50137
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x10, %rdx
leaq 0x1c5a7(%rip), %rcx     # 0x6c6d1
callq 0x51790
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: unqualify_type
static struct symbol *unqualify_type(struct symbol *ctype)
{
	if (!ctype)
		return ctype;
	if (ctype->type == SYM_NODE && (ctype->ctype.modifiers & MOD_QUALIFIER)) {
		struct symbol *unqual = alloc_symbol(ctype->pos, 0);

		*unqual = *ctype;
		unqual->ctype.modifiers &= ~MOD_QUALIFIER;
		return unqual;
	}
	return ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5016d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x501db
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x501d3
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
andq $0xe00, %rax            # imm = 0xE00
cmpq $0x0, %rax
je 0x501d3
movq -0x10(%rbp), %rax
movq 0x4(%rax), %rdi
xorl %esi, %esi
callq 0x3f4d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xe0, %edx
callq 0x111d0
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rcx
andq $-0xe01, %rcx           # imm = 0xF1FF
movq %rcx, 0x68(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x501db
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_if_statement
static void evaluate_if_statement(struct statement *stmt)
{
	if (!stmt->if_conditional)
		return;

	evaluate_conditional(stmt->if_conditional, 0);
	evaluate_statement(stmt->if_true);
	evaluate_statement(stmt->if_false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x50209
jmp 0x50232
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %esi, %esi
callq 0x526c0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4f0b0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x4f0b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_iterator
static void evaluate_iterator(struct statement *stmt)
{
	evaluate_symbol_list(stmt->iterator_syms);
	evaluate_conditional(stmt->iterator_pre_condition, 1);
	evaluate_conditional(stmt->iterator_post_condition,1);
	evaluate_statement(stmt->iterator_pre_statement);
	evaluate_statement(stmt->iterator_statement);
	evaluate_statement(stmt->iterator_post_statement);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x4ff30
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl $0x1, %esi
callq 0x526c0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movl $0x1, %esi
callq 0x526c0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x4f0b0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x4f0b0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x4f0b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_switch_statement
static void evaluate_switch_statement(struct statement *stmt)
{
	struct symbol *sym;
	struct expression *enumcase = NULL;
	struct expression **enumcase_holder = &enumcase;
	struct expression *sel = stmt->switch_expression;

	evaluate_expression(sel);
	evaluate_statement(stmt->switch_statement);
	if (!sel)
		return;
	if (sel->ctype && is_enum_type(sel->ctype))
		enumcase_holder = NULL; /* Only check cases against switch */

	FOR_EACH_PTR(stmt->switch_case->symbol_list, sym) {
		struct statement *case_stmt = sym->stmt;
		check_case_type(sel, case_stmt->case_expression, enumcase_holder);
		check_case_type(sel, case_stmt->case_to, enumcase_holder);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4bb70
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4f0b0
cmpq $0x0, -0x28(%rbp)
jne 0x502fa
jmp 0x503fc
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5031f
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x55550
cmpl $0x0, %eax
je 0x5031f
movq $0x0, -0x20(%rbp)
jmp 0x50321
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x98(%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 0x50350
jmp 0x503fc
jmp 0x50352
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 0x503e4
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x5039d
cmpq $0x0, -0x10(%rbp)
jne 0x5039d
jmp 0x503d6
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x55590
movq -0x28(%rbp), %rdi
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x55590
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x50359
jmp 0x503e6
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x50352
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_goto_statement
static void evaluate_goto_statement(struct statement *stmt)
{
	struct symbol *label = stmt->goto_label;

	if (!label) {
		// no label associated, may be a computed goto
		evaluate_expression(stmt->goto_expression);
		return;
	}

	check_label_declaration(stmt->pos, label);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5047e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4bb70
jmp 0x5048f
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rsi
movq 0x4(%rax), %rdi
callq 0x4f400
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: warn_for_different_enum_types
static void
warn_for_different_enum_types (struct position pos,
			       struct symbol *typea,
			       struct symbol *typeb)
{
	if (!Wenum_mismatch)
		return;
	if (typea->type == SYM_NODE)
		typea = typea->ctype.base_type;
	if (typeb->type == SYM_NODE)
		typeb = typeb->ctype.base_type;

	if (typea == typeb)
		return;

	if (typea->type == SYM_ENUM && typeb->type == SYM_ENUM) {
		warning(pos, "mixing different enum types:");
		info(pos, "   %s", show_typename(typea));
		info(pos, "   %s", show_typename(typeb));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x33f59(%rip), %rax     # 0x84824
cmpl $0x0, (%rax)
jne 0x508d5
jmp 0x50987
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x508f1
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x5090d
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x50919
jmp 0x50987
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x9, %eax
jne 0x50987
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x9, %eax
jne 0x50987
movq -0x8(%rbp), %rdi
leaq 0x1b22d(%rip), %rsi     # 0x6bb71
movb $0x0, %al
callq 0x16d80
movq -0x10(%rbp), %rdi
callq 0x33340
movq %rax, %rdx
movq -0x8(%rbp), %rdi
leaq 0x19b01(%rip), %rsi     # 0x6a463
movb $0x0, %al
callq 0x16c10
movq -0x18(%rbp), %rdi
callq 0x33340
movq %rax, %rdx
movq -0x8(%rbp), %rdi
leaq 0x19ae3(%rip), %rsi     # 0x6a463
movb $0x0, %al
callq 0x16c10
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: is_same_type
static int is_same_type(struct expression *expr, struct symbol *new)
{
	struct symbol *old = expr->ctype;
	unsigned long oldmod, newmod;
	struct ident *oldas, *newas;

	old = base_type(old, &oldmod, &oldas);
	new = base_type(new, &newmod, &newas);

	/* Same base type, same address space? */
	if (old == new && oldas == newas) {
		unsigned long difmod;

		/* Check the modifier bits. */
		difmod = (oldmod ^ newmod) & ~MOD_NOCAST;

		/* Exact same type? */
		if (!difmod)
			return 1;

		/*
		 * Not the same type, but differs only in "const".
		 * Don't warn about MOD_NOCAST.
		 */
		if (difmod == MOD_CONST)
			return 0;
	}
	if ((oldmod | newmod) & MOD_NOCAST) {
		const char *tofrom = "to/from";
		if (!(newmod & MOD_NOCAST))
			tofrom = "from";
		if (!(oldmod & MOD_NOCAST))
			tofrom = "to";
		warning(expr->pos, "implicit cast %s nocast type", tofrom);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x50d40
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x50d40
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x50a24
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jne 0x50a24
movq -0x28(%rbp), %rax
xorq -0x30(%rbp), %rax
andq $-0x4000001, %rax       # imm = 0xFBFFFFFF
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x50a0f
movl $0x1, -0x4(%rbp)
jmp 0x50a9a
cmpq $0x200, -0x48(%rbp)     # imm = 0x200
jne 0x50a22
movl $0x0, -0x4(%rbp)
jmp 0x50a9a
jmp 0x50a24
movq -0x28(%rbp), %rax
orq -0x30(%rbp), %rax
andq $0x4000000, %rax        # imm = 0x4000000
cmpq $0x0, %rax
je 0x50a93
leaq 0x1b14f(%rip), %rax     # 0x6bb8e
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
andq $0x4000000, %rax        # imm = 0x4000000
cmpq $0x0, %rax
jne 0x50a5e
leaq 0x12c4c(%rip), %rax     # 0x636a6
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
andq $0x4000000, %rax        # imm = 0x4000000
cmpq $0x0, %rax
jne 0x50a79
leaq 0x1452c(%rip), %rax     # 0x64fa1
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq -0x50(%rbp), %rdx
movq 0x8(%rax), %rdi
leaq 0x1b10a(%rip), %rsi     # 0x6bb96
movb $0x0, %al
callq 0x16d80
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: cast_flags
static int cast_flags(struct expression *expr, struct expression *old)
{
	struct symbol *t;
	int class;
	int flags = CEF_NONE;

	class = classify_type(expr->ctype, &t);
	if (class & TYPE_NUM) {
		flags = old->flags & ~CEF_CONST_MASK;
		/*
		 * Casts to numeric types never result in address
		 * constants [6.6(9)].
		 */
		flags &= ~CEF_ADDR;

		/*
		 * As an extension, treat address constants cast to
		 * integer type as an arithmetic constant.
		 */
		if (old->flags & CEF_ADDR)
			flags = CEF_ACE;

		/*
		 * Cast to float type -> not an integer constant
		 * expression [6.6(6)].
		 */
		if (class & TYPE_FLOAT)
			flags &= ~CEF_CLR_ICE;
		/*
		 * Casts of float literals to integer type results in
		 * a constant integer expression [6.6(6)].
		 */
		else if (old->flags & CEF_FLOAT)
			flags = CEF_SET_ICE;
	} else if (class & TYPE_PTR) {
		/*
		 * Casts of integer literals to pointer type yield
		 * address constants [6.6(9)].
		 *
		 * As an extension, treat address constants cast to a
		 * different pointer type as address constants again.
		 *
		 * As another extension, treat integer constant
		 * expressions (in contrast to literals) cast to
		 * pointer type as address constants.
		 */
		if (old->flags & (CEF_ICE | CEF_ADDR))
			flags = CEF_ADDR;
	}

	return flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4bf20
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x50bb7
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0xff, %eax
andl $-0xc, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
andl $-0x41, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0xff, %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x50b80
movl $0x20, -0x20(%rbp)
movl -0x1c(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x50b96
movl -0x20(%rbp), %eax
andl $-0x1e, %eax
movl %eax, -0x20(%rbp)
jmp 0x50bb5
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0xff, %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x50bb3
movl $0x30, -0x20(%rbp)
jmp 0x50bb5
jmp 0x50be3
movl -0x1c(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x50be1
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0xff, %eax
andl $0x50, %eax
cmpl $0x0, %eax
je 0x50bdf
movl $0x40, -0x20(%rbp)
jmp 0x50be1
jmp 0x50be3
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: cast_to_bool
static struct symbol *cast_to_bool(struct expression *expr)
{
	struct expression *old = expr->cast_expression;
	struct expression *zero;
	struct symbol *otype;
	int oclass = classify_type(degenerate(old), &otype);
	struct symbol *ctype;

	if (oclass & TYPE_COMPOUND)
		return NULL;

	zero = alloc_const_expression(expr->pos, 0);
	if (oclass & TYPE_PTR)
		zero->ctype = otype;
	expr->op = SPECIAL_NOTEQUAL;
	ctype = usual_conversions(expr->op, old, zero,
			oclass, TYPE_NUM, otype, zero->ctype);
	expr->type = EXPR_COMPARE;
	expr->left = cast_to(old, ctype);
	expr->right = cast_to(zero, ctype);

	return expr->ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4c1c0
movq %rax, %rdi
leaq -0x28(%rbp), %rsi
callq 0x4bf20
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x50c78
movq $0x0, -0x8(%rbp)
jmp 0x50d2b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x50de0
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x50ca2
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x10b, 0x4(%rax)       # imm = 0x10B
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %r9
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl $0x1, %r8d
movq %rax, (%rsp)
callq 0x50e50
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x16, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4c020
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4c020
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %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/evaluate.c
// Function: base_type
static struct symbol *base_type(struct symbol *node, unsigned long *modp, struct ident **asp)
{
	unsigned long mod = 0;
	struct ident *as = NULL;

	while (node) {
		mod |= node->ctype.modifiers;
		combine_address_space(node->pos, &as, node->ctype.as);
		if (node->type == SYM_NODE) {
			node = node->ctype.base_type;
			continue;
		}
		break;
	}
	*modp = mod & ~MOD_IGNORE;
	*asp = as;
	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x50db7
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x80(%rcx), %rdx
movq 0x4(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4b5e0
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x50db5
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x50d64
jmp 0x50db7
movq -0x20(%rbp), %rcx
andq $-0x204381e0, %rcx      # imm = 0xDFBC7E20
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop