LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x230f5
testq $-0xd, %r14
sete %cl
orb %bpl, %cl
je 0x1b683
movq 0x48(%r15), %rcx
testq %rcx, %rcx
je 0x1b699
movq (%rbx), %rdi
cmpq %r14, %rcx
jne 0x1b69f
leaq 0x28c82(%rip), %rsi     # 0x44303
jmp 0x1b68d
movq (%rbx), %rdi
leaq 0x28c54(%rip), %rsi     # 0x442e1
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a38
jmp 0x1b6ad
movq %r14, 0x48(%r15)
jmp 0x1b6ad
leaq 0x28c6a(%rip), %rsi     # 0x44310
xorl %eax, %eax
callq 0x11a38
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/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 0x1b6e7
callq 0x230f5
movq (%rbx), %rdi
leaq 0x28c06(%rip), %rsi     # 0x442e1
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a38
jmp 0x1b6fb
movq %rdx, %rsi
addq $0x8, %rsi
movl $0x20, %edx
movq %rbx, %rdi
callq 0x1b700
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1b847
cmpl $0x28, 0x10(%r14)
jne 0x1b847
movq %rdx, %rbx
movq 0x8(%r14), %rax
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x3, %ecx
jne 0x1b7db
movq 0x10(%rax), %rdi
movl $0x12, %esi
callq 0x2b511
testq %rax, %rax
je 0x1b7db
testb $0x2, 0x1(%rax)
jne 0x1b862
movq (%r14), %rdi
movl $0xa, %esi
callq 0x2b547
movq %rax, %r15
movq 0x8(%r14), %rdi
leaq 0xb0(%rax), %rsi
callq 0x3993b
movq %rax, %r14
movq (%rax), %rax
movq %rax, 0xc(%r15)
cmpq $0x0, 0xb0(%r15)
jne 0x1b827
movq (%r14), %rdi
leaq 0x28b42(%rip), %rsi     # 0x4435b
xorl %eax, %eax
callq 0x11a38
leaq 0x52091(%rip), %r15     # 0x6d8b8
movq %r15, (%rbx)
leaq 0x28b1d(%rip), %rdx     # 0x4434e
movq %r14, %rdi
movl $0x29, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x195d7
leaq 0x28af3(%rip), %rsi     # 0x44341
xorl %eax, %eax
callq 0x11a38
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 0x19726
movq %rax, %r14
movq (%r15), %rdx
movq 0x60(%rdx), %rax
addq $0x60, %rdx
movq %rax, (%rbx)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1b893
jmp 0x1b82a
// File: /workspace/github_c_makefile_star2_O1/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 0x1b8b6
leaq 0x8(%rbx), %rsi
movq %rsp, %rdi
callq 0x1b700
movq 0x18(%r14), %rdi
leaq 0x18(%rbx), %rsi
callq 0x22bbe
movq 0x10(%r14), %rax
cmpq 0x10(%rbx), %rax
jbe 0x1b8d1
movq %rax, 0x10(%rbx)
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x1b8de
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1b974
cmpl $0x28, 0x10(%rbx)
jne 0x1b974
movq %rdx, %r14
movq 0x8(%rbx), %rax
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x3, %ecx
jne 0x1b940
movq 0x10(%rax), %rdi
movl $0x12, %esi
callq 0x2b511
testq %rax, %rax
je 0x1b940
testb $0x2, 0x1(%rax)
jne 0x1b99b
movq %rsp, %r15
movq $0x0, (%r15)
leaq 0x28a3f(%rip), %rdx     # 0x44390
movq %rbx, %rdi
movq %r15, %rsi
callq 0x39869
movq %rax, %rbx
movq (%r15), %r12
testq %r12, %r12
je 0x1b991
movq %r12, %rdi
callq 0xf2f1
movq %rax, %r15
jmp 0x1b994
leaq 0x28a08(%rip), %rsi     # 0x44383
xorl %eax, %eax
callq 0x11a38
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r15d, %r15d
testq %r12, %r12
jne 0x1b9dc
jmp 0x1b982
movq %rsp, %r15
movq $0x0, (%r15)
movq 0x8(%rbx), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x19726
movq %rax, %rbx
movq (%r15), %rdi
callq 0x2b5f4
movq %rax, (%r15)
movl 0x70(%rax), %r15d
leaq 0x289d3(%rip), %rdx     # 0x4439f
movq %rbx, %rdi
movl $0x29, %esi
callq 0x195d7
movq %rax, %rbx
testl %r15d, %r15d
js 0x1b9f9
leal -0x1(%r15), %eax
testl %eax, %r15d
jne 0x1ba05
movl %r15d, %eax
cmpq %rax, 0x10(%r14)
jae 0x1b982
movq %rax, 0x10(%r14)
jmp 0x1b982
movq (%rbx), %rdi
leaq 0x289af(%rip), %rsi     # 0x443b2
jmp 0x1ba0f
movq (%rbx), %rdi
leaq 0x289ba(%rip), %rsi     # 0x443c9
xorl %eax, %eax
callq 0x118b4
jmp 0x1b982
// File: /workspace/github_c_makefile_star2_O1/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 0x289b2(%rip), %r14     # 0x443e2
movl $0x28, %esi
movq %r14, %rdx
callq 0x195d7
movq %rax, %rdi
movl $0x28, %esi
movq %r14, %rdx
callq 0x195d7
movq %rax, %r14
leaq 0x4c3f9(%rip), %rbp     # 0x67e50
leaq 0x289ab(%rip), %r15     # 0x44409
movq %rsp, %r12
leaq 0x2898a(%rip), %r13     # 0x443f2
movl (%r14), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1bb22
movq 0x10(%r14), %rdi
testb $0x4, 0x11(%rdi)
jne 0x1ba85
xorl %eax, %eax
jmp 0x1ba8f
movl $0x100, %esi            # imm = 0x100
callq 0x2b511
testq %rax, %rax
je 0x1baaf
movq 0x40(%rax), %rcx
movq 0x40(%rcx), %rcx
testq %rcx, %rcx
je 0x1baaf
movq 0x8(%r14), %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq *%rcx
jmp 0x1bafa
movq $0x0, (%rsp)
cmpl $0x0, (%rbp)
je 0x1bad6
movq 0x10(%r14), %rdi
callq 0x2e465
movq (%r14), %rdi
movq %r13, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x118b4
movq 0x8(%r14), %r14
movl (%r14), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1bafd
cmpl $0x28, 0x10(%r14)
jne 0x1bafd
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x39869
movq %rax, %r14
movl (%r14), %ecx
andl $0x3f, %ecx
movb $0x1, %al
cmpl $0x12, %ecx
jne 0x1bb12
cmpl $0x2c, 0x10(%r14)
setne %al
testb %al, %al
jne 0x1bb1a
movq 0x8(%r14), %r14
testb %al, %al
je 0x1ba68
leaq 0x288b9(%rip), %rbx     # 0x443e2
movq %r14, %rdi
movl $0x29, %esi
movq %rbx, %rdx
callq 0x195d7
movq %rax, %rdi
movl $0x29, %esi
movq %rbx, %rdx
callq 0x195d7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/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 0x1bdf8
movq 0x98(%rbx), %rcx
testq %rcx, %rcx
je 0x1bdf6
xorl %r8d, %r8d
movq %rcx, %rdx
movzwl (%rdx), %r9d
testb %r9b, %r9b
jle 0x1bde7
xorl %esi, %esi
movq 0x18(%rdx,%rsi,8), %rdi
movzwl %r9w, %r9d
cmpl $0x100, %r9d            # imm = 0x100
jb 0x1bdb2
testq %rdi, %rdi
jne 0x1bdb2
movq %r8, %rdi
jmp 0x1bdc2
cmpq $0x0, 0x18(%rdi)
je 0x1bdd6
testq %r8, %r8
je 0x1bdc2
movq %rdi, 0x38(%r8)
incq %rsi
movl (%rdx), %r9d
movsbq %r9b, %r10
movq %rdi, %r8
cmpq %r10, %rsi
jl 0x1bd96
jmp 0x1bdea
movq 0x60(%rdi), %r9
testq %r9, %r9
je 0x1bdb9
cmpb $0xb, (%r9)
je 0x1bdad
jmp 0x1bdb9
movq %r8, %rdi
movq 0x10(%rdx), %rdx
movq %rdi, %r8
cmpq %rcx, %rdx
jne 0x1bd8b
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x49386(%rip), %r15     # 0x65190
movq (%rbx), %rax
andl $0x3f, %eax
cmpq $0x12, %rax
jne 0x1be1c
cmpl $0x7d, 0x10(%rbx)
je 0x1be74
cmpl $0x3, %eax
jne 0x1be27
cmpq %r15, 0x10(%rbx)
je 0x1be59
cmpl $0x12, %eax
jne 0x1be32
cmpl $0x3b, 0x10(%rbx)
je 0x1be40
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1bf99
movq %rax, %rbx
movq (%rbx), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1be66
cmpl $0x3b, 0x10(%rbx)
jne 0x1be66
movq 0x8(%rbx), %rbx
jmp 0x1be0a
movq %rbx, %rdi
callq 0x1be7d
movq %rax, %rbx
jmp 0x1be0a
leaq 0x285ff(%rip), %rsi     # 0x4446c
xorl %eax, %eax
callq 0x11a38
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x285ee(%rip), %rdx     # 0x4448d
movl $0x28, %esi
callq 0x195d7
movq %rax, %rdi
movq %r14, %rsi
callq 0x3a79d
movq %rax, %rbx
cmpq %r15, (%r14)
jne 0x1becd
movq (%rbx), %rdi
leaq 0x285dc(%rip), %rsi     # 0x444a2
xorl %eax, %eax
callq 0x11a38
movl (%rbx), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1bf06
cmpl $0x2c, 0x10(%rbx)
jne 0x1bf06
movq 0x8(%rbx), %rdi
leaq 0x28608(%rip), %rdx     # 0x444f0
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x39940
movq %rax, %rbx
cmpq $0x0, (%r14)
jne 0x1bf06
movq $0x0, (%rsp)
leaq 0x285b2(%rip), %rdx     # 0x444bf
movq %rbx, %rdi
movl $0x29, %esi
callq 0x195d7
leaq 0x285c9(%rip), %rdx     # 0x444ea
movq %rax, %rdi
movl $0x3b, %esi
callq 0x195d7
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1bf8c
callq 0xf2f1
testq %rax, %rax
jne 0x1bf8c
movq (%rsp), %rax
cmpb $0x1, (%rax)
jne 0x1bf8c
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x1bf6c
movq 0x28(%rax), %rdi
callq 0x2e4b3
movq %rax, %rcx
leaq 0x27195(%rip), %rdx     # 0x430ff
jmp 0x1bf76
leaq 0x2595a(%rip), %rdx     # 0x418cd
movq %rdx, %rcx
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x2857c(%rip), %rsi     # 0x44501
xorl %eax, %eax
callq 0x11a38
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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        # 0x1c356
movl $0x9, %edi
callq 0x1bb69
movq (%rbx), %rcx
cmpq $0x0, 0x60(%rcx)
jne 0x1c354
leaq 0x513a8(%rip), %rdx     # 0x6d6f8
movq %rdx, 0x60(%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1ca67
shrl $0xe, %eax
andl $0x1, %eax
testq %rsi, %rsi
sete %dl
orb %dl, %al
jne 0x1ca69
cmpl $0x40, %ecx
setae %al
notq %rsi
shrq %cl, %rsi
testq %rsi, %rsi
sete %dl
orb %al, %dl
jmp 0x1ca69
xorl %edx, %edx
movzbl %dl, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x27daa(%rip), %rdx     # 0x44830
callq 0x39869
leaq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x1cabe
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x3, %ecx
jne 0x1caae
movq 0x10(%rax), %rcx
cmpq 0x444ec(%rip), %rcx     # 0x60f98
je 0x1cab0
popq %rbx
retq
movq 0x8(%rax), %rdi
addq $0x20, %rbx
movq %rbx, %rsi
popq %rbx
jmp 0x1cabe
// File: /workspace/github_c_makefile_star2_O1/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 0x480e6(%rip), %rdi     # 0x64df8
movl $0x20, %esi
callq 0x2b511
testq %rax, %rax
je 0x1cd56
movl $0x5, (%rbx)
movq %rax, 0x18(%rbx)
addq $0x10, %rbx
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x3993b
leaq 0x27b48(%rip), %rdx     # 0x4488a
movq %rax, %rdi
movl $0x3b, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x195d7
movq (%r14), %rdi
leaq 0x27b3e(%rip), %rsi     # 0x4489e
xorl %eax, %eax
callq 0x11b54
// File: /workspace/github_c_makefile_star2_O1/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 0x2b511
movl $0xa, (%r14)
movq %rax, 0x10(%r14)
testq %rax, %rax
jne 0x1cda1
movq 0x4(%r14), %rdi
leaq 0x27b35(%rip), %rsi     # 0x448cf
xorl %eax, %eax
callq 0x11a38
movq 0x8(%rbx), %rdi
leaq 0x27ade(%rip), %rdx     # 0x4488a
movl $0x3b, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x195d7
// File: /workspace/github_c_makefile_star2_O1/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 0x27b19(%rip), %rdx     # 0x448f4
movl $0x3a, %esi
callq 0x195d7
movq %rax, %r14
leaq 0x48049(%rip), %rdi     # 0x64e38
movl $0x20, %esi
callq 0x2b511
movq 0x4(%rbx), %rdi
testq %rax, %rax
je 0x1ce45
movq %rax, %r12
movl $0x3, %esi
callq 0x2b547
movq %rax, %r15
addq $0x98, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x2285b
movq %rbx, 0x90(%r15)
movq %r15, 0x28(%rbx)
movq 0x4b0fa(%rip), %rdi     # 0x67f30
testq %rdi, %rdi
je 0x1ce59
movq %r15, %rsi
callq 0x2285b
jmp 0x1ce59
leaq 0x27adf(%rip), %rsi     # 0x4492b
xorl %eax, %eax
callq 0x11a38
movl $0x0, (%rbx)
movq (%r14), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1cea2
cmpl $0x7d, 0x10(%r14)
jne 0x1cea2
leaq 0x27a93(%rip), %rsi     # 0x44907
xorl %eax, %eax
callq 0x118b4
movq (%r14), %r15
xorl %edi, %edi
callq 0x3008c
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 0x1cabe
// File: /workspace/github_c_makefile_star2_O1/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 0x3993b
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x12, %ecx
jne 0x1ceed
cmpl $0x117, 0x10(%rax)      # imm = 0x117
jne 0x1ceed
movq 0x8(%rax), %rdi
leaq 0x18(%rbx), %rsi
callq 0x3993b
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1cdc3
// File: /workspace/github_c_makefile_star2_O1/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 0x22dc3
movq 0x4(%rbx), %rdi
movl $0x3, %esi
callq 0x2b547
movq %rax, %r15
leaq 0x47f45(%rip), %rsi     # 0x64e70
movq %rax, %rdi
movl $0x20, %edx
callq 0x2c3dd
movq 0x4(%rbx), %rdi
movl $0x3, %esi
callq 0x2b547
movq %rax, %r12
leaq 0x47ee8(%rip), %rsi     # 0x64e38
movq %rax, %rdi
movl $0x20, %edx
callq 0x2c3dd
movq %rbx, 0x90(%r12)
movl %ebp, (%rbx)
movq %r15, 0x20(%rbx)
movq %r12, 0x28(%rbx)
movq 0x4afba(%rip), %rdi     # 0x67f30
testq %rdi, %rdi
je 0x1cf83
movq %r15, %rsi
callq 0x2285b
movq 0x4afa6(%rip), %rdi     # 0x67f30
testq %rdi, %rdi
je 0x1cf97
movq %r12, %rsi
callq 0x2285b
movq 0x8(%r14), %rdi
leaq 0x10(%rbx), %rsi
leaq 0x27999(%rip), %rdx     # 0x4493f
callq 0x39869
leaq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x1cabe
movq %rax, %r14
movq 0x28(%rbx), %rax
cmpq $0x0, 0x98(%rax)
jne 0x1cfda
movq 0x4(%rbx), %rdi
leaq 0x2797b(%rip), %rsi     # 0x4494e
xorl %eax, %eax
callq 0x118b4
callq 0x22ed4
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1d164
movq 0x8(%r14), %rdi
leaq 0x27954(%rip), %rdx     # 0x44963
movl $0x28, %esi
callq 0x195d7
movq %rax, %r14
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
movl (%r14), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1d04f
movq 0x10(%r14), %rdi
movl $0x12, %esi
callq 0x2b511
testq %rax, %rax
je 0x1d04f
testb $0x2, 0x1(%rax)
jne 0x1d14b
movq %rsp, %rsi
movq %r14, %rdi
callq 0x3993b
leaq 0x2790e(%rip), %rdx     # 0x4496f
movq %rax, %rdi
movl $0x3b, %esi
callq 0x195d7
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x3993b
leaq 0x278ed(%rip), %r14     # 0x4496f
movq %rax, %rdi
movl $0x3b, %esi
movq %r14, %rdx
callq 0x195d7
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x3993b
movq %rax, %rdi
movl $0x29, %esi
movq %r14, %rdx
callq 0x195d7
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1cabe
movq %rax, %r14
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rbx)
movq (%rsp), %r15
testq %r15, %r15
je 0x1d0ec
movq 0x8(%r15), %r12
xorl %edi, %edi
callq 0x3008c
movl $0x2, (%rax)
movq %r12, 0x4(%rax)
movq %r15, 0x10(%rax)
jmp 0x1d0ee
xorl %eax, %eax
movq %rax, 0x28(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rbx)
movq 0x18(%rsp), %r15
testq %r15, %r15
je 0x1d120
movq 0x8(%r15), %r12
xorl %edi, %edi
callq 0x3008c
movl $0x2, (%rax)
movq %r12, 0x4(%rax)
movq %r15, 0x10(%rax)
jmp 0x1d122
xorl %eax, %eax
movq %rax, 0x40(%rbx)
movq $0x0, 0x48(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rbx)
callq 0x22ed4
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xab(%rip), %rdx        # 0x1d1fd
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1a892
jmp 0x1d06e
// File: /workspace/github_c_makefile_star2_O1/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 0x22dc3
movq 0x4(%r14), %rdi
movl $0x3, %esi
callq 0x2b547
movq %rax, %rbx
leaq 0x47cff(%rip), %rsi     # 0x64e88
movq %rax, %rdi
movl $0x20, %edx
callq 0x2c3dd
movq 0x4(%r14), %rdi
movl $0x3, %esi
callq 0x2b547
movq %rax, %r15
leaq 0x47cc2(%rip), %rsi     # 0x64e70
movq %rax, %rdi
movl $0x20, %edx
callq 0x2c3dd
movl $0x8, (%r14)
movq %r15, 0x10(%r14)
movq %rbx, 0x18(%r14)
movq 0x4ad5f(%rip), %rdi     # 0x67f30
testq %rdi, %rdi
je 0x1d1de
movq %r15, %rsi
callq 0x2285b
movq 0x4ad4b(%rip), %rdi     # 0x67f30
testq %rdi, %rdi
je 0x1d1f7
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2285b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1d22a
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x2e465
movq 0x4(%rbx), %rdi
leaq 0x2775d(%rip), %rsi     # 0x44978
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a38
andb $-0x60, 0x68(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1d164
movq 0x8(%r14), %rdi
leaq 0x27754(%rip), %rdx     # 0x449a3
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x39869
leaq 0x8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x1cabe
movq %rax, %r12
movq (%r14), %rax
movq %rax, 0x30(%rbx)
movq $0x0, 0x48(%rbx)
movq (%r15), %rax
movq %rax, 0x38(%rbx)
callq 0x22ed4
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1d164
movq 0x8(%r14), %rdi
movq %rsp, %rsi
callq 0x1cabe
movq %rax, %r14
movq (%rax), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1d2dd
movq 0x10(%r14), %rax
cmpq 0x43cb1(%rip), %rax     # 0x60f88
je 0x1d360
leaq 0x276cd(%rip), %rsi     # 0x449b1
xorl %eax, %eax
callq 0x11a38
leaq 0x276db(%rip), %rdx     # 0x449cd
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x39869
movq %rax, %r14
movq (%r15), %rax
movq %rax, 0x48(%rbx)
movq (%rsp), %r15
movq %r15, 0x38(%rbx)
callq 0x22ed4
testq %r15, %r15
je 0x1d342
cmpl $0x3, (%r15)
je 0x1d342
leaq 0x4aad1(%rip), %rax     # 0x67dfc
cmpl $0x0, (%rax)
je 0x1d342
movq 0x4(%r15), %rdi
leaq 0x276a3(%rip), %rsi     # 0x449de
xorl %eax, %eax
callq 0x118b4
leaq 0x276c4(%rip), %rdx     # 0x44a0d
movq %r14, %rdi
movl $0x3b, %esi
callq 0x195d7
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r14), %r14
jmp 0x1d2eb
// File: /workspace/github_c_makefile_star2_O1/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 0x1d3b6
cmpl $0x12, %eax
jne 0x1d3d9
cmpl $0x2a, 0x10(%rbx)
jne 0x1d3b1
movq 0x8(%rbx), %rdi
leaq 0x18(%r14), %rsi
callq 0x3993b
movq %rax, %rbx
leaq 0x4ab81(%rip), %rdi     # 0x67f28
movq %r14, %rsi
callq 0x2285b
jmp 0x1d3e7
cmpl $0x3, %eax
jne 0x1d3d9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x196a5
movq %rax, 0x10(%r14)
movq 0x4(%r14), %rsi
movq %rax, %rdi
callq 0x1a212
movq 0x8(%rbx), %rbx
jmp 0x1d3e7
leaq 0x2763d(%rip), %rsi     # 0x44a1d
xorl %eax, %eax
callq 0x11a38
leaq 0x2749c(%rip), %rdx     # 0x4488a
movq %rbx, %rdi
movl $0x3b, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x195d7
// File: /workspace/github_c_makefile_star2_O1/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 0x2b547
movq %rax, %r14
movq (%rbx), %rdi
movl $0x5, %esi
callq 0x2b547
movq %rax, %r15
movq %rax, 0x60(%r14)
movq (%rbx), %r14
xorl %edi, %edi
callq 0x3008c
movl $0x0, (%rax)
movq %r14, 0x4(%rax)
movq %rax, 0x90(%r15)
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1d402
// File: /workspace/github_c_makefile_star2_O1/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), %r14
movq (%r14), %rax
andl $0x3f, %eax
cmpq $0x12, %rax
jne 0x1d67a
cmpl $0x3a, 0x10(%r14)
je 0x1d725
cmpl $0x12, %eax
jne 0x1d67a
cmpl $0x29, 0x10(%r14)
je 0x1d725
leaq 0x273e5(%rip), %r15     # 0x44a66
leaq 0x273ed(%rip), %r12     # 0x44a75
movq %rdi, %r14
xorl %edi, %edi
callq 0x2ffc6
movq %rax, %r13
movq 0x8(%r14), %rax
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x12, %ecx
jne 0x1d6df
cmpl $0x5b, 0x10(%rax)
jne 0x1d6df
movq 0x8(%rax), %rax
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x3, %ecx
jne 0x1d6df
movq 0x8(%rax), %rcx
movl (%rcx), %edx
andl $0x3f, %edx
cmpl $0x12, %edx
jne 0x1d6df
cmpl $0x5d, 0x10(%rcx)
jne 0x1d6df
movq 0x10(%rax), %rax
movq %rax, (%r13)
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
movq 0x8(%r14), %rdi
leaq 0x8(%r13), %rsi
movq %r15, %rdx
callq 0x39940
movq %r13, %rsi
addq $0x10, %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x39869
movq %rax, %r14
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2285b
movl (%r14), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1d725
cmpl $0x2c, 0x10(%r14)
je 0x1d68b
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2b540
movq %rax, %r14
leaq 0x27334(%rip), %rdx     # 0x44a86
movq %r15, %rdi
movl $0x28, %esi
callq 0x195d7
movq %rsp, %rsi
movq %rax, %rdi
callq 0x3a79d
leaq 0x2732d(%rip), %rdx     # 0x44a9e
movq %rax, %rdi
movl $0x2c, %esi
callq 0x195d7
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x3a79d
movl (%rax), %ecx
andl $0x3f, %ecx
cmpl $0x12, %ecx
jne 0x1d7d2
cmpl $0x2c, 0x10(%rax)
jne 0x1d7d2
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %r12
movq %r12, %rsi
callq 0x3a79d
leaq 0x27306(%rip), %rdx     # 0x44ab9
movq %rax, %rdi
movl $0x29, %esi
callq 0x195d7
movq %rax, %r15
movq -0x10(%r12), %rax
movq %rax, (%r14)
movl $0x1, %eax
jmp 0x1d7eb
leaq 0x272fb(%rip), %rdx     # 0x44ad4
movq %rax, %rdi
movl $0x29, %esi
callq 0x195d7
movq %rax, %r15
xorl %eax, %eax
movl %eax, %r12d
movq (%rsp,%r12,8), %rdi
callq 0xf23d
movl %eax, 0x8(%r14)
movq 0x8(%rsp,%r12,8), %rdi
callq 0xf23d
movl %eax, 0xc(%r14)
addq $0x18, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2285b
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x272af(%rip), %rdx     # 0x44aef
movl $0x28, %esi
callq 0x195d7
leaq 0x10(%rbx), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x3a91c
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
jne 0x1d872
leaq 0x272a1(%rip), %rsi     # 0x44b0b
movq %r14, %rdi
callq 0x1d8de
movl (%r14), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1d8b1
cmpl $0x2c, 0x10(%r14)
jne 0x1d8b1
movq 0x8(%r14), %rdi
movq 0x10(%rbx), %rax
movq %rax, 0x18(%rbx)
movq %r15, %rsi
callq 0x3a91c
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
jne 0x1d8b1
leaq 0x27280(%rip), %rsi     # 0x44b29
movq %r14, %rdi
callq 0x1d8de
leaq 0x2728f(%rip), %rdx     # 0x44b47
movq %r14, %rdi
movl $0x29, %esi
callq 0x195d7
leaq 0x26fbe(%rip), %rdx     # 0x4488a
movq %rax, %rdi
movl $0x3b, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x195d7
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/parse.c
// Function: parse_range_statement
static struct token *parse_range_statement(struct token *token, struct statement *stmt)
{
	stmt->type = STMT_RANGE;
	token = token->next;
	token = expect(token, '(', "after __range__ statement");
	token = assignment_expression(token, &stmt->range_expression);
	token = expect(token, ',', "after range expression");
	token = assignment_expression(token, &stmt->range_low);
	token = expect(token, ',', "after low range");
	token = assignment_expression(token, &stmt->range_high);
	token = expect(token, ')', "after range statement");
	return expect(token, ';', "after range statement");
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl $0xd, (%rsi)
movq 0x8(%rdi), %rdi
leaq 0x27232(%rip), %rdx     # 0x44b67
movl $0x28, %esi
callq 0x195d7
leaq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x3a91c
leaq 0x2722f(%rip), %rdx     # 0x44b81
movq %rax, %rdi
movl $0x2c, %esi
callq 0x195d7
leaq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x3a91c
leaq 0x27226(%rip), %rdx     # 0x44b98
movq %rax, %rdi
movl $0x2c, %esi
callq 0x195d7
addq $0x20, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3a91c
leaq 0x27213(%rip), %rbx     # 0x44ba8
movq %rax, %rdi
movl $0x29, %esi
movq %rbx, %rdx
callq 0x195d7
movq %rax, %rdi
movl $0x3b, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x195d7
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/parse.c
// Function: attribute_packed
static struct token *attribute_packed(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	if (!ctx->ctype.alignment) {
		ctx->ctype.alignment = 1;
		ctx->packed = 1;
	}
	return token;
}

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x47d15(%rip), %rax     # 0x656f8
movl (%rax), %r15d
movq $0x0, (%rsp)
movl (%rdi), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1da27
cmpl $0x28, 0x10(%rbx)
jne 0x1da27
leaq 0x26a04(%rip), %rdx     # 0x44409
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x39869
movq %rax, %rbx
movq (%r12), %rdi
testq %rdi, %rdi
je 0x1da27
callq 0xf2f1
movq %rax, %r15
leal -0x1(%r15), %eax
testl %eax, %r15d
jne 0x1da3f
movslq %r15d, %rax
cmpq %rax, 0x10(%r14)
jae 0x1da50
movq %rax, 0x10(%r14)
jmp 0x1da50
movq (%rbx), %rdi
leaq 0x27175(%rip), %rsi     # 0x44bbe
xorl %eax, %eax
callq 0x118b4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/parse.c
// Function: attribute_cleanup
static struct token *attribute_cleanup(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	struct expression *expr = NULL;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq $0x0, 0x8(%rsp)
movq (%rdi), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x1dab9
cmpl $0x28, 0x10(%r14)
jne 0x1dab9
movq %rdx, %rbx
movq 0x8(%r14), %r14
movq (%r14), %rdi
movl %edi, %eax
andl $0x3f, %eax
cmpq $0x3, %rax
je 0x1dad5
leaq 0x27171(%rip), %rsi     # 0x44c15
cmpl $0x12, %eax
jne 0x1dace
cmpl $0x29, 0x10(%r14)
jne 0x1dac9
leaq 0x2712e(%rip), %rsi     # 0x44be5
jmp 0x1dace
leaq 0x27125(%rip), %rsi     # 0x44be5
xorl %eax, %eax
callq 0x11a38
jmp 0x1db0d
cmpl $0x3, %eax
je 0x1dad5
xorl %eax, %eax
callq 0x11a38
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x39991
movq (%r15), %rcx
testq %rcx, %rcx
je 0x1daf6
cmpb $0x3, (%rcx)
jne 0x1daf6
movq %rcx, 0x38(%rbx)
leaq 0x27136(%rip), %rdx     # 0x44c33
movq %rax, %rdi
movl $0x29, %esi
callq 0x195d7
movq %rax, %r14
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/parse.c
// Function: attribute_address_space
static struct token *attribute_address_space(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	struct expression *expr = NULL;
	struct ident *as = NULL;
	struct token *next;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq $0x0, 0x8(%rsp)
leaq 0x270c9(%rip), %rdx     # 0x44c4f
movl $0x28, %esi
callq 0x195d7
movq %rax, %r14
movl (%rax), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
je 0x1dbec
cmpl $0x5, %eax
jne 0x1dbf6
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x39991
movq %rax, %r15
movq (%r12), %rax
cmpb $0x1, (%rax)
jne 0x1dbfa
movl 0x20(%rax), %edx
testl %edx, %edx
je 0x1dc7e
leaq 0x270df(%rip), %rsi     # 0x44caf
leaq 0x10(%rsp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0xe2c0
movq %r12, %rdi
callq 0x2edd4
movq %rax, %r12
jmp 0x1dc0e
movq 0x8(%r14), %r15
movq 0x10(%r14), %r12
jmp 0x1dc0e
movq 0x8(%r14), %r15
movq (%r14), %rdi
leaq 0x27069(%rip), %rsi     # 0x44c6d
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x118b4
leaq 0x43973(%rip), %rax     # 0x61588
cmpl $0x0, (%rax)
setne %al
testq %r12, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1dc5c
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1dc58
callq 0x23311
movq %rax, %r13
movq %r12, %rdi
callq 0x23311
movq (%r14), %rdi
leaq 0x2703d(%rip), %rsi     # 0x44c88
movq %r13, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x11a38
movq %r12, 0x20(%rbx)
leaq 0x26fec(%rip), %rdx     # 0x44c4f
movq %r15, %rdi
movl $0x29, %esi
callq 0x195d7
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r12d, %r12d
jmp 0x1dc0e
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/parse.c
// Function: attribute_designated_init
static struct token *attribute_designated_init(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	if (ctx->ctype.base_type && ctx->ctype.base_type->type == SYM_STRUCT)
		ctx->ctype.base_type->designated_init = 1;
	else
		warning(token->pos, "attribute designated_init applied to non-structure type");
	return token;
}

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x4a17b(%rip), %rax     # 0x67e3c
cmpl $0x0, (%rax)
je 0x1dcd7
movq (%rbx), %rdi
leaq 0x27020(%rip), %rsi     # 0x44cf0
xorl %eax, %eax
callq 0x118b4
movq (%r14), %rax
testq %rax, %rax
je 0x1dcea
cmpb $0x8, (%rax)
jne 0x1dcea
orb $0x40, 0x56(%rax)
jmp 0x1dcfb
movq (%rbx), %rdi
leaq 0x2701c(%rip), %rsi     # 0x44d10
xorl %eax, %eax
callq 0x118b4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq