LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/parse.c
// Function: expect
struct token *expect(struct token *token, int op, const char *where)
{
	if (!match_op(token, op)) {
		if (token != &bad_token) {
			bad_token.next = token;
			sparse_error(token->pos, "Expected %s %s", show_special(op), where);
			sparse_error(token->pos, "got %s", show_token(token));
		}
		if (op == ';')
			return skip_to(token, op);
		return &bad_token;
	}
	return token->next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movl (%rdi), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x174a4
cmpl %ebp, 0x10(%rbx)
jne 0x174a4
movq 0x8(%rbx), %r14
jmp 0x17522
leaq 0x45eed(%rip), %r14     # 0x5d398
cmpq %r14, %rbx
je 0x174f1
movq %rbx, 0x45ee9(%rip)     # 0x5d3a0
movl %ebp, %edi
callq 0x29332
movq (%rbx), %rdi
leaq 0x24b1c(%rip), %rsi     # 0x3bfe4
movq %rax, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1120e
movq %rbx, %rdi
callq 0x294bb
movq (%rbx), %rdi
leaq 0x2bced(%rip), %rsi     # 0x431d4
movq %rax, %rdx
xorl %eax, %eax
callq 0x1120e
cmpl $0x3b, %ebp
jne 0x17522
leaq 0x690e3(%rip), %rax     # 0x805e0
movl (%rbx), %edx
andl $0x3f, %edx
movb $0x1, %cl
cmpl $0x12, %edx
jne 0x17510
cmpl $0x3b, 0x10(%rbx)
setne %cl
cmpq %rax, %rbx
je 0x1751f
testb %cl, %cl
je 0x1751f
movq 0x8(%rbx), %rbx
jmp 0x174fd
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/parse.c
// Function: alloc_statement
struct statement *alloc_statement(struct position pos, int type)
{
	struct statement *stmt = __alloc_statement(0);
	stmt->type = type;
	stmt->pos = pos;
	return stmt;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %edi, %edi
callq 0x2ab66
movl %ebx, (%rax)
movq %r14, 0x4(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/parse.c
// Function: label_symbol
struct symbol *label_symbol(struct token *token, int used)
{
	struct symbol *sym = lookup_symbol(token->ident, NS_LABEL);
	if (!sym) {
		sym = alloc_symbol(token->pos, SYM_LABEL);
		bind_symbol(sym, token->ident, NS_LABEL);
		if (used)
			sym->used = 1;
		fn_local_symbol(sym);
	}
	return sym;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movq 0x10(%rdi), %rdi
pushq $0x8
popq %rsi
callq 0x266e9
movq %rax, %r14
testq %rax, %rax
jne 0x1759a
movq (%r15), %rdi
pushq $0xc
popq %rsi
callq 0x2671f
movq %rax, %r14
movq 0x10(%r15), %rsi
pushq $0x8
popq %rdx
movq %rax, %rdi
callq 0x274ad
testl %ebx, %ebx
je 0x17592
orb $0x2, 0x2(%r14)
movq %r14, %rdi
callq 0x175a3
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rsi, %r15
movq %rdi, %r13
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, 0x40(%r12)
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
andq $0x0, 0x50(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movb $0x1, 0x50(%r12)
movq (%rdi), %rdi
pushq $0x3
popq %rsi
callq 0x2671f
movq %rax, %r14
movq %rax, (%r15)
movq %r13, %rdi
movq %r12, %rsi
callq 0x176c5
movq %rax, %rdi
movq %r12, %rsi
callq 0x178e3
movq %rax, %r15
movq (%rax), %rdi
movq %r12, %rsi
callq 0x17fba
movq 0x20(%r12), %rax
movq %rax, 0x80(%r14)
movaps (%r12), %xmm0
movaps 0x10(%r12), %xmm1
movups %xmm1, 0x70(%r14)
movups %xmm0, 0x60(%r14)
movq (%r15), %rax
movq %rax, 0xc(%r14)
movq 0x48(%r12), %rdi
testq %rbx, %rbx
je 0x17687
movzbl 0x52(%rsp), %eax
movl %eax, (%rbx)
testq %rdi, %rdi
je 0x176b4
callq 0x203f7
movq %rax, %rbx
movq %r14, %rdi
callq 0x20b5a
movq 0x4(%r14), %rdi
leaq 0x2494c(%rip), %rsi     # 0x3bff3
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1108a
movq %r15, %rax
addq $0x60, %rsp
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: 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 0x17fdb
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq *0x48(%rax)
testq %rax, %rax
je 0x17fe3
movq %rax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rdi
callq 0x20b5a
leaq 0x26432(%rip), %rsi     # 0x3e424
movq %rbx, %rdi
movq %rax, %rdx
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: 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 0x18046
movq 0x18(%r15), %rdi
leaq 0x4c470(%rip), %rax     # 0x64498
movq (%rax), %rsi
callq 0x201ba
testl %eax, %eax
jne 0x1805f
movq 0x18(%r14), %rdx
movq 0x4(%r15), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x18065
cmpq $0x0, 0x48(%r14)
jne 0x1805f
leaq 0x4c444(%rip), %rax     # 0x64498
movq (%rax), %rax
movq %rax, 0x48(%r14)
movq %rbx, 0x50(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2936d
movq %rax, %r15
leaq 0x263c5(%rip), %rsi     # 0x3e447
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1120e
leaq 0x263de(%rip), %rsi     # 0x3e474
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x10ddc
leaq 0x71ec6(%rip), %rax     # 0x89f70
movq (%rax), %rax
orl $0x100, 0x54(%rax)      # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1ffed
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x180f1
movq %rax, %rbx
callq 0x200c6
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: 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
pushq $0xc
popq %rbp
leaq 0x45c7c(%rip), %r13     # 0x5dd88
pushq $0x8
popq %r15
movl (%r14), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1818b
leaq 0x461fe(%rip), %rax     # 0x5e320
cmpq %rax, 0x10(%r14)
jne 0x1818b
movq 0x8(%r14), %r14
movq (%r14), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x18174
movl %ebp, %esi
callq 0x2671f
movq %rax, %r12
movq 0x10(%r14), %rsi
movq (%r13), %rcx
movq %rax, %rdi
movl %r15d, %edx
callq 0x2733a
movq %r12, %rdi
callq 0x175a3
movq 0x8(%r14), %r14
movl (%r14), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x18174
cmpl $0x2c, 0x10(%r14)
je 0x18128
movq %r14, %rdi
pushq $0x3b
popq %rsi
leaq 0x2632b(%rip), %rdx     # 0x3e4ac
callq 0x17480
movq %rax, %r14
jmp 0x18110
leaq 0x6844e(%rip), %r15     # 0x805e0
pushq $0x1
popq %rbp
xorl %r12d, %r12d
cmpq %r15, %r14
je 0x1824c
movq (%r14), %rax
andl $0x3f, %eax
cmpq $0x3, %rax
je 0x181be
cmpl $0x12, %eax
jne 0x181cb
cmpl $0x7d, 0x10(%r14)
jne 0x181cb
jmp 0x1824c
leaq 0x45fcb(%rip), %rax     # 0x5e190
cmpq %rax, 0x10(%r14)
je 0x1823c
movq %r14, %rdi
callq 0x18efc
testl %eax, %eax
je 0x18210
testl %r12d, %r12d
je 0x181ed
movq (%r14), %rdi
leaq 0x262a9(%rip), %rsi     # 0x3e48f
xorl %eax, %eax
callq 0x1108a
movq (%r14), %rdi
movl %ebp, %esi
callq 0x17530
movq %rax, %r13
leaq 0x10(%rax), %rsi
xorl %r12d, %r12d
movq %r14, %rdi
xorl %edx, %edx
callq 0x185c9
movq %rax, %r14
jmp 0x1822c
leaq 0x42385(%rip), %rax     # 0x5a59c
movl (%rax), %r12d
movq %r14, %rdi
movq %rsp, %rsi
callq 0x1a51d
movq %rax, %r14
movq (%rsp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1fae9
jmp 0x18198
movq %r14, %rdi
callq 0x19a19
movq %rax, %r14
jmp 0x18198
movq %r14, %rax
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/./expression.h
// Function: alloc_expression
static inline struct expression *alloc_expression(struct position pos, int type)
{
	struct expression *expr = __alloc_expression(0);
	expr->type = type;
	expr->pos = pos;
	expr->flags = CEF_NONE;
	return expr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %edi, %edi
callq 0x2aafa
movzbl %bl, %ecx
movq %r14, 0x8(%rax)
movw %cx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18ec1
movq 0x10(%rbx), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x18e4b
testq %rax, %rax
je 0x18ec1
movq 0x40(%rax), %rax
testb $0x20, (%rax)
je 0x18ec1
movq 0x8(%rbx), %rdi
leaq 0x23bd3(%rip), %rbx     # 0x3ca64
pushq $0x28
popq %rsi
movq %rbx, %rdx
callq 0x17480
leaq 0x256bf(%rip), %rdx     # 0x3e562
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x328db
pushq $0x29
popq %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x17480
movq %rax, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/./expression.h
// Function: lookup_type
static inline int lookup_type(struct token *token)
{
	if (token->pos.type == TOKEN_IDENT) {
		struct symbol *sym = lookup_symbol(token->ident, NS_SYMBOL | NS_TYPEDEF);
		return sym && (sym->namespace & NS_TYPEDEF);
	}
	return 0;
}

// Assembly:
pushq %rbx
movl (%rdi), %eax
andl $0x3f, %eax
xorl %ebx, %ebx
cmpl $0x3, %eax
jne 0x18f22
movq 0x10(%rdi), %rdi
pushq $0x12
popq %rsi
callq 0x266e9
testq %rax, %rax
je 0x18f22
movl (%rax), %ebx
shrl $0x9, %ebx
andl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2049d
testq $-0xd, %r14
sete %cl
orb %bpl, %cl
je 0x192be
movq 0x48(%r15), %rcx
testq %rcx, %rcx
je 0x192d4
movq (%rbx), %rdi
cmpq %r14, %rcx
jne 0x192da
leaq 0x23067(%rip), %rsi     # 0x3c323
jmp 0x192c8
movq (%rbx), %rdi
leaq 0x23039(%rip), %rsi     # 0x3c301
movq %rax, %rdx
xorl %eax, %eax
callq 0x1120e
jmp 0x192e8
movq %r14, 0x48(%r15)
jmp 0x192e8
leaq 0x2304f(%rip), %rsi     # 0x3c330
xorl %eax, %eax
callq 0x1120e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x19322
callq 0x2049d
movq (%rbx), %rdi
leaq 0x22feb(%rip), %rsi     # 0x3c301
movq %rax, %rdx
xorl %eax, %eax
callq 0x1120e
jmp 0x19337
addq $0x8, %rdx
pushq $0x20
popq %rax
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x1933c
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x19435
cmpl $0x28, 0x10(%r14)
jne 0x19435
movq %rdx, %rbx
movq 0x8(%r14), %rdi
callq 0x18efc
testl %eax, %eax
je 0x19450
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x175d4
movq %rax, %r14
movq (%r15), %rdx
movq 0x60(%rdx), %rax
addq $0x60, %rdx
movq %rax, (%rbx)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x194b8
jmp 0x1949d
leaq 0x22f25(%rip), %rsi     # 0x3c361
xorl %eax, %eax
callq 0x1120e
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rdi
pushq $0xa
popq %rsi
callq 0x2671f
movq %rax, %r15
movq 0x8(%r14), %rdi
leaq 0xb0(%rax), %rsi
callq 0x328d6
movq %rax, %r14
movq (%rax), %rax
movq %rax, 0xc(%r15)
cmpq $0x0, 0xb0(%r15)
jne 0x1949a
movq (%r14), %rdi
leaq 0x22eef(%rip), %rsi     # 0x3c37b
xorl %eax, %eax
callq 0x1120e
leaq 0x4d41e(%rip), %r15     # 0x668b8
movq %r15, (%rbx)
leaq 0x22eca(%rip), %rdx     # 0x3c36e
pushq $0x29
popq %rsi
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x17480
// File: /workspace/github_c_makefile_star2_O2/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 0x194db
leaq 0x8(%rbx), %rsi
movq %rsp, %rdi
callq 0x1933c
movq 0x18(%r14), %rdi
leaq 0x18(%rbx), %rsi
callq 0x1fe0b
movq 0x10(%r14), %rax
cmpq 0x10(%rbx), %rax
jbe 0x194f6
movq %rax, 0x10(%rbx)
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x19503
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x19589
cmpl $0x28, 0x10(%rbx)
jne 0x19589
movq %rdx, %r14
movq 0x8(%rbx), %rdi
callq 0x18efc
leaq 0x8(%rsp), %r15
testl %eax, %eax
je 0x195a4
andq $0x0, (%r15)
movq 0x8(%rbx), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x175d4
movq %rax, %rbx
movq (%r15), %rdi
callq 0x267cd
movq 0x70(%rax), %r15
leaq 0x22e46(%rip), %rdx     # 0x3c3bf
pushq $0x29
popq %rsi
movq %rbx, %rdi
callq 0x17480
movq %rax, %rbx
jmp 0x195cd
leaq 0x22e13(%rip), %rsi     # 0x3c3a3
xorl %eax, %eax
callq 0x1120e
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
andq $0x0, (%r15)
leaq 0x22e01(%rip), %rdx     # 0x3c3b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x327fd
movq %rax, %rbx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x19597
callq 0xfecd
movq %rax, %r15
testl %r15d, %r15d
js 0x195ee
leal -0x1(%r15), %eax
testl %eax, %r15d
jne 0x195fa
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
cmpq %r15, 0x10(%r14)
jae 0x19597
movq %r15, 0x10(%r14)
jmp 0x19597
movq (%rbx), %rdi
leaq 0x22dda(%rip), %rsi     # 0x3c3d2
jmp 0x19604
movq (%rbx), %rdi
leaq 0x22de5(%rip), %rsi     # 0x3c3e9
xorl %eax, %eax
callq 0x1108a
jmp 0x19597
// File: /workspace/github_c_makefile_star2_O2/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 0x22de0(%rip), %r14     # 0x3c402
pushq $0x28
popq %rbp
movl %ebp, %esi
movq %r14, %rdx
callq 0x17480
movq %rax, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x17480
movq %rax, %r14
leaq 0x4780a(%rip), %rbp     # 0x60e50
leaq 0x22ddc(%rip), %r15     # 0x3c429
movq %rsp, %r12
leaq 0x22dbb(%rip), %r13     # 0x3c412
movl (%r14), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x196fa
movq 0x10(%r14), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x18e4b
testq %rax, %rax
je 0x19694
movq 0x40(%rax), %rcx
movq 0x40(%rcx), %rcx
testq %rcx, %rcx
je 0x19694
movq 0x8(%r14), %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq *%rcx
jmp 0x196dc
andq $0x0, (%rsp)
cmpl $0x0, (%rbp)
je 0x196b8
movq 0x10(%r14), %rdi
callq 0x2936d
movq (%r14), %rdi
movq %r13, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1108a
movq 0x8(%r14), %r14
movl (%r14), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x196df
cmpl $0x28, 0x10(%r14)
jne 0x196df
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x327fd
movq %rax, %r14
movl (%r14), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x196fa
cmpl $0x2c, 0x10(%r14)
jne 0x196fa
movq 0x8(%r14), %r14
jmp 0x19657
leaq 0x22d01(%rip), %rbx     # 0x3c402
pushq $0x29
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x17480
movq %rax, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x17480
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/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 0x19994
movq 0x98(%rbx), %rcx
testq %rcx, %rcx
je 0x19992
xorl %esi, %esi
movq %rcx, %rdx
xorl %edi, %edi
movl (%rdx), %r9d
movsbq %r9b, %r8
cmpq %r8, %rdi
jge 0x19989
movq 0x18(%rdx,%rdi,8), %r8
cmpw $0x100, %r9w            # imm = 0x100
jb 0x19960
testq %r8, %r8
jne 0x19960
movq %rsi, %r8
jmp 0x19970
cmpq $0x0, 0x18(%r8)
je 0x19978
testq %rsi, %rsi
je 0x19970
movq %r8, 0x38(%rsi)
incq %rdi
movq %r8, %rsi
jmp 0x1993d
movq 0x60(%r8), %r9
testq %r9, %r9
je 0x19967
cmpb $0xb, (%r9)
je 0x1995b
jmp 0x19967
movq 0x10(%rdx), %rdx
cmpq %rcx, %rdx
jne 0x1993b
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x447ea(%rip), %r15     # 0x5e190
movq (%rbx), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpq $0x3, %rax
je 0x199c8
cmpl $0x12, %eax
jne 0x199ce
movl 0x10(%rbx), %eax
cmpl $0x3b, %eax
je 0x199df
cmpl $0x7d, %eax
jne 0x199ce
jmp 0x19a10
cmpq %r15, 0x10(%rbx)
je 0x199f5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19b2f
movq %rax, %rbx
movq (%rax), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x19a02
cmpl $0x3b, 0x10(%rbx)
jne 0x19a02
movq 0x8(%rbx), %rbx
jmp 0x199a6
movq %rbx, %rdi
callq 0x19a19
movq %rax, %rbx
jmp 0x199a6
leaq 0x22a83(%rip), %rsi     # 0x3c48c
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/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 %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
andq $0x0, 0x10(%rsp)
movq 0x8(%rdi), %rdi
leaq 0x22a73(%rip), %rdx     # 0x3c4ad
pushq $0x28
popq %rsi
callq 0x17480
movq %rax, %rdi
movq %r14, %rsi
callq 0x33498
movq %rax, %rbx
xorl %eax, %eax
cmpq %rax, (%r14)
jne 0x19a68
movq (%rbx), %rdi
leaq 0x22a61(%rip), %rsi     # 0x3c4c2
xorl %eax, %eax
callq 0x1120e
movl (%rbx), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x19a9f
cmpl $0x2c, 0x10(%rbx)
jne 0x19a9f
movq 0x8(%rbx), %rdi
leaq 0x22a8d(%rip), %rdx     # 0x3c510
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x328db
movq %rax, %rbx
cmpq $0x0, (%r14)
jne 0x19a9f
andq $0x0, 0x8(%rsp)
leaq 0x22a39(%rip), %rdx     # 0x3c4df
pushq $0x29
popq %rsi
movq %rbx, %rdi
callq 0x17480
leaq 0x22a52(%rip), %rdx     # 0x3c50a
pushq $0x3b
popq %rsi
movq %rax, %rdi
callq 0x17480
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x19b24
callq 0xfecd
testq %rax, %rax
jne 0x19b24
movq 0x8(%rsp), %rax
cmpb $0x1, (%rax)
jne 0x19b24
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
je 0x19b08
movq 0x28(%rcx), %rdi
callq 0x293bb
movq %rax, %rcx
leaq 0x2162a(%rip), %rdx     # 0x3b12b
movq 0x8(%rsp), %rax
jmp 0x19b12
leaq 0x1fdbe(%rip), %rdx     # 0x398cd
movq %rdx, %rcx
movq 0x8(%rax), %rdi
leaq 0x22a04(%rip), %rsi     # 0x3c521
xorl %eax, %eax
callq 0x1120e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/./symbol.h
// Function: is_int_type
static inline int is_int_type(const struct symbol *type)
{
	if (type->type == SYM_NODE)
		type = type->ctype.base_type;
	if (type->type == SYM_ENUM)
		type = type->ctype.base_type;
	return type->type == SYM_BITFIELD ||
	       type->ctype.base_type == &int_type;
}

// Assembly:
movzbl (%rdi), %eax
cmpl $0x3, %eax
jne 0x19e4b
movq 0x60(%rdi), %rdi
movzbl (%rdi), %eax
cmpl $0x9, %eax
jne 0x19e57
movq 0x60(%rdi), %rdi
movzbl (%rdi), %eax
cmpl $0xb, %eax
jne 0x19e60
pushq $0x1
popq %rax
retq
movq 0x60(%rdi), %rcx
xorl %eax, %eax
cmpq 0x40113(%rip), %rcx     # 0x59f80
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/parse.c
// Function: alloc_indirect_symbol
static struct symbol * alloc_indirect_symbol(struct position pos, struct ctype *ctype, int type)
{
	struct symbol *sym = alloc_symbol(pos, type);

	sym->ctype.base_type = ctype->base_type;
	sym->ctype.modifiers = ctype->modifiers;

	ctype->base_type = sym;
	ctype->modifiers = 0;
	return sym;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl %edx, %esi
callq 0x2671f
movq (%rbx), %rcx
movq %rcx, 0x60(%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x68(%rax)
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1f(%rip), %rcx        # 0x19ee0
pushq $0x9
popq %rdi
callq 0x1973c
movq (%rbx), %rcx
cmpq $0x0, 0x60(%rcx)
jne 0x19ede
leaq 0x4c81e(%rip), %rdx     # 0x666f8
movq %rdx, 0x60(%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/./symbol.h
// Function: get_sym_type
static inline int get_sym_type(struct symbol *type)
{
	if (type->type == SYM_NODE)
		type = type->ctype.base_type;
	if (type->type == SYM_ENUM)
		type = type->ctype.base_type;
	return type->type;
}

// Assembly:
movzbl (%rdi), %eax
cmpl $0x3, %eax
jne 0x1a44d
movq 0x60(%rdi), %rdi
movzbl (%rdi), %eax
cmpl $0x9, %eax
jne 0x1a459
movq 0x60(%rdi), %rax
movzbl (%rax), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/parse.c
// Function: type_is_ok
static int type_is_ok(struct symbol *type, struct range range)
{
	int shift = type->bit_size;
	int is_unsigned = type->ctype.modifiers & MOD_UNSIGNED;

	if (!is_unsigned)
		shift--;
	if (rshift(range.pos, shift))
		return 0;
	if (range.neg == 0)
		return 1;
	if (is_unsigned)
		return 0;
	if (rshift(~range.neg, shift))
		return 0;
	return 1;
}

// Assembly:
movl 0x50(%rdi), %ecx
movq 0x68(%rdi), %rax
btl $0xe, %eax
adcl $-0x1, %ecx
cmpl $0x40, %ecx
setae %dil
shrq %cl, %rdx
testq %rdx, %rdx
sete %dl
orb %dil, %dl
cmpb $0x1, %dl
jne 0x1a4a6
shrl $0xe, %eax
andl $0x1, %eax
testq %rsi, %rsi
sete %dl
orb %dl, %al
jne 0x1a4a8
cmpl $0x40, %ecx
setae %al
notq %rsi
shrq %cl, %rsi
testq %rsi, %rsi
sete %dl
orb %al, %dl
jmp 0x1a4a8
xorl %edx, %edx
movzbl %dl, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/./symbol.h
// Function: is_signed_type
static inline int is_signed_type(struct symbol *sym)
{
	if (sym->type == SYM_NODE)
		sym = sym->ctype.base_type;
	if (sym->type == SYM_PTR)
		return 0;
	return !(sym->ctype.modifiers & MOD_UNSIGNED);
}

// Assembly:
movzbl (%rdi), %ecx
cmpl $0x3, %ecx
jne 0x1a4bb
movq 0x60(%rdi), %rdi
movzbl (%rdi), %ecx
xorl %eax, %eax
cmpl $0x4, %ecx
je 0x1a4cb
xorl %eax, %eax
testb $0x40, 0x69(%rdi)
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2236b(%rip), %rdx     # 0x3c850
callq 0x327fd
leaq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x1a51d
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x3, %ecx
jne 0x1a50d
movq 0x10(%rax), %rcx
cmpq 0x3fa8d(%rip), %rcx     # 0x59f98
je 0x1a50f
popq %rbx
retq
movq 0x8(%rax), %rdi
addq $0x20, %rbx
movq %rbx, %rsi
popq %rbx
jmp 0x1a51d
// File: /workspace/github_c_makefile_star2_O2/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 0x436ae(%rip), %rdi     # 0x5ddf8
pushq $0x20
popq %rsi
callq 0x266e9
testq %rax, %rax
je 0x1a775
movl $0x5, (%rbx)
movq %rax, 0x18(%rbx)
addq $0x10, %rbx
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a720
movq (%r14), %rdi
leaq 0x2213f(%rip), %rsi     # 0x3c8be
xorl %eax, %eax
callq 0x1132a
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %rsi
callq 0x266e9
movl $0xa, (%r14)
movq %rax, 0x10(%r14)
testq %rax, %rax
jne 0x1a7be
movq 0x4(%r14), %rdi
leaq 0x22138(%rip), %rsi     # 0x3c8ef
xorl %eax, %eax
callq 0x1120e
movq 0x8(%rbx), %rdi
leaq 0x220e1(%rip), %rdx     # 0x3c8aa
pushq $0x3b
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17480
// File: /workspace/github_c_makefile_star2_O2/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 0x2211e(%rip), %rdx     # 0x3c914
pushq $0x3a
popq %rsi
callq 0x17480
movq %rax, %r14
leaq 0x43630(%rip), %rdi     # 0x5de38
pushq $0x20
popq %rsi
callq 0x266e9
movq 0x4(%rbx), %rdi
testq %rax, %rax
je 0x1a84f
movq %rax, %r15
pushq $0x3
popq %rsi
callq 0x2671f
movq %rax, %r12
addq $0x98, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1fae9
movq %rbx, 0x90(%r12)
movq %r12, 0x28(%rbx)
movq %r12, %rdi
callq 0x175a3
jmp 0x1a860
leaq 0x220f5(%rip), %rsi     # 0x3c94b
xorl %eax, %eax
callq 0x1120e
andl $0x0, (%rbx)
movq (%r14), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1a89f
cmpl $0x7d, 0x10(%r14)
jne 0x1a89f
leaq 0x220ac(%rip), %rsi     # 0x3c927
xorl %eax, %eax
callq 0x1108a
movq (%r14), %rdi
xorl %esi, %esi
callq 0x17530
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 0x1a51d
// File: /workspace/github_c_makefile_star2_O2/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 0x328d6
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x12, %ecx
jne 0x1a8ea
cmpl $0x117, 0x10(%rax)      # imm = 0x117
jne 0x1a8ea
movq 0x8(%rax), %rdi
leaq 0x18(%rbx), %rsi
callq 0x328d6
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1a7de
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x7
popq %rax
movl %eax, (%rsi)
callq 0x1ffed
movq 0x4(%rbx), %rdi
pushq $0x3
popq %rbp
movl %ebp, %esi
callq 0x2671f
movq %rax, %r15
leaq 0x43547(%rip), %rsi     # 0x5de70
pushq $0x20
popq %r12
movq %rax, %rdi
movl %r12d, %edx
callq 0x274ad
movq 0x4(%rbx), %rdi
movl %ebp, %esi
callq 0x2671f
movq %rax, %r13
leaq 0x434eb(%rip), %rsi     # 0x5de38
movq %rax, %rdi
movl %r12d, %edx
callq 0x274ad
movq %rbx, 0x90(%r13)
pushq $0x7
popq %rax
movl %eax, (%rbx)
movq %r15, 0x20(%rbx)
movq %r13, 0x28(%rbx)
movq %r15, %rdi
callq 0x175a3
movq %r13, %rdi
callq 0x175a3
movq 0x8(%r14), %rdi
leaq 0x10(%rbx), %rsi
leaq 0x21fd4(%rip), %rdx     # 0x3c95f
callq 0x327fd
leaq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x1a51d
movq %rax, %r14
movq 0x28(%rbx), %rax
cmpq $0x0, 0x98(%rax)
jne 0x1a9bf
movq 0x4(%rbx), %rdi
leaq 0x21fb6(%rip), %rsi     # 0x3c96e
xorl %eax, %eax
callq 0x1108a
callq 0x200c6
movq %r14, %rax
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/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 %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1aaf7
movq 0x8(%r14), %rdi
leaq 0x21f87(%rip), %rdx     # 0x3c983
pushq $0x28
popq %rsi
callq 0x17480
andq $0x0, 0x10(%rsp)
movq %rax, %r14
andq $0x0, 0x8(%rsp)
movq %rax, %rdi
callq 0x18efc
testl %eax, %eax
je 0x1aa35
leaq 0x14e(%rip), %rdx       # 0x1ab74
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x185c9
jmp 0x1aa54
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x328d6
leaq 0x21f46(%rip), %rdx     # 0x3c98f
pushq $0x3b
popq %rsi
movq %rax, %rdi
callq 0x17480
leaq 0x28(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x328d6
leaq 0x21f24(%rip), %r12     # 0x3c98f
pushq $0x3b
popq %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x17480
leaq 0x20(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x328d6
pushq $0x29
popq %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x17480
leaq 0x18(%rsp), %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x1a51d
movq %rax, %r13
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rbx)
movq 0x8(%rsp), %rdi
callq 0x1aba2
movq %rax, 0x28(%rbx)
movq (%r14), %rax
movq %rax, 0x30(%rbx)
movq (%r15), %rdi
callq 0x1aba2
movq %rax, 0x40(%rbx)
andq $0x0, 0x48(%rbx)
movq (%r12), %rax
movq %rax, 0x38(%rbx)
callq 0x200c6
movq %r13, %rax
addq $0x30, %rsp
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: 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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1ffed
movq 0x4(%rbx), %rdi
pushq $0x3
popq %rbp
movl %ebp, %esi
callq 0x2671f
movq %rax, %r14
leaq 0x43369(%rip), %rsi     # 0x5de88
pushq $0x20
popq %r15
movq %rax, %rdi
movl %r15d, %edx
callq 0x274ad
movq 0x4(%rbx), %rdi
movl %ebp, %esi
callq 0x2671f
movq %rax, %r12
leaq 0x4332d(%rip), %rsi     # 0x5de70
movq %rax, %rdi
movl %r15d, %edx
callq 0x274ad
movl $0x8, (%rbx)
movq %r12, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq %r12, %rdi
callq 0x175a3
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x175a3
// File: /workspace/github_c_makefile_star2_O2/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 0x1aba1
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x2936d
movq 0x4(%rbx), %rdi
leaq 0x21e06(%rip), %rsi     # 0x3c998
movq %rax, %rdx
xorl %eax, %eax
callq 0x1120e
andb $-0x60, 0x68(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1aaf7
movq 0x8(%r14), %rdi
leaq 0x21de1(%rip), %rdx     # 0x3c9c3
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x327fd
movq %rsp, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x1a51d
movq (%r14), %rcx
movq %rcx, 0x30(%rbx)
andq $0x0, 0x48(%rbx)
movq %rax, %r14
movq (%r15), %rax
movq %rax, 0x38(%rbx)
callq 0x200c6
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: 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 0x1aaf7
movq 0x8(%r14), %rdi
movq %rsp, %rsi
callq 0x1a51d
movq %rax, %r14
movq (%rax), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1ac69
movq 0x10(%r14), %rax
cmpq 0x3f325(%rip), %rax     # 0x59f88
je 0x1acea
leaq 0x21d61(%rip), %rsi     # 0x3c9d1
xorl %eax, %eax
callq 0x1120e
leaq 0x21d6f(%rip), %rdx     # 0x3c9ed
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x327fd
movq %rax, %r14
movq (%r15), %rax
movq %rax, 0x48(%rbx)
movq (%rsp), %r15
movq %r15, 0x38(%rbx)
callq 0x200c6
testq %r15, %r15
je 0x1acce
cmpl $0x3, (%r15)
je 0x1acce
leaq 0x46145(%rip), %rax     # 0x60dfc
cmpl $0x0, (%rax)
je 0x1acce
movq 0x4(%r15), %rdi
leaq 0x21d37(%rip), %rsi     # 0x3c9fe
xorl %eax, %eax
callq 0x1108a
leaq 0x21d58(%rip), %rdx     # 0x3ca2d
pushq $0x3b
popq %rsi
movq %r14, %rdi
callq 0x17480
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r14), %r14
jmp 0x1ac77
// File: /workspace/github_c_makefile_star2_O2/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 0x1ad4b
cmpl $0x12, %eax
jne 0x1ad3b
cmpl $0x2a, 0x10(%rbx)
jne 0x1ad3b
movq 0x8(%rbx), %rdi
leaq 0x18(%r14), %rsi
callq 0x328d6
movq %rax, %rbx
leaq 0x461f7(%rip), %rdi     # 0x60f28
movq %r14, %rsi
callq 0x1fae9
jmp 0x1ad6a
leaq 0x21cfb(%rip), %rsi     # 0x3ca3d
xorl %eax, %eax
callq 0x1120e
jmp 0x1ad6a
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1754e
movq %rax, 0x10(%r14)
movq 0x4(%r14), %rsi
movq %rax, %rdi
callq 0x18006
movq 0x8(%rbx), %rbx
leaq 0x21b39(%rip), %rdx     # 0x3c8aa
pushq $0x3b
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: 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
pushq $0x3
popq %rsi
callq 0x2671f
movq %rax, %r14
movq (%rbx), %rdi
pushq $0x5
popq %rsi
callq 0x2671f
movq %rax, %r15
movq %rax, 0x60(%r14)
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x17530
movq %rax, 0x90(%r15)
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1ad83