LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/semind.c
// Function: command_rm
static void command_rm(int argc, char **argv)
{
	sqlite3_stmt *stmt;

	sqlite_command("BEGIN IMMEDIATE");
	sqlite_prepare("DELETE FROM file WHERE name GLOB @file", &stmt);

	if (semind_verbose > 1)
		message("SQL: %s", sqlite3_sql(stmt));

	for (int i = 0; i < argc; i++) {
		sqlite_bind_text(stmt, "@file",  argv[i], -1);
		sqlite_run(stmt);
		sqlite_reset_stmt(stmt);
	}

	sqlite3_finalize(stmt);
	sqlite_command("COMMIT");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x339a3(%rip), %rdi     # 0x442cd
callq 0x113cc
leaq 0x33db9(%rip), %r14     # 0x446ef
movq %rsp, %r15
movq 0x5bda0(%rip), %rdi     # 0x6c6e0
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xf4a0
cmpl $0x5, %eax
je 0x10939
testl %eax, %eax
jne 0x10a44
cmpl $0x2, 0x5bd85(%rip)     # 0x6c6ec
jge 0x10a21
testl %ebp, %ebp
jle 0x109fd
movl %ebp, %ebp
leaq 0x33d92(%rip), %r14     # 0x44710
xorl %r15d, %r15d
movq (%rsp), %r12
movq (%rbx,%r15,8), %r13
movq %r12, %rdi
movq %r14, %rsi
callq 0xf480
movq %r12, %rdi
movl %eax, %esi
movq %r13, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %r8d, %r8d
callq 0xf2e0
testl %eax, %eax
jne 0x109d4
movq (%rsp), %rdi
callq 0x113a4
movq (%rsp), %r12
movq %r12, %rdi
callq 0xf110
movq %r12, %rdi
callq 0xf080
incq %r15
cmpq %r15, %rbp
jne 0x10981
jmp 0x109fd
movq 0x5bd05(%rip), %rdi     # 0x6c6e0
callq 0xf3d0
movl $0x1, %edi
xorl %esi, %esi
leaq 0x33a85(%rip), %rdx     # 0x44473
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xf570
jmp 0x109ad
movq (%rsp), %rdi
callq 0xf290
leaq 0x338d0(%rip), %rdi     # 0x442dd
callq 0x113cc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rdi
callq 0xf0e0
leaq 0x33ce5(%rip), %rdx     # 0x44716
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0xf570
jmp 0x1096d
movq 0x5bc95(%rip), %rdi     # 0x6c6e0
callq 0xf3d0
leaq 0x33b43(%rip), %rdx     # 0x4459a
leaq 0x33c91(%rip), %r8      # 0x446ef
movl $0x1, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0xf570
jmp 0x10960
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/semind.c
// Function: show_usage
static void show_usage(void)
{
	if (semind_command)
		printf("Try '%s %s --help' for more information.\n",
		       progname, semind_command);
	else
		printf("Try '%s --help' for more information.\n",
		       progname);
	exit(1);
}

// Assembly:
pushq %rax
movq 0x5b5ee(%rip), %rdx     # 0x6c6d8
movq 0x5a5cf(%rip), %rsi     # 0x6b6c0
testq %rdx, %rdx
jne 0x11106
leaq 0x331a9(%rip), %rdi     # 0x442a6
xorl %eax, %eax
callq 0xf050
jmp 0x11114
leaq 0x3316f(%rip), %rdi     # 0x4427c
xorl %eax, %eax
callq 0xf050
movl $0x1, %edi
callq 0xf120
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/semind.c
// Function: r_symbol
static void r_symbol(unsigned mode, struct position *pos, struct symbol *sym)
{
	static struct ident null;
	struct ident *ctx = &null;
	struct index_record rec;

	update_stream();

	if (semind_streams[pos->stream].id == -1)
		return;

	if (!semind_include_local_syms && sym_is_local(sym))
		return;

	if (!sym->ident) {
		warning(*pos, "empty ident");
		return;
	}

	if (dissect_ctx)
		ctx = dissect_ctx->ident;

	rec.context = ctx->name;
	rec.ctx_len = ctx->len;
	rec.symbol  = sym->ident->name;
	rec.sym_len = sym->ident->len;
	rec.kind    = sym->kind;
	rec.mode    = mode;
	rec.file    = semind_streams[pos->stream].id;
	rec.line    = pos->line;
	rec.col     = pos->pos;

	insert_record(&rec);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebx
callq 0x1141d
movq 0x5b5cb(%rip), %rax     # 0x6c728
movq (%r15), %rdi
movl %edi, %ecx
shrl $0x3, %ecx
andl $0x1fff8, %ecx          # imm = 0x1FFF8
movq (%rax,%rcx), %rcx
cmpq $-0x1, %rcx
je 0x1122c
cmpb $0x0, 0x5b568(%rip)     # 0x6c6e8
je 0x111a0
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x111be
leaq 0x5ba3e(%rip), %rax     # 0x6cbd0
movq (%rax), %rax
testq %rax, %rax
je 0x111d5
movq 0x18(%rax), %rsi
jmp 0x111dc
movq 0x30(%r14), %rax
leaq 0x58a9d(%rip), %rdx     # 0x69c48
cmpq %rax, (%rdx)
je 0x11182
leaq 0x58a99(%rip), %rdx     # 0x69c50
cmpq %rax, (%rdx)
jne 0x1122c
jmp 0x11182
leaq 0x33278(%rip), %rsi     # 0x4443d
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x13394
leaq 0x5b554(%rip), %rsi     # 0x6c730
leaq 0x12(%rsi), %r8
movq %rsp, %rax
movq %r8, (%rax)
movzbl 0x10(%rsi), %esi
movl %esi, 0x8(%rax)
leaq 0x12(%rdx), %rsi
movq %rsi, 0x10(%rax)
movzbl 0x10(%rdx), %edx
movl %edx, 0x18(%rax)
movsbl 0xd0(%r14), %edx
movl %edx, 0x1c(%rax)
movl %ebx, 0x20(%rax)
movq %rcx, 0x30(%rax)
movq %rdi, %rcx
shrq $0x20, %rcx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl %ecx, 0x38(%rax)
shrl $0x16, %edi
movl %edi, 0x3c(%rax)
movq %rax, %rdi
callq 0x1179c
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/semind.c
// Function: r_member
static void r_member(unsigned mode, struct position *pos, struct symbol *sym, struct symbol *mem)
{
	static struct ident null;
	static char memname[1024];
	struct ident *ni, *si, *mi;
	struct ident *ctx = &null;
	struct index_record rec;

	update_stream();

	if (semind_streams[pos->stream].id == -1)
		return;

	if (!semind_include_local_syms && sym_is_local(sym))
		return;

	ni = built_in_ident("?");
	si = sym->ident ?: ni;
	/* mem == NULL means entire struct accessed */
	mi = mem ? (mem->ident ?: ni) : built_in_ident("*");

	if (dissect_ctx)
		ctx = dissect_ctx->ident;

	snprintf(memname, sizeof(memname), "%.*s.%.*s", si->len, si->name, mi->len, mi->name);

	rec.context = ctx->name;
	rec.ctx_len = ctx->len;
	rec.symbol  = memname;
	rec.sym_len = si->len + mi->len + 1;
	rec.kind    = 'm';
	rec.mode    = mode;
	rec.file    = semind_streams[pos->stream].id;
	rec.line    = pos->line;
	rec.col     = pos->pos;

	insert_record(&rec);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movl %edi, %ebp
callq 0x1141d
movq 0x5b4cd(%rip), %rax     # 0x6c728
movl (%rbx), %ecx
shrl $0x3, %ecx
andl $0x1fff8, %ecx          # imm = 0x1FFF8
cmpq $-0x1, (%rax,%rcx)
je 0x11395
cmpb $0x0, 0x5b470(%rip)     # 0x6c6e8
je 0x112a7
leaq 0x3deeb(%rip), %rdi     # 0x4f16c
callq 0x239ff
movq 0x18(%r12), %r12
testq %r12, %r12
cmoveq %rax, %r12
testq %r15, %r15
je 0x112ca
movq %rax, %r14
movq 0x18(%r15), %rax
testq %rax, %rax
cmovneq %rax, %r14
jmp 0x112d9
movq 0x30(%r12), %rax
leaq 0x58995(%rip), %rcx     # 0x69c48
cmpq %rax, (%rcx)
je 0x1127a
leaq 0x58991(%rip), %rcx     # 0x69c50
cmpq %rax, (%rcx)
jne 0x11395
jmp 0x1127a
leaq 0x3e18f(%rip), %rdi     # 0x4f460
callq 0x239ff
movq %rax, %r14
leaq 0x5b8f0(%rip), %rax     # 0x6cbd0
movq (%rax), %rax
testq %rax, %rax
je 0x112ee
movq 0x18(%rax), %r13
jmp 0x112f5
leaq 0x5b45b(%rip), %r13     # 0x6c750
movzbl 0x10(%r12), %ecx
leaq 0x12(%r12), %r8
movzbl 0x10(%r14), %r9d
leaq 0x12(%r14), %rax
movq %rax, (%rsp)
leaq 0x5b45c(%rip), %r15     # 0x6c770
leaq 0x331a3(%rip), %rdx     # 0x444be
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdi
xorl %eax, %eax
callq 0xf090
leaq 0x12(%r13), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movzbl 0x10(%r13), %eax
movl %eax, 0x8(%rdi)
movq %r15, 0x10(%rdi)
movzbl 0x10(%r12), %eax
movzbl 0x10(%r14), %ecx
leal 0x1(%rax,%rcx), %eax
movl %eax, 0x18(%rdi)
movl $0x6d, 0x1c(%rdi)
movl %ebp, 0x20(%rdi)
movq 0x5b3c3(%rip), %rax     # 0x6c728
movq (%rbx), %rcx
movl %ecx, %edx
shrl $0x3, %edx
andl $0x1fff8, %edx          # imm = 0x1FFF8
movq (%rax,%rdx), %rax
movq %rax, 0x30(%rdi)
movq %rcx, %rax
shrq $0x20, %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, 0x38(%rdi)
shrl $0x16, %ecx
movl %ecx, 0x3c(%rdi)
callq 0x1179c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/semind.c
// Function: sqlite_run
static int sqlite_run(sqlite3_stmt *stmt)
{
	int ret = sqlite3_step(stmt);
	if (ret != SQLITE_DONE && ret != SQLITE_ROW)
		semind_error(1, 0, "unable to process query: %s: %s", sqlite3_errmsg(semind_db), sqlite3_sql(stmt));
	return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf300
movl %eax, %ebp
addl $-0x66, %eax
cmpl $-0x3, %eax
jbe 0x113c2
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0xf683
jmp 0x113b9
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/semind.c
// Function: sqlite_command
static void sqlite_command(const char *sql)
{
	sqlite3_stmt *stmt;
	sqlite_prepare(sql, &stmt);
	sqlite_run(stmt);
	sqlite3_finalize(stmt);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq 0x5b303(%rip), %rdi     # 0x6c6e0
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r14, %rcx
xorl %r8d, %r8d
callq 0xf4a0
cmpl $0x5, %eax
je 0x113d6
testl %eax, %eax
jne 0x11413
movq (%rsp), %rdi
callq 0x113a4
movq (%rsp), %rdi
callq 0xf290
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0xf6c1
jmp 0x113f9
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/semind.c
// Function: insert_record
static void insert_record(struct index_record *rec)
{
	sqlite_bind_text(insert_rec_stmt,  "@context", rec->context, rec->ctx_len);
	sqlite_bind_text(insert_rec_stmt,  "@symbol",  rec->symbol, rec->sym_len);
	sqlite_bind_int64(insert_rec_stmt, "@kind",    rec->kind);
	sqlite_bind_int64(insert_rec_stmt, "@mode",    rec->mode);
	sqlite_bind_int64(insert_rec_stmt, "@file",    rec->file);
	sqlite_bind_int64(insert_rec_stmt, "@line",    rec->line);
	sqlite_bind_int64(insert_rec_stmt, "@column",  rec->col);
	sqlite_run(insert_rec_stmt);
	sqlite_reset_stmt(insert_rec_stmt);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x5af5b(%rip), %r14     # 0x6c708
movq (%rdi), %r15
movl 0x8(%rdi), %ebp
leaq 0x32cd9(%rip), %rsi     # 0x44493
movq %r14, %rdi
callq 0xf480
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0xf2e0
testl %eax, %eax
jne 0x11927
movq 0x5af25(%rip), %r14     # 0x6c708
movq 0x10(%rbx), %r15
movl 0x18(%rbx), %ebp
leaq 0x32cab(%rip), %rsi     # 0x4449c
movq %r14, %rdi
callq 0xf480
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0xf2e0
testl %eax, %eax
jne 0x11931
movq 0x5aeee(%rip), %r14     # 0x6c708
movslq 0x1c(%rbx), %r15
leaq 0x32c7f(%rip), %rsi     # 0x444a4
movq %r14, %rdi
callq 0xf480
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
callq 0xf250
testl %eax, %eax
jne 0x1193b
movq 0x5aebf(%rip), %r14     # 0x6c708
movl 0x20(%rbx), %r15d
leaq 0x32c56(%rip), %rsi     # 0x444aa
movq %r14, %rdi
callq 0xf480
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
callq 0xf250
testl %eax, %eax
jne 0x11945
movq 0x5ae90(%rip), %r14     # 0x6c708
movq 0x30(%rbx), %r15
leaq 0x32e8d(%rip), %rsi     # 0x44710
movq %r14, %rdi
callq 0xf480
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
callq 0xf250
testl %eax, %eax
jne 0x1194f
movq 0x5ae61(%rip), %r14     # 0x6c708
movslq 0x38(%rbx), %r15
leaq 0x32bfe(%rip), %rsi     # 0x444b0
movq %r14, %rdi
callq 0xf480
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
callq 0xf250
testl %eax, %eax
jne 0x11959
movq 0x5ae32(%rip), %r14     # 0x6c708
movslq 0x3c(%rbx), %rbx
leaq 0x32bd5(%rip), %rsi     # 0x444b6
movq %r14, %rdi
callq 0xf480
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0xf250
testl %eax, %eax
jne 0x11963
movq 0x5ae07(%rip), %rdi     # 0x6c708
callq 0x113a4
movq 0x5adfb(%rip), %rbx     # 0x6c708
movq %rbx, %rdi
callq 0xf110
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xf080
callq 0xf824
jmp 0x117dc
callq 0xf850
jmp 0x11813
callq 0xf87c
jmp 0x11842
callq 0xf8a8
jmp 0x11871
callq 0xf8d4
jmp 0x118a0
callq 0xf900
jmp 0x118cf
callq 0xf92c
jmp 0x118fa
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/dissect.c
// Function: do_symbol
static inline struct symbol *do_symbol(struct symbol *sym)
{
	struct symbol *type = base_type(sym);
	struct symbol *dctx = dissect_ctx;
	struct statement *stmt;

	reporter->r_symdef(sym);

	switch (type->type) {
	default:
		if (!sym->initializer)
			break;
		reporter->r_symbol(U_W_VAL, &sym->pos, sym);
		if (!dctx)
			dissect_ctx = sym;
		do_initializer(type, sym->initializer);
		dissect_ctx = dctx;

	break; case SYM_FN:
		stmt = sym->ctype.modifiers & MOD_INLINE
			? type->inline_stmt : type->stmt;
		if (!stmt)
			break;

		if (dctx)
			sparse_error(dctx->pos, "dissect_ctx change %s -> %s",
				show_ident(dctx->ident), show_ident(sym->ident));

		dissect_ctx = sym;
		do_sym_list(type->arguments);
		do_statement(U_VOID, stmt);
		dissect_ctx = dctx;
	}

	return type;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x12d51
movq %rax, %r14
movq 0x5a991(%rip), %r13     # 0x6cbd0
movq 0x5a982(%rip), %rax     # 0x6cbc8
movq %rbx, %rdi
callq *(%rax)
cmpb $0x5, (%r14)
jne 0x122c1
movb 0x68(%rbx), %al
andb $0x40, %al
shrb $0x6, %al
movzbl %al, %eax
shll $0x4, %eax
movq 0x90(%rax,%r14), %r15
testq %r15, %r15
je 0x12303
testq %r13, %r13
je 0x122a2
movq 0x18(%r13), %rdi
callq 0x230a1
movq %rax, %r12
movq 0x18(%rbx), %rdi
callq 0x230a1
movq 0x4(%r13), %rdi
leaq 0x33307(%rip), %rsi     # 0x4559c
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x13518
movq %rbx, 0x5a927(%rip)     # 0x6cbd0
movq 0x88(%r14), %rdi
callq 0x1200e
xorl %edi, %edi
movq %r15, %rsi
callq 0x12b03
jmp 0x122fc
cmpq $0x0, 0xb0(%rbx)
je 0x12303
movq 0x5a8f6(%rip), %rax     # 0x6cbc8
leaq 0x4(%rbx), %rsi
movl $0x8, %edi
movq %rbx, %rdx
callq *0x10(%rax)
testq %r13, %r13
jne 0x122ed
movq %rbx, 0x5a8e3(%rip)     # 0x6cbd0
movq 0xb0(%rbx), %rsi
movq %r14, %rdi
callq 0x12d83
movq %r13, 0x5a8cd(%rip)     # 0x6cbd0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/dissect.c
// Function: deanon
static bool deanon(struct symbol *base, struct ident *node, struct symbol *parent)
{
	struct ident *pi = parent ? parent->ident : NULL;
	char name[256];

	if (!node) {
		base->ident = pi;
		return false;
	}

	snprintf(name, sizeof(name), "%.*s:%.*s",
		pi ? pi->len : 0, pi ? pi->name : NULL, node->len, node->name);

	base->ident = built_in_ident(name);
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
testq %rdx, %rdx
je 0x12ab0
movq 0x18(%rdx), %rax
xorl %ecx, %ecx
testq %rsi, %rsi
je 0x12af2
testq %rax, %rax
je 0x12abb
movzbl 0x10(%rax), %ecx
addq $0x12, %rax
jmp 0x12abd
xorl %eax, %eax
xorl %ecx, %ecx
testq %rsi, %rsi
jne 0x12abd
jmp 0x12af2
xorl %eax, %eax
movzbl 0x10(%rsi), %r9d
addq $0x12, %rsi
movq %rsi, (%rsp)
leaq 0x32ac1(%rip), %rdx     # 0x45592
leaq 0x10(%rsp), %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movq %rax, %r8
xorl %eax, %eax
callq 0xf090
movq %r14, %rdi
callq 0x239ff
movb $0x1, %cl
movq %rax, 0x18(%rbx)
movl %ecx, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/dissect.c
// Function: base_type
static struct symbol *base_type(struct symbol *sym)
{
	if (!sym)
		return &bad_ctype;

	if (sym->type == SYM_NODE)
		examine_sym_node(sym, NULL);

	return sym->ctype.base_type	// builtin_fn_type
		?: &bad_ctype;
}

// Assembly:
testq %rdi, %rdi
je 0x12d7b
pushq %rbx
movq %rdi, %rbx
cmpb $0x3, (%rdi)
jne 0x12d69
movq %rbx, %rdi
xorl %esi, %esi
callq 0x12065
movq 0x60(%rbx), %rax
testq %rax, %rax
jne 0x12d79
leaq 0x5fe87(%rip), %rax     # 0x72c00
popq %rbx
retq
leaq 0x5fe7e(%rip), %rax     # 0x72c00
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/dissect.c
// Function: report_implicit
static void report_implicit(usage_t mode, struct position *pos, struct symbol *type)
{
	if (type->type != SYM_STRUCT && type->type != SYM_UNION)
		return;

	if (type->ident != NULL)
		reporter->r_member(mode, pos, type, NULL);

	DO_LIST(type->symbol_list, mem,
		report_implicit(mode, pos, base_type(mem)));
}

// Assembly:
movzbl (%rdx), %eax
addl $-0x7, %eax
cmpl $0x1, %eax
ja 0x1303a
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
cmpq $0x0, 0x18(%rdx)
je 0x12fd5
movq 0x59c00(%rip), %rax     # 0x6cbc8
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq *0x18(%rax)
movq 0x98(%r14), %r14
testq %r14, %r14
je 0x13032
movq %r14, %r15
movzwl (%r15), %eax
testb %al, %al
jle 0x13029
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %rdi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x13004
testq %rdi, %rdi
je 0x1301a
callq 0x12d51
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x12f9b
movzwl (%r15), %eax
incq %r12
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r12
jl 0x12fef
movq 0x10(%r15), %r15
cmpq %r14, %r15
jne 0x12fe4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/dissect.c
// Function: report_member
static struct symbol *report_member(usage_t mode, struct position *pos,
					struct symbol *type, struct symbol *mem)
{
	struct symbol *ret = mem->ctype.base_type;

	if (mem->ident || mem->type == SYM_BAD)
		reporter->r_member(fix_mode(ret, mode), pos, type, mem);

	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %esi
movq 0x60(%rcx), %rbx
cmpq $0x0, 0x18(%rcx)
jne 0x13060
cmpb $0x10, (%r14)
jne 0x13081
movq 0x59b61(%rip), %rax     # 0x6cbc8
movq 0x18(%rax), %r13
movq %rbx, %rdi
callq 0x130f7
movl %eax, %edi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *%r13
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/dissect.c
// Function: fix_mode
static usage_t fix_mode(struct symbol *type, usage_t mode)
{
	mode &= (U_SELF | (U_SELF << U_SHIFT));

	switch (type->type) {
		case SYM_BASETYPE:
			if (!type->ctype.base_type)
				break;
		case SYM_ENUM:
		case SYM_BITFIELD:
			if (mode & U_MASK)
				mode &= U_SELF;
		default:

		break; case SYM_FN:
			if (mode & U_R_VAL)
				mode |= U_R_AOF;
			mode &= ~(U_R_VAL | U_W_AOF);

		break; case SYM_ARRAY:
			if (mode & (U_MASK << U_SHIFT))
				mode >>= U_SHIFT;
			else if (mode != U_W_VAL)
				mode = u_addr(mode);
	}

	if (!(mode & U_R_AOF))
		mode &= ~U_W_AOF;

	return mode;
}

// Assembly:
movzwl %si, %ecx
movzbl (%rdi), %eax
addl $-0x2, %eax
cmpl $0x9, %eax
ja 0x1314f
leaq 0x32438(%rip), %rdx     # 0x45544
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
testb $0xd, %sil
jne 0x13137
jmp 0x1314f
testl $0xd00, %esi            # imm = 0xD00
je 0x1315b
shrl $0x8, %ecx
jmp 0x1314f
testb $0xd, %sil
je 0x1314f
cmpq $0x0, 0x60(%rdi)
je 0x1314f
movzbl %sil, %ecx
jmp 0x1314f
movl %esi, %eax
shrl $0x2, %eax
andl $0x1, %eax
andl $0xfff9, %esi           # imm = 0xFFF9
orl %eax, %esi
movl %esi, %ecx
movl %ecx, %eax
andl $-0x4, %eax
testb $0x1, %cl
cmovnel %ecx, %eax
retq
cmpl $0x8, %ecx
movl $0x8, %ecx
je 0x1314f
movl %esi, %eax
andl $0xd, %eax
andl $0x2, %esi
incl %esi
testl %eax, %eax
cmovel %eax, %esi
jmp 0x1314d
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/dissect.c
// Function: _lookup_member
static struct symbol *__lookup_member(struct symbol *type, struct ident *name, int *p_addr)
{
	struct symbol *node;
	int addr = 0;

	FOR_EACH_PTR(type->symbol_list, node)
		if (!name) {
			if (addr == *p_addr)
				return node;
		}
		else if (node->ident == NULL) {
			node = __lookup_member(node->ctype.base_type, name, NULL);
			if (node)
				goto found;
		}
		else if (node->ident == name) {
found:
			if (p_addr)
				*p_addr = addr;
			return node;
		}
		addr++;
	END_FOR_EACH_PTR(node);

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x98(%rdi), %r15
testq %r15, %r15
je 0x13207
movq %rdx, %rbx
movq %rsi, %r14
xorl %ebp, %ebp
movq %r15, %r12
movzwl (%r12), %ecx
testb %cl, %cl
jle 0x131fd
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %rax
movzwl %cx, %edx
cmpl $0x100, %edx            # imm = 0x100
jb 0x131b9
testq %rax, %rax
je 0x131ee
testq %r14, %r14
je 0x131ce
movq 0x18(%rax), %rdx
testq %rdx, %rdx
je 0x131d4
cmpq %r14, %rdx
jne 0x131ec
jmp 0x1320b
cmpl (%rbx), %ebp
jne 0x131ec
jmp 0x13212
movq 0x60(%rax), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x13176
testq %rax, %rax
jne 0x1320b
movzwl (%r12), %ecx
incl %ebp
incq %r13
movzwl %cx, %eax
movsbq %al, %rax
cmpq %rax, %r13
jl 0x131a4
movq 0x10(%r12), %r12
cmpq %r15, %r12
jne 0x13198
xorl %eax, %eax
jmp 0x13212
testq %rbx, %rbx
je 0x13212
movl %ebp, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/test-inspect.c
// Function: main
int main(int argc, char **argv)
{
	struct string_list *filelist = NULL;
	char *file;
	struct symbol_list *view_syms = NULL;

	gtk_init(&argc,&argv);
	setlocale(LC_ALL, "C");
	expand_symbols(sparse_initialize(argc, argv, &filelist));
	FOR_EACH_PTR(filelist, file) {
		struct symbol_list *syms = sparse(file);
		expand_symbols(syms);
		concat_symbol_list(syms, &view_syms);
	} END_FOR_EACH_PTR(file);
	treeview_main(view_syms);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0xc(%rsp), %r14
movl %edi, (%r14)
leaq 0x18(%rsp), %r15
movq %rsi, (%r15)
xorl %ebx, %ebx
leaq 0x10(%rsp), %r12
movq %rbx, (%r12)
movq %rbx, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xf4b0
leaq 0x36636(%rip), %rsi     # 0x462b0
movl $0x6, %edi
callq 0xf270
movl (%r14), %edi
movq (%r15), %rsi
movq %r12, %rdx
callq 0x130a6
movq %rax, %rdi
callq 0xfd1f
movq (%r12), %r15
testq %r15, %r15
je 0xfd07
movq %rsp, %rbx
movq %r15, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0xfcf9
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %rdi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0xfcca
testq %rdi, %rdi
je 0xfcea
callq 0x133de
movq %rax, %r14
movq %rax, %rdi
callq 0xfd1f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1dbbc
movzwl (%r12), %eax
incq %r13
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r13
jl 0xfcb5
movq 0x10(%r12), %r12
cmpq %r15, %r12
jne 0xfca9
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x40b78
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/test-inspect.c
// Function: expand_symbols
static void expand_symbols(struct symbol_list *list)
{
	struct symbol *sym;
	FOR_EACH_PTR(list, sym) {
		expand_symbol(sym);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
testq %rdi, %rdi
je 0xfd75
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %r14
movzwl (%r14), %eax
testb %al, %al
jle 0xfd67
xorl %r15d, %r15d
movq 0x18(%r14,%r15,8), %rdi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0xfd4f
testq %rdi, %rdi
je 0xfd58
callq 0x10010
movzwl (%r14), %eax
incq %r15
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r15
jl 0xfd3a
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0xfd2f
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_tree_model_init
static void
ast_tree_model_init (GtkTreeModelIface *iface)
{
	iface->get_flags       = ast_get_flags;
	iface->get_n_columns   = ast_get_n_columns;
	iface->get_column_type = ast_get_column_type;
	iface->get_iter        = ast_get_iter;
	iface->get_path        = ast_get_path;
	iface->get_value       = ast_get_value;
	iface->iter_next       = ast_iter_next;
	iface->iter_children   = ast_iter_children;
	iface->iter_has_child  = ast_iter_has_child;
	iface->iter_n_children = ast_iter_n_children;
	iface->iter_nth_child  = ast_iter_nth_child;
	iface->iter_parent     = ast_iter_parent;
}

// Assembly:
leaq 0xe1(%rip), %rax        # 0x4087a
movq %rax, 0x38(%rdi)
leaq 0xdc(%rip), %rax        # 0x40880
movq %rax, 0x40(%rdi)
leaq 0xd7(%rip), %rax        # 0x40886
movq %rax, 0x48(%rdi)
leaq 0xd2(%rip), %rax        # 0x4088c
movq %rax, 0x50(%rdi)
leaq 0x169(%rip), %rax       # 0x4092e
movq %rax, 0x58(%rdi)
leaq 0x1bb(%rip), %rax       # 0x4098b
movq %rax, 0x60(%rdi)
leaq 0x237(%rip), %rax       # 0x40a12
movq %rax, 0x68(%rdi)
leaq 0x2c2(%rip), %rax       # 0x40aa8
movq %rax, 0x78(%rdi)
leaq 0x2dd(%rip), %rax       # 0x40ace
movq %rax, 0x80(%rdi)
leaq 0x2f9(%rip), %rax       # 0x40af8
movq %rax, 0x88(%rdi)
leaq 0x32c(%rip), %rax       # 0x40b39
movq %rax, 0x90(%rdi)
leaq 0x346(%rip), %rax       # 0x40b61
movq %rax, 0x98(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_new
AstNode *
ast_new (AstNode *parent, int index, const char *text, void *ptr, void (*inspect)(AstNode*))
{
	AstNode *node = (AstNode*) g_object_new (AST_TYPE_NODE, NULL);
	g_assert(node != NULL);
	node->parent = parent;
	node->index = index;
	node->text = text;
	node->inspect = inspect;
	node->ptr = ptr;
	return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
callq 0x40700
movq %rax, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0xf030
testq %rax, %rax
je 0x4086b
movq %r12, 0x18(%rax)
movl %ebp, 0x20(%rax)
movq %r15, 0x28(%rax)
movq %r14, 0x30(%rax)
movq %rbx, 0x38(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xfaea
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_get_iter
static gboolean
ast_get_iter(GtkTreeModel *tree_model,
                  GtkTreeIter  *iter,
                  GtkTreePath  *path)
{
	AstNode    *node;
	gint          *indices, depth;
	int i;

	node = AST_NODE(tree_model);
	indices = gtk_tree_path_get_indices(path);
	depth   = gtk_tree_path_get_depth(path);

	for (i = 0; i < depth; i++)
		node = ast_nth_child(node, indices[i]);

	return ast_set_iter(iter, node);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x40700
movq %r14, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %r14
movq %r12, %rdi
callq 0xf1b0
movq %rax, %r15
movq %r12, %rdi
callq 0xf410
testl %eax, %eax
jle 0x4090c
movl %eax, %r12d
xorl %r13d, %r13d
testq %r14, %r14
je 0x40901
movslq (%r15,%r13,4), %rbp
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x408ef
movq %r14, %rdi
callq *%rax
movq $0x0, 0x30(%r14)
movq 0x40(%r14), %rax
cmpl %ebp, 0x8(%rax)
jbe 0x40901
movq (%rax), %rax
movq (%rax,%rbp,8), %r14
jmp 0x40904
xorl %r14d, %r14d
incq %r13
cmpq %r13, %r12
jne 0x408d0
movq %r14, 0x8(%rbx)
xorl %eax, %eax
testq %r14, %r14
setne %al
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_get_path
static GtkTreePath *
ast_get_path(GtkTreeModel *tree_model,
                  GtkTreeIter  *iter)
{
	GtkTreePath  *path;
	AstNode   *root = AST_NODE(tree_model);
	AstNode   *node = AST_NODE(iter->user_data);

	path = gtk_tree_path_new();
	while (node != root) {
		gtk_tree_path_prepend_index(path, node->index);
		node = node->parent;
	}
	return path;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x40700
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %rbx
movq 0x8(%r14), %r14
callq 0x40700
movq %r14, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %r14
callq 0xf3b0
movq %rax, %r15
cmpq %rbx, %r14
je 0x40982
movl 0x20(%r14), %esi
movq %r15, %rdi
callq 0xf440
movq 0x18(%r14), %r14
jmp 0x4096b
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_get_value
static void
ast_get_value(GtkTreeModel *tree_model,
                   GtkTreeIter  *iter,
                   gint          column,
                   GValue       *value)
{
	AstNode    *node = iter->user_data;

	g_assert(AST_IS_NODE(tree_model));
	if (column != 1)
		return;

	inspect_child_node(node);

	g_value_init(value, G_TYPE_STRING);
	g_value_set_string(value, node->text);
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r15
movq 0x8(%rsi), %r14
callq 0x40700
testq %r15, %r15
je 0x40a0d
movq (%r15), %rcx
testq %rcx, %rcx
je 0x409b5
cmpq %rax, (%rcx)
je 0x409c4
movq %r15, %rdi
movq %rax, %rsi
callq 0xf3a0
testl %eax, %eax
je 0x40a0d
cmpl $0x1, %ebp
jne 0x40a02
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x409df
movq %r14, %rdi
callq *%rax
movq $0x0, 0x30(%r14)
movl $0x40, %esi
movq %rbx, %rdi
callq 0xf4c0
movq 0x28(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xf240
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xfb0c
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_iter_next
static gboolean
ast_iter_next(GtkTreeModel  *tree_model,
                   GtkTreeIter   *iter)
{
	AstNode    *node = iter->user_data;
	
	g_assert(AST_IS_NODE (tree_model));

	node = ast_nth_child(node->parent, node->index + 1);
	return ast_set_iter(iter, node);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %r15
callq 0x40700
testq %r14, %r14
je 0x40aa3
movq (%r14), %rcx
testq %rcx, %rcx
je 0x40a3a
cmpq %rax, (%rcx)
je 0x40a49
movq %r14, %rdi
movq %rax, %rsi
callq 0xf3a0
testl %eax, %eax
je 0x40aa3
movq 0x18(%r15), %r14
testq %r14, %r14
je 0x40a83
movslq 0x20(%r15), %r15
leal 0x1(%r15), %ebp
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x40a70
movq %r14, %rdi
callq *%rax
movq $0x0, 0x30(%r14)
movq 0x40(%r14), %rax
cmpl %ebp, 0x8(%rax)
jbe 0x40a83
movq (%rax), %rax
movq 0x8(%rax,%r15,8), %rcx
jmp 0x40a85
xorl %ecx, %ecx
movq %rcx, 0x8(%rbx)
xorl %eax, %eax
testq %rcx, %rcx
setne %al
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xfb2e
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_iter_nth_child
static gboolean
ast_iter_nth_child(GtkTreeModel *tree_model,
                        GtkTreeIter  *iter,
                        GtkTreeIter  *parent,
                        gint          n)
{
	AstNode    *node = parent ? parent->user_data : (AstNode*) tree_model;
	GArray *array = node->childnodes;
	if (n >= array->len)
		return FALSE;
	iter->user_data = g_array_index(array, AstNode *, n);
	return TRUE;
}

// Assembly:
testq %rdx, %rdx
je 0x40b42
movq 0x8(%rdx), %rdi
movq 0x40(%rdi), %rdx
xorl %eax, %eax
cmpl %ecx, 0x8(%rdx)
jbe 0x40b60
movq (%rdx), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_iter_n_children
static gint
ast_iter_n_children (GtkTreeModel *tree_model,
                          GtkTreeIter  *iter)
{
	AstNode  *node = iter ? iter->user_data
				: AST_NODE(tree_model);

	inspect_child_node(node);
	return node->childnodes->len;
}

// Assembly:
pushq %rbx
testq %rsi, %rsi
je 0x40b04
movq 0x8(%rsi), %rbx
jmp 0x40b1a
movq %rdi, %rbx
callq 0x40700
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %rbx
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x40b30
movq %rbx, %rdi
callq *%rax
movq $0x0, 0x30(%rbx)
movq 0x40(%rbx), %rax
movl 0x8(%rax), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/ast-view.c
// Function: treeview_main
void
treeview_main (struct symbol_list *syms)
{
	GtkWidget *window, *view, *scrollwin;

	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_default_size (GTK_WINDOW(window), 600, 800);
	g_signal_connect(window, "delete_event", gtk_main_quit, NULL);

	scrollwin = gtk_scrolled_window_new(NULL,NULL);

	view = create_view_and_model(syms);

	gtk_container_add(GTK_CONTAINER(scrollwin), view);
	gtk_container_add(GTK_CONTAINER(window), scrollwin);

	gtk_widget_show_all(window);

	gtk_main();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
xorl %edi, %edi
callq 0xf320
movq %rax, %rbx
callq 0xf520
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %rdi
movl $0x258, %esi            # imm = 0x258
movl $0x320, %edx            # imm = 0x320
callq 0xf260
leaq 0xcd05(%rip), %rsi      # 0x4d8bb
movq 0x22403(%rip), %rdx     # 0x62fc0
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xf290
xorl %edi, %edi
xorl %esi, %esi
callq 0xf200
movq %rax, %r14
leaq 0x1ced(%rip), %rdx      # 0x428cd
leaq 0x8de(%rip), %r8        # 0x414c5
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rcx
callq 0x40823
movq %rax, %r12
callq 0xf370
movq %r12, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %rdi
callq 0xf490
movq %rax, %r15
movq %r12, %rdi
callq 0xf420
callq 0xf230
leaq 0xcc23(%rip), %rdi      # 0x4d848
leaq 0x436e(%rip), %rdx      # 0x44f9a
movq %rax, %rsi
movl $0x1, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xf0f0
movq %rax, %r12
callq 0xf310
movq %r15, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %rdi
movq %r12, %rsi
callq 0xf060
callq 0xf1a0
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %rdi
movq %r15, %rsi
callq 0xf250
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf0e0
movq %rax, %rdi
movq %r14, %rsi
callq 0xf250
movq %rbx, %rdi
callq 0xf400
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf350
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/ast-inspect.c
// Function: inspect_expression
void inspect_expression(AstNode *node)
{
	struct expression *expr = node->ptr;
	node->text = g_strdup_printf("%s %s", node->text, expression_type_name(expr->type));
	switch (expr->type) {
		case EXPR_STATEMENT:
			ast_append_child(node, "statement:", expr->statement, inspect_statement);
			break;
		case EXPR_BINOP:
		case EXPR_COMMA:
		case EXPR_COMPARE:
		case EXPR_LOGICAL:
		case EXPR_ASSIGNMENT:
			ast_append_child(node, "left:", expr->left, inspect_expression);
			ast_append_child(node, "right:", expr->right, inspect_expression);
			break;

		case EXPR_CAST:
		case EXPR_FORCE_CAST:
		case EXPR_IMPLIED_CAST:
			ast_append_child(node, "cast_type:", expr->cast_type, inspect_symbol);
			ast_append_child(node, "cast_expression:", expr->cast_expression, inspect_expression);
			break;

		case EXPR_PREOP:
			ast_append_child(node, "unop:", expr->unop, inspect_expression);
			break;
		
		default:
			break;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rsi
movq 0x38(%rdi), %r14
movzbl (%r14), %eax
testl %eax, %eax
je 0x41217
leaq 0x2191f(%rip), %rcx     # 0x62b30
movq (%rcx,%rax,8), %rdx
jmp 0x4121e
leaq 0xcbc3(%rip), %rdx      # 0x4dde1
leaq 0x4a71(%rip), %rdi      # 0x45c96
xorl %eax, %eax
callq 0xf1f0
movq %rax, 0x28(%rbx)
movzbl (%r14), %eax
addl $-0x5, %eax
cmpl $0x11, %eax
ja 0x41357
leaq 0xc69d(%rip), %rcx      # 0x4d8e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%r14), %rcx
testq %rcx, %rcx
je 0x4128a
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc86c(%rip), %rdx      # 0x4dad3
leaq -0x7b(%rip), %r8        # 0x411f3
movq %rbx, %rdi
callq 0x40823
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x40(%rbx), %rdi
movl $0x1, %edx
callq 0xf1c0
movq 0x28(%r14), %rcx
testq %rcx, %rcx
je 0x41357
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc834(%rip), %rdx      # 0x4dad9
jmp 0x41334
movq 0x20(%r14), %rcx
testq %rcx, %rcx
je 0x412e4
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc81f(%rip), %rdx      # 0x4dae0
leaq 0x97(%rip), %r8         # 0x4135f
movq %rbx, %rdi
callq 0x40823
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x40(%rbx), %rdi
movl $0x1, %edx
callq 0xf1c0
movq 0x28(%r14), %rcx
testq %rcx, %rcx
je 0x41357
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc7f0(%rip), %rdx      # 0x4daeb
jmp 0x41334
movq 0x20(%r14), %rcx
testq %rcx, %rcx
je 0x41357
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc6c3(%rip), %rdx      # 0x4d9d7
leaq -0x673(%rip), %r8       # 0x40ca8
jmp 0x4133b
movq 0x20(%r14), %rcx
testq %rcx, %rcx
je 0x41357
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc7c8(%rip), %rdx      # 0x4dafc
leaq -0x148(%rip), %r8       # 0x411f3
movq %rbx, %rdi
callq 0x40823
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x40(%rbx), %rdi
movl $0x1, %edx
callq 0xf1c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/ast-inspect.c
// Function: inspect_symbol
void inspect_symbol(AstNode *node)
{
	struct symbol *sym = node->ptr;
	node->text = g_strdup_printf("%s %s: %s", node->text, symbol_type_name(sym->type),
				      builtin_typename(sym) ?: show_ident(sym->ident));
	ast_append_child(node, "ctype.base_type:", sym->ctype.base_type,inspect_symbol);

	switch (sym->namespace) {
		case NS_PREPROCESSOR:
			break;
		default:
			ast_append_child(node, "arguments:", sym->arguments, inspect_symbol_list);
			ast_append_child(node, "symbol_list:", sym->symbol_list, inspect_symbol_list);
			ast_append_child(node, "stmt:", sym->stmt, inspect_statement);
			break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r15
movq 0x38(%rdi), %r14
movzbl (%r14), %eax
leaq 0xc5e7(%rip), %rcx      # 0x4d964
movslq (%rcx,%rax,4), %r12
addq %rcx, %r12
movq %r14, %rdi
callq 0x1e321
testq %rax, %rax
jne 0x4139a
movq 0x18(%r14), %rdi
callq 0x22ced
leaq 0xc6ed(%rip), %rdi      # 0x4da8e
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xf1f0
movq %rax, 0x28(%rbx)
movq 0x60(%r14), %rcx
testq %rcx, %rcx
je 0x413ef
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc6cc(%rip), %rdx      # 0x4da98
leaq -0x74(%rip), %r8        # 0x4135f
movq %rbx, %rdi
callq 0x40823
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x40(%rbx), %rdi
movl $0x1, %edx
callq 0xf1c0
movl $0x1ff00, %eax          # imm = 0x1FF00
andl (%r14), %eax
cmpl $0x4000, %eax           # imm = 0x4000
je 0x414b9
movq 0x88(%r14), %rcx
testq %rcx, %rcx
je 0x4143f
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc68d(%rip), %rdx      # 0x4daa9
leaq 0xa2(%rip), %r8         # 0x414c5
movq %rbx, %rdi
callq 0x40823
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x40(%rbx), %rdi
movl $0x1, %edx
callq 0xf1c0
movq 0x98(%r14), %rcx
testq %rcx, %rcx
je 0x4147c
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc65b(%rip), %rdx      # 0x4dab4
leaq 0x65(%rip), %r8         # 0x414c5
movq %rbx, %rdi
callq 0x40823
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x40(%rbx), %rdi
movl $0x1, %edx
callq 0xf1c0
movq 0x90(%r14), %rcx
testq %rcx, %rcx
je 0x414b9
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc62b(%rip), %rdx      # 0x4dac1
leaq -0x7f5(%rip), %r8       # 0x40ca8
movq %rbx, %rdi
callq 0x40823
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x40(%rbx), %rdi
movl $0x1, %edx
callq 0xf1c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/debug.c
// Function: dump_tokens
void dump_tokens(const Vector* vec) {
    for (int i = 0; i < vec->size; ++i) {
        Token* token = vec->elements[i];
        printf("index=%d,token=\"%s\"", i, decode_token_type(token->type));
        if (token->type == TK_IDENT) {
            printf("=\"%s\"", token->str);
        }
        printf("\n");
        fflush(stdout);
    }
}

// Assembly:
cmpl $0x0, 0x8(%rdi)
jle 0x1444
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7c31(%rip), %r14      # 0x9004
leaq 0x8010(%rip), %r15      # 0x93ea
movq 0xcbef(%rip), %r13      # 0xdfd0
xorl %r12d, %r12d
movq (%rbx), %rax
movq (%rax,%r12,8), %rbp
movl (%rbp), %edi
callq 0x8681
movq %r14, %rdi
movl %r12d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a0
cmpl $0x3, (%rbp)
jne 0x1417
movq 0x8(%rbp), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10a0
movl $0xa, %edi
callq 0x1040
movq (%r13), %rdi
callq 0x1110
incq %r12
movslq 0x8(%rbx), %rax
cmpq %rax, %r12
jl 0x13e4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/debug.c
// Function: dump_nodes
void dump_nodes(const TransUnitNode* node) {
    printf("TransUnitNode\n");

    for (int i = 0; i < node->external_decl_nodes->size; ++i) {
        const ExternalDeclNode* external_decl_node = (const ExternalDeclNode*)(node->external_decl_nodes->elements[i]);
        dump_external_decl_node(external_decl_node, 2);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8023(%rip), %rdi      # 0x947d
callq 0x1070
movq (%rbx), %rax
cmpl $0x0, 0x8(%rax)
jle 0x1557
leaq 0x7ba5(%rip), %r14      # 0x9018
xorl %ebp, %ebp
movq (%rax), %rax
movq (%rax,%rbp,8), %r12
movl $0x2, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1566
movq (%r12), %r15
testq %r15, %r15
je 0x14f9
movl $0x4, %edi
leaq 0x7b8a(%rip), %rsi      # 0x902a
xorl %eax, %eax
callq 0x1566
movq (%r15), %rax
cmpl $0x0, 0x8(%rax)
jle 0x14d3
xorl %r13d, %r13d
movq (%rax), %rax
movq (%rax,%r13,8), %rdi
movl $0x6, %esi
callq 0x1707
incq %r13
movq (%r15), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %r13
jl 0x14b3
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x14e6
movl $0x6, %esi
callq 0x1741
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x14f9
movl $0x6, %esi
callq 0x1797
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x150d
movl $0x4, %esi
callq 0x1616
movq 0x10(%r12), %r15
testq %r15, %r15
je 0x1544
movl $0x4, %edi
leaq 0x7f33(%rip), %rsi      # 0x9456
xorl %eax, %eax
callq 0x1566
cmpq $0x0, 0x8(%r15)
je 0x1544
movl $0x6, %edi
leaq 0x7f2c(%rip), %rsi      # 0x9469
xorl %eax, %eax
callq 0x1566
incq %rbp
movq (%rbx), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %rbp
jl 0x1475
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/debug.c
// Function: dump_declaration_node
static void dump_declaration_node(const DeclarationNode* node, int indent) {
    printf_indent(indent, "DeclarationNode\n");
    for (int i = 0; i < node->decl_specifier_nodes->size; ++i) {
        dump_decl_specifier_node(node->decl_specifier_nodes->elements[i], indent + 2);
    }

    for (int i = 0; i < node->init_declarator_nodes->size; ++i) {
        dump_init_declarator_node(node->init_declarator_nodes->elements[i], indent + 2);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x7d1e(%rip), %rsi      # 0x934b
movl %ebx, %edi
xorl %eax, %eax
callq 0x1566
movq (%r14), %rax
cmpl $0x0, 0x8(%rax)
jle 0x1662
leal 0x2(%rbx), %ebp
xorl %r15d, %r15d
movq (%rax), %rax
movq (%rax,%r15,8), %rdi
movl %ebp, %esi
callq 0x1707
incq %r15
movq (%r14), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %r15
jl 0x1645
movq 0x8(%r14), %rax
cmpl $0x0, 0x8(%rax)
jle 0x16f8
leal 0x2(%rbx), %ebp
leal 0x4(%rbx), %r15d
addl $0x6, %ebx
xorl %r13d, %r13d
movq (%rax), %rax
movq (%rax,%r13,8), %r12
movl %ebp, %edi
leaq 0x7d8f(%rip), %rsi      # 0x941c
xorl %eax, %eax
callq 0x1566
movq (%r12), %rdi
testq %rdi, %rdi
je 0x16a5
movl %r15d, %esi
callq 0x1741
movq 0x8(%r12), %r12
testq %r12, %r12
je 0x16e8
movl %r15d, %edi
leaq 0x7d77(%rip), %rsi      # 0x9430
xorl %eax, %eax
callq 0x1566
movq (%r12), %rdi
testq %rdi, %rdi
je 0x16d0
movl %ebx, %esi
callq 0x2088
cmpq $0x0, 0x8(%r12)
je 0x16e8
movl %ebx, %edi
leaq 0x7d60(%rip), %rsi      # 0x9441
xorl %eax, %eax
callq 0x1566
incq %r13
movq 0x8(%r14), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %r13
jl 0x167d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/debug.c
// Function: dump_decl_specifier_node
static void dump_decl_specifier_node(const DeclSpecifierNode* node, int indent) {
    printf_indent(
        indent, 
        "DeclSpecifierNode\n"
    );

    if (node->type_specifier_node != NULL) {
        dump_type_specifier_node(node->type_specifier_node, indent + 2);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x7920(%rip), %rsi      # 0x9037
movl %ebx, %edi
xorl %eax, %eax
callq 0x1566
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1739
addl $0x2, %ebx
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x181e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/debug.c
// Function: dump_declarator_node
static void dump_declarator_node(const DeclaratorNode* node, int indent) {
    printf_indent(indent, "DeclaratorNode\n");

    if (node->pointer_node != NULL) {
        dump_pointer_node(node->pointer_node, indent + 2);
    }

    if (node->direct_declarator_node != NULL) {
        dump_direct_declarator_node(node->direct_declarator_node, indent + 2);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x7ccf(%rip), %rsi      # 0x9420
movl %ebx, %edi
xorl %eax, %eax
callq 0x1566
movq (%r14), %rax
testq %rax, %rax
je 0x1775
leal 0x2(%rbx), %edi
movl (%rax), %edx
leaq 0x795c(%rip), %rsi      # 0x90ca
xorl %eax, %eax
callq 0x1566
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x178f
addl $0x2, %ebx
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x192c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/debug.c
// Function: dump_compound_stmt_node
static void dump_compound_stmt_node(const CompoundStmtNode* node, int indent) {
    printf_indent(indent, "CompoundStmtNode\n");
    for (int i = 0; i < node->block_item_nodes->size; ++i) {
        const BlockItemNode* block_item_node = node->block_item_nodes->elements[i];
        dump_block_item_node(block_item_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x7bae(%rip), %rsi      # 0x935c
movl %ebx, %edi
xorl %eax, %eax
callq 0x1566
movq (%r14), %rax
cmpl $0x0, 0x8(%rax)
jle 0x180f
leal 0x2(%rbx), %ebp
addl $0x4, %ebx
leaq 0x7ba1(%rip), %r15      # 0x936e
xorl %r12d, %r12d
movq (%rax), %rax
movq (%rax,%r12,8), %r13
movl %ebp, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1566
movq (%r13), %rdi
testq %rdi, %rdi
je 0x17f5
movl %ebx, %esi
callq 0x1616
jmp 0x1800
movq 0x8(%r13), %rdi
movl %ebx, %esi
callq 0x20e0
incq %r12
movq (%r14), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %r12
jl 0x17d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/debug.c
// Function: dump_type_specifier_node
static void dump_type_specifier_node(const TypeSpecifierNode* node, int indent) {
    printf_indent(
        indent, 
        "TypeSpecifierNode,Type=\"%s\",StructName=\"%s\"\n",
        decode_type_specifier(node->type_specifier),
        node->struct_name
    );

    if (node->struct_specifier_node != NULL) {
        dump_struct_specifier_node(node->struct_specifier_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %edi
callq 0x51ff
movq 0x10(%r14), %rcx
leaq 0x7807(%rip), %rsi      # 0x904a
movq %rbx, %r15
movl %ebx, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1566
movq 0x8(%r14), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x191d
leal 0x2(%r15), %edi
movq 0x8(%rsp), %rbx
movq (%rbx), %rdx
leaq 0x7800(%rip), %rsi      # 0x9077
xorl %eax, %eax
callq 0x1566
movq 0x8(%rbx), %rax
cmpl $0x0, 0x8(%rax)
jle 0x191d
leal 0x4(%r15), %ecx
movl %ecx, 0x4(%rsp)
leal 0x6(%r15), %r14d
addl $0x8, %r15d
leaq 0x780f(%rip), %r12      # 0x90b2
xorl %edx, %edx
movq (%rax), %rax
movq %rdx, 0x10(%rsp)
movq (%rax,%rdx,8), %r13
movl 0x4(%rsp), %edi
leaq 0x77df(%rip), %rsi      # 0x909b
xorl %eax, %eax
callq 0x1566
movq (%r13), %rax
cmpl $0x0, 0x8(%rax)
jle 0x1903
xorl %ebp, %ebp
movq (%rax), %rax
movq (%rax,%rbp,8), %rbx
movl %r14d, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1566
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x18f3
movl %r15d, %esi
callq 0x181e
incq %rbp
movq (%r13), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %rbp
jl 0x18cf
movq 0x10(%rsp), %rdx
incq %rdx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %rdx
jl 0x18a5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq