LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/pre-process.c
// Function: expand_has_extension
static bool expand_has_extension(struct token *token, struct arg *args)
{
	struct token *arg = args[0].expanded;
	struct ident *ident;
	bool val = false;

	if (token_type(arg) != TOKEN_IDENT) {
		sparse_error(arg->pos, "identifier expected");
		return false;
	}

	ident = arg->ident;
	if (ident == &c_alignas_ident)
		val = true;
	else if (ident == &c_alignof_ident)
		val = true;
	else if (ident == &c_generic_selections_ident)
		val = true;
	else if (ident == &c_static_assert_ident)
		val = true;

	replace_with_bool(token, val);
	return 1;
}

// Assembly:
pushq %rbx
movq 0x8(%rsi), %rcx
movq (%rcx), %rax
movl %eax, %ebx
andl $0x3f, %ebx
cmpq $0x3, %rbx
jne 0x1dc7f
movq 0x10(%rcx), %rax
cmpq 0x3c2f2(%rip), %rax     # 0x59f28
sete %cl
cmpq 0x3c2d8(%rip), %rax     # 0x59f18
sete %dl
orb %cl, %dl
cmpq 0x3c354(%rip), %rax     # 0x59fa0
sete %cl
cmpq 0x3c282(%rip), %rax     # 0x59ed8
sete %al
orb %cl, %al
orb %dl, %al
movq (%rdi), %rcx
andq $-0x40, %rcx
orq $0x5, %rcx
movq %rcx, (%rdi)
movzbl %al, %eax
leaq 0x34eeb(%rip), %rcx     # 0x52b60
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rdi)
jmp 0x1dc90
leaq 0x21746(%rip), %rsi     # 0x3f3cc
movq %rax, %rdi
xorl %eax, %eax
callq 0x1120e
cmpl $0x3, %ebx
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/pre-process.c
// Function: expand_has_feature
static bool expand_has_feature(struct token *token, struct arg *args)
{
	struct token *arg = args[0].expanded;
	struct ident *ident;
	bool val = false;

	if (token_type(arg) != TOKEN_IDENT) {
		sparse_error(arg->pos, "identifier expected");
		return false;
	}

	ident = arg->ident;
	if (standard >= STANDARD_C11) {
		if (ident == &c_alignas_ident)
			val = true;
		else if (ident == &c_alignof_ident)
			val = true;
		else if (ident == &c_generic_selections_ident)
			val = true;
		else if (ident == &c_static_assert_ident)
			val = true;
	}

	replace_with_bool(token, val);
	return 1;
}

