LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/parse.c
// Function: parse_asm_operands
static struct token *parse_asm_operands(struct token *token, struct statement *stmt,
	struct asm_operand_list **inout)
{
	/* Allow empty operands */
	if (match_op(token->next, ':') || match_op(token->next, ')'))
		return token->next;
	do {
		struct asm_operand *op = __alloc_asm_operand(0);
		if (match_op(token->next, '[') &&
		    token_type(token->next->next) == TOKEN_IDENT &&
		    match_op(token->next->next->next, ']')) {
			op->name = token->next->next->ident;
			token = token->next->next->next;
		}
		token = token->next;
		token = string_expression(token, &op->constraint, "asm constraint");
		token = parens_expression(token, &op->expr, "in asm parameter");
		add_ptr_list(inout, op);
	} while (match_op(token, ','));
	return token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rdi), %r12
movl (%r12), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1afcc
movl 0x10(%r12), %eax
cmpl $0x29, %eax
je 0x1b07b
cmpl $0x3a, %eax
je 0x1b07b
leaq 0x21ab3(%rip), %r14     # 0x3ca86
leaq 0x21abb(%rip), %r15     # 0x3ca95
movq %rdi, %r12
xorl %edi, %edi
callq 0x2aa8e
movq %rax, %r13
movq 0x8(%r12), %rdi
movl (%rdi), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1b037
cmpl $0x5b, 0x10(%rdi)
jne 0x1b037
movq 0x8(%rdi), %rax
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x3, %ecx
jne 0x1b037
movq 0x8(%rax), %rcx
movl (%rcx), %edx
andl $0x3f, %edx
cmpl $0x12, %edx
jne 0x1b037
cmpl $0x5d, 0x10(%rcx)
jne 0x1b037
movq 0x10(%rax), %rax
movq %rax, (%r13)
movq 0x8(%r12), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x8(%r13), %rsi
movq %r14, %rdx
callq 0x328db
movq %r13, %rsi
addq $0x10, %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x327fd
movq %rax, %r12
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1fae9
movl (%r12), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1b07b
cmpl $0x2c, 0x10(%r12)
je 0x1afdd
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/parse.c
// Function: attribute_context
static struct token *attribute_context(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	struct context *context = alloc_context();
	struct expression *args[3];
	int idx = 0;

	token = expect(token, '(', "after context attribute");
	token = conditional_expression(token, &args[0]);
	token = expect(token, ',', "after context 1st argument");
	token = conditional_expression(token, &args[1]);
	if (match_op(token, ',')) {
		token = token->next;
		token = conditional_expression(token, &args[2]);
		token = expect(token, ')', "after context 3rd argument");
		context->context = args[0];
		idx++;
	} else {
		token = expect(token, ')', "after context 2nd argument");
	}
	context->in =  get_expression_value(args[idx++]);
	context->out = get_expression_value(args[idx++]);
	add_ptr_list(&ctx->ctype.contexts, context);
	return token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r15
callq 0x26718
movq %rax, %r14
leaq 0x219fe(%rip), %rdx     # 0x3caa6
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x17480
movq %rsp, %rsi
movq %rax, %rdi
callq 0x33498
leaq 0x219f9(%rip), %rdx     # 0x3cabe
pushq $0x2c
popq %rsi
movq %rax, %rdi
callq 0x17480
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x33498
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x12, %ecx
jne 0x1b120
cmpl $0x2c, 0x10(%rax)
jne 0x1b120
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %r12
movq %r12, %rsi
callq 0x33498
leaq 0x219d4(%rip), %rdx     # 0x3cad9
pushq $0x29
popq %rsi
movq %rax, %rdi
callq 0x17480
movq %rax, %r15
movq -0x10(%r12), %rax
movq %rax, (%r14)
pushq $0x1
popq %rax
jmp 0x1b137
leaq 0x219cd(%rip), %rdx     # 0x3caf4
pushq $0x29
popq %rsi
movq %rax, %rdi
callq 0x17480
movq %rax, %r15
xorl %eax, %eax
movl %eax, %r12d
movq (%rsp,%r12,8), %rdi
callq 0xfe1b
movl %eax, 0x8(%r14)
movq 0x8(%rsp,%r12,8), %rdi
callq 0xfe1b
movl %eax, 0xc(%r14)
addq $0x18, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fae9
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/parse.c
// Function: parse_context_statement
static struct token *parse_context_statement(struct token *token, struct statement *stmt)
{
	stmt->type = STMT_CONTEXT;
	token = token->next;
	token = expect(token, '(', "after __context__ statement");
	token = assignment_expression(token, &stmt->expression);
	if (!stmt->expression)
		unexpected(token, "expression expected after '('");
	if (match_op(token, ',')) {
		token = token->next;
		stmt->context = stmt->expression;
		token = assignment_expression(token, &stmt->expression);
		if (!stmt->expression)
			unexpected(token, "expression expected after ','");
	}
	token = expect(token, ')', "at end of __context__ statement");
	return expect(token, ';', "at end of statement");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl $0xc, (%rsi)
movq 0x8(%rdi), %rdi
leaq 0x21983(%rip), %rdx     # 0x3cb0f
pushq $0x28
popq %rsi
callq 0x17480
leaq 0x10(%rbx), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x335c4
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
jne 0x1b1bc
leaq 0x21977(%rip), %rsi     # 0x3cb2b
movq %r14, %rdi
callq 0x1b224
movl (%r14), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1b1fb
cmpl $0x2c, 0x10(%r14)
jne 0x1b1fb
movq 0x8(%r14), %rdi
movq 0x10(%rbx), %rax
movq %rax, 0x18(%rbx)
movq %r15, %rsi
callq 0x335c4
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
jne 0x1b1fb
leaq 0x21956(%rip), %rsi     # 0x3cb49
movq %r14, %rdi
callq 0x1b224
leaq 0x21965(%rip), %rdx     # 0x3cb67
pushq $0x29
popq %rsi
movq %r14, %rdi
callq 0x17480
leaq 0x21696(%rip), %rdx     # 0x3c8aa
pushq $0x3b
popq %rsi
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x17480
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl $0xd, (%rsi)
movq 0x8(%rdi), %rdi
leaq 0x2190a(%rip), %rdx     # 0x3cb87
pushq $0x28
popq %rsi
callq 0x17480
leaq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x335c4
leaq 0x21909(%rip), %rdx     # 0x3cba1
pushq $0x2c
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0x17480
leaq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x335c4
leaq 0x21900(%rip), %rdx     # 0x3cbb8
movq %rax, %rdi
movl %ebp, %esi
callq 0x17480
addq $0x20, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x335c4
leaq 0x218f0(%rip), %rbx     # 0x3cbc8
pushq $0x29
popq %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x17480
pushq $0x3b
popq %rsi
movq %rax, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x17480
// File: /workspace/github_c_makefile_star2_O2/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 0x1b305
retq
movq $0x1, 0x10(%rdx)
movb $0x1, 0x53(%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x433d1(%rip), %rax     # 0x5e6f8
andq $0x0, (%rsp)
movl (%rax), %r15d
movl (%rdi), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1b368
cmpl $0x28, 0x10(%rbx)
jne 0x1b368
leaq 0x210e3(%rip), %rdx     # 0x3c429
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x327fd
movq %rax, %rbx
movq (%r12), %rdi
testq %rdi, %rdi
je 0x1b368
callq 0xfecd
movq %rax, %r15
leal -0x1(%r15), %eax
testl %eax, %r15d
jne 0x1b380
movslq %r15d, %rax
cmpq %rax, 0x10(%r14)
jae 0x1b391
movq %rax, 0x10(%r14)
jmp 0x1b391
movq (%rbx), %rdi
leaq 0x21854(%rip), %rsi     # 0x3cbde
xorl %eax, %eax
callq 0x1108a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x8(%rsp)
movq (%rdi), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1b3f0
cmpl $0x28, 0x10(%r14)
jne 0x1b3f0
movq %rdx, %rbx
movq 0x8(%r14), %r14
movq (%r14), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpq $0x3, %rax
je 0x1b40e
cmpl $0x12, %eax
jne 0x1b400
cmpl $0x29, 0x10(%r14)
jne 0x1b400
leaq 0x21817(%rip), %rsi     # 0x3cc05
jmp 0x1b407
leaq 0x2180e(%rip), %rsi     # 0x3cc05
xorl %eax, %eax
callq 0x1120e
jmp 0x1b444
leaq 0x2182e(%rip), %rsi     # 0x3cc35
xorl %eax, %eax
callq 0x1120e
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x32929
movq (%r15), %rcx
testq %rcx, %rcx
je 0x1b42f
cmpb $0x3, (%rcx)
jne 0x1b42f
movq %rcx, 0x38(%rbx)
leaq 0x2181d(%rip), %rdx     # 0x3cc53
pushq $0x29
popq %rsi
movq %rax, %rdi
callq 0x17480
movq %rax, %r14
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x8(%rsp)
leaq 0x217c3(%rip), %rdx     # 0x3cc6f
pushq $0x28
popq %rsi
callq 0x17480
movq %rax, %r14
movq (%rax), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x3, %eax
je 0x1b513
cmpl $0x5, %eax
jne 0x1b51d
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x32929
movq %rax, %r15
movq (%r12), %rax
cmpb $0x1, (%rax)
jne 0x1b523
movl 0x20(%rax), %edx
testl %edx, %edx
je 0x1b5a5
leaq 0x217d8(%rip), %rsi     # 0x3cccf
leaq 0x10(%rsp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0xe2d0
movq %r12, %rdi
callq 0x29ad9
movq %rax, %r12
jmp 0x1b537
movq 0x8(%r14), %r15
movq 0x10(%r14), %r12
jmp 0x1b537
movq 0x8(%r14), %r15
jmp 0x1b526
movq (%r14), %rdi
leaq 0x21760(%rip), %rsi     # 0x3cc8d
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x1108a
leaq 0x3f04a(%rip), %rax     # 0x5a588
cmpl $0x0, (%rax)
setne %al
testq %r12, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1b585
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1b581
callq 0x206aa
movq %rax, %r13
movq %r12, %rdi
callq 0x206aa
movq (%r14), %rdi
leaq 0x21734(%rip), %rsi     # 0x3cca8
movq %r13, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1120e
movq %r12, 0x20(%rbx)
leaq 0x216e3(%rip), %rdx     # 0x3cc6f
pushq $0x29
popq %rsi
movq %r15, %rdi
callq 0x17480
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r12d, %r12d
jmp 0x1b537
// File: /workspace/github_c_makefile_star2_O2/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 0x1b5c1
cmpb $0x7, (%rax)
jne 0x1b5c1
orb $0x1, 0x56(%rax)
jmp 0x1b5d2
movq (%rbx), %rdi
leaq 0x2170d(%rip), %rsi     # 0x3ccd8
xorl %eax, %eax
callq 0x1108a
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x45854(%rip), %rax     # 0x60e3c
cmpl $0x0, (%rax)
je 0x1b5fe
movq (%rbx), %rdi
leaq 0x21719(%rip), %rsi     # 0x3cd10
xorl %eax, %eax
callq 0x1108a
movq (%r14), %rax
testq %rax, %rax
je 0x1b611
cmpb $0x8, (%rax)
jne 0x1b611
orb $0x40, 0x56(%rax)
jmp 0x1b622
movq (%rbx), %rdi
leaq 0x21715(%rip), %rsi     # 0x3cd30
xorl %eax, %eax
callq 0x1108a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x21716(%rip), %rdx     # 0x3cd6a
pushq $0x28
popq %rsi
callq 0x17480
movq %rax, %rbx
movq (%rax), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1b6a7
movq 0x10(%rbx), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x18e4b
testq %rax, %rax
je 0x1b688
movq 0x40(%rax), %rax
testb $0x40, (%rax)
jne 0x1b6b7
movq 0x10(%rbx), %rdi
callq 0x2936d
movq (%rbx), %rdi
leaq 0x216e4(%rip), %rsi     # 0x3cd7f
movq %rax, %rdx
xorl %eax, %eax
callq 0x1120e
jmp 0x1b6bb
leaq 0x216eb(%rip), %rsi     # 0x3cd99
xorl %eax, %eax
callq 0x1120e
jmp 0x1b6bf
movq %rax, 0x30(%r14)
movq 0x8(%rbx), %rbx
leaq 0x216a4(%rip), %rdx     # 0x3cd6a
pushq $0x29
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17480
// File: /workspace/github_c_makefile_star2_O2/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 0x3e89d(%rip), %rax     # 0x59f80
je 0x1b6e8
xorl %eax, %eax
retq
leaq 0x49329(%rip), %rax     # 0x64a18
cmpq %rax, %rdi
je 0x1b701
testb $0x40, 0x69(%rdi)
jne 0x1b702
leaq 0x49bd7(%rip), %rax     # 0x652d8
retq
leaq 0x49caf(%rip), %rax     # 0x653b8
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rsp)
movq %rdi, %rax
movl (%rdi), %ecx
andl $0x3f, %ecx
cmpl $0x12, %ecx
jne 0x1b81d
cmpl $0x28, 0x10(%rax)
jne 0x1b81d
leaq 0x20c17(%rip), %rdx     # 0x3c429
movq %rsp, %rsi
movq %rax, %rdi
callq 0x327fd
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b844
leaq 0x22ac5(%rip), %rsi     # 0x3e2f8
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1120e
testb $0x4, %sil
jne 0x1b87f
testb $0x10, %sil
jne 0x1b888
testb $0x20, %sil
jne 0x1b891
testb $0x40, %sil
jne 0x1b89a
testb %sil, %sil
js 0x1b8a3
btl $0x8, %esi
jb 0x1b8ac
btl $0x9, %esi
leaq 0x28703(%rip), %rax     # 0x43f75
leaq 0x2414b(%rip), %r14     # 0x3f9c4
cmovaeq %rax, %r14
jmp 0x1b8b3
leaq 0x24112(%rip), %r14     # 0x3f998
jmp 0x1b8b3
leaq 0x24158(%rip), %r14     # 0x3f9e7
jmp 0x1b8b3
leaq 0x1faf9(%rip), %r14     # 0x3b391
jmp 0x1b8b3
leaq 0x209e0(%rip), %r14     # 0x3c281
jmp 0x1b8b3
leaq 0x285f8(%rip), %r14     # 0x43ea2
jmp 0x1b8b3
leaq 0x240f3(%rip), %r14     # 0x3f9a6
movq %rdx, %rdi
callq 0x2936d
leaq 0x22a05(%rip), %rsi     # 0x3e2c7
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1120e
// File: /workspace/github_c_makefile_star2_O2/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 0x1b907
pushq %rax
movq 0x10(%rdi), %rdi
pushq $0x2
popq %rsi
callq 0x18e4b
testq %rax, %rax
je 0x1b90a
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x1b90a
movb (%rax), %al
andb $0x8, %al
shrb $0x3, %al
jmp 0x1b90c
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c40d
movl 0x50(%rbx), %edx
testb $0x2, %bpl
leaq 0x1d4d3(%rip), %rax     # 0x398cd
leaq 0x228e5(%rip), %rsi     # 0x3ece6
cmoveq %rax, %rsi
movq %r14, %rdi
callq 0x1c533
testb $0x4, %bpl
je 0x1c46a
movq %rbx, %rdi
callq 0x206e2
movq %rax, %r15
movl 0x50(%rbx), %r12d
movq %rbx, %rdi
callq 0x1c57a
subl %r12d, %eax
pushq $-0x1
popq %r12
movl %eax, %ecx
shrq %cl, %r12
leaq 0x228ac(%rip), %rdx     # 0x3ece9
movq %rsp, %r13
pushq $0x20
popq %rsi
movq %r13, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0xe100
leaq 0x2289d(%rip), %rdx     # 0x3ecf4
pushq $0x1
popq %rsi
movq %r13, %rdi
movq %r12, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x1c59c
testb $0x8, %bpl
je 0x1c4cb
movq %rbx, %rdi
callq 0x206e2
movq %rax, %r15
leaq 0x2287a(%rip), %rdx     # 0x3ecfc
movq %rsp, %rdi
pushq $0x20
popq %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0xe100
movq %rbx, %rdi
callq 0x1c57a
testl %eax, %eax
je 0x1c4b4
leaq 0x22862(%rip), %rdi     # 0x3ed07
movq %rsp, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x11481
jmp 0x1c4cb
leaq 0x2286f(%rip), %rdx     # 0x3ed2a
movq %rsp, %rdi
pushq $0x1
popq %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1c59c
testb $0x20, %bpl
je 0x1c4ed
movq %rbx, %rdi
callq 0x206bb
leaq 0x2284e(%rip), %rdi     # 0x3ed2e
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x11481
testb $0x10, %bpl
je 0x1c524
leaq 0x22851(%rip), %rdx     # 0x3ed4b
movq %rsp, %r15
pushq $0x20
popq %rsi
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0xe100
movl 0x50(%rbx), %ecx
leaq 0x1e23a(%rip), %rdx     # 0x3a751
pushq $0x1
popq %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1c59c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/pre-process.c
// Function: 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 0x1c5f8
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 0x29ad9
movq %rax, %rbx
leaq 0x63fd9(%rip), %r14     # 0x805e0
testq %r15, %r15
je 0x1c6b6
cmpb $0x0, (%r15)
je 0x1c6b6
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 0x448fa(%rip), %rdi     # 0x60f40
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdx
callq 0xe0b0
xorl %edi, %edi
callq 0x2a947
movq %rax, %r14
callq 0xe310
movq (%rax), %rcx
movzbl 0x448d4(%rip), %edx     # 0x60f40
movq (%r14), %rax
andq $-0x40, %rax
testb $0x8, 0x1(%rcx,%rdx,2)
jne 0x1c68f
orq $0x3, %rax
movq %rax, (%r14)
leaq 0x448b8(%rip), %rdi     # 0x60f40
callq 0x29ad9
jmp 0x1c6a2
orq $0x5, %rax
movq %rax, (%r14)
leaq 0x448a3(%rip), %rdi     # 0x60f40
callq 0x2a5f8
movq %rax, 0x10(%r14)
orb $0x20, 0x2(%r14)
leaq 0x63f2e(%rip), %rax     # 0x805e0
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 0x1c6df
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq 0x4411a(%rip), %rbx     # 0x61040
testq %rbx, %rbx
je 0x1cf6d
movq %rbx, %r14
xorl %r15d, %r15d
movl (%r14), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jge 0x1cf64
movq 0x18(%r14,%r15,8), %rdi
cmpw $0x100, %ax             # imm = 0x100
jb 0x1cf4d
testq %rdi, %rdi
je 0x1cf5f
callq 0x1cf73
testq %rax, %rax
je 0x1cf5f
movq %rax, %rdi
callq 0x1cf9f
incq %r15
jmp 0x1cf31
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0x1cf2e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/pre-process.c
// Function: lookup_macro
static struct symbol *lookup_macro(struct ident *ident)
{
	struct symbol *sym = lookup_symbol(ident, NS_MACRO | NS_UNDEF);
	if (sym && sym->namespace != NS_MACRO)
		sym = NULL;
	return sym;
}

// Assembly:
pushq %rax
movl $0x81, %esi
callq 0x266e9
testq %rax, %rax
je 0x1cf98
movl $0x1ff00, %edx          # imm = 0x1FF00
andl (%rax), %edx
xorl %ecx, %ecx
cmpl $0x100, %edx            # imm = 0x100
cmoveq %rax, %rcx
jmp 0x1cf9a
xorl %ecx, %ecx
movq %rcx, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rbx
leaq 0x21c2f(%rip), %r13     # 0x3ed78
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
pushq $0x4
popq %r12
cmpq %r14, %r15
je 0x1d200
testq %r15, %r15
je 0x1d202
testq %r14, %r14
je 0x1d202
movl (%r15), %eax
andl $0x3f, %eax
movl (%r14), %ecx
andl $0x3f, %ecx
cmpl %ecx, %eax
jne 0x1d202
addl $-0x3, %eax
cmpl $0x18, %eax
ja 0x1d202
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
leaq 0x10(%r15), %rdi
leaq 0x10(%r14), %rsi
movq %r12, %rdx
jmp 0x1d1cf
movl 0x10(%r15), %ecx
xorl %eax, %eax
cmpl 0x10(%r14), %ecx
setne %al
jmp 0x1d1d4
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 0x1d202
addq $0x4, %rdi
addq $0x4, %rsi
callq 0xe190
testl %eax, %eax
jne 0x1d202
movq 0x8(%r15), %r15
movq 0x8(%r14), %r14
jmp 0x1d152
movq 0x10(%r15), %rcx
xorl %eax, %eax
cmpq 0x10(%r14), %rcx
jmp 0x1d1aa
movq 0x10(%r15), %rdi
movq 0x10(%r14), %rsi
callq 0xe1c0
jmp 0x1d1d4
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/pre-process.c
// Function: 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 0x1d25f
movq %rsi, %rdx
movq %rdi, %r14
movq 0x8(%r15), %rbx
pushq $0x16
popq %rsi
movq %rbx, %rdi
callq 0x1d282
movq (%r15), %rdi
testl %eax, %eax
je 0x1d269
andl $0x200000, %edi         # imm = 0x200000
movq $-0x200001, %rax        # imm = 0xFFDFFFFF
andq (%rbx), %rax
orq %rdi, %rax
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x2a956
movq %rbx, (%r14)
jmp 0x1d279
orb $-0x80, 0x7(%r15)
movq %r15, %rbx
jmp 0x1d279
leaq 0x21c4c(%rip), %rsi     # 0x3eebc
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1120e
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1d35d
movq (%rdi), %rcx
movl %ecx, %r8d
andl $0x3f, %r8d
cmpl $0x3, %r8d
jne 0x1d35d
movq 0x10(%rdi), %r8
xorl %eax, %eax
leaq 0x63332(%rip), %r10     # 0x805e0
xorl %r9d, %r9d
movq 0x8(%rdx), %rdx
cmpq %r10, %rdx
je 0x1d35d
cmpq %r8, 0x10(%rdx)
je 0x1d2cd
incl %r9d
movq 0x8(%rdx), %rdx
jmp 0x1d2b1
movq 0x8(%rdx), %rax
movl %r9d, 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 0x1d304
cmpl $0x15, %esi
jne 0x1d31e
leal 0x1(%rcx), %esi
andl $0x3ff, %esi            # imm = 0x3FF
movl $0xfffffc00, %r8d       # imm = 0xFFFFFC00
movl %esi, %edx
jmp 0x1d336
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 0x1d336
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 0x1d34c
xorl %eax, %eax
btl $0x1e, %ecx
adcl $0x1, %eax
retq
movq (%rdi), %rax
andq $-0x40, %rax
orq $0x2, %rax
movq %rax, (%rdi)
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1d4a1
movq 0x10(%rcx), %r8
cmpq 0x3cade(%rip), %r8      # 0x59f70
jne 0x1d4a1
movq 0x8(%rcx), %rcx
cmpq 0x3ca49(%rip), %rcx     # 0x59ee8
je 0x1d4cd
leaq 0x40f60(%rip), %rcx     # 0x5e408
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)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %rbx
leaq 0x630e2(%rip), %r15     # 0x805e0
leaq 0x4082b(%rip), %r14     # 0x5dd30
movq 0x8(%rbx), %rbx
cmpq %r15, %rbx
je 0x1d53e
movq (%rbx), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x10, %eax
jne 0x1d530
movq 0x10(%rbx), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1f467
jmp 0x1d505
leaq 0x21d8b(%rip), %rsi     # 0x3f2c2
xorl %eax, %eax
callq 0x1108a
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %rbx
leaq 0x6308a(%rip), %r15     # 0x805e0
leaq 0x407cb(%rip), %r14     # 0x5dd28
movq 0x8(%rbx), %rbx
cmpq %r15, %rbx
je 0x1d596
movq (%rbx), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x10, %eax
jne 0x1d588
movq 0x10(%rbx), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1f467
jmp 0x1d55d
leaq 0x21d33(%rip), %rsi     # 0x3f2c2
xorl %eax, %eax
callq 0x1120e
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %rbx
leaq 0x63032(%rip), %r15     # 0x805e0
leaq 0x40783(%rip), %r14     # 0x5dd38
movq 0x8(%rbx), %rbx
cmpq %r15, %rbx
je 0x1d5ee
movq (%rbx), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x10, %eax
jne 0x1d5e0
movq 0x10(%rbx), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1f467
jmp 0x1d5b5
leaq 0x21cdb(%rip), %rsi     # 0x3f2c2
xorl %eax, %eax
callq 0x1120e
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x62fe1(%rip), %rax     # 0x805e0
leaq 0x3fdaa(%rip), %rcx     # 0x5d3b0
movq 0x8(%rdx), %rdx
cmpq %rax, %rdx
je 0x1d653
movq (%rdx), %rdi
movl %edi, %esi
andl $0x3f, %esi
cmpl $0x10, %esi
jne 0x1d645
cmpq $0x0, 0x406dc(%rip)     # 0x5dd00
jne 0x1d658
movq 0x10(%rdx), %rsi
addq $0x4, %rsi
movq %rcx, %rdi
cmpq $0x0, (%rdi)
leaq 0x8(%rdi), %rdi
jne 0x1d631
movq %rsi, -0x8(%rdi)
andq $0x0, (%rdi)
jmp 0x1d606
leaq 0x21c76(%rip), %rsi     # 0x3f2c2
xorl %eax, %eax
callq 0x1120e
pushq $0x1
popq %rax
popq %rcx
retq
leaq 0x21c78(%rip), %rsi     # 0x3f2d7
xorl %eax, %eax
callq 0x1132a
// File: /workspace/github_c_makefile_star2_O2/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 0x1d6b4
callq 0x1f55c
movl %eax, %ebp
jmp 0x1d6ec
cmpl $0x0, 0x2c(%r14)
jne 0x1d6cf
movl $0x1, 0x2c(%r14)
cmpq $0x0, 0x40(%r14)
jne 0x1d6cf
andq $0x0, 0x38(%r14)
pushq $-0x1
popq %rbp
cmpl $0x0, 0x45a8b(%rip)     # 0x63164
jne 0x1d6ec
movq (%rbx), %rdi
leaq 0x21c10(%rip), %rsi     # 0x3f2f5
xorl %eax, %eax
callq 0x1120e
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1f5a6
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1d733
testl %eax, %eax
jne 0x1d727
cmpq $0x0, 0x40(%r14)
je 0x1d77c
callq 0x1f55c
movl %eax, %ebp
xorl $0x1, %ebp
jmp 0x1d768
testl %eax, %eax
jne 0x1d74b
movl $0x1, 0x2c(%r14)
cmpq $0x0, 0x40(%r14)
jne 0x1d74b
andq $0x0, 0x38(%r14)
pushq $-0x1
popq %rbp
cmpl $0x0, 0x45a0f(%rip)     # 0x63164
jne 0x1d768
movq (%rbx), %rdi
leaq 0x21b94(%rip), %rsi     # 0x3f2f5
xorl %eax, %eax
callq 0x1120e
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1f5a6
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x1d799
cmpq 0x10(%rdi), %rax
jne 0x1d727
movq %rbx, 0x40(%r14)
movl $0x1, 0x2c(%r14)
jmp 0x1d727
movq %rbx, 0x40(%r14)
movq 0x10(%rdi), %rax
movq %rax, 0x38(%r14)
jmp 0x1d727
// File: /workspace/github_c_makefile_star2_O2/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 0x1d7ff
testq %rbx, %rbx
je 0x1d817
movl (%rbx), %eax
andl $0x3f, %eax
cmpl $0x1e, %eax
jne 0x1d7e0
movl $0x1, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq (%rdx), %rdi
leaq 0x21b5b(%rip), %rsi     # 0x3f334
xorl %eax, %eax
callq 0x1120e
cmpl $0x0, 0x4597d(%rip)     # 0x63164
je 0x1d838
movq (%rbx), %rax
movl %eax, %ecx
andl $0x3f, %ecx
cmpl $0x1c, %ecx
jne 0x1d845
andl $0x0, 0x45967(%rip)     # 0x63164
jmp 0x1d845
andq $0x0, 0x40(%rdi)
cmpl $0x0, 0x2c(%rdi)
je 0x1d855
cmpq $0x0, 0x38(%rdi)
je 0x1d7b2
andl $0x0, 0x2c(%rdi)
jmp 0x1d7b2
movl $0x1, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq (%rdx), %rdi
leaq 0x21ae7(%rip), %rsi     # 0x3f316
xorl %eax, %eax
callq 0x1120e
jmp 0x1d850
movl $0x1, 0x45922(%rip)     # 0x63164
movq (%rbx), %rax
andq $-0x40, %rax
orq $0x1e, %rax
movq %rax, (%rbx)
pushq $0x1
popq %rax
popq %rbx
retq
andq $0x0, 0x38(%rdi)
jmp 0x1d7b2
// File: /workspace/github_c_makefile_star2_O2/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 0x1d893
pushq %rax
testq %rax, %rax
je 0x1d8ab
movl 0x458ef(%rip), %ecx     # 0x63164
testl %ecx, %ecx
je 0x1d881
decl %ecx
movl %ecx, 0x458e3(%rip)     # 0x63164
movq 0x8(%rax), %rcx
movq %rcx, 0x48(%rdi)
movq %rax, %rdi
callq 0x2a956
jmp 0x1d8ca
andq $0x0, 0x40(%rdi)
cmpl $0x0, 0x2c(%rdi)
je 0x1d8cf
cmpq $0x0, 0x38(%rdi)
je 0x1d869
andl $0x0, 0x2c(%rdi)
jmp 0x1d869
movl $0x1, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq (%rdx), %rdi
leaq 0x21a83(%rip), %rsi     # 0x3f346
xorl %eax, %eax
callq 0x1120e
pushq $0x1
popq %rax
popq %rcx
retq
andq $0x0, 0x38(%rdi)
jmp 0x1d869
// File: /workspace/github_c_makefile_star2_O2/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, 0x4587b(%rip)     # 0x63164
jne 0x1d8f6
leaq 0x8(%rbx), %rdi
callq 0x1f5fe
movl %eax, %edx
cmpl $0x0, 0x2c(%r14)
jne 0x1d911
movl $0x1, 0x2c(%r14)
cmpq $0x0, 0x40(%r14)
jne 0x1d911
andq $0x0, 0x38(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1f5a6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1d952
andq $0x0, 0x40(%rdi)
cmpl $0x0, 0x2c(%rdi)
je 0x1d94b
cmpq $0x0, 0x38(%rdi)
je 0x1d950
andl $0x0, 0x2c(%rdi)
jmp 0x1d950
andq $0x0, 0x38(%rdi)
xorl %ecx, %ecx
pushq %rax
testq %rax, %rax
je 0x1d990
movl (%rax), %esi
andl $0x3f, %esi
cmpl $0x1e, %esi
jne 0x1d9b1
movl $0x1, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq (%rdx), %rdi
leaq 0x21a34(%rip), %rsi     # 0x3f3ae
xorl %eax, %eax
callq 0x1120e
cmpl $0x0, 0x457dc(%rip)     # 0x63164
jne 0x1da12
jmp 0x1d9f5
movl $0x1, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq (%rdx), %rdi
leaq 0x219e8(%rip), %rsi     # 0x3f390
xorl %eax, %eax
callq 0x1120e
jmp 0x1da12
cmpl $0x0, 0x2c(%rdi)
jne 0x1d9c8
movl $0x1, 0x2c(%rdi)
testq %rcx, %rcx
jne 0x1d9c8
andq $0x0, 0x38(%rdi)
movq (%rax), %rcx
movl %ecx, %esi
andl $0x3f, %esi
cmpl $0x1c, %esi
jne 0x1da12
cmpl $0x0, 0x45788(%rip)     # 0x63164
je 0x1da01
andl $0x0, 0x4577f(%rip)     # 0x63164
addq $0x8, %rdx
movq %rdx, %rdi
callq 0x1f5fe
testl %eax, %eax
jne 0x1da12
movl $0x1, 0x45765(%rip)     # 0x63164
jmp 0x1da12
movl $0x1, 0x45759(%rip)     # 0x63164
orq $0x1d, %rcx
movq %rcx, (%rax)
pushq $0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x46a1e(%rip)     # 0x64480
jne 0x1da70
leaq 0x46a15(%rip), %rdi     # 0x64480
callq 0xe1f0
leaq 0x46a09(%rip), %rdi     # 0x64480
callq 0xe050
leaq 0x469ed(%rip), %r14     # 0x64470
leaq 0x21936(%rip), %rdx     # 0x3f3c0
pushq $0xc
popq %rsi
movq %r14, %rdi
movq %rax, %rcx
callq 0xe260
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1f7d9
// File: /workspace/github_c_makefile_star2_O2/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, 0x469c7(%rip)     # 0x64480
jne 0x1dac7
leaq 0x469be(%rip), %rdi     # 0x64480
callq 0xe1f0
leaq 0x469b2(%rip), %rdi     # 0x64480
callq 0xe050
leaq 0x469ae(%rip), %r14     # 0x64488
leaq 0x218e8(%rip), %rdx     # 0x3f3c9
pushq $0x9
popq %rsi
movq %r14, %rdi
movq %rax, %rcx
callq 0xe260
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1f7d9
// File: /workspace/github_c_makefile_star2_O2/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 0x1db65
movq 0x10(%rax), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x266e9
testq %rax, %rax
je 0x1db75
movq 0x40(%rax), %rcx
testq %rcx, %rcx
je 0x1db75
xorl %eax, %eax
cmpq $0x0, 0x40(%rcx)
setne %al
jmp 0x1db77
leaq 0x21860(%rip), %rsi     # 0x3f3cc
xorl %eax, %eax
callq 0x1120e
jmp 0x1db94
xorl %eax, %eax
movq (%rbx), %rcx
andq $-0x40, %rcx
orq $0x5, %rcx
movq %rcx, (%rbx)
leaq 0x34fd4(%rip), %rcx     # 0x52b60
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_O2/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 0x1dbda
movq 0x10(%rax), %rdi
pushq $0x10
popq %rsi
callq 0x266e9
testq %rax, %rax
je 0x1dbea
movl 0x54(%rax), %eax
shrl $0x13, %eax
andl $0x1, %eax
jmp 0x1dbec
leaq 0x217eb(%rip), %rsi     # 0x3f3cc
xorl %eax, %eax
callq 0x1120e
jmp 0x1dc09
xorl %eax, %eax
movq (%rbx), %rcx
andq $-0x40, %rcx
orq $0x5, %rcx
movq %rcx, (%rbx)
leaq 0x34f5f(%rip), %rcx     # 0x52b60
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
cmpl $0x3, %r14d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq