LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: typename
struct token *typename(struct token *token, struct symbol **p, int *forced)
{
	struct decl_state ctx = {.prefer_abstract = 1};
	unsigned long class;
	struct symbol *sym = alloc_symbol(token->pos, SYM_NODE);
	*p = sym;
	token = declaration_specifiers(token, &ctx);
	token = declarator(token, &ctx);
	apply_modifiers(token->pos, &ctx);
	sym->ctype = ctx.ctype;
	sym->endpos = token->pos;
	class = ctx.storage_class;
	if (forced)
		*forced = ctx.forced;
	if (class)
		warning(sym->pos, "storage class in typename (%s%s)",
			modifier_string(class), show_typename(sym));
	return token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, 0x40(%r12)
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq $0x0, 0x50(%r12)
movb $0x1, 0x50(%r12)
movq (%rdi), %rdi
movl $0x3, %esi
callq 0x2b00b
movq %rax, %rbx
movq %rax, (%r14)
movq %r13, %rdi
movq %r12, %rsi
callq 0x19753
movq %rax, %rdi
movq %r12, %rsi
callq 0x199a8
movq %rax, %r14
movq (%rax), %rdi
movq %r12, %rsi
callq 0x1a111
movq 0x20(%r12), %rax
movq %rax, 0x80(%rbx)
movaps (%r12), %xmm0
movaps 0x10(%r12), %xmm1
movups %xmm1, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
movq (%r14), %rax
movq %rax, 0xc(%rbx)
movq 0x48(%r12), %rdi
testq %r15, %r15
je 0x19715
movzbl 0x52(%rsp), %eax
movl %eax, (%r15)
testq %rdi, %rdi
je 0x19742
callq 0x22f8d
movq %rax, %r15
movq %rbx, %rdi
callq 0x237c5
movq 0x4(%rbx), %rdi
leaq 0x2985e(%rip), %rsi     # 0x42f93
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x118fc
movq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: apply_modifiers
static void apply_modifiers(struct position pos, struct decl_state *ctx)
{
	struct symbol *ctype;
	if (!ctx->mode)
		return;
	ctype = ctx->mode->to_mode(ctx->ctype.base_type);
	if (!ctype)
		sparse_error(pos, "don't know how to apply mode to %s",
				show_typename(ctx->ctype.base_type));
	else
		ctx->ctype.base_type = ctype;
	
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x1a132
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq *0x48(%rax)
testq %rax, %rax
je 0x1a13a
movq %rax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rdi
callq 0x237c5
leaq 0x2b27b(%rip), %rsi     # 0x453c4
movq %rbx, %rdi
movq %rax, %rdx
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: check_label_usage
void check_label_usage(struct symbol *label, struct position use_pos)
{
	struct statement *def = label->stmt;

	if (def) {
		if (!is_in_scope(def->label_scope, label_scope))
			warn_label_usage(def->pos, use_pos, label->ident);
	} else if (!label->label_scope) {
		label->label_scope = label_scope;
		label->label_pos = use_pos;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x90(%rdi), %r15
testq %r15, %r15
je 0x1a19d
movq 0x18(%r15), %rdi
leaq 0x50319(%rip), %rax     # 0x6a498
movq (%rax), %rsi
callq 0x22f4b
testl %eax, %eax
jne 0x1a1b6
movq 0x18(%r14), %rdx
movq 0x4(%r15), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1a1bc
cmpq $0x0, 0x48(%r14)
jne 0x1a1b6
leaq 0x502ed(%rip), %rax     # 0x6a498
movq (%rax), %rax
movq %rax, 0x48(%r14)
movq %rbx, 0x50(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: warn_label_usage
static void warn_label_usage(struct position def, struct position use, struct ident *ident)
{
	const char *id = show_ident(ident);
	sparse_error(use, "label '%s' used outside statement expression", id);
	info(def, "   label '%s' defined here", id);
	current_fn->bogus_linear = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x2de35
movq %rax, %r15
leaq 0x2b20e(%rip), %rsi     # 0x453e7
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a80
leaq 0x2b227(%rip), %rsi     # 0x45414
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1178c
leaq 0x75d6f(%rip), %rax     # 0x8ff70
movq (%rax), %rax
orl $0x100, 0x54(%rax)      # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: compound_statement
struct token *compound_statement(struct token *token, struct statement *stmt)
{
	stmt->type = STMT_COMPOUND;
	start_block_scope();
	token = statement_list(token, &stmt->stmts);
	end_block_scope();
	return token;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x3, (%rsi)
callq 0x22d1f
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a248
movq %rax, %rbx
callq 0x22e36
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: statement_list
static struct token * statement_list(struct token *token, struct statement_list **list)
{
	int seen_statement = 0;
	while (token_type(token) == TOKEN_IDENT &&
	       token->ident == &__label___ident)
		token = label_statement(token->next);
	for (;;) {
		struct statement * stmt;
		if (eof_token(token))
			break;
		if (match_op(token, '}'))
			break;
		if (match_ident(token, &_Static_assert_ident)) {
			token = parse_static_assert(token, NULL);
			continue;
		}
		if (lookup_type(token)) {
			if (seen_statement) {
				warning(token->pos, "mixing declarations and code");
				seen_statement = 0;
			}
			stmt = alloc_statement(token->pos, STMT_DECLARATION);
			token = external_declaration(token, &stmt->declaration, NULL);
		} else {
			seen_statement = Wdeclarationafterstatement;
			token = statement(token, &stmt);
		}
		add_statement(list, stmt);
	}
	return token;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1a2fc
leaq 0x4a0b2(%rip), %r13     # 0x64320
leaq 0x49b13(%rip), %rbp     # 0x63d88
leaq 0x2b1d0(%rip), %r15     # 0x4544c
cmpq %r13, 0x10(%r14)
jne 0x1a2fc
movq 0x8(%r14), %r14
movq (%r14), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1a2df
movl $0xc, %esi
callq 0x2b00b
movq %rax, %r12
movq 0x10(%r14), %rsi
movq (%rbp), %rcx
movq %rax, %rdi
movl $0x8, %edx
callq 0x2bd4a
movq 0x4cc74(%rip), %rdi     # 0x66f30
testq %rdi, %rdi
je 0x1a2c9
movq %r12, %rsi
callq 0x227b4
movq 0x8(%r14), %r14
movl (%r14), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1a2df
cmpl $0x2c, 0x10(%r14)
je 0x1a282
movq %r14, %rdi
movl $0x3b, %esi
movq %r15, %rdx
callq 0x1950f
movq %rax, %r14
movl (%rax), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
je 0x1a27c
leaq 0x6c2dd(%rip), %r15     # 0x865e0
cmpq %r15, %r14
je 0x1a3df
leaq 0x49e7d(%rip), %r13     # 0x64190
leaq 0x6c2c6(%rip), %r15     # 0x865e0
xorl %r12d, %r12d
movq (%r14), %rax
andl $0x3f, %eax
cmpq $0x3, %rax
je 0x1a367
cmpl $0x12, %eax
jne 0x1a339
cmpl $0x7d, 0x10(%r14)
je 0x1a3dc
leaq 0x4625c(%rip), %rax     # 0x6059c
movl (%rax), %r12d
movq %r14, %rdi
movq %rsp, %rsi
callq 0x1cbb8
movq %rax, %r14
movq (%rsp), %rbp
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x227b4
cmpq %r15, %r14
jne 0x1a31d
jmp 0x1a3df
movq 0x10(%r14), %rdi
cmpq %r13, %rdi
je 0x1a3cf
movl $0x12, %esi
callq 0x2afd5
testq %rax, %rax
je 0x1a339
testb $0x2, 0x1(%rax)
je 0x1a339
testl %r12d, %r12d
je 0x1a39b
movq (%r14), %rdi
leaq 0x2b09b(%rip), %rsi     # 0x4542f
xorl %eax, %eax
callq 0x118fc
movq (%r14), %r13
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x2fa58
movq %rax, %rbp
movl $0x1, (%rax)
movq %r13, 0x4(%rax)
leaq 0x10(%rax), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1a785
movq %rax, %r14
leaq 0x49dc3(%rip), %r13     # 0x64190
jmp 0x1a355
movq %r14, %rdi
callq 0x1bd79
movq %rax, %r14
jmp 0x1a360
movq %r14, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: handle_asm_name
static struct token *handle_asm_name(struct token *token, struct decl_state *ctx)
{
	struct expression *expr;
	struct symbol *keyword;

	if (token_type(token) != TOKEN_IDENT)
		return token;
	keyword = lookup_keyword(token->ident, NS_KEYWORD);
	if (!keyword)
		return token;
	if (!(keyword->op->type & KW_ASM))
		return token;

	token = token->next;
	token = expect(token, '(', "after asm");
	token = string_expression(token, &expr, "asm name");
	token = expect(token, ')', "after asm");
	return token;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1aec8
movq 0x10(%rbx), %rdi
testb $0x4, 0x11(%rdi)
je 0x1aec8
movl $0x100, %esi            # imm = 0x100
callq 0x2afd5
testq %rax, %rax
je 0x1aec8
movq 0x40(%rax), %rax
testb $0x20, (%rax)
je 0x1aec8
movq 0x8(%rbx), %rdi
leaq 0x28b70(%rip), %rbx     # 0x43a04
movl $0x28, %esi
movq %rbx, %rdx
callq 0x1950f
leaq 0x2a65a(%rip), %rdx     # 0x45502
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x38dc2
movq %rax, %rdi
movl $0x29, %esi
movq %rbx, %rdx
callq 0x1950f
movq %rax, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: storage_specifier
static struct token *storage_specifier(struct token *next, struct symbol *sym, struct decl_state *ctx)
{
	int is_tls = ctx->ctype.modifiers & MOD_TLS;
	unsigned long class = sym->ctype.modifiers;
	const char *storage = modifier_name(class);

	/* __thread can be used alone, or with extern or static */
	if (is_tls && (class & ~(MOD_STATIC|MOD_EXTERN)))
		sparse_error(next->pos, "__thread cannot be used with '%s'", storage);
	else if (!ctx->storage_class)
		ctx->storage_class = class;
	else if (ctx->storage_class == class)
		sparse_error(next->pos, "duplicate %s", storage);
	else
		sparse_error(next->pos, "multiple storage classes");
	return next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
movq 0x68(%rsi), %r14
testb $0x20, 0x8(%rdx)
sete %bpl
movq %r14, %rdi
callq 0x23042
testq $-0xd, %r14
sete %cl
orb %bpl, %cl
je 0x1b590
movq 0x48(%r15), %rcx
testq %rcx, %rcx
je 0x1b5a6
movq (%rbx), %rdi
cmpq %r14, %rcx
jne 0x1b5ac
leaq 0x27d35(%rip), %rsi     # 0x432c3
jmp 0x1b59a
movq (%rbx), %rdi
leaq 0x27d07(%rip), %rsi     # 0x432a1
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a80
jmp 0x1b5ba
movq %r14, 0x48(%r15)
jmp 0x1b5ba
leaq 0x27d1d(%rip), %rsi     # 0x432d0
xorl %eax, %eax
callq 0x11a80
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: thread_specifier
static struct token *thread_specifier(struct token *next, struct symbol *sym, struct decl_state *ctx)
{
	/* This GCC extension can be used alone, or with extern or static */
	if (!(ctx->storage_class & ~(MOD_STATIC|MOD_EXTERN))) {
		apply_qualifier(&next->pos, &ctx->ctype, MOD_TLS);
	} else {
		sparse_error(next->pos, "__thread cannot be used with '%s'",
			modifier_name(ctx->storage_class));
	}

	return next;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdx), %rdi
testq $-0xd, %rdi
je 0x1b5f4
callq 0x23042
movq (%rbx), %rdi
leaq 0x27cb9(%rip), %rsi     # 0x432a1
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a80
jmp 0x1b608
movq %rdx, %rsi
addq $0x8, %rsi
movl $0x20, %edx
movq %rbx, %rdi
callq 0x1b60d
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: typeof_specifier
static struct token *typeof_specifier(struct token *token, struct symbol *sym, struct decl_state *ctx)
{

	if (!match_op(token, '(')) {
		sparse_error(token->pos, "expected '(' after typeof");
		return token;
	}
	if (lookup_type(token->next)) {
		struct symbol *sym;
		token = typename(token->next, &sym, NULL);
		ctx->ctype.base_type = sym->ctype.base_type;
		apply_ctype(token->pos, &ctx->ctype, &sym->ctype);
	} else {
		struct symbol *typeof_sym = alloc_symbol(token->pos, SYM_TYPEOF);
		token = parse_expression(token->next, &typeof_sym->initializer);

		typeof_sym->endpos = token->pos;
		if (!typeof_sym->initializer) {
			sparse_error(token->pos, "expected expression after the '(' token");
			typeof_sym = &bad_ctype;
		}
		ctx->ctype.base_type = typeof_sym;
	}
	return expect(token, ')', "after typeof");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq (%rdi), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1b767
cmpl $0x28, 0x10(%r14)
jne 0x1b767
movq %rdx, %rbx
movq 0x8(%r14), %rax
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x3, %ecx
jne 0x1b6fb
movq 0x10(%rax), %rdi
movl $0x12, %esi
callq 0x2afd5
testq %rax, %rax
je 0x1b6fb
testb $0x2, 0x1(%rax)
jne 0x1b782
movq (%r14), %rdi
movl $0xa, %esi
callq 0x2b00b
movq %rax, %r15
movq 0x8(%r14), %rdi
leaq 0xb0(%rax), %rsi
callq 0x38dbd
movq %rax, %r14
movq (%rax), %rax
movq %rax, 0xc(%r15)
cmpq $0x0, 0xb0(%r15)
jne 0x1b747
movq (%r14), %rdi
leaq 0x27be2(%rip), %rsi     # 0x4331b
xorl %eax, %eax
callq 0x11a80
leaq 0x51171(%rip), %r15     # 0x6c8b8
movq %r15, (%rbx)
leaq 0x27bbd(%rip), %rdx     # 0x4330e
movq %r14, %rdi
movl $0x29, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1950f
leaq 0x27b93(%rip), %rsi     # 0x43301
xorl %eax, %eax
callq 0x11a80
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x1965e
movq %rax, %r14
movq (%r15), %rdx
movq 0x60(%rdx), %rax
addq $0x60, %rdx
movq %rax, (%rbx)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1b7b3
jmp 0x1b74a
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: apply_ctype
static void apply_ctype(struct position pos, struct ctype *dst, struct ctype *src)
{
	unsigned long mod = src->modifiers;

	if (mod)
		apply_qualifier(&pos, dst, mod);

	/* Context */
	concat_ptr_list((struct ptr_list *)src->contexts,
	                (struct ptr_list **)&dst->contexts);

	/* Alignment */
	if (src->alignment > dst->alignment)
		dst->alignment = src->alignment;

	/* Address space */
	if (src->as)
		dst->as = src->as;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, (%rsp)
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
je 0x1b7d6
leaq 0x8(%rbx), %rsi
movq %rsp, %rdi
callq 0x1b60d
movq 0x18(%r14), %rdi
leaq 0x18(%rbx), %rsi
callq 0x22b14
movq 0x10(%r14), %rax
cmpq 0x10(%rbx), %rax
jbe 0x1b7f1
movq %rax, 0x10(%rbx)
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x1b7fe
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: alignas_specifier
static struct token *alignas_specifier(struct token *token, struct symbol *sym, struct decl_state *ctx)
{
	int alignment = 0;

	if (!match_op(token, '(')) {
		sparse_error(token->pos, "expected '(' after _Alignas");
		return token;
	}
	if (lookup_type(token->next)) {
		struct symbol *sym = NULL;
		token = typename(token->next, &sym, NULL);
		sym = examine_symbol_type(sym);
		alignment = sym->ctype.alignment;
		token = expect(token, ')', "after _Alignas(...");
	} else {
		struct expression *expr = NULL;
		token = parens_expression(token, &expr, "after _Alignas");
		if (!expr)
			return token;
		alignment = const_expression_value(expr);
	}

	if (alignment < 0) {
		warning(token->pos, "non-positive alignment");
		return token;
	}
	if (alignment & (alignment-1)) {
		warning(token->pos, "non-power-of-2 alignment");
		return token;
	}
	if (alignment > ctx->ctype.alignment)
		ctx->ctype.alignment = alignment;
	return token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1b894
cmpl $0x28, 0x10(%rbx)
jne 0x1b894
movq %rdx, %r14
movq 0x8(%rbx), %rax
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x3, %ecx
jne 0x1b861
movq 0x10(%rax), %rdi
movl $0x12, %esi
callq 0x2afd5
testq %rax, %rax
je 0x1b861
testb $0x2, 0x1(%rax)
jne 0x1b8af
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
leaq 0x27adc(%rip), %rdx     # 0x43350
movq %rbx, %rdi
movq %r15, %rsi
callq 0x38cf5
movq %rax, %rbx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1b8a2
callq 0xf4b5
movq %rax, %r15
jmp 0x1b8ef
leaq 0x27aa8(%rip), %rsi     # 0x43343
xorl %eax, %eax
callq 0x11a80
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq 0x8(%rbx), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1965e
movq %rax, %rbx
movq (%r15), %rdi
callq 0x2b0b8
movq 0x70(%rax), %r15
leaq 0x27a80(%rip), %rdx     # 0x4335f
movq %rbx, %rdi
movl $0x29, %esi
callq 0x1950f
movq %rax, %rbx
testl %r15d, %r15d
js 0x1b910
leal -0x1(%r15), %eax
testl %eax, %r15d
jne 0x1b91c
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
cmpq %r15, 0x10(%r14)
jae 0x1b8a2
movq %r15, 0x10(%r14)
jmp 0x1b8a2
movq (%rbx), %rdi
leaq 0x27a58(%rip), %rsi     # 0x43372
jmp 0x1b926
movq (%rbx), %rdi
leaq 0x27a63(%rip), %rsi     # 0x43389
xorl %eax, %eax
callq 0x118fc
jmp 0x1b8a2
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: attribute_specifier
static struct token *attribute_specifier(struct token *token, struct symbol *sym, struct decl_state *ctx)
{
	token = expect(token, '(', "after attribute");
	token = expect(token, '(', "after attribute");

	while (token_type(token) == TOKEN_IDENT) {
		struct symbol *attr = lookup_keyword(token->ident, NS_KEYWORD);
		if (attr && attr->op->attribute)
			token = attr->op->attribute(token->next, attr, ctx);
		else
			token = recover_unknown_attribute(token);

		if (!match_op(token, ','))
			break;
		token = token->next;
	}

	token = expect(token, ')', "after attribute");
	token = expect(token, ')', "after attribute");
	return token;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
leaq 0x27a5b(%rip), %r14     # 0x433a2
movl $0x28, %esi
movq %r14, %rdx
callq 0x1950f
movq %rax, %rdi
movl $0x28, %esi
movq %r14, %rdx
callq 0x1950f
movq %rax, %r14
movl (%rax), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1ba34
leaq 0x4b4d4(%rip), %rbp     # 0x66e50
leaq 0x27a46(%rip), %r15     # 0x433c9
movq %rsp, %r12
leaq 0x27a25(%rip), %r13     # 0x433b2
movq 0x10(%r14), %rdi
testb $0x4, 0x11(%rdi)
je 0x1b9c1
movl $0x100, %esi            # imm = 0x100
callq 0x2afd5
testq %rax, %rax
je 0x1b9c1
movq 0x40(%rax), %rcx
movq 0x40(%rcx), %rcx
testq %rcx, %rcx
je 0x1b9c1
movq 0x8(%r14), %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq *%rcx
jmp 0x1ba0c
movq $0x0, (%rsp)
cmpl $0x0, (%rbp)
je 0x1b9e8
movq 0x10(%r14), %rdi
callq 0x2de35
movq (%r14), %rdi
movq %r13, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x118fc
movq 0x8(%r14), %r14
movl (%r14), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1ba0f
cmpl $0x28, 0x10(%r14)
jne 0x1ba0f
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x38cf5
movq %rax, %r14
movl (%r14), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1ba34
cmpl $0x2c, 0x10(%r14)
jne 0x1ba34
movq 0x8(%r14), %r14
movl (%r14), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
je 0x1b98d
leaq 0x27967(%rip), %rbx     # 0x433a2
movq %r14, %rdi
movl $0x29, %esi
movq %rbx, %rdx
callq 0x1950f
movq %rax, %rdi
movl $0x29, %esi
movq %rbx, %rdx
callq 0x1950f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: parse_struct_declaration
static struct token *parse_struct_declaration(struct token *token, struct symbol *sym)
{
	struct symbol *field, *last = NULL;
	struct token *res;
	res = struct_declaration_list(token, &sym->symbol_list);
	FOR_EACH_PTR(sym->symbol_list, field) {
		if (!field->ident) {
			struct symbol *base = field->ctype.base_type;
			if (base && base->type == SYM_BITFIELD)
				continue;
		}
		if (last)
			last->next_subobject = field;
		last = field;
	} END_FOR_EACH_PTR(field);
	return res;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
addq $0x98, %rsi
callq 0x1bcf4
movq 0x98(%rbx), %rcx
testq %rcx, %rcx
je 0x1bcf2
xorl %r9d, %r9d
movq %rcx, %rdx
movzwl (%rdx), %esi
testb %sil, %sil
jle 0x1bce3
xorl %edi, %edi
movq 0x18(%rdx,%rdi,8), %r8
movzwl %si, %r10d
cmpl $0x100, %r10d           # imm = 0x100
jb 0x1bcaa
testq %r8, %r8
jne 0x1bcaa
movq %r9, %r8
jmp 0x1bcbd
cmpq $0x0, 0x18(%r8)
je 0x1bcd2
testq %r9, %r9
je 0x1bcbd
movq %r8, 0x38(%r9)
movzwl (%rdx), %esi
incq %rdi
movzwl %si, %r9d
movsbq %r9b, %r10
movq %r8, %r9
cmpq %r10, %rdi
jl 0x1bc8e
jmp 0x1bce6
movq 0x60(%r8), %r10
testq %r10, %r10
je 0x1bcb1
cmpb $0xb, (%r10)
je 0x1bca5
jmp 0x1bcb1
movq %r9, %r8
movq 0x10(%rdx), %rdx
movq %r8, %r9
cmpq %rcx, %rdx
jne 0x1bc84
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: struct_declaration_list
static struct token *struct_declaration_list(struct token *token, struct symbol_list **list)
{
	while (!match_op(token, '}')) {
		if (match_ident(token, &_Static_assert_ident)) {
			token = parse_static_assert(token, NULL);
			continue;
		}
		if (!match_op(token, ';'))
			token = declaration_list(token, list);
		if (!match_op(token, ';')) {
			sparse_error(token->pos, "expected ; at end of declaration");
			break;
		}
		token = token->next;
	}
	return token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4848a(%rip), %r15     # 0x64190
movq (%rbx), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpq $0x3, %rax
je 0x1bd28
cmpl $0x12, %eax
jne 0x1bd2e
movl 0x10(%rbx), %eax
cmpl $0x3b, %eax
je 0x1bd3f
cmpl $0x7d, %eax
jne 0x1bd2e
jmp 0x1bd70
cmpq %r15, 0x10(%rbx)
je 0x1bd55
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1be95
movq %rax, %rbx
movq (%rax), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1bd62
cmpl $0x3b, 0x10(%rbx)
jne 0x1bd62
movq 0x8(%rbx), %rbx
jmp 0x1bd06
movq %rbx, %rdi
callq 0x1bd79
movq %rax, %rbx
jmp 0x1bd06
leaq 0x276c3(%rip), %rsi     # 0x4342c
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/parse.c
// Function: parse_static_assert
static struct token *parse_static_assert(struct token *token, struct symbol_list **unused)
{
	struct expression *cond = NULL, *message = NULL;

	token = expect(token->next, '(', "after _Static_assert");
	token = constant_expression(token, &cond);
	if (!cond)
		sparse_error(token->pos, "Expected constant expression");
	if (match_op(token, ',')) {
		token = token->next;
		token = string_expression(token, &message, "_Static_assert()");
		if (!message)
			cond = NULL;
	}
	token = expect(token, ')', "after diagnostic message in _Static_assert");
	token = expect(token, ';', "after _Static_assert()");

	if (cond && !const_expression_value(cond) && cond->type == EXPR_VALUE) {
		const char *sep = "", *msg = "";

		if (message) {
			sep = ": ";
			msg = show_string(message->string);
		}
		sparse_error(cond->pos, "static assertion failed%s%s", sep, msg);
	}

	return token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
xorl %r15d, %r15d
movq %rsp, %r14
movq %r15, (%r14)
movq %r15, 0x8(%rsp)
movq 0x8(%rdi), %rdi
leaq 0x276b2(%rip), %rdx     # 0x4344d
movl $0x28, %esi
callq 0x1950f
movq %rax, %rdi
movq %r14, %rsi
callq 0x39b4c
movq %rax, %rbx
cmpq %r15, (%r14)
jne 0x1bdc9
movq (%rbx), %rdi
leaq 0x276a0(%rip), %rsi     # 0x43462
xorl %eax, %eax
callq 0x11a80
movl (%rbx), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1be02
cmpl $0x2c, 0x10(%rbx)
jne 0x1be02
movq 0x8(%rbx), %rdi
leaq 0x276cc(%rip), %rdx     # 0x434b0
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x38dc2
movq %rax, %rbx
cmpq $0x0, (%r14)
jne 0x1be02
movq $0x0, (%rsp)
leaq 0x27676(%rip), %rdx     # 0x4347f
movq %rbx, %rdi
movl $0x29, %esi
callq 0x1950f
leaq 0x2768d(%rip), %rdx     # 0x434aa
movq %rax, %rdi
movl $0x3b, %esi
callq 0x1950f
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1be88
callq 0xf4b5
testq %rax, %rax
jne 0x1be88
movq (%rsp), %rax
cmpb $0x1, (%rax)
jne 0x1be88
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x1be6c
movq 0x28(%rcx), %rdi
callq 0x2de83
movq %rax, %rcx
leaq 0x26265(%rip), %rdx     # 0x420cb
movq (%rsp), %rax
jmp 0x1be76
leaq 0x24a5a(%rip), %rdx     # 0x408cd
movq %rdx, %rcx
movq 0x8(%rax), %rdi
leaq 0x27640(%rip), %rsi     # 0x434c1
xorl %eax, %eax
callq 0x11a80
movq %rbx, %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: enum_specifier
static struct token *enum_specifier(struct token *token, struct symbol *sym, struct decl_state *ctx)
{
	struct token *ret = struct_union_enum_specifier(SYM_ENUM, token, ctx, parse_enum_declaration);
	struct ctype *ctype = &ctx->ctype.base_type->ctype;

	if (!ctype->base_type)
		ctype->base_type = &incomplete_ctype;

	return ret;
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
movq %rdi, %rsi
leaq 0x21(%rip), %rcx        # 0x1c24f
movl $0x9, %edi
callq 0x1ba7b
movq (%rbx), %rcx
cmpq $0x0, 0x60(%rcx)
jne 0x1c24d
leaq 0x504af(%rip), %rdx     # 0x6c6f8
movq %rdx, 0x60(%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: parse_if_statement
static struct token *parse_if_statement(struct token *token, struct statement *stmt)
{
	stmt->type = STMT_IF;
	token = parens_expression(token->next, &stmt->if_conditional, "after if");
	token = statement(token, &stmt->if_true);
	if (token_type(token) != TOKEN_IDENT)
		return token;
	if (token->ident != &else_ident)
		return token;
	return statement(token->next, &stmt->if_false);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl $0x4, (%rsi)
movq 0x8(%rdi), %rdi
addq $0x10, %rsi
leaq 0x26c70(%rip), %rdx     # 0x437f0
callq 0x38cf5
leaq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x1cbb8
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x3, %ecx
jne 0x1cba8
movq 0x10(%rax), %rcx
cmpq 0x433fa(%rip), %rcx     # 0x5ffa0
je 0x1cbaa
popq %rbx
retq
movq 0x8(%rax), %rdi
addq $0x20, %rbx
movq %rbx, %rsi
popq %rbx
jmp 0x1cbb8
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: parse_return_statement
static struct token *parse_return_statement(struct token *token, struct statement *stmt)
{
	struct symbol *target = lookup_symbol(&return_ident, NS_ITERATOR);

	if (!target)
		error_die(token->pos, "internal error: return without a function target");
	stmt->type = STMT_RETURN;
	stmt->ret_target = target;
	return expression_statement(token->next, &stmt->ret_value);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x46fef(%rip), %rdi     # 0x63df8
movl $0x20, %esi
callq 0x2afd5
testq %rax, %rax
je 0x1ce4d
movl $0x5, (%rbx)
movq %rax, 0x18(%rbx)
addq $0x10, %rbx
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x38dbd
leaq 0x26a11(%rip), %rdx     # 0x4384a
movq %rax, %rdi
movl $0x3b, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1950f
movq (%r14), %rdi
leaq 0x26a07(%rip), %rsi     # 0x4385e
xorl %eax, %eax
callq 0x11b9c
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: parse_loop_iterator
static struct token *parse_loop_iterator(struct token *token, struct statement *stmt)
{
	struct symbol *target = lookup_symbol(token->ident, NS_ITERATOR);
	stmt->type = STMT_GOTO;
	stmt->goto_label = target;
	if (!target)
		sparse_error(stmt->pos, "break/continue not in iterator scope");
	return expect(token->next, ';', "at end of statement");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movl $0x20, %esi
callq 0x2afd5
movl $0xa, (%r14)
movq %rax, 0x10(%r14)
testq %rax, %rax
jne 0x1ce98
movq 0x4(%r14), %rdi
leaq 0x269fe(%rip), %rsi     # 0x4388f
xorl %eax, %eax
callq 0x11a80
movq 0x8(%rbx), %rdi
leaq 0x269a7(%rip), %rdx     # 0x4384a
movl $0x3b, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1950f
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: case_statement
static inline struct token *case_statement(struct token *token, struct statement *stmt)
{
	stmt->type = STMT_CASE;
	token = expect(token, ':', "after default/case");
	add_case_statement(stmt);
	if (match_op(token, '}')) {
		warning(token->pos, "statement expected after case label");
		stmt->case_statement = alloc_statement(token->pos, STMT_NONE);
		return token;
	}
	return statement(token, &stmt->case_statement);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl $0x6, (%rsi)
leaq 0x269e2(%rip), %rdx     # 0x438b4
movl $0x3a, %esi
callq 0x1950f
movq %rax, %r14
leaq 0x46f52(%rip), %rdi     # 0x63e38
movl $0x20, %esi
callq 0x2afd5
movq 0x4(%rbx), %rdi
testq %rax, %rax
je 0x1cf3c
movq %rax, %r12
movl $0x3, %esi
callq 0x2b00b
movq %rax, %r15
addq $0x98, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x227b4
movq %rbx, 0x90(%r15)
movq %r15, 0x28(%rbx)
movq 0x4a003(%rip), %rdi     # 0x66f30
testq %rdi, %rdi
je 0x1cf50
movq %r15, %rsi
callq 0x227b4
jmp 0x1cf50
leaq 0x269a8(%rip), %rsi     # 0x438eb
xorl %eax, %eax
callq 0x11a80
movl $0x0, (%rbx)
movq (%r14), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1cf99
cmpl $0x7d, 0x10(%r14)
jne 0x1cf99
leaq 0x2695c(%rip), %rsi     # 0x438c7
xorl %eax, %eax
callq 0x118fc
movq (%r14), %r15
xorl %edi, %edi
callq 0x2fa58
movl $0x0, (%rax)
movq %r15, 0x4(%rax)
movq %rax, 0x20(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addq $0x20, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1cbb8
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: parse_case_statement
static struct token *parse_case_statement(struct token *token, struct statement *stmt)
{
	token = parse_expression(token->next, &stmt->case_expression);
	if (match_op(token, SPECIAL_ELLIPSIS))
		token = parse_expression(token->next, &stmt->case_to);
	return case_statement(token, stmt);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rdi), %rdi
addq $0x10, %rsi
callq 0x38dbd
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x12, %ecx
jne 0x1cfe4
cmpl $0x117, 0x10(%rax)      # imm = 0x117
jne 0x1cfe4
movq 0x8(%rax), %rdi
leaq 0x18(%rbx), %rsi
callq 0x38dbd
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1ceba
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: parse_switch_statement
static struct token *parse_switch_statement(struct token *token, struct statement *stmt)
{
	stmt->type = STMT_SWITCH;
	start_switch(stmt);
	token = parens_expression(token->next, &stmt->switch_expression, "after 'switch'");
	token = statement(token, &stmt->switch_statement);
	end_switch(stmt);
	return token;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x7, %ebp
movl %ebp, (%rsi)
callq 0x22d1f
movq 0x4(%rbx), %rdi
movl $0x3, %esi
callq 0x2b00b
movq %rax, %r15
leaq 0x46e4e(%rip), %rsi     # 0x63e70
movq %rax, %rdi
movl $0x20, %edx
callq 0x2beca
movq 0x4(%rbx), %rdi
movl $0x3, %esi
callq 0x2b00b
movq %rax, %r12
leaq 0x46df1(%rip), %rsi     # 0x63e38
movq %rax, %rdi
movl $0x20, %edx
callq 0x2beca
movq %rbx, 0x90(%r12)
movl %ebp, (%rbx)
movq %r15, 0x20(%rbx)
movq %r12, 0x28(%rbx)
movq 0x49ec3(%rip), %rdi     # 0x66f30
testq %rdi, %rdi
je 0x1d08e
movq %r15, %rsi
callq 0x227b4
movq 0x49eaf(%rip), %rdi     # 0x66f30
testq %rdi, %rdi
je 0x1d08e
movq %r12, %rsi
callq 0x227b4
movq 0x8(%r14), %rdi
leaq 0x10(%rbx), %rsi
leaq 0x26862(%rip), %rdx     # 0x438ff
callq 0x38cf5
leaq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x1cbb8
movq %rax, %r14
movq 0x28(%rbx), %rax
cmpq $0x0, 0x98(%rax)
jne 0x1d0d1
movq 0x4(%rbx), %rdi
leaq 0x26844(%rip), %rsi     # 0x4390e
xorl %eax, %eax
callq 0x118fc
callq 0x22e36
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: parse_for_statement
static struct token *parse_for_statement(struct token *token, struct statement *stmt)
{
	struct symbol_list *syms;
	struct expression *e1, *e2, *e3;
	struct statement *iterator;

	start_iterator(stmt);
	token = expect(token->next, '(', "after 'for'");

	syms = NULL;
	e1 = NULL;
	/* C99 variable declaration? */
	if (lookup_type(token)) {
		token = external_declaration(token, &syms, validate_for_loop_decl);
	} else {
		token = parse_expression(token, &e1);
		token = expect(token, ';', "in 'for'");
	}
	token = parse_expression(token, &e2);
	token = expect(token, ';', "in 'for'");
	token = parse_expression(token, &e3);
	token = expect(token, ')', "in 'for'");
	token = statement(token, &iterator);

	stmt->iterator_syms = syms;
	stmt->iterator_pre_statement = make_statement(e1);
	stmt->iterator_pre_condition = e2;
	stmt->iterator_post_statement = make_statement(e3);
	stmt->iterator_post_condition = NULL;
	stmt->iterator_statement = iterator;
	end_iterator(stmt);

	return token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1d25b
movq 0x8(%r14), %rdi
leaq 0x2681d(%rip), %rdx     # 0x43923
movl $0x28, %esi
callq 0x1950f
movq %rax, %r14
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
movl (%r14), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1d146
movq 0x10(%r14), %rdi
movl $0x12, %esi
callq 0x2afd5
testq %rax, %rax
je 0x1d146
testb $0x2, 0x1(%rax)
jne 0x1d242
movq %rsp, %rsi
movq %r14, %rdi
callq 0x38dbd
leaq 0x267d7(%rip), %rdx     # 0x4392f
movq %rax, %rdi
movl $0x3b, %esi
callq 0x1950f
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x38dbd
leaq 0x267b6(%rip), %r14     # 0x4392f
movq %rax, %rdi
movl $0x3b, %esi
movq %r14, %rdx
callq 0x1950f
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x38dbd
movq %rax, %rdi
movl $0x29, %esi
movq %r14, %rdx
callq 0x1950f
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1cbb8
movq %rax, %r14
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rbx)
movq (%rsp), %r15
testq %r15, %r15
je 0x1d1e3
movq 0x8(%r15), %r12
xorl %edi, %edi
callq 0x2fa58
movl $0x2, (%rax)
movq %r12, 0x4(%rax)
movq %r15, 0x10(%rax)
jmp 0x1d1e5
xorl %eax, %eax
movq %rax, 0x28(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rbx)
movq 0x18(%rsp), %r15
testq %r15, %r15
je 0x1d217
movq 0x8(%r15), %r12
xorl %edi, %edi
callq 0x2fa58
movl $0x2, (%rax)
movq %r12, 0x4(%rax)
movq %r15, 0x10(%rax)
jmp 0x1d219
xorl %eax, %eax
movq %rax, 0x40(%rbx)
movq $0x0, 0x48(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rbx)
callq 0x22e36
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xab(%rip), %rdx        # 0x1d2f4
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1a785
jmp 0x1d165
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: start_iterator
static void start_iterator(struct statement *stmt)
{
	struct symbol *cont, *brk;

	start_block_scope();
	cont = alloc_symbol(stmt->pos, SYM_NODE);
	bind_symbol(cont, &continue_ident, NS_ITERATOR);
	brk = alloc_symbol(stmt->pos, SYM_NODE);
	bind_symbol(brk, &break_ident, NS_ITERATOR);

	stmt->type = STMT_ITERATOR;
	stmt->iterator_break = brk;
	stmt->iterator_continue = cont;
	fn_local_symbol(brk);
	fn_local_symbol(cont);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x22d1f
movq 0x4(%r14), %rdi
movl $0x3, %esi
callq 0x2b00b
movq %rax, %rbx
leaq 0x46c08(%rip), %rsi     # 0x63e88
movq %rax, %rdi
movl $0x20, %edx
callq 0x2beca
movq 0x4(%r14), %rdi
movl $0x3, %esi
callq 0x2b00b
movq %rax, %r15
leaq 0x46bcb(%rip), %rsi     # 0x63e70
movq %rax, %rdi
movl $0x20, %edx
callq 0x2beca
movl $0x8, (%r14)
movq %r15, 0x10(%r14)
movq %rbx, 0x18(%r14)
movq 0x49c68(%rip), %rdi     # 0x66f30
testq %rdi, %rdi
je 0x1d2ee
movq %r15, %rsi
callq 0x227b4
movq 0x49c54(%rip), %rdi     # 0x66f30
testq %rdi, %rdi
je 0x1d2ee
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x227b4
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: validate_for_loop_decl
static void validate_for_loop_decl(struct symbol *sym)
{
	unsigned long storage = sym->ctype.modifiers & MOD_STORAGE;

	if (storage & ~(MOD_AUTO | MOD_REGISTER)) {
		const char *name = show_ident(sym->ident);
		sparse_error(sym->pos, "non-local var '%s' in for-loop initializer", name);
		sym->ctype.modifiers &= ~MOD_STORAGE;
	}
}

// Assembly:
testb $0x5c, 0x68(%rdi)
je 0x1d321
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x2de35
movq 0x4(%rbx), %rdi
leaq 0x26626(%rip), %rsi     # 0x43938
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a80
andb $-0x60, 0x68(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: parse_while_statement
static struct token *parse_while_statement(struct token *token, struct statement *stmt)
{
	struct expression *expr;
	struct statement *iterator;

	start_iterator(stmt);
	token = parens_expression(token->next, &expr, "after 'while'");
	token = statement(token, &iterator);

	stmt->iterator_pre_condition = expr;
	stmt->iterator_post_condition = NULL;
	stmt->iterator_statement = iterator;
	end_iterator(stmt);

	return token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1d25b
movq 0x8(%r14), %rdi
leaq 0x2661d(%rip), %rdx     # 0x43963
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x38cf5
leaq 0x8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x1cbb8
movq %rax, %r12
movq (%r14), %rax
movq %rax, 0x30(%rbx)
movq $0x0, 0x48(%rbx)
movq (%r15), %rax
movq %rax, 0x38(%rbx)
callq 0x22e36
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: parse_do_statement
static struct token *parse_do_statement(struct token *token, struct statement *stmt)
{
	struct expression *expr;
	struct statement *iterator;

	start_iterator(stmt);
	token = statement(token->next, &iterator);
	if (token_type(token) == TOKEN_IDENT && token->ident == &while_ident)
		token = token->next;
	else
		sparse_error(token->pos, "expected 'while' after 'do'");
	token = parens_expression(token, &expr, "after 'do-while'");

	stmt->iterator_post_condition = expr;
	stmt->iterator_statement = iterator;
	end_iterator(stmt);

	if (iterator && iterator->type != STMT_COMPOUND && Wdo_while)
		warning(iterator->pos, "do-while statement is not a compound statement");

	return expect(token, ';', "after statement");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1d25b
movq 0x8(%r14), %rdi
movq %rsp, %rsi
callq 0x1cbb8
movq %rax, %r14
movq (%rax), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1d3d4
movq 0x10(%r14), %rax
cmpq 0x42bc2(%rip), %rax     # 0x5ff90
je 0x1d457
leaq 0x26596(%rip), %rsi     # 0x43971
xorl %eax, %eax
callq 0x11a80
leaq 0x265a4(%rip), %rdx     # 0x4398d
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x38cf5
movq %rax, %r14
movq (%r15), %rax
movq %rax, 0x48(%rbx)
movq (%rsp), %r15
movq %r15, 0x38(%rbx)
callq 0x22e36
testq %r15, %r15
je 0x1d439
cmpl $0x3, (%r15)
je 0x1d439
leaq 0x499da(%rip), %rax     # 0x66dfc
cmpl $0x0, (%rax)
je 0x1d439
movq 0x4(%r15), %rdi
leaq 0x2656c(%rip), %rsi     # 0x4399e
xorl %eax, %eax
callq 0x118fc
leaq 0x2658d(%rip), %rdx     # 0x439cd
movq %r14, %rdi
movl $0x3b, %esi
callq 0x1950f
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r14), %r14
jmp 0x1d3e2
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: parse_goto_statement
static struct token *parse_goto_statement(struct token *token, struct statement *stmt)
{
	stmt->type = STMT_GOTO;
	token = token->next;
	if (match_op(token, '*')) {
		token = parse_expression(token->next, &stmt->goto_expression);
		add_statement(&function_computed_goto_list, stmt);
	} else if (token_type(token) == TOKEN_IDENT) {
		struct symbol *label = label_symbol(token, 1);
		stmt->goto_label = label;
		check_label_usage(label, stmt->pos);
		token = token->next;
	} else {
		sparse_error(token->pos, "Expected identifier or goto expression");
	}
	return expect(token, ';', "at end of statement");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl $0xa, (%rsi)
movq 0x8(%rdi), %rbx
movq (%rbx), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpq $0x3, %rax
je 0x1d4b8
cmpl $0x12, %eax
jne 0x1d4a8
cmpl $0x2a, 0x10(%rbx)
jne 0x1d4a8
movq 0x8(%rbx), %rdi
leaq 0x18(%r14), %rsi
callq 0x38dbd
movq %rax, %rbx
leaq 0x49a8a(%rip), %rdi     # 0x66f28
movq %r14, %rsi
callq 0x227b4
jmp 0x1d4d9
leaq 0x2652e(%rip), %rsi     # 0x439dd
xorl %eax, %eax
callq 0x11a80
jmp 0x1d4d9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x195dd
movq %rax, 0x10(%r14)
movq 0x4(%r14), %rsi
movq %rax, %rdi
callq 0x1a15d
movq 0x8(%rbx), %rbx
leaq 0x2636a(%rip), %rdx     # 0x4384a
movq %rbx, %rdi
movl $0x3b, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1950f
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: toplevel_asm_declaration
static struct token *toplevel_asm_declaration(struct token *token, struct symbol_list **list)
{
	struct symbol *anon = alloc_symbol(token->pos, SYM_NODE);
	struct symbol *fn = alloc_symbol(token->pos, SYM_FN);
	struct statement *stmt;

	anon->ctype.base_type = fn;
	stmt = alloc_statement(token->pos, STMT_NONE);
	fn->stmt = stmt;

	token = parse_asm_statement(token, stmt);

	// FIXME: add_symbol(list, anon);
	return token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x3, %esi
callq 0x2b00b
movq %rax, %r14
movq (%rbx), %rdi
movl $0x5, %esi
callq 0x2b00b
movq %rax, %r15
movq %rax, 0x60(%r14)
movq (%rbx), %r14
xorl %edi, %edi
callq 0x2fa58
movl $0x0, (%rax)
movq %r14, 0x4(%rax)
movq %rax, 0x90(%r15)
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1d4f4
// File: /workspace/github_c_makefile_star2_O3/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 0x1d778
movl 0x10(%r12), %eax
cmpl $0x29, %eax
je 0x1d827
cmpl $0x3a, %eax
je 0x1d827
leaq 0x262a7(%rip), %r14     # 0x43a26
leaq 0x262af(%rip), %r15     # 0x43a35
movq %rdi, %r12
xorl %edi, %edi
callq 0x2f992
movq %rax, %r13
movq 0x8(%r12), %rdi
movl (%rdi), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1d7e3
cmpl $0x5b, 0x10(%rdi)
jne 0x1d7e3
movq 0x8(%rdi), %rax
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x3, %ecx
jne 0x1d7e3
movq 0x8(%rax), %rcx
movl (%rcx), %edx
andl $0x3f, %edx
cmpl $0x12, %edx
jne 0x1d7e3
cmpl $0x5d, 0x10(%rcx)
jne 0x1d7e3
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 0x38dc2
movq %r13, %rsi
addq $0x10, %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x38cf5
movq %rax, %r12
movq %rbx, %rdi
movq %r13, %rsi
callq 0x227b4
movl (%r12), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1d827
cmpl $0x2c, 0x10(%r12)
je 0x1d789
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2b004
movq %rax, %r14
leaq 0x261f2(%rip), %rdx     # 0x43a46
movq %r15, %rdi
movl $0x28, %esi
callq 0x1950f
movq %rsp, %rsi
movq %rax, %rdi
callq 0x39b4c
leaq 0x261eb(%rip), %rdx     # 0x43a5e
movq %rax, %rdi
movl $0x2c, %esi
callq 0x1950f
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x39b4c
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x12, %ecx
jne 0x1d8d4
cmpl $0x2c, 0x10(%rax)
jne 0x1d8d4
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %r12
movq %r12, %rsi
callq 0x39b4c
leaq 0x261c4(%rip), %rdx     # 0x43a79
movq %rax, %rdi
movl $0x29, %esi
callq 0x1950f
movq %rax, %r15
movq -0x10(%r12), %rax
movq %rax, (%r14)
movl $0x1, %eax
jmp 0x1d8ed
leaq 0x261b9(%rip), %rdx     # 0x43a94
movq %rax, %rdi
movl $0x29, %esi
callq 0x1950f
movq %rax, %r15
xorl %eax, %eax
movl %eax, %r12d
movq (%rsp,%r12,8), %rdi
callq 0xf401
movl %eax, 0x8(%r14)
movq 0x8(%rsp,%r12,8), %rdi
callq 0xf401
movl %eax, 0xc(%r14)
addq $0x18, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x227b4
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2616d(%rip), %rdx     # 0x43aaf
movl $0x28, %esi
callq 0x1950f
leaq 0x10(%rbx), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x39cd0
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
jne 0x1d974
leaq 0x2615f(%rip), %rsi     # 0x43acb
movq %r14, %rdi
callq 0x1d9e0
movl (%r14), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1d9b3
cmpl $0x2c, 0x10(%r14)
jne 0x1d9b3
movq 0x8(%r14), %rdi
movq 0x10(%rbx), %rax
movq %rax, 0x18(%rbx)
movq %r15, %rsi
callq 0x39cd0
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
jne 0x1d9b3
leaq 0x2613e(%rip), %rsi     # 0x43ae9
movq %r14, %rdi
callq 0x1d9e0
leaq 0x2614d(%rip), %rdx     # 0x43b07
movq %r14, %rdi
movl $0x29, %esi
callq 0x1950f
leaq 0x25e7c(%rip), %rdx     # 0x4384a
movq %rax, %rdi
movl $0x3b, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1950f