LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x28, %esi
leaq 0x3f432(%rip), %rdx     # 0x64db6
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x56f40
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x259ba
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3f418(%rip), %rsi     # 0x64dcb
movb $0x0, %al
callq 0x16f90
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x25a02
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq 0x3f431(%rip), %rdx     # 0x64e19
callq 0x55ce0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x25a00
movq $0x0, -0x18(%rbp)
jmp 0x25a02
movq -0x8(%rbp), %rdi
movl $0x29, %esi
leaq 0x3f3d6(%rip), %rdx     # 0x64de8
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3b, %esi
leaq 0x3f3e8(%rip), %rdx     # 0x64e13
callq 0x22eb0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x25ab1
movq -0x18(%rbp), %rdi
callq 0x12170
cmpq $0x0, %rax
jne 0x25ab1
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
jne 0x25ab1
leaq 0x3cdc8(%rip), %rax     # 0x62829
movq %rax, -0x28(%rbp)
leaq 0x3cdbd(%rip), %rax     # 0x62829
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x25a93
leaq 0x3e649(%rip), %rax     # 0x640c7
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x441d0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x8(%rax), %rdi
leaq 0x3f380(%rip), %rsi     # 0x64e2a
movb $0x0, %al
callq 0x16f90
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: declaration_list
static struct token *declaration_list(struct token *token, struct symbol_list **list)
{
	struct decl_state ctx = {.prefer_abstract = 0};
	struct ctype saved;
	unsigned long mod;

