LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_multiarch_dir
static char **handle_multiarch_dir(char *arg, char **next)
{
	multiarch_dir = *++next;
	if (!multiarch_dir)
		die("missing argument for -multiarch-dir option");
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, 0x62016(%rip)     # 0x847d0
cmpq $0x0, 0x6200e(%rip)     # 0x847d0
jne 0x227d2
leaq 0x41af3(%rip), %rdi     # 0x642be
movb $0x0, %al
callq 0x17190
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_subopt_val
static int handle_subopt_val(const char *opt, const char *arg, const struct val_map *map, int *flag)
{
	const char *name;

	if (*arg++ != '=')
		die("missing argument for option '%s'", opt);
	for (;(name = map->name); map++) {
		if (strcmp(name, arg) == 0 || strcmp(name, "*") == 0) {
			*flag = map->val;
			return 1;
		}
		if (strcmp(name, "?") == 0)
			die("invalid argument '%s' in option '%s'", arg, opt);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0x228f1
movq -0x10(%rbp), %rsi
leaq 0x41a8a(%rip), %rdi     # 0x64374
movb $0x0, %al
callq 0x17190
jmp 0x228f3
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x2297f
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x111b0
cmpl $0x0, %eax
je 0x2292b
movq -0x30(%rbp), %rdi
leaq 0x40ed5(%rip), %rsi     # 0x637f6
callq 0x111b0
cmpl $0x0, %eax
jne 0x22941
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x22986
movq -0x30(%rbp), %rdi
leaq 0x40b80(%rip), %rsi     # 0x634cc
callq 0x111b0
cmpl $0x0, %eax
jne 0x2296c
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x41a30(%rip), %rdi     # 0x64395
movb $0x0, %al
callq 0x17190
jmp 0x2296e
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0x228f3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_onoff_switch
static char **handle_onoff_switch(char *arg, char **next, const struct flag flags[])
{
	int flag = FLAG_ON;
	char *p = arg + 1;
	unsigned i;

	// Prefixes "no" and "no-" mean to turn warning off.
	if (p[0] == 'n' && p[1] == 'o') {
		p += 2;
		if (p[0] == '-')
			p++;
		flag = FLAG_FORCE_OFF;
	}

	for (i = 0; flags[i].name; i++) {
		if (!strcmp(p,flags[i].name)) {
			*flags[i].flag = flag;
			return next;
		}
	}

	// Unknown.
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6e, %eax
jne 0x22a2b
movq -0x30(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x6f, %eax
jne 0x22a2b
movq -0x30(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x22a24
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movl $0x2, -0x24(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x20(%rbp), %rax
movl -0x34(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x22a93
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movl -0x34(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x111b0
cmpl $0x0, %eax
jne 0x22a86
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl -0x34(%rbp), %edx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq 0x8(%rax), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x22a9b
jmp 0x22a88
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x22a32
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_arch
static char **handle_arch(char *arg, char **next)
{
	enum machine mach;

	if (*arg++ != '=')
		die("missing argument for --arch option");

	mach = target_parse(arg);
	if (mach != MACH_UNKNOWN)
		target_config(mach);

	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0x22ae5
leaq 0x41d8e(%rip), %rdi     # 0x6486c
movb $0x0, %al
callq 0x17190
movq -0x8(%rbp), %rdi
callq 0x41d60
movl %eax, -0x14(%rbp)
cmpl $0x18, -0x14(%rbp)
je 0x22aff
movl -0x14(%rbp), %edi
callq 0x41f10
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_os
static char **handle_os(char *arg, char **next)
{
	if (*arg++ != '=')
		die("missing argument for --os option");

	target_os(arg);

	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0x22b45
leaq 0x41d51(%rip), %rdi     # 0x6488f
movb $0x0, %al
callq 0x17190
movq -0x8(%rbp), %rdi
callq 0x41e90
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_param
static char **handle_param(char *arg, char **next)
{
	char *value = NULL;

	/* For now just skip any '--param=*' or '--param *' */
	if (*arg == '\0') {
		value = *++next;
	} else if (isspace((unsigned char)*arg) || *arg == '=') {
		value = ++arg;
	}

	if (!value)
		die("missing argument for --param option");

	if (!strcmp(value, "dissect-show-all-symbols"))
		dissect_show_all_symbols = 1;

	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x22b9d
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x22bdb
callq 0x112f0
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x22bc9
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x22bd9
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq %rax, -0x18(%rbp)
jmp 0x22bdb
cmpq $0x0, -0x18(%rbp)
jne 0x22bf0
leaq 0x41cc7(%rip), %rdi     # 0x648b0
movb $0x0, %al
callq 0x17190
movq -0x18(%rbp), %rdi
leaq 0x41cd9(%rip), %rsi     # 0x648d4
callq 0x111b0
cmpl $0x0, %eax
jne 0x22c0f
movl $0x1, 0x6a595(%rip)     # 0x8d1a4
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_onoff_switch_finalize
static void handle_onoff_switch_finalize(const struct flag flags[])
{
	unsigned i;

	for (i = 0; flags[i].name; i++) {
		if (*flags[i].flag == FLAG_FORCE_OFF)
			*flags[i].flag = FLAG_OFF;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x22caf
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpl $0x2, (%rax)
jne 0x22ca2
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl $0x0, (%rax)
jmp 0x22ca4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x22c5f
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: init_parser
void init_parser(int stream)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(typedefs); i++)
		init_keyword(stream, &typedefs[i], NS_TYPEDEF);
	for (i = 0; i < ARRAY_SIZE(keywords); i++)
		init_keyword(stream, &keywords[i], NS_KEYWORD);

	for (i = 0; i < ARRAY_SIZE(ignored_attributes); i++) {
		const char * name = ignored_attributes[i];
		struct symbol *sym = create_symbol(stream, name, SYM_KEYWORD,
						   NS_KEYWORD);
		if (!sym->op) {
			sym->ident->keyword = 1;
			sym->op = &ignore_attr_op;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movslq -0x8(%rbp), %rax
cmpq $0x35, %rax
jae 0x22d36
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x62096(%rip), %rsi     # 0x84db0
shlq $0x5, %rax
addq %rax, %rsi
movl $0x2, %edx
callq 0x22e00
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x22d02
movl $0x0, -0x8(%rbp)
movslq -0x8(%rbp), %rax
cmpq $0x47, %rax
jae 0x22d71
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x626fb(%rip), %rsi     # 0x85450
shlq $0x5, %rax
addq %rax, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x22e00
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x22d3d
movl $0x0, -0x8(%rbp)
movslq -0x8(%rbp), %rax
cmpq $0x1a7, %rax            # imm = 0x1A7
jae 0x22dec
movslq -0x8(%rbp), %rcx
leaq 0x62fa1(%rip), %rax     # 0x85d30
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0xf, %edx
movl $0x100, %ecx            # imm = 0x100
callq 0x40ab0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x22ddf
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movb 0x11(%rax), %cl
andb $-0x5, %cl
orb $0x4, %cl
movb %cl, 0x11(%rax)
movq -0x18(%rbp), %rax
leaq 0x63c8d(%rip), %rcx     # 0x86a68
movq %rcx, 0x40(%rax)
jmp 0x22de1
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x22d78
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: init_keyword
static void init_keyword(int stream, struct init_keyword *kw, enum namespace ns)
{
	struct symbol *sym = create_symbol(stream, kw->name, SYM_KEYWORD, ns);
	sym->ident->keyword = 1;
	sym->ident->reserved |= (ns == NS_TYPEDEF);
	sym->ctype.modifiers = kw->mods;
	sym->ctype.base_type = kw->type;
	sym->op = kw->op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %ecx
movl $0xf, %edx
callq 0x40ab0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movb 0x11(%rax), %cl
andb $-0x5, %cl
orb $0x4, %cl
movb %cl, 0x11(%rax)
cmpl $0x2, -0x14(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movb 0x11(%rax), %cl
shrb %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %edx, %ecx
movb %cl, %dl
movb 0x11(%rax), %cl
andb $0x1, %dl
shlb %dl
andb $-0x3, %cl
orb %dl, %cl
movb %cl, 0x11(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: expect
struct token *expect(struct token *token, int op, const char *where)
{
	if (!match_op(token, op)) {
		if (token != &bad_token) {
			bad_token.next = token;
			sparse_error(token->pos, "Expected %s %s", show_special(op), where);
			sparse_error(token->pos, "got %s", show_token(token));
		}
		if (op == ';')
			return skip_to(token, op);
		return &bad_token;
	}
	return token->next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x22f6a
leaq 0x65521(%rip), %rax     # 0x88400
cmpq %rax, -0x10(%rbp)
je 0x22f45
movq -0x10(%rbp), %rax
movq %rax, 0x65518(%rip)     # 0x88408
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %edi
callq 0x440f0
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax), %rdi
leaq 0x419d8(%rip), %rsi     # 0x648ed
movb $0x0, %al
callq 0x16f90
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44420
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rdi
leaq 0x48d66(%rip), %rsi     # 0x6bca4
movb $0x0, %al
callq 0x16f90
cmpl $0x3b, -0x14(%rbp)
jne 0x22f5d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x22fc0
movq %rax, -0x8(%rbp)
jmp 0x22f76
leaq 0x6549c(%rip), %rax     # 0x88400
movq %rax, -0x8(%rbp)
jmp 0x22f76
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: alloc_statement
struct statement *alloc_statement(struct position pos, int type)
{
	struct statement *stmt = __alloc_statement(0);
	stmt->type = type;
	stmt->pos = pos;
	return stmt;
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x8, %esi
callq 0x3f450
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x230da
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0xc, %esi
callq 0x3f4d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0x8, %edx
callq 0x40a40
cmpl $0x0, -0xc(%rbp)
je 0x230d1
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0xfffdffff, %ecx       # imm = 0xFFFDFFFF
orl $0x20000, %ecx          # imm = 0x20000
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x230f0
movq -0x18(%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: typename
struct token *typename(struct token *token, struct symbol **p, int *forced)
{
	struct decl_state ctx = {.prefer_abstract = 1};
	unsigned long class;
	struct symbol *sym = alloc_symbol(token->pos, SYM_NODE);
	*p = sym;
	token = declaration_specifiers(token, &ctx);
	token = declarator(token, &ctx);
	apply_modifiers(token->pos, &ctx);
	sym->ctype = ctx.ctype;
	sym->endpos = token->pos;
	class = ctx.storage_class;
	if (forced)
		*forced = ctx.forced;
	if (class)
		warning(sym->pos, "storage class in typename (%s%s)",
			modifier_string(class), show_typename(sym));
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x11130
movb $0x1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x3, %esi
callq 0x3f4d0
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x23280
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x23620
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq -0x70(%rbp), %rsi
callq 0x23660
movq -0x80(%rbp), %rdi
addq $0x48, %rdi
addq $0x18, %rdi
leaq -0x70(%rbp), %rsi
movl $0x28, %edx
callq 0x111d0
movq -0x80(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0xc(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2321f
movzbl -0x1e(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x78(%rbp)
je 0x2326d
movq -0x80(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x78(%rbp), %rdi
callq 0x32730
movq %rax, -0x90(%rbp)
movq -0x80(%rbp), %rdi
callq 0x33340
movq -0x90(%rbp), %rdx
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x41696(%rip), %rsi     # 0x648fc
movb $0x0, %al
callq 0x16d80
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: apply_modifiers
static void apply_modifiers(struct position pos, struct decl_state *ctx)
{
	struct symbol *ctype;
	if (!ctx->mode)
		return;
	ctype = ctx->mode->to_mode(ctx->ctype.base_type);
	if (!ctype)
		sparse_error(pos, "don't know how to apply mode to %s",
				show_typename(ctx->ctype.base_type));
	else
		ctx->ctype.base_type = ctype;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x2367d
jmp 0x236cb
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x236c0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x33340
movq %rax, %rdx
movq -0x8(%rbp), %rdi
leaq 0x43681(%rip), %rsi     # 0x66d38
movb $0x0, %al
callq 0x16f90
jmp 0x236cb
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%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: check_label_usage
void check_label_usage(struct symbol *label, struct position use_pos)
{
	struct statement *def = label->stmt;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2373d
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x6d163(%rip), %rax     # 0x90878
movq (%rax), %rsi
callq 0x32220
cmpl $0x0, %eax
jne 0x2373b
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rdx
movq 0x4(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x23770
jmp 0x23768
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x23766
leaq 0x6d129(%rip), %rax     # 0x90878
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x50(%rax)
jmp 0x23768
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: warn_label_usage
static void warn_label_usage(struct position def, struct position use, struct ident *ident)
{
	const char *id = show_ident(ident);
	sparse_error(use, "label '%s' used outside statement expression", id);
	info(def, "   label '%s' defined here", id);
	current_fn->bogus_linear = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x44150
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rdi
leaq 0x435bb(%rip), %rsi     # 0x66d5b
movb $0x0, %al
callq 0x16f90
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rdi
leaq 0x435d2(%rip), %rsi     # 0x66d88
movb $0x0, %al
callq 0x16c10
leaq 0x92b8c(%rip), %rax     # 0xb6350
movq (%rax), %rax
movl 0x54(%rax), %ecx
andl $0xfffffeff, %ecx       # imm = 0xFFFFFEFF
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x54(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: compound_statement
struct token *compound_statement(struct token *token, struct statement *stmt)
{
	stmt->type = STMT_COMPOUND;
	start_block_scope();
	token = statement_list(token, &stmt->stmts);
	end_block_scope();
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x3, (%rax)
callq 0x31e70
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x23830
movq %rax, -0x8(%rbp)
callq 0x32020
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: statement_list
static struct token * statement_list(struct token *token, struct statement_list **list)
{
	int seen_statement = 0;
	while (token_type(token) == TOKEN_IDENT &&
	       token->ident == &__label___ident)
		token = label_statement(token->next);
	for (;;) {
		struct statement * stmt;
		if (eof_token(token))
			break;
		if (match_op(token, '}'))
			break;
		if (match_ident(token, &_Static_assert_ident)) {
			token = parse_static_assert(token, NULL);
			continue;
		}
		if (lookup_type(token)) {
			if (seen_statement) {
				warning(token->pos, "mixing declarations and code");
				seen_statement = 0;
			}
			stmt = alloc_statement(token->pos, STMT_DECLARATION);
			token = external_declaration(token, &stmt->declaration, NULL);
		} else {
			seen_statement = Wdeclarationafterstatement;
			token = statement(token, &stmt);
		}
		add_statement(list, stmt);
	}
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x3, %ecx
movb %al, -0x21(%rbp)
jne 0x23873
movq -0x8(%rbp), %rax
leaq 0x66a87(%rip), %rcx     # 0x8a2f0
cmpq %rcx, 0x10(%rax)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x2387c
jmp 0x2388f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x29930
movq %rax, -0x8(%rbp)
jmp 0x23847
jmp 0x23891
leaq 0x89128(%rip), %rax     # 0xac9c0
cmpq %rax, -0x8(%rbp)
jne 0x238a3
jmp 0x23972
movq -0x8(%rbp), %rdi
movl $0x7d, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x238bb
jmp 0x23972
movq -0x8(%rbp), %rdi
leaq 0x6689a(%rip), %rsi     # 0x8a160
callq 0x25910
cmpl $0x0, %eax
je 0x238e3
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x25950
movq %rax, -0x8(%rbp)
jmp 0x23891
movq -0x8(%rbp), %rdi
callq 0x24680
cmpl $0x0, %eax
je 0x23943
cmpl $0x0, -0x14(%rbp)
je 0x23913
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x4349e(%rip), %rsi     # 0x66da3
movb $0x0, %al
callq 0x16d80
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x23020
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x23ba0
movq %rax, -0x8(%rbp)
jmp 0x23960
leaq 0x60ed2(%rip), %rax     # 0x8481c
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x26c20
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x27900
jmp 0x23891
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: initializer
struct token *initializer(struct expression **tree, struct token *token)
{
	if (match_op(token, '{')) {
		struct expression *expr = alloc_expression(token->pos, EXPR_INITIALIZER);
		*tree = expr;
		if (!Wuniversal_initializer) {
			struct token *next = token->next;
			// '{ 0 }' is equivalent to '{ }' except for some
			// warnings, like using 0 to initialize a null-pointer.
			if (match_token_zero(next)) {
				if (match_op(next->next, '}'))
					expr->zero_init = 1;
			}
		}

		token = initializer_list(&expr->expr_list, token->next);
		return expect(token, '}', "at end of initializer");
	}
	return assignment_expression(token, tree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x7b, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x23a50
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x18, %esi
callq 0x23a70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
leaq 0x6985e(%rip), %rax     # 0x8d22c
cmpl $0x0, (%rax)
jne 0x23a1c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x23ad0
cmpl $0x0, %eax
je 0x23a1a
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x7d, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x23a18
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0xfffeffff, %ecx       # imm = 0xFFFEFFFF
orl $0x10000, %ecx          # imm = 0x10000
movl %ecx, (%rax)
jmp 0x23a1a
jmp 0x23a1c
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x23b30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x7d, %esi
leaq 0x40ed8(%rip), %rdx     # 0x6491d
callq 0x22eb0
movq %rax, -0x8(%rbp)
jmp 0x23a61
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x57130
movq %rax, -0x8(%rbp)
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: initializer_list
static struct token *initializer_list(struct expression_list **list, struct token *token)
{
	struct expression *expr;

	for (;;) {
		token = single_initializer(&expr, token);
		if (!expr)
			break;
		add_expression(list, expr);
		if (!match_op(token, ','))
			break;
		token = token->next;
	}
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x299e0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x23b5a
jmp 0x23b8a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x27e10
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x23b7c
jmp 0x23b8a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x23b40
movq -0x10(%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: handle_asm_name
static struct token *handle_asm_name(struct token *token, struct decl_state *ctx)
{
	struct expression *expr;
	struct symbol *keyword;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
je 0x2457d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2461e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x244c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x245a4
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2461e
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl (%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x245c0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2461e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x28, %esi
leaq 0x40d91(%rip), %rdx     # 0x6536d
callq 0x22eb0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq 0x42882(%rip), %rdx     # 0x66e76
callq 0x55ce0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x29, %esi
leaq 0x40d60(%rip), %rdx     # 0x6536d
callq 0x22eb0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/./expression.h
// Function: lookup_type
static inline int lookup_type(struct token *token)
{
	if (token->pos.type == TOKEN_IDENT) {
		struct symbol *sym = lookup_symbol(token->ident, NS_SYMBOL | NS_TYPEDEF);
		return sym && (sym->namespace & NS_TYPEDEF);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x246e5
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x12, %esi
callq 0x3f450
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x246d8
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0x1ff, %eax            # imm = 0x1FF
andl $0x2, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x246ec
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
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_k_r_arguments
static struct token *parse_k_r_arguments(struct token *token, struct symbol *decl,
	struct symbol_list **list)
{
	struct symbol_list *args = NULL;

	if (Wold_style_definition)
		warning(token->pos, "non-ANSI definition of function '%s'", show_ident(decl->ident));

	do {
		token = declaration_list(token, &args);
		if (!match_op(token, ';')) {
			sparse_error(token->pos, "expected ';' at end of parameter declaration");
			break;
		}
		token = token->next;
	} while (lookup_type(token));

	apply_k_r_types(args, decl);

	if (!match_op(token, '{')) {
		sparse_error(token->pos, "expected function body");
		return token;
	}
	return parse_function_body(token, decl, list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
leaq 0x60125(%rip), %rax     # 0x84848
cmpl $0x0, (%rax)
je 0x24755
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44150
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rdi
leaq 0x42731(%rip), %rsi     # 0x66e7f
movb $0x0, %al
callq 0x16d80
jmp 0x24757
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x25ac0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3b, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x24792
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x4271b(%rip), %rsi     # 0x66ea4
movb $0x0, %al
callq 0x16f90
jmp 0x247ac
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x24680
cmpl $0x0, %eax
jne 0x24757
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x29d80
movq -0x10(%rbp), %rdi
movl $0x7b, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x247eb
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x426f7(%rip), %rsi     # 0x66ed1
movb $0x0, %al
callq 0x16f90
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x24800
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x24810
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: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
andq $0x20, %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x32860
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x24c8b
movq -0x28(%rbp), %rax
andq $-0xd, %rax
cmpq $0x0, %rax
je 0x24c8b
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rdx
movq (%rax), %rdi
leaq 0x3ff88(%rip), %rsi     # 0x64c0a
movb $0x0, %al
callq 0x16f90
jmp 0x24ce6
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x24ca4
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
jmp 0x24ce4
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x24ccd
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rdx
movq (%rax), %rdi
leaq 0x3ff68(%rip), %rsi     # 0x64c2c
movb $0x0, %al
callq 0x16f90
jmp 0x24ce2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3ff5e(%rip), %rsi     # 0x64c39
movb $0x0, %al
callq 0x16f90
jmp 0x24ce4
jmp 0x24ce6
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
andq $-0xd, %rax
cmpq $0x0, %rax
jne 0x24d2a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x20, %edx
callq 0x24d70
jmp 0x24d57
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x32860
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x3feba(%rip), %rsi     # 0x64c0a
movb $0x0, %al
callq 0x16f90
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: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x28, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x24ee9
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3fd95(%rip), %rsi     # 0x64c6a
movb $0x0, %al
callq 0x16f90
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x24fd4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x24680
cmpl $0x0, %eax
je 0x24f41
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x23160
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $0x48, %rdx
addq $0x18, %rdx
movq (%rax), %rdi
callq 0x24fe0
jmp 0x24fbb
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xa, %esi
callq 0x3f4d0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rsi
addq $0x48, %rsi
addq $0x68, %rsi
callq 0x55cb0
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0xc(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
jne 0x24fb0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3fce6(%rip), %rsi     # 0x64c84
movb $0x0, %al
callq 0x16f90
leaq 0x6dcec(%rip), %rax     # 0x92c98
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movl $0x29, %esi
leaq 0x3fcac(%rip), %rdx     # 0x64c77
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x25018
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x24d70
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x31a70
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x2504f
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2506a
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl $0x28, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x250f0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3fbd0(%rip), %rsi     # 0x64cac
movb $0x0, %al
callq 0x16f90
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2520c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x24680
cmpl $0x0, %eax
je 0x25156
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x23160
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3f650
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x70(%rax), %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl $0x29, %esi
leaq 0x3fb7d(%rip), %rdx     # 0x64cc8
callq 0x22eb0
movq %rax, -0x10(%rbp)
jmp 0x25196
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq 0x3fb4c(%rip), %rdx     # 0x64cb9
callq 0x55b00
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2518a
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2520c
movq -0x38(%rbp), %rdi
callq 0x12170
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x251bb
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3fb31(%rip), %rsi     # 0x64cdb
movb $0x0, %al
callq 0x16d80
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2520c
movl -0x24(%rbp), %eax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x251ea
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3fb19(%rip), %rsi     # 0x64cf2
movb $0x0, %al
callq 0x16d80
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2520c
movslq -0x24(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x25204
movslq -0x24(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x28, %esi
leaq 0x3fac7(%rip), %rdx     # 0x64d0b
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x28, %esi
leaq 0x3faae(%rip), %rdx     # 0x64d0b
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x252fd
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x244c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x252ca
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x40(%rax)
je 0x252ca
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x252d7
movq -0x8(%rbp), %rdi
callq 0x25340
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x252ec
jmp 0x252fd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x25266
movq -0x8(%rbp), %rdi
movl $0x29, %esi
leaq 0x3f9fe(%rip), %rdx     # 0x64d0b
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x29, %esi
leaq 0x3f9e5(%rip), %rdx     # 0x64d0b
callq 0x22eb0
movq %rax, -0x8(%rbp)
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: recover_unknown_attribute
static struct token *recover_unknown_attribute(struct token *token)
{
	struct expression *expr = NULL;

	if (Wunknown_attribute)
		warning(token->pos, "unknown attribute '%s'", show_ident(token->ident));
	token = token->next;
	if (match_op(token, '('))
		token = parens_expression(token, &expr, "in attribute");
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x67ed5(%rip), %rax     # 0x8d230
cmpl $0x0, (%rax)
je 0x2538d
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x44150
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x3f995(%rip), %rsi     # 0x64d1b
movb $0x0, %al
callq 0x16d80
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x28, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x253c4
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq 0x3f977(%rip), %rdx     # 0x64d32
callq 0x55b00
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: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
addq $0x50, %rsi
callq 0x25850
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %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 0x2577c
jmp 0x25840
jmp 0x2577e
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 0x25828
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x257cd
cmpq $0x0, -0x18(%rbp)
jne 0x257cd
jmp 0x2581a
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x257ff
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x257fd
movq -0x50(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0xb, %eax
jne 0x257fd
jmp 0x2581a
jmp 0x257ff
cmpq $0x0, -0x20(%rbp)
je 0x25812
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x25785
jmp 0x2582a
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x2577e
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x7d, %esi
callq 0x22f80
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2587f
jmp 0x25906
movq -0x8(%rbp), %rdi
leaq 0x648d6(%rip), %rsi     # 0x8a160
callq 0x25910
cmpl $0x0, %eax
je 0x258a7
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x25950
movq %rax, -0x8(%rbp)
jmp 0x25860
movq -0x8(%rbp), %rdi
movl $0x3b, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x258cb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25ac0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3b, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x258f5
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3f4a9(%rip), %rsi     # 0x64d95
movb $0x0, %al
callq 0x16f90
jmp 0x25906
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x25860
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq