LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/pre-process.c
// Function: dup_token
static struct token *dup_token(struct token *token, struct position *streampos)
{
	struct token *alloc = alloc_token(streampos);
	token_type(alloc) = token_type(token);
	alloc->pos.newline = token->pos.newline;
	alloc->pos.whitespace = token->pos.whitespace;
	alloc->number = token->number;
	alloc->pos.noexpand = token->pos.noexpand;
	return alloc;	
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1fc92
movq (%rbx), %rdx
andl $0x3f, %edx
movq (%rax), %rcx
andq $-0x40, %rcx
orq %rdx, %rcx
movq %rcx, (%rax)
movq (%rbx), %rdx
andl $0x100000, %edx         # imm = 0x100000
andq $-0x100001, %rcx        # imm = 0xFFEFFFFF
orq %rdx, %rcx
movq %rcx, (%rax)
movq (%rbx), %rdx
andl $0x200000, %edx         # imm = 0x200000
andq $-0x200001, %rcx        # imm = 0xFFDFFFFF
orq %rdx, %rcx
movq %rcx, (%rax)
movq 0x10(%rbx), %rdx
movq %rdx, 0x10(%rax)
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
incq %rdx
andq (%rbx), %rdx
btrq $0x3f, %rcx
orq %rdx, %rcx
movq %rcx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/pre-process.c
// Function: add_path_entry
static void add_path_entry(struct token *token, const char *path,
	const char ***where)
{
	const char **dst;
	const char *next;

	/* Need one free entry.. */
	if (includepath[INCLUDEPATHS-2])
		error_die(token->pos, "too many include path entries");

	/* check that this is not a duplicate */
	dst = includepath;
	while (*dst) {
		if (strcmp(*dst, path) == 0)
			return;
		dst++;
	}
	next = path;
	dst = *where;

	update_inc_ptrs(where);

	/*
	 * Move them all up starting at dst,
	 * insert the new entry..
	 */
	do {
		const char *tmp = *dst;
		*dst = next;
		next = tmp;
		dst++;
	} while (next);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x42bb4(%rip)     # 0x64d00
jne 0x22222
movq %rdx, %r14
movq %rsi, %rbx
movq 0x42251(%rip), %rdi     # 0x643b0
testq %rdi, %rdi
je 0x22187
leaq 0x4224d(%rip), %r15     # 0x643b8
movq %rbx, %rsi
callq 0xe1c0
testl %eax, %eax
je 0x2221c
movq (%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x2216b
movq (%r14), %rax
movq 0x42ba7(%rip), %rcx     # 0x64d38
cmpq %rcx, %rax
ja 0x221ad
addq $0x8, %rcx
movq %rcx, 0x42b97(%rip)     # 0x64d38
leaq 0x42b90(%rip), %rcx     # 0x64d38
cmpq %rcx, %r14
je 0x2220a
movq 0x42b74(%rip), %rcx     # 0x64d28
cmpq %rcx, (%r14)
ja 0x221d0
addq $0x8, %rcx
movq %rcx, 0x42b64(%rip)     # 0x64d28
leaq 0x42b5d(%rip), %rcx     # 0x64d28
cmpq %rcx, %r14
je 0x2220a
movq 0x42b59(%rip), %rcx     # 0x64d30
cmpq %rcx, (%r14)
ja 0x221f3
addq $0x8, %rcx
movq %rcx, 0x42b49(%rip)     # 0x64d30
leaq 0x42b42(%rip), %rcx     # 0x64d30
cmpq %rcx, %r14
je 0x2220a
movq 0x42b1e(%rip), %rcx     # 0x64d18
cmpq %rcx, (%r14)
ja 0x2220a
addq $0x8, %rcx
movq %rcx, 0x42b0e(%rip)     # 0x64d18
movq (%rax), %rcx
movq %rbx, (%rax)
addq $0x8, %rax
movq %rcx, %rbx
testq %rcx, %rcx
jne 0x2220a
popq %rbx
popq %r14
popq %r15
retq
movq (%rdi), %rdi
leaq 0x250cb(%rip), %rsi     # 0x472f7
xorl %eax, %eax
callq 0x11b54
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/pre-process.c
// Function: token_defined
static int token_defined(struct token *token)
{
	if (token_type(token) == TOKEN_IDENT) {
		struct symbol *sym = lookup_macro(token->ident);
		if (sym) {
			sym->used_in = file_scope;
			return 1;
		}
		return 0;
	}

	sparse_error(token->pos, "expected preprocessor identifier");
	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rax
movq (%rdi), %rdi
movl %edi, %ecx
andl $0x3f, %ecx
cmpl $0x3, %ecx
jne 0x2226e
movq 0x10(%rax), %rdi
movl $0x81, %esi
callq 0x2b511
xorl %ebx, %ebx
testq %rax, %rax
je 0x22280
movl $0x1ff00, %edx          # imm = 0x1FF00
andl (%rax), %edx
xorl %ecx, %ecx
cmpl $0x100, %edx            # imm = 0x100
cmoveq %rax, %rcx
jmp 0x22282
leaq 0x250a0(%rip), %rsi     # 0x47315
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x11a38
jmp 0x2229a
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x2229a
leaq 0x42b0a(%rip), %rax     # 0x64d98
movq (%rax), %rax
movq %rax, 0x58(%rcx)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/pre-process.c
// Function: preprocessor_if
static int preprocessor_if(struct stream *stream, struct token *token, int cond)
{
	token_type(token) = false_nesting ? TOKEN_SKIP_GROUPS : TOKEN_IF;
	free_preprocessor_line(token->next);
	token->next = stream->top_if;
	stream->top_if = token;
	if (false_nesting || cond != 1)
		false_nesting++;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
cmpl $0x1, 0x47eb5(%rip)     # 0x6a164
movq %rsi, %r14
movl $0x1d, %eax
sbbq $0x0, %rax
movq %rdi, %r15
movq (%rsi), %rcx
movq 0x8(%rsi), %rdi
andq $-0x40, %rcx
orq %rax, %rcx
movq %rcx, (%rsi)
testb $0x3f, (%rdi)
je 0x222e7
movq 0x8(%rdi), %r12
callq 0x2fea9
testb $0x3f, (%r12)
movq %r12, %rdi
jne 0x222d4
movq 0x48(%r15), %rax
movq %rax, 0x8(%r14)
movq %r14, 0x48(%r15)
movl 0x47e6b(%rip), %eax     # 0x6a164
xorl $0x1, %ebx
orl %eax, %ebx
je 0x22308
incl %eax
movl %eax, 0x47e5c(%rip)     # 0x6a164
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/pre-process.c
// Function: replace_with_string
static void replace_with_string(struct token *token, const char *str)
{
	int size = strlen(str) + 1;
	struct string *s = __alloc_string(size);

	s->length = size;
	memcpy(s->data, str, size);
	token_type(token) = TOKEN_STRING;
	token->string = s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xe0d0
movq %rax, %r15
incl %r15d
movl %r15d, %edi
callq 0x300ef
movq %rax, %r12
movslq %r15d, %rdx
movl $0x80000000, %eax       # imm = 0x80000000
andl (%r12), %eax
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
orl %r15d, %eax
movl %eax, (%r12)
leaq 0x4(%r12), %rdi
movq %r14, %rsi
callq 0xe1e0
movq (%rbx), %rax
andq $-0x40, %rax
orq $0x10, %rax
movq %rax, (%rbx)
movq %r12, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ptrlist.c
// Function: ptr_list_size
int ptr_list_size(struct ptr_list *head)
{
	int nr = 0;

	if (head) {
		struct ptr_list *list = head;
		do {
			nr += list->nr - list->rm;
		} while ((list = list->next) != head);
	}
	return nr;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x225d7
movq %rdi, %rcx
movswl (%rcx), %edx
movsbl %dl, %esi
sarl $0x8, %edx
subl %edx, %esi
movswl %si, %edx
addl %edx, %eax
movq 0x10(%rcx), %rcx
cmpq %rdi, %rcx
jne 0x225be
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ptrlist.c
// Function: ptr_list_multiple
bool ptr_list_multiple(const struct ptr_list *head)
{
	const struct ptr_list *list = head;
	int nr = 0;

	if (!head)
		return false;

	do {
		nr += list->nr - list->rm;
		if (nr > 1)
			return true;
	} while ((list = list->next) != head);

	return false;
}

// Assembly:
xorl %edx, %edx
testq %rdi, %rdi
je 0x22631
movq %rdi, %rcx
movl %edx, %eax
movswl (%rcx), %edx
movsbl %dl, %esi
sarl $0x8, %edx
subl %edx, %esi
movswl %si, %edx
addl %eax, %edx
cmpl $0x2, %edx
setge %al
jge 0x22630
movq 0x10(%rcx), %rcx
cmpq %rdi, %rcx
jne 0x2260d
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ptrlist.c
// Function: last_ptr_list
void *last_ptr_list(struct ptr_list *head)
{
	struct ptr_list *list;

	if (!head)
		return NULL;
	list = head->prev;
	while (list->nr == 0) {
		if (list == head)
			return NULL;
		list = list->prev;
	}
	return PTR_ENTRY_NOTAG(list, list->nr-1);
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x2266f
movq %rdi, %rcx
movq 0x8(%rcx), %rcx
movl (%rcx), %edx
shll $0x8, %edx
testw %dx, %dx
jne 0x22670
cmpq %rdi, %rcx
jne 0x2265c
retq
movswl %dx, %eax
shrl $0x8, %eax
movswq %ax, %rax
movq 0x10(%rcx,%rax,8), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ptrlist.c
// Function: ptr_list_nth_entry
void *ptr_list_nth_entry(struct ptr_list *list, unsigned int idx)
{
	struct ptr_list *head = list;

	if (!head)
		return NULL;

	do {
		unsigned int nr = list->nr;

		if (idx < nr)
			return list->list[idx];
		else
			idx -= nr;
	} while ((list = list->next) != head);
	return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x226ac
movq %rdi, %rcx
movl %esi, %edx
movsbl (%rcx), %r8d
subl %r8d, %edx
jae 0x2269c
movl %esi, %eax
movq 0x18(%rcx,%rax,8), %rax
movl %esi, %edx
cmpl %r8d, %esi
jb 0x226ae
movq 0x10(%rcx), %rcx
movl %edx, %esi
cmpq %rdi, %rcx
jne 0x2268a
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ptrlist.c
// Function: linearize_ptr_list
int linearize_ptr_list(struct ptr_list *head, void **arr, int max)
{
	int nr = 0;
	if (head && max > 0) {
		struct ptr_list *list = head;

		do {
			int i = list->nr;
			nr += i;
			if (max == 0)
				continue;
			if (i > max) 
				i = max;
			memcpy(arr, list->list, i*sizeof(void *));
			arr += i;
			max -= i;
		} while ((list = list->next) != head);
	}
	return nr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testq %rdi, %rdi
sete %al
testl %edx, %edx
setle %cl
xorl %r15d, %r15d
orb %al, %cl
jne 0x2271f
movl %edx, %ebp
movq %rsi, %rbx
xorl %r15d, %r15d
movq (%rsp), %r12
movsbl (%r12), %r13d
testl %ebp, %ebp
je 0x2270f
cmpl %r13d, %ebp
movl %r13d, %eax
cmovll %ebp, %eax
leaq 0x18(%r12), %rsi
movslq %eax, %r14
leaq (,%r14,8), %rdx
movq %rbx, %rdi
callq 0xe1e0
leaq (%rbx,%r14,8), %rbx
subl %r14d, %ebp
jmp 0x22711
xorl %ebp, %ebp
addl %r13d, %r15d
movq 0x10(%r12), %r12
cmpq (%rsp), %r12
jne 0x226dc
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_O1/lucvoo[P]sparse-dev/ptrlist.c
// Function: pack_ptr_list
void pack_ptr_list(struct ptr_list **listp)
{
	struct ptr_list *head = *listp;

	if (head) {
		struct ptr_list *entry = head;
		do {
			struct ptr_list *next;
restart:
			next = entry->next;
			if (!entry->nr) {
				struct ptr_list *prev;
				if (next == entry) {
					__free_ptrlist(entry);
					*listp = NULL;
					return;
				}
				prev = entry->prev;
				prev->next = next;
				next->prev = prev;
				__free_ptrlist(entry);
				if (entry == head) {
					*listp = next;
					head = next;
					entry = next;
					goto restart;
				}
			}
			entry = next;
		} while (entry != head);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x227c7
movq %rdi, %rbx
leaq 0x425f0(%rip), %r14     # 0x64d40
movq %r15, %r12
movq 0x10(%r15), %r13
cmpb $0x0, (%r15)
je 0x2276d
xorl %eax, %eax
movq %r13, %r15
testb %al, %al
jne 0x227c7
cmpq %r12, %r15
jne 0x22753
jmp 0x227c7
cmpq %r15, %r13
je 0x227a5
movq 0x8(%r15), %rax
movq %r13, 0x10(%rax)
movq %rax, 0x8(%r13)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2fd30
xorl %eax, %eax
movl $0x0, %ecx
cmpq %r12, %r15
jne 0x227bc
movl $0x4, %ecx
movq %r13, %rax
movq %r13, %r15
movq %r13, %r12
jmp 0x227b7
movq %r14, %rdi
movq %r15, %rsi
callq 0x2fd30
movl $0x1, %ecx
xorl %eax, %eax
movq %rax, (%rbx)
movb $0x1, %al
testl %ecx, %ecx
je 0x2275d
cmpl $0x4, %ecx
je 0x22753
jmp 0x22762
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ptrlist.c
// Function: split_ptr_list_head
void split_ptr_list_head(struct ptr_list *head)
{
	int old = head->nr, nr = old / 2;
	struct ptr_list *newlist = __alloc_ptrlist(0);
	struct ptr_list *next = head->next;

	old -= nr;
	head->nr = old;
	newlist->next = next;
	next->prev = newlist;
	newlist->prev = head;
	head->next = newlist;
	newlist->nr = nr;
	memcpy(newlist->list, head->list + old, nr * sizeof(void *));
	memset(head->list + old, 0xf0, nr * sizeof(void *));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsbl (%rdi), %ebp
movl %ebp, %r14d
shrl $0x1f, %r14d
addl %ebp, %r14d
movl %r14d, %r15d
shrl %r15d
sarl %r14d
leaq 0x42548(%rip), %rdi     # 0x64d40
movl $0x80, %esi
callq 0x2fd3c
movq 0x10(%rbx), %rcx
subl %r14d, %ebp
movb %bpl, (%rbx)
movq %rcx, 0x10(%rax)
movq %rax, 0x8(%rcx)
movq %rbx, 0x8(%rax)
movq %rax, 0x10(%rbx)
movb %r15b, (%rax)
leaq 0x18(%rax), %rdi
movslq %ebp, %rax
leaq (%rbx,%rax,8), %rbx
addq $0x18, %rbx
movsbq %r15b, %r14
shlq $0x3, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0xe1e0
movq %rbx, %rdi
movl $0xf0, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe130
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ptrlist.c
// Function: _add_ptr_list
void **__add_ptr_list(struct ptr_list **listp, void *ptr)
{
	struct ptr_list *list = *listp;
	struct ptr_list *last = NULL; /* gcc complains needlessly */
	void **ret;
	int nr;

	if (!list || (nr = (last = list->prev)->nr) >= LIST_NODE_NR) {
		struct ptr_list *newlist = __alloc_ptrlist(0);
		if (!list) {
			newlist->next = newlist;
			newlist->prev = newlist;
			*listp = newlist;
		} else {
			newlist->prev = last;
			newlist->next = list;
			list->prev = newlist;
			last->next = newlist;
		}
		last = newlist;
		nr = 0;
	}
	ret = last->list + nr;
	*ret = ptr;
	nr++;
	last->nr = nr;
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
testq %r15, %r15
je 0x22883
movq 0x8(%r15), %rax
movsbl (%rax), %ecx
cmpw $0xd, %cx
jl 0x228b1
movq %rax, %r12
jmp 0x22886
xorl %r12d, %r12d
leaq 0x424b3(%rip), %rdi     # 0x64d40
movl $0x80, %esi
callq 0x2fd3c
testq %r15, %r15
je 0x228b6
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x8(%r15)
addq $0x10, %r12
movq %r12, %r14
jmp 0x228be
movswl %cx, %ecx
jmp 0x228c3
movq %rax, 0x10(%rax)
movq %rax, 0x8(%rax)
movq %rax, (%r14)
xorl %ecx, %ecx
movslq %ecx, %rdx
leaq (%rax,%rdx,8), %rcx
addq $0x18, %rcx
movq %rbx, (%rcx)
incb %dl
movb %dl, (%rax)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ptrlist.c
// Function: _add_ptr_list_tag
void **__add_ptr_list_tag(struct ptr_list **listp, void *ptr, unsigned long tag)
{
	/* The low two bits are reserved for tags */
	assert((3 & (unsigned long)ptr) == 0);
	assert((~3 & tag) == 0);

	ptr = (void *)(tag | (unsigned long)ptr);

	return __add_ptr_list(listp, ptr);
}

// Assembly:
pushq %rax
testb $0x3, %sil
jne 0x228fa
cmpq $0x4, %rdx
jae 0x22919
orq %rdx, %rsi
popq %rax
jmp 0x2285b
leaq 0x24b39(%rip), %rdi     # 0x4743a
leaq 0x24b50(%rip), %rsi     # 0x47458
leaq 0x24b53(%rip), %rcx     # 0x47462
movl $0x12d, %edx            # imm = 0x12D
callq 0xe120
leaq 0x24b87(%rip), %rdi     # 0x474a7
leaq 0x24b31(%rip), %rsi     # 0x47458
leaq 0x24b34(%rip), %rcx     # 0x47462
movl $0x12e, %edx            # imm = 0x12E
callq 0xe120
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ptrlist.c
// Function: lookup_ptr_list_entry
bool lookup_ptr_list_entry(const struct ptr_list *head, const void *entry)
{
	const struct ptr_list *list = head;

	if (!head)
		return false;
	do {
		int nr = list->nr;
		int i;
		for (i = 0; i < nr; i++)
			if (list->list[i] == entry)
				return true;
	} while ((list = list->next) != head);
	return false;
}

// Assembly:
testq %rdi, %rdi
je 0x22965
movq %rdi, %rax
movsbl (%rax), %ecx
testw %cx, %cx
jle 0x2295c
movzwl %cx, %ecx
xorl %edx, %edx
cmpq %rsi, 0x18(%rax,%rdx,8)
je 0x22968
incq %rdx
cmpq %rdx, %rcx
jne 0x2294d
movq 0x10(%rax), %rax
cmpq %rdi, %rax
jne 0x22940
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ptrlist.c
// Function: delete_ptr_list_entry
int delete_ptr_list_entry(struct ptr_list **list, void *entry, int count)
{
	void *ptr;

	FOR_EACH_PTR(*list, ptr) {
		if (ptr == entry) {
			DELETE_CURRENT_PTR(ptr);
			if (!--count)
				goto out;
		}
	} END_FOR_EACH_PTR(ptr);
	assert(count <= 0);
out:
	pack_ptr_list(list);
	return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq (%rdi), %rax
testq %rax, %rax
je 0x22a2b
movl $0xf0f0f0f0, %ecx       # imm = 0xF0F0F0F0
movq %rax, %rdx
movzwl (%rdx), %ebp
movsbl %bpl, %r11d
testw %r11w, %r11w
jle 0x22a11
leaq 0x18(%rdx), %r8
leaq 0x10(%rdx), %r9
xorl %r10d, %r10d
movslq %r10d, %r14
movq (%r8,%r14,8), %r15
movzwl %bp, %ebp
cmpl $0x100, %ebp            # imm = 0x100
setb %bpl
testq %r15, %r15
setne %r12b
orb %bpl, %r12b
cmpb $0x1, %r12b
jne 0x229ff
cmpq %rsi, %r15
jne 0x229ff
leaq (%r8,%r14,8), %r14
movswq %r11w, %r11
leaq (%r9,%r11,8), %r11
cmpq %r11, %r14
jae 0x229f0
leaq 0x8(%r14), %r15
movq 0x8(%r14), %r12
movq %r12, (%r14)
movq %r15, %r14
cmpq %r11, %r15
jb 0x229db
jmp 0x229f3
movq %r14, %r15
movq %rcx, (%r15)
decb (%rdx)
decl %ebx
je 0x22a22
decl %r10d
incl %r10d
movl (%rdx), %ebp
movsbl %bpl, %r11d
movsbl %bpl, %r14d
cmpl %r14d, %r10d
jl 0x229a1
movq 0x10(%rdx), %rdx
cmpq %rax, %rdx
jne 0x22989
xorl %eax, %eax
jmp 0x22a30
xorl %ebx, %ebx
movl $0xd, %eax
jmp 0x22a30
movl $0x2, %eax
testl %eax, %eax
je 0x22a3e
cmpl $0xd, %eax
je 0x22a42
cmpl $0x2, %eax
jne 0x22a47
testl %ebx, %ebx
jg 0x22a52
callq 0x22731
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x24a5e(%rip), %rdi     # 0x474b7
leaq 0x249f8(%rip), %rsi     # 0x47458
leaq 0x24a5b(%rip), %rcx     # 0x474c2
movl $0x15a, %edx            # imm = 0x15A
callq 0xe120
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ptrlist.c
// Function: replace_ptr_list_entry
int replace_ptr_list_entry(struct ptr_list **list, void *old_ptr,
	void *new_ptr, int count)
{
	void *ptr;

	FOR_EACH_PTR(*list, ptr) {
		if (ptr==old_ptr) {
			REPLACE_CURRENT_PTR(ptr, new_ptr);
			if (!--count)
				goto out;
		}
	}END_FOR_EACH_PTR(ptr);
	assert(count <= 0);
out:
	return count;
}

// Assembly:
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x22ae0
movq %rax, %rdi
movzwl (%rdi), %r9d
testb %r9b, %r9b
jle 0x22aca
xorl %r8d, %r8d
movq 0x18(%rdi,%r8,8), %r10
movzwl %r9w, %r9d
cmpl $0x100, %r9d            # imm = 0x100
setb %r9b
testq %r10, %r10
setne %r11b
orb %r9b, %r11b
cmpb $0x1, %r11b
jne 0x22abb
cmpq %rsi, %r10
jne 0x22abb
movq %rdx, 0x18(%rdi,%r8,8)
decl %ecx
je 0x22ad7
incq %r8
movl (%rdi), %r9d
movsbq %r9b, %r10
cmpq %r10, %r8
jl 0x22a89
movq 0x10(%rdi), %rdi
cmpq %rax, %rdi
jne 0x22a7d
xorl %eax, %eax
jmp 0x22ae5
xorl %ecx, %ecx
movl $0xb, %eax
jmp 0x22ae5
movl $0x2, %eax
testb $0xd, %al
jne 0x22aed
testl %ecx, %ecx
jg 0x22af1
movl %ecx, %eax
popq %rcx
retq
leaq 0x249bf(%rip), %rdi     # 0x474b7
leaq 0x24959(%rip), %rsi     # 0x47458
leaq 0x249f7(%rip), %rcx     # 0x474fd
movl $0x172, %edx            # imm = 0x172
callq 0xe120
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ptrlist.c
// Function: undo_ptr_list_last
void * undo_ptr_list_last(struct ptr_list **head)
{
	struct ptr_list *last, *first = *head;

	if (!first)
		return NULL;
	last = first;
	do {
		last = last->prev;
		if (last->nr) {
			void *ptr;
			int nr = --last->nr;
			ptr = last->list[nr];
			last->list[nr] = (void *)0xf1f1f1f1;
			return ptr;
		}
	} while (last != first);
	return NULL;
}

// Assembly:
movq (%rdi), %rdx
xorl %eax, %eax
testq %rdx, %rdx
je 0x22b2e
movq %rdx, %rcx
movq 0x8(%rcx), %rcx
movzwl (%rcx), %esi
testb %sil, %sil
jne 0x22b2f
cmpq %rdx, %rcx
jne 0x22b1d
retq
leal -0x1(%rsi), %eax
movzbl %al, %edx
andl $0xffffff00, %esi       # imm = 0xFFFFFF00
orl %edx, %esi
movw %si, (%rcx)
movsbq %al, %rdx
movq 0x18(%rcx,%rdx,8), %rax
movl $0xf1f1f1f1, %esi       # imm = 0xF1F1F1F1
movq %rsi, 0x18(%rcx,%rdx,8)
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ptrlist.c
// Function: delete_ptr_list_last
void * delete_ptr_list_last(struct ptr_list **head)
{
	void *ptr = NULL;
	struct ptr_list *last, *first = *head;

	if (!first)
		return NULL;
	last = first->prev;
	if (last->nr)
		ptr = last->list[--last->nr];
	if (last->nr <=0) {
		first->prev = last->prev;
		last->prev->next = first;
		if (last == first)
			*head = NULL;
		__free_ptrlist(last);
	}
	return ptr;
}

// Assembly:
pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x22b86
movq 0x8(%rax), %rsi
movzwl (%rsi), %ecx
testb %cl, %cl
je 0x22b8a
leal -0x1(%rcx), %edx
movzbl %dl, %r8d
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl %r8d, %ecx
movw %cx, (%rsi)
movsbq %dl, %rcx
movq 0x18(%rsi,%rcx,8), %rbx
jmp 0x22b8c
xorl %ebx, %ebx
jmp 0x22bb9
xorl %ebx, %ebx
cmpb $0x0, (%rsi)
jg 0x22bb9
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsi), %rcx
movq %rax, 0x10(%rcx)
cmpq %rax, %rsi
jne 0x22bad
movq $0x0, (%rdi)
leaq 0x4218c(%rip), %rdi     # 0x64d40
callq 0x2fd30
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ptrlist.c
// Function: concat_ptr_list
void concat_ptr_list(struct ptr_list *a, struct ptr_list **b)
{
	void *entry;
	FOR_EACH_PTR(a, entry) {
		add_ptr_list(b, entry);
	} END_FOR_EACH_PTR(entry);
}

// Assembly:
testq %rdi, %rdi
je 0x22c1e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %r15
movzwl (%r15), %eax
testb %al, %al
jle 0x22c0a
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %rsi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x22bf3
testq %rsi, %rsi
je 0x22bfb
movq %rbx, %rdi
callq 0x2285b
incq %r12
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jl 0x22bdf
movq 0x10(%r15), %r15
cmpq %r14, %r15
jne 0x22bd4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ptrlist.c
// Function: copy_ptr_list
void copy_ptr_list(struct ptr_list **listp, struct ptr_list *src)
{
	struct ptr_list *head, *tail;
	struct ptr_list *cur = src;
	int idx;

	if (!src)
		return;
	head = *listp;
	if (!head) {
		*listp = src;
		return;
	}

	tail = head->prev;
	idx = tail->nr;
	do {
		struct ptr_list *next;
		int nr = cur->nr;
		int i;
		for (i = 0; i < nr;) {
			void *ptr = cur->list[i++];
			if (!ptr)
				continue;
			if (idx >= LIST_NODE_NR) {
				struct ptr_list *prev = tail;
				tail = __alloc_ptrlist(0);
				prev->next = tail;
				tail->prev = prev;
				prev->nr = idx;
				idx = 0;
			}
			tail->list[idx++] = ptr;
		}

		next = cur->next;
		__free_ptrlist(cur);
		cur = next;
	} while (cur != src);

	tail->nr = idx;
	head->prev = tail;
	tail->next = head;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
testq %rsi, %rsi
je 0x22ce4
movq (%rdi), %rax
testq %rax, %rax
je 0x22cdc
movq %rax, 0x10(%rsp)
movq 0x8(%rax), %r13
movsbl (%r13), %ebp
movq 0x8(%rsp), %r15
movsbl (%r15), %eax
testw %ax, %ax
jle 0x22cac
movzwl %ax, %r12d
xorl %ebx, %ebx
movq 0x18(%r15,%rbx,8), %r14
testq %r14, %r14
je 0x22ca4
cmpl $0xd, %ebp
jl 0x22c9a
leaq 0x420c1(%rip), %rdi     # 0x64d40
movl $0x80, %esi
callq 0x2fd3c
movq %rax, 0x10(%r13)
movq %r13, 0x8(%rax)
movb %bpl, (%r13)
xorl %ebp, %ebp
movq %rax, %r13
movslq %ebp, %rax
incl %ebp
movq %r14, 0x18(%r13,%rax,8)
incq %rbx
cmpq %rbx, %r12
jne 0x22c69
movq 0x10(%r15), %rbx
leaq 0x42089(%rip), %rdi     # 0x64d40
movq %r15, %rsi
callq 0x2fd30
movq %rbx, %r15
cmpq 0x8(%rsp), %rbx
jne 0x22c5a
movb %bpl, (%r13)
movq 0x10(%rsp), %rax
movq %r13, 0x8(%rax)
movq %rax, 0x10(%r13)
jmp 0x22ce4
movq 0x8(%rsp), %rax
movq %rax, (%rdi)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ptrlist.c
// Function: _free_ptr_list
void __free_ptr_list(struct ptr_list **listp)
{
	struct ptr_list *tmp, *list = *listp;

	if (!list)
		return;

	list->prev->next = NULL;
	while (list) {
		tmp = list;
		list = list->next;
		__free_ptrlist(tmp);
	}

	*listp = NULL;
}

// Assembly:
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x22d36
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq $0x0, 0x10(%rax)
leaq 0x4202a(%rip), %r14     # 0x64d40
movq 0x10(%rsi), %r15
movq %r14, %rdi
callq 0x2fd30
movq %r15, %rsi
testq %r15, %r15
jne 0x22d16
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/scope.c
// Function: rebind_scope
void rebind_scope(struct symbol *sym, struct scope *new)
{
	struct scope *old = sym->scope;

	if (old == new)
		return;

	if (old)
		delete_ptr_list_entry((struct ptr_list**) &old->symbols, sym, 1);

	bind_scope(sym, new);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
cmpq %rsi, %rdi
je 0x22d91
movq %rsi, %r14
testq %rdi, %rdi
je 0x22d7b
movq %rbx, %rsi
movl $0x1, %edx
callq 0x2296b
movq %r14, 0x30(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2285b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/scope.c
// Function: start_file_scope
void start_file_scope(void)
{
	struct scope *scope = __alloc_scope(0);

	scope->next = &builtin_scope;
	file_scope = scope;

	/* top-level stuff defaults to file scope, "extern" etc will choose global scope */
	function_scope = scope;
	block_scope = scope;
}

// Assembly:
pushq %rax
xorl %edi, %edi
callq 0x30152
leaq 0x41fd0(%rip), %rcx     # 0x64d78
movq %rcx, 0x8(%rax)
movq %rax, 0x41fe5(%rip)     # 0x64d98
movq %rax, 0x41fd6(%rip)     # 0x64d90
movq %rax, 0x41fc7(%rip)     # 0x64d88
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/scope.c
// Function: end_scope
static void end_scope(struct scope **s)
{
	struct scope *scope = *s;
	struct symbol_list *symbols = scope->symbols;
	struct symbol *sym;

	*s = scope->next;
	scope->symbols = NULL;
	FOR_EACH_PTR(symbols, sym) {
		remove_symbol_scope(sym);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
movq (%rdi), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
movq %rdx, (%rdi)
movq $0x0, (%rcx)
testq %rax, %rax
je 0x22e94
movq %rax, %rcx
movzwl (%rcx), %edi
testb %dil, %dil
jle 0x22e8b
xorl %edx, %edx
movq 0x18(%rcx,%rdx,8), %rsi
movzwl %di, %edi
cmpl $0x100, %edi            # imm = 0x100
jb 0x22e5f
testq %rsi, %rsi
je 0x22e7d
movq 0x18(%rsi), %rdi
addq $0x8, %rdi
movq %rdi, %r8
movq (%rdi), %r9
leaq 0x20(%r9), %rdi
cmpq %rsi, %r9
jne 0x22e67
movq 0x20(%rsi), %rsi
movq %rsi, (%r8)
incq %rdx
movl (%rcx), %edi
movsbq %dil, %rsi
cmpq %rsi, %rdx
jl 0x22e4a
movq 0x10(%rcx), %rcx
cmpq %rax, %rcx
jne 0x22e40
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/scope.c
// Function: end_label_scope
void end_label_scope(void)
{
	struct symbol *sym;

	FOR_EACH_PTR(label_scope->symbols, sym) {
		if (!sym->stmt || sym->used)
			continue;
		if (sym->label_modifiers & MOD_UNUSED)
			continue;
		warning(sym->pos, "unused label '%s'", show_ident(sym->ident));
	} END_FOR_EACH_PTR(sym);

	end_scope(&label_scope);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x48586(%rip), %rax     # 0x6b498
movq (%rax), %r14
testq %r14, %r14
je 0x22f8d
leaq 0x24629(%rip), %rbx     # 0x4754a
movq %r14, %r15
movzwl (%r15), %eax
testb %al, %al
jle 0x22f84
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %r13
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x22f43
testq %r13, %r13
je 0x22f75
cmpq $0x0, 0x90(%r13)
je 0x22f75
testb $0x2, 0x2(%r13)
jne 0x22f75
testb $0x40, 0x5a(%r13)
jne 0x22f75
movq 0x18(%r13), %rdi
callq 0x2e465
movq 0x4(%r13), %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x118b4
incq %r12
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jl 0x22f2f
movq 0x10(%r15), %r15
cmpq %r14, %r15
jne 0x22f24
leaq 0x48504(%rip), %rdi     # 0x6b498
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x22e24
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/scope.c
// Function: is_in_scope
int is_in_scope(struct scope *outer, struct scope *inner)
{
	while (inner != outer) {
		if (inner == function_scope)
			return 0;
		inner = inner->next;
	}
	return 1;
}

// Assembly:
movl $0x1, %eax
cmpq %rdi, %rsi
je 0x23003
movq 0x41d9b(%rip), %rcx     # 0x64d90
cmpq %rcx, %rsi
je 0x23004
movq 0x8(%rsi), %rsi
cmpq %rdi, %rsi
jne 0x22ff5
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/show-parse.c
// Function: show_modifiers
static const char *show_modifiers(unsigned long mod, int term)
{
	static char buffer[100];
	int len = 0;
	int i;
	struct mod_name {
		unsigned long mod;
		const char *name;
	} *m;

	static struct mod_name mod_names[] = {
		{MOD_AUTO,		"auto"},
		{MOD_EXTERN,		"extern"},
		{MOD_REGISTER,		"register"},
		{MOD_STATIC,		"static"},
		{MOD_INLINE,		"inline"},
		{MOD_CONST,		"const"},
		{MOD_RESTRICT,		"restrict"},
		{MOD_VOLATILE,		"volatile"},
		{MOD_ADDRESSABLE,	"[addressable]"},
		{MOD_ASSIGNED,		"[assigned]"},
		{MOD_ATOMIC,		"[atomic]"},
		{MOD_BITWISE,		"[bitwise]"},
		{MOD_EXPLICITLY_SIGNED,	"[explicitly-signed]"},
		{MOD_GNU_INLINE,	"[gnu_inline]"},
		{MOD_NOCAST,		"[nocast]"},
		{MOD_NODEREF,		"[noderef]"},
		{MOD_NORETURN,		"[noreturn]"},
		{MOD_PURE,		"[pure]"},
		{MOD_SAFE,		"[safe]"},
		{MOD_SIGNED,		"[signed]"},
		{MOD_TLS,		"[tls]"},
		{MOD_TOPLEVEL,		"[toplevel]"},
		{MOD_UNSIGNED,		"[unsigned]"},
		{MOD_UNUSED,		"[unused]"},
		{MOD_USERTYPE,		"[usertype]"},
	};

	for (i = 0; i < ARRAY_SIZE(mod_names); i++) {
		m = mod_names + i;
		if (mod & m->mod) {
			char c;
			const char *name = m->name;
			while ((c = *name++) != '\0' && len + 2 < sizeof buffer)
				buffer[len++] = c;
			buffer[len++] = ' ';
		}
	}
	if (len && !term)		// strip the trailing space
		--len;
	buffer[len] = 0;
	return buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %edx, %edx
leaq 0x36e2e(%rip), %r8      # 0x59e90
leaq 0x48507(%rip), %rax     # 0x6b570
xorl %ecx, %ecx
movq %rdx, %r9
shlq $0x4, %r9
testq %rdi, (%r9,%r8)
je 0x230ca
addq %r8, %r9
movq 0x8(%r9), %r9
movb (%r9), %r10b
testb %r10b, %r10b
je 0x230c0
leal 0x2(%rcx), %r11d
cmpl $0x63, %r11d
ja 0x230c0
movslq %ecx, %r11
leaq 0x3(%r11), %rbx
xorl %r14d, %r14d
leaq (%r11,%r14), %r15
movb %r10b, (%rax,%r15)
movb 0x1(%r9,%r14), %r10b
leaq 0x1(%r14), %r15
testb %r10b, %r10b
je 0x230bd
addq %rbx, %r14
cmpq $0x64, %r14
movq %r15, %r14
jb 0x2309b
addl %r15d, %ecx
movslq %ecx, %r9
incl %ecx
movb $0x20, (%r9,%rax)
incq %rdx
cmpq $0x19, %rdx
jne 0x2306b
testl %ecx, %ecx
setne %dl
testl %esi, %esi
sete %sil
andb %dl, %sil
movslq %ecx, %rcx
movzbl %sil, %edx
subq %rdx, %rcx
movb $0x0, (%rcx,%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/show-parse.c
// Function: show_symbol_list
void show_symbol_list(struct symbol_list *list)
{
	struct symbol *sym;
	const char *prepend = "";

	FOR_EACH_PTR(list, sym) {
		puts(prepend);
		prepend = ", ";
		show_symbol(sym);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
testq %rdi, %rdi
je 0x2317b
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x1e7af(%rip), %rdi     # 0x418cd
leaq 0x1f686(%rip), %r15     # 0x427ab
movq %rbx, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0x23168
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %r14
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x23148
testq %r14, %r14
je 0x23158
callq 0xe0a0
movq %r14, %rdi
callq 0x2317c
movq %r15, %rdi
incq %r13
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jl 0x23134
movq 0x10(%r12), %r12
cmpq %rbx, %r12
jne 0x23128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/show-parse.c
// Function: show_symbol
void show_symbol(struct symbol *sym)
{
	struct symbol *type;

	if (!sym)
		return;

	if (sym->ctype.alignment)
		printf(".align %ld\n", sym->ctype.alignment);

	show_type(sym);
	type = sym->ctype.base_type;
	if (!type) {
		printf("\n");
		return;
	}

	/*
	 * Show actual implementation information
	 */
	switch (type->type) {
		struct symbol *member;

	case SYM_STRUCT:
	case SYM_UNION:
		printf(" {\n");
		FOR_EACH_PTR(type->symbol_list, member) {
			show_struct_member(member);
		} END_FOR_EACH_PTR(member);
		printf("}\n");
		break;

	case SYM_FN: {
		struct statement *stmt = type->stmt;
		printf("\n");
		if (stmt) {
			int val;
			val = show_statement(stmt);
			if (val)
				printf("\tmov.%d\t\tretval,%d\n", stmt->ret->bit_size, val);
			printf("\tret\n");
		}
		break;
	}

	default:
		printf("\n");
		break;
	}

	if (sym->initializer) {
		printf(" = \n");
		show_expression(sym->initializer);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x23302
movq %rdi, %rbx
movq 0x70(%rdi), %rsi
testq %rsi, %rsi
je 0x231aa
leaq 0x244d0(%rip), %rdi     # 0x47673
xorl %eax, %eax
callq 0xe0f0
movq %rbx, %rdi
callq 0x233a1
movq 0x60(%rbx), %r14
testq %r14, %r14
je 0x23264
movzbl (%r14), %eax
leal -0x7(%rax), %ecx
cmpl $0x2, %ecx
jae 0x2327c
leaq 0x24b76(%rip), %rdi     # 0x47d4c
callq 0xe0a0
movq 0x98(%r14), %r15
testq %r15, %r15
je 0x2325b
leaq 0x248ec(%rip), %r14     # 0x47ada
movq %r15, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0x23251
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %rbp
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x23211
testq %rbp, %rbp
je 0x23241
movq 0x18(%rbp), %rdi
callq 0x2e465
movl 0x50(%rbp), %edx
movq 0x70(%rbp), %rcx
movq 0x48(%rbp), %r8
movzbl 0x54(%rbp), %r9d
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
movl $0xa, %edi
callq 0xe040
incq %r13
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jl 0x231fd
movq 0x10(%r12), %r12
cmpq %r15, %r12
jne 0x231f1
leaq 0x24aed(%rip), %rdi     # 0x47d4f
jmp 0x232c1
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe040
cmpl $0x5, %eax
jne 0x232c8
movq 0x90(%r14), %r14
movl $0xa, %edi
callq 0xe040
testq %r14, %r14
je 0x232d2
movq %r14, %rdi
callq 0x2389a
testl %eax, %eax
je 0x232ba
movq 0x18(%r14), %rcx
movl 0x50(%rcx), %esi
leaq 0x243ce(%rip), %rdi     # 0x4767f
movl %eax, %edx
xorl %eax, %eax
callq 0xe0f0
leaq 0x24a86(%rip), %rdi     # 0x47d47
callq 0xe0a0
jmp 0x232d2
movl $0xa, %edi
callq 0xe040
cmpq $0x0, 0xb0(%rbx)
je 0x23302
leaq 0x24a6e(%rip), %rdi     # 0x47d51
callq 0xe0a0
movq 0xb0(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x23eb8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/show-parse.c
// Function: show_type
void show_type(struct symbol *sym)
{
	char array[200];
	struct type_name name;

	name.start = name.end = array+100;
	do_show_type(sym, &name);
	*name.end = 0;
	printf("%s", name.start);
}

// Assembly:
pushq %rbx
subq $0xe0, %rsp
leaq 0x74(%rsp), %rax
movq %rsp, %rbx
movq %rax, 0x8(%rbx)
movq %rax, (%rbx)
movq %rbx, %rsi
callq 0x233e1
movq 0x8(%rbx), %rax
movb $0x0, (%rax)
movq (%rbx), %rsi
leaq 0x290fc(%rip), %rdi     # 0x4c4cd
xorl %eax, %eax
callq 0xe0f0
addq $0xe0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/show-parse.c
// Function: show_typename
const char *show_typename(struct symbol *sym)
{
	static char array[200];
	struct type_name name;

	name.start = name.end = array+100;
	do_show_type(sym, &name);
	*name.end = 0;
	return name.start;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x47c8c(%rip), %rax     # 0x6b504
movq %rsp, %rbx
movq %rax, 0x8(%rbx)
movq %rax, (%rbx)
movq %rbx, %rsi
callq 0x233e1
movq 0x8(%rbx), %rax
movb $0x0, (%rax)
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/show-parse.c
// Function: show_symbol_decl
static void show_symbol_decl(struct symbol_list *syms)
{
	struct symbol *sym;
	FOR_EACH_PTR(syms, sym) {
		show_symbol_init(sym);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0x2425a
leaq 0x2390d(%rip), %r14     # 0x47af6
movq (%rsp), %r13
movzwl (%r13), %eax
testb %al, %al
jle 0x24250
xorl %ebx, %ebx
movq 0x18(%r13,%rbx,8), %r15
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x2420c
testq %r15, %r15
je 0x24240
movq 0xb0(%r15), %rdi
testq %rdi, %rdi
je 0x24240
movq 0x10(%rdi), %rax
movl 0x50(%rax), %ebp
callq 0x23eb8
movl %eax, %r12d
movq %r15, %rdi
callq 0x24269
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0xe0f0
incq %rbx
movl (%r13), %eax
movsbq %al, %rcx
cmpq %rcx, %rbx
jl 0x241f8
movq 0x10(%r13), %r13
cmpq (%rsp), %r13
jne 0x241ed
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/show-parse.c
// Function: show_symbol_expr
static int show_symbol_expr(struct symbol *sym)
{
	int new = new_pseudo();

	if (sym->initializer && sym->initializer->type == EXPR_STRING)
		return show_string_expr(sym->initializer);

	if (sym->ctype.modifiers & (MOD_TOPLEVEL | MOD_EXTERN | MOD_STATIC)) {
		printf("\tmovi.%d\t\tv%d,$%s\n", bits_in_pointer, new, show_ident(sym->ident));
		return new;
	}
	if (sym->ctype.modifiers & MOD_ADDRESSABLE) {
		printf("\taddi.%d\t\tv%d,vFP,$%lld\n", bits_in_pointer, new, 0LL);
		return new;
	}
	printf("\taddi.%d\t\tv%d,vFP,$offsetof(%s:%p)\n", bits_in_pointer, new, show_ident(sym->ident), sym);
	return new;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl 0x4776a(%rip), %ebx     # 0x6b9e0
incl %ebx
movl %ebx, 0x47762(%rip)     # 0x6b9e0
movq 0xb0(%rdi), %rdi
testq %rdi, %rdi
je 0x24298
cmpb $0x2, (%rdi)
jne 0x24298
popq %rbx
popq %r14
popq %rbp
jmp 0x24629
movq 0x68(%r14), %rax
testb $0x1c, %al
je 0x242c2
leaq 0x41485(%rip), %rax     # 0x6572c
movl (%rax), %ebp
movq 0x18(%r14), %rdi
callq 0x2e465
leaq 0x238a8(%rip), %rdi     # 0x47b61
movl %ebp, %esi
movl %ebx, %edx
movq %rax, %rcx
jmp 0x24301
btl $0x8, %eax
leaq 0x4145f(%rip), %rax     # 0x6572c
movl (%rax), %ebp
jb 0x242f4
movq 0x18(%r14), %rdi
callq 0x2e465
leaq 0x238ac(%rip), %rdi     # 0x47b8d
movl %ebp, %esi
movl %ebx, %edx
movq %rax, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0xe0f0
jmp 0x24308
leaq 0x23879(%rip), %rdi     # 0x47b74
movl %ebp, %esi
movl %ebx, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xe0f0
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/show-parse.c
// Function: show_symbol_expr_init
int show_symbol_expr_init(struct symbol *sym)
{
	struct expression *expr = sym->initializer;

	if (expr)
		show_expression(expr);
	return show_symbol_expr(sym);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xb0(%rdi), %rdi
testq %rdi, %rdi
je 0x24324
callq 0x23eb8
movq %rbx, %rdi
popq %rbx
jmp 0x24269
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/show-parse.c
// Function: show_call_expression
static int show_call_expression(struct expression *expr)
{
	struct symbol *direct;
	struct expression *arg, *fn;
	int fncall, retval;
	int framesize;

	if (!expr->ctype) {
		warning(expr->pos, "\tcall with no type!");
		return 0;
	}

	framesize = 0;
	FOR_EACH_PTR_REVERSE(expr->args, arg) {
		int new = show_expression(arg);
		int size = arg->ctype->bit_size;
		printf("\tpush.%d\t\tv%d\n", size, new);
		framesize += bits_to_bytes(size);
	} END_FOR_EACH_PTR_REVERSE(arg);

	fn = expr->fn;

	/* Remove dereference, if any */
	direct = NULL;
	if (fn->type == EXPR_PREOP) {
		if (fn->unop->type == EXPR_SYMBOL) {
			struct symbol *sym = fn->unop->symbol;
			if (sym->ctype.base_type->type == SYM_FN)
				direct = sym;
		}
	}
	if (direct) {
		printf("\tcall\t\t%s\n", show_ident(direct->ident));
	} else {
		fncall = show_expression(fn);
		printf("\tcall\t\t*v%d\n", fncall);
	}
	if (framesize)
		printf("\tadd.%d\t\tvSP,vSP,$%d\n", bits_in_pointer, framesize);

	retval = new_pseudo();
	printf("\tmov.%d\t\tv%d,retval\n", expr->ctype->bit_size, retval);
	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x10(%rdi)
je 0x243d0
movq %rdi, (%rsp)
movq 0x28(%rdi), %rbx
testq %rbx, %rbx
je 0x243e9
leaq 0x2386a(%rip), %r14     # 0x47bc5
movq %rbx, %r12
xorl %ebp, %ebp
movq 0x8(%r12), %r12
movsbq (%r12), %r13
movl %r13d, %r13d
testl %r13d, %r13d
jle 0x243c9
movq 0x10(%r12,%r13,8), %r15
decq %r13
cmpw $0x100, (%r12)          # imm = 0x100
jb 0x24388
testq %r15, %r15
je 0x2436d
movq %r15, %rdi
callq 0x23eb8
movq 0x10(%r15), %rcx
movl 0x50(%rcx), %r15d
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0xe0f0
testl %r15d, %r15d
js 0x243c0
leaq 0x4134d(%rip), %rax     # 0x65700
movl (%rax), %ecx
leal (%r15,%rcx), %eax
decl %eax
cltd
idivl %ecx
jmp 0x243c5
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addl %eax, %ebp
jmp 0x2436a
cmpq %rbx, %r12
jne 0x24360
jmp 0x243eb
movq 0x8(%rdi), %rdi
leaq 0x237d6(%rip), %rsi     # 0x47bb1
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x118b4
jmp 0x2448e
xorl %ebp, %ebp
movq (%rsp), %rbx
movq 0x20(%rbx), %rdi
cmpb $0x9, (%rdi)
jne 0x24414
movq 0x20(%rdi), %rax
cmpb $0x3, (%rax)
jne 0x24414
movq 0x20(%rax), %rcx
movq 0x60(%rcx), %rdx
xorl %eax, %eax
cmpb $0x5, (%rdx)
cmoveq %rcx, %rax
jmp 0x24416
xorl %eax, %eax
testq %rax, %rax
je 0x24437
movq 0x18(%rax), %rdi
callq 0x2e465
leaq 0x237a9(%rip), %rdi     # 0x47bd4
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
jmp 0x2444c
callq 0x23eb8
leaq 0x2379c(%rip), %rdi     # 0x47bdf
movl %eax, %esi
xorl %eax, %eax
callq 0xe0f0
testl %ebp, %ebp
je 0x24469
leaq 0x412d5(%rip), %rax     # 0x6572c
movl (%rax), %esi
leaq 0x2378c(%rip), %rdi     # 0x47bec
movl %ebp, %edx
xorl %eax, %eax
callq 0xe0f0
movl 0x47571(%rip), %ebp     # 0x6b9e0
incl %ebp
movl %ebp, 0x47569(%rip)     # 0x6b9e0
movq 0x10(%rbx), %rax
movl 0x50(%rax), %esi
leaq 0x2377d(%rip), %rdi     # 0x47c02
movl %ebp, %edx
xorl %eax, %eax
callq 0xe0f0
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_O1/lucvoo[P]sparse-dev/show-parse.c
// Function: show_assignment
static int show_assignment(struct expression *expr)
{
	struct expression *target = expr->left;
	int val, addr, bits;

	if (!expr->ctype)
		return 0;

	bits = expr->ctype->bit_size;
	val = show_expression(expr->right);
	addr = show_address_gen(target);
	show_store_gen(bits, val, target, addr);
	return val;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x244dd
movl 0x50(%rax), %ebp
movq 0x20(%rdi), %r14
movq 0x28(%rdi), %rdi
callq 0x23eb8
movl %eax, %ebx
movq 0x20(%r14), %rdi
callq 0x23eb8
leaq 0x23628(%rip), %rdi     # 0x47af6
movl %ebp, %esi
movl %ebx, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0xe0f0
jmp 0x244df
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/show-parse.c
// Function: show_preop
static int show_preop(struct expression *expr)
{
	/*
	 * '*' is an lvalue access, and is fundamentally different
	 * from an arithmetic operation. Maybe it should have an
	 * expression type of its own..
	 */
	if (expr->op == '*')
		return show_access(expr);
	if (expr->op == SPECIAL_INCREMENT || expr->op == SPECIAL_DECREMENT)
		return show_inc_dec(expr, 0);
	return show_regular_preop(expr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x4(%rdi), %eax
cmpl $0x103, %eax            # imm = 0x103
je 0x2454f
cmpl $0x101, %eax            # imm = 0x101
je 0x2454f
cmpl $0x2a, %eax
jne 0x24563
movq 0x20(%r14), %rdi
callq 0x23eb8
movq 0x10(%r14), %rcx
movl 0x50(%rcx), %esi
movl 0x474ad(%rip), %ebx     # 0x6b9e0
incl %ebx
movl %ebx, 0x474a5(%rip)     # 0x6b9e0
leaq 0x2316b(%rip), %rdi     # 0x476ad
movl %ebx, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0xe0f0
jmp 0x245b6
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x24998
movq 0x20(%r14), %rdi
callq 0x23eb8
movl %eax, %ebp
movl 0x4746c(%rip), %ebx     # 0x6b9e0
incl %ebx
movl %ebx, 0x47464(%rip)     # 0x6b9e0
movl 0x4(%r14), %r15d
movl %r15d, %edi
callq 0x2e42a
cmpq $0x7e, %r15
ja 0x24599
leaq 0x35e7b(%rip), %rax     # 0x5a410
movq (%rax,%r15,8), %rax
movq 0x10(%r14), %rcx
movl 0x50(%rcx), %edx
leaq 0x236a9(%rip), %rdi     # 0x47c50
movq %rax, %rsi
movl %ebx, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0xe0f0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/show-parse.c
// Function: show_value
static int show_value(struct expression *expr)
{
	int new = new_pseudo();
	unsigned long long value = expr->value;

	printf("\tmovi.%d\t\tv%d,$%llu\n", expr->ctype->bit_size, new, value);
	return new;
}

// Assembly:
pushq %rbx
movl 0x47416(%rip), %ebx     # 0x6b9e0
incl %ebx
movl %ebx, 0x4740e(%rip)     # 0x6b9e0
movq 0x10(%rdi), %rax
movq 0x20(%rdi), %rcx
movl 0x50(%rax), %esi
leaq 0x236a9(%rip), %rdi     # 0x47c8d
movl %ebx, %edx
xorl %eax, %eax
callq 0xe0f0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/show-parse.c
// Function: show_fvalue
static int show_fvalue(struct expression *expr)
{
	int new = new_pseudo();
	long double value = expr->fvalue;

	printf("\tmovf.%d\t\tv%d,$%Le\n", expr->ctype->bit_size, new, value);
	return new;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl 0x473e4(%rip), %ebx     # 0x6b9e0
incl %ebx
movl %ebx, 0x473dc(%rip)     # 0x6b9e0
fldt 0x20(%rdi)
movq 0x10(%rdi), %rax
movl 0x50(%rax), %esi
fstpt (%rsp)
leaq 0x2368a(%rip), %rdi     # 0x47ca2
movl %ebx, %edx
xorl %eax, %eax
callq 0xe0f0
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/show-parse.c
// Function: show_initializer_expr
static int show_initializer_expr(struct expression *expr, struct symbol *ctype)
{
	struct expression *entry;

	FOR_EACH_PTR(expr->expr_list, entry) {

again:
		// Nested initializers have their positions already
		// recursively calculated - just output them too
		if (entry->type == EXPR_INITIALIZER) {
			show_initializer_expr(entry, ctype);
			continue;
		}

		// Initializer indexes and identifiers should
		// have been evaluated to EXPR_POS
		if (entry->type == EXPR_IDENTIFIER) {
			printf(" AT '%s':\n", show_ident(entry->expr_ident));
			entry = entry->ident_expression;
			goto again;
		}
			
		if (entry->type == EXPR_INDEX) {
			printf(" AT '%d..%d:\n", entry->idx_from, entry->idx_to);
			entry = entry->idx_expression;
			goto again;
		}
		if (entry->type == EXPR_POS) {
			show_position_expr(entry, ctype);
			continue;
		}
		show_initialization(ctype, entry);
	} END_FOR_EACH_PTR(entry);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x10(%rsp)
movq 0x20(%rdi), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x247ea
leaq 0x22faa(%rip), %rbx     # 0x47640
leaq 0x2362c(%rip), %r15     # 0x47cc9
leaq 0x23630(%rip), %r12     # 0x47cd4
movq 0x20(%rsp), %r14
movzwl (%r14), %eax
testb %al, %al
jle 0x247db
xorl %r13d, %r13d
movq 0x18(%r14,%r13,8), %rbp
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x24709
testq %rbp, %rbp
je 0x247c8
jmp 0x24709
movq 0x28(%rbp), %rdi
callq 0x2e465
movq %r15, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
movl $0x38, %eax
jmp 0x24704
movl 0x20(%rbp), %esi
movl 0x24(%rbp), %edx
movq %r12, %rdi
xorl %eax, %eax
callq 0xe0f0
movl $0x28, %eax
movq (%rbp,%rax), %rbp
movzbl (%rbp), %eax
addl $-0x18, %eax
cmpl $0x3, %eax
ja 0x24730
movslq (%rbx,%rax,4), %rax
addq %rbx, %rax
jmpq *%rax
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0x2466a
jmp 0x247c8
movq 0x10(%rbp), %rax
testq %rax, %rax
je 0x247c8
movl 0x50(%rax), %eax
movl %eax, 0xc(%rsp)
movq %rbp, %rdi
callq 0x23eb8
movl %eax, %ebp
movq 0x10(%rsp), %rdi
callq 0x24269
leaq 0x23397(%rip), %rdi     # 0x47af6
movl 0xc(%rsp), %esi
movl %ebp, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0xe0f0
jmp 0x247c8
movq 0x28(%rbp), %rdi
callq 0x23eb8
movl %eax, 0x1c(%rsp)
movq 0x28(%rbp), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x24794
movzbl 0x54(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x2479c
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movl 0x20(%rbp), %ebp
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x2e465
leaq 0x2352e(%rip), %rdi     # 0x47ce2
movl 0x1c(%rsp), %esi
movl %ebp, %edx
movl 0xc(%rsp), %ecx
movq %rax, %r8
xorl %eax, %eax
callq 0xe0f0
incq %r13
movl (%r14), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jl 0x246b8
movq 0x10(%r14), %r14
cmpq 0x20(%rsp), %r14
jne 0x246a9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq