LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/tokenize.c
// Function: get_one_number
static int get_one_number(int c, int next, stream_t *stream)
{
	struct token *token;
	static char buffer[4095];
	char *p = buffer, *buffer_end = buffer + sizeof (buffer);

	*p++ = c;
	for (;;) {
		long class =  cclass[next + 1];
		if (!(class & (Dot | Digit | Letter)))
			break;
		if (p != buffer_end)
			*p++ = next;
		next = nextchar(stream);
		if (class & Exp) {
			if (next == '-' || next == '+') {
				if (p != buffer_end)
					*p++ = next;
				next = nextchar(stream);
			}
		}
	}

	if (p == buffer_end) {
		sparse_error(stream_pos(stream), "number token exceeds %td characters",
		      buffer_end - buffer);
		// Pretend we saw just "1".
		buffer[0] = '1';
		p = buffer + 1;
	}

	*p++ = 0;
	token = stream->token;
	token_type(token) = TOKEN_NUMBER;
	token->number = xmemdup(buffer, p - buffer);
	add_token(stream);

	return next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movb %dil, 0x5c3e3(%rip)     # 0x86620
leaq 0x5c3dd(%rip), %r15     # 0x86621
leaq 0x5d3d4(%rip), %r13     # 0x8761f
leal 0x1(%r14), %eax
leaq 0x1719a(%rip), %rcx     # 0x413f0
movzbl (%rax,%rcx), %r12d
testb $0x13, %r12b
je 0x2a2b4
movq %r13, %rbp
cmpq %r13, %r15
je 0x2a272
movb %r14b, (%r15)
incq %r15
movq %r15, %rbp
movq %rbx, %rdi
callq 0x2a08b
movl %eax, %r14d
movq %rbp, %r15
testb $0x8, %r12b
je 0x2a24b
cmpl $0x2d, %r14d
je 0x2a295
movq %rbp, %r15
cmpl $0x2b, %r14d
jne 0x2a24b
movq %r13, %r15
cmpq %r13, %rbp
je 0x2a2a7
movb %r14b, (%rbp)
incq %rbp
movq %rbp, %r15
movq %rbx, %rdi
callq 0x2a08b
movl %eax, %r14d
jmp 0x2a24b
leaq 0x5d364(%rip), %rax     # 0x8761f
cmpq %rax, %r15
jne 0x2a2ec
movq %rbx, %rdi
callq 0x2a052
leaq 0x17425(%rip), %rsi     # 0x416f4
movl $0xfff, %edx            # imm = 0xFFF
movq %rax, %rdi
xorl %eax, %eax
callq 0x1120e
movb $0x31, 0x5c33b(%rip)    # 0x86620
leaq 0x5c335(%rip), %r15     # 0x86621
movb $0x0, (%r15)
movq 0x28(%rbx), %r12
movq (%r12), %rax
andq $-0x40, %rax
orq $0x5, %rax
movq %rax, (%r12)
leaq 0x5c315(%rip), %rdi     # 0x86620
subq %rdi, %r15
incq %r15
movq %r15, %rsi
callq 0x2a5d2
movq %rax, 0x10(%r12)
movq 0x28(%rbx), %rax
andq $0x0, 0x28(%rbx)
leaq 0x8(%rax), %rcx
andq $0x0, 0x8(%rax)
movq 0x20(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x20(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/allocate.c
// Function: drop_all_allocations
void drop_all_allocations(struct allocator_struct *desc)
{
	struct allocation_blob *blob = desc->blobs;

	desc->blobs = NULL;
	desc->allocations = 0;
	desc->total_bytes = 0;
	desc->useful_bytes = 0;
	desc->freelist = NULL;
	while (blob) {
		struct allocation_blob *next = blob->next;
		blob_free(blob, desc->chunking);
		blob = next;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
andq $0x0, 0x8(%rbx)
andl $0x0, 0x20(%rbx)
andq $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
testq %rdi, %rdi
je 0x2a743
movq (%rdi), %r14
movl 0x14(%rbx), %esi
callq 0x2bddf
movq %r14, %rdi
jmp 0x2a72e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/allocate.c
// Function: allocate
void *allocate(struct allocator_struct *desc, unsigned int size)
{
	unsigned long alignment = desc->alignment;
	struct allocation_blob *blob = desc->blobs;
	void *retval;

	/*
	 * NOTE! The freelist only works with things that are
	 *  (a) sufficiently aligned
	 *  (b) use a constant size
	 * Don't try to free allocators that don't follow
	 * these rules.
	 */
	if (desc->freelist) {
		void **p = desc->freelist;
		retval = p;
		desc->freelist = *p;
		do {
			*p = NULL;
			p++;
		} while ((size -= sizeof(void *)) > 0);
		return retval;
	}

	desc->allocations++;
	desc->useful_bytes += size;
	size = (size + alignment - 1) & ~(alignment-1);
	if (!blob || blob->left < size) {
		unsigned int offset, chunking = desc->chunking;
		struct allocation_blob *newblob = blob_alloc(chunking);
		if (!newblob)
			die("out of memory");
		if (size > chunking)
			die("alloc too big");
		desc->total_bytes += chunking;
		newblob->next = blob;
		blob = newblob;
		desc->blobs = newblob;
		offset = offsetof(struct allocation_blob, data);
		offset = (offset + alignment - 1) & ~(alignment-1);
		blob->left = chunking - offset;
		blob->offset = offset - offsetof(struct allocation_blob, data);
	}
	retval = blob->data + blob->offset;
	blob->offset += size;
	blob->left -= size;
	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x2a78b
movq (%rax), %rcx
movq %rcx, 0x18(%r14)
movl %esi, %ecx
xorl %edx, %edx
andq $0x0, (%rax,%rdx)
addq $0x8, %rdx
cmpl %edx, %ecx
jne 0x2a779
jmp 0x2a814
movl 0x10(%r14), %r13d
movq 0x8(%r14), %r12
incl 0x20(%r14)
movl %esi, %eax
addq %rax, 0x30(%r14)
leal (%rsi,%r13), %eax
decl %eax
movq %r13, %r15
negq %r15
movl %r15d, %ebp
andl %eax, %ebp
testq %r12, %r12
je 0x2a7bc
movl 0x8(%r12), %ebx
cmpl %ebp, %ebx
jae 0x2a7f6
movl 0x14(%r14), %ebx
movq %rbx, %rdi
callq 0x2bda4
testq %rax, %rax
je 0x2a823
cmpl %ebp, %ebx
jb 0x2a82c
addq %rbx, 0x28(%r14)
movq %r12, (%rax)
movq %rax, 0x8(%r14)
addl $0xf, %r13d
andl %r13d, %r15d
subl %r15d, %ebx
movl %ebx, 0x8(%rax)
addl $-0x10, %r15d
movl %r15d, 0xc(%rax)
movq %rax, %r12
jmp 0x2a7fb
movl 0xc(%r12), %r15d
movl %r15d, %eax
addq %r12, %rax
addq $0x10, %rax
addl %ebp, %r15d
movl %r15d, 0xc(%r12)
subl %ebp, %ebx
movl %ebx, 0x8(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x170ce(%rip), %rdi     # 0x418f8
jmp 0x2a833
leaq 0x170d3(%rip), %rdi     # 0x41906
xorl %eax, %eax
callq 0x113be
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/allocate.c
// Function: show_allocations
void show_allocations(struct allocator_struct *x)
{
	fprintf(stderr, "%s: %d allocations, %lu bytes (%lu total bytes, "
			"%6.2f%% usage, %6.2f average size)\n",
		x->name, x->allocations, x->useful_bytes, x->total_bytes,
		100 * (double) x->useful_bytes / x->total_bytes,
		(double) x->useful_bytes / x->allocations);
}

// Assembly:
movq %rdi, %rax
movq 0x2f7ac(%rip), %rcx     # 0x59ff0
movq (%rcx), %rdi
movq (%rax), %rdx
movl 0x20(%rax), %ecx
movq 0x30(%rax), %r8
movq 0x28(%rax), %r9
movq %r8, %xmm0
movq 0x1706e(%rip), %xmm2    # 0x418d0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0x17072(%rip), %xmm3    # 0x418e0
subpd %xmm3, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x1706a(%rip), %xmm0    # 0x418f0
mulsd %xmm1, %xmm0
movq %r9, %xmm4
punpckldq %xmm2, %xmm4    # xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1]
subpd %xmm3, %xmm4
movapd %xmm4, %xmm2
unpckhpd %xmm4, %xmm2            # xmm2 = xmm2[1],xmm4[1]
addsd %xmm4, %xmm2
cvtsi2sd %rcx, %xmm3
divsd %xmm2, %xmm0
divsd %xmm3, %xmm1
leaq 0x1705d(%rip), %rsi     # 0x41914
movb $0x2, %al
jmp 0xe1d0
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/builtin.c
// Function: declare_builtins
void declare_builtins(int stream, const struct builtin_fn tbl[])
{
	if (!tbl)
		return;

	while (tbl->name)
		declare_builtin(stream, tbl++);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, 0x4(%rsp)
testq %rsi, %rsi
je 0x2b219
movq %rsi, %rbx
leaq 0x18(%rsi), %r12
pushq $0x3
popq %r14
leaq 0x5e4e2(%rip), %rbp     # 0x89620
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x2b219
movl 0x4(%rsp), %edi
movl %r14d, %edx
pushq $0x10
popq %rcx
callq 0x274d6
movq %rax, %r13
movq 0x4(%rax), %rdi
pushq $0x5
popq %rsi
callq 0x2671f
movq %rax, %r15
movq %rax, 0x60(%r13)
movq $0x10, 0x68(%r13)
orb $0x8, 0x56(%r13)
movq 0x50(%rbx), %rax
movq %rax, 0x40(%r13)
movq 0x8(%rbx), %rax
cmpq %rbp, %rax
jne 0x2b197
leaq 0x3348c(%rip), %rax     # 0x5e620
movq (%rax), %rax
movq %rax, 0x60(%r15)
movq %rbx, 0x10(%rsp)
movzbl 0x10(%rbx), %eax
andl $0x1, %eax
shll $0x9, %eax
movl 0x54(%r15), %ecx
movl $0xfffffdff, %edx       # imm = 0xFFFFFDFF
andl %edx, %ecx
orl %eax, %ecx
movl %ecx, 0x54(%r15)
addq $0x88, %r15
movq %r12, 0x8(%rsp)
movq %r12, %rbx
movq (%rbx), %r12
testq %r12, %r12
je 0x2b202
movq 0x4(%r13), %rdi
movl %r14d, %esi
callq 0x2671f
cmpq %rbp, %r12
jne 0x2b1ed
leaq 0x33436(%rip), %rcx     # 0x5e620
movq (%rcx), %r12
movq %r12, 0x60(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x1fae9
addq $0x8, %rbx
jmp 0x2b1ca
movq 0x10(%rsp), %rbx
addq $0x58, %rbx
movq 0x8(%rsp), %r12
addq $0x58, %r12
jmp 0x2b13e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/builtin.c
// Function: eval_args
static int eval_args(struct expression *expr, int n)
{
	struct expression *arg;
	struct symbol *sym;
	const char *msg;
	int rc = 1;

	FOR_EACH_PTR(expr->args, arg) {
		if (n-- == 0) {
			msg = "too many arguments";
			goto error;
		}
		if (!evaluate_expression(arg))
			rc = 0;
	} END_FOR_EACH_PTR(arg);
	if (n > 0) {
		msg = "not enough arguments";
		goto error;
	}
	return rc;

error:
	sym = expr->fn->ctype;
	expression_error(expr, "%s for %s", msg, show_ident(sym->ident));
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, (%rsp)
movq 0x28(%rdi), %r14
pushq $0x1
popq %rbp
testq %r14, %r14
je 0x2b2ba
xorl %r13d, %r13d
movq %r14, %r12
xorl %ebx, %ebx
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %rbx
jge 0x2b2b0
movq 0x18(%r12,%rbx,8), %rdi
cmpw $0x100, %ax             # imm = 0x100
jb 0x2b297
testq %rdi, %rdi
je 0x2b2ab
testl %r15d, %r15d
je 0x2b2c8
decl %r15d
callq 0x2d0ed
testq %rax, %rax
cmovel %r13d, %ebp
incq %rbx
jmp 0x2b27a
movq 0x10(%r12), %r12
cmpq %r14, %r12
jne 0x2b278
testl %r15d, %r15d
jle 0x2b2fd
leaq 0x1678a(%rip), %r14     # 0x41a50
jmp 0x2b2cf
leaq 0x1676e(%rip), %r14     # 0x41a3d
movq (%rsp), %rbx
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x2936d
leaq 0x1677a(%rip), %rsi     # 0x41a65
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x11292
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/builtin.c
// Function: evaluate_choose
static int evaluate_choose(struct expression *expr)
{
	struct expression_list *list = expr->args;
	struct expression *arg, *args[3];
	int n = 0;

	/* there will be exactly 3; we'd already verified that */
	FOR_EACH_PTR(list, arg) {
		args[n++] = arg;
	} END_FOR_EACH_PTR(arg);

	*expr = get_expression_value(args[0]) ? *args[1] : *args[2];

	return 1;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
xorl %ecx, %ecx
movq %rax, %rdx
movzwl (%rdx), %esi
movsbl %sil, %edi
testw %di, %di
movl $0x0, %r8d
cmovgl %edi, %r8d
movzwl %r8w, %edi
xorl %r8d, %r8d
cmpq %r8, %rdi
je 0x2b597
movq 0x18(%rdx,%r8,8), %r9
cmpw $0x100, %si             # imm = 0x100
jb 0x2b589
testq %r9, %r9
je 0x2b592
movslq %ecx, %r10
incl %ecx
movq %r9, (%rsp,%r10,8)
incq %r8
jmp 0x2b573
movq 0x10(%rdx), %rdx
cmpq %rax, %rdx
jne 0x2b558
movq (%rsp), %rdi
callq 0xfe1b
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
movq 0x8(%rsp,%rcx,8), %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)
pushq $0x1
popq %rax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/builtin.c
// Function: expand_constant_p
static int expand_constant_p(struct expression *expr, int cost)
{
	expr->type = EXPR_VALUE;
	expr->value = !cost;
	expr->taint = 0;
	return 0;
}

// Assembly:
movb $0x1, (%rdi)
xorl %eax, %eax
testl %esi, %esi
sete %al
movq %rax, 0x20(%rdi)
andl $0x0, 0x28(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/builtin.c
// Function: expand_expect
static int expand_expect(struct expression *expr, int cost)
{
	struct expression *arg = first_ptr_list((struct ptr_list *) expr->args);

	if (arg)
		*expr = *arg;
	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x1f919
testq %rax, %rax
je 0x2b63d
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)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/builtin.c
// Function: expand_safe_p
static int expand_safe_p(struct expression *expr, int cost)
{
	expr->type = EXPR_VALUE;
	expr->value = (cost < SIDE_EFFECTS);
	expr->taint = 0;
	return 0;
}

// Assembly:
movb $0x1, (%rdi)
xorl %eax, %eax
cmpl $0x2710, %esi           # imm = 0x2710
setl %al
movq %rax, 0x20(%rdi)
andl $0x0, 0x28(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/builtin.c
// Function: expand_warning
static int expand_warning(struct expression *expr, int cost)
{
	struct expression *arg;
	struct expression_list *arglist = expr->args;

	FOR_EACH_PTR (arglist, arg) {
		/*
		 * Constant strings get printed out as a warning. By the
		 * time we get here, the EXPR_STRING has been fully 
		 * evaluated, so by now it's an anonymous symbol with a
		 * string initializer.
		 *
		 * Just for the heck of it, allow any constant string
		 * symbol.
		 */
		if (arg->type == EXPR_SYMBOL) {
			struct symbol *sym = arg->symbol;
			if (sym->initializer && sym->initializer->type == EXPR_STRING) {
				struct string *string = sym->initializer->string;
				warning(expr->pos, "%*s", string->length-1, string->data);
			}
			continue;
		}

		/*
		 * Any other argument is a conditional. If it's
		 * non-constant, or it is false, we exit and do
		 * not print any warning.
		 */
		if (arg->type != EXPR_VALUE)
			goto out;
		if (!arg->value)
			goto out;
	} END_FOR_EACH_PTR(arg);
out:
	expr->type = EXPR_VALUE;
	expr->value = 1;
	expr->taint = 0;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r15
testq %r15, %r15
je 0x2b6fb
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
leaq 0x1724d(%rip), %r14     # 0x428ce
movq %r15, %r12
xorl %r13d, %r13d
movl (%r12), %ecx
movsbq %cl, %rax
cmpq %rax, %r13
jge 0x2b6f1
movq 0x18(%r12,%r13,8), %rax
cmpw $0x100, %cx             # imm = 0x100
jb 0x2b6a5
testq %rax, %rax
je 0x2b6ec
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x2b6e5
cmpl $0x3, %ecx
jne 0x2b6fb
movq 0x20(%rax), %rax
movq 0xb0(%rax), %rax
testq %rax, %rax
je 0x2b6ec
cmpb $0x2, (%rax)
jne 0x2b6ec
movq 0x28(%rax), %rcx
movl (%rcx), %edx
andl %ebp, %edx
decl %edx
addq $0x4, %rcx
movq 0x8(%rbx), %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1108a
jmp 0x2b6ec
cmpq $0x0, 0x20(%rax)
je 0x2b6fb
incq %r13
jmp 0x2b687
movq 0x10(%r12), %r12
cmpq %r15, %r12
jne 0x2b684
movb $0x1, (%rbx)
movq $0x1, 0x20(%rbx)
andl $0x0, 0x28(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/builtin.c
// Function: evaluate_overflow_gen
static int evaluate_overflow_gen(struct expression *expr, int ptr)
{
	struct expression *arg;
	int n = 0;

	/* there will be exactly 3; we'd already verified that */
	FOR_EACH_PTR(expr->args, arg) {
		struct symbol *type;

		n++;
		if (!arg || !(type = arg->ctype))
			return 0;
		// 1st & 2nd args must be a basic integer type
		// 3rd arg must be a pointer to such a type.
		if (n == 3 && ptr) {
			if (type->type == SYM_NODE)
				type = type->ctype.base_type;
			if (!type)
				return 0;
			if (type->type != SYM_PTR)
				goto err;
			type = type->ctype.base_type;
			if (!type)
				return 0;
		}
		if (type->type == SYM_NODE)
			type = type->ctype.base_type;
		if (!type)
			return 0;
		if (type->ctype.base_type != &int_type || type == &bool_ctype)
			goto err;
	} END_FOR_EACH_PTR(arg);

	// the builtin returns a bool
	expr->ctype = &bool_ctype;
	return 1;

err:
	sparse_error(arg->pos, "invalid type for argument %d:", n);
	info(arg->pos, "        %s", show_typename(arg->ctype));
	expr->ctype = &bad_ctype;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
pushq $0x1
popq %rbp
testq %rdi, %rdi
je 0x2b819
xorl %edx, %edx
leaq 0x398f1(%rip), %rcx     # 0x65038
leaq 0x3972a(%rip), %r9      # 0x64e78
movq %rdi, %r10
movzwl (%r10), %r11d
movsbl %r11b, %eax
testw %ax, %ax
movl $0x0, %r8d
cmovgl %eax, %r8d
movzwl %r8w, %r15d
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x2b807
movq 0x18(%r10,%r12,8), %r14
cmpw $0x100, %r11w           # imm = 0x100
jb 0x2b788
testq %r14, %r14
je 0x2b7ff
xorl %eax, %eax
testq %r14, %r14
je 0x2b866
movq 0x10(%r14), %r13
testq %r13, %r13
je 0x2b866
incl %edx
testl %esi, %esi
sete %r8b
cmpl $0x3, %edx
setne %bpl
orb %r8b, %bpl
jne 0x2b7e4
movzbl (%r13), %r8d
cmpl $0x3, %r8d
jne 0x2b7d1
movq 0x60(%r13), %r13
testq %r13, %r13
je 0x2b866
movzbl (%r13), %r8d
cmpl $0x4, %r8d
jne 0x2b822
movq 0x60(%r13), %r13
testq %r13, %r13
je 0x2b866
cmpb $0x3, (%r13)
jne 0x2b7f4
movq 0x60(%r13), %r13
testq %r13, %r13
je 0x2b866
cmpq %rcx, %r13
je 0x2b827
cmpq %r9, 0x60(%r13)
jne 0x2b827
incq %r12
jmp 0x2b76d
movq 0x10(%r10), %r10
cmpq %rdi, %r10
jne 0x2b751
pushq $0x1
popq %rbp
jmp 0x2b860
leaq 0x39818(%rip), %rcx     # 0x65038
jmp 0x2b860
pushq $0x3
popq %rax
movl %eax, %edx
movq 0x8(%r14), %rdi
leaq 0x1707e(%rip), %rsi     # 0x428b0
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x1120e
movq 0x10(%r14), %rdi
callq 0x20b5a
movq 0x8(%r14), %rdi
leaq 0x161e3(%rip), %rsi     # 0x41a32
movq %rax, %rdx
xorl %eax, %eax
callq 0x10ddc
leaq 0x3b058(%rip), %rcx     # 0x668b8
movq %rcx, 0x10(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/builtin.c
// Function: evaluate_pure_unop
static int evaluate_pure_unop(struct expression *expr)
{
	struct expression *arg = first_expression(expr->args);
	int flags = arg->flags;

	/*
	 * Allow such functions with a constant integer expression
	 * argument to be treated as a *constant* integer.
	 * This allow us to use them in switch() { case ...:
	 */
	flags |= (flags & CEF_ICE) ? CEF_SET_INT : 0;
	expr->flags = flags;
	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x1f919
movl (%rax), %eax
movl %eax, %ecx
andl $0xff00, %ecx           # imm = 0xFF00
shll $0x13, %eax
sarl $0x1f, %eax
andl $0x3100, %eax           # imm = 0x3100
movl $0xffff00ff, %edx       # imm = 0xFFFF00FF
andl (%rbx), %edx
orl %ecx, %edx
orl %eax, %edx
movl %edx, (%rbx)
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/builtin.c
// Function: expand_bswap
static int expand_bswap(struct expression *expr, int cost)
{
	struct expression *arg;
	long long val;

	if (cost)
		return cost;

	/* the arguments number & type have already been checked */
	arg = first_expression(expr->args);
	val = get_expression_value_silent(arg);
	switch (expr->ctype->bit_size) {
	case 16: expr->value = bswap16(val); break;
	case 32: expr->value = bswap32(val); break;
	case 64: expr->value = bswap64(val); break;
	default: /* impossible error */
		return SIDE_EFFECTS;
	}

	expr->type = EXPR_VALUE;
	expr->taint = 0;
	return 0;
}

// Assembly:
testl %esi, %esi
jne 0x2b902
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x1f919
movq %rax, %rdi
callq 0xfed5
movq 0x10(%rbx), %rcx
movl 0x50(%rcx), %ecx
cmpl $0x40, %ecx
je 0x2b8f1
cmpl $0x20, %ecx
je 0x2b8ed
movl $0x2710, %esi           # imm = 0x2710
cmpl $0x10, %ecx
jne 0x2b901
rolw $0x8, %ax
movzwl %ax, %eax
jmp 0x2b8f4
bswapl %eax
jmp 0x2b8f4
bswapq %rax
movq %rax, 0x20(%rbx)
movb $0x1, (%rbx)
andl $0x0, 0x28(%rbx)
xorl %esi, %esi
popq %rbx
movl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/builtin.c
// Function: expand_isdigit
static int expand_isdigit(struct expression *expr, int cost)
{
	struct expression *arg = first_expression(expr->args);
	long long val = get_expression_value_silent(arg);

	if (cost)
		return cost;

	expr->value = (val >= '0') && (val <= '9');
	expr->type = EXPR_VALUE;
	expr->taint = 0;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
callq 0x1f919
movq %rax, %rdi
callq 0xfed5
testl %ebx, %ebx
jne 0x2bad7
addq $-0x30, %rax
xorl %ecx, %ecx
cmpq $0xa, %rax
setb %cl
movq %rcx, 0x20(%r14)
movb $0x1, (%r14)
andl $0x0, 0x28(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/builtin.c
// Function: evaluate_fp_unop
static int evaluate_fp_unop(struct expression *expr)
{
	struct expression *arg;

	if (!eval_args(expr, 1))
		return 0;

	arg = first_expression(expr->args);
	if (!is_float_type(arg->ctype)) {
		expression_error(expr, "non-floating-point argument in call to %s()",
			show_ident(expr->fn->ctype->ident));
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x2b254
testl %eax, %eax
je 0x2bb41
movq 0x28(%rbx), %rdi
callq 0x1f919
movq 0x10(%rax), %rax
cmpb $0x3, (%rax)
jne 0x2bb0b
movq 0x60(%rax), %rax
movq 0x60(%rax), %rax
cmpq 0x2e43a(%rip), %rax     # 0x59f50
je 0x2bb43
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x2936d
leaq 0x16da2(%rip), %rsi     # 0x428d2
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x11292
jmp 0x2bb43
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/builtin.c
// Function: expand_object_size
static int expand_object_size(struct expression *expr, int cost)
{
	struct expression *arg = first_expression(expr->args);
	int type = get_expression_value_silent(ptr_list_nth(expr->args, 1));
	unsigned long val = -1, off = 0;

	while (arg) {
		switch (arg->type) {
		case EXPR_IMPLIED_CAST:
		case EXPR_CAST:
			// ignore those
			arg = arg->cast_expression;
			continue;
		case EXPR_BINOP:
			// a constant add is (maybe) an offset
			if (!arg->right || arg->op != '+' || arg->right->type != EXPR_VALUE)
				break;
			off += arg->right->value;
			arg = arg->left;
			continue;
		case EXPR_PREOP:
			// a deref is just intermediate variable
			// and so the offset needs to be zeroed.
			if (arg->op == '*') {
				struct expression *parent = arg;
				arg = arg->unop;
				off = 0;
				switch (arg->type) {
				case EXPR_SYMBOL:
					arg = arg->symbol->initializer;
					if (arg == parent) {
						// stop at self-initialized vars
						// and do not expand them.
						arg = NULL;
						val = -1;
						break;
					}
					continue;
				default:
					break;
				}
			}
			break;
		case EXPR_SYMBOL:
			// the symbol we're looking after
			val = bits_to_bytes(arg->symbol->bit_size);
			break;
		case EXPR_CALL:
			// use alloc_size() attribute but only after linearization.
			return UNSAFE;
		default:
			break;
		}
		break;
	}

	if (val == -1)
		val = (type & 2) ? 0 : val;
	else if (type & 1)
		return UNSAFE;
	else
		val -= off;

	expr->flags |= CEF_SET_ICE;
	expr->type = EXPR_VALUE;
	expr->value = val;
	expr->taint = 0;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x1f919
movq %rax, %r14
movq 0x28(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x1f965
movq %rax, %rdi
callq 0xfed5
movq %rax, %rcx
xorl %esi, %esi
leaq 0x15e65(%rip), %rax     # 0x419e4
testq %r14, %r14
je 0x2bc1f
movzbl (%r14), %edx
leal -0x3(%rdx), %edi
cmpl $0xa, %edi
ja 0x2bbec
movslq (%rax,%rdi,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movq 0x28(%r14), %r14
jmp 0x2bb7f
cmpl $0x2a, 0x4(%r14)
jne 0x2bc1f
movq 0x20(%r14), %rdx
cmpb $0x3, (%rdx)
jne 0x2bc1f
movq 0x20(%rdx), %rdx
movq 0xb0(%rdx), %rdx
movl $0x0, %esi
cmpq %r14, %rdx
movq %rdx, %r14
jne 0x2bb7f
jmp 0x2bc1f
movq 0x28(%r14), %rdx
testq %rdx, %rdx
je 0x2bc1f
cmpl $0x2b, 0x4(%r14)
jne 0x2bc1f
cmpb $0x1, (%rdx)
jne 0x2bc1f
addq 0x20(%rdx), %rsi
movq 0x20(%r14), %r14
jmp 0x2bb7f
cmpl $0x14, %edx
je 0x2bc4b
jmp 0x2bc1f
movq 0x20(%r14), %rax
movl 0x50(%rax), %eax
testl %eax, %eax
js 0x2bc1f
leaq 0x32afb(%rip), %rdx     # 0x5e700
movl (%rdx), %edi
addl %edi, %eax
decl %eax
cltd
idivl %edi
cmpl $-0x1, %eax
je 0x2bc1f
testb $0x1, %cl
jne 0x2bc4b
cltq
subq %rsi, %rax
jmp 0x2bc2a
xorl %eax, %eax
btl $0x1, %ecx
adcl $-0x1, %eax
cltq
movl $0xffffcf00, %ecx       # imm = 0xFFFFCF00
andl (%rbx), %ecx
orl $0x3001, %ecx           # imm = 0x3001
movl %ecx, (%rbx)
movq %rax, 0x20(%rbx)
andl $0x0, 0x28(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x64
popq %rax
jmp 0x2bc43
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/./compat/mmap-blob.c
// Function: blob_alloc
void *blob_alloc(unsigned long size)
{
	void *ptr;

	if (size & ~CHUNK)
		die("internal error: bad allocation size (%lu bytes)", size);
	ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
	if (ptr == MAP_FAILED)
		ptr = NULL;
	return ptr;
}

// Assembly:
pushq %rbx
movq %rdi, %rsi
testq $-0x8001, %rdi          # imm = 0xFFFF7FFF
jne 0x2bdd1
xorl %ebx, %ebx
pushq $0x3
popq %rdx
pushq $0x22
popq %rcx
pushq $-0x1
popq %r8
xorl %edi, %edi
xorl %r9d, %r9d
callq 0xe0e0
cmpq $-0x1, %rax
cmoveq %rbx, %rax
popq %rbx
retq
leaq 0x16b26(%rip), %rdi     # 0x428fe
xorl %eax, %eax
callq 0x113be
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/./compat/mmap-blob.c
// Function: blob_free
void blob_free(void *addr, unsigned long size)
{
	if (!size || (size & ~CHUNK) || ((unsigned long) addr & 512))
		die("internal error: bad blob free (%lu bytes at %p)", size, addr);
#ifndef DEBUG
	munmap(addr, size);
#else
	mprotect(addr, size, PROT_NONE);
#endif
}

// Assembly:
movq %rdi, %rdx
cmpq $0x8000, %rsi           # imm = 0x8000
jne 0x2be01
movl %edx, %eax
andl $0x200, %eax            # imm = 0x200
jne 0x2be01
movl $0x8000, %esi           # imm = 0x8000
movq %rdx, %rdi
jmp 0xe250
pushq %rax
leaq 0x16b25(%rip), %rdi     # 0x4292e
xorl %eax, %eax
callq 0x113be
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/cse.c
// Function: cse_one_instruction
static struct instruction * cse_one_instruction(struct instruction *insn, struct instruction *def)
{
	convert_instruction_target(insn, def->target);

	kill_instruction(insn);
	repeat_phase |= REPEAT_CSE;
	return def;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rsi
callq 0x34a2a
movq %r14, %rdi
xorl %esi, %esi
callq 0x21d6f
leaq 0x348e4(%rip), %rax     # 0x60d74
orb $0x1, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/dominate.c
// Function: idf_compute
void idf_compute(struct entrypoint *ep, struct basic_block_list **idf, struct basic_block_list *alpha)
{
	int levels = ep->dom_levels;
	struct piggy *bank = bank_init(levels);
	struct basic_block *bb;
	unsigned long generation = bb_generation;

	generation = bb_generation;
	generation += -generation & FLAGS;
	bb_generation = generation + (FLAGS + 1);

	// init all the nodes
	FOR_EACH_PTR(ep->bbs, bb) {
		// FIXME: this should be removed and the tests for
		//	  visited/in_phi/alpha should use a sparse set
		bb->generation = generation;
	} END_FOR_EACH_PTR(bb);

	FOR_EACH_PTR(alpha, bb) {
		bb->generation = generation | ALPHA;
		bank_put(bank, bb);
	} END_FOR_EACH_PTR(bb);

	while ((bb = bank_get(bank))) {
		visit(bank, idf, bb, bb->dom_level);
	}

	bank_free(bank, levels);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, (%rsp)
movq %rdi, %r12
movl 0x30(%rdi), %r13d
leaq 0x8(,%r13,8), %rsi
pushq $0x1
popq %rdi
callq 0xe1b0
movq %rax, %rbx
leal -0x1(%r13), %eax
movl %eax, (%rbx)
leaq 0x5da9f(%rip), %rax     # 0x89f78
movq (%rax), %rcx
movl %ecx, %edx
negl %edx
andl $0x7, %edx
leaq (%rdx,%rcx), %rbp
addq %rdx, %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
movq 0x18(%r12), %rax
testq %rax, %rax
je 0x2c52e
movq %rax, %rcx
xorl %edx, %edx
movl (%rcx), %esi
movsbq %sil, %rdi
cmpq %rdi, %rdx
jge 0x2c525
movq 0x18(%rcx,%rdx,8), %rdi
cmpw $0x100, %si             # imm = 0x100
jb 0x2c51c
testq %rdi, %rdi
je 0x2c520
movq %rbp, 0x8(%rdi)
incq %rdx
jmp 0x2c500
movq 0x10(%rcx), %rcx
cmpq %rax, %rcx
jne 0x2c4fe
testq %r14, %r14
je 0x2c575
orq $0x4, %rbp
movq %r14, %r12
xorl %r15d, %r15d
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jge 0x2c56b
movq 0x18(%r12,%r15,8), %rsi
cmpw $0x100, %ax             # imm = 0x100
jb 0x2c55a
testq %rsi, %rsi
je 0x2c566
movq %rbp, 0x8(%rsi)
movq %rbx, %rdi
callq 0x2c5ea
incq %r15
jmp 0x2c53d
movq 0x10(%r12), %r12
cmpq %r14, %r12
jne 0x2c53a
leaq 0x8(%rbx), %r12
movslq (%rbx), %rbp
leal -0x1(%rbp), %r14d
leaq (%r12,%rbp,8), %r15
movq %r15, %rdi
callq 0x1fdad
subq $0x1, %rbp
jb 0x2c5a3
testq %rax, %rax
jne 0x2c5a3
movl %r14d, (%rbx)
decl %r14d
addq $-0x8, %r15
jmp 0x2c584
testq %rax, %rax
je 0x2c5bc
movl 0x3c(%rax), %ecx
movq %rbx, %rdi
movq (%rsp), %rsi
movq %rax, %rdx
callq 0x2c61c
jmp 0x2c579
shlq $0x3, %r13
testq %r13, %r13
je 0x2c5d4
leaq (%rbx,%r13), %rdi
callq 0x1ff30
addq $-0x8, %r13
jmp 0x2c5c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe030
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/dominate.c
// Function: visit
static void visit(struct piggy *bank, struct basic_block_list **idf, struct basic_block *x, int curr_level)
{
	struct basic_block *y;

	x->generation |= 1;
	FOR_EACH_PTR(x->children, y) {
		unsigned flags = y->generation & FLAGS;
		if (y->idom == x)	// J-edges will be processed later
			continue;
		if (y->dom_level > curr_level)
			continue;
		if (flags & INPHI)
			continue;
		y->generation |= INPHI;
		add_bb(idf, y);
		if (flags & ALPHA)
			continue;
		bank_put(bank, y);
	} END_FOR_EACH_PTR(y);

	FOR_EACH_PTR(x->doms, y) {
		if (y->generation & VISITED)
			continue;
		visit(bank, idf, y, curr_level);
	} END_FOR_EACH_PTR(y);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movq %rdx, %r12
orb $0x1, 0x8(%rdx)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x20(%rdx), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0x2c6c6
movq (%rsp), %rbp
xorl %r15d, %r15d
movl (%rbp), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jge 0x2c6bc
movq 0x18(%rbp,%r15,8), %r13
cmpw $0x100, %ax             # imm = 0x100
jb 0x2c66d
testq %r13, %r13
je 0x2c6b7
cmpq %r12, 0x30(%r13)
je 0x2c6b7
movq 0x8(%r13), %r14
cmpl %ebx, 0x3c(%r13)
setle %al
testb $0x2, %r14b
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2c6b7
movq %r14, %rax
orq $0x2, %rax
movq %rax, 0x8(%r13)
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x1fae9
testb $0x4, %r14b
jne 0x2c6b7
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x2c5ea
incq %r15
jmp 0x2c651
movq 0x10(%rbp), %rbp
cmpq (%rsp), %rbp
jne 0x2c64e
movq 0x40(%r12), %r15
testq %r15, %r15
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %rbp
je 0x2c71f
movq %r15, %r12
xorl %r13d, %r13d
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jge 0x2c715
movq 0x18(%r12,%r13,8), %rdx
cmpw $0x100, %ax             # imm = 0x100
jb 0x2c6fd
testq %rdx, %rdx
je 0x2c710
testb $0x1, 0x8(%rdx)
jne 0x2c710
movq %rbp, %rdi
movq %r14, %rsi
movl %ebx, %ecx
callq 0x2c61c
incq %r13
jmp 0x2c6e0
movq 0x10(%r12), %r12
cmpq %r15, %r12
jne 0x2c6dd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x36162
movq (%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x2936d
leaq 0x16461(%rip), %rdi     # 0x42bb8
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
movq %rbx, 0x20(%rsp)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x2c87d
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x152b0(%rip), %r13     # 0x41a39
movq 0x18(%rsp), %rbp
xorl %ebx, %ebx
movl (%rbp), %eax
movsbq %al, %rcx
cmpq %rcx, %rbx
jge 0x2c86e
movq 0x18(%rbp,%rbx,8), %r12
cmpw $0x100, %ax             # imm = 0x100
jb 0x2c7b4
testq %r12, %r12
je 0x2c866
andq $0x0, 0x10(%rsp)
andq $0x0, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x1fae9
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x2c4a0
movq %r12, %rdi
callq 0x11a05
leaq 0x163d7(%rip), %rdi     # 0x42bc3
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x2c844
movq %r14, %r12
xorl %r15d, %r15d
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jge 0x2c83a
movq 0x18(%r12,%r15,8), %rdi
cmpw $0x100, %ax             # imm = 0x100
jb 0x2c823
testq %rdi, %rdi
je 0x2c835
callq 0x11a05
movq %r13, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
incq %r15
jmp 0x2c806
movq 0x10(%r12), %r12
cmpq %r14, %r12
jne 0x2c803
pushq $0xa
popq %rdi
callq 0xe040
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1ff30
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1ff30
incq %rbx
jmp 0x2c790
movq 0x10(%rbp), %rbp
cmpq 0x18(%rsp), %rbp
jne 0x2c78e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/evaluate.c
// Function: examine_fn_arguments
static void examine_fn_arguments(struct symbol *fn)
{
	struct symbol *s;

	FOR_EACH_PTR(fn->arguments, s) {
		struct symbol *arg = evaluate_symbol(s);
		/* Array/function arguments silently degenerate into pointers */
		if (arg) {
			struct symbol *ptr;
			switch(arg->type) {
			case SYM_ARRAY:
			case SYM_FN:
				ptr = alloc_symbol(s->pos, SYM_PTR);
				if (arg->type == SYM_ARRAY)
					ptr->ctype = arg->ctype;
				else
					ptr->ctype.base_type = arg;
				combine_address_space(s->pos, &ptr->ctype.as, s->ctype.as);
				ptr->ctype.modifiers |= s->ctype.modifiers & MOD_PTRINHERIT;

				s->ctype.base_type = ptr;
				s->ctype.as = NULL;
				s->ctype.modifiers &= ~MOD_PTRINHERIT;
				s->bit_size = 0;
				s->examined = 0;
				examine_symbol_type(s);
				break;
			default:
				/* nothing */
				break;
			}
		}
	} END_FOR_EACH_PTR(s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x88(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0x2ce22
pushq $0x4
popq %rbx
movq (%rsp), %rbp
xorl %r13d, %r13d
movl (%rbp), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jge 0x2ce14
movq 0x18(%rbp,%r13,8), %r14
cmpw $0x100, %ax             # imm = 0x100
jb 0x2cd65
testq %r14, %r14
je 0x2ce0c
movq %r14, %rdi
callq 0x3031d
testq %rax, %rax
je 0x2ce0c
movq %rax, %r12
movb (%rax), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0x2ce0c
movq 0x4(%r14), %rdi
movl %ebx, %esi
callq 0x2671f
movq %rax, %r15
addq $0x60, %rax
cmpb $0x6, (%r12)
jne 0x2cdbf
movq 0x80(%r12), %rcx
movq %rcx, 0x20(%rax)
movups 0x60(%r12), %xmm0
movups 0x70(%r12), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x2cdc2
movq %r12, (%rax)
movq %r15, %rsi
subq $-0x80, %rsi
movq 0x4(%r14), %rdi
movq 0x80(%r14), %rdx
callq 0x2cce9
movq 0x68(%r14), %rax
andl $0x1c001e00, %eax       # imm = 0x1C001E00
orq %rax, 0x68(%r15)
movq %r15, 0x60(%r14)
andq $0x0, 0x80(%r14)
andl $0xe3ffe1ff, 0x68(%r14) # imm = 0xE3FFE1FF
andl $0x0, 0x50(%r14)
andb $-0x9, 0x55(%r14)
movq %r14, %rdi
callq 0x267cd
incq %r13
jmp 0x2cd41
movq 0x10(%rbp), %rbp
cmpq (%rsp), %rbp
jne 0x2cd3e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
movzbl (%rdi), %eax
cmpl $0x3, %eax
jne 0x2f4f0
movq 0x60(%rdi), %rdi
movzbl (%rdi), %eax
cmpl $0xa, %eax
jne 0x2f50c
callq 0x267cd
movq %rax, %rdi
movzbl (%rax), %eax
cmpl $0x3, %eax
jne 0x2f50c
movq 0x60(%rdi), %rdi
movzbl (%rdi), %eax
cmpl $0x9, %eax
jne 0x2f515
movq 0x60(%rdi), %rdi
movq %rdi, (%rbx)
movzbl (%rdi), %eax
cmpq $0x2, %rax
jne 0x2f537
movq 0x60(%rdi), %rcx
cmpq 0x2aa54(%rip), %rcx     # 0x59f80
je 0x2f543
cmpq 0x2aa1b(%rip), %rcx     # 0x59f50
je 0x2f547
leaq 0x138c2(%rip), %rcx     # 0x42e00
movl (%rcx,%rax,4), %eax
jmp 0x2f54a
pushq $0x1
jmp 0x2f549
pushq $0x9
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rsi
movq %rbx, %rdx
callq 0x30681
movq 0x10(%r14), %rdi
cmpq 0x2aa3a(%rip), %rdi     # 0x59fb0
je 0x2f608
leaq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x3083a
movq %rax, %r15
movq %rsp, %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x3083a
cmpq %rax, %r15
je 0x2f5ae
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
jmp 0x2f5c7
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
cmpq 0x10(%rsp), %rdx
je 0x2f668
movl %eax, %edx
orl %ecx, %edx
btl $0x1a, %edx
jae 0x2f608
btl $0x1a, %ecx
leaq 0xb1f0(%rip), %rcx      # 0x3a7cc
leaq 0x13adb(%rip), %rsi     # 0x430be
cmovaeq %rcx, %rsi
btl $0x1a, %eax
leaq 0xd0a6(%rip), %rdx      # 0x3c698
cmovbq %rsi, %rdx
movq 0x8(%r14), %rdi
leaq 0x13ac5(%rip), %rsi     # 0x430c6
xorl %eax, %eax
callq 0x1108a
movq 0x8(%r14), %rdi
pushq $0xd
popq %rsi
callq 0x30712
movq %rax, %r15
movq %rbx, 0x10(%rax)
movq %rbx, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x30734
shll $0x8, %eax
movl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
andl (%r15), %ecx
orl %eax, %ecx
movl %ecx, (%r15)
cmpb $0x3, (%rbx)
jne 0x2f647
movq 0x60(%rbx), %rbx
cmpq 0x2a992(%rip), %rbx     # 0x59fe0
jne 0x2f658
movq %r15, %rdi
callq 0x30797
movq %r15, %r14
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rcx, %rdx
xorq %rax, %rdx
andq $-0x4000001, %rdx       # imm = 0xFBFFFFFF
je 0x2f65b
cmpq $0x200, %rdx            # imm = 0x200
je 0x2f608
jmp 0x2f5c7
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq 0x10(%r14), %rdi
movq %rsp, %rsi
movq %rdi, (%rsi)
callq 0x2f4dd
movl %eax, %ebp
testl %eax, %eax
setne %al
testb $0x20, %bpl
sete %cl
testb %cl, %al
je 0x2f9c2
movq 0x20(%rbx), %rax
cmpb $0x9, (%rax)
jne 0x2f9cb
cmpl $0x2a, 0x4(%rax)
jne 0x2f9cb
movq %rsp, %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x30ae2
testb $0x1, %bpl
jne 0x2f9ed
cmpl $0x10, %ebp
jne 0x2f9b9
movq (%rsp), %r15
movq %r15, %rdi
callq 0x270ef
testq %rax, %rax
je 0x2f99c
cmpb $0x5, (%rax)
je 0x2f9b9
movl 0x50(%rax), %eax
testl %eax, %eax
js 0x2fa0d
leaq 0x2ed56(%rip), %rcx     # 0x5e700
movl (%rcx), %ecx
addl %ecx, %eax
decl %eax
cltd
idivl %ecx
movl %eax, %ebp
testl %eax, %eax
jne 0x2f9f4
leaq 0x13b91(%rip), %rsi     # 0x43551
jmp 0x2f9d2
leaq 0x13b51(%rip), %rsi     # 0x4351a
jmp 0x2f9d2
leaq 0x13b5e(%rip), %rsi     # 0x43530
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11292
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rbp
movq (%rsp), %r15
movq 0x10(%r14), %rsi
movq %r14, %rdi
callq 0x31553
movslq %ebp, %rax
movq %rax, 0x28(%rbx)
movq %r15, 0x10(%rbx)
jmp 0x2f9df
pushq $-0x1
popq %rbp
jmp 0x2f9f4
// File: /workspace/github_c_makefile_star2_O2/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 0x3030d
cmpl $0x8, %eax
jne 0x3031b
cmpq $0x0, 0x90(%rsi)
jne 0x3031b
movq %rdi, %rbx
movq 0x18(%rsi), %rdi
callq 0x2936d
leaq 0x13536(%rip), %rsi     # 0x43836
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1120e
movq 0x59c5c(%rip), %rax     # 0x89f70
orl $0x100, 0x54(%rax)      # imm = 0x100
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %r15
leaq 0x135e2(%rip), %r12     # 0x43918
testq %rdi, %rdi
je 0x303fa
movl 0x54(%rdi), %eax
btl $0xd, %eax
jb 0x303fe
orl $0x2000, %eax           # imm = 0x2000
movl %eax, 0x54(%rdi)
callq 0x267cd
movq %rax, %r14
movq %rax, %rdi
callq 0x310b8
testq %rax, %rax
je 0x303fa
movq %rax, %rbx
cmpq $0x0, 0xb0(%r14)
je 0x303b0
leaq 0xb0(%r14), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x2f4dd
movq %r13, %rdi
xorl %esi, %esi
movl %eax, %edx
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x31867
testl %eax, %eax
jne 0x303b0
movq (%r13), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x11292
cmpb $0x5, (%rbx)
jne 0x30401
movq 0x59bb4(%rip), %r13     # 0x89f70
movq 0xc8(%r14), %rdi
testq %rdi, %rdi
je 0x303d1
cmpq %r14, %rdi
jne 0x30336
movq %r14, 0x59b98(%rip)     # 0x89f70
movq %rbx, %rdi
callq 0x2cd18
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x30412
callq 0x2fc99
movq %r13, 0x59b78(%rip)     # 0x89f70
jmp 0x30401
xorl %ebx, %ebx
jmp 0x30401
movq %rdi, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpq $0x0, 0xa0(%rbx)
je 0x303f1
cmpq $0x0, 0xc8(%r14)
je 0x303f1
movq %r14, %rdi
callq 0x10460
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
jne 0x303ec
jmp 0x303f1
// File: /workspace/github_c_makefile_star2_O2/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 0x30634
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x3079f(%rip), %r15     # 0x60d84
movq %rdi, %r12
xorl %r13d, %r13d
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jge 0x30621
movq 0x18(%r12,%r13,8), %r14
cmpw $0x100, %ax             # imm = 0x100
jb 0x30608
testq %r14, %r14
je 0x3061c
andb $-0x2, (%r15)
movq %r14, %rdi
callq 0x3031d
movq %r14, %rdi
callq 0x3043c
incq %r13
jmp 0x305eb
movq 0x10(%r12), %r12
cmpq %rbx, %r12
jne 0x305e8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x30674
movq %rdi, %rbx
cmpb $0x3, (%rdi)
jne 0x30676
testb $0xe, 0x69(%rbx)
je 0x30676
movq 0x4(%rbx), %rdi
xorl %esi, %esi
callq 0x2671f
movq %rax, %r14
movl $0xe0, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe1e0
andb $-0xf, 0x69(%r14)
movq %r14, %rbx
jmp 0x30676
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x29f17(%rip), %rax     # 0x5a5a4
cmpl $0x0, (%rax)
je 0x3070c
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpb $0x3, (%rsi)
jne 0x306a4
movq 0x60(%r15), %r15
cmpb $0x3, (%r14)
jne 0x306ae
movq 0x60(%r14), %r14
cmpq %r14, %r15
je 0x3070c
cmpb $0x9, (%r15)
jne 0x3070c
cmpb $0x9, (%r14)
jne 0x3070c
leaq 0x129db(%rip), %rsi     # 0x430a1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1108a
movq %r15, %rdi
callq 0x20b5a
leaq 0x11358(%rip), %r15     # 0x41a37
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10ddc
movq %r14, %rdi
callq 0x20b5a
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x10ddc
popq %rbx
popq %r14
popq %r15
retq