LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: visit_parent
static char *visit_parent(char *path, char *newpath, int *presel)
{
	char *dir;

	/* There is no going back */
	if (istopdir(path)) {
		/* Continue in type-to-nav mode, if enabled */
		if (cfg.filtermode && presel)
			*presel = FILTER;
		return NULL;
	}

	/* Use a copy as xdirname() may change the string passed */
	if (newpath)
		xstrsncpy(newpath, path, PATH_MAX);
	else
		newpath = path;

	dir = xdirname(newpath);
	if (chdir(dir) == -1) {
		printwarn(presel);
		return NULL;
	}

	return dir;
}

// 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
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x10276
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x10276
movl 0x1027d(%rip), %eax     # 0x204d0
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1026c
cmpq $0x0, -0x20(%rbp)
je 0x1026c
movq -0x20(%rbp), %rax
movl $0x2f, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x102de
cmpq $0x0, -0x18(%rbp)
je 0x10291
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x6250
jmp 0x10299
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x72a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x42d0
cmpl $-0x1, %eax
jne 0x102d6
callq 0x40c0
movl (%rax), %edi
callq 0x4870
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0xd210
movq $0x0, -0x8(%rbp)
jmp 0x102de
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: cdprep
static bool cdprep(char *lastdir, char *lastname, char *path, char *newpath)
{
	if (lastname)
		lastname[0] =  '\0';

	/* Save last working directory */
	xstrsncpy(lastdir, path, PATH_MAX);

	/* Save the newly opted dir in path */
	xstrsncpy(path, newpath, PATH_MAX);
	DPRINTF_S(path);

	clearfilter();
	return cfg.filtermode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x10316
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x6250
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x6250
callq 0x10600
movl 0x1018b(%rip), %eax     # 0x204d0
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: clearfilter
static void clearfilter(void)
{
	char * const fltr = g_ctx[cfg.curctx].c_fltr;

	if (fltr[1]) {
		fltr[REGEX_MAX - 1] = fltr[1];
		fltr[1] = '\0';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xfec6(%rip), %eax      # 0x204d0
shrl $0xd, %eax
andl $0x7, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x11875(%rip), %rax     # 0x21e90
imulq $0x2138, %rcx, %rcx     # imm = 0x2138
addq %rcx, %rax
addq $0x2100, %rax           # imm = 0x2100
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x1(%rax)
je 0x1064f
movq -0x8(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2f(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x1(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: bmtarget
static char *bmtarget(const char *filepath, char *cwd, char *buf)
{
	char target[PATH_MAX + 1];
	ssize_t n = readlink(filepath, target, PATH_MAX);
	if (n != -1) {
		target[n] = '\0';
		return abspath(target, cwd, buf);
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1030(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x41e0
movq %rax, -0x1038(%rbp)
cmpq $-0x1, -0x1038(%rbp)
je 0x106c6
movq -0x1038(%rbp), %rax
movb $0x0, -0x1030(%rbp,%rax)
leaq -0x1030(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5f00
movq %rax, -0x8(%rbp)
jmp 0x106ce
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: send_to_explorer
static void send_to_explorer(int *presel)
{
	if (nselected) {
		int fd = open(fifopath, O_WRONLY|O_NONBLOCK|O_CLOEXEC, 0600);
		if ((fd == -1) || (seltofile(fd, NULL, NEWLINE) != (size_t)(selbufpos)))
			printwarn(presel);
		else {
			resetselind();
			clearselection();
		}
		if (fd > 1)
			close(fd);
	} else
		notify_fifo(TRUE); /* Send opened path to NNN_FIFO */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x19b49(%rip)     # 0x2a5ac
je 0x10ad8
movq 0x111e4(%rip), %rdi     # 0x21c50
movl $0x80801, %esi          # imm = 0x80801
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x46c0
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0x10aa4
movl -0xc(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
leaq 0xbdda(%rip), %rdx      # 0x1c86e
callq 0xc650
movl 0x112d1(%rip), %ecx     # 0x21d70
cmpq %rcx, %rax
je 0x10abe
callq 0x40c0
movl (%rax), %edi
callq 0x4870
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0xd210
jmp 0x10ac8
callq 0x13260
callq 0x12c80
cmpl $0x1, -0xc(%rbp)
jle 0x10ad6
movl -0xc(%rbp), %edi
callq 0x43c0
jmp 0x10ae2
movl $0x1, %edi
callq 0xc890
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: appendfpath
static void appendfpath(const char *path, const size_t len)
{
	if ((selbufpos >= selbuflen) || ((len + 3) > (selbuflen - selbufpos))) {
		selbuflen += PATH_MAX;
		pselbuf = xrealloc(pselbuf, selbuflen);
		if (!pselbuf)
			errexit();
	}

	selbufpos += xstrsncpy(pselbuf + selbufpos, path, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl 0x1126a(%rip), %eax     # 0x21d70
cmpl 0x198c0(%rip), %eax     # 0x2a3cc
jae 0x10b29
movq -0x10(%rbp), %rax
addq $0x3, %rax
movl 0x198b0(%rip), %ecx     # 0x2a3cc
subl 0x1124e(%rip), %ecx     # 0x21d70
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0x10b6b
movl 0x1989d(%rip), %eax     # 0x2a3cc
addl $0x1000, %eax           # imm = 0x1000
movl %eax, 0x19892(%rip)     # 0x2a3cc
movq 0x11237(%rip), %rdi     # 0x21d78
movl 0x19885(%rip), %eax     # 0x2a3cc
movl %eax, %esi
callq 0xcb00
movq %rax, 0x11223(%rip)     # 0x21d78
cmpq $0x0, 0x1121b(%rip)     # 0x21d78
jne 0x10b69
movl $0x667, %edi            # imm = 0x667
callq 0xeb50
jmp 0x10b6b
movq 0x11206(%rip), %rdi     # 0x21d78
movl 0x111f8(%rip), %eax     # 0x21d70
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x6250
movq %rax, %rcx
movl 0x111df(%rip), %eax     # 0x21d70
addq %rcx, %rax
movl %eax, 0x111d6(%rip)     # 0x21d70
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: get_input
static int get_input(const char *prompt)
{
	wint_t ch[1];

	if (prompt)
		printmsg(prompt);
	cleartimeout();

	get_wch(ch);

#ifdef KEY_RESIZE
	while (*ch == KEY_RESIZE) {
		if (prompt) {
			clearoldprompt();
			xlines = LINES;
			printmsg(prompt);
		}

		get_wch(ch);
	}
#endif
	settimeout();
	return (int)*ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10ddc
movq -0x8(%rbp), %rdi
callq 0xd020
movq 0xf1ad(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4580
movq 0xf199(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
leaq -0xc(%rbp), %rsi
callq 0x48d0
cmpl $0x19a, -0xc(%rbp)      # imm = 0x19A
jne 0x10e46
cmpq $0x0, -0x8(%rbp)
je 0x10e31
callq 0x19290
movq 0xf1b1(%rip), %rax      # 0x1ffd0
movl (%rax), %eax
movw %ax, 0x11060(%rip)      # 0x21e88
movq -0x8(%rbp), %rdi
callq 0xd020
movq 0xf158(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
leaq -0xc(%rbp), %rsi
callq 0x48d0
jmp 0x10e03
movq 0xf143(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x4580
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: archive_mount
static bool archive_mount(char *newpath)
{
	char *dir, *cmd = xgetenv("NNN_ARCHMNT", utils[UTIL_ARCHMNT]);
	char *name = pdents[cur].name;
	size_t len = pdents[cur].nlen;
	char mntpath[PATH_MAX];

	if (!getutil(cmd)) {
		printmsg("install utility");
		return FALSE;
	}

	dir = xstrdup(name);
	if (!dir) {
		printmsg(messages[MSG_FAILED]);
		return FALSE;
	}

	while (len > 1)
		if (dir[--len] == '.') {
			dir[len] = '\0';
			break;
		}

	DPRINTF_S(dir);

	/* Create the mount point */
	mkpath(cfgpath, toks[TOK_MNT], mntpath);
	mkpath(mntpath, dir, newpath);
	free(dir);

	if (!xmktree(newpath, TRUE)) {
		printwarn(NULL);
		return FALSE;
	}

	/* Mount archive */
	DPRINTF_S(name);
	DPRINTF_S(newpath);
	if (spawn(cmd, name, newpath, NULL, F_NORMAL)) {
		printmsg(messages[MSG_FAILED]);
		return FALSE;
	}

	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x10(%rbp)
movq 0xe922(%rip), %rsi      # 0x1fa58
leaq 0xb63a(%rip), %rdi      # 0x1c777
callq 0x5c70
movq %rax, -0x20(%rbp)
movq 0x19223(%rip), %rax     # 0x2a370
movslq 0x19224(%rip), %rcx     # 0x2a378
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x19207(%rip), %rax     # 0x2a370
movslq 0x19208(%rip), %rcx     # 0x2a378
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
shrq $0x28, %rax
andq $0xffff, %rax           # imm = 0xFFFF
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x12930
testb $0x1, %al
jne 0x111ab
leaq 0xb5e6(%rip), %rdi      # 0x1c783
callq 0xd020
movb $0x0, -0x1(%rbp)
jmp 0x112a7
movq -0x28(%rbp), %rdi
callq 0x7190
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x111d4
movq 0xe8c2(%rip), %rdi      # 0x1fa88
callq 0xd020
movb $0x0, -0x1(%rbp)
jmp 0x112a7
jmp 0x111d6
cmpq $0x1, -0x30(%rbp)
jbe 0x1120a
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x30(%rbp)
movsbl -0x1(%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x11208
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x1120a
jmp 0x111d6
movq 0x10a57(%rip), %rdi     # 0x21c68
movq 0xeaa8(%rip), %rsi      # 0x1fcc0
leaq -0x1030(%rbp), %rdx
callq 0x74c0
leaq -0x1030(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x74c0
movq -0x18(%rbp), %rdi
callq 0x4090
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7360
testb $0x1, %al
jne 0x11271
callq 0x40c0
movl (%rax), %edi
callq 0x4870
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd210
movb $0x0, -0x1(%rbp)
jmp 0x112a7
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movl $0x8, %r8d
callq 0xde30
cmpl $0x0, %eax
je 0x112a3
movq 0xe7f0(%rip), %rdi      # 0x1fa88
callq 0xd020
movb $0x0, -0x1(%rbp)
jmp 0x112a7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: set_smart_ctx
static void set_smart_ctx(int ctx, char *nextpath, char **path, char *file, char **lastname, char **lastdir)
{
	if (ctx == '+') /* Get smart context */
		ctx = (int)(get_free_ctx() + 1);

	if (ctx == 0 || ctx == cfg.curctx + 1) { /* Same context */
		clearfilter();
		xstrsncpy(*lastdir, *path, PATH_MAX);
		xstrsncpy(*path, nextpath, PATH_MAX);
	} else { /* New context */
		--ctx;
		/* Deactivate the new context and build from scratch */
		g_ctx[ctx].c_cfg.ctxactive = 0;
		DPRINTF_S(nextpath);
		savecurctx(nextpath, file, ctx);
		*path = g_ctx[ctx].c_path;
		*lastdir = g_ctx[ctx].c_last;
		*lastname = g_ctx[ctx].c_name;
	}
}

// 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 %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpl $0x2b, -0x4(%rbp)
jne 0x112f3
callq 0x19210
movzbl %al, %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x1130f
movl -0x4(%rbp), %eax
movl 0xf1ce(%rip), %ecx      # 0x204d0
shrl $0xd, %ecx
andl $0x7, %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x11346
callq 0x10600
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x6250
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x6250
jmp 0x113eb
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x10b36(%rip), %rax     # 0x21e90
imulq $0x2138, %rcx, %rcx     # imm = 0x2138
addq %rcx, %rax
movl 0x2130(%rax), %ecx
andl $0xfffffdff, %ecx       # imm = 0xFFFFFDFF
orl $0x0, %ecx
movl %ecx, 0x2130(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x4(%rbp), %edx
callq 0x10050
movslq -0x4(%rbp), %rax
leaq 0x10afc(%rip), %rcx     # 0x21e90
imulq $0x2138, %rax, %rax     # imm = 0x2138
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movslq -0x4(%rbp), %rax
leaq 0x10ae0(%rip), %rcx     # 0x21e90
imulq $0x2138, %rax, %rax     # imm = 0x2138
addq %rax, %rcx
addq $0x1000, %rcx           # imm = 0x1000
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movslq -0x4(%rbp), %rax
leaq 0x10abd(%rip), %rcx     # 0x21e90
imulq $0x2138, %rax, %rax     # imm = 0x2138
addq %rax, %rcx
addq $0x2000, %rcx           # imm = 0x2000
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: add_bookmark
static void add_bookmark(char *path, char *newpath, int *presel)
{
	char *dir = xbasename(path);

	dir = xreadline(dir[0] ? dir : NULL, messages[MSG_BM_NAME]);
	if (dir && *dir) {
		size_t r = mkpath(cfgpath, toks[TOK_BM], newpath);

		newpath[r - 1] = '/';
		xstrsncpy(newpath + r, dir, PATH_MAX - r);
		printwait((symlink(path, newpath) == -1) ? strerror(errno) : newpath, presel);
	} else
		printwait(messages[MSG_CANCEL], presel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7240
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x11f17
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x11f1f
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x11f1f
movq -0x30(%rbp), %rdi
movq 0xdc8e(%rip), %rsi      # 0x1fbb8
callq 0x144a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x11fce
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x11fce
movq 0xfd13(%rip), %rdi      # 0x21c68
movq 0xdd54(%rip), %rsi      # 0x1fcb0
movq -0x10(%rbp), %rdx
callq 0x74c0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movb $0x2f, (%rax,%rcx)
movq -0x10(%rbp), %rdi
addq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
subq -0x28(%rbp), %rdx
callq 0x6250
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4910
cmpl $-0x1, %eax
jne 0x11fb7
callq 0x40c0
movl (%rax), %edi
callq 0x4870
movq %rax, -0x38(%rbp)
jmp 0x11fbf
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd210
jmp 0x11fde
movq 0xdaab(%rip), %rdi      # 0x1fa80
movq -0x18(%rbp), %rsi
callq 0xd210
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: dentfind
static int dentfind(const char *fname, int n)
{
	for (int i = 0; i < n; ++i)
		if (xstrcmp(fname, pdents[i].name) == 0)
			return i;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x12809
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movq 0x17bc4(%rip), %rcx     # 0x2a370
movslq -0x18(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x127cb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x1c(%rbp)
jmp 0x127ec
movq -0x10(%rbp), %rdi
movq 0x17b9a(%rip), %rax     # 0x2a370
movslq -0x18(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x44e0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl $0x0, %eax
jne 0x127fc
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12810
jmp 0x127fe
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x12796
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: show_stats
static bool show_stats(char *fpath)
{
	static char * const cmds[] = {
#ifdef FILE_MIME_OPTS
		("file " FILE_MIME_OPTS),
#endif
		"file -b",
#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__)
		"stat -x",
#else
		"stat",
#endif
	};

	size_t r = ELEMENTS(cmds);
	int fd = create_tmp_file();
	if (fd == -1)
		return FALSE;

	while (r)
		get_output(cmds[--r], fpath, NULL, fd, FALSE);

	close(fd);

	spawn(pager, g_tmpfpath, NULL, NULL, F_CLI | F_TTY);
	unlink(g_tmpfpath);
	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x3, -0x18(%rbp)
callq 0xddd0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x12848
movb $0x0, -0x1(%rbp)
jmp 0x128b9
jmp 0x1284a
cmpq $0x0, -0x18(%rbp)
je 0x12881
movq -0x18(%rbp), %rcx
movq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
leaq 0xd4a9(%rip), %rax      # 0x1fd10
movq -0x8(%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edx
xorl %r8d, %r8d
callq 0x10ba0
jmp 0x1284a
movl -0x1c(%rbp), %edi
callq 0x43c0
movq 0xe160(%rip), %rdi      # 0x209f0
leaq 0xe169(%rip), %rsi      # 0x20a00
xorl %eax, %eax
movl %eax, %ecx
movl $0x109, %r8d            # imm = 0x109
movq %rcx, %rdx
callq 0xde30
leaq 0xe150(%rip), %rdi      # 0x20a00
callq 0x40d0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: plugscript
static bool plugscript(const char *plugin, uchar_t flags)
{
	mkpath(plgpath, plugin, g_buf);
	if (!access(g_buf, X_OK)) {
		spawn(g_buf, NULL, NULL, NULL, flags);
		return TRUE;
	}

	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq 0xf417(%rip), %rdi      # 0x21da0
movq -0x10(%rbp), %rsi
leaq 0xe0bc(%rip), %rdx      # 0x20a50
callq 0x74c0
leaq 0xe0b0(%rip), %rdi      # 0x20a50
movl $0x1, %esi
callq 0x4720
cmpl $0x0, %eax
jne 0x129d1
movzbl -0x11(%rbp), %eax
leaq 0xe096(%rip), %rdi      # 0x20a50
xorl %ecx, %ecx
movq %rcx, %rsi
movq %rcx, %rdx
movzwl %ax, %r8d
callq 0xde30
movb $0x1, -0x1(%rbp)
jmp 0x129d5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: clearselection
static void clearselection(void)
{
	nselected = 0;
	selbufpos = 0;
	g_state.selmode = 0;
	writesel(NULL, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x1791e(%rip)     # 0x2a5ac
movl $0x0, 0xf0d8(%rip)      # 0x21d70
movl 0xdb86(%rip), %eax      # 0x20824
andl $0xffdfffff, %eax       # imm = 0xFFDFFFFF
orl $0x0, %eax
movl %eax, 0xdb78(%rip)      # 0x20824
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0xe130
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: startselection
static void startselection(void)
{
	if (!g_state.selmode) {
		g_state.selmode = 1;
		nselected = 0;

		if (selbufpos) {
			resetselind();
			writesel(NULL, 0);
			selbufpos = 0;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xd6ba(%rip), %eax      # 0x20824
shrl $0x15, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x131bb
movl 0xd6a9(%rip), %eax      # 0x20824
andl $0xffdfffff, %eax       # imm = 0xFFDFFFFF
orl $0x200000, %eax         # imm = 0x200000
movl %eax, 0xd699(%rip)      # 0x20824
movl $0x0, 0x17417(%rip)     # 0x2a5ac
cmpl $0x0, 0xebd4(%rip)      # 0x21d70
je 0x131b9
callq 0x13260
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0xe130
movl $0x0, 0xebb7(%rip)      # 0x21d70
jmp 0x131bb
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: rmfromselbuf
static void rmfromselbuf(size_t len)
{
	char *found = findinsel(findselpos, len);
	if (!found)
		return;

	memmove(found, found + len, selbufpos - (found + len - pselbuf));
	selbufpos -= len;

	nselected ? writesel(pselbuf, selbufpos - 1) : clearselection();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x183ed(%rip), %rdi     # 0x2b5c0
movq -0x8(%rbp), %rax
movl %eax, %esi
callq 0x17c90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x131eb
jmp 0x13255
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x8(%rbp), %rsi
movl 0xeb73(%rip), %eax      # 0x21d70
movl %eax, %edx
movq -0x10(%rbp), %rax
addq -0x8(%rbp), %rax
movq 0xeb6a(%rip), %rcx      # 0x21d78
subq %rcx, %rax
subq %rax, %rdx
callq 0x46e0
movq -0x8(%rbp), %rcx
movl 0xeb4d(%rip), %eax      # 0x21d70
subq %rcx, %rax
movl %eax, 0xeb44(%rip)      # 0x21d70
cmpl $0x0, 0x17379(%rip)     # 0x2a5ac
je 0x13250
movq 0xeb3c(%rip), %rdi      # 0x21d78
movl 0xeb2e(%rip), %eax      # 0x21d70
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0xe130
jmp 0x13255
callq 0x12c80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: scanselforpath
static int scanselforpath(const char *path, bool getsize)
{
	if (!path[1]) { /* path should always be at least two bytes (including NULL) */
		g_sel[0] = '/';
		findselpos = pselbuf;
		return 1; /* Length of '/' is 1 */
	}

	size_t off = xstrsncpy(g_sel, path, PATH_MAX);

	g_sel[off - 1] = '/';
	/*
	 * We set findselpos only here. Directories can be listed in arbitrary order.
	 * This is the best best we can do for remembering position.
	 */
	findselpos = findinsel(NULL, off);

	if (getsize)
		return off;
	return (findselpos ? off : 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x1(%rax)
jne 0x1332c
movb $0x2f, 0x172ab(%rip)    # 0x2a5c0
movq 0xea5c(%rip), %rax      # 0x21d78
movq %rax, 0x1829d(%rip)     # 0x2b5c0
movl $0x1, -0x4(%rbp)
jmp 0x133a0
movq -0x10(%rbp), %rsi
leaq 0x17289(%rip), %rdi     # 0x2a5c0
movl $0x1000, %edx           # imm = 0x1000
callq 0x6250
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
leaq 0x1726c(%rip), %rax     # 0x2a5c0
movb $0x2f, (%rax,%rcx)
movq -0x20(%rbp), %rax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edi
callq 0x17c90
movq %rax, 0x18252(%rip)     # 0x2b5c0
testb $0x1, -0x11(%rbp)
je 0x1337d
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x133a0
cmpq $0x0, 0x1823b(%rip)     # 0x2b5c0
je 0x13391
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x13399
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x13399
movq -0x28(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: get_cur_or_sel
static int get_cur_or_sel(void)
{
	bool sel = (selbufpos || !isselfileempty());

	/* Check both local buffer and selection file for external selection */
	if (sel && ndents) {
		/* If selection is preferred and we have a local selection, return selection.
		 * Always show the prompt in case of an external selection.
		 */
		if (cfg.prefersel && selbufpos)
			return 's';

		int choice = get_input(messages[MSG_CUR_SEL_OPTS]);

		return ((choice == 'c' || choice == 's') ? choice : 0);
	}

	if (sel)
		return 's';

	if (ndents)
		return 'c';

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb $0x1, %al
cmpl $0x0, 0xddef(%rip)      # 0x21d70
movb %al, -0xd(%rbp)
jne 0x13f90
callq 0x18af0
xorb $-0x1, %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
movb %al, -0x5(%rbp)
testb $0x1, -0x5(%rbp)
je 0x13ffc
cmpl $0x0, 0xdee7(%rip)      # 0x21e8c
je 0x13ffc
movl 0xc523(%rip), %eax      # 0x204d0
shrl $0x10, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x13fca
cmpl $0x0, 0xddb1(%rip)      # 0x21d70
je 0x13fca
movl $0x73, -0x4(%rbp)
jmp 0x14024
movq 0xbacf(%rip), %rdi      # 0x1faa0
callq 0x10dc0
movl %eax, -0xc(%rbp)
cmpl $0x63, -0xc(%rbp)
je 0x13fe5
cmpl $0x73, -0xc(%rbp)
jne 0x13fed
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x13ff4
xorl %eax, %eax
movl %eax, -0x14(%rbp)
jmp 0x13ff4
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x14024
testb $0x1, -0x5(%rbp)
je 0x1400b
movl $0x73, -0x4(%rbp)
jmp 0x14024
cmpl $0x0, 0xde7a(%rip)      # 0x21e8c
je 0x1401d
movl $0x63, -0x4(%rbp)
jmp 0x14024
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: xrm
static bool xrm(char * const fpath, bool use_trash)
{
	char r = confirm_force(FALSE, use_trash);
	if (!r)
		return FALSE;

	if (!use_trash) {
		char rm_opts[5] = "-vr\0";

		rm_opts[3] = r;
		spawn("rm", rm_opts, "--", fpath, F_NORMAL | F_CHKRTN);
	} else
		spawn(trashcmd, fpath, NULL, NULL, F_NORMAL | F_MULTI);

	return (access(fpath, F_OK) == -1); /* File is removed */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
xorl %edi, %edi
andb $0x1, %al
movzbl %al, %esi
callq 0x19a60
movb %al, -0x12(%rbp)
cmpb $0x0, -0x12(%rbp)
jne 0x14062
movb $0x0, -0x1(%rbp)
jmp 0x140d6
testb $0x1, -0x11(%rbp)
jne 0x140a3
movl 0x7a71(%rip), %eax      # 0x1badf
movl %eax, -0x17(%rbp)
movb 0x7a6c(%rip), %al       # 0x1bae3
movb %al, -0x13(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x14(%rbp)
leaq -0x17(%rbp), %rsi
movq -0x10(%rbp), %rcx
leaq 0x883b(%rip), %rdi      # 0x1c8ca
leaq 0x81a8(%rip), %rdx      # 0x1c23e
movl $0x28, %r8d
callq 0xde30
jmp 0x140c0
movq 0xdbb6(%rip), %rdi      # 0x21c60
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movl $0x9, %r8d
movq %rcx, %rdx
callq 0xde30
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x4720
cmpl $-0x1, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: xrmfromsel
static void xrmfromsel(char *path, char *fpath)
{
#ifndef NOX11
	bool selected = TRUE;
#endif

	if ((pdents[cur].flags & DIR_OR_DIRLNK) && scanselforpath(fpath, FALSE))
		clearselection();
	else if (pdents[cur].flags & FILE_SELECTED) {
		--nselected;
		rmfromselbuf(mkpath(path, pdents[cur].name, g_sel));
	}
#ifndef NOX11
	else
		selected = FALSE;

	if (selected && cfg.x11)
		plugscript(utils[UTIL_CBCP], F_NOWAIT | F_NOTRACE);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq 0x16265(%rip), %rax     # 0x2a370
movslq 0x16266(%rip), %rcx     # 0x2a378
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
shrq $0x38, %rax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x14140
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x132f0
cmpl $0x0, %eax
je 0x14140
callq 0x12c80
jmp 0x141ac
movq 0x16229(%rip), %rax     # 0x2a370
movslq 0x1622a(%rip), %rcx     # 0x2a378
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
shrq $0x38, %rax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x141a6
movl 0x16441(%rip), %eax     # 0x2a5ac
addl $-0x1, %eax
movl %eax, 0x16438(%rip)     # 0x2a5ac
movq -0x8(%rbp), %rdi
movq 0x161f1(%rip), %rax     # 0x2a370
movslq 0x161f2(%rip), %rcx     # 0x2a378
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0x16429(%rip), %rdx     # 0x2a5c0
callq 0x74c0
movq %rax, %rdi
callq 0x131c0
jmp 0x141aa
movb $0x0, -0x11(%rbp)
jmp 0x141ac
testb $0x1, -0x11(%rbp)
je 0x141d4
movl 0xc318(%rip), %eax      # 0x204d0
shrl $0x1a, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x141d4
movq 0xb866(%rip), %rdi      # 0x1fa30
movl $0x6, %esi
callq 0x12970
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: copynextname
static void copynextname(char *lastname)
{
	if (cur) {
		cur += (cur != (ndents - 1)) ? 1 : -1;
		copycurname();
	} else
		lastname[0] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x16185(%rip)     # 0x2a378
je 0x1426f
movl 0x1617d(%rip), %edx     # 0x2a378
movl 0xdc8b(%rip), %esi      # 0x21e8c
subl $0x1, %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl %esi, %edx
cmovnel %ecx, %eax
addl 0x1615f(%rip), %eax     # 0x2a378
movl %eax, 0x16159(%rip)     # 0x2a378
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0xdc5e(%rip)      # 0x21e8c
je 0x1424e
movq 0x16139(%rip), %rax     # 0x2a370
movslq 0x1613a(%rip), %rcx     # 0x2a378
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1425b
leaq 0x7223(%rip), %rax      # 0x1b478
movq %rax, -0x18(%rbp)
jmp 0x1425b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x6250
jmp 0x14276
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: cpmvrm_selection
static bool cpmvrm_selection(enum action sel, char *path)
{
	int r;

	if (isselfileempty()) {
		if (nselected)
			clearselection();
		printmsg(messages[MSG_0_SELECTED]);
		return FALSE;
	}

	if (!selsafe())
		return FALSE;

	switch (sel) {
	case SEL_CP:
		opstr(g_buf, cp);
		break;
	case SEL_MV:
		opstr(g_buf, mv);
		break;
	case SEL_CPMVAS:
		r = get_input(messages[MSG_CP_MV_AS]);
		if (r != 'c' && r != 'm') {
			printmsg(messages[MSG_INVALID_KEY]);
			return FALSE;
		}

		if (!cpmv_rename(r, path)) {
			printmsg(messages[MSG_FAILED]);
			return FALSE;
		}
		break;
	default: /* SEL_TRASH, SEL_RM_RF */
		if (!rmmulstr(g_buf, trashcmd && (sel == SEL_TRASH))) {
			printmsg(messages[MSG_CANCEL]);
			return FALSE;
		}
	}

	if (sel != SEL_CPMVAS && spawn(utils[UTIL_SH_EXEC], g_buf, NULL, NULL, F_CLI | F_CHKRTN)) {
		printmsg(messages[MSG_FAILED]);
		return FALSE;
	}

	/* Clear selection */
	clearselection();

	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x18af0
testb $0x1, %al
jne 0x1429a
jmp 0x142bd
cmpl $0x0, 0x1630b(%rip)     # 0x2a5ac
je 0x142a8
callq 0x12c80
movq 0xb7c9(%rip), %rdi      # 0x1fa78
callq 0xd020
movb $0x0, -0x1(%rbp)
jmp 0x14406
callq 0x14420
testb $0x1, %al
jne 0x142cf
movb $0x0, -0x1(%rbp)
jmp 0x14406
movl -0x8(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x2b, %eax
je 0x142f3
jmp 0x142dc
movl -0x18(%rbp), %eax
subl $0x2c, %eax
je 0x1430b
jmp 0x142e6
movl -0x18(%rbp), %eax
subl $0x2d, %eax
je 0x14323
jmp 0x1437a
leaq 0xc756(%rip), %rdi      # 0x20a50
leaq 0xc1ab(%rip), %rsi      # 0x204ac
callq 0x19c20
jmp 0x143c0
leaq 0xc73e(%rip), %rdi      # 0x20a50
leaq 0xc1a0(%rip), %rsi      # 0x204b9
callq 0x19c20
jmp 0x143c0
movq 0xb76e(%rip), %rdi      # 0x1fa98
callq 0x10dc0
movl %eax, -0x14(%rbp)
cmpl $0x63, -0x14(%rbp)
je 0x14353
cmpl $0x6d, -0x14(%rbp)
je 0x14353
movq 0xb85b(%rip), %rdi      # 0x1fba0
callq 0xd020
movb $0x0, -0x1(%rbp)
jmp 0x14406
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x19c60
testb $0x1, %al
jne 0x14378
movq 0xb71e(%rip), %rdi      # 0x1fa88
callq 0xd020
movb $0x0, -0x1(%rbp)
jmp 0x14406
jmp 0x143c0
xorl %eax, %eax
cmpq $0x0, 0xd8dc(%rip)      # 0x21c60
movb %al, -0x19(%rbp)
je 0x14393
cmpl $0x2e, -0x8(%rbp)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
leaq 0xc6ad(%rip), %rdi      # 0x20a50
callq 0x19eb0
testb $0x1, %al
jne 0x143be
movq 0xb6cd(%rip), %rdi      # 0x1fa80
callq 0xd020
movb $0x0, -0x1(%rbp)
jmp 0x14406
jmp 0x143c0
cmpl $0x2d, -0x8(%rbp)
je 0x143fd
movq 0xb61b(%rip), %rdi      # 0x1f9e8
leaq 0xc67c(%rip), %rsi      # 0x20a50
xorl %eax, %eax
movl %eax, %ecx
movl $0x29, %r8d
movq %rcx, %rdx
callq 0xde30
cmpl $0x0, %eax
je 0x143fd
movq 0xb696(%rip), %rdi      # 0x1fa88
callq 0xd020
movb $0x0, -0x1(%rbp)
jmp 0x14406
callq 0x12c80
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: selsafe
static bool selsafe(void)
{
	/* Fail if selection file path not generated */
	if (!selpath) {
		printmsg(messages[MSG_SEL_MISSING]);
		return FALSE;
	}

	/* Fail if selection file path isn't accessible */
	if (access(selpath, R_OK | W_OK) == -1) {
		errno == ENOENT ? printmsg(messages[MSG_0_SELECTED]) : printwarn(NULL);
		return FALSE;
	}

	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0xc3f8(%rip)      # 0x20828
jne 0x14444
movq 0xb6df(%rip), %rdi      # 0x1fb18
callq 0xd020
movb $0x0, -0x1(%rbp)
jmp 0x14494
movq 0xc3dd(%rip), %rdi      # 0x20828
movl $0x6, %esi
callq 0x4720
cmpl $-0x1, %eax
jne 0x14490
callq 0x40c0
cmpl $0x2, (%rax)
jne 0x14472
movq 0xb60d(%rip), %rdi      # 0x1fa78
callq 0xd020
jmp 0x1448a
callq 0x40c0
movl (%rax), %edi
callq 0x4870
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd210
movb $0x0, -0x1(%rbp)
jmp 0x14494
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: getreadline
static char *getreadline(const char *prompt)
{
	exitcurses();

	char *input = readline(prompt);

	refresh();

	if (input && input[0]) {
		add_history(input);
		xstrsncpy(g_buf, input, CMD_LEN_MAX);
		free(input);
		return g_buf;
	}

	free(input);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x4890
movq -0x10(%rbp), %rdi
callq 0x43b0
movq %rax, -0x18(%rbp)
movq 0xac7b(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
callq 0x4440
cmpq $0x0, -0x18(%rbp)
je 0x15364
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x15364
movq -0x18(%rbp), %rdi
callq 0x41b0
movq -0x18(%rbp), %rsi
leaq 0xb70c(%rip), %rdi      # 0x20a50
movl $0x1200, %edx           # imm = 0x1200
callq 0x6250
movq -0x18(%rbp), %rdi
callq 0x4090
leaq 0xb6f2(%rip), %rax      # 0x20a50
movq %rax, -0x8(%rbp)
jmp 0x15375
movq -0x18(%rbp), %rdi
callq 0x4090
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: archive_selection
static void archive_selection(const char *cmd, const char *archive)
{
	size_t len = xstrlen(patterns[P_ARCHIVE_CMD]) + xstrlen(cmd) + xstrlen(archive)
	            + xstrlen(selpath) + 1;
	char *buf = malloc(len);
	if (!buf) {
		DPRINTF_S(strerror(errno));
		printwarn(NULL);
		return;
	}

	snprintf(buf, len, patterns[P_ARCHIVE_CMD], cmd, archive, selpath);
	spawn(utils[UTIL_SH_EXEC], buf, NULL, NULL, F_CLI | F_CONFIRM);
	free(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xa7c9(%rip), %rdi      # 0x1fbe0
callq 0x5cc0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5cc0
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5cc0
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq 0xb3d3(%rip), %rdi      # 0x20828
callq 0x5cc0
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x45e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1549a
callq 0x40c0
movl (%rax), %edi
callq 0x4870
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd210
jmp 0x154e5
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0xa737(%rip), %rdx      # 0x1fbe0
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
movq 0xb370(%rip), %r9       # 0x20828
movb $0x0, %al
callq 0x4350
movq 0xa522(%rip), %rdi      # 0x1f9e8
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movl $0x19, %r8d
movq %rcx, %rdx
callq 0xde30
movq -0x20(%rbp), %rdi
callq 0x4090
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: get_archive_cmd
static char *get_archive_cmd(const char *archive)
{
	uchar_t i = 3;

	if (!g_state.usebsdtar && getutil(utils[UTIL_ATOOL]))
		i = 0;
	else if (getutil(utils[UTIL_BSDTAR]))
		i = 1;
	else if (is_suffix(archive, ".zip"))
		i = 2;
	// else tar

	return archive_cmd[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x3, -0x9(%rbp)
movl 0xb31e(%rip), %eax      # 0x20824
shrl $0x18, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x15529
movq 0xa4a0(%rip), %rdi      # 0x1f9b8
callq 0x12930
testb $0x1, %al
jne 0x15523
jmp 0x15529
movb $0x0, -0x9(%rbp)
jmp 0x1555f
movq 0xa490(%rip), %rdi      # 0x1f9c0
callq 0x12930
testb $0x1, %al
jne 0x1553b
jmp 0x15541
movb $0x1, -0x9(%rbp)
jmp 0x1555d
movq -0x8(%rbp), %rdi
leaq 0x7226(%rip), %rsi      # 0x1c772
callq 0x192d0
testb $0x1, %al
jne 0x15557
jmp 0x1555b
movb $0x2, -0x9(%rbp)
jmp 0x1555d
jmp 0x1555f
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0xa7c4(%rip), %rax      # 0x1fd30
movq (%rax,%rcx,8), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: get_cwd_entry
static char *get_cwd_entry(const char *restrict cwdpath, char *entrypath, size_t *tokenlen)
{
	size_t len = xstrlen(cwdpath);
	char *end;

	if (!is_prefix(entrypath, cwdpath, len))
		return NULL;

	entrypath += len + 1; /* Add 1 for trailing / */
	end = strchr(entrypath, '/');
	if (end)
		*tokenlen = end - entrypath;
	else
		*tokenlen = xstrlen(entrypath);
	DPRINTF_U(*tokenlen);

	return entrypath;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5cc0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x7200
testb $0x1, %al
jne 0x155c0
movq $0x0, -0x8(%rbp)
jmp 0x15618
movq -0x28(%rbp), %rax
addq $0x1, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2f, %esi
callq 0x4310
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x155fd
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x15610
movq -0x18(%rbp), %rdi
callq 0x5cc0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: handle_openwith
static void handle_openwith(const char *path, const char *name, char *newpath, char *tmp)
{
	/* Confirm if app is CLI or GUI */
	int r = get_input(messages[MSG_CLI_MODE]);

	r = (r == 'c' ? F_CLI :
	     ((r == 'g' || r == '\r') ? (F_NOWAIT | F_NOTRACE | F_MULTI) : 0));
	if (r) {
		mkpath(path, name, newpath);
		spawn(tmp, newpath, NULL, NULL, r);
	}
}

// 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 0xa471(%rip), %rdi      # 0x1fac0
callq 0x10dc0
movl %eax, -0x24(%rbp)
cmpl $0x63, -0x24(%rbp)
jne 0x15667
movl $0x9, %eax
movl %eax, -0x28(%rbp)
jmp 0x1568f
movb $0x1, %al
cmpl $0x67, -0x24(%rbp)
movb %al, -0x29(%rbp)
je 0x1567c
cmpl $0xd, -0x24(%rbp)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %dl
xorl %eax, %eax
movl $0x7, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x156c5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x74c0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %eax
xorl %ecx, %ecx
movq %rcx, %rdx
movzwl %ax, %r8d
callq 0xde30
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: printkeys
static void printkeys(kv *kvarr, char *buf, uchar_t max)
{
	uchar_t i = 0;

	for (; i < max && kvarr[i].key; ++i) {
		buf[i << 1] = ' ';
		buf[(i << 1) + 1] = kvarr[i].key;
	}

	buf[i << 1] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
movzbl -0x12(%rbp), %ecx
movzbl -0x11(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x13(%rbp)
jge 0x15928
movq -0x8(%rbp), %rax
movzbl -0x12(%rbp), %ecx
cmpl $0x0, (%rax,%rcx,8)
setne %al
movb %al, -0x13(%rbp)
movb -0x13(%rbp), %al
testb $0x1, %al
jne 0x15931
jmp 0x1596c
movq -0x10(%rbp), %rax
movzbl -0x12(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
movb $0x20, (%rax,%rcx)
movq -0x8(%rbp), %rax
movzbl -0x12(%rbp), %ecx
movl (%rax,%rcx,8), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movzbl -0x12(%rbp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x12(%rbp), %al
addb $0x1, %al
movb %al, -0x12(%rbp)
jmp 0x15905
movq -0x10(%rbp), %rax
movzbl -0x12(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: showselsize
static void showselsize(const char *path)
{
	off_t sz = 0;
	int len = scanselforpath(path, FALSE);

	for (int r = 0, selcount = nselected; (r < ndents) && selcount; ++r)
		if (findinsel(findselpos, len + xstrsncpy(g_sel + len, pdents[r].name, pdents[r].nlen))) {
			sz += cfg.blkorder ? pdents[r].blocks : pdents[r].size;
			--selcount;
		}

	printmsg(coolsize(cfg.blkorder ? sz << blk_shift : sz));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x132f0
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl 0x14bfd(%rip), %eax     # 0x2a5ac
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl 0xc4cf(%rip), %ecx      # 0x21e8c
movb %al, -0x1d(%rbp)
jge 0x159cc
cmpl $0x0, -0x1c(%rbp)
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x159d8
jmp 0x15ac5
movq 0x15be1(%rip), %rax     # 0x2b5c0
movq %rax, -0x30(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0x14(%rbp), %rax
leaq 0x14bca(%rip), %rdi     # 0x2a5c0
addq %rax, %rdi
movq 0x14970(%rip), %rax     # 0x2a370
movslq -0x18(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq 0x1495b(%rip), %rax     # 0x2a370
movslq -0x18(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdx
shrq $0x28, %rdx
andq $0xffff, %rdx           # imm = 0xFFFF
callq 0x6250
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movl %eax, %esi
callq 0x17c90
cmpq $0x0, %rax
je 0x15ab5
movl 0xaa7b(%rip), %eax      # 0x204d0
shrl $0x4, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x15a86
movq 0x14909(%rip), %rcx     # 0x2a370
movslq -0x18(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rcx
movabsq $0xffffffffff, %rax     # imm = 0xFFFFFFFFFF
andq 0x20(%rcx), %rax
movq %rax, -0x38(%rbp)
jmp 0x15aa0
movq 0x148e3(%rip), %rax     # 0x2a370
movslq -0x18(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15ab7
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x159b2
movl 0xaa05(%rip), %eax      # 0x204d0
shrl $0x4, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x15aec
movq -0x10(%rbp), %rax
movzbl 0xacff(%rip), %ecx      # 0x207e0
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x40(%rbp)
jmp 0x15af4
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x17ea0
movq %rax, %rdi
callq 0xd020
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: handle_cmd
static bool handle_cmd(enum action sel, char *path, char *newpath)
{
	endselection(FALSE);

	if (sel == SEL_LAUNCH)
		return launch_app(newpath);

	setexports(path);

	if (sel == SEL_PROMPT)
		return prompt_run();

	/* Set nnn nesting level */
	char *tmp = getenv(env_cfg[NNNLVL]);
	int r = tmp ? atoi(tmp) : 0;

	setenv(env_cfg[NNNLVL], xitoa(r + 1), 1);
	spawn(shell, NULL, NULL, NULL, F_CLI);
	setenv(env_cfg[NNNLVL], xitoa(r), 1);
	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %edi, %edi
callq 0xdb10
cmpl $0x3b, -0x8(%rbp)
jne 0x15b43
movq -0x18(%rbp), %rdi
callq 0x1a030
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x15bfe
movq -0x10(%rbp), %rdi
callq 0x18c10
cmpl $0x3c, -0x8(%rbp)
jne 0x15b61
callq 0x1a0f0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x15bfe
movq 0x9e08(%rip), %rdi      # 0x1f970
callq 0x4050
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x15b86
movq -0x20(%rbp), %rdi
callq 0x47c0
movl %eax, -0x28(%rbp)
jmp 0x15b8d
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0x15b8d
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movq 0x9dd6(%rip), %rax      # 0x1f970
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %edi
addl $0x1, %edi
callq 0x5df0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x4200
movq 0xae37(%rip), %rdi      # 0x209f8
xorl %eax, %eax
movl %eax, %ecx
movl $0x9, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0xde30
movq 0x9d93(%rip), %rax      # 0x1f970
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %edi
callq 0x5df0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x4200
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: export_file_list
static void export_file_list(void)
{
	if (!ndents)
		return;

	struct entry *pdent = pdents;
	int fd = create_tmp_file();

	if (fd == -1) {
		DPRINTF_S(strerror(errno));
		return;
	}

	for (int r = 0; r < ndents; ++pdent, ++r) {
		if (write(fd, pdent->name, pdent->nlen - 1) != (pdent->nlen - 1))
			break;

		if ((r != ndents - 1) && (write(fd, "\n", 1) != 1))
			break;
	}

	if (close(fd)) {
		DPRINTF_S(strerror(errno));
	}

	spawn(editor, g_tmpfpath, NULL, NULL, F_CLI);

	if (xconfirm(get_input(messages[MSG_RM_TMP])))
		unlink(g_tmpfpath);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0xbfad(%rip)      # 0x21e8c
jne 0x15ee6
jmp 0x15ffd
movq 0x14483(%rip), %rax     # 0x2a370
movq %rax, -0x8(%rbp)
callq 0xddd0
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x15f04
jmp 0x15ffd
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0xbf78(%rip), %eax      # 0x21e8c
jge 0x15fa9
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
shrq $0x28, %rax
andq $0xffff, %rax           # imm = 0xFFFF
subl $0x1, %eax
movslq %eax, %rdx
callq 0x4210
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
shrq $0x28, %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
je 0x15f61
jmp 0x15fa9
movl -0x10(%rbp), %eax
movl 0xbf22(%rip), %ecx      # 0x21e8c
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x15f8d
movl -0xc(%rbp), %edi
leaq 0x68f3(%rip), %rsi      # 0x1c86e
movl $0x1, %edx
callq 0x4210
cmpq $0x1, %rax
je 0x15f8d
jmp 0x15fa9
jmp 0x15f8f
movq -0x8(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x15f0b
movl -0xc(%rbp), %edi
callq 0x43c0
cmpl $0x0, %eax
je 0x15fb8
jmp 0x15fb8
movq 0xaa29(%rip), %rdi      # 0x209e8
leaq 0xaa3a(%rip), %rsi      # 0x20a00
xorl %eax, %eax
movl %eax, %ecx
movl $0x9, %r8d
movq %rcx, %rdx
callq 0xde30
movq 0x9bb9(%rip), %rdi      # 0x1fb98
callq 0x10dc0
movl %eax, %edi
callq 0x153d0
testb $0x1, %al
jne 0x15ff1
jmp 0x15ffd
leaq 0xaa08(%rip), %rdi      # 0x20a00
callq 0x40d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)