LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: predefine
void predefine(const char *name, int weak, const char *fmt, ...)
{
	struct ident *ident = built_in_ident(name);
	struct token *value = &eof_token_entry;
	int attr = weak ? SYM_ATTR_WEAK : SYM_ATTR_NORMAL;

	if (fmt && fmt[0]) {
		static char buf[256];
		va_list ap;

		va_start(ap, fmt);
		vsnprintf(buf, sizeof(buf), fmt, ap);
		va_end(ap);

		value = __alloc_token(0);
		if (isdigit((unsigned char)buf[0])) {
			token_type(value) = TOKEN_NUMBER;
			value->number = xstrdup(buf);
		} else {
			token_type(value) = TOKEN_IDENT;
			value->ident = built_in_ident(buf);
		}
		value->pos.whitespace = 1;
		value->next = &eof_token_entry;
	}

	do_define(value->pos, NULL, ident, NULL, value, attr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x2b3de
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x44f10
movq %rax, -0x20(%rbp)
leaq 0x815ae(%rip), %rax     # 0xac9c0
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2b52b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2b52b
leaq -0x50(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x18(%rbp), %rdx
leaq -0x50(%rbp), %rcx
leaq 0x61ea9(%rip), %rdi     # 0x8d320
movl $0x100, %esi            # imm = 0x100
callq 0x110b0
leaq -0x50(%rbp), %rax
xorl %edi, %edi
callq 0x46980
movq %rax, -0x28(%rbp)
callq 0x112f0
movq (%rax), %rax
movzbl 0x61e81(%rip), %ecx     # 0x8d320
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x2b4db
movq -0x28(%rbp), %rax
movq (%rax), %rcx
andq $-0x40, %rcx
orq $0x5, %rcx
movq %rcx, (%rax)
leaq 0x61e57(%rip), %rdi     # 0x8d320
callq 0x46350
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x2b504
movq -0x28(%rbp), %rax
movq (%rax), %rcx
andq $-0x40, %rcx
orq $0x3, %rcx
movq %rcx, (%rax)
leaq 0x61e2c(%rip), %rdi     # 0x8d320
callq 0x44f10
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
andq $-0x200001, %rcx        # imm = 0xFFDFFFFF
orq $0x200000, %rcx         # imm = 0x200000
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
leaq 0x81499(%rip), %rcx     # 0xac9c0
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %r8
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %r9d
movq (%r8), %rdi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
callq 0x2b550
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: preprocess
struct token * preprocess(struct token *token)
{
	preprocessing = 1;
	init_preprocessor();
	do_preprocess(&token);

	// Drop all expressions from preprocessing, they're not used any more.
	// This is not true when we have multiple files, though ;/
	// clear_expression_alloc();
	preprocessing = 0;

	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x618bd(%rip), %rax     # 0x8d240
movl $0x1, (%rax)
callq 0x2b9b0
leaq -0x8(%rbp), %rdi
callq 0x2bb70
leaq 0x618a2(%rip), %rax     # 0x8d240
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: dump_macro_definitions
void dump_macro_definitions(void)
{
	struct ident *name;

	FOR_EACH_PTR(macros, name) {
		struct symbol *sym = lookup_macro(name);
		if (sym)
			dump_macro(sym);
	} END_FOR_EACH_PTR(name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x61681(%rip), %rax     # 0x8d420
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2bdbf
jmp 0x2be4e
jmp 0x2bdc1
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x2be36
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x2be0c
cmpq $0x0, -0x8(%rbp)
jne 0x2be0c
jmp 0x2be2b
movq -0x8(%rbp), %rdi
callq 0x2be60
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x2be29
movq -0x30(%rbp), %rdi
callq 0x2beb0
jmp 0x2be2b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2bdc8
jmp 0x2be38
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
jne 0x2bdc1
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: lookup_macro
static struct symbol *lookup_macro(struct ident *ident)
{
	struct symbol *sym = lookup_symbol(ident, NS_MACRO | NS_UNDEF);
	if (sym && sym->namespace != NS_MACRO)
		sym = NULL;
	return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x81, %esi
callq 0x3f450
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2bea0
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0x1ff, %eax            # imm = 0x1FF
cmpl $0x1, %eax
je 0x2bea0
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: token_list_different
static int token_list_different(struct token *list1, struct token *list2)
{
	for (;;) {
		if (list1 == list2)
			return 0;
		if (!list1 || !list2)
			return 1;
		if (token_different(list1, list2))
			return 1;
		list1 = list1->next;
		list2 = list2->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x2c2f3
movl $0x0, -0x4(%rbp)
jmp 0x2c33f
cmpq $0x0, -0x10(%rbp)
je 0x2c301
cmpq $0x0, -0x18(%rbp)
jne 0x2c30a
movl $0x1, -0x4(%rbp)
jmp 0x2c33f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2c8f0
cmpl $0x0, %eax
je 0x2c325
movl $0x1, -0x4(%rbp)
jmp 0x2c33f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2c2e0
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: handle_hash
static struct token *handle_hash(struct token **p, struct token *arglist)
{
	struct token *token = *p;
	if (arglist) {
		struct token *next = token->next;
		if (!try_arg(next, TOKEN_STR_ARGUMENT, arglist))
			goto Equote;
		next->pos.whitespace = token->pos.whitespace;
		__free_token(token);
		token = *p = next;
	} else {
		token->pos.noexpand = 1;
	}
	return token;

Equote:
	sparse_error(token->pos, "'#' is not followed by a macro parameter");
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2c452
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x16, %esi
callq 0x2c650
cmpl $0x0, %eax
jne 0x2c407
jmp 0x2c47d
movq -0x20(%rbp), %rax
movq (%rax), %rax
shrq $0x15, %rax
andq $0x1, %rax
movl %eax, %ecx
movq -0x28(%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 -0x20(%rbp), %rdi
callq 0x469b0
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
movq %rax, -0x20(%rbp)
jmp 0x2c473
movq -0x20(%rbp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq (%rax), %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
orq %rdx, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c49a
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x3b3dd(%rip), %rsi     # 0x67868
movb $0x0, %al
callq 0x16f90
movq $0x0, -0x8(%rbp)
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: alloc_token
static struct token *alloc_token(struct position *pos)
{
	struct token *token = __alloc_token(0);

	token->pos.stream = pos->stream;
	token->pos.line = pos->line;
	token->pos.pos = pos->pos;
	token->pos.whitespace = 1;
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %edi, %edi
callq 0x46980
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
shrq $0x6, %rax
andq $0x3fff, %rax           # imm = 0x3FFF
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq (%rax), %rcx
andq $0x3fff, %rdx           # imm = 0x3FFF
shlq $0x6, %rdx
andq $-0xfffc1, %rcx         # imm = 0xFFF0003F
orq %rdx, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
shrq $0x20, %rax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq (%rax), %rcx
andq $0x7fffffff, %rdx       # imm = 0x7FFFFFFF
shlq $0x20, %rdx
movabsq $-0x7fffffff00000001, %rsi # imm = 0x80000000FFFFFFFF
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
shrq $0x16, %rax
andq $0x3ff, %rax            # imm = 0x3FF
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq (%rax), %rcx
andq $0x3ff, %rdx            # imm = 0x3FF
shlq $0x16, %rdx
movabsq $-0xffc00001, %rsi      # imm = 0xFFFFFFFF003FFFFF
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $-0x200001, %rcx        # imm = 0xFFDFFFFF
orq $0x200000, %rcx         # imm = 0x200000
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: handle_pragma
static int handle_pragma(struct stream *stream, struct token **line, struct token *token)
{
	struct token *next = *line;

	if (match_ident(token->next, &once_ident) && eof_token(token->next->next)) {
		stream->once = 1;
		return 1;
	}
	token->ident = &pragma_ident;
	token->pos.newline = 1;
	token->pos.whitespace = 1;
	token->pos.pos = 1;
	*line = token;
	token->next = next;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x5d692(%rip), %rsi     # 0x8a330
callq 0x305a0
cmpl $0x0, %eax
je 0x2ccd1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0x7fd09(%rip), %rcx     # 0xac9c0
cmpq %rcx, 0x8(%rax)
jne 0x2ccd1
movq -0x10(%rbp), %rax
movl $0x1, 0x34(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x2cd49
movq -0x20(%rbp), %rax
leaq 0x5d6fc(%rip), %rcx     # 0x8a3d8
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
andq $-0x100001, %rcx        # imm = 0xFFEFFFFF
orq $0x100000, %rcx         # imm = 0x100000
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
andq $-0x200001, %rcx        # imm = 0xFFDFFFFF
orq $0x200000, %rcx         # imm = 0x200000
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movabsq $-0xffc00001, %rcx      # imm = 0xFFFFFFFF003FFFFF
andq (%rax), %rcx
orq $0x400000, %rcx         # imm = 0x400000
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
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_add_include
static int handle_add_include(struct stream *stream, struct token **line, struct token *token)
{
	for (;;) {
		token = token->next;
		if (eof_token(token))
			return 1;
		if (token_type(token) != TOKEN_STRING) {
			warning(token->pos, "expected path string");
			return 1;
		}
		add_path_entry(token, token->string->data, &isys_includepath);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
leaq 0x7fbc9(%rip), %rax     # 0xac9c0
cmpq %rax, -0x20(%rbp)
jne 0x2ce06
movl $0x1, -0x4(%rbp)
jmp 0x2ce52
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x10, %eax
je 0x2ce34
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x3ae4a(%rip), %rsi     # 0x67c6e
movb $0x0, %al
callq 0x16d80
movl $0x1, -0x4(%rbp)
jmp 0x2ce52
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x4, %rsi
leaq 0x5c1f5(%rip), %rdx     # 0x89040
callq 0x305e0
jmp 0x2cde4
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: handle_add_isystem
static int handle_add_isystem(struct stream *stream, struct token **line, struct token *token)
{
	for (;;) {
		token = token->next;
		if (eof_token(token))
			return 1;
		if (token_type(token) != TOKEN_STRING) {
			sparse_error(token->pos, "expected path string");
			return 1;
		}
		add_path_entry(token, token->string->data, &sys_includepath);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
leaq 0x7fb39(%rip), %rax     # 0xac9c0
cmpq %rax, -0x20(%rbp)
jne 0x2ce96
movl $0x1, -0x4(%rbp)
jmp 0x2cee2
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x10, %eax
je 0x2cec4
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x3adba(%rip), %rsi     # 0x67c6e
movb $0x0, %al
callq 0x16f90
movl $0x1, -0x4(%rbp)
jmp 0x2cee2
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x4, %rsi
leaq 0x5c15d(%rip), %rdx     # 0x89038
callq 0x305e0
jmp 0x2ce74
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: handle_add_system
static int handle_add_system(struct stream *stream, struct token **line, struct token *token)
{
	for (;;) {
		token = token->next;
		if (eof_token(token))
			return 1;
		if (token_type(token) != TOKEN_STRING) {
			sparse_error(token->pos, "expected path string");
			return 1;
		}
		add_path_entry(token, token->string->data, &dirafter_includepath);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
leaq 0x7faa9(%rip), %rax     # 0xac9c0
cmpq %rax, -0x20(%rbp)
jne 0x2cf26
movl $0x1, -0x4(%rbp)
jmp 0x2cf72
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x10, %eax
je 0x2cf54
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x3ad2a(%rip), %rsi     # 0x67c6e
movb $0x0, %al
callq 0x16f90
movl $0x1, -0x4(%rbp)
jmp 0x2cf72
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x4, %rsi
leaq 0x5c0dd(%rip), %rdx     # 0x89048
callq 0x305e0
jmp 0x2cf04
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: handle_add_dirafter
static int handle_add_dirafter(struct stream *stream, struct token **line, struct token *token)
{
	for (;;) {
		token = token->next;
		if (eof_token(token))
			return 1;
		if (token_type(token) != TOKEN_STRING) {
			sparse_error(token->pos, "expected path string");
			return 1;
		}
		add_dirafter_entry(token, token->string->data);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
leaq 0x7fa19(%rip), %rax     # 0xac9c0
cmpq %rax, -0x20(%rbp)
jne 0x2cfb6
movl $0x1, -0x4(%rbp)
jmp 0x2cffb
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x10, %eax
je 0x2cfe4
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x3ac9a(%rip), %rsi     # 0x67c6e
movb $0x0, %al
callq 0x16f90
movl $0x1, -0x4(%rbp)
jmp 0x2cffb
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x4, %rsi
callq 0x30780
jmp 0x2cf94
movl -0x4(%rbp), %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: handle_ifdef
static int handle_ifdef(struct stream *stream, struct token **line, struct token *token)
{
	struct token *next = token->next;
	int arg;
	if (token_type(next) == TOKEN_IDENT) {
		arg = token_defined(next);
	} else {
		dirty_stream(stream);
		if (!false_nesting)
			sparse_error(token->pos, "expected preprocessor identifier");
		arg = -1;
	}
	return preprocessor_if(stream, token, arg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x2d0be
movq -0x20(%rbp), %rdi
callq 0x30800
movl %eax, -0x24(%rbp)
jmp 0x2d115
jmp 0x2d0c0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x2d0ee
movq -0x8(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x2d0ec
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
jmp 0x2d0ee
jmp 0x2d0f0
cmpl $0x0, 0x6244d(%rip)     # 0x8f544
jne 0x2d10e
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x3ab9a(%rip), %rsi     # 0x67ca1
movb $0x0, %al
callq 0x16f90
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x30880
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: handle_ifndef
static int handle_ifndef(struct stream *stream, struct token **line, struct token *token)
{
	struct token *next = token->next;
	int arg;
	if (token_type(next) == TOKEN_IDENT) {
		if (!stream->dirty && !stream->ifndef) {
			if (!stream->protect) {
				stream->ifndef = token;
				stream->protect = next->ident;
			} else if (stream->protect == next->ident) {
				stream->ifndef = token;
				stream->dirty = 1;
			}
		}
		arg = !token_defined(next);
	} else {
		dirty_stream(stream);
		if (!false_nesting)
			sparse_error(token->pos, "expected preprocessor identifier");
		arg = -1;
	}

	return preprocessor_if(stream, token, arg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x2d1ea
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x2d1cf
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x2d1cf
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x2d1a2
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x2d1cd
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x2d1cb
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x2c(%rax)
jmp 0x2d1cd
jmp 0x2d1cf
movq -0x20(%rbp), %rdi
callq 0x30800
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
jmp 0x2d241
jmp 0x2d1ec
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x2d21a
movq -0x8(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x2d218
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
jmp 0x2d21a
jmp 0x2d21c
cmpl $0x0, 0x62321(%rip)     # 0x8f544
jne 0x2d23a
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x3aa6e(%rip), %rsi     # 0x67ca1
movb $0x0, %al
callq 0x16f90
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x30880
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: handle_else
static int handle_else(struct stream *stream, struct token **line, struct token *token)
{
	struct token *top_if = stream->top_if;
	end_group(stream);

	if (!top_if) {
		nesting_error(stream);
		sparse_error(token->pos, "unmatched #else within stream");
		return 1;
	}

	if (token_type(top_if) == TOKEN_ELSE) {
		nesting_error(stream);
		sparse_error(token->pos, "#else after #else");
	}
	if (false_nesting) {
		if (token_type(top_if) == TOKEN_IF)
			false_nesting = 0;
	} else {
		false_nesting = 1;
	}
	token_type(top_if) = TOKEN_ELSE;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x2d2d0
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x2d2b6
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
jmp 0x2d2ce
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x2d2cc
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
jmp 0x2d2ce
jmp 0x2d2d0
jmp 0x2d2d2
cmpq $0x0, -0x28(%rbp)
jne 0x2d31f
jmp 0x2d2db
movq -0x10(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x3a9b6(%rip), %rsi     # 0x67cc2
movb $0x0, %al
callq 0x16f90
movl $0x1, -0x4(%rbp)
jmp 0x2d3b1
movq -0x28(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x1e, %eax
jne 0x2d369
jmp 0x2d331
movq -0x10(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x3a97e(%rip), %rsi     # 0x67ce0
movb $0x0, %al
callq 0x16f90
cmpl $0x0, 0x621d4(%rip)     # 0x8f544
je 0x2d38e
movq -0x28(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x1c, %eax
jne 0x2d38c
movl $0x0, 0x621b8(%rip)     # 0x8f544
jmp 0x2d398
movl $0x1, 0x621ac(%rip)     # 0x8f544
movq -0x28(%rbp), %rax
movq (%rax), %rcx
andq $-0x40, %rcx
orq $0x1e, %rcx
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: handle_endif
static int handle_endif(struct stream *stream, struct token **line, struct token *token)
{
	struct token *top_if = stream->top_if;
	end_group(stream);
	if (!top_if) {
		nesting_error(stream);
		sparse_error(token->pos, "unmatched #endif in stream");
		return 1;
	}
	if (false_nesting)
		false_nesting--;
	stream->top_if = top_if->next;
	__free_token(top_if);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x2d430
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x2d416
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
jmp 0x2d42e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x2d42c
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
jmp 0x2d42e
jmp 0x2d430
jmp 0x2d432
cmpq $0x0, -0x28(%rbp)
jne 0x2d47c
jmp 0x2d43b
movq -0x10(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x3a886(%rip), %rsi     # 0x67cf2
movb $0x0, %al
callq 0x16f90
movl $0x1, -0x4(%rbp)
jmp 0x2d4b4
cmpl $0x0, 0x620c1(%rip)     # 0x8f544
je 0x2d494
movl 0x620b9(%rip), %eax     # 0x8f544
addl $-0x1, %eax
movl %eax, 0x620b0(%rip)     # 0x8f544
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rdi
callq 0x469b0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: handle_if
static int handle_if(struct stream *stream, struct token **line, struct token *token)
{
	int value = 0;
	if (!false_nesting)
		value = expression_value(&token->next);

	dirty_stream(stream);
	return preprocessor_if(stream, token, value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, 0x62062(%rip)     # 0x8f544
jne 0x2d4f4
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x30920
movl %eax, -0x1c(%rbp)
jmp 0x2d4f6
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x2d524
movq -0x8(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x2d522
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
jmp 0x2d524
jmp 0x2d526
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x30880
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: handle_elif
static int handle_elif(struct stream * stream, struct token **line, struct token *token)
{
	struct token *top_if = stream->top_if;
	end_group(stream);

	if (!top_if) {
		nesting_error(stream);
		sparse_error(token->pos, "unmatched #elif within stream");
		return 1;
	}

	if (token_type(top_if) == TOKEN_ELSE) {
		nesting_error(stream);
		sparse_error(token->pos, "#elif after #else");
		if (!false_nesting)
			false_nesting = 1;
		return 1;
	}

	dirty_stream(stream);
	if (token_type(top_if) != TOKEN_IF)
		return 1;
	if (false_nesting) {
		false_nesting = 0;
		if (!expression_value(&token->next))
			false_nesting = 1;
	} else {
		false_nesting = 1;
		token_type(top_if) = TOKEN_SKIP_GROUPS;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x2d5b0
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x2d596
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
jmp 0x2d5ae
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x2d5ac
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
jmp 0x2d5ae
jmp 0x2d5b0
jmp 0x2d5b2
cmpq $0x0, -0x28(%rbp)
jne 0x2d5ff
jmp 0x2d5bb
movq -0x10(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x3a750(%rip), %rsi     # 0x67d3c
movb $0x0, %al
callq 0x16f90
movl $0x1, -0x4(%rbp)
jmp 0x2d707
movq -0x28(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x1e, %eax
jne 0x2d668
jmp 0x2d611
movq -0x10(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x3a718(%rip), %rsi     # 0x67d5a
movb $0x0, %al
callq 0x16f90
cmpl $0x0, 0x61ef4(%rip)     # 0x8f544
jne 0x2d65c
movl $0x1, 0x61ee8(%rip)     # 0x8f544
movl $0x1, -0x4(%rbp)
jmp 0x2d707
jmp 0x2d66a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x2d698
movq -0x10(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x2d696
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
jmp 0x2d698
jmp 0x2d69a
movq -0x28(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x1c, %eax
je 0x2d6b3
movl $0x1, -0x4(%rbp)
jmp 0x2d707
cmpl $0x0, 0x61e8a(%rip)     # 0x8f544
je 0x2d6e4
movl $0x0, 0x61e7e(%rip)     # 0x8f544
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x30920
cmpl $0x0, %eax
jne 0x2d6e2
movl $0x1, 0x61e62(%rip)     # 0x8f544
jmp 0x2d700
movl $0x1, 0x61e56(%rip)     # 0x8f544
movq -0x28(%rbp), %rax
movq (%rax), %rcx
andq $-0x40, %rcx
orq $0x1d, %rcx
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: expand_date
static void expand_date(struct token *token)
{
	static char buffer[12]; /* __DATE__: 3 + ' ' + 2 + ' ' + 4 + '\0' */

	if (!t)
		time(&t);
	strftime(buffer, 12, "%b %e %Y", localtime(&t));
	replace_with_string(token, buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x6309c(%rip)     # 0x90860
jne 0x2d7d2
leaq 0x63093(%rip), %rdi     # 0x90860
callq 0x111e0
leaq 0x63087(%rip), %rdi     # 0x90860
callq 0x11050
movq %rax, %rcx
leaq 0x63068(%rip), %rdi     # 0x90850
movl $0xc, %esi
leaq 0x3a578(%rip), %rdx     # 0x67d6c
callq 0x11250
movq -0x8(%rbp), %rdi
leaq 0x6304c(%rip), %rsi     # 0x90850
callq 0x30c30
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: expand_time
static void expand_time(struct token *token)
{
	static char buffer[9]; /* __TIME__: 2 + ':' + 2 + ':' + 2 + '\0' */

	if (!t)
		time(&t);
	strftime(buffer, 9, "%T", localtime(&t));
	replace_with_string(token, buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x6303c(%rip)     # 0x90860
jne 0x2d832
leaq 0x63033(%rip), %rdi     # 0x90860
callq 0x111e0
leaq 0x63027(%rip), %rdi     # 0x90860
callq 0x11050
movq %rax, %rcx
leaq 0x63020(%rip), %rdi     # 0x90868
movl $0x9, %esi
leaq 0x3a521(%rip), %rdx     # 0x67d75
callq 0x11250
movq -0x8(%rbp), %rdi
leaq 0x63004(%rip), %rsi     # 0x90868
callq 0x30c30
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/pre-process.c
// Function: expand_has_attribute
static bool expand_has_attribute(struct token *token, struct arg *args)
{
	struct token *arg = args[0].expanded;
	struct symbol *sym;

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

	sym = lookup_symbol(arg->ident, NS_KEYWORD);
	replace_with_bool(token, sym && sym->op && sym->op->attribute);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
je 0x2d917
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x3a46e(%rip), %rsi     # 0x67d78
movb $0x0, %al
callq 0x16f90
movb $0x0, -0x1(%rbp)
jmp 0x2d97a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x3f450
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x29(%rbp)
je 0x2d964
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x40(%rcx)
movb %al, -0x29(%rbp)
je 0x2d964
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x40(%rax)
setne %al
movb %al, -0x29(%rbp)
movq -0x38(%rbp), %rdi
movb -0x29(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x30b80
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
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: expand_has_builtin
static bool expand_has_builtin(struct token *token, struct arg *args)
{
	struct token *arg = args[0].expanded;
	struct symbol *sym;

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

	sym = lookup_symbol(arg->ident, NS_SYMBOL);
	replace_with_bool(token, sym && sym->builtin);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
je 0x2d9d7
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x3a3ae(%rip), %rsi     # 0x67d78
movb $0x0, %al
callq 0x16f90
movb $0x0, -0x1(%rbp)
jmp 0x2da2d
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x10, %esi
callq 0x3f450
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x29(%rbp)
je 0x2da17
movq -0x28(%rbp), %rax
movl 0x54(%rax), %eax
shrl $0x13, %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movq -0x38(%rbp), %rdi
movb -0x29(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x30b80
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
je 0x2da8b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x3a2fa(%rip), %rsi     # 0x67d78
movb $0x0, %al
callq 0x16f90
movb $0x0, -0x1(%rbp)
jmp 0x2dafc
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
leaq 0x5c8aa(%rip), %rax     # 0x8a348
cmpq %rax, -0x28(%rbp)
jne 0x2daaa
movb $0x1, -0x29(%rbp)
jmp 0x2dae7
leaq 0x5c8b7(%rip), %rax     # 0x8a368
cmpq %rax, -0x28(%rbp)
jne 0x2dabd
movb $0x1, -0x29(%rbp)
jmp 0x2dae5
leaq 0x5c8c4(%rip), %rax     # 0x8a388
cmpq %rax, -0x28(%rbp)
jne 0x2dad0
movb $0x1, -0x29(%rbp)
jmp 0x2dae3
leaq 0x5c8d9(%rip), %rax     # 0x8a3b0
cmpq %rax, -0x28(%rbp)
jne 0x2dae1
movb $0x1, -0x29(%rbp)
jmp 0x2dae3
jmp 0x2dae5
jmp 0x2dae7
movq -0x10(%rbp), %rdi
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x30b80
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
je 0x2db5b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x3a22a(%rip), %rsi     # 0x67d78
movb $0x0, %al
callq 0x16f90
movb $0x0, -0x1(%rbp)
jmp 0x2dbda
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
leaq 0x56c6a(%rip), %rax     # 0x847d8
cmpl $0x8, (%rax)
jb 0x2dbc5
leaq 0x5c7ce(%rip), %rax     # 0x8a348
cmpq %rax, -0x28(%rbp)
jne 0x2db86
movb $0x1, -0x29(%rbp)
jmp 0x2dbc3
leaq 0x5c7db(%rip), %rax     # 0x8a368
cmpq %rax, -0x28(%rbp)
jne 0x2db99
movb $0x1, -0x29(%rbp)
jmp 0x2dbc1
leaq 0x5c7e8(%rip), %rax     # 0x8a388
cmpq %rax, -0x28(%rbp)
jne 0x2dbac
movb $0x1, -0x29(%rbp)
jmp 0x2dbbf
leaq 0x5c7fd(%rip), %rax     # 0x8a3b0
cmpq %rax, -0x28(%rbp)
jne 0x2dbbd
movb $0x1, -0x29(%rbp)
jmp 0x2dbbf
jmp 0x2dbc1
jmp 0x2dbc3
jmp 0x2dbc5
movq -0x10(%rbp), %rdi
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x30b80
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
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: create_arglist
static void create_arglist(struct symbol *sym, int count)
{
	struct token *token;
	struct token **next;

	if (!count)
		return;

	token = __alloc_token(0);
	token_type(token) = TOKEN_ARG_COUNT;
	token->count.normal = count;
	sym->arglist = token;
	next = &token->next;

	while (count--) {
		struct token *id, *uses;
		id = __alloc_token(0);
		token_type(id) = TOKEN_IDENT;
		uses = __alloc_token(0);
		token_type(uses) = TOKEN_ARG_COUNT;
		uses->count.normal = 1;

		*next = id;
		id->next = uses;
		next = &uses->next;
	}
	*next = &eof_token_entry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x2dc0a
jmp 0x2dced
xorl %edi, %edi
callq 0x46980
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
andq $-0x40, %rcx
orq $0x1b, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x3ff, %edx            # imm = 0x3FF
andl $0xfffffc00, %ecx       # imm = 0xFFFFFC00
orl %edx, %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x2dcdf
xorl %edi, %edi
callq 0x46980
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
andq $-0x40, %rcx
orq $0x3, %rcx
movq %rcx, (%rax)
xorl %edi, %edi
callq 0x46980
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rcx
andq $-0x40, %rcx
orq $0x1b, %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0xfffffc00, %ecx       # imm = 0xFFFFFC00
orl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x2dc5a
movq -0x20(%rbp), %rax
leaq 0x7ecd6(%rip), %rcx     # 0xac9c0
movq %rcx, (%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: do_handle_define
static int do_handle_define(struct stream *stream, struct token **line, struct token *token, int attr)
{
	struct token *arglist, *expansion;
	struct token *left = token->next;
	struct ident *name;

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

	name = left->ident;

	arglist = NULL;
	expansion = left->next;
	if (!expansion->pos.whitespace) {
		if (match_op(expansion, '(')) {
			arglist = expansion;
			expansion = parse_arguments(expansion);
			if (!expansion)
				return 1;
		} else if (!eof_token(expansion)) {
			warning(expansion->pos,
				"no whitespace before object-like macro body");
		}
	}

	return do_define(left->pos, token, name, arglist, expansion, attr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
je 0x2dd54
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x39c8d(%rip), %rsi     # 0x679ce
movb $0x0, %al
callq 0x16f90
movl $0x1, -0x4(%rbp)
jmp 0x2de0b
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
shrq $0x15, %rax
andq $0x1, %rax
cmpl $0x0, %eax
jne 0x2dde8
movq -0x38(%rbp), %rdi
movl $0x28, %esi
callq 0x2c380
cmpl $0x0, %eax
je 0x2ddc2
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2de20
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2ddc0
movl $0x1, -0x4(%rbp)
jmp 0x2de0b
jmp 0x2dde6
leaq 0x7ebf7(%rip), %rax     # 0xac9c0
cmpq %rax, -0x38(%rbp)
je 0x2dde4
movq -0x38(%rbp), %rax
movq (%rax), %rdi
leaq 0x39c11(%rip), %rsi     # 0x679ee
movb $0x0, %al
callq 0x16d80
jmp 0x2dde6
jmp 0x2dde8
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movl -0x24(%rbp), %r9d
movq (%rax), %rdi
callq 0x2b550
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
je 0x2e294
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x3986c(%rip), %rsi     # 0x67aed
movb $0x0, %al
callq 0x16f90
movl $0x1, -0x4(%rbp)
jmp 0x2e3ab
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x81, %esi
callq 0x3f450
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x2e30c
movl -0x24(%rbp), %eax
movq -0x38(%rbp), %rcx
movl (%rcx), %ecx
shrl $0x12, %ecx
andl $0x3, %ecx
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0x2e2d3
movl $0x1, -0x4(%rbp)
jmp 0x2e3ab
movl -0x24(%rbp), %eax
movq -0x38(%rbp), %rcx
movl (%rcx), %ecx
shrl $0x12, %ecx
andl $0x3, %ecx
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x2e30a
movq -0x38(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0x1ff, %eax            # imm = 0x1FF
cmpl $0x80, %eax
jne 0x2e30a
movl $0x1, -0x4(%rbp)
jmp 0x2e3ab
jmp 0x2e320
cmpl $0x1, -0x24(%rbp)
jg 0x2e31e
movl $0x1, -0x4(%rbp)
jmp 0x2e3ab
jmp 0x2e320
cmpq $0x0, -0x38(%rbp)
je 0x2e33b
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
leaq 0x5ad82(%rip), %rcx     # 0x890b8
cmpq (%rcx), %rax
je 0x2e366
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl $0x3, %esi
callq 0x3f4d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0x1, %edx
callq 0x40a40
movq -0x38(%rbp), %rax
movl (%rax), %ecx
andl $0xfffe00ff, %ecx       # imm = 0xFFFE00FF
orl $0x8000, %ecx           # imm = 0x8000
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x58(%rax)
movl -0x24(%rbp), %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movzbl %cl, %edx
movl (%rax), %ecx
andl $0x3, %edx
shll $0x12, %edx
andl $0xfff3ffff, %ecx       # imm = 0xFFF3FFFF
orl %edx, %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
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: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x5f16a(%rip), %rax     # 0x8d540
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2e3fe
cmpl $0x0, -0x14(%rbp)
jne 0x2e3fe
leaq 0x35172(%rip), %rax     # 0x63567
movq %rax, -0x8(%rbp)
jmp 0x2e4fa
jmp 0x2e400
leaq 0x7e5b9(%rip), %rax     # 0xac9c0
cmpq %rax, -0x10(%rbp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2e419
jmp 0x2e4e8
cmpl $0x0, -0x14(%rbp)
je 0x2e42e
movq -0x10(%rbp), %rdi
callq 0x447b0
movq %rax, -0x40(%rbp)
jmp 0x2e43b
movq -0x10(%rbp), %rdi
callq 0x44420
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x110c0
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
movslq -0x34(%rbp), %rcx
addq %rcx, %rax
leaq 0x5f0d8(%rip), %rcx     # 0x8d540
addq $0x1fff, %rcx           # imm = 0x1FFF
cmpq %rcx, %rax
jb 0x2e48b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3968a(%rip), %rsi     # 0x67b0c
movb $0x0, %al
callq 0x16f90
jmp 0x2e4e8
cmpl $0x0, -0x24(%rbp)
je 0x2e4a3
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x20, (%rax)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq -0x34(%rbp), %rdx
callq 0x111d0
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
shrq $0x15, %rax
andq $0x1, %rax
movl %eax, -0x24(%rbp)
jmp 0x2e400
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
leaq 0x5f04a(%rip), %rax     # 0x8d540
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2eaf0
movq %rax, -0x10(%rbp)
leaq 0x7e2d0(%rip), %rcx     # 0xac9c0
cmpq %rcx, %rax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2e6fe
jmp 0x2e72a
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x2e71c
movq -0x8(%rbp), %rdi
callq 0x2eb70
cmpl $0x0, %eax
je 0x2e728
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x2e6dc
addq $0x10, %rsp
popq %rbp
retq