LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/parse.c
// Function: attribute_mode
static struct token *attribute_mode(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	token = expect(token, '(', "after mode attribute");
	if (token_type(token) == TOKEN_IDENT) {
		struct symbol *mode = lookup_keyword(token->ident, NS_KEYWORD);
		if (mode && mode->op->type & KW_MODE)
			ctx->mode = mode->op;
		else
			sparse_error(token->pos, "unknown mode attribute %s", show_ident(token->ident));
		token = token->next;
	} else
		sparse_error(token->pos, "expect attribute mode symbol\n");
	token = expect(token, ')', "after mode attribute");
	return token;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
leaq 0x2701d(%rip), %rdx     # 0x44d4a
movl $0x28, %esi
callq 0x195d7
movq %rax, %rbx
movq (%rax), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1dd55
movq 0x10(%rbx), %rdi
testb $0x4, 0x11(%rdi)
jne 0x1dd65
xorl %eax, %eax
jmp 0x1dd6f
leaq 0x2701d(%rip), %rsi     # 0x44d79
xorl %eax, %eax
callq 0x11a38
jmp 0x1dda4
movl $0x100, %esi            # imm = 0x100
callq 0x2b511
testq %rax, %rax
je 0x1dd7d
movq 0x40(%rax), %rax
testb $0x40, (%rax)
jne 0x1dd9c
movq 0x10(%rbx), %rdi
callq 0x2e465
movq (%rbx), %rdi
leaq 0x26fcf(%rip), %rsi     # 0x44d5f
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a38
jmp 0x1dda0
movq %rax, 0x30(%r14)
movq 0x8(%rbx), %rbx
leaq 0x26f9f(%rip), %rdx     # 0x44d4a
movq %rbx, %rdi
movl $0x29, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x195d7
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/parse.c
// Function: to_QI_mode
static struct symbol *to_QI_mode(struct symbol *ctype)
{
	if (ctype->ctype.base_type != &int_type)
		return NULL;
	if (ctype == &char_ctype)
		return ctype;
	return ctype->ctype.modifiers & MOD_UNSIGNED ? &uchar_ctype
						     : &schar_ctype;
}

// Assembly:
movq 0x60(%rdi), %rax
cmpq 0x431b6(%rip), %rax     # 0x60f80
je 0x1ddcf
xorl %eax, %eax
retq
leaq 0x4dc42(%rip), %rax     # 0x6ba18
cmpq %rax, %rdi
je 0x1dde8
testb $0x40, 0x69(%rdi)
jne 0x1dde9
leaq 0x4e4f0(%rip), %rax     # 0x6c2d8
retq
leaq 0x4e5c8(%rip), %rax     # 0x6c3b8
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/parse.c
// Function: ignore_attribute
static struct token *ignore_attribute(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	struct expression *expr = NULL;
	if (match_op(token, '('))
		token = parens_expression(token, &expr, "in attribute");
	return token;
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq $0x0, (%rsp)
movl (%rdi), %ecx
andl $0x3f, %ecx
cmpl $0x12, %ecx
jne 0x1df07
cmpl $0x28, 0x10(%rax)
jne 0x1df07
leaq 0x2650d(%rip), %rdx     # 0x44409
movq %rsp, %rsi
movq %rax, %rdi
callq 0x39869
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/parse.c
// Function: specifier_conflict
static void specifier_conflict(struct position pos, int what, struct ident *new)
{
	const char *old;
	if (what & (Set_S | Set_T))
		goto Catch_all;
	if (what & Set_Char)
		old = "char";
	else if (what & Set_Double)
		old = "double";
	else if (what & Set_Float)
		old = "float";
	else if (what & Set_Signed)
		old = "signed";
	else if (what & Set_Unsigned)
		old = "unsigned";
	else if (what & Set_Short)
		old = "short";
	else if (what & Set_Long)
		old = "long";
	else
		old = "long long";
	sparse_error(pos, "impossible combination of type specifiers: %s %s",
			old, show_ident(new));
	return;

Catch_all:
	sparse_error(pos, "two or more data types in declaration specifiers");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x3, %sil
je 0x1df2e
leaq 0x283bb(%rip), %rsi     # 0x462d8
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11a38
testb $0x4, %sil
jne 0x1df69
testb $0x10, %sil
jne 0x1df72
testb $0x20, %sil
jne 0x1df7b
testb $0x40, %sil
jne 0x1df84
testb %sil, %sil
js 0x1df8d
btl $0x8, %esi
jb 0x1df96
btl $0x9, %esi
leaq 0x2de59(%rip), %rax     # 0x4bdb5
leaq 0x29a81(%rip), %r14     # 0x479e4
cmovaeq %rax, %r14
jmp 0x1df9d
leaq 0x29a48(%rip), %r14     # 0x479b8
jmp 0x1df9d
leaq 0x29a8e(%rip), %r14     # 0x47a07
jmp 0x1df9d
leaq 0x253ec(%rip), %r14     # 0x4336e
jmp 0x1df9d
leaq 0x262d6(%rip), %r14     # 0x44261
jmp 0x1df9d
leaq 0x2dd4e(%rip), %r14     # 0x4bce2
jmp 0x1df9d
leaq 0x29a29(%rip), %r14     # 0x479c6
movq %rdx, %rdi
callq 0x2e465
leaq 0x282fb(%rip), %rsi     # 0x462a7
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11a38
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/parse.c
// Function: match_attribute
static bool match_attribute(struct token *token)
{
	struct symbol *sym;

	if (token_type(token) != TOKEN_IDENT)
		return false;
	sym = lookup_keyword(token->ident, NS_TYPEDEF);
	if (!sym || !sym->op)
		return false;
	return sym->op->type & KW_ATTRIBUTE;
}

// Assembly:
movl (%rdi), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1dfdc
pushq %rax
movq 0x10(%rdi), %rdi
testb $0x4, 0x11(%rdi)
jne 0x1dfdf
xorl %eax, %eax
jmp 0x1dfe9
xorl %eax, %eax
retq
movl $0x2, %esi
callq 0x2b511
testq %rax, %rax
je 0x1e000
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x1e000
movb (%rax), %al
andb $0x8, %al
shrb $0x3, %al
jmp 0x1e002
xorl %eax, %eax
addq $0x8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/predefine.c
// Function: predefined_ctype
static void predefined_ctype(const char *name, struct symbol *type, int flags)
{
	unsigned bits = type->bit_size;

	if (flags & PTYPE_SIZEOF) {
		const char *suffix = (flags & PTYPE_T) ? "_T" : "";
		predefined_sizeof(name, suffix, bits);
	}
	if (flags & PTYPE_MAX)
		predefined_max(name, type);
	if (flags & PTYPE_MIN)
		predefined_min(name, type);
	if (flags & PTYPE_TYPE)
		predefined_type(name, type);
	if (flags & PTYPE_WIDTH)
		predefined_width(name, type);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testb $0x1, %bpl
je 0x1ec60
movl 0x50(%rbx), %r15d
testb $0x2, %bpl
leaq 0x22cb1(%rip), %rax     # 0x418cd
leaq 0x280a3(%rip), %r8      # 0x46cc6
cmoveq %rax, %r8
leaq 0x2810a(%rip), %rdx     # 0x46d38
movq %rsp, %r12
movl $0x20, %esi
movq %r12, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0xe100
shrl $0x3, %r15d
leaq 0x23ad3(%rip), %rdx     # 0x42721
movq %r12, %rdi
movl $0x1, %esi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x1edb4
testb $0x4, %bpl
je 0x1ecd7
movq %rbx, %rdi
callq 0x2334a
movq %rax, %r15
cmpb $0x3, (%rbx)
movq %rbx, %rax
jne 0x1ec7d
movq 0x60(%rbx), %rax
movl 0x50(%rbx), %ecx
xorl %edx, %edx
cmpb $0x4, (%rax)
je 0x1ec91
xorl %edx, %edx
btl $0xe, 0x68(%rax)
adcl $-0x1, %edx
addl %edx, %ecx
negb %cl
movq $-0x1, %r12
shrq %cl, %r12
leaq 0x28023(%rip), %rdx     # 0x46cc9
movq %rsp, %r13
movl $0x20, %esi
movq %r13, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0xe100
leaq 0x28012(%rip), %rdx     # 0x46cd4
movq %r13, %rdi
movl $0x1, %esi
movq %r12, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x1edb4
testb $0x8, %bpl
je 0x1ed47
movq %rbx, %rdi
callq 0x2334a
movq %rax, %r15
leaq 0x27fed(%rip), %rdx     # 0x46cdc
movq %rsp, %rdi
movl $0x20, %esi
movq %r14, %rcx
xorl %eax, %eax
callq 0xe100
cmpb $0x3, (%rbx)
movq %rbx, %rax
jne 0x1ed0d
movq 0x60(%rbx), %rax
cmpb $0x4, (%rax)
je 0x1ed2e
testb $0x40, 0x69(%rax)
jne 0x1ed2e
leaq 0x27fc8(%rip), %rdi     # 0x46ce7
movq %rsp, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x11caf
jmp 0x1ed47
leaq 0x27fd5(%rip), %rdx     # 0x46d0a
movq %rsp, %rdi
movl $0x1, %esi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1edb4
testb $0x20, %bpl
je 0x1ed69
movq %rbx, %rdi
callq 0x23322
leaq 0x27fb2(%rip), %rdi     # 0x46d0e
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x11caf
testb $0x10, %bpl
je 0x1eda4
leaq 0x27fb5(%rip), %rdx     # 0x46d2b
movq %rsp, %r15
movl $0x20, %esi
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0xe100
movl 0x50(%rbx), %ecx
leaq 0x2398c(%rip), %rdx     # 0x42721
movq %r15, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x1edb4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x1ee10
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
callq 0x2edd4
movq %rax, %rbx
leaq 0x687c1(%rip), %r14     # 0x875e0
testq %r15, %r15
je 0x1eece
cmpb $0x0, (%r15)
je 0x1eece
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rcx)
leaq 0x490e2(%rip), %rdi     # 0x67f40
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdx
callq 0xe0b0
xorl %edi, %edi
callq 0x2fe9a
movq %rax, %r14
callq 0xe300
movq (%rax), %rcx
movzbl 0x490bc(%rip), %edx     # 0x67f40
movq (%r14), %rax
andq $-0x40, %rax
testb $0x8, 0x1(%rcx,%rdx,2)
jne 0x1eea7
orq $0x3, %rax
movq %rax, (%r14)
leaq 0x490a0(%rip), %rdi     # 0x67f40
callq 0x2edd4
jmp 0x1eeba
orq $0x5, %rax
movq %rax, (%r14)
leaq 0x4908b(%rip), %rdi     # 0x67f40
callq 0x2fbd4
movq %rax, 0x10(%r14)
orb $0x20, 0x2(%r14)
leaq 0x68716(%rip), %rax     # 0x875e0
movq %rax, 0x8(%r14)
xorl %r9d, %r9d
testl %ebp, %ebp
sete %r9b
movq (%r14), %rdi
xorl %esi, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
movq %r14, %r8
callq 0x1eef7
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x48842(%rip), %rbx     # 0x68040
testq %rbx, %rbx
je 0x1f86c
movl $0x1ff00, %ebp          # imm = 0x1FF00
movq %rbx, %r14
movzwl (%r14), %eax
testb %al, %al
jle 0x1f863
xorl %r15d, %r15d
movq 0x18(%r14,%r15,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x1f82a
testq %rdi, %rdi
je 0x1f854
movl $0x81, %esi
callq 0x2b511
testq %rax, %rax
je 0x1f845
movl (%rax), %ecx
andl %ebp, %ecx
cmpl $0x100, %ecx            # imm = 0x100
je 0x1f847
xorl %eax, %eax
testq %rax, %rax
je 0x1f854
movq %rax, %rdi
callq 0x1f877
incq %r15
movl (%r14), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jl 0x1f816
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0x1f80b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq %rsi, %rdi
je 0x1fb11
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x27316(%rip), %r15     # 0x46d58
movl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
movl $0x1, %ebp
testq %r14, %r14
je 0x1fb13
testq %rbx, %rbx
je 0x1fb13
movl (%r14), %ecx
andl $0x3f, %ecx
movl (%rbx), %edx
andl $0x3f, %edx
movl $0x1, %eax
cmpl %edx, %ecx
jne 0x1fad8
addl $-0x3, %ecx
cmpl $0x18, %ecx
ja 0x1faef
movslq (%r15,%rcx,4), %rax
addq %r15, %rax
jmpq *%rax
movl 0x10(%r14), %ecx
movl 0x10(%rbx), %edx
bswapl %ecx
bswapl %edx
xorl %eax, %eax
cmpl %edx, %ecx
seta %al
sbbl $0x0, %eax
jmp 0x1fad8
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
movl (%rdi), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movl (%rsi), %ecx
andl %r12d, %ecx
movl $0x1, %eax
cmpl %ecx, %edx
jne 0x1fad8
addq $0x4, %rdi
addq $0x4, %rsi
callq 0xe190
jmp 0x1fad8
xorl %eax, %eax
jmp 0x1fad8
movl 0x10(%r14), %ecx
xorl %eax, %eax
cmpl 0x10(%rbx), %ecx
setne %al
testl %eax, %eax
jne 0x1fb13
movq 0x8(%r14), %r14
movq 0x8(%rbx), %rbx
cmpq %rbx, %r14
jne 0x1fa48
jmp 0x1fb11
movl $0x1, %eax
jmp 0x1fad8
movq 0x10(%r14), %rcx
xorl %eax, %eax
cmpq 0x10(%rbx), %rcx
jmp 0x1fad5
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0xe1c0
jmp 0x1fad8
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rsi, %rsi
je 0x1fb6f
movq %rsi, %rdx
movq %rdi, %r15
movq 0x8(%rbx), %r14
movq %r14, %rdi
movl $0x16, %esi
callq 0x1fba2
movl %eax, %ebp
testl %eax, %eax
je 0x1fb75
movq (%rbx), %rax
andl $0x200000, %eax         # imm = 0x200000
movq $-0x200001, %rcx        # imm = 0xFFDFFFFF
andq (%r14), %rcx
orq %rax, %rcx
movq %rcx, (%r14)
movq %rbx, %rdi
callq 0x2fea9
movq %r14, (%r15)
jmp 0x1fb78
orb $-0x80, 0x7(%rbx)
jmp 0x1fb94
movq %rbx, %r14
testl %ebp, %ebp
je 0x1fb81
movq %r14, %rbx
jmp 0x1fb94
movq (%r14), %rdi
leaq 0x27351(%rip), %rsi     # 0x46edc
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x11a38
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/pre-process.c
// Function: try_arg
static int try_arg(struct token *token, enum token_type type, struct token *arglist)
{
	struct ident *ident = token->ident;
	int nr;

	if (!arglist || token_type(token) != TOKEN_IDENT)
		return 0;

	arglist = arglist->next;

	for (nr = 0; !eof_token(arglist); nr++, arglist = arglist->next->next) {
		if (arglist->ident == ident) {
			struct argcount *count = &arglist->next->count;
			int n;

			token->argnum = nr;
			token_type(token) = type;
			switch (type) {
			case TOKEN_MACRO_ARGUMENT:
				n = ++count->normal;
				break;
			case TOKEN_QUOTED_ARGUMENT:
				n = ++count->quoted;
				break;
			default:
				n = ++count->str;
			}
			if (n)
				return count->vararg ? 2 : 1;
			/*
			 * XXX - need saner handling of that
			 * (>= 1024 instances of argument)
			 */
			token_type(token) = TOKEN_ERROR;
			return -1;
		}
	}
	return 0;
}

// Assembly:
xorl %eax, %eax
testq %rdx, %rdx
je 0x1fc91
movq (%rdi), %rcx
movl %ecx, %r8d
andl $0x3f, %r8d
cmpl $0x3, %r8d
jne 0x1fc91
movq 0x8(%rdx), %rdx
cmpq 0x4130c(%rip), %rdx     # 0x60ed8
je 0x1fc91
movq 0x10(%rdi), %rax
xorl %r8d, %r8d
leaq 0x67a00(%rip), %r9      # 0x875e0
cmpq %rax, 0x10(%rdx)
je 0x1fbf9
incl %r8d
movq 0x8(%rdx), %rdx
movq 0x8(%rdx), %rdx
cmpq %r9, %rdx
jne 0x1fbe0
xorl %eax, %eax
retq
movq 0x8(%rdx), %rax
movl %r8d, 0x10(%rdi)
movl %esi, %edx
andl $0x3f, %edx
andq $-0x40, %rcx
orq %rdx, %rcx
movq %rcx, (%rdi)
movl 0x10(%rax), %ecx
cmpl $0x17, %esi
je 0x1fc30
cmpl $0x15, %esi
jne 0x1fc4a
leal 0x1(%rcx), %esi
andl $0x3ff, %esi            # imm = 0x3FF
movl $0xfffffc00, %r8d       # imm = 0xFFFFFC00
movl %esi, %edx
jmp 0x1fc62
movl %ecx, %edx
shrl $0xa, %edx
incl %edx
andl $0x3ff, %edx            # imm = 0x3FF
movl %edx, %esi
shll $0xa, %esi
movl $0xfff003ff, %r8d       # imm = 0xFFF003FF
jmp 0x1fc62
movl %ecx, %edx
shrl $0x14, %edx
incl %edx
andl $0x3ff, %edx            # imm = 0x3FF
movl %edx, %esi
shll $0x14, %esi
movl $0xc00fffff, %r8d       # imm = 0xC00FFFFF
andl %r8d, %ecx
orl %esi, %ecx
movl %ecx, 0x10(%rax)
testl %edx, %edx
je 0x1fc7e
movb 0x13(%rax), %al
andb $0x40, %al
cmpb $0x1, %al
movl $0x2, %eax
sbbl $0x0, %eax
retq
movq (%rdi), %rax
andq $-0x40, %rax
orq $0x2, %rax
movq %rax, (%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0x2fe9a
movq (%rbx), %rcx
andl $0xfffc0, %ecx          # imm = 0xFFFC0
movq $-0xfffc1, %rdx         # imm = 0xFFF0003F
andq (%rax), %rdx
orq %rcx, %rdx
movq %rdx, (%rax)
movabsq $0x7fffffff00000000, %rcx # imm = 0x7FFFFFFF00000000
andq (%rbx), %rcx
movabsq $-0x7fffffff00000001, %rsi # imm = 0x80000000FFFFFFFF
andq %rdx, %rsi
orq %rcx, %rsi
movq %rsi, (%rax)
movq (%rbx), %rcx
andl $0xffc00000, %ecx       # imm = 0xFFC00000
movabsq $-0xffe00001, %rdx      # imm = 0xFFFFFFFF001FFFFF
andq %rsi, %rdx
addq %rdx, %rcx
addq $0x200000, %rcx         # imm = 0x200000
movq %rcx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq (%rsi), %rax
movq 0x8(%rdx), %rcx
movl (%rcx), %r8d
andl $0x3f, %r8d
cmpl $0x3, %r8d
jne 0x1fde6
movq 0x10(%rcx), %r8
cmpq 0x41189(%rip), %r8      # 0x60f60
jne 0x1fde6
movq 0x8(%rcx), %rcx
cmpq 0x410f4(%rip), %rcx     # 0x60ed8
je 0x1fe12
leaq 0x4561b(%rip), %rcx     # 0x65408
movq %rcx, 0x10(%rdx)
movabsq $-0xfff00001, %rcx      # imm = 0xFFFFFFFF000FFFFF
andq (%rdx), %rcx
orq $0x700000, %rcx         # imm = 0x700000
movq %rcx, (%rdx)
movq %rdx, (%rsi)
movq %rax, 0x8(%rdx)
xorl %eax, %eax
retq
movl $0x1, 0x34(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq 0x8(%rdx), %rbx
cmpq 0x41089(%rip), %rbx     # 0x60ed8
je 0x1fe98
leaq 0x44ed8(%rip), %r14     # 0x64d30
leaq 0x67781(%rip), %r15     # 0x875e0
movq (%rbx), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x10, %eax
jne 0x1fe8a
movq 0x10(%rbx), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2213f
movq 0x8(%rbx), %rbx
cmpq %r15, %rbx
jne 0x1fe5f
jmp 0x1fe98
leaq 0x27451(%rip), %rsi     # 0x472e2
xorl %eax, %eax
callq 0x118b4
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq 0x8(%rdx), %rbx
cmpq 0x41025(%rip), %rbx     # 0x60ed8
je 0x1fefc
leaq 0x44e6c(%rip), %r14     # 0x64d28
leaq 0x6771d(%rip), %r15     # 0x875e0
movq (%rbx), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x10, %eax
jne 0x1feee
movq 0x10(%rbx), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2213f
movq 0x8(%rbx), %rbx
cmpq %r15, %rbx
jne 0x1fec3
jmp 0x1fefc
leaq 0x273ed(%rip), %rsi     # 0x472e2
xorl %eax, %eax
callq 0x11a38
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq 0x8(%rdx), %rbx
cmpq 0x40fc1(%rip), %rbx     # 0x60ed8
je 0x1ff60
leaq 0x44e18(%rip), %r14     # 0x64d38
leaq 0x676b9(%rip), %r15     # 0x875e0
movq (%rbx), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x10, %eax
jne 0x1ff52
movq 0x10(%rbx), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2213f
movq 0x8(%rbx), %rbx
cmpq %r15, %rbx
jne 0x1ff27
jmp 0x1ff60
leaq 0x27389(%rip), %rsi     # 0x472e2
xorl %eax, %eax
callq 0x11a38
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movq 0x8(%rdx), %rax
cmpq 0x40f61(%rip), %rax     # 0x60ed8
je 0x1ffd7
leaq 0x44430(%rip), %rcx     # 0x643b0
leaq 0x67659(%rip), %rdx     # 0x875e0
movq (%rax), %rdi
movl %edi, %esi
andl $0x3f, %esi
cmpl $0x10, %esi
jne 0x1ffc9
cmpq $0x0, 0x44d64(%rip)     # 0x64d00
jne 0x1ffde
movq 0x10(%rax), %rsi
addq $0x4, %rsi
movq %rcx, %rdi
cmpq $0x0, (%rdi)
leaq 0x8(%rdi), %rdi
jne 0x1ffa9
movq %rsi, -0x8(%rdi)
movq $0x0, (%rdi)
movq 0x8(%rax), %rax
cmpq %rdx, %rax
jne 0x1ff87
jmp 0x1ffd7
leaq 0x27312(%rip), %rsi     # 0x472e2
xorl %eax, %eax
callq 0x11a38
movl $0x1, %eax
popq %rcx
retq
leaq 0x27312(%rip), %rsi     # 0x472f7
xorl %eax, %eax
callq 0x11b54
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdx), %rdi
movl (%rdi), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x2003e
callq 0x22233
movl %eax, %ebp
jmp 0x2007b
cmpl $0x0, 0x2c(%r14)
jne 0x2005c
movl $0x1, 0x2c(%r14)
cmpq $0x0, 0x40(%r14)
jne 0x2005c
movq $0x0, 0x38(%r14)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $0x0, 0x4a0fc(%rip)     # 0x6a164
jne 0x2007b
movq (%rbx), %rdi
leaq 0x272a1(%rip), %rsi     # 0x47315
xorl %eax, %eax
callq 0x11a38
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2229e
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdx), %rdi
movl (%rdi), %ecx
andl $0x3f, %ecx
movl 0x2c(%r14), %eax
cmpl $0x3, %ecx
jne 0x200c2
testl %eax, %eax
jne 0x200b6
cmpq $0x0, 0x40(%r14)
je 0x20110
callq 0x22233
movl %eax, %ebp
xorl $0x1, %ebp
jmp 0x200fc
testl %eax, %eax
jne 0x200dd
movl $0x1, 0x2c(%r14)
cmpq $0x0, 0x40(%r14)
jne 0x200dd
movq $0x0, 0x38(%r14)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $0x0, 0x4a07b(%rip)     # 0x6a164
jne 0x200fc
movq (%rbx), %rdi
leaq 0x27220(%rip), %rsi     # 0x47315
xorl %eax, %eax
callq 0x11a38
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2229e
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x2012d
cmpq 0x10(%rdi), %rax
jne 0x200b6
movq %rbx, 0x40(%r14)
movl $0x1, 0x2c(%r14)
jmp 0x200b6
movq %rbx, 0x40(%r14)
movq 0x10(%rdi), %rax
movq %rax, 0x38(%r14)
jmp 0x200b6
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq 0x48(%rdi), %rbx
cmpq %rbx, 0x40(%rdi)
je 0x2018e
testq %rbx, %rbx
je 0x201ac
movl (%rbx), %eax
andl $0x3f, %eax
cmpl $0x1e, %eax
jne 0x20177
movl $0x1, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq (%rdx), %rdi
leaq 0x271e4(%rip), %rsi     # 0x47354
xorl %eax, %eax
callq 0x11a38
cmpl $0x0, 0x49fe6(%rip)     # 0x6a164
je 0x201cd
movl (%rbx), %ecx
andl $0x3f, %ecx
xorl %eax, %eax
cmpl $0x1c, %ecx
je 0x201d2
jmp 0x201d8
movq $0x0, 0x40(%rdi)
cmpl $0x0, 0x2c(%rdi)
je 0x201ed
cmpq $0x0, 0x38(%rdi)
je 0x20149
movl $0x0, 0x2c(%rdi)
jmp 0x20149
movl $0x1, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq (%rdx), %rdi
leaq 0x27172(%rip), %rsi     # 0x47336
xorl %eax, %eax
callq 0x11a38
jmp 0x201e6
movl $0x1, %eax
movl %eax, 0x49f8c(%rip)     # 0x6a164
movq (%rbx), %rax
andq $-0x40, %rax
orq $0x1e, %rax
movq %rax, (%rbx)
movl $0x1, %eax
popq %rbx
retq
movq $0x0, 0x38(%rdi)
jmp 0x20149
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x48(%rdi), %rax
cmpq %rax, 0x40(%rdi)
je 0x2022e
pushq %rax
testq %rax, %rax
je 0x2024c
movl 0x49f54(%rip), %ecx     # 0x6a164
testl %ecx, %ecx
je 0x2021c
decl %ecx
movl %ecx, 0x49f48(%rip)     # 0x6a164
movq 0x8(%rax), %rcx
movq %rcx, 0x48(%rdi)
movq %rax, %rdi
callq 0x2fea9
jmp 0x2026b
movq $0x0, 0x40(%rdi)
cmpl $0x0, 0x2c(%rdi)
je 0x20272
cmpq $0x0, 0x38(%rdi)
je 0x20204
movl $0x0, 0x2c(%rdi)
jmp 0x20204
movl $0x1, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq (%rdx), %rdi
leaq 0x27102(%rip), %rsi     # 0x47366
xorl %eax, %eax
callq 0x11a38
movl $0x1, %eax
popq %rcx
retq
movq $0x0, 0x38(%rdi)
jmp 0x20204
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
xorl %edx, %edx
cmpl $0x0, 0x49ed5(%rip)     # 0x6a164
jne 0x2029c
leaq 0x8(%rbx), %rdi
callq 0x22314
movl %eax, %edx
cmpl $0x0, 0x2c(%r14)
jne 0x202ba
movl $0x1, 0x2c(%r14)
cmpq $0x0, 0x40(%r14)
jne 0x202ba
movq $0x0, 0x38(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2229e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x48(%rdi), %rax
cmpq %rax, 0x40(%rdi)
je 0x2031a
pushq %rax
testq %rax, %rax
je 0x2033c
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x1e, %ecx
jne 0x2035d
movl $0x1, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq (%rdx), %rdi
leaq 0x270cd(%rip), %rsi     # 0x473ce
xorl %eax, %eax
callq 0x11a38
cmpl $0x0, 0x49e55(%rip)     # 0x6a164
jne 0x203d3
jmp 0x203a9
movq $0x0, 0x40(%rdi)
cmpl $0x0, 0x2c(%rdi)
je 0x203b5
cmpq $0x0, 0x38(%rdi)
je 0x202d9
movl $0x0, 0x2c(%rdi)
jmp 0x202d9
movl $0x1, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq (%rdx), %rdi
leaq 0x2705c(%rip), %rsi     # 0x473b0
xorl %eax, %eax
callq 0x11a38
jmp 0x203d3
cmpl $0x0, 0x2c(%rdi)
jne 0x20379
movl $0x1, 0x2c(%rdi)
cmpq $0x0, 0x40(%rdi)
jne 0x20379
movq $0x0, 0x38(%rdi)
movq (%rax), %rcx
movl %ecx, %esi
andl $0x3f, %esi
cmpl $0x1c, %esi
jne 0x203d3
cmpl $0x0, 0x49dd7(%rip)     # 0x6a164
je 0x203c2
movl $0x0, 0x49dcb(%rip)     # 0x6a164
addq $0x8, %rdx
movq %rdx, %rdi
callq 0x22314
testl %eax, %eax
jne 0x203d3
movl $0x1, 0x49db1(%rip)     # 0x6a164
jmp 0x203d3
movq $0x0, 0x38(%rdi)
jmp 0x202d9
movl $0x1, 0x49d98(%rip)     # 0x6a164
orq $0x1d, %rcx
movq %rcx, (%rax)
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x4b022(%rip)     # 0x6b480
jne 0x2046c
leaq 0x4b019(%rip), %rdi     # 0x6b480
callq 0xe1f0
leaq 0x4b00d(%rip), %rdi     # 0x6b480
callq 0xe050
leaq 0x4aff1(%rip), %r14     # 0x6b470
leaq 0x26f5a(%rip), %rdx     # 0x473e0
movl $0xc, %esi
movq %r14, %rdi
movq %rax, %rcx
callq 0xe250
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x224f1
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x4afc9(%rip)     # 0x6b480
jne 0x204c5
leaq 0x4afc0(%rip), %rdi     # 0x6b480
callq 0xe1f0
leaq 0x4afb4(%rip), %rdi     # 0x6b480
callq 0xe050
leaq 0x4afb0(%rip), %r14     # 0x6b488
leaq 0x26f0a(%rip), %rdx     # 0x473e9
movl $0x9, %esi
movq %r14, %rdi
movq %rax, %rcx
callq 0xe250
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x224f1
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq (%rax), %rdi
movl %edi, %r14d
andl $0x3f, %r14d
cmpq $0x3, %r14
jne 0x205dc
movq 0x10(%rax), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x2b511
testq %rax, %rax
je 0x205ec
movq 0x40(%rax), %rcx
testq %rcx, %rcx
je 0x205ec
xorl %eax, %eax
cmpq $0x0, 0x40(%rcx)
setne %al
jmp 0x205ee
leaq 0x26e09(%rip), %rsi     # 0x473ec
xorl %eax, %eax
callq 0x11a38
jmp 0x2060b
xorl %eax, %eax
movq (%rbx), %rcx
andq $-0x40, %rcx
orq $0x5, %rcx
movq %rcx, (%rbx)
leaq 0x3954d(%rip), %rcx     # 0x59b50
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
cmpl $0x3, %r14d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq (%rax), %rdi
movl %edi, %r14d
andl $0x3f, %r14d
cmpq $0x3, %r14
jne 0x20653
movq 0x10(%rax), %rdi
movl $0x10, %esi
callq 0x2b511
testq %rax, %rax
je 0x20663
movl 0x54(%rax), %eax
shrl $0x13, %eax
andl $0x1, %eax
jmp 0x20665
leaq 0x26d92(%rip), %rsi     # 0x473ec
xorl %eax, %eax
callq 0x11a38
jmp 0x20682
xorl %eax, %eax
movq (%rbx), %rcx
andq $-0x40, %rcx
orq $0x5, %rcx
movq %rcx, (%rbx)
leaq 0x394d6(%rip), %rcx     # 0x59b50
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
cmpl $0x3, %r14d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x206f8
movq 0x10(%rcx), %rax
cmpq 0x40869(%rip), %rax     # 0x60f18
sete %cl
cmpq 0x4084f(%rip), %rax     # 0x60f08
sete %dl
orb %cl, %dl
cmpq 0x408db(%rip), %rax     # 0x60fa0
sete %cl
cmpq 0x407f9(%rip), %rax     # 0x60ec8
sete %al
orb %cl, %al
orb %dl, %al
movq (%rdi), %rcx
andq $-0x40, %rcx
orq $0x5, %rcx
movq %rcx, (%rdi)
movzbl %al, %eax
leaq 0x39462(%rip), %rcx     # 0x59b50
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rdi)
jmp 0x20709
leaq 0x26ced(%rip), %rsi     # 0x473ec
movq %rax, %rdi
xorl %eax, %eax
callq 0x11a38
cmpl $0x3, %ebx
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x20767
leaq 0x40e2d(%rip), %rax     # 0x61558
cmpl $0x8, (%rax)
jb 0x2077a
movq 0x10(%rcx), %rax
cmpq 0x407dd(%rip), %rax     # 0x60f18
sete %cl
cmpq 0x407c3(%rip), %rax     # 0x60f08
sete %dl
orb %cl, %dl
cmpq 0x4084f(%rip), %rax     # 0x60fa0
sete %cl
cmpq 0x4076d(%rip), %rax     # 0x60ec8
sete %al
orb %cl, %al
orb %dl, %al
movzbl %al, %eax
jmp 0x2077c
leaq 0x26c7e(%rip), %rsi     # 0x473ec
movq %rax, %rdi
xorl %eax, %eax
callq 0x11a38
jmp 0x20799
xorl %eax, %eax
movq (%rdi), %rcx
andq $-0x40, %rcx
orq $0x5, %rcx
movq %rcx, (%rdi)
leaq 0x393bf(%rip), %rcx     # 0x59b50
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rdi)
cmpl $0x3, %ebx
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x20b55
movl %esi, %ebx
movq 0x10(%r15), %rdi
movl $0x81, %esi
callq 0x2b511
movq %rax, %r14
testq %rax, %rax
je 0x20b6b
movl (%r14), %eax
movl %eax, %ecx
shrl $0x12, %ecx
andl $0x3, %ecx
cmpl %ebx, %ecx
jg 0x20bc6
xorl %ebx, %ecx
andl $0x1ff00, %eax          # imm = 0x1FF00
xorl $0x8000, %eax           # imm = 0x8000
orl %ecx, %eax
jne 0x20b70
jmp 0x20bc6
movq (%rdi), %rdi
leaq 0x26602(%rip), %rsi     # 0x47161
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x11a38
cmpl $0x2, %ebx
jl 0x20bc6
testq %r14, %r14
je 0x20b85
movq 0x30(%r14), %rax
leaq 0x44218(%rip), %rcx     # 0x64d98
cmpq (%rcx), %rax
je 0x20ba6
movq (%r15), %rdi
movl $0x3, %esi
callq 0x2b547
movq %rax, %r14
movq 0x10(%r15), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0x2c3dd
movl $0x8000, %eax           # imm = 0x8000
orl (%r14), %eax
movq $0x0, 0x58(%r14)
andl $0x3, %ebx
shll $0x12, %ebx
andl $0xfff280ff, %eax       # imm = 0xFFF280FF
orl %ebx, %eax
movl %eax, (%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x20c9d
movq %rdi, %r14
xorl %r15d, %r15d
xorl %ebx, %ebx
cmpq 0x402db(%rip), %r14     # 0x60ed8
je 0x20c8d
cmpl $0x0, 0x4(%rsp)
je 0x20c14
movq %r14, %rdi
callq 0x2e8d1
jmp 0x20c1c
movq %r14, %rdi
callq 0x2e5c0
movq %rax, %r12
movq %rax, %rdi
callq 0xe0d0
movl %ebx, %ebp
addq %r15, %rbp
movslq %eax, %r13
addq %r13, %rbp
cmpq $0x1fff, %rbp           # imm = 0x1FFF
jge 0x20c6f
leaq 0x4751e(%rip), %rax     # 0x68160
testl %ebx, %ebx
je 0x20c4e
movb $0x20, (%r15,%rax)
incq %r15
leaq (%rax,%r15), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xe1e0
addq %r13, %r15
movq 0x8(%r14), %r14
movl (%r14), %ebx
shrl $0x15, %ebx
andl $0x1, %ebx
jmp 0x20c80
movq (%r14), %rdi
leaq 0x26507(%rip), %rsi     # 0x47180
xorl %eax, %eax
callq 0x11a38
cmpq $0x1fff, %rbp           # imm = 0x1FFF
jl 0x20bf6
leaq 0x474cc(%rip), %rax     # 0x68160
addq %rax, %r15
movb $0x0, (%r15)
jmp 0x20ca4
leaq 0x219b9(%rip), %rax     # 0x4265d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/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 0x66657(%rip), %r14     # 0x875e0
movq (%rbx), %r15
movl (%r15), %eax
andl $0x3f, %eax
cmpl $0x1a, %eax
jne 0x20fb1
movq 0x10(%r15), %rax
andb $-0x2, 0x11(%rax)
movq 0x8(%r15), %r15
movl (%r15), %eax
andl $0x3f, %eax
cmpl $0x1a, %eax
je 0x20f97
movq %r15, (%rbx)
cmpq %r14, %r15
je 0x20fd6
movl (%r15), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x20fcd
movq %rbx, %rdi
callq 0x2116f
testl %eax, %eax
je 0x20f89
addq $0x8, %r15
movq %r15, %rbx
jmp 0x20f89
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4945e(%rip), %r12     # 0x6a470
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xe1e0
testl %r13d, %r13d
je 0x21052
movq %r15, %rax
shlq $0x20, %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
addq %rax, %rcx
sarq $0x20, %rcx
cmpb $0x2f, (%r14,%rcx)
je 0x21055
movb $0x2f, (%r13,%r12)
incl %r13d
movl %r13d, %r15d
jmp 0x21055
xorl %r15d, %r15d
movslq %r15d, %rdi
addq %r12, %rdi
movslq %ebp, %rdx
leaq 0x4930b(%rip), %rsi     # 0x6a370
callq 0xe1e0
movq %r12, %rdi
callq 0x2ebfc
movl (%rax), %ebx
testl %ebx, %ebx
js 0x21104
leaq 0x4df25(%rip), %r14     # 0x6efa8
leaq 0x493e6(%rip), %r12     # 0x6a470
movq (%r14), %rax
movl %ebx, %ecx
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %r13
movl 0x30(%rax,%rcx), %ebx
cmpl $0x0, 0x34(%rax,%rcx)
je 0x210bb
movq 0x8(%r13), %rsi
movq %r12, %rdi
callq 0xe1c0
testl %eax, %eax
jne 0x21100
jmp 0x21157
cmpl $0x3, 0x28(%r13)
jne 0x21100
movq 0x8(%r13), %rsi
movq %r12, %rdi
callq 0xe1c0
testl %eax, %eax
jne 0x21100
movq 0x38(%r13), %rdi
movl $0x1, %r13d
testq %rdi, %rdi
je 0x2115d
movl $0x81, %esi
callq 0x2b511
testq %rax, %rax
je 0x21100
movl (%rax), %eax
movl $0x1ff00, %ecx          # imm = 0x1FF00
andl %ecx, %eax
cmpl $0x100, %eax            # imm = 0x100
je 0x2115d
testl %ebx, %ebx
jns 0x2108a
leaq 0x49365(%rip), %rdi     # 0x6a470
xorl %r13d, %r13d
xorl %esi, %esi
xorl %eax, %eax
callq 0xe290
testl %eax, %eax
js 0x2115d
movl %eax, %r12d
addl %ebp, %r15d
movslq %r15d, %rsi
leaq 0x49345(%rip), %rdi     # 0x6a470
callq 0x2fbae
movq 0x8(%rsp), %rbx
movq (%rbx), %rcx
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
movl %r12d, %edx
movq (%rsp), %r8
callq 0x2f3e3
movq %rax, (%rbx)
movl %r12d, %edi
callq 0xe150
movl $0x1, %r13d
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/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 0x211bc
movq %rdi, %rbx
movq 0x10(%r14), %rdi
movl $0x81, %esi
callq 0x2b511
testq %rax, %rax
je 0x211a7
movl $0x1ff00, %ecx          # imm = 0x1FF00
andl (%rax), %ecx
xorl %esi, %esi
cmpl $0x100, %ecx            # imm = 0x100
cmoveq %rax, %rsi
jmp 0x211a9
xorl %esi, %esi
testq %rsi, %rsi
je 0x211bc
movq 0x60(%rsi), %rax
testq %rax, %rax
je 0x211c9
movq %r14, %rdi
callq *%rax
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x43bc8(%rip), %rax     # 0x64d98
movq (%rax), %rax
movq %rax, 0x58(%rsi)
movb $0x1, 0x48f82(%rip)     # 0x6a160
movq %rbx, %rdi
callq 0x211ef
movb $0x0, 0x48f73(%rip)     # 0x6a160
jmp 0x211c1
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rdi, %r15
movq (%rsi), %r12
movq %r12, %rcx
movq %rcx, %rax
movq 0x8(%rcx), %rcx
testb $0x10, 0x2(%rcx)
je 0x21fa0
movq %rcx, (%r14)
leaq 0x65629(%rip), %rcx     # 0x875e0
movq %rcx, 0x8(%rax)
movq 0x8(%r12), %rbx
cmpq %rcx, %rbx
je 0x22097
movl (%rbx), %eax
andl $0x3f, %eax
movb $0x1, %bpl
cmpl $0x5, %eax
je 0x22008
cmpl $0x3, %eax
jne 0x21fff
movq 0x10(%rbx), %rdi
movl $0x40, %esi
callq 0x2b511
testq %rax, %rax
je 0x21fff
movq 0x48(%rax), %r13
cmpl $0x0, 0x50(%rax)
setne %bpl
sete %al
jmp 0x22011
leaq 0xa0(%rip), %r13        # 0x220a6
jmp 0x2200f
leaq -0x21f0(%rip), %r13     # 0x1fe1f
xorl %eax, %eax
testb %al, %al
jne 0x2203c
cmpl $0x0, 0x2c(%r15)
jne 0x22033
movl $0x1, 0x2c(%r15)
cmpq $0x0, 0x40(%r15)
jne 0x22033
movq $0x0, 0x38(%r15)
cmpl $0x0, 0x4812a(%rip)     # 0x6a164
jne 0x2207d
cmpb $0x1, 0x4811d(%rip)     # 0x6a160
jne 0x2206d
leaq 0x45dd4(%rip), %rax     # 0x67e20
cmpl $0x0, (%rax)
setne %al
orb %al, %bpl
cmpb $0x1, %bpl
jne 0x2206d
movq (%r12), %rdi
leaq 0x251dc(%rip), %rsi     # 0x47242
xorl %eax, %eax
callq 0x118b4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r13
testl %eax, %eax
je 0x22097
testb $0x3f, (%rbx)
je 0x22097
movq 0x8(%rbx), %r14
movq %rbx, %rdi
callq 0x2fea9
testb $0x3f, (%r14)
movq %r14, %rbx
jne 0x22082
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq