LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: command_change_directory
static void command_change_directory(struct commandexecutor *commandexecutor, char *path)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	save_current_position(app);

	if(path_set_from_string(&app->cwd, path) == 0)
		enter_directory(app, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x178, %rax           # imm = 0xFE88
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x58f0
movq -0x18(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
movq -0x10(%rbp), %rsi
callq 0xb540
cmpl $0x0, %eax
jne 0x3d4d
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5260
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: command_yank
static void command_yank(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	const struct list *list = NULL;

	int ret = dirmodel_getmarkedfilenames(&app->model, &list);
	char *cwd_copy = strdup(path_tocstr(&app->cwd));

	if(ret == ENOMEM)
		goto err;

	if(ret == 0) {
		if(cwd_copy == NULL)
			goto err;
	} else if(ret == ENOENT) {
		if(listmodel_count(&app->model.listmodel) == 0)
			goto err;

		struct list *selectedlist = list_new(1);
		if(selectedlist == NULL)
			goto err;
		list = selectedlist;

		size_t index = listview_getindex(&app->view);
		char *filename = strdup(dirmodel_getfilename(&app->model, index));
		if(filename == NULL)
			goto err;

		if(!list_append(selectedlist, filename)) {
			free(filename);
			goto err;
		}
	}
	clipboard_set_contents(&app->clipboard, cwd_copy, list);
	return;
err:
	free(cwd_copy);
	list_delete(list, free);
	clipboard_set_contents(&app->clipboard, NULL, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x178, %rax           # imm = 0xFE88
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
leaq -0x20(%rbp), %rsi
callq 0x7790
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0xb310
movq %rax, %rdi
callq 0x36a0
movq %rax, -0x30(%rbp)
cmpl $0xc, -0x24(%rbp)
jne 0x4071
jmp 0x4136
cmpl $0x0, -0x24(%rbp)
jne 0x4088
cmpq $0x0, -0x30(%rbp)
jne 0x4083
jmp 0x4136
jmp 0x411c
cmpl $0x2, -0x24(%rbp)
jne 0x411a
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0xa660
cmpq $0x0, %rax
jne 0x40aa
jmp 0x4136
movl $0x1, %edi
callq 0x9f60
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x40c1
jmp 0x4136
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xafa0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x40(%rbp), %rsi
callq 0x8250
movq %rax, %rdi
callq 0x36a0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x40fc
jmp 0x4136
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xa0b0
testb $0x1, %al
jne 0x4118
movq -0x48(%rbp), %rdi
callq 0x3740
jmp 0x4136
jmp 0x411a
jmp 0x411c
movq -0x18(%rbp), %rdi
addq $0x150, %rdi            # imm = 0x150
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5fb0
jmp 0x4166
movq -0x30(%rbp), %rdi
callq 0x3740
movq -0x20(%rbp), %rdi
movq 0xce6e(%rip), %rsi      # 0x10fb8
callq 0xa010
movq -0x18(%rbp), %rdi
addq $0x150, %rdi            # imm = 0x150
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x5fb0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: command_mkdir
static void command_mkdir(struct commandexecutor *commandexecutor, char *dirname)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	if(mkdir(dirname, 0777) == 0) {
		dirmodel_notify_file_added_or_changed(&app->model, dirname);
		dirmodel_notify_flush(&app->model);
		select_filename(app, dirname);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x178, %rax           # imm = 0xFE88
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3130
cmpl $0x0, %eax
jne 0x41fc
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0x7fc0
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x80a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5a80
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: command_cmdline
static void command_cmdline(struct commandexecutor *commandexecutor, char *command)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	app->mode = MODE_COMMAND;
	curs_set(1);
	commandline_start(&app->commandline, L':');

	if(command != NULL) {
		size_t length = mbstowcs(NULL, command, 0);
		if(length != (size_t)-1) {
			wchar_t buffer[length + 1];
			mbstowcs(buffer, command, length);

			for(size_t i = 0; i < length; i++)
				commandline_handlekey(&app->commandline, buffer[i], false);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x178, %rax           # imm = 0xFE88
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x1, 0x1bc(%rax)
movl $0x1, %edi
callq 0x3140
movq -0x18(%rbp), %rdi
addq $0xf8, %rdi
movl $0x3a, %esi
callq 0x65b0
cmpq $0x0, -0x10(%rbp)
je 0x4302
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rdi
callq 0x31a0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x4300
movq -0x20(%rbp), %rcx
movq %rcx, %rax
incq %rax
movq %rsp, %rdx
movq %rdx, -0x28(%rbp)
leaq 0x13(,%rcx,4), %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rsp
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x31a0
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x42f9
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rdi
addq $0xf8, %rdi
movq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %esi
xorl %edx, %edx
callq 0x69e0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x42c4
movq -0x28(%rbp), %rax
movq %rax, %rsp
jmp 0x4302
movq %rbp, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: command_rename
static void command_rename(struct commandexecutor *commandexecutor, char *newfilename)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	if(listmodel_count(&app->model.listmodel) == 0)
		return;

	size_t index = listview_getindex(&app->view);
	const char *filename = dirmodel_getfilename(&app->model, index);

	if(rename(filename, newfilename) == 0) {
		dirmodel_notify_file_deleted(&app->model, filename);
		dirmodel_notify_file_added_or_changed(&app->model, newfilename);
		dirmodel_notify_flush(&app->model);
		select_filename(app, newfilename);
		if(app->mode == MODE_NORMAL)
			refresh_statusbar(app);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x178, %rax           # imm = 0xFE88
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0xa660
cmpq $0x0, %rax
jne 0x4346
jmp 0x43ce
movq -0x18(%rbp), %rdi
callq 0xafa0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x20(%rbp), %rsi
callq 0x8250
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3630
cmpl $0x0, %eax
jne 0x43ce
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x28(%rbp), %rsi
callq 0x7e50
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0x7fc0
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x80a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5a80
movq -0x18(%rbp), %rax
cmpl $0x0, 0x1bc(%rax)
jne 0x43cc
movq -0x18(%rbp), %rdi
callq 0x5560
jmp 0x43ce
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: command_search_next
static void command_search_next(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	if(!app->lastsearch_regex)
		return;

	size_t index = listview_getindex(&app->view);

	index = dirmodel_regex_getnext(&app->model, app->lastsearch_regex, index, app->lastsearch_direction);

	listview_setindex(&app->view, index);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x178, %rax           # imm = 0xFE88
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x1c8(%rax)
jne 0x444e
jmp 0x44a4
movq -0x18(%rbp), %rdi
callq 0xafa0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rax
movq 0x1c8(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x1d0(%rax), %ecx
callq 0x79f0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xaf70
movq -0x18(%rbp), %rdi
callq 0xa990
movq -0x18(%rbp), %rdi
callq 0x5560
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: command_sort
static void command_sort(struct commandexecutor *commandexecutor, char *mode_string)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	enum dirmodel_sort_mode mode;
	if(strcmp(mode_string, "name+") == 0)
		mode = DIRMODEL_FILENAME;
	else if(strcmp(mode_string, "name-") == 0)
		mode = DIRMODEL_FILENAME_DESCENDING;
	else if(strcmp(mode_string, "size+") == 0)
		mode = DIRMODEL_SIZE;
	else if(strcmp(mode_string, "size-") == 0)
		mode = DIRMODEL_SIZE_DESCENDING;
	else if(strcmp(mode_string, "mtime+") == 0)
		mode = DIRMODEL_MTIME;
	else if(strcmp(mode_string, "mtime-") == 0)
		mode = DIRMODEL_MTIME_DESCENDING;
	else
		return;
	dirmodel_set_sort_mode(&app->model, mode);
	enter_directory(app, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x178, %rax           # imm = 0xFE88
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8bb6(%rip), %rsi      # 0xd15f
callq 0x33d0
cmpl $0x0, %eax
jne 0x45bf
movl $0x0, -0x1c(%rbp)
jmp 0x4664
movq -0x10(%rbp), %rdi
leaq 0x8b9b(%rip), %rsi      # 0xd165
callq 0x33d0
cmpl $0x0, %eax
jne 0x45e0
movl $0x1, -0x1c(%rbp)
jmp 0x4662
movq -0x10(%rbp), %rdi
leaq 0x8b80(%rip), %rsi      # 0xd16b
callq 0x33d0
cmpl $0x0, %eax
jne 0x45fe
movl $0x2, -0x1c(%rbp)
jmp 0x4660
movq -0x10(%rbp), %rdi
leaq 0x8b68(%rip), %rsi      # 0xd171
callq 0x33d0
cmpl $0x0, %eax
jne 0x461c
movl $0x3, -0x1c(%rbp)
jmp 0x465e
movq -0x10(%rbp), %rdi
leaq 0x8b50(%rip), %rsi      # 0xd177
callq 0x33d0
cmpl $0x0, %eax
jne 0x463a
movl $0x4, -0x1c(%rbp)
jmp 0x465c
movq -0x10(%rbp), %rdi
leaq 0x8b39(%rip), %rsi      # 0xd17e
callq 0x33d0
cmpl $0x0, %eax
jne 0x4658
movl $0x5, -0x1c(%rbp)
jmp 0x465a
jmp 0x4681
jmp 0x465c
jmp 0x465e
jmp 0x4660
jmp 0x4662
jmp 0x4664
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movl -0x1c(%rbp), %esi
callq 0x7e20
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5260
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: handle_signal
static void handle_signal(struct application *app)
{
	struct signalfd_siginfo info;
	int status;

	if(read(app->signal_fd, &info, sizeof(info)) != sizeof(info))
		return;

	switch(info.ssi_signo) {
	case SIGWINCH:
		endwin();
		doupdate();
		mvwin(app->status, LINES - 1, 0);
		wresize(app->status, 1, COLS);
		wresize(app->pathbar, 1, COLS);
		listview_resize(&app->view, COLS, LINES - 2);
		listview_refresh(&app->view);
		commandline_resize(&app->commandline, 0, LINES - 1, COLS);
		display_current_path(app);
		if(app->mode == MODE_NORMAL)
			refresh_statusbar(app);
		break;
	case SIGCHLD:
		if(info.ssi_code == CLD_EXITED ||
		   info.ssi_code == CLD_KILLED ||
		   info.ssi_code == CLD_DUMPED) {
			processmanager_waitpid(&app->pm, info.ssi_pid, &status);
		}
		break;
	case SIGALRM:
		app->timer_running = false;
		dirmodel_notify_flush(&app->model);
		listview_refresh(&app->view);
		if(app->mode == MODE_NORMAL)
			refresh_statusbar(app);
		else
			commandline_updatecursor(&app->commandline);
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x1ac(%rax), %edi
leaq -0x88(%rbp), %rsi
movl $0x80, %edx
callq 0x33c0
cmpq $0x80, %rax
je 0x4b17
jmp 0x4c9c
movl -0x88(%rbp), %eax
movl %eax, -0x90(%rbp)
subl $0xe, %eax
je 0x4c51
jmp 0x4b2e
movl -0x90(%rbp), %eax
subl $0x11, %eax
je 0x4c23
jmp 0x4b3f
movl -0x90(%rbp), %eax
subl $0x1c, %eax
jne 0x4c9c
jmp 0x4b50
callq 0x36c0
callq 0x3500
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rdi
movq 0xc47c(%rip), %rax      # 0x10fe8
movl (%rax), %esi
subl $0x1, %esi
xorl %edx, %edx
callq 0x35c0
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rdi
movq 0xc456(%rip), %rax      # 0x10fe0
movl (%rax), %edx
movl $0x1, %esi
callq 0x3650
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rdi
movq 0xc438(%rip), %rax      # 0x10fe0
movl (%rax), %edx
movl $0x1, %esi
callq 0x3650
movq -0x8(%rbp), %rdi
movq 0xc421(%rip), %rax      # 0x10fe0
movl (%rax), %esi
movq 0xc420(%rip), %rax      # 0x10fe8
movl (%rax), %edx
subl $0x2, %edx
callq 0xafe0
movq -0x8(%rbp), %rdi
callq 0xa990
movq -0x8(%rbp), %rdi
addq $0xf8, %rdi
movq 0xc3fb(%rip), %rax      # 0x10fe8
movl (%rax), %edx
subl $0x1, %edx
movq 0xc3e7(%rip), %rax      # 0x10fe0
movl (%rax), %ecx
xorl %esi, %esi
callq 0x71e0
movq -0x8(%rbp), %rdi
callq 0x5c90
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1bc(%rax)
jne 0x4c21
movq -0x8(%rbp), %rdi
callq 0x5560
jmp 0x4c9c
cmpl $0x1, -0x80(%rbp)
je 0x4c35
cmpl $0x2, -0x80(%rbp)
je 0x4c35
cmpl $0x3, -0x80(%rbp)
jne 0x4c4f
movq -0x8(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
movl -0x7c(%rbp), %esi
leaq -0x8c(%rbp), %rdx
callq 0xba50
jmp 0x4c9c
movq -0x8(%rbp), %rax
movb $0x0, 0x1a8(%rax)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x80a0
movq -0x8(%rbp), %rdi
callq 0xa990
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1bc(%rax)
jne 0x4c8a
movq -0x8(%rbp), %rdi
callq 0x5560
jmp 0x4c9a
movq -0x8(%rbp), %rdi
addq $0xf8, %rdi
callq 0x6540
jmp 0x4c9c
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: enter_directory
static bool enter_directory(struct application *app, const char *oldpathname)
{
	while(1) {
		const char *cwd = path_tocstr(&app->cwd);

		if(app->inotify_fd != -1) {
			if(app->inotify_watch != -1)
				inotify_rm_watch(app->inotify_fd, app->inotify_watch);

			app->inotify_watch = inotify_add_watch(app->inotify_fd, cwd,
				IN_CREATE |
				IN_ATTRIB |
				IN_DELETE |
				IN_MOVED_FROM |
				IN_MOVED_TO |
				IN_MODIFY |
				IN_EXCL_UNLINK
				);
		}

		if(chdir(cwd) == 0 && dirmodel_change_directory(&app->model, cwd))
			break;

		if(strcmp(cwd, "/") == 0) {
			puts("Cannot even open \"/\", exiting");
			app->running = false;
			return false;
		}
		path_remove_component(&app->cwd, &oldpathname);
	}

	update_terminal_title(app);
	select_stored_position(app, oldpathname);
	display_current_path(app);
	refresh_statusbar(app);
	listview_refresh(&app->view);

	app->inotify_cookie = 0;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0xb310
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x1b0(%rax)
je 0x52db
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x1b4(%rax)
je 0x52b7
movq -0x10(%rbp), %rax
movl 0x1b0(%rax), %edi
movq -0x10(%rbp), %rax
movl 0x1b4(%rax), %esi
callq 0x36b0
movq -0x10(%rbp), %rax
movl 0x1b0(%rax), %edi
movq -0x20(%rbp), %rsi
movl $0x40003c6, %edx        # imm = 0x40003C6
callq 0x34b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1b4(%rax)
movq -0x20(%rbp), %rdi
callq 0x3250
cmpl $0x0, %eax
jne 0x5302
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movq -0x20(%rbp), %rsi
callq 0x8330
testb $0x1, %al
jne 0x5300
jmp 0x5302
jmp 0x534d
movq -0x20(%rbp), %rdi
leaq 0x7e78(%rip), %rsi      # 0xd185
callq 0x33d0
cmpl $0x0, %eax
jne 0x5334
leaq 0x7e69(%rip), %rdi      # 0xd187
callq 0x3160
movq -0x10(%rbp), %rax
movb $0x0, 0x1c0(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x5390
movq -0x10(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
leaq -0x18(%rbp), %rsi
callq 0xb470
jmp 0x5270
movq -0x10(%rbp), %rdi
callq 0x5d10
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5da0
movq -0x10(%rbp), %rdi
callq 0x5c90
movq -0x10(%rbp), %rdi
callq 0x5560
movq -0x10(%rbp), %rdi
callq 0xa990
movq -0x10(%rbp), %rax
movl $0x0, 0x1b8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: application_run_rcfile
static bool application_run_rcfile(struct application *app)
{
	struct path *rc_path = determine_usable_config_file(PROJECT, NULL, "rc", R_OK);
	if(rc_path == NULL)
		return false;

	char *rcstr = application_load_rcfile(path_tocstr(rc_path));
	if(rcstr == NULL) {
		path_delete(rc_path);
		return false;
	}

	char *saveptr;
	char *token = strtok_r(rcstr, "\n", &saveptr);

	do {
		commandexecutor_execute(&app->commandexecutor, token);
	} while((token = strtok_r(NULL, "\n", &saveptr)) != NULL);

	path_delete(rc_path);
	free(rcstr);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x7d81(%rip), %rdi      # 0xd134
xorl %eax, %eax
movl %eax, %esi
leaq 0x7dfa(%rip), %rdx      # 0xd1b8
movl $0x4, %ecx
callq 0xbed0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x53dc
movb $0x0, -0x1(%rbp)
jmp 0x5467
movq -0x18(%rbp), %rdi
callq 0xb310
movq %rax, %rdi
callq 0x5e80
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5407
movq -0x18(%rbp), %rdi
callq 0xb7f0
movb $0x0, -0x1(%rbp)
jmp 0x5467
movq -0x20(%rbp), %rdi
leaq 0x7da9(%rip), %rsi      # 0xd1bb
leaq -0x28(%rbp), %rdx
callq 0x33b0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
movq -0x30(%rbp), %rsi
callq 0x6410
xorl %eax, %eax
movl %eax, %edi
leaq 0x7d7d(%rip), %rsi      # 0xd1bb
leaq -0x28(%rbp), %rdx
callq 0x33b0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x541f
movq -0x18(%rbp), %rdi
callq 0xb7f0
movq -0x20(%rbp), %rdi
callq 0x3740
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: application_destroy
void application_destroy(struct application *app)
{
	free((void*)app->lastsearch_regex);
	listview_destroy(&app->view);
	path_destroy(&app->cwd);
	commandline_destroy(&app->commandline);
	if(app->status)
		delwin(app->status);
	if(app->pathbar)
		delwin(app->pathbar);
	dict_delete(app->stored_positions, true);
	dirmodel_destroy(&app->model);
	keymap_destroy(&app->keymap);
	clipboard_destroy(&app->clipboard);
	processmanager_destroy(&app->pm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rdi
callq 0x3740
movq -0x8(%rbp), %rdi
callq 0xb2d0
movq -0x8(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0xb8a0
movq -0x8(%rbp), %rdi
addq $0xf8, %rdi
callq 0x7480
movq -0x8(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
je 0x54e3
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rdi
callq 0x31e0
movq -0x8(%rbp), %rax
cmpq $0x0, 0xe8(%rax)
je 0x5501
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rdi
callq 0x31e0
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rdi
movl $0x1, %esi
callq 0x7500
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x8860
movq -0x8(%rbp), %rdi
addq $0x168, %rdi            # imm = 0x168
callq 0x8f10
movq -0x8(%rbp), %rdi
addq $0x150, %rdi            # imm = 0x150
callq 0x6110
movq -0x8(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
callq 0xbb40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: save_current_position
static void save_current_position(struct application *app)
{
	if(listmodel_count(&app->model.listmodel) != 0) {
		free(dict_get(app->stored_positions, path_tocstr(&app->cwd)));

		size_t index = listview_getindex(&app->view);
		const char *filename = dirmodel_getfilename(&app->model, index);

		char *filename_copy = strdup(filename);
		if(filename_copy == NULL)
			return;
		if(!dict_set(app->stored_positions, path_tocstr(&app->cwd), filename_copy))
			free(filename_copy);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0xa660
cmpq $0x0, %rax
je 0x59bc
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0xb310
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x76d0
movq %rax, %rdi
callq 0x3740
movq -0x8(%rbp), %rdi
callq 0xafa0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0x8250
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x36a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x597e
jmp 0x59bc
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0xb310
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x75a0
testb $0x1, %al
jne 0x59ba
movq -0x20(%rbp), %rdi
callq 0x3740
jmp 0x59bc
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: unblock_signals
static void unblock_signals(void)
{
	sigset_t sigset;

	sigemptyset(&sigset);
	sigaddset(&sigset, SIGWINCH);
	sigaddset(&sigset, SIGCHLD);
	sigaddset(&sigset, SIGALRM);
	sigprocmask(SIG_UNBLOCK, &sigset, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x80(%rbp), %rdi
callq 0x3400
leaq -0x80(%rbp), %rdi
movl $0x1c, %esi
callq 0x36e0
leaq -0x80(%rbp), %rdi
movl $0x11, %esi
callq 0x36e0
leaq -0x80(%rbp), %rdi
movl $0xe, %esi
callq 0x36e0
movl $0x1, %edi
leaq -0x80(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x30a0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: background_process_and_unblock_signals
static void background_process_and_unblock_signals(void)
{
	int fd = open("/dev/null", O_RDWR);
	dup2(fd, 0);
	dup2(fd, 1);
	dup2(fd, 2);

	unblock_signals();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x7716(%rip), %rdi      # 0xd155
movl $0x2, %esi
movb $0x0, %al
callq 0x3600
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
xorl %esi, %esi
callq 0x3270
movl -0x4(%rbp), %edi
movl $0x1, %esi
callq 0x3270
movl -0x4(%rbp), %edi
movl $0x2, %esi
callq 0x3270
callq 0x59d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: select_filename
static void select_filename(struct application *app, const char *filename)
{
	size_t index;

	if(!dirmodel_get_index(&app->model, filename, &index))
		return;
	if(index == listmodel_count(&app->model.listmodel))
		index--;
	listview_setindex(&app->view, index);
	listview_refresh(&app->view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x79b0
testb $0x1, %al
jne 0x5aab
jmp 0x5aee
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0xa660
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0x5ad8
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xaf70
movq -0x8(%rbp), %rdi
callq 0xa990
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: search
static void search(struct application *app, const char *regex, int direction)
{
	free((void*)app->lastsearch_regex);
	app->lastsearch_regex = strdup(regex);
	app->lastsearch_direction = direction;

	command_search_next(&app->commandexecutor, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rdi
callq 0x3740
movq -0x10(%rbp), %rdi
callq 0x36a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1c8(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1d0(%rax)
movq -0x8(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
xorl %eax, %eax
movl %eax, %esi
callq 0x4420
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: insert_current_file_into_commandline
static void insert_current_file_into_commandline(struct application *app)
{
	if(listmodel_count(&app->model.listmodel) == 0)
		return;

	size_t index = listview_getindex(&app->view);
	const char *filename = dirmodel_getfilename(&app->model, index);
	size_t length = mbstowcs(NULL, filename, 0);

	if(length != (size_t)-1) {
		wchar_t buffer[length + 1];
		mbstowcs(buffer, filename, length);

		for(size_t i = 0; i < length; i++)
			commandline_handlekey(&app->commandline, buffer[i], false);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0xa660
cmpq $0x0, %rax
jne 0x5bc4
jmp 0x5c80
movq -0x8(%rbp), %rdi
callq 0xafa0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0x8250
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rdi
callq 0x31a0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x5c80
movq -0x20(%rbp), %rcx
movq %rcx, %rax
incq %rax
movq %rsp, %rdx
movq %rdx, -0x28(%rbp)
leaq 0x13(,%rcx,4), %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rsp
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x31a0
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x5c79
movq -0x40(%rbp), %rax
movq -0x8(%rbp), %rdi
addq $0xf8, %rdi
movq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %esi
xorl %edx, %edx
callq 0x69e0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x5c44
movq -0x28(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: display_current_path
static void display_current_path(struct application *app)
{
	wmove(app->pathbar, 0, 0);
	werase(app->pathbar);
	wprintw(app->pathbar, "%s", path_tocstr(&app->cwd));
	wrefresh(app->pathbar);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x3090
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rdi
callq 0x30e0
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0xb310
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x743f(%rip), %rsi      # 0xd12c
movb $0x0, %al
callq 0x3730
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rdi
callq 0x3390
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: update_terminal_title
static void update_terminal_title(struct application *app)
{
	if(!tigetflag("hs"))
		return;

	putp(tigetstr("tsl"));
	putp("dfm [");
	putp(path_tocstr(&app->cwd));
	putp("]");
	putp(tigetstr("fsl"));
	fflush(stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7482(%rip), %rdi      # 0xd1a5
callq 0x31f0
cmpl $0x0, %eax
jne 0x5d2f
jmp 0x5d96
leaq 0x7472(%rip), %rdi      # 0xd1a8
callq 0x35f0
movq %rax, %rdi
callq 0x3510
leaq 0x7462(%rip), %rdi      # 0xd1ac
callq 0x3510
movq -0x8(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0xb310
movq %rax, %rdi
callq 0x3510
leaq 0x7444(%rip), %rdi      # 0xd1b2
callq 0x3510
leaq 0x743a(%rip), %rdi      # 0xd1b4
callq 0x35f0
movq %rax, %rdi
callq 0x3510
movq 0xb242(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
callq 0x34a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: select_stored_position
static void select_stored_position(struct application *app, const char *oldfilename)
{
	const char *filename;

	if(oldfilename)
		filename = oldfilename;
	else
		filename = dict_get(app->stored_positions, path_tocstr(&app->cwd));

	if(filename)
		select_filename(app, filename);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5dc1
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x5df0
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0xb310
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x76d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5e04
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5a80
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: create_signalfd
static int create_signalfd()
{
	sigset_t sigset;

	sigemptyset(&sigset);
	sigaddset(&sigset, SIGWINCH);
	sigaddset(&sigset, SIGCHLD);
	sigaddset(&sigset, SIGALRM);
	sigprocmask(SIG_BLOCK, &sigset, NULL);

	return signalfd(-1, &sigset, SFD_CLOEXEC);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x80(%rbp), %rdi
callq 0x3400
leaq -0x80(%rbp), %rdi
movl $0x1c, %esi
callq 0x36e0
leaq -0x80(%rbp), %rdi
movl $0x11, %esi
callq 0x36e0
leaq -0x80(%rbp), %rdi
movl $0xe, %esi
callq 0x36e0
xorl %edi, %edi
leaq -0x80(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x30a0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq -0x80(%rbp), %rsi
movl $0x80000, %edx          # imm = 0x80000
callq 0x3300
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: application_load_rcfile
static char *application_load_rcfile(const char *filename)
{
	struct stat st;
	int ret = stat(filename, &st);
	if(ret != 0)
		return NULL;

	size_t size = st.st_size;
	if(size == 0)
		return NULL;
	char *contents = malloc(size + 1);

	if(contents == NULL)
		return NULL;

	int fd = open(filename, O_RDONLY);
	if(fd < 0) {
		free(contents);
		return NULL;
	}

	ret = read(fd, contents, size);
	close(fd);

	if(ret < 0) {
		free(contents);
		return NULL;
	}

	contents[ret] = '\0';
	return contents;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3430
movl %eax, -0xa4(%rbp)
cmpl $0x0, -0xa4(%rbp)
je 0x5ebb
movq $0x0, -0x8(%rbp)
jmp 0x5fa3
movq -0x70(%rbp), %rax
movq %rax, -0xb0(%rbp)
cmpq $0x0, -0xb0(%rbp)
jne 0x5edd
movq $0x0, -0x8(%rbp)
jmp 0x5fa3
movq -0xb0(%rbp), %rdi
addq $0x1, %rdi
callq 0x3490
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0xb8(%rbp)
jne 0x5f0b
movq $0x0, -0x8(%rbp)
jmp 0x5fa3
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x3600
movl %eax, -0xbc(%rbp)
cmpl $0x0, -0xbc(%rbp)
jge 0x5f3d
movq -0xb8(%rbp), %rdi
callq 0x3740
movq $0x0, -0x8(%rbp)
jmp 0x5fa3
movl -0xbc(%rbp), %edi
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
callq 0x33c0
movl %eax, -0xa4(%rbp)
movl -0xbc(%rbp), %edi
callq 0x3320
cmpl $0x0, -0xa4(%rbp)
jge 0x5f86
movq -0xb8(%rbp), %rdi
callq 0x3740
movq $0x0, -0x8(%rbp)
jmp 0x5fa3
movq -0xb8(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0xb8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/clipboard.c
// Function: clipboard_set_contents
bool clipboard_set_contents(struct clipboard *clipboard, const char *path, const struct list *filelist)
{
	if(clipboard->shared_clipboard_path) {
		int clipboard_dir_fd = open(clipboard->shared_clipboard_path, O_RDONLY);
		if(clipboard_dir_fd == -1) {
			free((void *)path);
			list_delete(filelist, free);
			return false;
		}

		unlinkat(clipboard_dir_fd, CLIPBOARD_PATH, 0);
		unlinkat(clipboard_dir_fd, CLIPBOARD_LIST, 0);
		bool ret = dump_contents_to_directory(clipboard_dir_fd, path, filelist);

		free((void *)path);
		list_delete(filelist, free);
		close(clipboard_dir_fd);

		return ret;
	} else {
		clipboard_destroy(clipboard);
		clipboard->path = path;
		clipboard->filelist = filelist;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6071
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x3600
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x600f
movq -0x18(%rbp), %rdi
callq 0x3740
movq -0x20(%rbp), %rdi
movq 0xafb7(%rip), %rsi      # 0x10fb8
callq 0xa010
movb $0x0, -0x1(%rbp)
jmp 0x6095
movl -0x24(%rbp), %edi
leaq 0x71b7(%rip), %rsi      # 0xd1d0
xorl %edx, %edx
callq 0x3150
movl -0x24(%rbp), %edi
leaq 0x71b5(%rip), %rsi      # 0xd1df
xorl %edx, %edx
callq 0x3150
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x60a0
andb $0x1, %al
movb %al, -0x25(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3740
movq -0x20(%rbp), %rdi
movq 0xaf5e(%rip), %rsi      # 0x10fb8
callq 0xa010
movl -0x24(%rbp), %edi
callq 0x3320
movb -0x25(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6095
movq -0x10(%rbp), %rdi
callq 0x6110
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/clipboard.c
// Function: dump_contents_to_directory
static bool dump_contents_to_directory(int dir_fd, const char *path, const struct list *filelist) {
	if(path && filelist) {
		if(!dump_string_to_file(dir_fd, CLIPBOARD_PATH, path))
			return false;

		if(!dump_filelist_to_file(dir_fd, CLIPBOARD_LIST, filelist))
			return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x60fd
cmpq $0x0, -0x18(%rbp)
je 0x60fd
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rdx
leaq 0x7101(%rip), %rsi      # 0xd1d0
callq 0xc000
testb $0x1, %al
jne 0x60de
movb $0x0, -0x1(%rbp)
jmp 0x6101
movl -0x8(%rbp), %edi
movq -0x18(%rbp), %rdx
leaq 0x70f3(%rip), %rsi      # 0xd1df
callq 0xc0a0
testb $0x1, %al
jne 0x60fb
movb $0x0, -0x1(%rbp)
jmp 0x6101
jmp 0x60fd
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/clipboard.c
// Function: clipboard_dump_contents_to_directory
bool clipboard_dump_contents_to_directory(struct clipboard *clipboard, int dir_fd)
{
	if(clipboard->shared_clipboard_path) {
		int clipboard_dir_fd = open(clipboard->shared_clipboard_path, O_RDONLY);
		if(clipboard_dir_fd == -1)
			return false;

		if((faccessat(clipboard_dir_fd, CLIPBOARD_PATH, F_OK, 0) != 0 &&
		    faccessat(clipboard_dir_fd, CLIPBOARD_LIST, F_OK, 0) != 0) ||
		   (linkat(clipboard_dir_fd, CLIPBOARD_PATH, dir_fd, CLIPBOARD_PATH, 0) == 0 &&
		    linkat(clipboard_dir_fd, CLIPBOARD_LIST, dir_fd, CLIPBOARD_LIST, 0) == 0)) {
			close(clipboard_dir_fd);
			return true;
		}
		close(clipboard_dir_fd);
		return false;
	} else {
		return dump_contents_to_directory(dir_fd, clipboard->path, clipboard->filelist);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6217
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x3600
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x6191
movb $0x0, -0x1(%rbp)
jmp 0x6233
movl -0x18(%rbp), %edi
leaq 0x7035(%rip), %rsi      # 0xd1d0
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x3190
cmpl $0x0, %eax
je 0x61c1
movl -0x18(%rbp), %edi
leaq 0x702c(%rip), %rsi      # 0xd1df
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x3190
cmpl $0x0, %eax
jne 0x61fb
movl -0x18(%rbp), %edi
movl -0x14(%rbp), %edx
leaq 0x7002(%rip), %rcx      # 0xd1d0
xorl %r8d, %r8d
movq %rcx, %rsi
callq 0x3550
cmpl $0x0, %eax
jne 0x6209
movl -0x18(%rbp), %edi
movl -0x14(%rbp), %edx
leaq 0x6ff4(%rip), %rcx      # 0xd1df
xorl %r8d, %r8d
movq %rcx, %rsi
callq 0x3550
cmpl $0x0, %eax
jne 0x6209
movl -0x18(%rbp), %edi
callq 0x3320
movb $0x1, -0x1(%rbp)
jmp 0x6233
movl -0x18(%rbp), %edi
callq 0x3320
movb $0x0, -0x1(%rbp)
jmp 0x6233
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x60a0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/commandexecutor.c
// Function: commandexecutor_verify
int commandexecutor_verify(struct commandexecutor *commandexecutor, const char *command) {
	command_ptr commandptr;
	char *param;

	char buffer[strlen(command) + 1];
	strcpy(buffer, command);

	return command_parse(buffer, &commandptr, &param, commandexecutor->commandmap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3230
movq %rax, %rcx
movq %rcx, %rax
incq %rax
movq %rsp, %rdx
movq %rdx, -0x28(%rbp)
addq $0x10, %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rsp
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x3110
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rcx
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x62f0
movq -0x28(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/commandexecutor.c
// Function: command_parse
static int command_parse(char *command, command_ptr *commandptr, char **param, struct command_map *commandmap)
{
	bool param_mandatory;
	bool characters_after_command = false;

	char *token = command;
	size_t length = strcspn(token, " \t");

	if(length > 0) {
		if(token[length] != '\0')
			characters_after_command = true;
		token[length] = '\0';
		map_command(commandmap, token, commandptr, &param_mandatory);
		if(*commandptr == NULL)
			return EINVAL;
	} else
		return EINVAL;

	if(characters_after_command) {
		token = token + length + 1 + strspn(token + length + 1, " \t");
		if(token[0] != '\0') {
			*param = token;
			return 0;
		}
	}

	*param = NULL;
	if(param_mandatory)
		return EINVAL;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movb $0x0, -0x2a(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq 0x6ecf(%rip), %rsi      # 0xd1ee
callq 0x33a0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jbe 0x637d
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x6344
movb $0x1, -0x2a(%rbp)
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x29(%rbp), %rcx
callq 0x6490
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x637b
movl $0x16, -0x4(%rbp)
jmp 0x6405
jmp 0x6386
movl $0x16, -0x4(%rbp)
jmp 0x6405
testb $0x1, -0x2a(%rbp)
je 0x63e4
movq -0x38(%rbp), %rax
addq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
addq -0x40(%rbp), %rdi
addq $0x1, %rdi
leaq 0x6e3f(%rip), %rsi      # 0xd1ee
callq 0x3340
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x63e2
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x6405
jmp 0x63e4
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
testb $0x1, -0x29(%rbp)
je 0x63fe
movl $0x16, -0x4(%rbp)
jmp 0x6405
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/commandexecutor.c
// Function: commandexecutor_execute
int commandexecutor_execute(struct commandexecutor *commandexecutor, char *command) {
	command_ptr commandptr;
	char *param;

	int ret = command_parse(command, &commandptr, &param, commandexecutor->commandmap);
	if(ret == 0)
		commandptr(commandexecutor, param);
	else
		return ret;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x62f0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x6451
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq *%rax
jmp 0x6459
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6460
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/commandexecutor.c
// Function: map_command
static void map_command(struct command_map *commandmap, const char *commandname, command_ptr *command_ptr, bool *param_mandatory)
{
	*command_ptr = NULL;

	for(size_t i = 0; commandmap[i].command_name != NULL; i++) {
		if(strcmp(commandmap[i].command_name, commandname) == 0) {
			*command_ptr = commandmap[i].command;
			*param_mandatory = commandmap[i].param_mandatory;
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x652b
movq -0x8(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x33d0
cmpl $0x0, %eax
jne 0x651b
movq -0x8(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movb 0x10(%rax), %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
jmp 0x652b
jmp 0x651d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x64bb
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/commandline.c
// Function: commandline_start
int commandline_start(struct commandline *commandline, wchar_t prompt)
{
	commandline->prompt[0] = prompt;
	commandline->cursor_pos = 0;
	commandline->first = 0;
	commandline->history_position = 0;

	if(commandline->backup_buffer) {
		commandline->buffer = commandline->backup_buffer;
		commandline->backup_buffer = NULL;
	}
	if(commandline->buffer == NULL)
		commandline->buffer = malloc(commandline->allocated_size * sizeof(wchar_t));
	if(commandline->buffer == NULL)
		return ENOMEM;

	commandline->buffer[0] = L'\0';

	commandline_updateview(commandline);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x6614
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x663b
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
shlq $0x2, %rdi
callq 0x3490
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x664f
movl $0xc, -0x4(%rbp)
jmp 0x666d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x6680
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/commandline.c
// Function: commandline_copy_history_buffer
static int commandline_copy_history_buffer(struct commandline *commandline)
{
	if(commandline->history_position == 0)
		return 0;

	wchar_t *history_buffer = commandline->buffer;
	commandline->buffer = commandline->backup_buffer;
	commandline->backup_buffer = NULL;

	while(commandline->allocated_size < wcslen(history_buffer) + 1) {
		if(commandline_makeroom(commandline) != 0)
			return ENOMEM;
	}

	wcscpy(commandline->buffer, history_buffer);
	commandline->history_position = 0;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x6fb3
movl $0x0, -0x4(%rbp)
jmp 0x703d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3280
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x7019
movq -0x10(%rbp), %rdi
callq 0x7150
cmpl $0x0, %eax
je 0x7017
movl $0xc, -0x4(%rbp)
jmp 0x703d
jmp 0x6fdb
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x33e0
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/commandline.c
// Function: commandline_delete_character_before_cursor
static void commandline_delete_character_before_cursor(struct commandline *commandline)
{
	size_t oldcursorpos = commandline->cursor_pos;
	size_t length = wcslen(commandline->buffer);

	if(commandline->cursor_pos > 0) {
		size_t distance = 0;
		int width;
		do {
			width = wcwidth(commandline->buffer[commandline->cursor_pos - 1]);
			distance++;
			commandline->cursor_pos--;
		} while(commandline->cursor_pos > 0 && width < 1);

		wmemmove(commandline->buffer + commandline->cursor_pos, commandline->buffer + oldcursorpos, length - commandline->cursor_pos);
		commandline->buffer[length - distance] = L'\0';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3280
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jbe 0x713e
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %edi
callq 0x3480
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x38(%rcx)
movb %al, -0x25(%rbp)
jbe 0x70e5
cmpl $0x1, -0x24(%rbp)
setl %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x7090
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
subq 0x38(%rax), %rdx
callq 0x35d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
subq -0x20(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)