// Assembly:
pushq %rbx
movq 0x8(%rsi), %rcx
movq (%rcx), %rax
movl %eax, %ebx
andl $0x3f, %ebx
cmpq $0x3, %rbx
jne 0x1dcee
leaq 0x3c8a6(%rip), %rax     # 0x5a558
cmpl $0x8, (%rax)
jb 0x1dd01
movq 0x10(%rcx), %rax
cmpq 0x3c266(%rip), %rax     # 0x59f28
sete %cl
cmpq 0x3c24c(%rip), %rax     # 0x59f18
sete %dl
orb %cl, %dl
cmpq 0x3c2c8(%rip), %rax     # 0x59fa0
sete %cl
cmpq 0x3c1f6(%rip), %rax     # 0x59ed8
sete %al
orb %cl, %al
orb %dl, %al
movzbl %al, %eax
jmp 0x1dd03
leaq 0x216d7(%rip), %rsi     # 0x3f3cc
movq %rax, %rdi
xorl %eax, %eax
callq 0x1120e
jmp 0x1dd20
xorl %eax, %eax
movq (%rdi), %rcx
andq $-0x40, %rcx
orq $0x5, %rcx
movq %rcx, (%rdi)
leaq 0x34e48(%rip), %rcx     # 0x52b60
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rdi)
cmpl $0x3, %ebx
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/pre-process.c
// Function: do_handle_undef
static int do_handle_undef(struct stream *stream, struct token **line, struct token *token, int attr)
{
	struct token *left = token->next;
	struct symbol *sym;

	if (token_type(left) != TOKEN_IDENT) {
		sparse_error(token->pos, "expected identifier to 'undef'");
		return 1;
	}

	sym = lookup_symbol(left->ident, NS_MACRO | NS_UNDEF);
	if (sym) {
		if (attr < sym->attr)
			return 1;
		if (attr == sym->attr && sym->namespace == NS_UNDEF)
			return 1;
	} else if (attr <= SYM_ATTR_NORMAL)
		return 1;

	if (!sym || sym->scope != file_scope) {
		sym = alloc_symbol(left->pos, SYM_NODE);
		bind_symbol(sym, left->ident, NS_MACRO);
	}

	sym->namespace = NS_UNDEF;
	sym->used_in = NULL;
	sym->attr = attr;

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rdi), %r15
movl (%r15), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1e08b
movl %esi, %ebx
movq 0x10(%r15), %rdi
movl $0x81, %esi
callq 0x266e9
testq %rax, %rax
je 0x1e0a1
movq %rax, %r14
movl (%rax), %eax
movl %eax, %ecx
shrl $0x12, %ecx
andl $0x3, %ecx
cmpl %ebx, %ecx
jg 0x1e0e0
xorl %ebx, %ecx
movl %eax, %edx
andl $0x1ff00, %edx          # imm = 0x1FF00
xorl $0x8000, %edx           # imm = 0x8000
orl %ecx, %edx
je 0x1e0e0
movq 0x30(%r14), %rcx
leaq 0x3fd14(%rip), %rdx     # 0x5dd98
cmpq (%rdx), %rcx
jne 0x1e0a6
jmp 0x1e0c6
movq (%rdi), %rdi
leaq 0x210ac(%rip), %rsi     # 0x3f141
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1120e
cmpl $0x2, %ebx
jl 0x1e0e0
movq (%r15), %rdi
pushq $0x3
popq %rsi
callq 0x2671f
movq %rax, %r14
movq 0x10(%r15), %rsi
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x274ad
movl (%r14), %eax
andq $0x0, 0x58(%r14)
andl $0x3, %ebx
shll $0x12, %ebx
andl $0xfff200ff, %eax       # imm = 0xFFF200FF
addl %ebx, %eax
addl $0x8000, %eax           # imm = 0x8000
movl %eax, (%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/pre-process.c
// Function: show_token_sequence
static const char *show_token_sequence(struct token *token, int quote)
{
	static char buffer[MAX_STRING];
	char *ptr = buffer;
	int whitespace = 0;

	if (!token && !quote)
		return "<none>";
	while (!eof_token(token)) {
		const char *val = quote ? quote_token(token) : show_token(token);
		int len = strlen(val);

		if (ptr + whitespace + len >= buffer + sizeof(buffer)) {
			sparse_error(token->pos, "too long token expansion");
			break;
		}

		if (whitespace)
			*ptr++ = ' ';
		memcpy(ptr, val, len);
		ptr += len;
		token = token->next;
		whitespace = token->pos.whitespace;
	}
	*ptr = 0;
	return buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
movl %esi, 0x4(%rsp)
testl %esi, %esi
sete %cl
testb %cl, %al
jne 0x1e18a
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x4304b(%rip), %rbx     # 0x61160
xorl %ebp, %ebp
cmpq 0x3bdca(%rip), %r14     # 0x59ee8
je 0x1e1a4
cmpl $0x0, 0x4(%rsp)
je 0x1e135
movq %r14, %rdi
callq 0x2974e
jmp 0x1e13d
movq %r14, %rdi
callq 0x294bb
movq %rax, %r15
movq %rax, %rdi
callq 0xe0d0
movl %ebp, %ecx
addq %r13, %rcx
movslq %eax, %r12
addq %r12, %rcx
cmpq $0x1fff, %rcx           # imm = 0x1FFF
jge 0x1e193
testl %ebp, %ebp
je 0x1e169
movb $0x20, (%r13,%rbx)
incq %r13
leaq (%rbx,%r13), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xe1e0
addq %r12, %r13
movq 0x8(%r14), %r14
movl (%r14), %ebp
shrl $0x15, %ebp
andl $0x1, %ebp
jmp 0x1e117
leaq 0x1c4fc(%rip), %rbx     # 0x3a68d
jmp 0x1e1aa
movq (%r14), %rdi
leaq 0x20fc3(%rip), %rsi     # 0x3f160
xorl %eax, %eax
callq 0x1120e
movb $0x0, (%r13,%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/pre-process.c
// Function: expand_list
static void expand_list(struct token **list)
{
	struct token *next;
	while (!eof_token(next = scan_next(list))) {
		if (token_type(next) != TOKEN_IDENT || expand_one_symbol(list))
			list = &next->next;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6217c(%rip), %r15     # 0x805e0
movq %rbx, %rdi
callq 0x1e5fe
cmpq %r15, %rax
je 0x1e493
movq %rax, %r14
movl (%rax), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1e48a
movq %rbx, %rdi
callq 0x1e625
testl %eax, %eax
je 0x1e464
addq $0x8, %r14
movq %r14, %rbx
jmp 0x1e464
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, (%rsp)
movq %rcx, 0x8(%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movq %rsi, %rdi
callq 0xe0d0
movq %rax, %r15
movslq %r15d, %r13
leaq 0x44fa1(%rip), %r12     # 0x63470
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xe1e0
testl %r13d, %r13d
je 0x1e50f
movq %r15, %rax
shlq $0x20, %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
addq %rax, %rcx
sarq $0x20, %rcx
cmpb $0x2f, (%r14,%rcx)
je 0x1e512
movb $0x2f, (%r13,%r12)
incl %r13d
movl %r13d, %r15d
jmp 0x1e512
xorl %r15d, %r15d
movslq %r15d, %rdi
addq %r12, %rdi
movslq %ebp, %rdx
leaq 0x44e4e(%rip), %rsi     # 0x63370
callq 0xe1e0
movq %r12, %rdi
callq 0x298bc
movl (%rax), %r13d
leaq 0x49a6f(%rip), %r14     # 0x67fa8
testl %r13d, %r13d
js 0x1e595
movq (%r14), %rax
movl %r13d, %ecx
imulq $0x50, %rcx, %rcx
leaq (%rax,%rcx), %rbx
movl 0x30(%rax,%rcx), %r13d
cmpl $0x0, 0x34(%rax,%rcx)
je 0x1e56a
movq 0x8(%rbx), %rsi
movq %r12, %rdi
callq 0xe1c0
testl %eax, %eax
jne 0x1e539
jmp 0x1e5e8
cmpl $0x3, 0x28(%rbx)
jne 0x1e539
movq 0x8(%rbx), %rsi
movq %r12, %rdi
callq 0xe1c0
testl %eax, %eax
jne 0x1e539
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x1e5e8
callq 0x1cf73
testq %rax, %rax
je 0x1e539
jmp 0x1e5e8
leaq 0x44ed4(%rip), %rdi     # 0x63470
xorl %r14d, %r14d
xorl %esi, %esi
xorl %eax, %eax
callq 0xe2a0
testl %eax, %eax
js 0x1e5ec
movl %eax, %r12d
addl %ebp, %r15d
movslq %r15d, %rsi
leaq 0x44eb4(%rip), %rdi     # 0x63470
callq 0x2a5d2
movq 0x8(%rsp), %rbx
movq (%rbx), %rcx
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
movl %r12d, %edx
movq (%rsp), %r8
callq 0x29fca
movq %rax, (%rbx)
movl %r12d, %edi
callq 0xe150
pushq $0x1
popq %r14
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/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:
movq (%rdi), %rax
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x1a, %ecx
jne 0x1e624
movq 0x10(%rax), %rcx
andb $-0x2, 0x11(%rcx)
movq 0x8(%rax), %rax
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x1a, %ecx
je 0x1e60b
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
cmpq $0x0, (%r14)
js 0x1e651
movq %rdi, %rbx
movq 0x10(%r14), %rdi
callq 0x1cf73
testq %rax, %rax
je 0x1e651
movq 0x60(%rax), %rcx
testq %rcx, %rcx
je 0x1e65c
movq %r14, %rdi
callq *%rcx
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3f735(%rip), %rcx     # 0x5dd98
movq (%rcx), %rcx
movq %rcx, 0x58(%rax)
movb $0x1, 0x44aef(%rip)     # 0x63160
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1e685
movb $0x0, 0x44add(%rip)     # 0x63160
jmp 0x1e654
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r12
movq %r12, %rcx
movq %rcx, %rax
movq 0x8(%rcx), %rcx
testb $0x10, 0x2(%rcx)
je 0x1f2c6
movq %rcx, (%rbx)
leaq 0x61303(%rip), %rcx     # 0x805e0
movq %rcx, 0x8(%rax)
movq 0x8(%r12), %r15
cmpq %rcx, %r15
je 0x1f3ab
movl (%r15), %eax
andl $0x3f, %eax
movb $0x1, %bpl
cmpl $0x5, %eax
je 0x1f32c
cmpl $0x3, %eax
jne 0x1f323
movq 0x10(%r15), %rdi
pushq $0x40
popq %rsi
callq 0x266e9
testq %rax, %rax
je 0x1f323
movq 0x48(%rax), %r13
cmpl $0x0, 0x50(%rax)
setne %bpl
jne 0x1f333
jmp 0x1f357
leaq 0x90(%rip), %r13        # 0x1f3ba
jmp 0x1f333
leaq -0x1e5b(%rip), %r13     # 0x1d4d8
cmpl $0x0, 0x2c(%r14)
jne 0x1f34e
movl $0x1, 0x2c(%r14)
cmpq $0x0, 0x40(%r14)
jne 0x1f34e
andq $0x0, 0x38(%r14)
cmpl $0x0, 0x43e0f(%rip)     # 0x63164
jne 0x1f398
cmpb $0x1, 0x43e02(%rip)     # 0x63160
jne 0x1f388
leaq 0x41ab9(%rip), %rax     # 0x60e20
cmpl $0x0, (%rax)
setne %al
orb %al, %bpl
cmpb $0x1, %bpl
jne 0x1f388
movq (%r12), %rdi
leaq 0x1fea1(%rip), %rsi     # 0x3f222
xorl %eax, %eax
callq 0x1108a
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq *%r13
testl %eax, %eax
je 0x1f3ab
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1f3e1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/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 %rbx
testb $0x3f, (%rdi)
je 0x1f3f5
movq 0x8(%rdi), %rbx
callq 0x2a956
movq %rbx, %rdi
jmp 0x1f3e2
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x3e88c(%rip)     # 0x5dd00
jne 0x1f54b
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x3df29(%rip), %r15     # 0x5d3b0
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1f4a4
movq %rbx, %rsi
callq 0xe1c0
addq $0x8, %r15
testl %eax, %eax
jne 0x1f487
jmp 0x1f545
movq (%r14), %rax
movq 0x3e88a(%rip), %rdx     # 0x5dd38
movq %rax, %rcx
cmpq %rdx, %rax
ja 0x1f4d0
addq $0x8, %rdx
movq %rdx, 0x3e877(%rip)     # 0x5dd38
leaq 0x3e870(%rip), %rcx     # 0x5dd38
cmpq %rcx, %r14
je 0x1f533
movq (%r14), %rcx
movq 0x3e851(%rip), %rdx     # 0x5dd28
cmpq %rdx, %rcx
ja 0x1f4f6
addq $0x8, %rdx
movq %rdx, 0x3e841(%rip)     # 0x5dd28
leaq 0x3e83a(%rip), %rcx     # 0x5dd28
cmpq %rcx, %r14
je 0x1f533
movq (%r14), %rcx
movq 0x3e833(%rip), %rdx     # 0x5dd30
cmpq %rdx, %rcx
ja 0x1f51c
addq $0x8, %rdx
movq %rdx, 0x3e823(%rip)     # 0x5dd30
leaq 0x3e81c(%rip), %rcx     # 0x5dd30
cmpq %rcx, %r14
je 0x1f533
movq (%r14), %rcx
movq 0x3e7f5(%rip), %rdx     # 0x5dd18
cmpq %rdx, %rcx
ja 0x1f533
addq $0x8, %rdx
movq %rdx, 0x3e7e5(%rip)     # 0x5dd18
movq (%rax), %rcx
movq %rbx, (%rax)
addq $0x8, %rax
movq %rcx, %rbx
testq %rcx, %rcx
jne 0x1f533
popq %rbx
popq %r14
popq %r15
retq
movq (%rdi), %rdi
leaq 0x1fd82(%rip), %rsi     # 0x3f2d7
xorl %eax, %eax
callq 0x1132a
// File: /workspace/github_c_makefile_star2_O2/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 0x1f58e
movq 0x10(%rax), %rdi
callq 0x1cf73
testq %rax, %rax
je 0x1f5a0
leaq 0x3e816(%rip), %rcx     # 0x5dd98
movq (%rcx), %rcx
movq %rcx, 0x58(%rax)
pushq $0x1
popq %rbx
jmp 0x1f5a2
leaq 0x1fd60(%rip), %rsi     # 0x3f2f5
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1120e
jmp 0x1f5a2
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x1, 0x43baa(%rip)     # 0x63164
pushq $0x1d
popq %rax
sbbq $0x0, %rax
movq (%rsi), %rcx
movq 0x8(%rsi), %rdi
andq $-0x40, %rcx
orq %rax, %rcx
movq %rcx, (%rsi)
callq 0x1f3e1
movq 0x48(%r15), %rax
movq %rax, 0x8(%r14)
movq %r14, 0x48(%r15)
movl 0x43b7b(%rip), %eax     # 0x63164
xorl $0x1, %ebx
orl %eax, %ebx
je 0x1f5f8
incl %eax
movl %eax, 0x43b6c(%rip)     # 0x63164
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/pre-process.c
// Function: expression_value
static int expression_value(struct token **where)
{
	struct expression *expr;
	struct token *p;
	struct token **list = where, **beginning = NULL;
	long long value;
	int state = 0;

	while (!eof_token(p = scan_next(list))) {
		switch (state) {
		case 0:
			if (token_type(p) != TOKEN_IDENT)
				break;
			if (p->ident == &defined_ident) {
				state = 1;
				beginning = list;
				break;
			}
			if (!expand_one_symbol(list))
				continue;
			if (token_type(p) != TOKEN_IDENT)
				break;
			token_type(p) = TOKEN_ZERO_IDENT;
			break;
		case 1:
			if (match_op(p, '(')) {
				state = 2;
			} else {
				state = 0;
				replace_with_defined(p);
				*beginning = p;
			}
			break;
		case 2:
			if (token_type(p) == TOKEN_IDENT)
				state = 3;
			else
				state = 0;
			replace_with_defined(p);
			*beginning = p;
			break;
		case 3:
			state = 0;
			if (!match_op(p, ')'))
				sparse_error(p->pos, "missing ')' after \"defined\"");
			*list = p->next;
			continue;
		}
		list = &p->next;
	}

	p = constant_expression(*where, &expr);
	if (!eof_token(p))
		sparse_error(p->pos, "garbage at end: %s", show_token_sequence(p, 0));
	value = get_expression_value(expr);
	return value != 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
leaq 0x60fca(%rip), %r13     # 0x805e0
leaq 0x1f7d3(%rip), %rbp     # 0x3edf0
leaq 0x3ed1c(%rip), %rbx     # 0x5e340
movq %rdi, 0x8(%rsp)
movq $0x0, (%rsp)
xorl %r14d, %r14d
movq %r12, %rdi
callq 0x1e5fe
cmpq %r13, %rax
je 0x1f710
movq %rax, %r15
movq (%rax), %rdi
movl %edi, %eax
andl $0x3f, %eax
movl %r14d, %ecx
movslq (%rbp,%rcx,4), %rcx
addq %rbp, %rcx
jmpq *%rcx
cmpl $0x3, %eax
jne 0x1f6da
cmpq %rbx, 0x10(%r15)
je 0x1f6c1
movq %r12, %rdi
callq 0x1e625
xorl %r14d, %r14d
testl %eax, %eax
je 0x1f634
movq (%r15), %rax
movl %eax, %ecx
andl $0x3f, %ecx
xorl %r14d, %r14d
cmpl $0x3, %ecx
jne 0x1f6dd
andq $-0x40, %rax
orq $0x4, %rax
movq %rax, (%r15)
jmp 0x1f6dd
cmpl $0x12, %eax
jne 0x1f6cb
cmpl $0x28, 0x10(%r15)
jne 0x1f6cb
pushq $0x2
jmp 0x1f6c7
xorl %ecx, %ecx
cmpl $0x3, %eax
sete %cl
leal (%rcx,%rcx,2), %r14d
movq %r15, %rdi
callq 0x1f76f
movq (%rsp), %rax
movq %r15, (%rax)
jmp 0x1f6dd
movq %r12, (%rsp)
pushq $0x1
popq %r14
jmp 0x1f6dd
movq %r15, %rdi
callq 0x1f76f
movq (%rsp), %rax
movq %r15, (%rax)
xorl %r14d, %r14d
addq $0x8, %r15
movq %r15, %r12
jmp 0x1f634
cmpl $0x12, %eax
jne 0x1f6f5
cmpl $0x29, 0x10(%r15)
je 0x1f703
leaq 0x1fc65(%rip), %rsi     # 0x3f361
xorl %eax, %eax
callq 0x1120e
movq 0x8(%r15), %rax
movq %rax, (%r12)
jmp 0x1f631
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x33498
cmpq 0x3a7bf(%rip), %rax     # 0x59ee8
je 0x1f74c
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1e0e6
movq (%rbx), %rdi
leaq 0x1fc3b(%rip), %rsi     # 0x3f37d
movq %rax, %rdx
xorl %eax, %eax
callq 0x1120e
movq 0x10(%rsp), %rdi
callq 0xfe1b
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
pushq $0xb
popq %rdi
callq 0x2acaa
movq %rax, %r15
leaq 0x1ae4b(%rip), %rsi     # 0x3a600
movq %rax, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0xe2d0
movq (%r14), %rax
andq $-0x40, %rax
orq $0x5, %rax
movq %rax, (%r14)
movq %r15, 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1f8bf
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 0x1f8a6
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1f916
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 0x1f915
movq 0x10(%rcx), %rcx
cmpq %rdi, %rcx
jne 0x1f8f2
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1f954
movq %rdi, %rcx
movq 0x8(%rcx), %rcx
movl (%rcx), %edx
shll $0x8, %edx
testw %dx, %dx
jne 0x1f955
cmpq %rdi, %rcx
jne 0x1f941
retq
movswl %dx, %eax
shrl $0x8, %eax
movswq %ax, %rax
movq 0x10(%rcx,%rax,8), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
testq %rdi, %rdi
je 0x1f985
movq %rdi, %rcx
movl %esi, %edx
movsbl (%rcx), %r8d
subl %r8d, %edx
jb 0x1f986
movq 0x10(%rcx), %rcx
movl %edx, %esi
cmpq %rdi, %rcx
jne 0x1f971
retq
movl %esi, %eax
movq 0x18(%rcx,%rax,8), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq (%rdi), %r15
testq %r15, %r15
je 0x1fa6d
movq %rdi, %rbx
movq %r15, %r14
movq 0x10(%r14), %r12
cmpb $0x0, (%r14)
jne 0x1fa4f
cmpq %r14, %r12
je 0x1fa61
movq 0x8(%r14), %rax
movq %r12, 0x10(%rax)
movq %rax, 0x8(%r12)
movq %r14, %rdi
callq 0x1f85a
cmpq %r15, %r14
je 0x1fa59
movq %r12, %r14
cmpq %r15, %r12
jne 0x1fa26
jmp 0x1fa6d
movq %r12, (%rbx)
movq %r12, %r15
jmp 0x1fa23
movq %r14, %rdi
callq 0x1f85a
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
movsbl (%rdi), %ebp
movsbl %bpl, %eax
movb $0x2, %cl
idivb %cl
movsbl %al, %r14d
xorl %edi, %edi
callq 0x1f848
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 %r14b, (%rax)
leaq 0x18(%rax), %rdi
movslq %ebp, %rax
leaq (%rbx,%rax,8), %rbx
addq $0x18, %rbx
movsbq %r14b, %r14
shlq $0x3, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0xe1e0
movq %rbx, %rdi
movl $0xf0, %esi
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0xe130
// File: /workspace/github_c_makefile_star2_O2/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 0x1fb11
movq 0x8(%r15), %rax
movsbl (%rax), %ecx
cmpw $0xd, %cx
jl 0x1fb35
movq %rax, %r12
jmp 0x1fb14
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x1f848
testq %r15, %r15
je 0x1fb3a
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x8(%r15)
addq $0x10, %r12
movq %r12, %r14
jmp 0x1fb42
movswl %cx, %ecx
jmp 0x1fb47
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_O2/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 0x1fb7e
cmpq $0x4, %rdx
jae 0x1fb9d
orq %rdx, %rsi
popq %rax
jmp 0x1fae9
leaq 0x1f895(%rip), %rdi     # 0x3f41a
leaq 0x1f8ac(%rip), %rsi     # 0x3f438
leaq 0x1f8af(%rip), %rcx     # 0x3f442
movl $0x12d, %edx            # imm = 0x12D
callq 0xe120
leaq 0x1f8e3(%rip), %rdi     # 0x3f487
leaq 0x1f88d(%rip), %rsi     # 0x3f438
leaq 0x1f890(%rip), %rcx     # 0x3f442
movl $0x12e, %edx            # imm = 0x12E
callq 0xe120
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
testq %rdi, %rdi
je 0x1fbfc
movq %rdi, %rax
movsbl (%rax), %ecx
testw %cx, %cx
movl $0x0, %edx
cmovgl %ecx, %edx
movzwl %dx, %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x1fbee
leaq 0x1(%rdx), %r8
cmpq %rsi, 0x18(%rax,%rdx,8)
movq %r8, %rdx
jne 0x1fbd9
jmp 0x1fbfa
movq 0x10(%rax), %rax
cmpq %rdi, %rax
jne 0x1fbc6
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1fcaf
movl $0xf0f0f0f0, %ecx       # imm = 0xF0F0F0F0
movq %rax, %rdx
leaq 0x18(%rdx), %r9
leaq 0x10(%rdx), %r8
movzwl (%rdx), %r11d
xorl %r10d, %r10d
movsbl %r11b, %ebp
cmpl %ebp, %r10d
jge 0x1fca3
movslq %r10d, %r14
movq (%r9,%r14,8), %r15
cmpw $0x100, %r11w           # imm = 0x100
setb %bpl
testq %r15, %r15
setne %r12b
orb %bpl, %r12b
cmpb $0x1, %r12b
jne 0x1fc9e
cmpq %rsi, %r15
jne 0x1fc9e
movsbl %r11b, %ebp
leaq (%r9,%r14,8), %r11
movswq %bp, %r14
leaq (%r8,%r14,8), %r14
cmpq %r14, %r11
jae 0x1fc7b
movq 0x8(%r11), %r15
movq %r15, (%r11)
addq $0x8, %r11
jmp 0x1fc69
movq %rcx, (%r11)
movl (%rdx), %r11d
leal -0x1(%r11), %ebp
movzbl %bpl, %ebp
andl $0xffffff00, %r11d      # imm = 0xFFFFFF00
orl %ebp, %r11d
movw %r11w, (%rdx)
decl %ebx
je 0x1fcd2
decl %r10d
incl %r10d
jmp 0x1fc2a
movq (%r8), %rdx
cmpq %rax, %rdx
jne 0x1fc1b
testl %ebx, %ebx
jle 0x1fcd4
leaq 0x1f7dd(%rip), %rdi     # 0x3f497
leaq 0x1f777(%rip), %rsi     # 0x3f438
leaq 0x1f7da(%rip), %rcx     # 0x3f4a2
movl $0x15a, %edx            # imm = 0x15A
callq 0xe120
xorl %ebx, %ebx
callq 0x1fa10
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x1fd3b
movq %rax, %rdi
movl (%rdi), %r8d
movsbq %r8b, %r9
xorl %r10d, %r10d
cmpq %r9, %r10
jge 0x1fd32
cmpw $0x100, %r8w            # imm = 0x100
setb %bl
movq 0x18(%rdi,%r10,8), %r11
testq %r11, %r11
setne %bpl
orb %bl, %bpl
cmpb $0x1, %bpl
jne 0x1fd2d
cmpq %rsi, %r11
jne 0x1fd2d
movq %rdx, 0x18(%rdi,%r10,8)
decl %ecx
je 0x1fd5e
incq %r10
jmp 0x1fcfc
movq 0x10(%rdi), %rdi
cmpq %rax, %rdi
jne 0x1fcf2
testl %ecx, %ecx
jle 0x1fd60
leaq 0x1f751(%rip), %rdi     # 0x3f497
leaq 0x1f6eb(%rip), %rsi     # 0x3f438
leaq 0x1f789(%rip), %rcx     # 0x3f4dd
movl $0x172, %edx            # imm = 0x172
callq 0xe120
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1fd87
movq %rdx, %rcx
movq 0x8(%rcx), %rcx
movzwl (%rcx), %esi
testb %sil, %sil
jne 0x1fd88
cmpq %rdx, %rcx
jne 0x1fd76
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_O2/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), %rcx
testq %rcx, %rcx
je 0x1fddf
movq 0x8(%rcx), %rax
movzwl (%rax), %edx
testb %dl, %dl
je 0x1fde3
leal -0x1(%rdx), %esi
movzbl %sil, %r8d
andl $0xffffff00, %edx       # imm = 0xFFFFFF00
orl %r8d, %edx
movw %dx, (%rax)
movsbq %sil, %rsi
movq 0x18(%rax,%rsi,8), %rbx
jmp 0x1fde5
xorl %ebx, %ebx
jmp 0x1fe06
xorl %ebx, %ebx
testb %dl, %dl
jg 0x1fe06
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rcx)
movq %rcx, 0x10(%rdx)
cmpq %rcx, %rax
jne 0x1fdfe
andq $0x0, (%rdi)
movq %rax, %rdi
callq 0x1f85a
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1fe61
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jge 0x1fe4d
movq 0x18(%r15,%r12,8), %rsi
cmpw $0x100, %ax             # imm = 0x100
jb 0x1fe40
testq %rsi, %rsi
je 0x1fe48
movq %rbx, %rdi
callq 0x1fae9
incq %r12
jmp 0x1fe24
movq 0x10(%r15), %r15
cmpq %r14, %r15
jne 0x1fe21
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1ff21
movq (%rdi), %rax
testq %rax, %rax
je 0x1ff19
movq %rax, 0x10(%rsp)
movq 0x8(%rax), %r12
movsbl (%r12), %ebp
movq 0x8(%rsp), %r14
movsbl (%r14), %eax
testw %ax, %ax
movl $0x0, %ecx
cmovgl %eax, %ecx
movzwl %cx, %r13d
xorl %r15d, %r15d
cmpq %r15, %r13
je 0x1feef
movq 0x18(%r14,%r15,8), %rbx
incq %r15
testq %rbx, %rbx
je 0x1feb3
cmpl $0xd, %ebp
jl 0x1fee3
xorl %edi, %edi
callq 0x1f848
movq %rax, 0x10(%r12)
movq %r12, 0x8(%rax)
movb %bpl, (%r12)
xorl %ebp, %ebp
movq %rax, %r12
movslq %ebp, %rax
incl %ebp
movq %rbx, 0x18(%r12,%rax,8)
jmp 0x1feb3
movq 0x10(%r14), %rbx
movq %r14, %rdi
callq 0x1f85a
movq %rbx, %r14
cmpq 0x8(%rsp), %rbx
jne 0x1fe9d
movb %bpl, (%r12)
movq 0x10(%rsp), %rax
movq %r12, 0x8(%rax)
movq %rax, 0x10(%r12)
jmp 0x1ff21
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_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1ff5f
movq 0x8(%rdi), %rax
andq $0x0, 0x10(%rax)
testq %rdi, %rdi
je 0x1ff5b
movq 0x10(%rdi), %r14
callq 0x1f85a
movq %r14, %rdi
jmp 0x1ff48
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq 0x30(%rdi), %rdi
cmpq %rsi, %rdi
je 0x1ffbb
movq %rsi, %rbx
testq %rdi, %rdi
je 0x1ffa9
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x1fbfd
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1ff74
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2ac3e
leaq 0x3dda6(%rip), %rcx     # 0x5dd78
movq %rcx, 0x8(%rax)
movq %rax, 0x3ddbb(%rip)     # 0x5dd98
movq %rax, 0x3ddac(%rip)     # 0x5dd90
movq %rax, 0x3dd9d(%rip)     # 0x5dd88
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, (%rcx)
testq %rax, %rax
je 0x200a2
movq %rax, %rcx
xorl %edx, %edx
movl (%rcx), %edi
movsbq %dil, %rsi
cmpq %rsi, %rdx
jge 0x20099
movq 0x18(%rcx,%rdx,8), %rsi
cmpw $0x100, %di             # imm = 0x100
jb 0x20076
testq %rsi, %rsi
je 0x20094
movq 0x18(%rsi), %rdi
addq $0x8, %rdi
movq %rdi, %r8
movq (%rdi), %r9
leaq 0x20(%r9), %rdi
cmpq %rsi, %r9
jne 0x2007e
movq 0x20(%rsi), %rsi
movq %rsi, (%r8)
incq %rdx
jmp 0x2005a
movq 0x10(%rcx), %rcx
cmpq %rax, %rcx
jne 0x20058
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x44394(%rip), %rax     # 0x64498
movq (%rax), %r14
testq %r14, %r14
je 0x20175
leaq 0x1f417(%rip), %rbx     # 0x3f52a
movq %r14, %r15
xorl %r12d, %r12d
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jge 0x2016c
movq 0x18(%r15,%r12,8), %r13
cmpw $0x100, %ax             # imm = 0x100
jb 0x20135
testq %r13, %r13
je 0x20167
cmpq $0x0, 0x90(%r13)
je 0x20167
testb $0x2, 0x2(%r13)
jne 0x20167
testb $0x40, 0x5a(%r13)
jne 0x20167
movq 0x18(%r13), %rdi
callq 0x2936d
movq 0x4(%r13), %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1108a
incq %r12
jmp 0x20119
movq 0x10(%r15), %r15
cmpq %r14, %r15
jne 0x20116
leaq 0x4431c(%rip), %rdi     # 0x64498
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2003f
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x3dbcf(%rip), %rcx     # 0x5dd90
pushq $0x1
popq %rax
cmpq %rdi, %rsi
je 0x201d6
cmpq %rcx, %rsi
je 0x201d4
movq 0x8(%rsi), %rsi
jmp 0x201c4
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x20518
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x19407(%rip), %rdi     # 0x398cd
leaq 0x1a30e(%rip), %r15     # 0x3a7db
movq %rbx, %r12
xorl %r13d, %r13d
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jge 0x20505
movq 0x18(%r12,%r13,8), %r14
cmpw $0x100, %ax             # imm = 0x100
jb 0x204f0
testq %r14, %r14
je 0x20500
callq 0xe0a0
movq %r14, %rdi
callq 0x20519
movq %r15, %rdi
incq %r13
jmp 0x204d3
movq 0x10(%r12), %r12
cmpq %rbx, %r12
jne 0x204d0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2069b
movq %rdi, %rbx
movq 0x70(%rdi), %rsi
testq %rsi, %rsi
je 0x20547
leaq 0x1f113(%rip), %rdi     # 0x3f653
xorl %eax, %eax
callq 0xe0f0
movq %rbx, %rdi
callq 0x20737
movq 0x60(%rbx), %r14
testq %r14, %r14
je 0x20603
movzbl (%r14), %eax
leal -0x7(%rax), %ecx
cmpl $0x2, %ecx
jae 0x20619
movq %rbx, (%rsp)
leaq 0x1f7a1(%rip), %rdi     # 0x3fd18
callq 0xe0a0
movq 0x98(%r14), %r15
testq %r15, %r15
je 0x205f1
leaq 0x1f52b(%rip), %r14     # 0x3faba
pushq $0xa
popq %rbp
movq %r15, %r12
xorl %r13d, %r13d
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jge 0x205e7
movq 0x18(%r12,%r13,8), %rbx
cmpw $0x100, %ax             # imm = 0x100
jb 0x205b5
testq %rbx, %rbx
je 0x205e2
movq 0x18(%rbx), %rdi
callq 0x2936d
movl 0x50(%rbx), %edx
movq 0x70(%rbx), %rcx
movq 0x48(%rbx), %r8
movzbl 0x54(%rbx), %r9d
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
movl %ebp, %edi
callq 0xe040
incq %r13
jmp 0x20598
movq 0x10(%r12), %r12
cmpq %r15, %r12
jne 0x20595
leaq 0x1f723(%rip), %rdi     # 0x3fd1b
callq 0xe0a0
movq (%rsp), %rbx
jmp 0x2066b
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe040
cmpl $0x5, %eax
jne 0x20663
movq 0x90(%r14), %r14
pushq $0xa
popq %rdi
callq 0xe040
testq %r14, %r14
je 0x2066b
movq %r14, %rdi
callq 0x20b88
testl %eax, %eax
je 0x20655
movq 0x18(%r14), %rcx
movl 0x50(%rcx), %esi
leaq 0x1f013(%rip), %rdi     # 0x3f65f
movl %eax, %edx
xorl %eax, %eax
callq 0xe0f0
leaq 0x1f6b7(%rip), %rdi     # 0x3fd13
callq 0xe0a0
jmp 0x2066b
pushq $0xa
popq %rdi
callq 0xe040
cmpq $0x0, 0xb0(%rbx)
je 0x2069b
leaq 0x1f6a1(%rip), %rdi     # 0x3fd1d
callq 0xe0a0
movq 0xb0(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21182
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/show-parse.c
// Function: builtin_type_suffix
const char *builtin_type_suffix(struct symbol *sym)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(typenames); i++)
		if (typenames[i].sym == sym)
			return typenames[i].suffix;
	return NULL;
}

// Assembly:
xorl %eax, %eax
leaq 0x32485(%rip), %rcx     # 0x52b70
xorl %edx, %edx
leaq 0x18(%rdx), %rsi
cmpq $0x2b8, %rsi            # imm = 0x2B8
je 0x20708
cmpq %rdi, (%rdx,%rcx)
movq %rsi, %rdx
jne 0x206ed
movq -0x8(%rsi,%rcx), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x20777
movq 0x8(%rbx), %rax
movb $0x0, (%rax)
movq (%rbx), %rsi
leaq 0x23f26(%rip), %rdi     # 0x4468d
xorl %eax, %eax
callq 0xe0f0
addq $0xe0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4399e(%rip), %rax     # 0x64504
movq %rsp, %rbx
movq %rax, 0x8(%rbx)
movq %rax, (%rbx)
movq %rbx, %rsi
callq 0x20777
movq 0x8(%rbx), %rax
movb $0x0, (%rax)
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2175b
leaq 0x1e3e1(%rip), %r14     # 0x3fad6
movq (%rsp), %r13
xorl %ebx, %ebx
movl (%r13), %eax
movsbq %al, %rcx
cmpq %rcx, %rbx
jge 0x21751
movq 0x18(%r13,%rbx,8), %r15
cmpw $0x100, %ax             # imm = 0x100
jb 0x21718
testq %r15, %r15
je 0x2174c
movq 0xb0(%r15), %rdi
testq %rdi, %rdi
je 0x2174c
movq 0x10(%rdi), %rax
movl 0x50(%rax), %ebp
callq 0x21182
movl %eax, %r12d
movq %r15, %rdi
callq 0x2176a
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0xe0f0
incq %rbx
jmp 0x216fb
movq 0x10(%r13), %r13
cmpq (%rsp), %r13
jne 0x216f9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq