LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x20(%rdi), %r15
movq 0x10(%r15), %rbx
movzbl (%rbx), %eax
cmpl $0x3, %eax
jne 0x34664
movq 0x60(%rbx), %rbx
movzbl (%rbx), %eax
cmpl $0xa, %eax
jne 0x34683
movq %rbx, %rdi
callq 0x2b0b8
movq %rax, %rbx
movzbl (%rax), %eax
cmpl $0x3, %eax
jne 0x34683
movq 0x60(%rbx), %rbx
movzbl (%rbx), %eax
cmpl $0x9, %eax
jne 0x3468f
movq 0x60(%rbx), %rbx
movzbl (%rbx), %eax
cmpl $0x2, %eax
jne 0x346aa
movq 0x60(%rbx), %rcx
cmpq 0x2b8e9(%rip), %rcx     # 0x5ff88
je 0x346b9
cmpq 0x2b8a8(%rip), %rcx     # 0x5ff50
je 0x346c1
movl %eax, %eax
leaq 0x154fd(%rip), %rcx     # 0x49bb0
movl (%rcx,%rax,4), %r12d
jmp 0x346c7
movl $0x1, %r12d
jmp 0x346c7
movl $0x9, %r12d
testl %r12d, %r12d
setne %al
testb $0x20, %r12b
sete %cl
testb %cl, %al
je 0x3476d
movq 0x20(%r14), %rax
cmpb $0x9, (%rax)
jne 0x34776
cmpl $0x2a, 0x4(%rax)
jne 0x34776
testb $0x4, %r12b
je 0x34724
testb $0x40, %r12b
je 0x34703
movq 0x60(%rbx), %rbx
movq %rbx, %rdi
callq 0x237c5
movq 0x8(%r14), %rdi
leaq 0x1577d(%rip), %rsi     # 0x49e93
movq %rax, %rdx
xorl %eax, %eax
callq 0x118fc
movq 0x60(%rbx), %rbx
movl $0x1, %ebp
testb $0x1, %r12b
jne 0x3479a
cmpl $0x10, %r12d
jne 0x34764
movq %rbx, %rdi
callq 0x2baa4
testq %rax, %rax
je 0x34747
cmpb $0x5, (%rax)
je 0x34764
movl 0x50(%rax), %eax
testl %eax, %eax
js 0x34795
leaq 0x2ffab(%rip), %rcx     # 0x64700
movl (%rcx), %ecx
addl %ecx, %eax
decl %eax
cltd
idivl %ecx
movl %eax, %ebp
testl %eax, %eax
jne 0x3479a
leaq 0x15b94(%rip), %rsi     # 0x4a2ff
jmp 0x3477d
leaq 0x15b54(%rip), %rsi     # 0x4a2c8
jmp 0x3477d
leaq 0x15b61(%rip), %rsi     # 0x4a2de
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x11b04
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq 0x10(%r15), %rax
movq 0x68(%rax), %rsi
movq %r15, %rdi
callq 0x376dc
movslq %ebp, %rax
movq %rax, 0x28(%r14)
movq %rbx, 0x10(%r14)
jmp 0x34789
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x37959
testq %rax, %rax
je 0x34ae6
movzbl (%rax), %ecx
cmpl $0x3, %ecx
jne 0x34aa1
movq 0x60(%rax), %rax
testq %rax, %rax
je 0x34ae6
movl (%rax), %ecx
cmpb $0x6, %cl
je 0x34abc
movzbl %cl, %ecx
cmpl $0x4, %ecx
jne 0x34aeb
movq 0x60(%rax), %rdi
callq 0x2b0b8
testq %rax, %rax
je 0x34aeb
movl 0x50(%rax), %edx
leaq 0x2fc3a(%rip), %rax     # 0x64700
movl (%rax), %esi
decl %esi
xorl %ecx, %ecx
testl %edx, %esi
cmovel %edx, %ecx
movb $0x1, (%rbx)
testl %ecx, %ecx
js 0x34b01
movl (%rax), %esi
leal (%rcx,%rsi), %eax
decl %eax
cltd
idivl %esi
cltq
jmp 0x34b08
xorl %r14d, %r14d
jmp 0x34b21
leaq 0x159d1(%rip), %rsi     # 0x4a4c3
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11b04
jmp 0x34b21
movq $-0x1, %rax
movq %rax, 0x20(%rbx)
movl $0x0, 0x28(%rbx)
leaq 0x2fb06(%rip), %rax     # 0x64620
movq (%rax), %r14
movq %r14, 0x10(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0x37959
testq %rax, %rax
je 0x34b5c
movb $0x1, (%rbx)
movq 0x70(%rax), %rax
movq %rax, 0x20(%rbx)
movl $0x0, 0x28(%rbx)
leaq 0x2facd(%rip), %rax     # 0x64620
movq (%rax), %rax
movq %rax, 0x10(%rbx)
jmp 0x34b5e
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl (%rsi), %eax
shrl $0x8, %eax
andl $0x1ff, %eax            # imm = 0x1FF
je 0x35bd9
cmpl $0x8, %eax
jne 0x35be7
cmpq $0x0, 0x90(%rsi)
jne 0x35be7
movq %rdi, %rbx
movq 0x18(%rsi), %rdi
callq 0x2de35
leaq 0x14a18(%rip), %rsi     # 0x4a5e4
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a80
movq 0x5a390(%rip), %rax     # 0x8ff70
orl $0x100, 0x54(%rax)      # imm = 0x100
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x3527d(%rip), %r13     # 0x6ae78
leaq 0x14ac4(%rip), %r15     # 0x4a6c6
leaq 0x13fa7(%rip), %rbp     # 0x49bb0
testq %rdi, %rdi
je 0x35d2b
movl 0x54(%rdi), %eax
btl $0xd, %eax
jb 0x35d2f
orl $0x2000, %eax           # imm = 0x2000
movl %eax, 0x54(%rdi)
callq 0x2b0b8
movq %rax, %r14
movq 0x60(%rax), %rdi
callq 0x2b0b8
testq %rax, %rax
je 0x35d2b
movq %rax, %rbx
cmpq $0x0, 0xb0(%r14)
je 0x35ce1
movzbl (%r14), %ecx
movq %r14, %rax
cmpl $0x3, %ecx
jne 0x35c65
movq 0x60(%r14), %rax
movzbl (%rax), %ecx
cmpl $0xa, %ecx
jne 0x35c81
movq %rax, %rdi
callq 0x2b0b8
movzbl (%rax), %ecx
cmpl $0x3, %ecx
jne 0x35c81
movq 0x60(%rax), %rax
movzbl (%rax), %ecx
cmpl $0x9, %ecx
jne 0x35c8d
movq 0x60(%rax), %rax
movzbl (%rax), %ecx
cmpl $0x2, %ecx
jne 0x35ca4
movq 0x60(%rax), %rax
cmpq %r13, %rax
je 0x35cac
cmpq 0x2a2ae(%rip), %rax     # 0x5ff50
je 0x35cb3
movl %ecx, %eax
movl (%rbp,%rax,4), %edx
jmp 0x35cb8
movl $0x1, %edx
jmp 0x35cb8
movl $0x9, %edx
leaq 0xb0(%r14), %r12
movq %r12, %rdi
xorl %esi, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x37b3d
testl %eax, %eax
jne 0x35ce1
movq (%r12), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x11b04
cmpb $0x5, (%rbx)
jne 0x35d32
movq 0x5a283(%rip), %r12     # 0x8ff70
movq 0xc8(%r14), %rdi
testq %rdi, %rdi
je 0x35d02
cmpq %r14, %rdi
jne 0x35c09
movq %r14, 0x5a267(%rip)     # 0x8ff70
movq %rbx, %rdi
callq 0x31d66
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x35d44
callq 0x35508
movq %r12, 0x5a247(%rip)     # 0x8ff70
jmp 0x35d32
xorl %ebx, %ebx
jmp 0x35d32
movq %rdi, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0xa0(%rbx)
je 0x35d22
cmpq $0x0, 0xc8(%r14)
je 0x35d22
movq %r14, %rdi
callq 0x10c10
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
jne 0x35d1d
jmp 0x35d22
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x364a2
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x30941(%rip), %r15     # 0x66d84
movq %rdi, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0x3648f
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %r14
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x36467
testq %r14, %r14
je 0x36480
andb $-0x2, (%r15)
movq %r14, %rdi
callq 0x35be9
movq %r14, %rdi
callq 0x36296
movzwl (%r12), %eax
incq %r13
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r13
jl 0x36452
movq 0x10(%r12), %r12
cmpq %rbx, %r12
jne 0x36446
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x364e2
movq %rdi, %rbx
cmpb $0x3, (%rdi)
jne 0x364e4
testb $0xe, 0x69(%rbx)
je 0x364e4
movq 0x4(%rbx), %rdi
xorl %esi, %esi
callq 0x2b00b
movq %rax, %r14
movl $0xe0, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe1e0
andb $-0xf, 0x69(%r14)
movq %r14, %rbx
jmp 0x364e4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
leaq 0x2a0a9(%rip), %rax     # 0x605a4
cmpl $0x0, (%rax)
je 0x3657a
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpb $0x3, (%rsi)
jne 0x36512
movq 0x60(%r15), %r15
cmpb $0x3, (%r14)
jne 0x3651c
movq 0x60(%r14), %r14
cmpq %r14, %r15
je 0x3657a
cmpb $0x9, (%r15)
jne 0x3657a
cmpb $0x9, (%r14)
jne 0x3657a
leaq 0x1391d(%rip), %rsi     # 0x49e51
movq %rbx, %rdi
xorl %eax, %eax
callq 0x118fc
movq %r15, %rdi
callq 0x237c5
leaq 0x1233a(%rip), %r15     # 0x48887
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1178c
movq %r14, %rdi
callq 0x237c5
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1178c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rsi, %rbx
movzbl (%rdi), %eax
cmpl $0x3, %eax
jne 0x36593
movq 0x60(%rdi), %rdi
movzbl (%rdi), %eax
cmpl $0xa, %eax
jne 0x365af
callq 0x2b0b8
movq %rax, %rdi
movzbl (%rax), %eax
cmpl $0x3, %eax
jne 0x365af
movq 0x60(%rdi), %rdi
movzbl (%rdi), %eax
cmpl $0x9, %eax
jne 0x365bb
movq 0x60(%rdi), %rdi
movzbl (%rdi), %eax
cmpl $0x2, %eax
jne 0x365d6
movq 0x60(%rdi), %rcx
cmpq 0x299bd(%rip), %rcx     # 0x5ff88
je 0x36609
cmpq 0x2997c(%rip), %rcx     # 0x5ff50
je 0x36610
movl %eax, %ecx
movl $0x197ff, %edx          # imm = 0x197FF
btq %rax, %rdx
jb 0x365ef
leaq 0x135c6(%rip), %rax     # 0x49bb0
movl (%rax,%rcx,4), %ecx
jmp 0x36615
addq $-0x7, %rcx
xorl %eax, %eax
cmpq $-0x3, %rcx
jb 0x36644
xorl %eax, %eax
testb $0x50, 0x1(%rbx)
setne %al
shll $0x6, %eax
jmp 0x36644
movl $0x1, %ecx
jmp 0x36615
movl $0x9, %ecx
movl (%rbx), %edx
movl %edx, %esi
shrl $0x8, %esi
andl $0xb4, %esi
btl $0xe, %edx
movl $0x20, %eax
cmovael %esi, %eax
testb $0x8, %cl
jne 0x36641
btl $0x9, %edx
movl $0x30, %ecx
cmovbl %ecx, %eax
jmp 0x36644
andl $-0x60, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x32bf6
movq %rax, %r15
movzbl (%rax), %eax
cmpl $0x3, %eax
jne 0x36673
movq 0x60(%r15), %r15
movzbl (%r15), %eax
cmpl $0xa, %eax
jne 0x36693
movq %r15, %rdi
callq 0x2b0b8
movq %rax, %r15
movzbl (%rax), %eax
cmpl $0x3, %eax
jne 0x36693
movq 0x60(%r15), %r15
movzbl (%r15), %eax
cmpl $0x9, %eax
jne 0x366a0
movq 0x60(%r15), %r15
movzbl (%r15), %eax
cmpl $0x2, %eax
jne 0x366bf
movq 0x60(%r15), %rcx
cmpq 0x298d8(%rip), %rcx     # 0x5ff88
je 0x366db
cmpq 0x29897(%rip), %rcx     # 0x5ff50
je 0x366e2
movl %eax, %eax
jmp 0x366cf
movl %eax, %eax
leaq -0x9(%rax), %rcx
cmpq $-0x4, %rcx
ja 0x3676e
leaq 0x134da(%rip), %rcx     # 0x49bb0
movl (%rcx,%rax,4), %ebp
jmp 0x366e7
movl $0x1, %ebp
jmp 0x366e7
movl $0x9, %ebp
movq 0x8(%rbx), %r13
xorl %edi, %edi
callq 0x2f9f5
movq %rax, %r12
movq %r13, 0x8(%rax)
movq $0x0, 0x20(%rax)
leaq 0x35030(%rip), %rax     # 0x6b738
movq %rax, 0x10(%r12)
movw $0x3101, (%r12)         # imm = 0x3101
testb $0x10, %bpl
je 0x3671f
movq %r15, 0x10(%r12)
movl $0x10b, 0x4(%rbx)       # imm = 0x10B
movq 0x10(%r12), %rax
movq %rax, (%rsp)
movl $0x10b, %edi            # imm = 0x10B
movq %r14, %rsi
movq %r12, %rdx
movl %ebp, %ecx
movl $0x1, %r8d
movq %r15, %r9
callq 0x36814
movq %rax, %r15
movb $0x16, (%rbx)
movq %r14, %rdi
movq %rax, %rsi
callq 0x32aa9
movq %rax, 0x20(%rbx)
movq %r12, %rdi
movq %r15, %rsi
callq 0x32aa9
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x367f4
movq %rdi, %r15
leaq 0x1029f(%rip), %r12     # 0x46a3c
leaq 0x2ec3c(%rip), %rbp     # 0x653e0
xorl %r13d, %r13d
xorl %eax, %eax
orq 0x68(%r15), %r13
movq 0x80(%r15), %rcx
testq %rcx, %rcx
je 0x367d9
testq %rax, %rax
je 0x367d6
cmpq %rcx, %rax
je 0x367d9
movq 0x4(%r15), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x11a80
movq %rbp, %rax
jmp 0x367d9
movq %rcx, %rax
cmpb $0x3, (%r15)
jne 0x367eb
movq 0x60(%r15), %r15
testq %r15, %r15
jne 0x367a9
xorl %r15d, %r15d
andq $-0x204381e0, %r13      # imm = 0xDFBC7E20
jmp 0x367fc
xorl %r15d, %r15d
xorl %eax, %eax
xorl %r13d, %r13d
movq %r13, (%r14)
movq %rax, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/evaluate.c
// Function: restricted_binop_type
static struct symbol *restricted_binop_type(int op,
					struct expression *left,
					struct expression *right,
					int lclass, int rclass,
					struct symbol *ltype,
					struct symbol *rtype)
{
	struct symbol *ctype = NULL;
	if (lclass & TYPE_RESTRICT) {
		if (rclass & TYPE_RESTRICT) {
			if (ltype == rtype) {
				ctype = ltype;
			} else if (lclass & TYPE_FOULED) {
				if (unfoul(ltype) == rtype)
					ctype = ltype;
			} else if (rclass & TYPE_FOULED) {
				if (unfoul(rtype) == ltype)
					ctype = rtype;
			}
		} else {
			if (!restricted_value(right, ltype))
				ctype = ltype;
		}
	} else if (!restricted_value(left, rtype))
		ctype = rtype;

	if (ctype) {
		switch (restricted_binop(op, ctype)) {
		case 1:
			if ((lclass ^ rclass) & TYPE_FOULED)
				ctype = unfoul(ctype);
			break;
		case 3:
			if (!(lclass & rclass & TYPE_FOULED))
				break;
		case 0:
			ctype = NULL;
		default:
			break;
		}
	}

	return ctype;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movq 0x20(%rsp), %rax
testb $0x4, %r14b
jne 0x36a45
cmpb $0x1, (%rsi)
jne 0x36ab4
cmpq $0x0, 0x20(%rsi)
movq %rax, %rbx
jne 0x36ab4
jmp 0x36a78
movq %r9, %rbx
testb $0x4, %bpl
jne 0x36a5c
cmpb $0x1, (%rdx)
jne 0x36ab4
cmpq $0x0, 0x20(%rdx)
jne 0x36ab4
jmp 0x36a78
cmpq %rax, %rbx
je 0x36a78
testb $0x40, %r14b
jne 0x36aa3
testb $0x40, %bpl
je 0x36ab4
cmpq %rbx, 0x60(%rax)
movq %rax, %rbx
jne 0x36ab4
jmp 0x36a7d
testq %rbx, %rbx
je 0x36ab4
callq 0x36b0a
movl %eax, %eax
leaq 0x13059(%rip), %rcx     # 0x49ae4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %r14d, %ebp
testb $0x40, %bpl
je 0x36ab6
movq 0x60(%rbx), %rbx
jmp 0x36ab6
cmpq %rax, 0x60(%rbx)
jne 0x36ab4
jmp 0x36a7d
andl %ebp, %r14d
testb $0x40, %r14b
je 0x36ab6
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/evaluate.c
// Function: unrestrict
static inline void unrestrict(struct expression *expr,
			      int class, struct symbol **ctype)
{
	if (class & TYPE_RESTRICT) {
		if (class & TYPE_FOULED)
			*ctype = unfoul(*ctype);
		warning(expr->pos, "%s degrades to integer",
			show_typename(*ctype));
		*ctype = (*ctype)->ctype.base_type; /* get to arithmetic type */
	}
}

// Assembly:
testb $0x4, %sil
je 0x36b09
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdx), %rdi
testb $0x40, %sil
je 0x36ade
movq 0x60(%rdi), %rdi
movq %rdi, (%rbx)
callq 0x237c5
movq 0x8(%r14), %rdi
leaq 0x133a5(%rip), %rsi     # 0x49e93
movq %rax, %rdx
xorl %eax, %eax
callq 0x118fc
movq (%rbx), %rax
movq 0x60(%rax), %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/evaluate.c
// Function: create_pointer
static struct symbol *create_pointer(struct expression *expr, struct symbol *sym, int degenerate)
{
	struct symbol *node = alloc_symbol(expr->pos, SYM_NODE);
	struct symbol *ptr = alloc_symbol(expr->pos, SYM_PTR);

	node->ctype.base_type = ptr;
	ptr->bit_size = bits_in_pointer;
	ptr->ctype.alignment = pointer_alignment;

	node->bit_size = bits_in_pointer;
	node->ctype.alignment = pointer_alignment;

	access_symbol(sym);
	if (sym->ctype.modifiers & MOD_REGISTER) {
		warning(expr->pos, "taking address of 'register' variable '%s'", show_ident(sym->ident));
		sym->ctype.modifiers &= ~MOD_REGISTER;
	}
	if (sym->type == SYM_NODE) {
		combine_address_space(sym->pos, &ptr->ctype.as, sym->ctype.as);
		ptr->ctype.modifiers |= sym->ctype.modifiers & MOD_PTRINHERIT;
		sym = sym->ctype.base_type;
	}
	if (degenerate && sym->type == SYM_ARRAY) {
		combine_address_space(sym->pos, &ptr->ctype.as, sym->ctype.as);
		ptr->ctype.modifiers |= sym->ctype.modifiers & MOD_PTRINHERIT;
		sym = sym->ctype.base_type;
	}
	ptr->ctype.base_type = sym;

	return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r12
movq 0x8(%rdi), %rdi
movl $0x3, %esi
callq 0x2b00b
movq %rax, %r14
movq 0x8(%r12), %rdi
movl $0x4, %esi
callq 0x2b00b
movq %rax, %r15
movq %rax, 0x60(%r14)
leaq 0x2db96(%rip), %rax     # 0x6472c
movl (%rax), %eax
movl %eax, 0x50(%r15)
leaq 0x2db8d(%rip), %rcx     # 0x64730
movslq (%rcx), %rcx
movq %rcx, 0x70(%r15)
movl %eax, 0x50(%r14)
movq %rcx, 0x70(%r14)
movq %rbx, %rdi
callq 0x2afb0
testb $0x2, 0x68(%rbx)
je 0x36be3
movq 0x18(%rbx), %rdi
callq 0x2de35
movq 0x8(%r12), %rdi
leaq 0x13326(%rip), %rsi     # 0x49efb
movq %rax, %rdx
xorl %eax, %eax
callq 0x118fc
andb $-0x3, 0x68(%rbx)
cmpb $0x3, (%rbx)
jne 0x36c3f
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x36c2e
movq 0x80(%r15), %rcx
testq %rcx, %rcx
je 0x36c27
cmpq %rax, %rcx
je 0x36c2e
movq 0x4(%rbx), %rdi
leaq 0x2e7d0(%rip), %rax     # 0x653e0
movq %rax, 0x80(%r15)
leaq 0xfe1e(%rip), %rsi      # 0x46a3c
xorl %eax, %eax
callq 0x11a80
jmp 0x36c2e
movq %rax, 0x80(%r15)
movq 0x68(%rbx), %rax
andl $0x1c001e00, %eax       # imm = 0x1C001E00
orq %rax, 0x68(%r15)
movq 0x60(%rbx), %rbx
testl %ebp, %ebp
je 0x36c9f
cmpb $0x6, (%rbx)
jne 0x36c9f
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x36c8e
movq 0x80(%r15), %rcx
testq %rcx, %rcx
je 0x36c87
cmpq %rax, %rcx
je 0x36c8e
movq 0x4(%rbx), %rdi
leaq 0x2e770(%rip), %rax     # 0x653e0
movq %rax, 0x80(%r15)
leaq 0xfdbe(%rip), %rsi      # 0x46a3c
xorl %eax, %eax
callq 0x11a80
jmp 0x36c8e
movq %rax, 0x80(%r15)
movq 0x68(%rbx), %rax
andl $0x1c001e00, %eax       # imm = 0x1C001E00
orq %rax, 0x68(%r15)
movq 0x60(%rbx), %rbx
movq %rbx, 0x60(%r15)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/evaluate.c
// Function: compatible_assignment_types
static int compatible_assignment_types(struct expression *expr, struct symbol *target,
	struct expression **rp, const char *where)
{
	const char *typediff;

	if (!check_assignment_types(target, rp, &typediff)) {
		struct symbol *source = *rp ? (*rp)->ctype : NULL;
		warning(expr->pos, "incorrect type in %s (%s)", where, typediff);
		info(expr->pos, "   expected %s", show_typename(target));
		info(expr->pos, "   got %s", show_typename(source));
		*rp = cast_to(*rp, target);
		return 0;
	}

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq %rsp, %rdx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x36d67
movl $0x1, %r15d
testl %eax, %eax
jne 0x36d55
movq (%rbx), %rax
xorl %r15d, %r15d
testq %rax, %rax
je 0x36cef
movq 0x10(%rax), %rbp
jmp 0x36cf1
xorl %ebp, %ebp
movq (%rsp), %rcx
movq 0x8(%r12), %rdi
leaq 0x13257(%rip), %rsi     # 0x49f58
movq %r13, %rdx
xorl %eax, %eax
callq 0x118fc
movq %r14, %rdi
callq 0x237c5
movq 0x8(%r12), %rdi
leaq 0x13253(%rip), %rsi     # 0x49f72
movq %rax, %rdx
xorl %eax, %eax
callq 0x1178c
movq %rbp, %rdi
callq 0x237c5
movq 0x8(%r12), %rdi
leaq 0x13244(%rip), %rsi     # 0x49f81
movq %rax, %rdx
xorl %eax, %eax
callq 0x1178c
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x32aa9
movq %rax, (%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/evaluate.c
// Function: bad_expr_type
static struct symbol *bad_expr_type(struct expression *expr)
{
	switch (expr->type) {
	case EXPR_BINOP:
	case EXPR_COMPARE:
		if (!valid_subexpr_type(expr))
			break;
		sparse_error(expr->pos, "incompatible types for operation (%s):", show_special(expr->op));
		info(expr->pos, "   %s", show_typename(expr->left->ctype));
		info(expr->pos, "   %s", show_typename(expr->right->ctype));
		break;
	case EXPR_PREOP:
	case EXPR_POSTOP:
		if (!valid_expr_type(expr->unop))
			break;
		sparse_error(expr->pos, "incompatible type for operation (%s):", show_special(expr->op));
		info(expr->pos, "   %s", show_typename(expr->unop->ctype));
		break;
	default:
		break;
	}

	expr->flags = CEF_NONE;
	return expr->ctype = &bad_ctype;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzbl (%rdi), %eax
leal -0x9(%rax), %ecx
cmpl $0x2, %ecx
jb 0x372c1
cmpl $0x16, %eax
je 0x37226
cmpl $0x5, %eax
jne 0x37327
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x37327
movq 0x10(%rax), %rax
testq %rax, %rax
sete %cl
cmpq 0x28d1c(%rip), %rax     # 0x5ff60
sete %al
orb %cl, %al
jne 0x37327
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x37327
movq 0x10(%rax), %rax
testq %rax, %rax
sete %cl
cmpq 0x28cf3(%rip), %rax     # 0x5ff60
sete %al
orb %cl, %al
jne 0x37327
leaq 0x28(%rbx), %r15
leaq 0x8(%rbx), %r14
movl 0x4(%rbx), %edi
callq 0x2ddfa
movq 0x8(%rbx), %rdi
leaq 0x12d42(%rip), %rsi     # 0x49fd5
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a80
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0x237c5
movq 0x8(%rbx), %rdi
leaq 0x115d2(%rip), %rsi     # 0x48887
movq %rax, %rdx
xorl %eax, %eax
callq 0x1178c
jmp 0x37307
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x37327
movq 0x10(%rax), %rax
testq %rax, %rax
sete %cl
cmpq 0x28c85(%rip), %rax     # 0x5ff60
sete %al
orb %cl, %al
jne 0x37327
leaq 0x20(%rbx), %r15
leaq 0x8(%rbx), %r14
movl 0x4(%rbx), %edi
callq 0x2ddfa
movq 0x8(%rbx), %rdi
leaq 0x12cff(%rip), %rsi     # 0x49ffc
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a80
movq (%r15), %rax
movq 0x10(%rax), %rdi
callq 0x237c5
movq (%r14), %rdi
leaq 0x1156a(%rip), %rsi     # 0x48887
movq %rax, %rdx
xorl %eax, %eax
callq 0x1178c
movb $0x0, 0x1(%rbx)
leaq 0x35586(%rip), %rax     # 0x6c8b8
movq %rax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_conditional
static struct symbol *evaluate_conditional(struct expression *expr, int iterator)
{
	struct symbol *ctype;

	if (!expr)
		return NULL;

	if (!iterator && expr->type == EXPR_ASSIGNMENT && expr->op == '=')
		warning(expr->pos, "assignment expression in conditional");

	ctype = evaluate_expression(expr);
	if (!valid_type(ctype))
		return NULL;
	if (is_safe_type(ctype))
		warning(expr->pos, "testing a 'safe expression'");
	if (is_func_type(ctype)) {
		if (Waddress)
			warning(expr->pos, "the address of %s will always evaluate as true", "a function");
	} else if (is_array_type(ctype)) {
		if (Waddress)
			warning(expr->pos, "the address of %s will always evaluate as true", "an array");
	} else if (!is_scalar_type(ctype)) {
		sparse_error(expr->pos, "non-scalar type in conditional:");
		info(expr->pos, "   %s", show_typename(ctype));
		return NULL;
	}

	ctype = degenerate(expr);
	return ctype;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x375e5
movq %rdi, %rbx
testl %esi, %esi
jne 0x375c6
cmpb $0x6, (%rbx)
jne 0x375c6
cmpl $0x3d, 0x4(%rbx)
jne 0x375c6
movq 0x8(%rbx), %rdi
leaq 0x12b4d(%rip), %rsi     # 0x4a10c
xorl %eax, %eax
callq 0x118fc
movq %rbx, %rdi
callq 0x32223
movq %rax, %r14
testq %rax, %rax
sete %al
cmpq 0x28982(%rip), %r14     # 0x5ff60
sete %cl
orb %al, %cl
je 0x375ef
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testb $-0x80, 0x6a(%r14)
je 0x37608
movq 0x8(%rbx), %rdi
leaq 0x12b30(%rip), %rsi     # 0x4a131
xorl %eax, %eax
callq 0x118fc
movzbl (%r14), %eax
cmpl $0x6, %eax
je 0x37645
cmpl $0x5, %eax
je 0x37630
movq %r14, %rcx
cmpl $0x3, %eax
jne 0x3766c
movq 0x60(%r14), %rcx
movl (%rcx), %eax
cmpb $0x6, %al
je 0x37645
movzbl %al, %edx
cmpl $0x5, %edx
jne 0x3766c
leaq 0x2f7a9(%rip), %rax     # 0x66de0
cmpl $0x0, (%rax)
je 0x3767d
leaq 0x12e19(%rip), %rdx     # 0x4a45c
jmp 0x37658
leaq 0x2f794(%rip), %rax     # 0x66de0
cmpl $0x0, (%rax)
je 0x3767d
leaq 0x12b24(%rip), %rdx     # 0x4a17c
movq 0x8(%rbx), %rdi
leaq 0x12aea(%rip), %rsi     # 0x4a14d
xorl %eax, %eax
callq 0x118fc
jmp 0x3767d
cmpb $0xe, %al
ja 0x3768c
movzbl %al, %eax
movl $0x6a10, %edx           # imm = 0x6A10
btl %eax, %edx
jae 0x3768c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x32bf6
movq 0x60(%rcx), %rax
cmpq 0x288f1(%rip), %rax     # 0x5ff88
sete %cl
cmpq 0x288af(%rip), %rax     # 0x5ff50
sete %al
orb %cl, %al
jne 0x3767d
movq 0x8(%rbx), %rdi
leaq 0x12ad2(%rip), %rsi     # 0x4a185
xorl %eax, %eax
callq 0x11a80
movq %r14, %rdi
callq 0x237c5
movq 0x8(%rbx), %rdi
leaq 0x111ba(%rip), %rsi     # 0x48887
movq %rax, %rdx
xorl %eax, %eax
callq 0x1178c
jmp 0x375e5
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/evaluate.c
// Function: mark_assigned
static void mark_assigned(struct expression *expr)
{
	struct symbol *sym;

	if (!expr)
		return;
	switch (expr->type) {
	case EXPR_SYMBOL:
		sym = expr->symbol;
		if (!sym)
			return;
		if (sym->type != SYM_NODE)
			return;
		sym->ctype.modifiers |= MOD_ASSIGNED;
		return;

	case EXPR_BINOP:
		mark_assigned(expr->left);
		mark_assigned(expr->right);
		return;
	case EXPR_CAST:
	case EXPR_FORCE_CAST:
		mark_assigned(expr->cast_expression);
		return;
	case EXPR_SLICE:
		mark_assigned(expr->base);
		return;
	default:
		/* Hmm? */
		return;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x3774b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl (%rbx), %eax
movl $0x28, %r14d
cmpl $0xa, %eax
jle 0x3772d
leal -0xb(%rax), %ecx
cmpl $0x2, %ecx
jb 0x3773b
cmpl $0x1d, %eax
jne 0x37744
movl $0x20, %r14d
jmp 0x3773b
cmpl $0x5, %eax
jne 0x3774c
movq 0x20(%rbx), %rdi
callq 0x376fe
movq (%rbx,%r14), %rbx
testq %rbx, %rbx
jne 0x3770a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x3, %eax
jne 0x37744
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x37744
cmpb $0x3, (%rax)
jne 0x37744
orb $-0x80, 0x68(%rax)
jmp 0x37744
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_addressof
static struct symbol *evaluate_addressof(struct expression *expr)
{
	struct expression *op = expr->unop;
	struct symbol *ctype;

	if (op->op != '*' || op->type != EXPR_PREOP) {
		expression_error(expr, "not addressable");
		return NULL;
	}
	ctype = op->ctype;
	if (ctype->builtin)
		sparse_error(expr->pos, "taking the address of built-in function '%s'", show_ident(ctype->ident));
	*expr = *op->unop;

	mark_addressable(expr);

	/*
	 * symbol expression evaluation is lazy about the type
	 * of the sub-expression, so we may have to generate
	 * the type here if so..
	 */
	if (expr->ctype == &lazy_ptr_ctype) {
		ctype = create_pointer(expr, ctype, 0);
		expr->ctype = ctype;
	}
	return expr->ctype;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r15
cmpl $0x2a, 0x4(%r15)
jne 0x377e0
cmpb $0x9, (%r15)
jne 0x377e0
movq 0x10(%r15), %r14
testb $0x8, 0x56(%r14)
je 0x377a7
movq 0x18(%r14), %rdi
callq 0x2de35
movq 0x8(%rbx), %rdi
leaq 0x12731(%rip), %rsi     # 0x49ece
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a80
movq 0x20(%r15), %rax
movaps (%rax), %xmm0
movaps 0x10(%rax), %xmm1
movaps 0x20(%rax), %xmm2
movaps 0x30(%rax), %xmm3
movaps %xmm3, 0x30(%rbx)
movaps %xmm2, 0x20(%rbx)
movaps %xmm1, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq %rbx, %rax
movzbl (%rax), %ecx
cmpl $0x5, %ecx
jne 0x377fd
cmpl $0x2b, 0x4(%rax)
jne 0x3780e
movq 0x20(%rax), %rax
jmp 0x377cc
leaq 0x12ad1(%rip), %rsi     # 0x4a2b8
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11b04
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x3, %ecx
jne 0x3780e
movq 0x20(%rax), %rax
orq $0x100, 0x68(%rax)      # imm = 0x100
movq 0x10(%rbx), %r15
cmpq 0x286f7(%rip), %r15     # 0x5ff10
jne 0x377f4
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x36b58
movq %rax, %r15
movq %rax, 0x10(%rbx)
jmp 0x377f4
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_compound_literal
static struct symbol *evaluate_compound_literal(struct expression *expr, struct expression *source)
{
	struct expression *addr = alloc_expression(expr->pos, EXPR_SYMBOL);
	struct symbol *sym = expr->cast_type;

	sym->initializer = source;
	evaluate_symbol(sym);

	addr->ctype = &lazy_ptr_ctype;	/* Lazy eval */
	addr->symbol = sym;
	if (sym->ctype.modifiers & MOD_TOPLEVEL)
		addr->flags |= CEF_ADDR;

	expr->type = EXPR_PREOP;
	expr->op = '*';
	expr->deref = addr;
	expr->ctype = sym;
	return sym;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %r15
xorl %edi, %edi
callq 0x2f9f5
movq %rax, %r14
movq %r15, 0x8(%rax)
movw $0x3, (%rax)
movq 0x20(%rbx), %r15
movq %r12, 0xb0(%r15)
movq %r15, %rdi
callq 0x35be9
leaq 0x34da8(%rip), %rax     # 0x6c618
movq %rax, 0x10(%r14)
movq %r15, 0x20(%r14)
testb $0x10, 0x68(%r15)
je 0x37884
orb $0x40, 0x1(%r14)
movb $0x9, (%rbx)
movl $0x2a, 0x4(%rbx)
movq %r14, 0x20(%rbx)
movq %r15, 0x10(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/evaluate.c
// Function: find_member_type
static struct symbol *find_member_type(struct symbol *utype, struct symbol *type)
{
	struct symbol *t, *member;

	if (utype->type != SYM_UNION)
		return NULL;

	FOR_EACH_PTR(utype->symbol_list, member) {
		classify_type(member, &t);
		if (type == t)
			return member;
	} END_FOR_EACH_PTR(member);
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpb $0x8, (%rdi)
jne 0x37949
movq 0x98(%rdi), %r15
testq %r15, %r15
je 0x37949
movq %rsi, %rbx
movq %r15, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0x3793f
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %r14
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x378ee
testq %r14, %r14
je 0x37930
movzbl (%r14), %ecx
movq %r14, %rax
cmpl $0x3, %ecx
jne 0x37901
movq 0x60(%r14), %rax
movzbl (%rax), %ecx
cmpl $0xa, %ecx
jne 0x3791d
movq %rax, %rdi
callq 0x2b0b8
movzbl (%rax), %ecx
cmpl $0x3, %ecx
jne 0x3791d
movq 0x60(%rax), %rax
movzbl (%rax), %ecx
cmpl $0x9, %ecx
jne 0x37926
movq 0x60(%rax), %rax
cmpq %rbx, %rax
je 0x3794c
movzwl (%r12), %eax
incq %r13
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r13
jl 0x378d9
movq 0x10(%r12), %r12
cmpq %r15, %r12
jne 0x378cd
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_type_information
static struct symbol *evaluate_type_information(struct expression *expr)
{
	struct symbol *sym = expr->cast_type;
	if (!sym) {
		sym = evaluate_expression(expr->cast_expression);
		if (!sym)
			return NULL;
		/*
		 * Expressions of restricted types will possibly get
		 * promoted - check that here
		 */
		if (is_restricted_type(sym)) {
			if (sym->bit_size < bits_in_int && is_promoted(expr))
				sym = &int_ctype;
		} else if (is_fouled_type(sym)) {
			sym = &int_ctype;
		}
	}
	examine_symbol_type(sym);
	if (is_bitfield_type(sym)) {
		expression_error(expr, "trying to examine bitfield type");
		return NULL;
	}
	return sym;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
testq %r14, %r14
jne 0x37a1e
movq 0x28(%rbx), %rdi
callq 0x32223
testq %rax, %rax
je 0x379ef
movzbl (%rax), %ecx
movl %ecx, %edx
movq %rax, %rsi
cmpl $0x3, %ecx
jne 0x3798f
movq 0x60(%rax), %rsi
movzbl (%rsi), %edx
cmpl $0x9, %edx
jne 0x3799b
movq 0x60(%rsi), %rdx
movzbl (%rdx), %edx
cmpl $0xd, %edx
jne 0x379f4
movl 0x50(%rax), %ecx
leaq 0x2cd5e(%rip), %rdx     # 0x64708
cmpl (%rdx), %ecx
jge 0x37a1b
leaq 0x33d83(%rip), %r14     # 0x6b738
movq %rbx, %rcx
movzbl (%rcx), %edx
cmpl $0x10, %edx
jle 0x379cf
movl $0x28, %esi
cmpl $0x15, %edx
je 0x379e9
jmp 0x37a7a
cmpl $0x9, %edx
jne 0x37a84
movl 0x4(%rcx), %edx
movl $0x20, %esi
cmpl $0x28, %edx
jne 0x37a69
movq (%rcx,%rsi), %rcx
jmp 0x379b8
xorl %r14d, %r14d
jmp 0x37a5e
movq %rax, %rdx
cmpl $0x3, %ecx
jne 0x37a03
movq 0x60(%rax), %rdx
movzbl (%rdx), %ecx
cmpl $0x9, %ecx
jne 0x37a0f
movq 0x60(%rdx), %rcx
movzbl (%rcx), %ecx
cmpl $0xe, %ecx
jne 0x37a1b
leaq 0x33d1d(%rip), %rax     # 0x6b738
movq %rax, %r14
movq %r14, %rdi
callq 0x2b0b8
movzbl (%r14), %eax
movq %r14, %rcx
cmpl $0x3, %eax
jne 0x37a39
movq 0x60(%r14), %rcx
movzbl (%rcx), %eax
cmpl $0x9, %eax
jne 0x37a45
movq 0x60(%rcx), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x37a5e
leaq 0x12a52(%rip), %rsi     # 0x4a4a3
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11b04
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x2b, %edx
je 0x37a1e
cmpl $0x2d, %edx
je 0x37a1e
cmpl $0x7e, %edx
je 0x37a1e
jmp 0x37a1b
addl $-0x11, %edx
cmpl $0x2, %edx
jb 0x37a1e
jmp 0x37a1b
cmpl $0x5, %edx
je 0x37a1e
jmp 0x37a1b
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/evaluate.c
// Function: find_identifier
static struct symbol *find_identifier(struct ident *ident, struct symbol_list *_list, int *offset)
{
	struct ptr_list *head = (struct ptr_list *)_list;
	struct ptr_list *list = head;

	if (!head)
		return NULL;
	do {
		int i;
		for (i = 0; i < list->nr; i++) {
			struct symbol *sym = (struct symbol *) list->list[i];
			if (sym->ident) {
				if (sym->ident != ident)
					continue;
				*offset = sym->offset;
				return sym;
			} else {
				struct symbol *ctype = sym->ctype.base_type;
				struct symbol *sub;
				if (!ctype)
					continue;
				if (ctype->type != SYM_UNION && ctype->type != SYM_STRUCT)
					continue;
				sub = find_identifier(ident, ctype->symbol_list, offset);
				if (!sub)
					continue;
				*offset += sym->offset;
				return sub;
			}	
		}
	} while ((list = list->next) != head);
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x37b13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %r13
movzwl (%r13), %eax
testb %al, %al
jle 0x37b0a
xorl %ebp, %ebp
movq 0x18(%r13,%rbp,8), %r12
movq 0x18(%r12), %rcx
testq %rcx, %rcx
je 0x37ad7
cmpq %r15, %rcx
je 0x37b18
incq %rbp
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %rbp
jl 0x37ab2
jmp 0x37b0a
movq 0x60(%r12), %rcx
testq %rcx, %rcx
je 0x37ac6
movzbl (%rcx), %edx
addl $-0x7, %edx
cmpl $0x1, %edx
ja 0x37ac6
movq 0x98(%rcx), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x37a8b
testq %rax, %rax
jne 0x37b31
movzwl (%r13), %eax
jmp 0x37ac6
movq 0x10(%r13), %r13
cmpq %r14, %r13
jne 0x37aa7
xorl %r12d, %r12d
jmp 0x37b1f
movl 0x48(%r12), %ecx
movl %ecx, (%rbx)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl (%rbx), %ecx
addl 0x48(%r12), %ecx
movq %rax, %r12
jmp 0x37b1d
// File: /workspace/github_c_makefile_star2_O3/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:
movq (%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x385c7
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rcx, %r14
movzbl (%r14), %edx
cmpl $0x9, %edx
jne 0x38590
cmpl $0x28, 0x4(%r14)
jne 0x385c0
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x38575
jmp 0x385c0
cmpl $0x2, %edx
jne 0x385c0
cmpq %rcx, %r14
je 0x385b8
leaq 0x2e877(%rip), %rax     # 0x66e18
cmpl $0x0, (%rax)
je 0x385b8
movq 0x8(%r14), %rdi
leaq 0x121e8(%rip), %rsi     # 0x4a799
xorl %eax, %eax
callq 0x118fc
movq %r14, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/evaluate.c
// Function: first_subobject
static struct expression *first_subobject(struct symbol *ctype, int class,
					  struct expression **v)
{
	struct expression *e = *v, *new;

	if (ctype->type == SYM_NODE)
		ctype = ctype->ctype.base_type;

	if (class & TYPE_PTR) { /* array */
		if (!ctype->bit_size)
			return NULL;
		new = alloc_expression(e->pos, EXPR_INDEX);
		new->idx_expression = e;
		new->ctype = ctype->ctype.base_type;
	} else  {
		struct symbol *field, *p;
		PREPARE_PTR_LIST(ctype->symbol_list, p);
		while (p && !p->ident && is_bitfield_type(p))
			NEXT_PTR_LIST(p);
		field = p;
		FINISH_PTR_LIST(p);
		if (!field)
			return NULL;
		new = alloc_expression(e->pos, EXPR_IDENTIFIER);
		new->ident_expression = e;
		new->field = new->ctype = field;
		new->offset = field->offset;
	}
	*v = new;
	return new;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
cmpb $0x3, (%rdi)
jne 0x385df
movq 0x60(%r14), %r14
movq (%rbx), %r15
testb $0x10, %sil
jne 0x38610
movq 0x98(%r14), %rcx
testq %rcx, %rcx
je 0x386a3
xorl %eax, %eax
movq %rcx, %rdx
cmpb $0x0, (%rdx)
jg 0x38640
movq 0x10(%rdx), %rdx
cmpq %rcx, %rdx
jne 0x385fd
jmp 0x386a5
cmpl $0x0, 0x50(%r14)
je 0x386a3
movq 0x8(%r15), %r12
xorl %edi, %edi
callq 0x2f9f5
movq %r12, 0x8(%rax)
movw $0x1a, (%rax)
movq %r15, 0x28(%rax)
movq 0x60(%r14), %rcx
movq %rcx, 0x10(%rax)
movq %rax, (%rbx)
jmp 0x386a5
movq 0x18(%rdx), %r14
andq $-0x4, %r14
je 0x386a3
movl $0x1, %esi
xorl %eax, %eax
cmpq $0x0, 0x18(%r14)
jne 0x386b1
movzbl (%r14), %edi
movq %r14, %r8
cmpl $0x3, %edi
jne 0x3866c
movq 0x60(%r14), %r8
movzbl (%r8), %edi
cmpl $0x9, %edi
jne 0x38678
movq 0x60(%r8), %rdi
movzbl (%rdi), %edi
cmpl $0xb, %edi
jne 0x386b1
movsbl (%rdx), %edi
cmpl %edi, %esi
jl 0x38691
movq 0x10(%rdx), %rdx
xorl %esi, %esi
cmpq %rcx, %rdx
jne 0x3867d
jmp 0x386a3
movslq %esi, %rdi
movq 0x18(%rdx,%rdi,8), %r14
incl %esi
andq $-0x4, %r14
jne 0x38651
jmp 0x386a5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%r15), %r12
xorl %edi, %edi
callq 0x2f9f5
movq %r12, 0x8(%rax)
movw $0x19, (%rax)
movq %r15, 0x38(%rax)
movq %r14, 0x10(%rax)
movq %r14, 0x30(%rax)
movl 0x48(%r14), %ecx
movl %ecx, 0x20(%rax)
jmp 0x3863b
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x388e2
pushq %rbx
movq %rdi, %rbx
movl (%rbx), %eax
cmpb $0x19, %al
je 0x388c0
movzbl %al, %eax
cmpl $0x1a, %eax
jne 0x388e1
movq %rbx, %rdi
callq 0x388e3
movq 0x28(%rbx), %rbx
jmp 0x388dc
movq 0x38(%rbx), %rcx
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
orl $0x1b, %eax
movl %eax, (%rbx)
movl $0x1, 0x24(%rbx)
movq %rcx, 0x28(%rbx)
movq %rcx, %rbx
testq %rbx, %rbx
jne 0x388a4
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x20(%rdi), %esi
movl 0x24(%rdi), %ecx
movb $0x1b, (%rdi)
movq 0x10(%rdi), %rax
movl 0x50(%rax), %eax
testl %eax, %eax
js 0x3890c
leaq 0x2be02(%rip), %rdx     # 0x64700
movl (%rdx), %r8d
addl %r8d, %eax
decl %eax
cltd
idivl %r8d
jmp 0x38911
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
imull %esi, %eax
movl %eax, 0x20(%rdi)
subl %esi, %ecx
incl %ecx
movl %ecx, 0x24(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/evaluate.c
// Function: parse_asm_constraint
static void parse_asm_constraint(struct asm_operand *op)
{
	struct expression *constraint = op->constraint;
	const char *str = constraint->string->data;
	int c;

	switch (str[0]) {
	case '\0':
		sparse_error(constraint->pos, "invalid ASM constraint (\"\")");
		break;
	case '+':
		op->is_modify = true;
		/* fall-through */
	case '=':
		op->is_assign = true;
		str++;
		break;
	}

	while ((c = *str++)) {
		switch (c) {
		case '=':
		case '+':
			sparse_error(constraint->pos, "invalid ASM constraint '%c'", c);
			break;

		case '&':
			op->is_earlyclobber = true;
			break;
		case '%':
			op->is_commutative = true;
			break;
		case 'r':
			op->is_register = true;
			break;

		case 'm':
		case 'o':
		case 'V':
		case 'Q':
			op->is_memory = true;
			break;

		case '<':
		case '>':
			// FIXME: ignored for now
			break;

		case ',':
			// FIXME: multiple alternative constraints
			break;

		case '0' ... '9':
			// FIXME: numeric  matching constraint?
			break;
		case '[':
			// FIXME: symbolic matching constraint
			return;

		default:
			if (arch_target->asm_constraint)
				str = arch_target->asm_constraint(op, c, str);

			// FIXME: multi-letter constraints
			break;
		}
	}

	// FIXME: how to deal with multi-constraint?
	if (op->is_register)
		op->is_memory = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movq 0x28(%r12), %rax
leaq 0x4(%rax), %r14
movzbl 0x4(%rax), %ecx
testl %ecx, %ecx
je 0x38b68
cmpl $0x2b, %ecx
je 0x38b53
cmpl $0x3d, %ecx
jne 0x38b7b
movb 0x18(%rbx), %cl
jmp 0x38b59
movb 0x18(%rbx), %cl
orb $0x2, %cl
orb $0x1, %cl
movb %cl, 0x18(%rbx)
addq $0x5, %rax
movq %rax, %r14
jmp 0x38b7b
movq 0x8(%r12), %rdi
leaq 0x11ece(%rip), %rsi     # 0x4aa42
xorl %eax, %eax
callq 0x11a80
leaq 0x10f72(%rip), %r13     # 0x49af4
leaq 0x11ed5(%rip), %r15     # 0x4aa5e
leaq 0x2bbb0(%rip), %rbp     # 0x64740
movzbl (%r14), %eax
incq %r14
movsbl %al, %edx
cmpl $0x55, %eax
jg 0x38bc2
leal -0x25(%rax), %ecx
cmpl $0x2c, %ecx
ja 0x38bfa
movslq (%r13,%rcx,4), %rax
addq %r13, %rax
jmpq *%rax
movq 0x8(%r12), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x11a80
jmp 0x38b90
cmpl $0x6e, %eax
jg 0x38bd8
cmpl $0x56, %eax
je 0x38be8
cmpl $0x6d, %eax
je 0x38be8
cmpl $0x5b, %eax
jne 0x38bfe
jmp 0x38c29
cmpl $0x6f, %eax
je 0x38be8
cmpl $0x72, %eax
jne 0x38bfe
orb $0x10, 0x18(%rbx)
jmp 0x38b90
orb $0x20, 0x18(%rbx)
jmp 0x38b90
orb $0x8, 0x18(%rbx)
jmp 0x38b90
orb $0x4, 0x18(%rbx)
jmp 0x38b90
testl %eax, %eax
je 0x38c1d
movq (%rbp), %rax
movq 0x68(%rax), %rax
testq %rax, %rax
je 0x38b90
movq %rbx, %rdi
movl %edx, %esi
movq %r14, %rdx
callq *%rax
movq %rax, %r14
jmp 0x38b90
movb 0x18(%rbx), %al
testb $0x10, %al
je 0x38c29
andb $-0x21, %al
movb %al, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq