LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/semind.c
// Function: command_add
static void command_add(int argc, char **argv)
{
	static struct reporter reporter = {
		.r_symdef = r_symdef,
		.r_symbol = r_symbol,
		.r_memdef = r_memdef,
		.r_member = r_member,
	};

	open_temp_database();

	sqlite_prepare_persistent(
		"BEGIN IMMEDIATE",
		&lock_stmt);

	sqlite_prepare_persistent(
		"COMMIT",
		&unlock_stmt);

	sqlite_prepare_persistent(
		"INSERT OR IGNORE INTO tempdb.semind "
		"(context, symbol, kind, mode, file, line, column) "
		"VALUES (@context, @symbol, @kind, @mode, @file, @line, @column)",
		&insert_rec_stmt);

	sqlite_prepare_persistent(
		"SELECT id, mtime FROM file WHERE name == @name",
		&select_file_stmt);

	sqlite_prepare_persistent(
		"INSERT INTO file (name, mtime) VALUES (@name, @mtime)",
		&insert_file_stmt);

	sqlite_prepare_persistent(
		"DELETE FROM file WHERE name == @name",
		&delete_file_stmt);

	dissect(&reporter, semind_filelist);

	sqlite_run(lock_stmt);
	sqlite_command("INSERT OR IGNORE INTO semind SELECT * FROM tempdb.semind");
	sqlite_run(unlock_stmt);

	sqlite3_finalize(insert_rec_stmt);
	sqlite3_finalize(select_file_stmt);
	sqlite3_finalize(insert_file_stmt);
	sqlite3_finalize(delete_file_stmt);
	sqlite3_finalize(lock_stmt);
	sqlite3_finalize(unlock_stmt);
	free(semind_streams);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
leaq 0x47d69(%rip), %r14     # 0x57850
cmpq $0x10, %rbx
je 0xfafc
movq (%rbx,%r14), %rdi
callq 0x10817
addq $0x8, %rbx
jmp 0xfae7
leaq 0x2d7ca(%rip), %rdi     # 0x3d2cd
leaq 0x56bfe(%rip), %rsi     # 0x66708
callq 0x10757
leaq 0x2d7c7(%rip), %rdi     # 0x3d2dd
leaq 0x56bf3(%rip), %rsi     # 0x66710
callq 0x10757
leaq 0x2d7bb(%rip), %rdi     # 0x3d2e4
leaq 0x56be8(%rip), %rsi     # 0x66718
callq 0x10757
leaq 0x2d83e(%rip), %rdi     # 0x3d37a
leaq 0x56bdd(%rip), %rsi     # 0x66720
callq 0x10757
leaq 0x2d85a(%rip), %rdi     # 0x3d3a9
leaq 0x56bd2(%rip), %rsi     # 0x66728
callq 0x10757
leaq 0x2d87d(%rip), %rdi     # 0x3d3df
leaq 0x56bc7(%rip), %rsi     # 0x66730
callq 0x10757
movq 0x56b8b(%rip), %rsi     # 0x66700
leaq 0x5075c(%rip), %rdi     # 0x602d8
callq 0x11194
movq 0x56b80(%rip), %rdi     # 0x66708
callq 0x107c8
leaq 0x2d870(%rip), %rdi     # 0x3d404
callq 0x10817
movq 0x56b70(%rip), %rdi     # 0x66710
callq 0x107c8
movq 0x56b6c(%rip), %rdi     # 0x66718
callq 0xf290
movq 0x56b68(%rip), %rdi     # 0x66720
callq 0xf290
movq 0x56b64(%rip), %rdi     # 0x66728
callq 0xf290
movq 0x56b60(%rip), %rdi     # 0x66730
callq 0xf290
movq 0x56b2c(%rip), %rdi     # 0x66708
callq 0xf290
movq 0x56b28(%rip), %rdi     # 0x66710
callq 0xf290
movq 0x56b44(%rip), %rdi     # 0x66738
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf210
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/semind.c
// Function: parse_cmdline_rm
static void parse_cmdline_rm(int argc, char **argv)
{
	static const struct option long_options[] = {
		{ "verbose", no_argument, NULL, 'v' },
		{ "help", no_argument, NULL, 'h' },
		{ NULL }
	};
	int c;

	while ((c = getopt_long(argc, argv, "+vh", long_options, NULL)) != -1) {
		switch (c) {
			case 'v':
				semind_verbose++;
				break;
			case 'h':
				show_help_rm(0);
		}
	}

	if (optind == argc) {
		message("more arguments required");
		show_usage();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
leaq 0x2d50b(%rip), %r15     # 0x3d11f
leaq 0x47c55(%rip), %r12     # 0x57870
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0xf360
cmpl $0x76, %eax
je 0xfc3f
cmpl $-0x1, %eax
je 0xfc47
cmpl $0x68, %eax
jne 0xfc1b
jmp 0xfc5e
incl 0x56ab7(%rip)           # 0x666fc
jmp 0xfc1b
movq 0x502f2(%rip), %rax     # 0x5ff40
cmpl %ebx, (%rax)
je 0xfc7a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x55a6b(%rip), %rsi     # 0x656d0
leaq 0x2d96e(%rip), %rdi     # 0x3d5da
xorl %eax, %eax
callq 0xf050
xorl %edi, %edi
callq 0xf120
leaq 0x2d4a2(%rip), %rdx     # 0x3d123
xorl %edi, %edi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10384
callq 0x10497
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %r14d
leaq 0x2d623(%rip), %rdi     # 0x3d2cd
callq 0x10817
leaq 0x2da39(%rip), %rdi     # 0x3d6ef
leaq 0x8(%rsp), %rsi
callq 0x10cc3
cmpl $0x2, 0x56a35(%rip)     # 0x666fc
jl 0xfce8
movq 0x8(%rsp), %rdi
callq 0xf0e0
leaq 0x2da3c(%rip), %rdx     # 0x3d716
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x10384
xorl %r12d, %r12d
testl %r14d, %r14d
cmovlel %r12d, %r14d
leaq 0x2da17(%rip), %r15     # 0x3d710
pushq $-0x1
popq %rbp
movq 0x8(%rsp), %rdi
cmpq %r12, %r14
je 0xfd2d
movq (%rbx,%r12,8), %rdx
movq %r15, %rsi
movl %ebp, %ecx
callq 0x10bf6
movq 0x8(%rsp), %rdi
callq 0x107c8
movq 0x8(%rsp), %rdi
callq 0x10c5d
incq %r12
jmp 0xfcfc
callq 0xf290
leaq 0x2d5a4(%rip), %rdi     # 0x3d2dd
callq 0x10817
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/semind.c
// Function: semind_error
static void semind_error(int status, int errnum, const char *fmt, ...)
{
	va_list ap;
	semind_print_progname();

	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);

	if (errnum > 0)
		fprintf(stderr, ": %s", strerror(errnum));

	fprintf(stderr, "\n");

	if (status)
		exit(status);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
movl %esi, %ebp
movl %edi, %ebx
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x103e2
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x4fbd7(%rip), %r15     # 0x5ffc0
movq (%r15), %rdi
movq 0x552dd(%rip), %rdx     # 0x656d0
leaq 0x2d9f3(%rip), %rsi     # 0x3dded
xorl %eax, %eax
callq 0xf4c0
movq 0x562e0(%rip), %rdx     # 0x666e8
testq %rdx, %rdx
je 0x1041e
movq (%r15), %rdi
leaq 0x2d9d6(%rip), %rsi     # 0x3dded
xorl %eax, %eax
callq 0xf4c0
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rdx)
movq (%r15), %rdi
movq %r14, %rsi
callq 0xf1f0
testl %ebp, %ebp
jg 0x1046f
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0xf200
testl %ebx, %ebx
jne 0x1048f
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %r14
movl %ebp, %edi
callq 0xf2b0
leaq 0x2d31a(%rip), %rsi     # 0x3d79a
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xf4c0
jmp 0x10452
pushq $0x1
popq %rdi
callq 0xf120
// File: /workspace/github_c_makefile_star2_O2/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 0x56249(%rip), %rdx     # 0x666e8
movq 0x5522a(%rip), %rsi     # 0x656d0
testq %rdx, %rdx
jne 0x104bb
leaq 0x2cdf4(%rip), %rdi     # 0x3d2a6
xorl %eax, %eax
callq 0xf050
jmp 0x104c9
leaq 0x2cdba(%rip), %rdi     # 0x3d27c
xorl %eax, %eax
callq 0xf050
pushq $0x1
popq %rdi
callq 0xf120
// File: /workspace/github_c_makefile_star2_O2/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 0x1083f
movq 0x56228(%rip), %rax     # 0x66738
movq (%r15), %rdi
movl %edi, %ecx
shrl $0x3, %ecx
andl $0x1fff8, %ecx          # imm = 0x1FFF8
movq (%rax,%rcx), %rcx
cmpq $-0x1, %rcx
je 0x105df
cmpb $0x0, 0x561c5(%rip)     # 0x666f8
je 0x10553
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x10571
leaq 0x5669b(%rip), %rax     # 0x66be0
movq (%rax), %rax
testq %rax, %rax
je 0x10588
movq 0x18(%rax), %rsi
jmp 0x1058f
movq 0x30(%r14), %rax
leaq 0x536fa(%rip), %rdx     # 0x63c58
cmpq %rax, (%rdx)
je 0x10535
leaq 0x536f6(%rip), %rdx     # 0x63c60
cmpq %rax, (%rdx)
jne 0x105df
jmp 0x10535
leaq 0x2cec5(%rip), %rsi     # 0x3d43d
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1263a
leaq 0x561b1(%rip), %rsi     # 0x66740
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 0x10b37
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1083f
movq 0x5612a(%rip), %rax     # 0x66738
movl (%rbx), %ecx
shrl $0x3, %ecx
andl $0x1fff8, %ecx          # imm = 0x1FFF8
cmpq $-0x1, (%rax,%rcx)
je 0x10748
cmpb $0x0, 0x560cd(%rip)     # 0x666f8
je 0x1065a
leaq 0x37b58(%rip), %rdi     # 0x4818c
callq 0x21b51
movq 0x18(%r12), %r12
testq %r12, %r12
cmoveq %rax, %r12
testq %r15, %r15
je 0x1067d
movq %rax, %r14
movq 0x18(%r15), %rax
testq %rax, %rax
cmovneq %rax, %r14
jmp 0x1068c
movq 0x30(%r12), %rax
leaq 0x535f2(%rip), %rcx     # 0x63c58
cmpq %rax, (%rcx)
je 0x1062d
leaq 0x535ee(%rip), %rcx     # 0x63c60
cmpq %rax, (%rcx)
jne 0x10748
jmp 0x1062d
leaq 0x37dfc(%rip), %rdi     # 0x48480
callq 0x21b51
movq %rax, %r14
leaq 0x5654d(%rip), %rax     # 0x66be0
movq (%rax), %rax
testq %rax, %rax
je 0x106a1
movq 0x18(%rax), %r13
jmp 0x106a8
leaq 0x560b8(%rip), %r13     # 0x66760
movzbl 0x10(%r12), %ecx
leaq 0x12(%r12), %r8
movzbl 0x10(%r14), %r9d
leaq 0x12(%r14), %rax
movq %rax, (%rsp)
leaq 0x560b9(%rip), %r15     # 0x66780
leaq 0x2cdf0(%rip), %rdx     # 0x3d4be
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 0x56020(%rip), %rax     # 0x66738
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 0x10b37
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0xf310
movl %eax, %ebx
addl $-0x66, %eax
cmpl $-0x3, %eax
ja 0x1080f
movq 0x55f0a(%rip), %rdi     # 0x666f0
callq 0xf3e0
movq %rax, %r15
movq %r14, %rdi
callq 0xf0e0
leaq 0x2cdbd(%rip), %rdx     # 0x3d5ba
pushq $0x1
popq %rdi
xorl %esi, %esi
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x10384
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x55bd6(%rip), %rdi     # 0x66718
movq (%rbx), %rdx
movl 0x8(%rbx), %ecx
leaq 0x2c944(%rip), %rsi     # 0x3d493
callq 0x10bf6
movq 0x55bbd(%rip), %rdi     # 0x66718
movq 0x10(%rbx), %rdx
movl 0x18(%rbx), %ecx
leaq 0x2c933(%rip), %rsi     # 0x3d49c
callq 0x10bf6
movq 0x55ba3(%rip), %rdi     # 0x66718
movslq 0x1c(%rbx), %rdx
leaq 0x2c924(%rip), %rsi     # 0x3d4a4
callq 0x10c6f
movq 0x55b8c(%rip), %rdi     # 0x66718
movl 0x20(%rbx), %edx
leaq 0x2c914(%rip), %rsi     # 0x3d4aa
callq 0x10c6f
movq 0x55b76(%rip), %rdi     # 0x66718
movq 0x30(%rbx), %rdx
leaq 0x2cb63(%rip), %rsi     # 0x3d710
callq 0x10c6f
movq 0x55b5f(%rip), %rdi     # 0x66718
movslq 0x38(%rbx), %rdx
leaq 0x2c8ec(%rip), %rsi     # 0x3d4b0
callq 0x10c6f
movq 0x55b48(%rip), %rdi     # 0x66718
movslq 0x3c(%rbx), %rdx
leaq 0x2c8db(%rip), %rsi     # 0x3d4b6
callq 0x10c6f
movq 0x55b31(%rip), %rdi     # 0x66718
callq 0x107c8
movq 0x55b25(%rip), %rdi     # 0x66718
popq %rbx
jmp 0x10c5d
// File: /workspace/github_c_makefile_star2_O2/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 0x11ed6
movq %rax, %r14
movq 0x555ab(%rip), %r13     # 0x66be0
movq 0x5559c(%rip), %rax     # 0x66bd8
movq %rbx, %rdi
callq *(%rax)
cmpb $0x5, (%r14)
jne 0x116b7
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 0x116f7
testq %r13, %r13
je 0x11698
movq 0x18(%r13), %rdi
callq 0x213e5
movq %rax, %r12
movq 0x18(%rbx), %rdi
callq 0x213e5
movq 0x4(%r13), %rdi
leaq 0x2cf11(%rip), %rsi     # 0x3e59c
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x127be
movq %rbx, 0x55541(%rip)     # 0x66be0
movq 0x88(%r14), %rdi
callq 0x113af
xorl %edi, %edi
movq %r15, %rsi
callq 0x11cb7
jmp 0x116f0
cmpq $0x0, 0xb0(%rbx)
je 0x116f7
movq 0x55510(%rip), %rax     # 0x66bd8
leaq 0x4(%rbx), %rsi
pushq $0x8
popq %rdi
movq %rbx, %rdx
callq *0x10(%rax)
testq %r13, %r13
jne 0x116e1
movq %rbx, 0x554ff(%rip)     # 0x66be0
movq 0xb0(%rbx), %rsi
movq %r14, %rdi
callq 0x11f08
movq %r13, 0x554e9(%rip)     # 0x66be0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x11f00
pushq %rbx
movq %rdi, %rbx
cmpb $0x3, (%rdi)
jne 0x11eee
movq %rbx, %rdi
xorl %esi, %esi
callq 0x11414
movq 0x60(%rbx), %rax
testq %rax, %rax
jne 0x11efe
leaq 0x5ad12(%rip), %rax     # 0x6cc10
popq %rbx
retq
leaq 0x5ad09(%rip), %rax     # 0x6cc10
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/dissect.c
// Function: do_initializer
static struct symbol *do_initializer(struct symbol *type, struct expression *expr)
{
	struct symbol *m_type;
	struct expression *m_expr;
	int m_addr;

	if (expr) switch (expr->type) {
	default:
		do_expression(u_lval(type), expr);

	break; case EXPR_INDEX:
		do_initializer(base_type(type), expr->idx_expression);

	break; case EXPR_INITIALIZER:
		m_addr = 0;
		FOR_EACH_PTR(expr->expr_list, m_expr) {
			if (type->type == SYM_ARRAY) {
				m_type = base_type(type);
				if (m_expr->type == EXPR_INDEX)
					m_expr = m_expr->idx_expression;
			} else {
				int *m_atop = &m_addr;

				m_type = type;
				while (m_expr->type == EXPR_IDENTIFIER) {
					m_type = report_member(U_W_VAL, &m_expr->pos, m_type,
							lookup_member(m_type, m_expr->expr_ident, m_atop));
					m_expr = m_expr->ident_expression;
					m_atop = NULL;
				}

				if (m_atop) {
					m_type = report_member(U_W_VAL, &m_expr->pos, m_type,
							lookup_member(m_type, NULL, m_atop));
				}

				if (m_expr->type != EXPR_INITIALIZER)
					report_implicit(U_W_VAL, &m_expr->pos, m_type);
			}
			do_initializer(m_type, m_expr);
			m_addr++;
		} END_FOR_EACH_PTR(m_expr);
	}

	return type;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
testq %rsi, %rsi
je 0x12069
movq %rsi, %r14
movzbl (%rsi), %eax
cmpl $0x18, %eax
je 0x11f4f
movq %r15, %rdi
cmpl $0x1a, %eax
jne 0x1205a
callq 0x11ed6
movq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x11f08
jmp 0x12069
andl $0x0, 0x4(%rsp)
movq 0x20(%r14), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x12069
pushq $0x8
popq %rbp
movq 0x8(%rsp), %r13
movq %r15, 0x10(%rsp)
xorl %ebx, %ebx
movl (%r13), %eax
movsbq %al, %rcx
cmpq %rcx, %rbx
jge 0x12049
movq 0x18(%r13,%rbx,8), %r14
cmpw $0x100, %ax             # imm = 0x100
jb 0x11f9a
testq %r14, %r14
je 0x12041
cmpb $0x6, (%r15)
jne 0x11fb7
movq %r15, %rdi
callq 0x11ed6
movq %rax, %r15
cmpb $0x1a, (%r14)
jne 0x1202d
movq 0x28(%r14), %r14
jmp 0x1202d
leaq 0x4(%rsp), %rdx
movzbl (%r14), %eax
cmpl $0x19, %eax
jne 0x11ff0
leaq 0x8(%r14), %r12
movq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0x121d3
movl %ebp, %edi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x12180
movq %rax, %r15
movq 0x38(%r14), %r14
xorl %edx, %edx
jmp 0x11fbc
testq %rdx, %rdx
je 0x1201a
leaq 0x8(%r14), %r12
movq %r15, %rdi
xorl %esi, %esi
callq 0x121d3
movl %ebp, %edi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x12180
movq %rax, %r15
movzbl (%r14), %eax
cmpl $0x18, %eax
je 0x1202d
leaq 0x8(%r14), %rsi
movl %ebp, %edi
movq %r15, %rdx
callq 0x120a7
movq %r15, %rdi
movq %r14, %rsi
callq 0x11f08
incl 0x4(%rsp)
movq 0x10(%rsp), %r15
incq %rbx
jmp 0x11f75
movq 0x10(%r13), %r13
cmpq 0x8(%rsp), %r13
jne 0x11f73
jmp 0x12069
callq 0x1207b
movl %eax, %edi
movq %r14, %rsi
callq 0x11701
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/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 0x12137
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
cmpq $0x0, 0x18(%rdx)
je 0x120e1
movq 0x54b04(%rip), %rax     # 0x66bd8
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq *0x18(%rax)
movq 0x98(%r14), %r14
testq %r14, %r14
je 0x1212f
movq %r14, %r15
xorl %r12d, %r12d
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jge 0x12126
movq 0x18(%r15,%r12,8), %rdi
cmpw $0x100, %ax             # imm = 0x100
jb 0x1210f
testq %rdi, %rdi
je 0x12121
callq 0x11ed6
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x120a7
incq %r12
jmp 0x120f3
movq 0x10(%r15), %r15
cmpq %r14, %r15
jne 0x120f0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/dissect.c
// Function: peek_preop
static struct expression *peek_preop(struct expression *expr, int op)
{
	do {
		if (expr->type != EXPR_PREOP)
			break;
		if (expr->op == op)
			return expr->unop;
		if (expr->op == '(')
			expr = expr->unop;
		else
			break;
	} while (expr);

	return NULL;
}

// Assembly:
xorl %eax, %eax
cmpb $0x9, (%rdi)
jne 0x1217a
movl 0x4(%rdi), %ecx
cmpl %esi, %ecx
je 0x1217b
cmpl $0x28, %ecx
jne 0x1217a
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
jne 0x12160
retq
movq 0x20(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x121a5
cmpb $0x10, (%r14)
jne 0x121c6
movq 0x54a2c(%rip), %rax     # 0x66bd8
movq 0x18(%rax), %r13
movq %rbx, %rdi
callq 0x1226f
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_O2/lucvoo[P]sparse-dev/dissect.c
// Function: lookup_member
static struct symbol *lookup_member(struct symbol *type, struct ident *name, int *addr)
{
	struct symbol *mem = __lookup_member(type, name, addr);

	if (!mem) {
		static struct symbol bad_member = {
			.type = SYM_BAD,
			.ctype.base_type = &bad_ctype,
			.kind = 'm',
		};

		if (!type->symbol_list)
			type->scope = file_scope;

		mem = &bad_member;
		mem->ident = name;
	}

	return mem;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x122ed
testq %rax, %rax
jne 0x1220d
cmpq $0x0, 0x98(%r14)
jne 0x121ff
leaq 0x51a60(%rip), %rax     # 0x63c58
movq (%rax), %rax
movq %rax, 0x30(%r14)
movq %rbx, 0x4e112(%rip)     # 0x60318
leaq 0x4e0f3(%rip), %rax     # 0x60300
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x122c6
leaq 0x2c2c0(%rip), %rdx     # 0x3e544
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
testb $0xd, %sil
jne 0x122ae
jmp 0x122c6
testw $0xd00, %si             # imm = 0xD00
je 0x122d2
shrl $0x8, %ecx
jmp 0x122c6
testb $0xd, %sil
je 0x122c6
cmpq $0x0, 0x60(%rdi)
je 0x122c6
movzbl %sil, %ecx
jmp 0x122c6
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
jne 0x122dc
pushq $0x8
popq %rcx
jmp 0x122c6
movl %esi, %eax
andl $0xd, %eax
andl $0x2, %esi
incl %esi
testl %eax, %eax
cmovel %eax, %esi
jmp 0x122c4
// File: /workspace/github_c_makefile_star2_O2/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 0x1236f
movq %rdx, %rbx
movq %rsi, %r14
xorl %ebp, %ebp
movq %r15, %r12
xorl %r13d, %r13d
movl (%r12), %ecx
movsbq %cl, %rax
cmpq %rax, %r13
jge 0x12365
movq 0x18(%r12,%r13,8), %rax
cmpw $0x100, %cx             # imm = 0x100
jb 0x12330
testq %rax, %rax
je 0x12360
testq %r14, %r14
je 0x12345
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x1234b
cmpq %r14, %rcx
jne 0x1235e
jmp 0x12373
cmpl (%rbx), %ebp
jne 0x1235e
jmp 0x1237a
movq 0x60(%rax), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x122ed
testq %rax, %rax
jne 0x12373
incl %ebp
incq %r13
jmp 0x12312
movq 0x10(%r12), %r12
cmpq %r15, %r12
jne 0x1230f
xorl %eax, %eax
jmp 0x1237a
testq %rbx, %rbx
je 0x1237a
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_O2/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), %rbx
movl %edi, (%rbx)
leaq 0x18(%rsp), %r14
leaq 0x10(%rsp), %r15
andq $0x0, (%r15)
movq %rsi, (%r14)
andq $0x0, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf4c0
leaq 0x2fc28(%rip), %rsi     # 0x3f2b0
pushq $0x6
popq %rdi
callq 0xf270
movl (%rbx), %edi
movq (%r14), %rsi
movq %r15, %rdx
callq 0x127cc
movq %rax, %rdi
callq 0xf71a
movq (%r15), %r15
testq %r15, %r15
je 0xf703
movq %rsp, %rbx
movq %r15, %r12
xorl %r13d, %r13d
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jge 0xf6f3
movq 0x18(%r12,%r13,8), %rdi
cmpw $0x100, %ax             # imm = 0x100
jb 0xf6d3
testq %rdi, %rdi
je 0xf6ee
callq 0x12af0
movq %rax, %r14
movq %rax, %rdi
callq 0xf71a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c5b7
incq %r13
jmp 0xf6b6
movq 0x10(%r12), %r12
cmpq %r15, %r12
jne 0xf6b3
movq (%rsp), %rdi
jmp 0xf705
xorl %edi, %edi
callq 0x39c84
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf761
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movl (%r14), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jge 0xf753
movq 0x18(%r14,%r15,8), %rdi
cmpw $0x100, %ax             # imm = 0x100
jb 0xf749
testq %rdi, %rdi
je 0xf74e
callq 0xf9eb
incq %r15
jmp 0xf72d
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0xf72a
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xfd(%rip), %rax        # 0x3997c
movq %rax, 0x38(%rdi)
leaq 0xf6(%rip), %rax        # 0x39980
movq %rax, 0x40(%rdi)
leaq 0xef(%rip), %rax        # 0x39984
movq %rax, 0x48(%rdi)
leaq 0xe8(%rip), %rax        # 0x39988
movq %rax, 0x50(%rdi)
leaq 0x157(%rip), %rax       # 0x39a02
movq %rax, 0x58(%rdi)
leaq 0x1a9(%rip), %rax       # 0x39a5f
movq %rax, 0x60(%rdi)
leaq 0x23c(%rip), %rax       # 0x39afd
movq %rax, 0x68(%rdi)
leaq 0x2b1(%rip), %rax       # 0x39b7d
movq %rax, 0x78(%rdi)
leaq 0x2ca(%rip), %rax       # 0x39ba1
movq %rax, 0x80(%rdi)
leaq 0x2e3(%rip), %rax       # 0x39bc8
movq %rax, 0x88(%rdi)
leaq 0x313(%rip), %rax       # 0x39c06
movq %rax, 0x90(%rdi)
leaq 0x32b(%rip), %rax       # 0x39c2c
movq %rax, 0x98(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x397ec
movq %rax, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0xf030
testq %rax, %rax
je 0x39951
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
leaq 0xd13d(%rip), %rsi      # 0x46a95
leaq 0xd142(%rip), %rcx      # 0x46aa1
leaq 0xd143(%rip), %r8       # 0x46aa9
xorl %edi, %edi
movl $0x1cd, %edx            # imm = 0x1CD
callq 0xf4f0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x397ec
movq %r14, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %r14
movq %r12, %rdi
callq 0xf1b0
movq %rax, %r15
movq %r12, %rdi
callq 0xf420
movl %eax, %r12d
xorl %r13d, %r13d
testl %eax, %eax
cmovlel %r13d, %r12d
cmpq %r13, %r12
je 0x399e5
movl (%r15,%r13,4), %esi
movq %r14, %rdi
callq 0x39c41
movq %rax, %r14
incq %r13
jmp 0x399cc
movq %r14, 0x8(%rbx)
xorl %eax, %eax
testq %r14, %r14
setne %al
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x397ec
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %rbx
movq 0x8(%r14), %r14
callq 0x397ec
movq %r14, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %r14
callq 0xf3c0
movq %rax, %r15
cmpq %rbx, %r14
je 0x39a56
movl 0x20(%r14), %esi
movq %r15, %rdi
callq 0xf450
movq 0x18(%r14), %r14
jmp 0x39a3f
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x397ec
testq %r15, %r15
je 0x39adc
movq (%r15), %rcx
testq %rcx, %rcx
je 0x39a89
cmpq %rax, (%rcx)
je 0x39a98
movq %r15, %rdi
movq %rax, %rsi
callq 0xf3b0
testl %eax, %eax
je 0x39adc
cmpl $0x1, %ebp
jne 0x39ad1
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x39ab0
movq %r14, %rdi
callq *%rax
andq $0x0, 0x30(%r14)
pushq $0x40
popq %rsi
movq %rbx, %rdi
callq 0xf4d0
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
leaq 0xcfb2(%rip), %rsi      # 0x46a95
leaq 0xcfcc(%rip), %rcx      # 0x46ab6
leaq 0xcfd3(%rip), %r8       # 0x46ac4
xorl %edi, %edi
movl $0x13e, %edx            # imm = 0x13E
callq 0xf4f0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %r15
callq 0x397ec
testq %r14, %r14
je 0x39b5c
movq (%r14), %rcx
testq %rcx, %rcx
je 0x39b23
cmpq %rax, (%rcx)
je 0x39b32
movq %r14, %rdi
movq %rax, %rsi
callq 0xf3b0
testl %eax, %eax
je 0x39b5c
movq 0x18(%r15), %rdi
movl 0x20(%r15), %esi
incl %esi
callq 0x39c41
movq %rax, 0x8(%rbx)
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xcf32(%rip), %rsi      # 0x46a95
leaq 0xcf72(%rip), %rcx      # 0x46adc
leaq 0xcf79(%rip), %r8       # 0x46aea
xorl %edi, %edi
movl $0x157, %edx            # imm = 0x157
callq 0xf4f0
// File: /workspace/github_c_makefile_star2_O2/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 0x39c0f
movq 0x8(%rdx), %rdi
movq 0x40(%rdi), %rdx
xorl %eax, %eax
cmpl %ecx, 0x8(%rdx)
jbe 0x39c2b
movq (%rdx), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x39bd4
movq 0x8(%rsi), %rbx
jmp 0x39bea
movq %rdi, %rbx
callq 0x397ec
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %rbx
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x39bfd
movq %rbx, %rdi
callq *%rax
andq $0x0, 0x30(%rbx)
movq 0x40(%rbx), %rax
movl 0x8(%rax), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_nth_child
static inline
AstNode* ast_nth_child(AstNode *node, int n)
{
	if (!node)
		return NULL;

	inspect_child_node(node);

	if (n >= node->childnodes->len)
		return NULL;
	return g_array_index(node->childnodes, AstNode *, n);
}

// Assembly:
testq %rdi, %rdi
je 0x39c77
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x39c62
movq %r14, %rdi
callq *%rax
andq $0x0, 0x30(%r14)
movq 0x40(%r14), %rax
cmpl %ebx, 0x8(%rax)
jbe 0x39c7a
movq (%rax), %rax
movslq %ebx, %rcx
movq (%rax,%rcx,8), %rax
jmp 0x39c7c
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf330
movq %rax, %rbx
callq 0xf530
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %rdi
movl $0x258, %esi            # imm = 0x258
movl $0x320, %edx            # imm = 0x320
callq 0xf260
leaq 0xce41(%rip), %rsi      # 0x46b03
movq 0x232ff(%rip), %rdx     # 0x5cfc8
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 0x1be1(%rip), %rdx      # 0x3b8cd
leaq 0x5ba(%rip), %r8        # 0x3a2ad
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rcx
callq 0x39909
movq %rax, %r12
callq 0xf380
movq %r12, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %rdi
callq 0xf4a0
movq %rax, %r15
movq %r12, %rdi
callq 0xf430
callq 0xf230
leaq 0xcd5f(%rip), %rdi      # 0x46a90
leaq 0x4262(%rip), %rdx      # 0x3df9a
pushq $0x1
popq %rcx
movq %rax, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xf0f0
movq %rax, %r12
callq 0xf320
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 0xf410
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf360
nop
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/./ast-model.h
// Function: ast_append_child
static inline
AstNode* ast_append_child(AstNode *parent, const char *text,
			   void *ptr, void (*inspect)(AstNode*))
{
	if (ptr) {
		AstNode *child = ast_new(parent, parent->childnodes->len,
						text, ptr, inspect);
		g_array_append_val(parent->childnodes, child);
		return child;
	}
	return NULL;
}

// Assembly:
movq %rcx, %r8
movq %rdx, %rcx
testq %rdx, %rdx
je 0x3a023
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movl 0x8(%rax), %esi
callq 0x39909
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq 0x40(%rbx), %rdi
pushq $0x1
popq %rdx
callq 0xf1c0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rsi
movq 0x38(%rdi), %r15
movzbl (%r15), %eax
testl %eax, %eax
je 0x3a05c
leaq 0x22aea(%rip), %rcx     # 0x5cb40
movq (%rcx,%rax,8), %rdx
jmp 0x3a063
leaq 0xcfc6(%rip), %rdx      # 0x47029
leaq 0x4c2c(%rip), %rdi      # 0x3ec96
xorl %eax, %eax
callq 0xf1f0
movq %rax, 0x28(%rbx)
movzbl (%r15), %eax
addl $-0x5, %eax
cmpl $0x11, %eax
ja 0x3a0e8
leaq 0xcaa4(%rip), %rcx      # 0x46b2c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%r15), %rdx
leaq 0xcc7f(%rip), %rsi      # 0x46d1b
leaq -0x6c(%rip), %r14       # 0x3a037
movq %rbx, %rdi
movq %r14, %rcx
callq 0x39fe8
movq 0x28(%r15), %rdx
leaq 0xcc68(%rip), %rsi      # 0x46d21
movq %rbx, %rdi
movq %r14, %rcx
jmp 0x3a117
movq 0x20(%r15), %rdx
leaq 0xcc5c(%rip), %rsi      # 0x46d28
leaq 0x4e(%rip), %rcx        # 0x3a121
movq %rbx, %rdi
callq 0x39fe8
movq 0x28(%r15), %rdx
leaq 0xcc4d(%rip), %rsi      # 0x46d33
jmp 0x3a10d
popq %rbx
popq %r14
popq %r15
retq
movq 0x20(%r15), %rdx
leaq 0xcb26(%rip), %rsi      # 0x46c1f
leaq -0x34c(%rip), %rcx      # 0x39db4
jmp 0x3a114
movq 0x20(%r15), %rdx
leaq 0xcc37(%rip), %rsi      # 0x46d44
leaq -0xdd(%rip), %rcx       # 0x3a037
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x39fe8
// File: /workspace/github_c_makefile_star2_O2/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 0xca6d(%rip), %rcx      # 0x46bac
movslq (%rcx,%rax,4), %r12
addq %rcx, %r12
movq %r14, %rdi
callq 0x1ce67
testq %rax, %rax
jne 0x3a15c
movq 0x18(%r14), %rdi
callq 0x214b5
leaq 0xcb73(%rip), %rdi      # 0x46cd6
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xf1f0
movq %rax, 0x28(%rbx)
movq 0x60(%r14), %rdx
leaq 0xcb5e(%rip), %rsi      # 0x46ce0
leaq -0x68(%rip), %rcx       # 0x3a121
movq %rbx, %rdi
callq 0x39fe8
movl $0x1ff00, %eax          # imm = 0x1FF00
andl (%r14), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x3a1ac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x88(%r14), %rdx
leaq 0xcb37(%rip), %rsi      # 0x46cf1
leaq 0xec(%rip), %r15        # 0x3a2ad
movq %rbx, %rdi
movq %r15, %rcx
callq 0x39fe8
movq 0x98(%r14), %rdx
leaq 0xcb22(%rip), %rsi      # 0x46cfc
movq %rbx, %rdi
movq %r15, %rcx
callq 0x39fe8
movq 0x90(%r14), %rdx
leaq 0xcb16(%rip), %rsi      # 0x46d09
leaq -0x446(%rip), %rcx      # 0x39db4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x39fe8
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/ast-inspect.c
// Function: inspect_ptr_list
static inline void inspect_ptr_list(AstNode *node, const char *name, void (*inspect)(AstNode *))
{
	struct ptr_list *ptrlist = node->ptr;
	void *ptr;
	int i = 0;

	node->text = g_strdup_printf("%s %s:", node->text, name);
	FOR_EACH_PTR(ptrlist, ptr) {
		char *index = g_strdup_printf("%d: ", i++);
		ast_append_child(node, index, ptr, inspect);
	} END_FOR_EACH_PTR(ptr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
movq 0x28(%rdi), %rsi
movq 0x38(%rdi), %r15
leaq 0xc9c0(%rip), %rdi      # 0x46bf0
xorl %eax, %eax
callq 0xf1f0
movq %rax, 0x28(%r14)
movq %r15, (%rsp)
testq %r15, %r15
je 0x3a29e
movq (%rsp), %rbp
xorl %esi, %esi
xorl %r13d, %r13d
movl (%rbp), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jge 0x3a294
movq 0x18(%rbp,%r13,8), %r12
cmpw $0x100, %ax             # imm = 0x100
jb 0x3a269
testq %r12, %r12
je 0x3a28f
leal 0x1(%rsi), %r15d
leaq 0xcb7d(%rip), %rdi      # 0x46df1
xorl %eax, %eax
callq 0xf1f0
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x39fe8
movl %r15d, %esi
incq %r13
jmp 0x3a24d
movq 0x10(%rbp), %rbp
cmpq (%rsp), %rbp
jne 0x3a24a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7cab(%rip), %r14      # 0x9004
pushq $0xa
popq %rbp
movq 0xcc6d(%rip), %r13      # 0xdfd0
xorl %r12d, %r12d
movslq 0x8(%rbx), %rax
cmpq %rax, %r12
jge 0x13bb
movq (%rbx), %rax
movq (%rax,%r12,8), %r15
movl (%r15), %edi
callq 0x807a
movq %r14, %rdi
movl %r12d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a0
cmpl $0x3, (%r15)
jne 0x13a6
movq 0x8(%r15), %rsi
leaq 0x804b(%rip), %rdi      # 0x93ea
xorl %eax, %eax
callq 0x10a0
movl %ebp, %edi
callq 0x1040
movq (%r13), %rdi
callq 0x1110
incq %r12
jmp 0x1366
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq