LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/semind.c
// Function: parse_cmdline_add
static void parse_cmdline_add(int argc, char **argv)
{
	static const struct option long_options[] = {
		{ "include-local-syms", no_argument, NULL, 1 },
		{ "verbose", no_argument, NULL, 'v' },
		{ "help", no_argument, NULL, 'h' },
		{ NULL }
	};
	int c;

	opterr = 0;

	while ((c = getopt_long(argc, argv, "+vh", long_options, NULL)) != -1) {
		switch (c) {
			case 1:
				semind_include_local_syms = 1;
				break;
			case 'v':
				semind_verbose++;
				break;
			case 'h':
				show_help_add(0);
			case '?':
				goto done;
		}
	}
done:
	if (optind == argc) {
		message("more arguments required");
		show_usage();
	}

	// enforce tabstop
	tabstop = 1;

	// step back since sparse_initialize will ignore argv[0].
	optind--;

	sparse_initialize(argc - optind, argv + optind, &semind_filelist);
	dissect_show_all_symbols = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x7978a(%rip), %rax     # 0x8bfd0
movl $0x0, (%rax)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x54945(%rip), %rdx     # 0x6719f
leaq 0x7231f(%rip), %rcx     # 0x84b80
xorl %eax, %eax
movl %eax, %r8d
callq 0x12320
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x128c6
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0x1289e
jmp 0x12880
movl -0x18(%rbp), %eax
subl $0x3f, %eax
je 0x128c2
jmp 0x1288a
movl -0x18(%rbp), %eax
subl $0x68, %eax
je 0x128bb
jmp 0x12894
movl -0x18(%rbp), %eax
subl $0x76, %eax
je 0x128aa
jmp 0x128c4
movl $0x1, 0x82280(%rip)     # 0x94b28
jmp 0x128c4
movl 0x8227c(%rip), %eax     # 0x94b2c
addl $0x1, %eax
movl %eax, 0x82273(%rip)     # 0x94b2c
jmp 0x128c4
xorl %edi, %edi
callq 0x13550
jmp 0x128c8
jmp 0x1284c
jmp 0x128c8
movq 0x796f1(%rip), %rax     # 0x8bfc0
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x128ed
xorl %esi, %esi
leaq 0x548c4(%rip), %rdx     # 0x671a3
movl %esi, %edi
movb $0x0, %al
callq 0x131c0
callq 0x13580
leaq 0x7fcec(%rip), %rax     # 0x925e0
movl $0x1, (%rax)
movq 0x796bf(%rip), %rax     # 0x8bfc0
movl (%rax), %ecx
addl $-0x1, %ecx
movq 0x796b3(%rip), %rax     # 0x8bfc0
movl %ecx, (%rax)
movl -0x4(%rbp), %edi
movq 0x796a7(%rip), %rax     # 0x8bfc0
subl (%rax), %edi
movq -0x10(%rbp), %rsi
movq 0x7969a(%rip), %rax     # 0x8bfc0
movslq (%rax), %rax
shlq $0x3, %rax
addq %rax, %rsi
leaq 0x821f9(%rip), %rdx     # 0x94b30
callq 0x17570
leaq 0x82c11(%rip), %rax     # 0x95554
movl $0x1, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x139a0
leaq 0x549e2(%rip), %rdi     # 0x6734d
leaq 0x821c6(%rip), %rsi     # 0x94b38
callq 0x139f0
leaq 0x549df(%rip), %rdi     # 0x6735d
leaq 0x821bb(%rip), %rsi     # 0x94b40
callq 0x139f0
leaq 0x549d3(%rip), %rdi     # 0x67364
leaq 0x821b0(%rip), %rsi     # 0x94b48
callq 0x139f0
leaq 0x54a56(%rip), %rdi     # 0x673fa
leaq 0x821a5(%rip), %rsi     # 0x94b50
callq 0x139f0
leaq 0x54a72(%rip), %rdi     # 0x67429
leaq 0x8219a(%rip), %rsi     # 0x94b58
callq 0x139f0
leaq 0x54a95(%rip), %rdi     # 0x6745f
leaq 0x8218f(%rip), %rsi     # 0x94b60
callq 0x139f0
movq 0x82153(%rip), %rsi     # 0x94b30
leaq 0x798d4(%rip), %rdi     # 0x8c2b8
callq 0x14c40
movq 0x82148(%rip), %rdi     # 0x94b38
callq 0x13a70
leaq 0x54a88(%rip), %rdi     # 0x67484
callq 0x13ae0
movq 0x82138(%rip), %rdi     # 0x94b40
callq 0x13a70
movq 0x82134(%rip), %rdi     # 0x94b48
callq 0x12260
movq 0x82130(%rip), %rdi     # 0x94b50
callq 0x12260
movq 0x8212c(%rip), %rdi     # 0x94b58
callq 0x12260
movq 0x82128(%rip), %rdi     # 0x94b60
callq 0x12260
movq 0x820f4(%rip), %rdi     # 0x94b38
callq 0x12260
movq 0x820f0(%rip), %rdi     # 0x94b40
callq 0x12260
movq 0x8210c(%rip), %rdi     # 0x94b68
callq 0x121e0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x54712(%rip), %rdx     # 0x6719f
leaq 0x7216c(%rip), %rcx     # 0x84c00
xorl %eax, %eax
movl %eax, %r8d
callq 0x12320
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x12ad7
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x68, %eax
je 0x12ace
jmp 0x12ab3
movl -0x18(%rbp), %eax
subl $0x76, %eax
jne 0x12ad5
jmp 0x12abd
movl 0x82069(%rip), %eax     # 0x94b2c
addl $0x1, %eax
movl %eax, 0x82060(%rip)     # 0x94b2c
jmp 0x12ad5
xorl %edi, %edi
callq 0x141f0
jmp 0x12a7f
movq 0x794e2(%rip), %rax     # 0x8bfc0
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x12afc
xorl %esi, %esi
leaq 0x546b5(%rip), %rdx     # 0x671a3
movl %esi, %edi
movb $0x0, %al
callq 0x131c0
callq 0x13580
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x54827(%rip), %rdi     # 0x6734d
callq 0x13ae0
leaq 0x54c3d(%rip), %rdi     # 0x6776f
leaq -0x18(%rbp), %rsi
callq 0x14170
cmpl $0x1, 0x81fea(%rip)     # 0x94b2c
jle 0x12b62
movq -0x18(%rbp), %rdi
callq 0x120c0
movq %rax, %rcx
xorl %esi, %esi
leaq 0x54c3d(%rip), %rdx     # 0x67796
movl %esi, %edi
movb $0x0, %al
callq 0x131c0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x12baf
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x54c08(%rip), %rsi     # 0x67790
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x14000
movq -0x18(%rbp), %rdi
callq 0x13a70
movq -0x18(%rbp), %rdi
callq 0x14080
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12b69
movq -0x18(%rbp), %rdi
callq 0x12260
leaq 0x5479e(%rip), %rdi     # 0x6735d
callq 0x13ae0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x131f8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
callq 0x14ad0
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq 0x78da1(%rip), %rax     # 0x8bfe8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x121d0
leaq -0x30(%rbp), %rax
cmpl $0x0, -0x8(%rbp)
jle 0x13292
movq 0x78d80(%rip), %rax     # 0x8bfe8
movq (%rax), %rax
movq %rax, -0xe8(%rbp)
movl -0x8(%rbp), %edi
callq 0x12280
movq -0xe8(%rbp), %rdi
movq %rax, %rdx
leaq 0x5458f(%rip), %rsi     # 0x6781a
movb $0x0, %al
callq 0x12480
movq 0x78d4f(%rip), %rax     # 0x8bfe8
movq (%rax), %rdi
leaq 0x54914(%rip), %rsi     # 0x67bb7
movb $0x0, %al
callq 0x12480
cmpl $0x0, -0x4(%rbp)
je 0x132b8
movl -0x4(%rbp), %edi
callq 0x12100
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/semind.c
// Function: parse_cmdline
static void parse_cmdline(int argc, char **argv)
{
	static const struct option long_options[] = {
		{ "database", required_argument, NULL, 'D' },
		{ "basedir", required_argument, NULL, 'B' },
		{ "verbose", no_argument, NULL, 'v' },
		{ "help", no_argument, NULL, 'h' },
		{ NULL }
	};
	int c;
	char *basedir = getenv("SINDEX_BASEDIR");
	char *env;

	if ((env = getenv("SINDEX_DATABASE")) != NULL)
		semind_dbfile = env;

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

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

	if (basedir) {
		if (!realpath(basedir, cwd))
			semind_error(1, errno, "unable to get project base directory");
		n_cwd = strlen(cwd);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x54b9d(%rip), %rdi     # 0x67e83
callq 0x12340
movq %rax, -0x20(%rbp)
leaq 0x54b9c(%rip), %rdi     # 0x67e92
callq 0x12340
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x13310
movq -0x28(%rbp), %rax
movq %rax, 0x78fa0(%rip)     # 0x8c2b0
jmp 0x13312
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x54b82(%rip), %rdx     # 0x67ea2
leaq 0x71a59(%rip), %rcx     # 0x84d80
xorl %eax, %eax
movl %eax, %r8d
callq 0x12320
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x133a4
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0x42, %eax
je 0x13377
jmp 0x13346
movl -0x2c(%rbp), %eax
subl $0x44, %eax
je 0x13364
jmp 0x13350
movl -0x2c(%rbp), %eax
subl $0x68, %eax
je 0x13398
jmp 0x1335a
movl -0x2c(%rbp), %eax
subl $0x76, %eax
je 0x13387
jmp 0x1339f
movq 0x78c75(%rip), %rax     # 0x8bfe0
movq (%rax), %rax
movq %rax, 0x78f3b(%rip)     # 0x8c2b0
jmp 0x1339f
movq 0x78c62(%rip), %rax     # 0x8bfe0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1339f
movl 0x8179f(%rip), %eax     # 0x94b2c
addl $0x1, %eax
movl %eax, 0x81796(%rip)     # 0x94b2c
jmp 0x1339f
xorl %edi, %edi
callq 0x14b20
jmp 0x13312
movq 0x78c15(%rip), %rax     # 0x8bfc0
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x133c9
xorl %esi, %esi
leaq 0x54aef(%rip), %rdx     # 0x67eaa
movl %esi, %edi
movb $0x0, %al
callq 0x131c0
callq 0x13580
cmpq $0x0, -0x20(%rbp)
je 0x13413
movq -0x20(%rbp), %rdi
leaq 0x80735(%rip), %rsi     # 0x93b10
callq 0x12240
cmpq $0x0, %rax
jne 0x13400
callq 0x12350
movl (%rax), %esi
movl $0x1, %edi
leaq 0x54ac2(%rip), %rdx     # 0x67ebb
movb $0x0, %al
callq 0x131c0
leaq 0x80709(%rip), %rdi     # 0x93b10
callq 0x121f0
movq %rax, 0x816fd(%rip)     # 0x94b10
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/semind.c
// Function: open_database
static void open_database(const char *filename, int flags)
{
	static const char *database_schema[] = {
		"CREATE TABLE file ("
			" id INTEGER PRIMARY KEY AUTOINCREMENT,"
			" name TEXT UNIQUE NOT NULL,"
			" mtime INTEGER NOT NULL"
		")",
		"CREATE TABLE semind ("
			" file INTEGER NOT NULL REFERENCES file(id) ON DELETE CASCADE,"
			" line INTEGER NOT NULL,"
			" column INTEGER NOT NULL,"
			" symbol TEXT NOT NULL,"
			" kind INTEGER NOT NULL,"
			" context TEXT,"
			" mode INTEGER NOT NULL"
		")",
		"CREATE UNIQUE INDEX semind_0 ON semind (symbol, kind, mode, file, line, column)",
		"CREATE INDEX semind_1 ON semind (file)",
		NULL,
	};

	int exists = !access(filename, R_OK);

	if (sqlite3_open_v2(filename, &semind_db, flags, NULL) != SQLITE_OK)
		semind_error(1, 0, "unable to open database: %s: %s", filename, sqlite3_errmsg(semind_db));

	sqlite_command("PRAGMA journal_mode = WAL");
	sqlite_command("PRAGMA synchronous = OFF");
	sqlite_command("PRAGMA secure_delete = FAST");
	sqlite_command("PRAGMA busy_timeout = 2147483647");
	sqlite_command("PRAGMA foreign_keys = ON");

	if (exists) {
		if (get_db_version() < SINDEX_DATABASE_VERSION)
			semind_error(1, 0, "%s: Database too old. Please rebuild it.", filename);
		return;
	}

	set_db_version();

	for (int i = 0; database_schema[i]; i++)
		sqlite_command(database_schema[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x12440
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x816c5(%rip), %rsi     # 0x94b20
xorl %eax, %eax
movl %eax, %ecx
callq 0x12120
cmpl $0x0, %eax
je 0x13499
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x816a8(%rip), %rdi     # 0x94b20
callq 0x123b0
movq -0x20(%rbp), %rcx
movq %rax, %r8
movl $0x1, %edi
xorl %esi, %esi
leaq 0x54f55(%rip), %rdx     # 0x683e7
movb $0x0, %al
callq 0x131c0
leaq 0x54f67(%rip), %rdi     # 0x68407
callq 0x13ae0
leaq 0x54f75(%rip), %rdi     # 0x68421
callq 0x13ae0
leaq 0x54f82(%rip), %rdi     # 0x6843a
callq 0x13ae0
leaq 0x54f92(%rip), %rdi     # 0x68456
callq 0x13ae0
leaq 0x54fa7(%rip), %rdi     # 0x68477
callq 0x13ae0
cmpl $0x0, -0x10(%rbp)
je 0x13501
callq 0x14b50
cmpq $0x1, %rax
jge 0x134ff
movq -0x8(%rbp), %rcx
movl $0x1, %edi
xorl %esi, %esi
leaq 0x54f98(%rip), %rdx     # 0x68490
movb $0x0, %al
callq 0x131c0
jmp 0x1353e
callq 0x14ba0
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x78de8(%rip), %rax     # 0x8c300
cmpq $0x0, (%rax,%rcx,8)
je 0x1353e
movslq -0x14(%rbp), %rcx
leaq 0x78dd6(%rip), %rax     # 0x8c300
movq (%rax,%rcx,8), %rdi
callq 0x13ae0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1350d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
cmpq $0x0, 0x8158c(%rip)     # 0x94b18
je 0x135ac
movq 0x8056b(%rip), %rsi     # 0x93b00
movq 0x8157c(%rip), %rdx     # 0x94b18
leaq 0x53d59(%rip), %rdi     # 0x672fc
movb $0x0, %al
callq 0x12050
jmp 0x135c1
movq 0x8054d(%rip), %rsi     # 0x93b00
leaq 0x53d6c(%rip), %rdi     # 0x67326
movb $0x0, %al
callq 0x12050
movl $0x1, %edi
callq 0x12100
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x81526(%rip), %rax     # 0x94b70
movq %rax, -0x20(%rbp)
callq 0x13b20
movq 0x8150e(%rip), %rax     # 0x94b68
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x6, %rcx
andq $0x3fff, %rcx           # imm = 0x3FFF
movl %ecx, %ecx
cmpq $-0x1, (%rax,%rcx,8)
jne 0x1367a
jmp 0x13779
cmpl $0x0, 0x814a7(%rip)     # 0x94b28
jne 0x13697
movq -0x18(%rbp), %rdi
callq 0x13ed0
testb $0x1, %al
jne 0x13692
jmp 0x13697
jmp 0x13779
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x136bc
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x53e0d(%rip), %rsi     # 0x674bd
movb $0x0, %al
callq 0x16f90
jmp 0x13779
leaq 0x8194d(%rip), %rax     # 0x95010
cmpq $0x0, (%rax)
je 0x136db
leaq 0x81940(%rip), %rax     # 0x95010
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x12, %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x10(%rax), %eax
movl %eax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x12, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0x10(%rax), %eax
movl %eax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movsbl 0xd0(%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x40(%rbp)
movq 0x8143c(%rip), %rax     # 0x94b68
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x6, %rcx
andq $0x3fff, %rcx           # imm = 0x3FFF
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
shrq $0x20, %rax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
shrq $0x16, %rax
andq $0x3ff, %rax            # imm = 0x3FF
movl %eax, -0x24(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x13f00
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/semind.c
// Function: sqlite_prepare_persistent
static inline void sqlite_prepare_persistent(const char *sql, sqlite3_stmt **stmt)
{
	int ret;
	do {
		ret = sqlite3_prepare_v3(semind_db, sql, -1, SQLITE_PREPARE_PERSISTENT, stmt, NULL);
		if (ret != SQLITE_OK && ret != SQLITE_BUSY)
			semind_error(1, 0, "unable to prepare query: %s: %s", sqlite3_errmsg(semind_db), sql);
	} while (ret == SQLITE_BUSY);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x81119(%rip), %rdi     # 0x94b20
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %r8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
xorl %eax, %eax
movl %eax, %r9d
callq 0x120d0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x13a5a
cmpl $0x5, -0x14(%rbp)
je 0x13a5a
movq 0x810e7(%rip), %rdi     # 0x94b20
callq 0x123b0
movq %rax, %rcx
movq -0x8(%rbp), %r8
movl $0x1, %edi
xorl %esi, %esi
leaq 0x53bc7(%rip), %rdx     # 0x6761a
movb $0x0, %al
callq 0x131c0
jmp 0x13a5c
cmpl $0x5, -0x14(%rbp)
je 0x13a00
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x122d0
movl %eax, -0xc(%rbp)
cmpl $0x65, -0xc(%rbp)
je 0x13ac9
cmpl $0x64, -0xc(%rbp)
je 0x13ac9
movq 0x81085(%rip), %rdi     # 0x94b20
callq 0x123b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x120c0
movq -0x18(%rbp), %rcx
movq %rax, %r8
movl $0x1, %edi
xorl %esi, %esi
leaq 0x53b78(%rip), %rdx     # 0x6763a
movb $0x0, %al
callq 0x131c0
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x80c35(%rip), %rdi     # 0x94b48
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0x535eb(%rip), %rsi     # 0x67513
callq 0x14000
movq 0x80c14(%rip), %rdi     # 0x94b48
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
leaq 0x535d2(%rip), %rsi     # 0x6751c
callq 0x14000
movq 0x80bf2(%rip), %rdi     # 0x94b48
movq -0x8(%rbp), %rax
movslq 0x1c(%rax), %rdx
leaq 0x535bf(%rip), %rsi     # 0x67524
callq 0x140b0
movq 0x80bd7(%rip), %rdi     # 0x94b48
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, %edx
leaq 0x535a9(%rip), %rsi     # 0x6752a
callq 0x140b0
movq 0x80bbb(%rip), %rdi     # 0x94b48
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdx
leaq 0x537f4(%rip), %rsi     # 0x67790
callq 0x140b0
movq 0x80ba0(%rip), %rdi     # 0x94b48
movq -0x8(%rbp), %rax
movslq 0x38(%rax), %rdx
leaq 0x53579(%rip), %rsi     # 0x67530
callq 0x140b0
movq 0x80b85(%rip), %rdi     # 0x94b48
movq -0x8(%rbp), %rax
movslq 0x3c(%rax), %rdx
leaq 0x53564(%rip), %rsi     # 0x67536
callq 0x140b0
movq 0x80b6a(%rip), %rdi     # 0x94b48
callq 0x13a70
movq 0x80b5e(%rip), %rdi     # 0x94b48
callq 0x14080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/semind.c
// Function: sqlite_prepare
static inline void sqlite_prepare(const char *sql, sqlite3_stmt **stmt)
{
	int ret;
	do {
		ret = sqlite3_prepare_v2(semind_db, sql, -1, stmt, NULL);
		if (ret != SQLITE_OK && ret != SQLITE_BUSY)
			semind_error(1, 0, "unable to prepare query: %s: %s", sqlite3_errmsg(semind_db), sql);
	} while (ret == SQLITE_BUSY);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x80999(%rip), %rdi     # 0x94b20
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rcx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %r8d
callq 0x12470
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x141d5
cmpl $0x5, -0x14(%rbp)
je 0x141d5
movq 0x8096c(%rip), %rdi     # 0x94b20
callq 0x123b0
movq %rax, %rcx
movq -0x8(%rbp), %r8
movl $0x1, %edi
xorl %esi, %esi
leaq 0x5344c(%rip), %rdx     # 0x6761a
movb $0x0, %al
callq 0x131c0
jmp 0x141d7
cmpl $0x5, -0x14(%rbp)
je 0x14180
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/semind.c
// Function: query_appendf
static int query_appendf(sqlite3_str *query, const char *fmt, ...)
{
	int status;
	va_list args;

	va_start(args, fmt);
	sqlite3_str_vappendf(query, fmt, args);
	va_end(args);

	if ((status = sqlite3_str_errcode(query)) == SQLITE_OK)
		return 0;

	if (status == SQLITE_NOMEM)
		message("not enough memory");

	if (status == SQLITE_TOOBIG)
		message("string too big");

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x1447b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x123c0
leaq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
callq 0x12310
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jne 0x144f2
movl $0x0, -0x4(%rbp)
jmp 0x14529
cmpl $0x7, -0x1c(%rbp)
jne 0x1450a
xorl %esi, %esi
leaq 0x538ec(%rip), %rdx     # 0x67ded
movl %esi, %edi
movb $0x0, %al
callq 0x131c0
cmpl $0x12, -0x1c(%rbp)
jne 0x14522
xorl %esi, %esi
leaq 0x538e6(%rip), %rdx     # 0x67dff
movl %esi, %edi
movb $0x0, %al
callq 0x131c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/semind.c
// Function: print_mode
static inline void print_mode(char *value)
{
	char str[3];
	int v = atoi(value);

	if (v == U_DEF) {
		printf("def");
		return;
	}

#define U(m) "-rwm"[(v / m) & 3]
	str[0] = U(U_R_AOF);
	str[1] = U(U_R_VAL);
	str[2] = U(U_R_PTR);

	printf("%.3s", str);
#undef U
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x122c0
movl %eax, -0x10(%rbp)
cmpl $0x10000, -0x10(%rbp)   # imm = 0x10000
jne 0x148b1
leaq 0x54e44(%rip), %rdi     # 0x696ec
movb $0x0, %al
callq 0x12050
jmp 0x1491d
movl -0x10(%rbp), %eax
movl $0x1, %ecx
cltd
idivl %ecx
andl $0x3, %eax
movslq %eax, %rcx
leaq 0x53588(%rip), %rax     # 0x67e51
movb (%rax,%rcx), %al
movb %al, -0xb(%rbp)
movl -0x10(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
andl $0x3, %eax
movslq %eax, %rcx
leaq 0x5356a(%rip), %rax     # 0x67e51
movb (%rax,%rcx), %al
movb %al, -0xa(%rbp)
movl -0x10(%rbp), %eax
movl $0x400, %ecx            # imm = 0x400
cltd
idivl %ecx
andl $0x3, %eax
movslq %eax, %rcx
leaq 0x5354c(%rip), %rax     # 0x67e51
movb (%rax,%rcx), %al
movb %al, -0x9(%rbp)
leaq -0xb(%rbp), %rsi
leaq 0x53540(%rip), %rdi     # 0x67e56
movb $0x0, %al
callq 0x12050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/semind.c
// Function: print_file_line
static void print_file_line(const char *name, int lnum)
{
	/*
	 * All files are sorted by name and line number. So, we can reopen
	 * the file and read it line by line.
	 */
	if (!semind_file_name || strcmp(semind_file_name, name)) {
		if (semind_file_fd) {
			fclose(semind_file_fd);
			free(semind_file_name);
		}

		semind_file_name = strdup(name);

		if (!semind_file_name)
			semind_error(1, errno, "strdup");

		semind_file_fd = fopen(name, "r");

		if (!semind_file_fd)
			semind_error(1, errno, "fopen: %s", name);

		semind_file_lnum = 0;
	}

	do {
		if (semind_file_lnum == lnum) {
			if (semind_line[semind_line_len-1] == '\n')
				semind_line_len--;
			printf("%.*s", semind_line_len, semind_line);
			break;
		}
		semind_file_lnum++;
		errno = 0;
	} while((semind_line_len = getline(&semind_line, &semind_line_buflen, semind_file_fd)) != -1);

	if (errno && errno != EOF)
		semind_error(1, errno, "getline");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, 0x806a1(%rip)     # 0x94fe8
je 0x14962
movq 0x80698(%rip), %rdi     # 0x94fe8
movq -0x8(%rbp), %rsi
callq 0x12370
cmpl $0x0, %eax
je 0x14a01
cmpq $0x0, 0x80676(%rip)     # 0x94fe0
je 0x14984
movq 0x8066d(%rip), %rdi     # 0x94fe0
callq 0x12400
movq 0x80669(%rip), %rdi     # 0x94fe8
callq 0x121e0
movq -0x8(%rbp), %rdi
callq 0x12360
movq %rax, 0x80654(%rip)     # 0x94fe8
cmpq $0x0, 0x8064c(%rip)     # 0x94fe8
jne 0x149b8
callq 0x12350
movl (%rax), %esi
movl $0x1, %edi
leaq 0x5a3fc(%rip), %rdx     # 0x6edad
movb $0x0, %al
callq 0x131c0
movq -0x8(%rbp), %rdi
leaq 0x59aa5(%rip), %rsi     # 0x6e468
callq 0x12190
movq %rax, 0x80611(%rip)     # 0x94fe0
cmpq $0x0, 0x80609(%rip)     # 0x94fe0
jne 0x149f7
callq 0x12350
movl (%rax), %esi
movq -0x8(%rbp), %rcx
movl $0x1, %edi
leaq 0x5346b(%rip), %rdx     # 0x67e5b
movb $0x0, %al
callq 0x131c0
movl $0x0, 0x805f7(%rip)     # 0x94ff8
jmp 0x14a03
movl 0x805ef(%rip), %eax     # 0x94ff8
cmpl -0xc(%rbp), %eax
jne 0x14a56
movq 0x805db(%rip), %rax     # 0x94ff0
movl 0x805e1(%rip), %ecx     # 0x94ffc
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x14a39
movl 0x805cc(%rip), %eax     # 0x94ffc
addl $-0x1, %eax
movl %eax, 0x805c3(%rip)     # 0x94ffc
movl 0x805bd(%rip), %esi     # 0x94ffc
movq 0x805aa(%rip), %rdx     # 0x94ff0
leaq 0x5b53d(%rip), %rdi     # 0x6ff8a
movb $0x0, %al
callq 0x12050
jmp 0x14a99
movl 0x8059c(%rip), %eax     # 0x94ff8
addl $0x1, %eax
movl %eax, 0x80593(%rip)     # 0x94ff8
callq 0x12350
movl $0x0, (%rax)
movq 0x80569(%rip), %rdx     # 0x94fe0
leaq 0x80572(%rip), %rdi     # 0x94ff0
leaq 0x8057b(%rip), %rsi     # 0x95000
callq 0x12390
movl %eax, 0x8056c(%rip)     # 0x94ffc
cmpl $-0x1, %eax
jne 0x14a03
callq 0x12350
cmpl $0x0, (%rax)
je 0x14ac7
callq 0x12350
cmpl $-0x1, (%rax)
je 0x14ac7
callq 0x12350
movl (%rax), %esi
movl $0x1, %edi
leaq 0x533a5(%rip), %rdx     # 0x67e65
movb $0x0, %al
callq 0x131c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/semind.c
// Function: get_db_version
static sqlite3_int64 get_db_version(void)
{
	sqlite3_stmt *stmt;
	sqlite3_int64 dbversion;

	sqlite_prepare("PRAGMA user_version", &stmt);
	sqlite_run(stmt);
	dbversion = sqlite3_column_int64(stmt, 0);
	sqlite3_finalize(stmt);

	return dbversion;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x5395a(%rip), %rdi     # 0x684b9
leaq -0x8(%rbp), %rsi
callq 0x14170
movq -0x8(%rbp), %rdi
callq 0x13a70
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x12210
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12260
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/semind.c
// Function: set_db_version
static void set_db_version(void)
{
	char *sql;
	sqlite3_str *query = sqlite3_str_new(semind_db);

	if (query_appendf(query, "PRAGMA user_version = %d", SINDEX_DATABASE_VERSION) < 0)
		exit(1);

	sql = sqlite3_str_finish(query);
	sqlite_command(sql);
	sqlite3_free(sql);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x7ff71(%rip), %rdi     # 0x94b20
callq 0x122f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5390a(%rip), %rsi     # 0x684cd
movl $0x1, %edx
movb $0x0, %al
callq 0x14440
cmpl $0x0, %eax
jge 0x14bde
movl $0x1, %edi
callq 0x12100
movq -0x10(%rbp), %rdi
callq 0x12290
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13ae0
movq -0x8(%rbp), %rdi
callq 0x121b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16290
movq %rax, -0x10(%rbp)
movq 0x7fc20(%rip), %rax     # 0x95010
movq %rax, -0x18(%rbp)
movq 0x7fc0d(%rip), %rax     # 0x95008
movq (%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movb (%rax), %al
subb $0x5, %al
je 0x15477
jmp 0x15410
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
jne 0x15423
jmp 0x15535
movq 0x7fbde(%rip), %rax     # 0x95008
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
addq $0x4, %rsi
movq -0x8(%rbp), %rdx
movl $0x8, %edi
callq *%rax
cmpq $0x0, -0x18(%rbp)
jne 0x15453
movq -0x8(%rbp), %rax
movq %rax, 0x7fbbd(%rip)     # 0x95010
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rsi
callq 0x16310
movq -0x18(%rbp), %rax
movq %rax, 0x7fb9e(%rip)     # 0x95010
jmp 0x15535
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x40, %rax
cmpq $0x0, %rax
je 0x1549a
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x154a9
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x154ba
jmp 0x15535
cmpq $0x0, -0x18(%rbp)
je 0x15504
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x30ea0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x30ea0
movq -0x38(%rbp), %rdx
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x5311f(%rip), %rsi     # 0x6861c
movb $0x0, %al
callq 0x171a0
movq -0x8(%rbp), %rax
movq %rax, 0x7fb01(%rip)     # 0x95010
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x14fe0
movq -0x20(%rbp), %rsi
xorl %edi, %edi
callq 0x15f90
movq -0x18(%rbp), %rax
movq %rax, 0x7fadb(%rip)     # 0x95010
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x15e3f
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x138(%rbp)
jmp 0x15e4a
xorl %eax, %eax
movq %rax, -0x138(%rbp)
jmp 0x15e4a
movq -0x138(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x15e71
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x15f26
leaq -0x130(%rbp), %rax
movq %rax, -0x140(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x15e96
movq -0x28(%rbp), %rax
movzbl 0x10(%rax), %eax
movl %eax, -0x144(%rbp)
jmp 0x15ea0
xorl %eax, %eax
movl %eax, -0x144(%rbp)
jmp 0x15ea0
movl -0x144(%rbp), %eax
movl %eax, -0x148(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x15ec4
movq -0x28(%rbp), %rax
addq $0x12, %rax
movq %rax, -0x150(%rbp)
jmp 0x15ecf
xorl %eax, %eax
movq %rax, -0x150(%rbp)
jmp 0x15ecf
movl -0x148(%rbp), %ecx
movq -0x140(%rbp), %rdi
movq -0x150(%rbp), %r8
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %r9d
movq -0x18(%rbp), %rax
addq $0x12, %rax
movl $0x100, %esi            # imm = 0x100
leaq 0x52712(%rip), %rdx     # 0x68612
movq %rax, (%rsp)
movb $0x0, %al
callq 0x12090
leaq -0x130(%rbp), %rdi
callq 0x31c60
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x162b0
leaq 0x84d86(%rip), %rax     # 0x9b030
movq %rax, -0x8(%rbp)
jmp 0x162fe
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x162cd
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15150
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x162e9
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x162f6
leaq 0x84d40(%rip), %rax     # 0x9b030
movq %rax, -0x20(%rbp)
jmp 0x162f6
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x7, %eax
je 0x16698
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x8, %eax
je 0x16698
jmp 0x16784
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x166bd
movq 0x7e95e(%rip), %rax     # 0x95008
movq 0x18(%rax), %rax
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq *%rax
jmp 0x166bf
jmp 0x166c1
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x166ec
jmp 0x16782
jmp 0x166ee
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x30(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x1676a
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x16739
cmpq $0x0, -0x20(%rbp)
jne 0x16739
jmp 0x1675f
movl -0x4(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x16290
movl -0x4c(%rbp), %edi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x16660
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x166f5
jmp 0x1676c
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x166ee
jmp 0x16784
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x9, %eax
je 0x1681d
jmp 0x1685a
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x16837
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x16862
movq -0x10(%rbp), %rax
cmpl $0x28, 0x4(%rax)
jne 0x1684f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x16851
jmp 0x1685a
jmp 0x16853
cmpq $0x0, -0x10(%rbp)
jne 0x1680b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x168de
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x10, %eax
jne 0x1690d
movq 0x7e723(%rip), %rax     # 0x95008
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x16af0
movl %eax, %edi
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq *%rax
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x16bd0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x16987
movq -0x8(%rbp), %rax
cmpq $0x0, 0x98(%rax)
jne 0x16970
leaq 0x7a3c3(%rip), %rax     # 0x90d28
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
leaq 0x759b1(%rip), %rax     # 0x8c328
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/dissect.c
// Function: report_symbol
static struct symbol *report_symbol(usage_t mode, struct expression *expr)
{
	struct symbol *sym = expr_symbol(expr);
	struct symbol *ret = base_type(sym);

	if (0 && ret->type == SYM_ENUM)
		return report_member(mode, &expr->pos, ret, expr->symbol);

	reporter->r_symbol(fix_mode(ret, mode), &expr->pos, sym);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16d30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16290
movq %rax, -0x20(%rbp)
movq 0x7e638(%rip), %rax     # 0x95008
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x16af0
movl %eax, %edi
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x9, %eax
ja 0x16b56
movq -0x18(%rbp), %rax
leaq 0x51a9e(%rip), %rcx     # 0x685c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x16b3c
jmp 0x16ba4
jmp 0x16b3e
movl -0xc(%rbp), %eax
andl $0xd, %eax
cmpl $0x0, %eax
je 0x16b54
movl -0xc(%rbp), %eax
andl $0xff, %eax
movl %eax, -0xc(%rbp)
jmp 0x16b56
jmp 0x16ba4
movl -0xc(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x16b6c
movl -0xc(%rbp), %eax
orl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $-0x7, %eax
movl %eax, -0xc(%rbp)
jmp 0x16ba4
movl -0xc(%rbp), %eax
andl $0xd00, %eax            # imm = 0xD00
cmpl $0x0, %eax
je 0x16b8f
movl -0xc(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0xc(%rbp)
jmp 0x16ba2
cmpl $0x8, -0xc(%rbp)
je 0x16ba0
movl -0xc(%rbp), %edi
callq 0x16870
movl %eax, -0xc(%rbp)
jmp 0x16ba2
jmp 0x16ba4
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x16bb8
movl -0xc(%rbp), %eax
andl $-0x3, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x16c16
jmp 0x16d17
jmp 0x16c18
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq -0x40(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x16cff
movq -0x40(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x16c6a
cmpq $0x0, -0x28(%rbp)
jne 0x16c6a
jmp 0x16cf1
cmpq $0x0, -0x18(%rbp)
jne 0x16c8b
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x16c89
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x16d1f
jmp 0x16ce8
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x16cba
movq -0x28(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x16bd0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x16cb8
jmp 0x16cca
jmp 0x16ce6
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x16ce4
jmp 0x16cca
cmpq $0x0, -0x20(%rbp)
je 0x16cda
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x16d1f
jmp 0x16ce6
jmp 0x16ce8
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x16c1f
jmp 0x16d01
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq -0x38(%rbp), %rax
jne 0x16c18
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)