	token = declaration_specifiers(token, &ctx);
	mod = decl_modifiers(&ctx);
	saved = ctx.ctype;
	for (;;) {
		struct symbol *decl = alloc_symbol(token->pos, SYM_NODE);
		ctx.cleanup = NULL;
		ctx.ident = &decl->ident;

		token = declarator(token, &ctx);
		if (match_op(token, ':'))
			token = handle_bitfield(token, &ctx);

		token = handle_attributes(token, &ctx);
		apply_modifiers(token->pos, &ctx);

		decl->ctype = ctx.ctype;
		decl->ctype.modifiers |= mod;
		decl->cleanup = ctx.cleanup;
		decl->endpos = token->pos;
		add_symbol(list, decl);
		if (!match_op(token, ','))
			break;
		token = token->next;
		ctx.ctype = saved;
	}
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x11130
movq -0x8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x23280
movq %rax, -0x8(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x24510
movq %rax, -0x98(%rbp)
leaq -0x68(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movl $0x28, %edx
callq 0x111d0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x3, %esi
callq 0x3f4d0
movq %rax, -0xa0(%rbp)
movq $0x0, -0x30(%rbp)
movq -0xa0(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x23620
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3a, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x25b7d
movq -0x8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x25c50
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x24630
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq -0x68(%rbp), %rsi
callq 0x23660
movq -0xa0(%rbp), %rdi
addq $0x48, %rdi
addq $0x18, %rdi
leaq -0x68(%rbp), %rsi
movl $0x28, %edx
callq 0x111d0
movq -0x98(%rbp), %rcx
movq -0xa0(%rbp), %rax
orq 0x68(%rax), %rcx
movq %rcx, 0x68(%rax)
movq -0x30(%rbp), %rcx
movq -0xa0(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq -0xa0(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0xc(%rax)
movq -0x10(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x22cc0
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x25c1a
jmp 0x25c40
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x90(%rbp), %rsi
movl $0x28, %edx
callq 0x111d0
jmp 0x25b19
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x25ec4
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x9, %eax
jne 0x25ee0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xff, %ecx
movb $0x1, %al
cmpl $0xb, %ecx
movb %al, -0x9(%rbp)
je 0x25f0b
movq -0x8(%rbp), %rax
leaq 0x6b357(%rip), %rcx     # 0x91258
cmpq %rcx, 0x60(%rax)
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rdi
callq 0x3f4d0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x9, %edi
leaq 0x48(%rip), %rcx        # 0x26070
callq 0x25410
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x48, %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2605c
movq -0x28(%rbp), %rax
leaq 0x6ca7f(%rip), %rcx     # 0x92ad8
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: update_range
static void update_range(struct range *range, unsigned long long uval, struct symbol *vtype)
{
	long long sval = uval;

	if (is_signed_type(vtype) && (sval < 0)) {
		if (sval < range->neg)
			range->neg = sval;
	} else {
		if (uval > range->pos)
			range->pos = uval;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x26990
cmpl $0x0, %eax
je 0x2676b
cmpq $0x0, -0x20(%rbp)
jge 0x2676b
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x26769
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x26787
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x26785
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x26787
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x4000, %rax           # imm = 0x4000
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x267ce
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x26a00
cmpq $0x0, %rax
je 0x267e9
movl $0x0, -0x4(%rbp)
jmp 0x2682e
cmpq $0x0, -0x18(%rbp)
jne 0x267f9
movl $0x1, -0x4(%rbp)
jmp 0x2682e
cmpl $0x0, -0x28(%rbp)
je 0x26808
movl $0x0, -0x4(%rbp)
jmp 0x2682e
movq -0x18(%rbp), %rdi
xorq $-0x1, %rdi
movl -0x24(%rbp), %esi
callq 0x26a00
cmpq $0x0, %rax
je 0x26827
movl $0x0, -0x4(%rbp)
jmp 0x2682e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: cast_enum_list
static void cast_enum_list(struct symbol_list *list, struct symbol *base_type)
{
	struct range irange = type_range(&int_ctype);
	struct symbol *sym;

	FOR_EACH_PTR(list, sym) {
		struct expression *expr = sym->initializer;
		struct symbol *ctype;
		long long val;
		if (expr->type != EXPR_VALUE)
			continue;
		ctype = expr->ctype;
		val = get_expression_value(expr);
		if (is_int_type(ctype) && val_in_range(&irange, val, ctype)) {
			expr->ctype = &int_ctype;
			continue;
		}
		cast_value(expr, base_type, expr);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x6b2c1(%rip), %rdi     # 0x91b18
callq 0x26a40
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x26888
jmp 0x26982
jmp 0x2688a
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x38(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x2696a
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x268dc
cmpq $0x0, -0x28(%rbp)
jne 0x268dc
jmp 0x2695c
movq -0x28(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
je 0x268fd
jmp 0x2695c
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x11ff0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x25ea0
cmpl $0x0, %eax
je 0x2694b
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x26ab0
cmpl $0x0, %eax
je 0x2694b
movq -0x50(%rbp), %rax
leaq 0x6b1d3(%rip), %rcx     # 0x91b18
movq %rcx, 0x10(%rax)
jmp 0x2695c
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x11640
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x26891
jmp 0x2696c
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x2688a
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x269b4
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x4, %eax
jne 0x269cd
movl $0x0, -0x4(%rbp)
jmp 0x269ec
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x4000, %rax           # imm = 0x4000
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: type_range
static struct range type_range(struct symbol *type)
{
	struct range range;
	unsigned int size = type->bit_size;
	unsigned long long max;
	long long min;

	if (is_signed_type(type)) {
		min = sign_bit(size);
		max = min - 1;
	} else {
		min = 0;
		max = bits_mask(size);
	}

	range.pos = max;
	range.neg = min;
	return range;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x26990
cmpl $0x0, %eax
je 0x26a7e
movl -0x1c(%rbp), %edi
callq 0x26b20
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x26a92
movq $0x0, -0x30(%rbp)
movl -0x1c(%rbp), %edi
callq 0x26b40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: val_in_range
static int val_in_range(struct range *range, long long sval, struct symbol *vtype)
{
	unsigned long long uval = sval;

	if (is_signed_type(vtype) && (sval < 0))
		return range->neg <= sval;
	else
		return uval <= range->pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x26990
cmpl $0x0, %eax
je 0x26af9
cmpq $0x0, -0x18(%rbp)
jge 0x26af9
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
setle %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x26b10
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
setbe %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x4, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
leaq 0x3e5b8(%rip), %rdx     # 0x65159
callq 0x55b00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
addq $0x8, %rsi
callq 0x26c20
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
je 0x26bdd
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x26c15
movq -0x10(%rbp), %rax
leaq 0x631c8(%rip), %rcx     # 0x89db0
cmpq %rcx, 0x10(%rax)
je 0x26bf8
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x26c15
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rsi
callq 0x26c20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: handle_label_attributes
static struct token *handle_label_attributes(struct token *token, struct symbol *label)
{
	struct decl_state ctx = { };

	token = handle_attributes(token, &ctx);
	label->label_modifiers = ctx.ctype.modifiers;
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x11130
movq -0x8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x24630
movq %rax, -0x8(%rbp)
movq -0x60(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x62e81(%rip), %rdi     # 0x89dc8
movl $0x20, %esi
callq 0x3f450
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x26f71
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3e25d(%rip), %rsi     # 0x651c7
movb $0x0, %al
callq 0x170e0
movq -0x10(%rbp), %rax
movl $0x5, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x26ef0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x20, %esi
callq 0x3f450
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0xa, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x27009
movq -0x10(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x3e1f6(%rip), %rsi     # 0x651f8
movb $0x0, %al
callq 0x16f90
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x3b, %esi
leaq 0x3e196(%rip), %rdx     # 0x651b3
callq 0x22eb0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
leaq 0x3e193(%rip), %rdx     # 0x6521d
callq 0x22eb0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x27110
movq -0x10(%rbp), %rdi
movl $0x7d, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x270e7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3e173(%rip), %rsi     # 0x65230
movb $0x0, %al
callq 0x16d80
movq -0x10(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x23020
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x27100
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rsi
callq 0x26c20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: add_case_statement
static void add_case_statement(struct statement *stmt)
{
	struct symbol *target = lookup_symbol(&case_ident, NS_ITERATOR);
	struct symbol *sym;

	if (!target) {
		sparse_error(stmt->pos, "not in switch scope");
		stmt->type = STMT_NONE;
		return;
	}
	sym = alloc_symbol(stmt->pos, SYM_NODE);
	add_symbol(&target->symbol_list, sym);
	sym->stmt = stmt;
	stmt->case_label = sym;
	fn_local_symbol(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x62ce5(%rip), %rdi     # 0x89e08
movl $0x20, %esi
callq 0x3f450
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2715a
movq -0x8(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x3e10d(%rip), %rsi     # 0x65254
movb $0x0, %al
callq 0x16f90
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
jmp 0x271a9
movq -0x8(%rbp), %rax
movq 0x4(%rax), %rdi
movl $0x3, %esi
callq 0x3f4d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
callq 0x22cc0
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rdi
callq 0x230f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x55cb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x117, %esi            # imm = 0x117
callq 0x22f80
cmpl $0x0, %eax
je 0x27209
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x8, %rsi
callq 0x55cb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x27060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x7, (%rax)
movq -0x10(%rbp), %rdi
callq 0x27290
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
leaq 0x3e00e(%rip), %rdx     # 0x65268
callq 0x55b00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x8, %rsi
callq 0x26c20
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x27340
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: start_switch
static void start_switch(struct statement *stmt)
{
	struct symbol *brk, *switch_case;

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

	switch_case = alloc_symbol(stmt->pos, SYM_NODE);
	bind_symbol(switch_case, &case_ident, NS_ITERATOR);
	switch_case->stmt = stmt;

	stmt->type = STMT_SWITCH;
	stmt->switch_break = brk;
	stmt->switch_case = switch_case;

	fn_local_symbol(brk);
	fn_local_symbol(switch_case);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x31e70
movq -0x8(%rbp), %rax
movq 0x4(%rax), %rdi
movl $0x3, %esi
callq 0x3f4d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x62b7e(%rip), %rsi     # 0x89e40
movl $0x20, %edx
callq 0x40a40
movq -0x8(%rbp), %rax
movq 0x4(%rax), %rdi
movl $0x3, %esi
callq 0x3f4d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x62b1b(%rip), %rsi     # 0x89e08
movl $0x20, %edx
callq 0x40a40
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rax
movl $0x7, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0x230f0
movq -0x18(%rbp), %rdi
callq 0x230f0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x274f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x28, %esi
leaq 0x3dedf(%rip), %rdx     # 0x6528c
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24680
cmpl $0x0, %eax
je 0x273ee
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq 0x1bd(%rip), %rdx       # 0x275a0
callq 0x23ba0
movq %rax, -0x8(%rbp)
jmp 0x27418
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x55cb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3b, %esi
leaq 0x3de89(%rip), %rdx     # 0x65298
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x55cb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3b, %esi
leaq 0x3de5f(%rip), %rdx     # 0x65298
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x55cb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x29, %esi
leaq 0x3de35(%rip), %rdx     # 0x65298
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x26c20
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rdi
callq 0x27610
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rdi
callq 0x27610
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rdi
callq 0x27670
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x31e70
movq -0x8(%rbp), %rax
movq 0x4(%rax), %rdi
movl $0x3, %esi
callq 0x3f4d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x62936(%rip), %rsi     # 0x89e58
movl $0x20, %edx
callq 0x40a40
movq -0x8(%rbp), %rax
movq 0x4(%rax), %rdi
movl $0x3, %esi
callq 0x3f4d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x628f3(%rip), %rsi     # 0x89e40
movl $0x20, %edx
callq 0x40a40
movq -0x8(%rbp), %rax
movl $0x8, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0x230f0
movq -0x10(%rbp), %rdi
callq 0x230f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x5f, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $-0x4, %rax
cmpq $0x0, %rax
je 0x27605
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44150
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rdx
movq 0x4(%rax), %rdi
leaq 0x3dcb3(%rip), %rsi     # 0x652a1
movb $0x0, %al
callq 0x16f90
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
andq $-0x60, %rcx
movq %rcx, 0x68(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: make_statement
static struct statement *make_statement(struct expression *expr)
{
	struct statement *stmt;

	if (!expr)
		return NULL;
	stmt = alloc_statement(expr->pos, STMT_EXPRESSION);
	stmt->expression = expr;
	return stmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2762d
movq $0x0, -0x8(%rbp)
jmp 0x27657
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x2, %esi
callq 0x23020
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x274f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x18(%rbp), %rsi
leaq 0x3dc10(%rip), %rdx     # 0x652cc
callq 0x55b00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x26c20
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rdi
callq 0x27670
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x274f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x26c20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x2776d
movq -0x8(%rbp), %rax
leaq 0x62737(%rip), %rcx     # 0x89e90
cmpq %rcx, 0x10(%rax)
jne 0x2776d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x27782
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3db5f(%rip), %rsi     # 0x652da
movb $0x0, %al
callq 0x16f90
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq 0x3db65(%rip), %rdx     # 0x652f6
callq 0x55b00
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rdi
callq 0x27670
cmpq $0x0, -0x20(%rbp)
je 0x277ed
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
je 0x277ed
leaq 0x65a0a(%rip), %rax     # 0x8d1dc
cmpl $0x0, (%rax)
je 0x277ed
movq -0x20(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x3db21(%rip), %rsi     # 0x65307
movb $0x0, %al
callq 0x16d80
movq -0x8(%rbp), %rdi
movl $0x3b, %esi
leaq 0x3db39(%rip), %rdx     # 0x65336
callq 0x22eb0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0xa, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2a, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x27878
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x8, %rsi
callq 0x55cb0
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x65a97(%rip), %rdi     # 0x8d308
callq 0x27900
jmp 0x278dc
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x278c5
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x23060
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x4(%rax), %rsi
callq 0x236e0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x278da
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3da73(%rip), %rsi     # 0x65346
movb $0x0, %al
callq 0x16f90
jmp 0x278dc
movq -0x8(%rbp), %rdi
movl $0x3b, %esi
leaq 0x3d8c7(%rip), %rdx     # 0x651b3
callq 0x22eb0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x3, %esi
callq 0x3f4d0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x5, %esi
callq 0x3f4d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x23020
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x27930
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x3a, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x27c02
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x29, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x27c13
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x27d15
jmp 0x27c15
xorl %edi, %edi
callq 0x46c50
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x5b, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x27c99
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x27c99
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movl $0x5d, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x27c99
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
leaq 0x3d6d7(%rip), %rdx     # 0x6538f
callq 0x55ce0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x10, %rsi
leaq 0x3d6ca(%rip), %rdx     # 0x6539e
callq 0x55b00
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x31370
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x27c15
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: parse_asm_clobbers
static struct token *parse_asm_clobbers(struct token *token, struct statement *stmt,
	struct expression_list **clobbers)
{
	struct expression *expr;

	do {
		token = primary_expression(token->next, &expr);
		if (expr)
			add_expression(clobbers, expr);
	} while (match_op(token, ','));
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x55d50
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x27d5d
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x27e10
jmp 0x27d5f
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x27d34
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: parse_asm_labels
static struct token *parse_asm_labels(struct token *token, struct statement *stmt,
		        struct symbol_list **labels)
{
	struct symbol *label;

	do {
		token = token->next; /* skip ':' and ',' */
		if (token_type(token) != TOKEN_IDENT)
			return token;
		label = label_symbol(token, 1);
		add_symbol(labels, label);
		token = token->next;
	} while (match_op(token, ','));
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
je 0x27dba
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x27e00
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x23060
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x22cc0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x27d94
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x3f4c0
movq %rax, -0x20(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x8(%rbp), %rdi
movl $0x28, %esi
leaq 0x3d53b(%rip), %rdx     # 0x653af
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x56f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
leaq 0x3d529(%rip), %rdx     # 0x653c7
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
addq $0x8, %rsi
callq 0x56f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x27f1f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
addq $0x10, %rsi
callq 0x56f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x29, %esi
leaq 0x3d4e2(%rip), %rdx     # 0x653e2
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x27f38
movq -0x8(%rbp), %rdi
movl $0x29, %esi
leaq 0x3d4ce(%rip), %rdx     # 0x653fd
callq 0x22eb0
movq %rax, -0x8(%rbp)
movl -0x44(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x44(%rbp)
cltq
movq -0x40(%rbp,%rax,8), %rdi
callq 0x11ff0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x44(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x44(%rbp)
cltq
movq -0x40(%rbp,%rax,8), %rdi
callq 0x11ff0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x31370
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0xc, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x28, %esi
leaq 0x3d442(%rip), %rdx     # 0x65418
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x57130
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2800f
movq -0x8(%rbp), %rdi
leaq 0x3d42a(%rip), %rsi     # 0x65434
callq 0x280b0
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x28070
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x57130
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2806e
movq -0x8(%rbp), %rdi
leaq 0x3d3e9(%rip), %rsi     # 0x65452
callq 0x280b0
jmp 0x28070
movq -0x8(%rbp), %rdi
movl $0x29, %esi
leaq 0x3d3f0(%rip), %rdx     # 0x65470
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3b, %esi
leaq 0x3d11a(%rip), %rdx     # 0x651b3
callq 0x22eb0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: unexpected
static void unexpected(struct token *token, const char *errmsg)
{
	if (token == &bad_token)
		return;
	sparse_error(token->pos, "%s", errmsg);
	sparse_error(token->pos, "got %s", show_token(token));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x60339(%rip), %rax     # 0x88400
cmpq %rax, -0x8(%rbp)
jne 0x280cf
jmp 0x28111
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
movq (%rax), %rdi
leaq 0x450b4(%rip), %rsi     # 0x6d195
movb $0x0, %al
callq 0x16f90
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x44420
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x43b9a(%rip), %rsi     # 0x6bca4
movb $0x0, %al
callq 0x16f90
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)