LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: parse_range_statement
static struct token *parse_range_statement(struct token *token, struct statement *stmt)
{
	stmt->type = STMT_RANGE;
	token = token->next;
	token = expect(token, '(', "after __range__ statement");
	token = assignment_expression(token, &stmt->range_expression);
	token = expect(token, ',', "after range expression");
	token = assignment_expression(token, &stmt->range_low);
	token = expect(token, ',', "after low range");
	token = assignment_expression(token, &stmt->range_high);
	token = expect(token, ')', "after range statement");
	return expect(token, ';', "after range statement");
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl $0xd, (%rsi)
movq 0x8(%rdi), %rdi
leaq 0x260f0(%rip), %rdx     # 0x43b27
movl $0x28, %esi
callq 0x1950f
leaq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x39cd0
leaq 0x260ed(%rip), %rdx     # 0x43b41
movq %rax, %rdi
movl $0x2c, %esi
callq 0x1950f
leaq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x39cd0
leaq 0x260e4(%rip), %rdx     # 0x43b58
movq %rax, %rdi
movl $0x2c, %esi
callq 0x1950f
addq $0x20, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x39cd0
leaq 0x260d1(%rip), %rbx     # 0x43b68
movq %rax, %rdi
movl $0x29, %esi
movq %rbx, %rdx
callq 0x1950f
movq %rax, %rdi
movl $0x3b, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x1950f
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: attribute_packed
static struct token *attribute_packed(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	if (!ctx->ctype.alignment) {
		ctx->ctype.alignment = 1;
		ctx->packed = 1;
	}
	return token;
}

// Assembly:
movq %rdi, %rax
cmpq $0x0, 0x10(%rdx)
je 0x1dac3
retq
movq $0x1, 0x10(%rdx)
movb $0x1, 0x53(%rdx)
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: attribute_aligned
static struct token *attribute_aligned(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	int alignment = max_alignment;
	struct expression *expr = NULL;

	if (match_op(token, '(')) {
		token = parens_expression(token, &expr, "in attribute");
		if (expr)
			alignment = const_expression_value(expr);
	}
	if (alignment & (alignment-1)) {
		warning(token->pos, "I don't like non-power-of-2 alignments");
		return token;
	} else if (alignment > ctx->ctype.alignment)
		ctx->ctype.alignment = alignment;
	return token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x46c13(%rip), %rax     # 0x646f8
movl (%rax), %r15d
movq $0x0, (%rsp)
movl (%rdi), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1db29
cmpl $0x28, 0x10(%rbx)
jne 0x1db29
leaq 0x258c2(%rip), %rdx     # 0x433c9
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x38cf5
movq %rax, %rbx
movq (%r12), %rdi
testq %rdi, %rdi
je 0x1db29
callq 0xf4b5
movq %rax, %r15
leal -0x1(%r15), %eax
testl %eax, %r15d
jne 0x1db41
movslq %r15d, %rax
cmpq %rax, 0x10(%r14)
jae 0x1db52
movq %rax, 0x10(%r14)
jmp 0x1db52
movq (%rbx), %rdi
leaq 0x26033(%rip), %rsi     # 0x43b7e
xorl %eax, %eax
callq 0x118fc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: attribute_cleanup
static struct token *attribute_cleanup(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	struct expression *expr = NULL;

	if (match_op(token, '(')) {
		token = token->next;
		if (match_op(token, ')'))
			sparse_error(token->pos, "an argument is expected for attribute 'cleanup'");
		else if (token_type(token) != TOKEN_IDENT)
			sparse_error(token->pos, "argument is not an identifier");
		token = primary_expression(token, &expr);
		if (expr && expr->type == EXPR_SYMBOL)
			ctx->cleanup = expr;
		return expect(token, ')', "after attribute's argument'");
	}

	sparse_error(token->pos, "an argument is expected for attribute 'cleanup'");
	return token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq $0x0, 0x8(%rsp)
movq (%rdi), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1dbb4
cmpl $0x28, 0x10(%r14)
jne 0x1dbb4
movq %rdx, %rbx
movq 0x8(%r14), %r14
movq (%r14), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpq $0x3, %rax
je 0x1dbd2
cmpl $0x12, %eax
jne 0x1dbc4
cmpl $0x29, 0x10(%r14)
jne 0x1dbc4
leaq 0x25ff3(%rip), %rsi     # 0x43ba5
jmp 0x1dbcb
leaq 0x25fea(%rip), %rsi     # 0x43ba5
xorl %eax, %eax
callq 0x11a80
jmp 0x1dc0a
leaq 0x2600a(%rip), %rsi     # 0x43bd5
xorl %eax, %eax
callq 0x11a80
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x38e13
movq (%r15), %rcx
testq %rcx, %rcx
je 0x1dbf3
cmpb $0x3, (%rcx)
jne 0x1dbf3
movq %rcx, 0x38(%rbx)
leaq 0x25ff9(%rip), %rdx     # 0x43bf3
movq %rax, %rdi
movl $0x29, %esi
callq 0x1950f
movq %rax, %r14
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: attribute_address_space
static struct token *attribute_address_space(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	struct expression *expr = NULL;
	struct ident *as = NULL;
	struct token *next;

	token = expect(token, '(', "after address_space attribute");
	switch (token_type(token)) {
	case TOKEN_NUMBER:
		next = primary_expression(token, &expr);
		if (expr->type != EXPR_VALUE)
			goto invalid;
		as = numerical_address_space(expr->value);
		break;
	case TOKEN_IDENT:
		next = token->next;
		as = token->ident;
		break;
	default:
		next = token->next;
	invalid:
		as = NULL;
		warning(token->pos, "invalid address space name");
	}

	if (Waddress_space && as) {
		if (ctx->ctype.as)
			sparse_error(token->pos,
				     "multiple address spaces given: %s & %s",
				     show_as(ctx->ctype.as), show_as(as));
		ctx->ctype.as = as;
	}
	token = expect(next, ')', "after address_space attribute");
	return token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq $0x0, 0x8(%rsp)
leaq 0x25f8c(%rip), %rdx     # 0x43c0f
movl $0x28, %esi
callq 0x1950f
movq %rax, %r15
movq (%rax), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x3, %eax
je 0x1dcf4
cmpl $0x5, %eax
jne 0x1dd4c
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x38e13
movq %rax, %r14
movq (%r12), %rax
cmpb $0x1, (%rax)
jne 0x1dd52
movl 0x20(%rax), %edx
testl %edx, %edx
je 0x1dd85
leaq 0x25f97(%rip), %rsi     # 0x43c6f
leaq 0x10(%rsp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0xe2c0
movq %r12, %rdi
callq 0x2e793
movq %rax, %r12
jmp 0x1dcfc
movq 0x8(%r15), %r14
movq 0x10(%r15), %r12
leaq 0x42885(%rip), %rax     # 0x60588
cmpl $0x0, (%rax)
setne %al
testq %r12, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1dd63
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1dd46
callq 0x23268
movq %rax, %r13
movq %r12, %rdi
callq 0x23268
movq (%r15), %rdi
leaq 0x25f0f(%rip), %rsi     # 0x43c48
movq %r13, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x11a80
movq %r12, 0x20(%rbx)
jmp 0x1dd63
movq 0x8(%r15), %r14
jmp 0x1dd55
movq (%r15), %rdi
leaq 0x25ed1(%rip), %rsi     # 0x43c2d
xorl %eax, %eax
callq 0x118fc
leaq 0x25ea5(%rip), %rdx     # 0x43c0f
movq %r14, %rdi
movl $0x29, %esi
callq 0x1950f
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r12d, %r12d
jmp 0x1dcfc
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: attribute_designated_init
static struct token *attribute_designated_init(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	if (ctx->ctype.base_type && ctx->ctype.base_type->type == SYM_STRUCT)
		ctx->ctype.base_type->designated_init = 1;
	else
		warning(token->pos, "attribute designated_init applied to non-structure type");
	return token;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdx), %rax
testq %rax, %rax
je 0x1dda4
cmpb $0x7, (%rax)
jne 0x1dda4
orb $0x1, 0x56(%rax)
jmp 0x1ddb5
movq (%rbx), %rdi
leaq 0x25eca(%rip), %rsi     # 0x43c78
xorl %eax, %eax
callq 0x118fc
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: attribute_transparent_union
static struct token *attribute_transparent_union(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	if (Wtransparent_union)
		warning(token->pos, "attribute __transparent_union__");

	if (ctx->ctype.base_type && ctx->ctype.base_type->type == SYM_UNION)
		ctx->ctype.base_type->transparent_union = 1;
	else
		warning(token->pos, "attribute __transparent_union__ applied to non-union type");
	return token;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x49071(%rip), %rax     # 0x66e3c
cmpl $0x0, (%rax)
je 0x1dde1
movq (%rbx), %rdi
leaq 0x25ed6(%rip), %rsi     # 0x43cb0
xorl %eax, %eax
callq 0x118fc
movq (%r14), %rax
testq %rax, %rax
je 0x1ddf4
cmpb $0x8, (%rax)
jne 0x1ddf4
orb $0x40, 0x56(%rax)
jmp 0x1de05
movq (%rbx), %rdi
leaq 0x25ed2(%rip), %rsi     # 0x43cd0
xorl %eax, %eax
callq 0x118fc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x25ed3(%rip), %rdx     # 0x43d0a
movl $0x28, %esi
callq 0x1950f
movq %rax, %rbx
movq (%rax), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1de96
movq 0x10(%rbx), %rdi
testb $0x4, 0x11(%rdi)
je 0x1de73
movl $0x100, %esi            # imm = 0x100
callq 0x2afd5
testq %rax, %rax
je 0x1de73
movq 0x40(%rax), %rax
testb $0x40, (%rax)
jne 0x1debf
movq 0x10(%rbx), %rdi
callq 0x2de35
movq (%rbx), %rdi
leaq 0x25e99(%rip), %rsi     # 0x43d1f
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a80
movq 0x8(%rbx), %rbx
jmp 0x1dea4
leaq 0x25e9c(%rip), %rsi     # 0x43d39
xorl %eax, %eax
callq 0x11a80
leaq 0x25e5f(%rip), %rdx     # 0x43d0a
movq %rbx, %rdi
movl $0x29, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1950f
movq %rax, 0x30(%r14)
jmp 0x1de90
// File: /workspace/github_c_makefile_star2_O3/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 0x420b8(%rip), %rax     # 0x5ff88
je 0x1ded5
xorl %eax, %eax
retq
leaq 0x4cb3c(%rip), %rax     # 0x6aa18
cmpq %rax, %rdi
je 0x1deee
testb $0x40, 0x69(%rdi)
jne 0x1deef
leaq 0x4d3ea(%rip), %rax     # 0x6b2d8
retq
leaq 0x4d4c2(%rip), %rax     # 0x6b3b8
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1e00d
cmpl $0x28, 0x10(%rax)
jne 0x1e00d
leaq 0x253c7(%rip), %rdx     # 0x433c9
movq %rsp, %rsi
movq %rax, %rdi
callq 0x38cf5
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1e034
leaq 0x27275(%rip), %rsi     # 0x45298
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11a80
testb $0x4, %sil
jne 0x1e06f
testb $0x10, %sil
jne 0x1e078
testb $0x20, %sil
jne 0x1e081
testb $0x40, %sil
jne 0x1e08a
testb %sil, %sil
js 0x1e093
btl $0x8, %esi
jb 0x1e09c
btl $0x9, %esi
leaq 0x2ccc3(%rip), %rax     # 0x4ad25
leaq 0x288fb(%rip), %r14     # 0x46964
cmovaeq %rax, %r14
jmp 0x1e0a3
leaq 0x288c2(%rip), %r14     # 0x46938
jmp 0x1e0a3
leaq 0x28908(%rip), %r14     # 0x46987
jmp 0x1e0a3
leaq 0x242a9(%rip), %r14     # 0x42331
jmp 0x1e0a3
leaq 0x25190(%rip), %r14     # 0x43221
jmp 0x1e0a3
leaq 0x2cbb8(%rip), %r14     # 0x4ac52
jmp 0x1e0a3
leaq 0x288a3(%rip), %r14     # 0x46946
movq %rdx, %rdi
callq 0x2de35
leaq 0x271b5(%rip), %rsi     # 0x45267
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11a80
// File: /workspace/github_c_makefile_star2_O3/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 0x1e0ff
pushq %rax
movq 0x10(%rdi), %rdi
testb $0x4, 0x11(%rdi)
je 0x1e102
movl $0x2, %esi
callq 0x2afd5
testq %rax, %rax
je 0x1e102
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x1e102
movb (%rax), %al
andb $0x8, %al
shrb $0x3, %al
jmp 0x1e104
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x1ed66
movl 0x50(%rbx), %r15d
testb $0x2, %bpl
leaq 0x21bab(%rip), %rax     # 0x408cd
leaq 0x26f5d(%rip), %r8      # 0x45c86
cmoveq %rax, %r8
leaq 0x26fc4(%rip), %rdx     # 0x45cf8
movq %rsp, %r12
movl $0x20, %esi
movq %r12, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0xe100
shrl $0x3, %r15d
leaq 0x2299d(%rip), %rdx     # 0x416f1
movq %r12, %rdi
movl $0x1, %esi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x1eec8
testb $0x4, %bpl
je 0x1ede3
movq %rbx, %rdi
callq 0x232a1
movq %rax, %r15
movzbl (%rbx), %edx
movq %rbx, %rax
cmpl $0x3, %edx
jne 0x1ed89
movq 0x60(%rbx), %rax
movzbl (%rax), %edx
movl 0x50(%rbx), %ecx
xorl %esi, %esi
cmpl $0x4, %edx
je 0x1ed9d
xorl %esi, %esi
btl $0xe, 0x68(%rax)
adcl $-0x1, %esi
addl %esi, %ecx
negb %cl
movq $-0x1, %r12
shrq %cl, %r12
leaq 0x26ed7(%rip), %rdx     # 0x45c89
movq %rsp, %r13
movl $0x20, %esi
movq %r13, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0xe100
leaq 0x26ec6(%rip), %rdx     # 0x45c94
movq %r13, %rdi
movl $0x1, %esi
movq %r12, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x1eec8
testb $0x8, %bpl
je 0x1ee59
movq %rbx, %rdi
callq 0x232a1
movq %rax, %r15
leaq 0x26ea1(%rip), %rdx     # 0x45c9c
movq %rsp, %rdi
movl $0x20, %esi
movq %r14, %rcx
xorl %eax, %eax
callq 0xe100
movzbl (%rbx), %ecx
movq %rbx, %rax
cmpl $0x3, %ecx
jne 0x1ee1f
movq 0x60(%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x4, %ecx
je 0x1ee40
testb $0x40, 0x69(%rax)
jne 0x1ee40
leaq 0x26e76(%rip), %rdi     # 0x45ca7
movq %rsp, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x11cf7
jmp 0x1ee59
leaq 0x26e83(%rip), %rdx     # 0x45cca
movq %rsp, %rdi
movl $0x1, %esi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1eec8
testb $0x20, %bpl
je 0x1ee7b
movq %rbx, %rdi
callq 0x23279
leaq 0x26e60(%rip), %rdi     # 0x45cce
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x11cf7
testb $0x10, %bpl
je 0x1eeb6
leaq 0x26e63(%rip), %rdx     # 0x45ceb
movq %rsp, %r15
movl $0x20, %esi
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0xe100
movl 0x50(%rbx), %ecx
leaq 0x2284a(%rip), %rdx     # 0x416f1
movq %r15, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x1eec8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x1ef24
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 0x2e793
movq %rax, %rbx
leaq 0x676ad(%rip), %r14     # 0x865e0
testq %r15, %r15
je 0x1efe2
cmpb $0x0, (%r15)
je 0x1efe2
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 0x47fce(%rip), %rdi     # 0x66f40
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdx
callq 0xe0b0
xorl %edi, %edi
callq 0x2f866
movq %rax, %r14
callq 0xe300
movq (%rax), %rcx
movzbl 0x47fa8(%rip), %edx     # 0x66f40
movq (%r14), %rax
andq $-0x40, %rax
testb $0x8, 0x1(%rcx,%rdx,2)
jne 0x1efbb
orq $0x3, %rax
movq %rax, (%r14)
leaq 0x47f8c(%rip), %rdi     # 0x66f40
callq 0x2e793
jmp 0x1efce
orq $0x5, %rax
movq %rax, (%r14)
leaq 0x47f77(%rip), %rdi     # 0x66f40
callq 0x2f598
movq %rax, 0x10(%r14)
orb $0x20, 0x2(%r14)
leaq 0x67602(%rip), %rax     # 0x865e0
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 0x1f00b
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x477ae(%rip), %rbx     # 0x67040
testq %rbx, %rbx
je 0x1f8f9
movl $0x1ff00, %ebp          # imm = 0x1FF00
movq %rbx, %r14
movzwl (%r14), %eax
testb %al, %al
jle 0x1f8f0
xorl %r15d, %r15d
movq 0x18(%r14,%r15,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x1f8be
testq %rdi, %rdi
je 0x1f8e1
movl $0x81, %esi
callq 0x2afd5
testq %rax, %rax
je 0x1f8e1
movl (%rax), %ecx
andl %ebp, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jne 0x1f8e1
movq %rax, %rdi
callq 0x1f904
incq %r15
movl (%r14), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jl 0x1f8aa
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0x1f89f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1fb90
movq %rsi, %r14
movq %rdi, %r15
leaq 0x26249(%rip), %r12     # 0x45d18
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movl $0x1, %ebx
testq %r15, %r15
je 0x1fb92
testq %r14, %r14
je 0x1fb92
movl (%r15), %eax
andl $0x3f, %eax
movl (%r14), %ecx
andl $0x3f, %ecx
cmpl %ecx, %eax
jne 0x1fb92
addl $-0x3, %eax
cmpl $0x18, %eax
ja 0x1fb92
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movl 0x10(%r15), %ecx
movl 0x10(%r14), %edx
bswapl %ecx
bswapl %edx
xorl %eax, %eax
cmpl %edx, %ecx
seta %al
sbbl $0x0, %eax
jmp 0x1fb7b
movl 0x10(%r15), %ecx
xorl %eax, %eax
cmpl 0x10(%r14), %ecx
setne %al
jmp 0x1fb7b
movq 0x10(%r15), %rdi
movq 0x10(%r14), %rsi
movl (%rdi), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movl (%rsi), %eax
andl %ebp, %eax
cmpl %eax, %edx
jne 0x1fb92
addq $0x4, %rdi
addq $0x4, %rsi
callq 0xe190
jmp 0x1fb7b
movq 0x10(%r15), %rcx
xorl %eax, %eax
cmpq 0x10(%r14), %rcx
jmp 0x1fb36
movq 0x10(%r15), %rdi
movq 0x10(%r14), %rsi
callq 0xe1c0
testl %eax, %eax
jne 0x1fb92
movq 0x8(%r15), %r15
movq 0x8(%r14), %r14
cmpq %r14, %r15
jne 0x1fad9
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq (%rdi), %r15
testq %rsi, %rsi
je 0x1fbeb
movq %rsi, %rdx
movq %rdi, %r14
movq 0x8(%r15), %rbx
movq %rbx, %rdi
movl $0x16, %esi
callq 0x1fc0e
movq (%r15), %rdi
testl %eax, %eax
je 0x1fbf5
andl $0x200000, %edi         # imm = 0x200000
movq $-0x200001, %rax        # imm = 0xFFDFFFFF
andq (%rbx), %rax
orq %rdi, %rax
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x2f875
movq %rbx, (%r14)
jmp 0x1fc05
orb $-0x80, 0x7(%r15)
movq %r15, %rbx
jmp 0x1fc05
leaq 0x26260(%rip), %rsi     # 0x45e5c
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x11a80
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1fcf7
movq (%rdi), %rcx
movl %ecx, %r8d
andl $0x3f, %r8d
cmpl $0x3, %r8d
jne 0x1fcf7
movq 0x8(%rdx), %rdx
cmpq 0x402b0(%rip), %rdx     # 0x5fee8
je 0x1fcf7
movq 0x10(%rdi), %rax
xorl %r8d, %r8d
leaq 0x66994(%rip), %r9      # 0x865e0
cmpq %rax, 0x10(%rdx)
je 0x1fc65
incl %r8d
movq 0x8(%rdx), %rdx
movq 0x8(%rdx), %rdx
cmpq %r9, %rdx
jne 0x1fc4c
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 0x1fc9c
cmpl $0x15, %esi
jne 0x1fcb6
leal 0x1(%rcx), %esi
andl $0x3ff, %esi            # imm = 0x3FF
movl $0xfffffc00, %r8d       # imm = 0xFFFFFC00
movl %esi, %edx
jmp 0x1fcce
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 0x1fcce
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 0x1fce4
xorl %eax, %eax
btl $0x1e, %ecx
adcl $0x1, %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_O3/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 0x1fe4c
movq 0x10(%rcx), %r8
cmpq 0x40133(%rip), %r8      # 0x5ff70
jne 0x1fe4c
movq 0x8(%rcx), %rcx
cmpq 0x4009e(%rip), %rcx     # 0x5fee8
je 0x1fe78
leaq 0x445b5(%rip), %rcx     # 0x64408
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_O3/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 0x40033(%rip), %rbx     # 0x5fee8
je 0x1fefe
leaq 0x43e72(%rip), %r14     # 0x63d30
leaq 0x6671b(%rip), %r15     # 0x865e0
movq (%rbx), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x10, %eax
jne 0x1fef0
movq 0x10(%rbx), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x220bb
movq 0x8(%rbx), %rbx
cmpq %r15, %rbx
jne 0x1fec5
jmp 0x1fefe
leaq 0x2636b(%rip), %rsi     # 0x46262
xorl %eax, %eax
callq 0x118fc
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3ffcf(%rip), %rbx     # 0x5fee8
je 0x1ff62
leaq 0x43e06(%rip), %r14     # 0x63d28
leaq 0x666b7(%rip), %r15     # 0x865e0
movq (%rbx), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x10, %eax
jne 0x1ff54
movq 0x10(%rbx), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x220bb
movq 0x8(%rbx), %rbx
cmpq %r15, %rbx
jne 0x1ff29
jmp 0x1ff62
leaq 0x26307(%rip), %rsi     # 0x46262
xorl %eax, %eax
callq 0x11a80
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3ff6b(%rip), %rbx     # 0x5fee8
je 0x1ffc6
leaq 0x43db2(%rip), %r14     # 0x63d38
leaq 0x66653(%rip), %r15     # 0x865e0
movq (%rbx), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x10, %eax
jne 0x1ffb8
movq 0x10(%rbx), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x220bb
movq 0x8(%rbx), %rbx
cmpq %r15, %rbx
jne 0x1ff8d
jmp 0x1ffc6
leaq 0x262a3(%rip), %rsi     # 0x46262
xorl %eax, %eax
callq 0x11a80
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3ff0b(%rip), %rax     # 0x5fee8
je 0x2003d
leaq 0x433ca(%rip), %rcx     # 0x633b0
leaq 0x665f3(%rip), %rdx     # 0x865e0
movq (%rax), %rdi
movl %edi, %esi
andl $0x3f, %esi
cmpl $0x10, %esi
jne 0x2002f
cmpq $0x0, 0x43cfe(%rip)     # 0x63d00
jne 0x20044
movq 0x10(%rax), %rsi
addq $0x4, %rsi
movq %rcx, %rdi
cmpq $0x0, (%rdi)
leaq 0x8(%rdi), %rdi
jne 0x2000f
movq %rsi, -0x8(%rdi)
movq $0x0, (%rdi)
movq 0x8(%rax), %rax
cmpq %rdx, %rax
jne 0x1ffed
jmp 0x2003d
leaq 0x2622c(%rip), %rsi     # 0x46262
xorl %eax, %eax
callq 0x11a80
movl $0x1, %eax
popq %rcx
retq
leaq 0x2622c(%rip), %rsi     # 0x46277
xorl %eax, %eax
callq 0x11b9c
// File: /workspace/github_c_makefile_star2_O3/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 0x200a4
callq 0x221bb
movl %eax, %ebp
jmp 0x200e1
cmpl $0x0, 0x2c(%r14)
jne 0x200c2
movl $0x1, 0x2c(%r14)
cmpq $0x0, 0x40(%r14)
jne 0x200c2
movq $0x0, 0x38(%r14)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $0x0, 0x49096(%rip)     # 0x69164
jne 0x200e1
movq (%rbx), %rdi
leaq 0x261bb(%rip), %rsi     # 0x46295
xorl %eax, %eax
callq 0x11a80
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x22219
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x20128
testl %eax, %eax
jne 0x2011c
cmpq $0x0, 0x40(%r14)
je 0x20176
callq 0x221bb
movl %eax, %ebp
xorl $0x1, %ebp
jmp 0x20162
testl %eax, %eax
jne 0x20143
movl $0x1, 0x2c(%r14)
cmpq $0x0, 0x40(%r14)
jne 0x20143
movq $0x0, 0x38(%r14)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $0x0, 0x49015(%rip)     # 0x69164
jne 0x20162
movq (%rbx), %rdi
leaq 0x2613a(%rip), %rsi     # 0x46295
xorl %eax, %eax
callq 0x11a80
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x22219
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x20193
cmpq 0x10(%rdi), %rax
jne 0x2011c
movq %rbx, 0x40(%r14)
movl $0x1, 0x2c(%r14)
jmp 0x2011c
movq %rbx, 0x40(%r14)
movq 0x10(%rdi), %rax
movq %rax, 0x38(%r14)
jmp 0x2011c
// File: /workspace/github_c_makefile_star2_O3/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 0x201ff
testq %rbx, %rbx
je 0x2021d
movl (%rbx), %eax
andl $0x3f, %eax
cmpl $0x1e, %eax
jne 0x201dd
movl $0x1, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq (%rdx), %rdi
leaq 0x260fe(%rip), %rsi     # 0x462d4
xorl %eax, %eax
callq 0x11a80
cmpl $0x0, 0x48f80(%rip)     # 0x69164
je 0x2023e
movq (%rbx), %rax
movl %eax, %ecx
andl $0x3f, %ecx
cmpl $0x1c, %ecx
jne 0x2024b
movl $0x0, 0x48f67(%rip)     # 0x69164
jmp 0x2024b
movq $0x0, 0x40(%rdi)
cmpl $0x0, 0x2c(%rdi)
je 0x2025d
cmpq $0x0, 0x38(%rdi)
je 0x201af
movl $0x0, 0x2c(%rdi)
jmp 0x201af
movl $0x1, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq (%rdx), %rdi
leaq 0x26081(%rip), %rsi     # 0x462b6
xorl %eax, %eax
callq 0x11a80
jmp 0x20256
movl $0x1, 0x48f1c(%rip)     # 0x69164
movq (%rbx), %rax
andq $-0x40, %rax
orq $0x1e, %rax
movq %rax, (%rbx)
movl $0x1, %eax
popq %rbx
retq
movq $0x0, 0x38(%rdi)
jmp 0x201af
// File: /workspace/github_c_makefile_star2_O3/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 0x2029e
pushq %rax
testq %rax, %rax
je 0x202bc
movl 0x48ee4(%rip), %ecx     # 0x69164
testl %ecx, %ecx
je 0x2028c
decl %ecx
movl %ecx, 0x48ed8(%rip)     # 0x69164
movq 0x8(%rax), %rcx
movq %rcx, 0x48(%rdi)
movq %rax, %rdi
callq 0x2f875
jmp 0x202db
movq $0x0, 0x40(%rdi)
cmpl $0x0, 0x2c(%rdi)
je 0x202e2
cmpq $0x0, 0x38(%rdi)
je 0x20274
movl $0x0, 0x2c(%rdi)
jmp 0x20274
movl $0x1, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq (%rdx), %rdi
leaq 0x26012(%rip), %rsi     # 0x462e6
xorl %eax, %eax
callq 0x11a80
movl $0x1, %eax
popq %rcx
retq
movq $0x0, 0x38(%rdi)
jmp 0x20274
// File: /workspace/github_c_makefile_star2_O3/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, 0x48e65(%rip)     # 0x69164
jne 0x2030c
leaq 0x8(%rbx), %rdi
callq 0x22291
movl %eax, %edx
cmpl $0x0, 0x2c(%r14)
jne 0x2032a
movl $0x1, 0x2c(%r14)
cmpq $0x0, 0x40(%r14)
jne 0x2032a
movq $0x0, 0x38(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22219
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x40(%rdi), %rcx
movq 0x48(%rdi), %rax
cmpq %rax, %rcx
jne 0x20374
movq $0x0, 0x40(%rdi)
cmpl $0x0, 0x2c(%rdi)
je 0x2036a
cmpq $0x0, 0x38(%rdi)
je 0x20372
movl $0x0, 0x2c(%rdi)
jmp 0x20372
movq $0x0, 0x38(%rdi)
xorl %ecx, %ecx
pushq %rax
testq %rax, %rax
je 0x203b2
movl (%rax), %esi
andl $0x3f, %esi
cmpl $0x1e, %esi
jne 0x203d3
movl $0x1, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq (%rdx), %rdi
leaq 0x25fb2(%rip), %rsi     # 0x4634e
xorl %eax, %eax
callq 0x11a80
cmpl $0x0, 0x48dba(%rip)     # 0x69164
jne 0x2043a
jmp 0x2041d
movl $0x1, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq (%rdx), %rdi
leaq 0x25f66(%rip), %rsi     # 0x46330
xorl %eax, %eax
callq 0x11a80
jmp 0x2043a
cmpl $0x0, 0x2c(%rdi)
jne 0x203ed
movl $0x1, 0x2c(%rdi)
testq %rcx, %rcx
jne 0x203ed
movq $0x0, 0x38(%rdi)
movq (%rax), %rcx
movl %ecx, %esi
andl $0x3f, %esi
cmpl $0x1c, %esi
jne 0x2043a
cmpl $0x0, 0x48d63(%rip)     # 0x69164
je 0x20429
movl $0x0, 0x48d57(%rip)     # 0x69164
addq $0x8, %rdx
movq %rdx, %rdi
callq 0x22291
testl %eax, %eax
jne 0x2043a
movl $0x1, 0x48d3d(%rip)     # 0x69164
jmp 0x2043a
movl $0x1, 0x48d31(%rip)     # 0x69164
orq $0x1d, %rcx
movq %rcx, (%rax)
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x49fbb(%rip)     # 0x6a480
jne 0x204d3
leaq 0x49fb2(%rip), %rdi     # 0x6a480
callq 0xe1f0
leaq 0x49fa6(%rip), %rdi     # 0x6a480
callq 0xe050
leaq 0x49f8a(%rip), %r14     # 0x6a470
leaq 0x25e73(%rip), %rdx     # 0x46360
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 0x2246e
// File: /workspace/github_c_makefile_star2_O3/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, 0x49f62(%rip)     # 0x6a480
jne 0x2052c
leaq 0x49f59(%rip), %rdi     # 0x6a480
callq 0xe1f0
leaq 0x49f4d(%rip), %rdi     # 0x6a480
callq 0xe050
leaq 0x49f49(%rip), %r14     # 0x6a488
leaq 0x25e23(%rip), %rdx     # 0x46369
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 0x2246e
// File: /workspace/github_c_makefile_star2_O3/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 0x20643
movq 0x10(%rax), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x2afd5
testq %rax, %rax
je 0x20653
movq 0x40(%rax), %rcx
testq %rcx, %rcx
je 0x20653
xorl %eax, %eax
cmpq $0x0, 0x40(%rcx)
setne %al
jmp 0x20655
leaq 0x25d22(%rip), %rsi     # 0x4636c
xorl %eax, %eax
callq 0x11a80
jmp 0x20672
xorl %eax, %eax
movq (%rbx), %rcx
andq $-0x40, %rcx
orq $0x5, %rcx
movq %rcx, (%rbx)
leaq 0x384f6(%rip), %rcx     # 0x58b60
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_O3/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 0x206ba
movq 0x10(%rax), %rdi
movl $0x10, %esi
callq 0x2afd5
testq %rax, %rax
je 0x206ca
movl 0x54(%rax), %eax
shrl $0x13, %eax
andl $0x1, %eax
jmp 0x206cc
leaq 0x25cab(%rip), %rsi     # 0x4636c
xorl %eax, %eax
callq 0x11a80
jmp 0x206e9
xorl %eax, %eax
movq (%rbx), %rcx
andq $-0x40, %rcx
orq $0x5, %rcx
movq %rcx, (%rbx)
leaq 0x3847f(%rip), %rcx     # 0x58b60
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_O3/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 0x2075f
movq 0x10(%rcx), %rax
cmpq 0x3f812(%rip), %rax     # 0x5ff28
sete %cl
cmpq 0x3f7f8(%rip), %rax     # 0x5ff18
sete %dl
orb %cl, %dl
cmpq 0x3f87c(%rip), %rax     # 0x5ffa8
sete %cl
cmpq 0x3f7a2(%rip), %rax     # 0x5fed8
sete %al
orb %cl, %al
orb %dl, %al
movq (%rdi), %rcx
andq $-0x40, %rcx
orq $0x5, %rcx
movq %rcx, (%rdi)
movzbl %al, %eax
leaq 0x3840b(%rip), %rcx     # 0x58b60
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rdi)
jmp 0x20770
leaq 0x25c06(%rip), %rsi     # 0x4636c
movq %rax, %rdi
xorl %eax, %eax
callq 0x11a80
cmpl $0x3, %ebx
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x207ce
leaq 0x3fdc6(%rip), %rax     # 0x60558
cmpl $0x8, (%rax)
jb 0x207e1
movq 0x10(%rcx), %rax
cmpq 0x3f786(%rip), %rax     # 0x5ff28
sete %cl
cmpq 0x3f76c(%rip), %rax     # 0x5ff18
sete %dl
orb %cl, %dl
cmpq 0x3f7f0(%rip), %rax     # 0x5ffa8
sete %cl
cmpq 0x3f716(%rip), %rax     # 0x5fed8
sete %al
orb %cl, %al
orb %dl, %al
movzbl %al, %eax
jmp 0x207e3
leaq 0x25b97(%rip), %rsi     # 0x4636c
movq %rax, %rdi
xorl %eax, %eax
callq 0x11a80
jmp 0x20800
xorl %eax, %eax
movq (%rdi), %rcx
andq $-0x40, %rcx
orq $0x5, %rcx
movq %rcx, (%rdi)
leaq 0x38368(%rip), %rcx     # 0x58b60
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rdi)
cmpl $0x3, %ebx
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x20b7e
movl %esi, %ebx
movq 0x10(%r15), %rdi
movl $0x81, %esi
callq 0x2afd5
testq %rax, %rax
je 0x20b94
movq %rax, %r14
movl (%rax), %eax
movl %eax, %ecx
shrl $0x12, %ecx
andl $0x3, %ecx
cmpl %ebx, %ecx
jg 0x20bda
xorl %ebx, %ecx
movl %eax, %edx
andl $0x1ff00, %edx          # imm = 0x1FF00
xorl $0x8000, %edx           # imm = 0x8000
orl %ecx, %edx
je 0x20bda
movq 0x30(%r14), %rcx
leaq 0x43221(%rip), %rdx     # 0x63d98
cmpq (%rdx), %rcx
jne 0x20b99
jmp 0x20bbd
movq (%rdi), %rdi
leaq 0x25559(%rip), %rsi     # 0x460e1
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x11a80
cmpl $0x2, %ebx
jl 0x20bda
movq (%r15), %rdi
movl $0x3, %esi
callq 0x2b00b
movq %rax, %r14
movq 0x10(%r15), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0x2beca
movl (%r14), %eax
movq $0x0, 0x58(%r14)
andl $0x3, %ebx
shll $0x12, %ebx
andl $0xfff200ff, %eax       # imm = 0xFFF200FF
addl %ebx, %eax
addl $0x8000, %eax           # imm = 0x8000
movl %eax, (%r14)
popq %rbx
popq %r14
popq %r15
retq