LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: token_name_sequence
static const char *token_name_sequence(struct token *token, int endop, struct token *start)
{
	static char buffer[256];
	char *ptr = buffer;

	while (!eof_token(token) && !match_op(token, endop)) {
		int len;
		const char *val = token->string->data;
		if (token_type(token) != TOKEN_STRING)
			val = show_token(token);
		len = strlen(val);
		memcpy(ptr, val, len);
		ptr += len;
		token = token->next;
	}
	*ptr = 0;
	if (endop && !match_op(token, endop))
		sparse_error(start->pos, "expected '>' at end of filename");
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x61006(%rip), %rax     # 0x8f750
movq %rax, -0x20(%rbp)
xorl %eax, %eax
leaq 0x7e269(%rip), %rcx     # 0xac9c0
cmpq %rcx, -0x8(%rbp)
movb %al, -0x31(%rbp)
je 0x2e777
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2c380
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x2e780
jmp 0x2e7ec
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x10, %eax
je 0x2e7ad
movq -0x8(%rbp), %rdi
callq 0x44420
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x110c0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x111d0
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2e74e
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x0, -0xc(%rbp)
je 0x2e81f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2c380
cmpl $0x0, %eax
jne 0x2e81f
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x39436(%rip), %rsi     # 0x67c4e
movb $0x0, %al
callq 0x16f90
leaq 0x60f2a(%rip), %rax     # 0x8f750
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: try_include
static int try_include(struct position pos, const char *path, const char *filename, int flen, struct token **where, const char **next_path)
{
	int fd;
	int plen = strlen(path);
	static char fullname[PATH_MAX];

	memcpy(fullname, path, plen);
	if (plen && path[plen-1] != '/') {
		fullname[plen] = '/';
		plen++;
	}
	memcpy(fullname+plen, filename, flen);
	if (already_tokenized(fullname))
		return 1;
	fd = open(fullname, O_RDONLY);
	if (fd >= 0) {
		char *streamname = xmemdup(fullname, plen + flen);
		*where = tokenize(&pos, streamname, fd, *where, next_path);
		close(fd);
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x110c0
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rsi
movslq -0x40(%rbp), %rdx
leaq 0x60fe6(%rip), %rdi     # 0x8f850
callq 0x111d0
cmpl $0x0, -0x40(%rbp)
je 0x2e8a3
movq -0x18(%rbp), %rax
movl -0x40(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x2e8a3
movslq -0x40(%rbp), %rcx
leaq 0x60fba(%rip), %rax     # 0x8f850
movb $0x2f, (%rax,%rcx)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
movslq -0x40(%rbp), %rax
leaq 0x60fa2(%rip), %rdi     # 0x8f850
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x111d0
leaq 0x60f8b(%rip), %rdi     # 0x8f850
callq 0x304c0
cmpl $0x0, %eax
je 0x2e8d8
movl $0x1, -0x4(%rbp)
jmp 0x2e947
leaq 0x60f71(%rip), %rdi     # 0x8f850
xorl %esi, %esi
movb $0x0, %al
callq 0x11290
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jl 0x2e940
movl -0x40(%rbp), %eax
addl -0x24(%rbp), %eax
movslq %eax, %rsi
leaq 0x60f4f(%rip), %rdi     # 0x8f850
callq 0x46310
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movl -0x3c(%rbp), %edx
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %r8
leaq -0xc(%rbp), %rdi
callq 0x45270
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0x3c(%rbp), %edi
callq 0x11150
movl $0x1, -0x4(%rbp)
jmp 0x2e947
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: set_stream_include_path
static void set_stream_include_path(struct stream *stream)
{
	const char *path = stream->path;
	if (!path) {
		const char *p = strrchr(stream->name, '/');
		path = "";
		if (p) {
			int len = p - stream->name + 1;
			char *m = malloc(len+1);
			/* This includes the final "/" */
			memcpy(m, stream->name, len);
			m[len] = 0;
			path = m;
			/* normalize this path */
			while (path[0] == '.' && path[1] == '/') {
				path += 2;
				while (path[0] == '/')
					path++;
			}
		}
		stream->path = path;
	}
	includepath[0] = path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2ea51
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x2f, %esi
callq 0x11110
movq %rax, -0x18(%rbp)
leaq 0x33e99(%rip), %rax     # 0x62829
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2ea45
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x11200
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x111d0
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
movb %al, -0x29(%rbp)
jne 0x2ea12
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x2ea1b
jmp 0x2ea43
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x2ea41
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2ea27
jmp 0x2e9f0
jmp 0x2ea45
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x599c4(%rip)     # 0x88420
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: do_include_path
static int do_include_path(const char **pptr, struct token **list, struct token *token, const char *filename, int flen)
{
	const char *path;

	while ((path = *pptr++) != NULL) {
		if (!try_include(token->pos, path, filename, flen, list, pptr))
			continue;
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x2ead7
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %r8
movq -0x10(%rbp), %r9
movq (%rax), %rdi
callq 0x2e830
cmpl $0x0, %eax
jne 0x2eace
jmp 0x2ea8c
movl $0x1, -0x4(%rbp)
jmp 0x2eade
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: scan_next
static inline struct token *scan_next(struct token **where)
{
	struct token *token = *where;
	if (token_type(token) != TOKEN_UNTAINT)
		return token;
	do {
		token->ident->tainted = 0;
		token = token->next;
	} while (token_type(token) == TOKEN_UNTAINT);
	*where = token;
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x1a, %eax
je 0x2eb1d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2eb62
jmp 0x2eb1f
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movb 0x11(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x11(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x1a, %eax
je 0x2eb1f
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: expand_one_symbol
static int expand_one_symbol(struct token **list)
{
	struct token *token = *list;
	struct symbol *sym;

	if (token->pos.noexpand)
		return 1;

	sym = lookup_macro(token->ident);
	if (!sym)
		return 1;
	if (sym->expand_simple) {
		sym->expand_simple(token);
		return 1;
	} else {
		int rc;

		sym->used_in = file_scope;
		expanding = 1;
		rc = expand(list, sym);
		expanding = 0;
		return rc;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
shrq $0x3f, %rax
cmpl $0x0, %eax
je 0x2eba0
movl $0x1, -0x4(%rbp)
jmp 0x2ec1f
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2be60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2ebc1
movl $0x1, -0x4(%rbp)
jmp 0x2ec1f
movq -0x20(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x2ebe3
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x2ec1f
leaq 0x5a4ce(%rip), %rax     # 0x890b8
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x58(%rax)
movl $0x1, 0x60941(%rip)     # 0x8f540
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2ec30
movl %eax, -0x24(%rbp)
movl $0x0, 0x60927(%rip)     # 0x8f540
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: expand_arguments
static void expand_arguments(int count, struct arg *args)
{
	int i;
	for (i = 0; i < count; i++) {
		struct token *arg = args[i].arg;
		if (!arg)
			arg = &eof_token_entry;
		if (args[i].n_str)
			args[i].str = stringify(arg);
		if (args[i].n_normal) {
			if (!args[i].n_quoted) {
				args[i].expanded = arg;
				args[i].arg = NULL;
			} else if (eof_token(arg)) {
				args[i].expanded = arg;
			} else {
				args[i].expanded = dup_list(arg);
			}
			expand_list(&args[i].expanded);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2f3aa
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2f2aa
leaq 0x7d71a(%rip), %rax     # 0xac9c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x20(%rax)
je 0x2f2de
movq -0x20(%rbp), %rdi
callq 0x2fc80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x18(%rax)
je 0x2f39a
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x1c(%rax)
jne 0x2f33b
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
jmp 0x2f382
leaq 0x7d67e(%rip), %rax     # 0xac9c0
cmpq %rax, -0x20(%rbp)
jne 0x2f361
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
jmp 0x2f380
movq -0x20(%rbp), %rdi
callq 0x2fd40
movq %rax, %rcx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
jmp 0x2f382
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
addq $0x8, %rdi
callq 0x2e6d0
jmp 0x2f39c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2f276
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: preprocessor_line
static void preprocessor_line(struct stream *stream, struct token **line)
{
	struct token *start = *line, *next;
	struct token **tp = &start->next;

	for (;;) {
		next = *tp;
		if (next->pos.newline)
			break;
		tp = &next->next;
	}
	*line = next;
	*tp = &eof_token_entry;
	handle_preprocessor_line(stream, line, start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
shrq $0x14, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x2fa18
jmp 0x2fa26
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0x2f9f7
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
leaq 0x7cf84(%rip), %rcx     # 0xac9c0
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2fa60
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: handle_preprocessor_line
static void handle_preprocessor_line(struct stream *stream, struct token **line, struct token *start)
{
	int (*handler)(struct stream *, struct token **, struct token *);
	struct token *token = start->next;
	int is_normal = 1;
	int is_cond = 0;	// is one of {is,ifdef,ifndef,elif,else,endif}

	if (eof_token(token))
		return;

	if (token_type(token) == TOKEN_IDENT) {
		struct symbol *sym = lookup_symbol(token->ident, NS_PREPROCESSOR);
		if (sym) {
			handler = sym->handler;
			is_normal = sym->normal;
			is_cond = !sym->normal;
		} else {
			handler = handle_nondirective;
		}
	} else if (token_type(token) == TOKEN_NUMBER) {
		handler = handle_line;
	} else {
		handler = handle_nondirective;
	}

	if (is_normal) {
		dirty_stream(stream);
		if (false_nesting)
			goto out;
	}

	if (expanding) {
		if (!is_cond || Wpedantic)
			warning(start->pos, "directive in macro's argument list");
	}
	if (!handler(stream, line, token))	/* all set */
		return;

out:
	free_preprocessor_line(token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
leaq 0x7cf2b(%rip), %rax     # 0xac9c0
cmpq %rax, -0x28(%rbp)
jne 0x2faa0
jmp 0x2fbcc
movq -0x28(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x2fb07
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x40, %esi
callq 0x3f450
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x2fafa
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, 0x50(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x30(%rbp)
jmp 0x2fb05
leaq 0xdf(%rip), %rax        # 0x2fbe0
movq %rax, -0x20(%rbp)
jmp 0x2fb31
movq -0x28(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x5, %eax
jne 0x2fb24
leaq -0x2dbe(%rip), %rax     # 0x2cd60
movq %rax, -0x20(%rbp)
jmp 0x2fb2f
leaq 0xb5(%rip), %rax        # 0x2fbe0
movq %rax, -0x20(%rbp)
jmp 0x2fb31
cmpl $0x0, -0x2c(%rbp)
je 0x2fb76
jmp 0x2fb39
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x2fb67
movq -0x8(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x2fb65
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
jmp 0x2fb67
jmp 0x2fb69
cmpl $0x0, 0x5f9d4(%rip)     # 0x8f544
je 0x2fb74
jmp 0x2fbc3
jmp 0x2fb76
cmpl $0x0, 0x5f9c3(%rip)     # 0x8f540
je 0x2fba8
cmpl $0x0, -0x30(%rbp)
je 0x2fb91
leaq 0x5d674(%rip), %rax     # 0x8d200
cmpl $0x0, (%rax)
je 0x2fba6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x3802f(%rip), %rsi     # 0x67bce
movb $0x0, %al
callq 0x16d80
jmp 0x2fba8
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
cmpl $0x0, %eax
jne 0x2fbc1
jmp 0x2fbcc
jmp 0x2fbc3
movq -0x28(%rbp), %rdi
callq 0x2fc30
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: free_preprocessor_line
static int free_preprocessor_line(struct token *token)
{
	while (token_type(token) != TOKEN_EOF) {
		struct token *free = token;
		token = token->next;
		__free_token(free);
	};
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x0, %eax
je 0x2fc6b
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x469b0
jmp 0x2fc3c
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: stringify
static struct token *stringify(struct token *arg)
{
	const char *s = show_token_sequence(arg, 1);
	int size = strlen(s)+1;
	struct token *token = __alloc_token(0);
	struct string *string = __alloc_string(size);

	memcpy(string->data, s, size);
	string->length = size;
	token->pos = arg->pos;
	token_type(token) = TOKEN_STRING;
	token->string = string;
	token->next = &eof_token_entry;
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x2e3c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x110c0
addq $0x1, %rax
movl %eax, -0x14(%rbp)
xorl %edi, %edi
callq 0x46980
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
callq 0x46f20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x111d0
movl -0x14(%rbp), %edx
movq -0x28(%rbp), %rax
movl (%rax), %ecx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andl $0x80000000, %ecx       # imm = 0x80000000
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
andq $-0x40, %rcx
orq $0x10, %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
leaq 0x7cc96(%rip), %rcx     # 0xac9c0
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: dup_list
static struct token *dup_list(struct token *list)
{
	struct token *res = NULL;
	struct token **p = &res;

	while (!eof_token(list)) {
		struct token *newtok = __alloc_token(0);
		*newtok = *list;
		*p = newtok;
		p = &newtok->next;
		list = list->next;
	}
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x7cc5d(%rip), %rax     # 0xac9c0
cmpq %rax, -0x8(%rbp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2fd72
jmp 0x2fdc0
xorl %edi, %edi
callq 0x46980
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2fd5c
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: handle_kludge
static int handle_kludge(struct token **p, struct arg *args)
{
	struct token *t = (*p)->next->next;
	while (1) {
		struct arg *v = &args[t->argnum];
		if (token_type(t->next) != TOKEN_CONCAT) {
			if (v->arg) {
				/* ignore the first ## */
				*p = (*p)->next;
				return 0;
			}
			/* skip the entire thing */
			*p = t;
			return 1;
		}
		if (v->arg && !eof_token(v->arg))
			return 0; /* no magic */
		t = t->next->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq 0x10(%rcx), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x18, %eax
je 0x2fe53
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2fe3f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x2fe8b
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x2fe8b
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2fe76
movq -0x28(%rbp), %rax
leaq 0x7cb58(%rip), %rcx     # 0xac9c0
cmpq %rcx, (%rax)
je 0x2fe76
movl $0x0, -0x4(%rbp)
jmp 0x2fe8b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2fdef
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2c800
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq (%rax), %rcx
andq $0x3f, %rdx
andq $-0x40, %rcx
orq %rdx, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
shrq $0x14, %rax
andq $0x1, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq (%rax), %rcx
andq $0x1, %rdx
shlq $0x14, %rdx
andq $-0x100001, %rcx        # imm = 0xFFEFFFFF
orq %rdx, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
shrq $0x15, %rax
andq $0x1, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq (%rax), %rcx
andq $0x1, %rdx
shlq $0x15, %rdx
andq $-0x200001, %rcx        # imm = 0xFFDFFFFF
orq %rdx, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
shrq $0x3f, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq (%rax), %rcx
andq $0x1, %rdx
shlq $0x3f, %rdx
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: copy
static struct token **copy(struct token **where, struct token *list, int *count)
{
	int need_copy = --*count;
	while (!eof_token(list)) {
		struct token *token;
		if (need_copy)
			token = dup_token(list, &list->pos);
		else
			token = list;
		if (token_type(token) == TOKEN_IDENT && token->ident->tainted)
			token->pos.noexpand = 1;
		*where = token;
		where = &token->next;
		list = list->next;
	}
	*where = &eof_token_entry;
	return where;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
movl %eax, -0x1c(%rbp)
leaq 0x7ca07(%rip), %rax     # 0xac9c0
cmpq %rax, -0x10(%rbp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2ffcb
jmp 0x3005a
cmpl $0x0, -0x1c(%rbp)
je 0x2ffe4
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2fe90
movq %rax, -0x28(%rbp)
jmp 0x2ffec
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x30032
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movb 0x11(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x30032
movq -0x28(%rbp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq (%rax), %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
orq %rdx, %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2ffb2
movq -0x8(%rbp), %rax
leaq 0x7c95b(%rip), %rcx     # 0xac9c0
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: already_tokenized
static int already_tokenized(const char *path)
{
	int stream, next;

	for (stream = *hash_stream(path); stream >= 0 ; stream = next) {
		struct stream *s = input_streams + stream;

		next = s->next_stream;
		if (s->once) {
			if (strcmp(path, s->name))
				continue;
			return 1;
		}
		if (s->constant != CONSTANT_FILE_YES)
			continue;
		if (strcmp(path, s->name))
			continue;
		if (s->protect && !lookup_macro(s->protect))
			continue;
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44ae0
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x3058a
leaq 0x63e9d(%rip), %rax     # 0x94388
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x34(%rax)
je 0x30532
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x111b0
cmpl $0x0, %eax
je 0x30529
jmp 0x3057f
movl $0x1, -0x4(%rbp)
jmp 0x30591
movq -0x20(%rbp), %rax
cmpl $0x3, 0x28(%rax)
je 0x3053e
jmp 0x3057f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x111b0
cmpl $0x0, %eax
je 0x30556
jmp 0x3057f
movq -0x20(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x30576
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2be60
cmpq $0x0, %rax
jne 0x30576
jmp 0x3057f
movl $0x1, -0x4(%rbp)
jmp 0x30591
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x304da
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, 0x58774(%rip)     # 0x88d70
je 0x30613
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x37677(%rip), %rsi     # 0x67c83
movb $0x0, %al
callq 0x170e0
leaq 0x57e06(%rip), %rax     # 0x88420
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3064d
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x111b0
cmpl $0x0, %eax
jne 0x3063f
jmp 0x3069a
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x3061e
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x306a0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x30669
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: update_inc_ptrs
static inline void update_inc_ptrs(const char ***where)
{

	if (*where <= dirafter_includepath) {
		dirafter_includepath++;
		/* If this was the entry that we prepend, don't
		 * rise the lower entries, even if they are at
		 * the same level. */
		if (where == &dirafter_includepath)
			return;
	}
	if (*where <= sys_includepath) {
		sys_includepath++;
		if (where == &sys_includepath)
			return;
	}
	if (*where <= isys_includepath) {
		isys_includepath++;
		if (where == &isys_includepath)
			return;
	}

	/* angle_includepath is actually never updated, since we
	 * don't suppport -iquote rught now. May change some day. */
	if (*where <= angle_includepath) {
		angle_includepath++;
		if (where == &angle_includepath)
			return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq 0x58992(%rip), %rax     # 0x89048
ja 0x306de
movq 0x58989(%rip), %rax     # 0x89048
addq $0x8, %rax
movq %rax, 0x5897e(%rip)     # 0x89048
leaq 0x58977(%rip), %rax     # 0x89048
cmpq %rax, -0x8(%rbp)
jne 0x306dc
jmp 0x30777
jmp 0x306de
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq 0x5894c(%rip), %rax     # 0x89038
ja 0x30711
movq 0x58943(%rip), %rax     # 0x89038
addq $0x8, %rax
movq %rax, 0x58938(%rip)     # 0x89038
leaq 0x58931(%rip), %rax     # 0x89038
cmpq %rax, -0x8(%rbp)
jne 0x3070f
jmp 0x30777
jmp 0x30711
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq 0x58921(%rip), %rax     # 0x89040
ja 0x30744
movq 0x58918(%rip), %rax     # 0x89040
addq $0x8, %rax
movq %rax, 0x5890d(%rip)     # 0x89040
leaq 0x58906(%rip), %rax     # 0x89040
cmpq %rax, -0x8(%rbp)
jne 0x30742
jmp 0x30777
jmp 0x30744
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq 0x588d6(%rip), %rax     # 0x89028
ja 0x30777
movq 0x588cd(%rip), %rax     # 0x89028
addq $0x8, %rax
movq %rax, 0x588c2(%rip)     # 0x89028
leaq 0x588bb(%rip), %rax     # 0x89028
cmpq %rax, -0x8(%rbp)
jne 0x30775
jmp 0x30777
jmp 0x30777
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: add_dirafter_entry
static void add_dirafter_entry(struct token *token, const char *path)
{
	const char **dst = includepath;

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

	/* Add to the end */
	while (*dst)
		dst++;
	*dst = path;
	dst++;
	*dst = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x57c89(%rip), %rax     # 0x88420
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x585cd(%rip)     # 0x88d70
je 0x307ba
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x374d0(%rip), %rsi     # 0x67c83
movb $0x0, %al
callq 0x170e0
jmp 0x307bc
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x307d4
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x307bc
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x30858
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2be60
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3084f
leaq 0x5887d(%rip), %rax     # 0x890b8
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x30874
movl $0x0, -0x4(%rbp)
jmp 0x30874
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3743b(%rip), %rsi     # 0x67ca1
movb $0x0, %al
callq 0x16f90
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl 0x5ecab(%rip), %edx     # 0x8f544
movl $0x1c, %ecx
movl $0x1d, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq (%rax), %rcx
andq $0x3f, %rdx
andq $-0x40, %rcx
orq %rdx, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2fc30
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
cmpl $0x0, 0x5ec52(%rip)     # 0x8f544
jne 0x308fa
cmpl $0x1, -0x14(%rbp)
je 0x30909
movl 0x5ec44(%rip), %eax     # 0x8f544
addl $0x1, %eax
movl %eax, 0x5ec3b(%rip)     # 0x8f544
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: replace_with_integer
static void replace_with_integer(struct token *token, unsigned int val)
{
	char *buf = __alloc_bytes(11);
	sprintf(buf, "%u", val);
	token_type(token) = TOKEN_NUMBER;
	token->number = buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0xb, %edi
callq 0x47100
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x328d5(%rip), %rsi     # 0x634d0
movb $0x0, %al
callq 0x112c0
movq -0x8(%rbp), %rax
movq (%rax), %rcx
andq $-0x40, %rcx
orq $0x5, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x110c0
addq $0x1, %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x46f20
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andl $0x80000000, %ecx       # imm = 0x80000000
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x111d0
movq -0x8(%rbp), %rax
movq (%rax), %rcx
andq $-0x40, %rcx
orq $0x10, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x30e38
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movw (%rax), %ax
shlw $0x8, %ax
sarw $0x8, %ax
cwtl
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
sarw $0x8, %cx
movswl %cx, %ecx
subl %ecx, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq -0x8(%rbp), %rax
jne 0x30dfe
jmp 0x30e38
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ptrlist.c
// Function: ptr_list_empty
bool ptr_list_empty(const struct ptr_list *head)
{
	const struct ptr_list *list = head;

	if (!head)
		return true;

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

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x30e5d
movb $0x1, -0x1(%rbp)
jmp 0x30ea2
jmp 0x30e5f
movq -0x18(%rbp), %rax
movw (%rax), %ax
shlw $0x8, %ax
sarw $0x8, %ax
cwtl
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
sarw $0x8, %cx
movswl %cx, %ecx
subl %ecx, %eax
cmpl $0x0, %eax
je 0x30e8a
movb $0x0, -0x1(%rbp)
jmp 0x30ea2
jmp 0x30e8c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
jne 0x30e5f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x30ed4
movb $0x0, -0x1(%rbp)
jmp 0x30f20
jmp 0x30ed6
movq -0x18(%rbp), %rax
movw (%rax), %ax
shlw $0x8, %ax
sarw $0x8, %ax
cwtl
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
sarw $0x8, %cx
movswl %cx, %ecx
subl %ecx, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jle 0x30f08
movb $0x1, -0x1(%rbp)
jmp 0x30f20
jmp 0x30f0a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
jne 0x30ed6
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ptrlist.c
// Function: first_ptr_list
void *first_ptr_list(struct ptr_list *head)
{
	struct ptr_list *list = head;

	if (!head)
		return NULL;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x30f51
movq $0x0, -0x8(%rbp)
jmp 0x30f96
jmp 0x30f53
movq -0x18(%rbp), %rax
movw (%rax), %ax
shlw $0x8, %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
jne 0x30f8a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x30f88
movq $0x0, -0x8(%rbp)
jmp 0x30f96
jmp 0x30f53
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x30fb9
movq $0x0, -0x8(%rbp)
jmp 0x31021
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movw (%rax), %ax
shlw $0x8, %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
jne 0x30ffc
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x30fee
movq $0x0, -0x8(%rbp)
jmp 0x31021
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x30fc5
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x31054
movq $0x0, -0x8(%rbp)
jmp 0x310aa
jmp 0x31056
movq -0x10(%rbp), %rax
movw (%rax), %ax
shlw $0x8, %ax
sarw $0x8, %ax
cwtl
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x31083
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x310aa
movl -0x24(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x31090
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x31056
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x31166
cmpl $0x0, -0x14(%rbp)
jle 0x31166
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
shlw $0x8, %ax
sarw $0x8, %ax
cwtl
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x3110b
jmp 0x31152
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x31119
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x18, %rsi
movslq -0x24(%rbp), %rdx
shlq $0x3, %rdx
callq 0x111d0
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x24(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x8(%rbp), %rax
jne 0x310e7
jmp 0x31166
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3124e
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3119c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movw (%rax), %ax
shlw $0x8, %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
jne 0x31236
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x311dd
movq -0x18(%rbp), %rdi
callq 0x30d20
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x3124e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x30d20
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x31234
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3119c
jmp 0x31236
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x3119a
jmp 0x3124e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %ax
shlw $0x8, %ax
sarw $0x8, %ax
cwtl
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
xorl %edi, %edi
callq 0x30cf0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movw %cx, %dx
movw (%rax), %cx
andw $0xff, %dx
andw $0xff00, %cx            # imm = 0xFF00
orw %dx, %cx
movw %cx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movw %cx, %dx
movw (%rax), %cx
andw $0xff, %dx
andw $0xff00, %cx            # imm = 0xFF00
orw %dx, %cx
movw %cx, (%rax)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movslq -0x10(%rbp), %rdx
shlq $0x3, %rdx
callq 0x111d0
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movslq -0x10(%rbp), %rdx
shlq $0x3, %rdx
movl $0xf0, %esi
callq 0x11130
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)