LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: xitoa
static char *xitoa(uint_t val)
{
	static char dst[32] = {'\0'};
	static const char digits[201] =
		"0001020304050607080910111213141516171819"
		"2021222324252627282930313233343536373839"
		"4041424344454647484950515253545556575859"
		"6061626364656667686970717273747576777879"
		"8081828384858687888990919293949596979899";
	uint_t next = 30, quo, i;

	while (val >= 100) {
		quo = val / 100;
		i = (val - (quo * 100)) * 2;
		val = quo;
		dst[next] = digits[i + 1];
		dst[--next] = digits[i];
		--next;
	}

	/* Handle last 1-2 digits */
	if (val < 10)
		dst[next] = '0' + val;
	else {
		i = val * 2;
		dst[next] = digits[i + 1];
		dst[--next] = digits[i];
	}

	return &dst[next];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x1e, -0x8(%rbp)
cmpl $0x64, -0x4(%rbp)
jb 0x5e7b
movl -0x4(%rbp), %eax
movl $0x64, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
imull $0x64, -0xc(%rbp), %ecx
subl %ecx, %eax
shll %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x15648(%rip), %rax     # 0x1b480
movb (%rax,%rcx), %dl
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x1bf39(%rip), %rax     # 0x21d80
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x1562a(%rip), %rax     # 0x1b480
movb (%rax,%rcx), %dl
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
movl %eax, %eax
movl %eax, %ecx
leaq 0x1bf13(%rip), %rax     # 0x21d80
movb %dl, (%rax,%rcx)
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x5dfe
cmpl $0xa, -0x4(%rbp)
jae 0x5e9a
movl -0x4(%rbp), %eax
addl $0x30, %eax
movb %al, %dl
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x1beeb(%rip), %rax     # 0x21d80
movb %dl, (%rax,%rcx)
jmp 0x5eeb
movl -0x4(%rbp), %eax
shll %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x155cd(%rip), %rax     # 0x1b480
movb (%rax,%rcx), %dl
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x1bebe(%rip), %rax     # 0x21d80
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x155af(%rip), %rax     # 0x1b480
movb (%rax,%rcx), %dl
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
movl %eax, %eax
movl %eax, %ecx
leaq 0x1be98(%rip), %rax     # 0x21d80
movb %dl, (%rax,%rcx)
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x1be89(%rip), %rax     # 0x21d80
addq %rcx, %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: xstrsncpy
static size_t xstrsncpy(char *restrict dst, const char *restrict src, size_t n)
{
	char *end = memccpy(dst, src, '\0', n);

	if (!end) {
		if (n)
			dst[n - 1] = '\0';
		end = dst + n; /* If we return n here, binary size increases due to auto-inlining */
	}

	return end - dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
xorl %edx, %edx
callq 0x4860
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x62a5
cmpq $0x0, -0x18(%rbp)
je 0x6299
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: set_tmp_path
static bool set_tmp_path(void)
{
	char *tmp = "/tmp";
	char *path = xdiraccess(tmp) ? tmp : getenv("TMPDIR");

	if (!path) {
		msg("set TMPDIR");
		return FALSE;
	}

	tmpfplen = (uchar_t)xstrsncpy(g_tmpfpath, path, TMP_LEN_MAX);
	DPRINTF_S(g_tmpfpath);
	DPRINTF_U(tmpfplen);

	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x15e46(%rip), %rax     # 0x1c155
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7300
testb $0x1, %al
jne 0x6322
jmp 0x632c
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x633c
leaq 0x15e2b(%rip), %rdi     # 0x1c15e
callq 0x4050
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x635d
leaq 0x15e08(%rip), %rdi     # 0x1c15a
callq 0x6ab0
movb $0x0, -0x1(%rbp)
jmp 0x637c
movq -0x18(%rbp), %rsi
leaq 0x1a698(%rip), %rdi     # 0x20a00
movl $0x40, %edx
callq 0x6250
movb %al, 0x1a6c8(%rip)      # 0x20a40
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: cleanup
static void cleanup(void)
{
#ifndef NOX11
	if (cfg.x11 && !g_state.picker) {
		printf("\033[23;0t"); /* reset terminal window title */
		fflush(stdout);
	}
#endif
	free(selpath);
	free(plgpath);
	free(cfgpath);
	free(initpath);
	free(bmstr);
	free(pluginstr);
	free(listroot);
	free(ihashbmp);
	free(bookmark);
	free(plug);
	if (lastcmdpos != INVALID_POS)
		for (uchar_t pos = 0; pos <= lastcmdpos; ++pos)
			free(cmd_hist[pos]);
#ifndef NOFIFO
	if (g_state.autofifo)
		unlink(fifopath);
#endif
	if (g_state.pluginit)
		unlink(g_pipepath);
#ifdef DEBUG
	disabledbg();
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x1a132(%rip), %eax     # 0x204d0
shrl $0x1a, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x63d7
movl 0x1a475(%rip), %eax     # 0x20824
shrl $0xc, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x63d7
leaq 0x15da4(%rip), %rdi     # 0x1c165
movb $0x0, %al
callq 0x4320
movq 0x19ba1(%rip), %rax     # 0x1ff70
movq (%rax), %rdi
callq 0x45f0
movq 0x1a44a(%rip), %rdi     # 0x20828
callq 0x4090
movq 0x1b9b6(%rip), %rdi     # 0x21da0
callq 0x4090
movq 0x1b872(%rip), %rdi     # 0x21c68
callq 0x4090
movq 0x1a536(%rip), %rdi     # 0x20938
callq 0x4090
movq 0x1a552(%rip), %rdi     # 0x20960
callq 0x4090
movq 0x1a55e(%rip), %rdi     # 0x20978
callq 0x4090
movq 0x1b982(%rip), %rdi     # 0x21da8
callq 0x4090
movq 0x1b97e(%rip), %rdi     # 0x21db0
callq 0x4090
movq 0x1a51a(%rip), %rdi     # 0x20958
callq 0x4090
movq 0x1a526(%rip), %rdi     # 0x20970
callq 0x4090
movzbl 0x1a34a(%rip), %eax     # 0x207a0
cmpl $0xff, %eax
je 0x6492
movb $0x0, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
movzbl 0x1a334(%rip), %ecx     # 0x207a0
cmpl %ecx, %eax
jg 0x6490
movzbl -0x1(%rbp), %eax
movl %eax, %ecx
leaq 0x1b943(%rip), %rax     # 0x21dc0
movq (%rax,%rcx,8), %rdi
callq 0x4090
movb -0x1(%rbp), %al
addb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6461
jmp 0x6492
movl 0x1a38c(%rip), %eax     # 0x20824
andl $0x1, %eax
cmpl $0x0, %eax
je 0x64ac
movq 0x1b7a9(%rip), %rdi     # 0x21c50
callq 0x40d0
movl 0x1a372(%rip), %eax     # 0x20824
shrl $0xd, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x64c9
leaq 0x1b97c(%rip), %rdi     # 0x21e40
callq 0x40d0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: get_kv_val
static char *get_kv_val(kv *kvarr, char *buf, int key, uchar_t max, uchar_t id)
{
	char *val;

	if (!kvarr)
		return NULL;

	for (int r = 0; r < max && kvarr[r].key; ++r) {
		if (kvarr[r].key == key) {
			/* Do not allocate new memory for plugin */
			if (id == NNN_PLUG)
				return pluginstr + kvarr[r].off;

			val = bmstr + kvarr[r].off;
			bool tilde = convert_tilde(val, g_buf);
			return abspath((tilde ? g_buf : val), NULL, buf);
		}
	}

	DPRINTF_S("Invalid key");
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movb %cl, -0x1d(%rbp)
movb %al, -0x1e(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7090
movq $0x0, -0x8(%rbp)
jmp 0x7179
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movzbl -0x1d(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x2e(%rbp)
jge 0x70b9
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,8)
setne %al
movb %al, -0x2e(%rbp)
movb -0x2e(%rbp), %al
testb $0x1, %al
jne 0x70c5
jmp 0x7171
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,8), %eax
cmpl -0x1c(%rbp), %eax
jne 0x7161
movzbl -0x1e(%rbp), %eax
cmpl $0x2, %eax
jne 0x70ff
movq 0x1988f(%rip), %rax     # 0x20978
movq -0x10(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movslq 0x4(%rcx,%rdx,8), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x7179
movq 0x1985a(%rip), %rax     # 0x20960
movq -0x10(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movslq 0x4(%rcx,%rdx,8), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x1992b(%rip), %rsi     # 0x20a50
callq 0xd180
andb $0x1, %al
movb %al, -0x2d(%rbp)
testb $0x1, -0x2d(%rbp)
je 0x7142
leaq 0x19914(%rip), %rax     # 0x20a50
movq %rax, -0x38(%rbp)
jmp 0x714a
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x5f00
movq %rax, -0x8(%rbp)
jmp 0x7179
jmp 0x7163
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7097
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: xdirname
static char *xdirname(char *path)
{
	char *base = xmemrchr((uchar_t *)path, '/', xstrlen(path));

	if (base == path)
		path[1] = '\0';
	else
		*base = '\0';

	return path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5cc0
movq -0x18(%rbp), %rdi
movq %rax, %rdx
movl $0x2f, %esi
callq 0xcad0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x72e6
movq -0x8(%rbp), %rax
movb $0x0, 0x1(%rax)
jmp 0x72ed
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: xdiraccess
static bool xdiraccess(const char *path)
{
	DIR *dirp = opendir(path);

	if (!dirp) {
		printwarn(NULL);
		return FALSE;
	}

	closedir(dirp);
	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4270
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x733e
callq 0x40c0
movl (%rax), %edi
callq 0x4870
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd210
movb $0x0, -0x1(%rbp)
jmp 0x734b
movq -0x18(%rbp), %rdi
callq 0x4400
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: xmktree
static bool xmktree(char *path, bool dir)
{
	char *p = path;
	char *slash = path;

	if (!p || !*p)
		return FALSE;

	/* Skip the first '/' */
	++p;

	while (*p != '\0') {
		if (*p == '/') {
			slash = p;
			*p = '\0';
		} else {
			++p;
			continue;
		}

		/* Create folder from path to '\0' inserted at p */
		if (mkdir(path, 0777) == -1 && errno != EEXIST) {
#ifdef __HAIKU__
			// XDG_CONFIG_HOME contains a directory
			// that is read-only, but the full path
			// is writeable.
			// Try to continue and see what happens.
			// TODO: Find a more robust solution.
			if (errno == B_READ_ONLY_DEVICE)
				goto next;
#endif
			DPRINTF_S("mkdir1!");
			DPRINTF_S(strerror(errno));
			*slash = '/';
			return FALSE;
		}

#ifdef __HAIKU__
next:
#endif
		/* Restore path */
		*slash = '/';
		++p;
	}

	if (dir) {
		if (mkdir(path, 0777) == -1 && errno != EEXIST) {
			DPRINTF_S("mkdir2!");
			DPRINTF_S(strerror(errno));
			return FALSE;
		}
	} else {
		int fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IWUSR | S_IRUSR); /* Forced create mode for files */

		if (fd == -1 && errno != EEXIST) {
			DPRINTF_S("open!");
			DPRINTF_S(strerror(errno));
			return FALSE;
		}

		close(fd);
	}

	return TRUE;
}

// 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
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7394
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x739d
movb $0x0, -0x1(%rbp)
jmp 0x7484
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x741f
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x73d2
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
jmp 0x73e0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x73a9
movq -0x10(%rbp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x4130
cmpl $-0x1, %eax
jne 0x740a
callq 0x40c0
cmpl $0x11, (%rax)
je 0x740a
movq -0x28(%rbp), %rax
movb $0x2f, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x7484
movq -0x28(%rbp), %rax
movb $0x2f, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x73a9
testb $0x1, -0x11(%rbp)
je 0x744a
movq -0x10(%rbp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x4130
cmpl $-0x1, %eax
jne 0x7448
callq 0x40c0
cmpl $0x11, (%rax)
je 0x7448
movb $0x0, -0x1(%rbp)
jmp 0x7484
jmp 0x7480
movq -0x10(%rbp), %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x46c0
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x7478
callq 0x40c0
cmpl $0x11, (%rax)
je 0x7478
movb $0x0, -0x1(%rbp)
jmp 0x7484
movl -0x2c(%rbp), %edi
callq 0x43c0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: mkpath
static size_t mkpath(const char *dir, const char *name, char *out)
{
	size_t len = 0;

	/* same rational for being strict as abspath() */
	if (tilde_is_home_strict(name)) { //NOLINT
		len = xstrsncpy(out, home, PATH_MAX);
		--len;
		++name;
	} else if (name[0] != '/') { // NOLINT
		/* Handle root case */
		len = istopdir(dir) ? 1 : xstrsncpy(out, dir, PATH_MAX);
		out[len - 1] = '/'; // NOLINT
	}
	return (xstrsncpy(out + len, name, PATH_MAX - len) + len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xca90
testb $0x1, %al
jne 0x74eb
jmp 0x751e
movq -0x18(%rbp), %rdi
movq 0x1944a(%rip), %rsi     # 0x20940
movl $0x1000, %edx           # imm = 0x1000
callq 0x6250
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x757e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x757c
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x754e
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x754e
movl $0x1, %eax
movq %rax, -0x28(%rbp)
jmp 0x7564
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x6250
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movb $0x2f, (%rax,%rcx)
jmp 0x757e
movq -0x18(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
subq -0x20(%rbp), %rdx
callq 0x6250
addq -0x20(%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: rmlistpath
static void rmlistpath(void)
{
	if (listpath) {
		DPRINTF_S(__func__);
		DPRINTF_S(listpath);
		spawn(utils[UTIL_RM_RF], listpath, NULL, NULL, F_NOTRACE | F_MULTI);
		/* Do not free if program was started in list mode */
		if (listpath != initpath)
			free(listpath);
		listpath = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x15644(%rip)     # 0x21e80
je 0xc885
movq 0x1320b(%rip), %rdi     # 0x1fa50
movq 0x15634(%rip), %rsi     # 0x21e80
xorl %eax, %eax
movl %eax, %ecx
movl $0x5, %r8d
movq %rcx, %rdx
callq 0xde30
movq 0x1561b(%rip), %rax     # 0x21e80
cmpq 0x140cc(%rip), %rax     # 0x20938
je 0xc87a
movq 0x1560b(%rip), %rdi     # 0x21e80
callq 0x4090
movq $0x0, 0x155fb(%rip) # 0x21e80
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: notify_fifo
static void notify_fifo(bool force)
{
	if (!fifopath)
		return;

	if (fifofd == -1) {
		fifofd = open(fifopath, O_WRONLY|O_NONBLOCK|O_CLOEXEC);
		if (fifofd == -1) {
			if (errno != ENXIO)
				/* Unexpected error, the FIFO file might have been removed */
				/* We give up FIFO notification */
				fifopath = NULL;
			return;
		}
	}

	static struct entry lastentry;

	if (!force && !memcmp(&lastentry, &pdents[cur], sizeof(struct entry))) // NOLINT
		return;

	lastentry = pdents[cur];

	char path[PATH_MAX];
	size_t len = mkpath(g_ctx[cfg.curctx].c_path, ndents ? pdents[cur].name : "", path);

	path[len - 1] = '\n';

	ssize_t ret = write(fifofd, path, len);

	if (ret != (ssize_t)len && !(ret == -1 && (errno == EAGAIN || errno == EPIPE))) {
		DPRINTF_S(strerror(errno));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
cmpq $0x0, 0x153a5(%rip)     # 0x21c50
jne 0xc8b2
jmp 0xca3b
cmpl $-0x1, 0x13c13(%rip)    # 0x204cc
jne 0xc8f9
movq 0x1538e(%rip), %rdi     # 0x21c50
movl $0x80801, %esi          # imm = 0x80801
movb $0x0, %al
callq 0x46c0
movl %eax, 0x13bf8(%rip)     # 0x204cc
cmpl $-0x1, 0x13bf1(%rip)    # 0x204cc
jne 0xc8f7
callq 0x40c0
cmpl $0x6, (%rax)
je 0xc8f2
movq $0x0, 0x1535e(%rip) # 0x21c50
jmp 0xca3b
jmp 0xc8f9
testb $0x1, -0x1(%rbp)
jne 0xc92f
movq 0x1da6a(%rip), %rsi     # 0x2a370
movslq 0x1da6b(%rip), %rax     # 0x2a378
imulq $0x30, %rax, %rax
addq %rax, %rsi
leaq 0x1ed7d(%rip), %rdi     # 0x2b698
movl $0x30, %edx
callq 0x4470
cmpl $0x0, %eax
jne 0xc92f
jmp 0xca3b
movq 0x1da3a(%rip), %rsi     # 0x2a370
movslq 0x1da3b(%rip), %rax     # 0x2a378
imulq $0x30, %rax, %rax
addq %rax, %rsi
leaq 0x1ed4d(%rip), %rdi     # 0x2b698
movl $0x30, %edx
callq 0x4560
movl 0x13b75(%rip), %eax     # 0x204d0
shrl $0xd, %eax
andl $0x7, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x15524(%rip), %rax     # 0x21e90
imulq $0x2138, %rcx, %rcx     # imm = 0x2138
addq %rcx, %rax
movq %rax, -0x1028(%rbp)
cmpl $0x0, 0x15508(%rip)     # 0x21e8c
je 0xc9a7
movq 0x1d9e3(%rip), %rax     # 0x2a370
movslq 0x1d9e4(%rip), %rcx     # 0x2a378
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x1030(%rbp)
jmp 0xc9b7
leaq 0xfd17(%rip), %rax      # 0x1c6c5
movq %rax, -0x1030(%rbp)
jmp 0xc9b7
movq -0x1028(%rbp), %rdi
movq -0x1030(%rbp), %rsi
leaq -0x1010(%rbp), %rdx
callq 0x74c0
movq %rax, -0x1018(%rbp)
movq -0x1018(%rbp), %rax
subq $0x1, %rax
movb $0xa, -0x1010(%rbp,%rax)
movl 0x13adb(%rip), %edi     # 0x204cc
leaq -0x1010(%rbp), %rsi
movq -0x1018(%rbp), %rdx
callq 0x4210
movq %rax, -0x1020(%rbp)
movq -0x1020(%rbp), %rax
cmpq -0x1018(%rbp), %rax
je 0xca3b
cmpq $-0x1, -0x1020(%rbp)
jne 0xca39
callq 0x40c0
cmpl $0xb, (%rax)
je 0xca3b
callq 0x40c0
cmpl $0x20, (%rax)
je 0xca3b
jmp 0xca3b
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: xrealloc
static void *xrealloc(void *pcur, size_t len)
{
	void *pmem = realloc(pcur, len);

	if (!pmem)
		free(pcur);

	return pmem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4650
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xcb31
movq -0x8(%rbp), %rdi
callq 0x4090
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: common_prefix
static char *common_prefix(const char *path, char *prefix)
{
	const char *x = path, *y = prefix;
	char *sep;

	if (!path || !*path || !prefix)
		return NULL;

	if (!*prefix) {
		xstrsncpy(prefix, path, PATH_MAX);
		return prefix;
	}

	while (*x && *y && (*x == *y))
		++x, ++y;

	/* Strings are same */
	if (!*x && !*y)
		return prefix;

	/* Path is shorter */
	if (!*x && *y == '/') {
		xstrsncpy(prefix, path, y - path);
		return prefix;
	}

	/* Prefix is shorter */
	if (!*y && *x == '/')
		return prefix;

	/* Shorten prefix */
	prefix[y - prefix] = '\0';

	sep = xmemrchr((uchar_t *)prefix, '/', y - prefix);
	if (sep != prefix)
		*sep = '\0';
	else /* Just '/' */
		prefix[1] = '\0';

	return prefix;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcbe7
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xcbe7
cmpq $0x0, -0x18(%rbp)
jne 0xcbf4
movq $0x0, -0x8(%rbp)
jmp 0xcd41
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xcc1c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x6250
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcd41
jmp 0xcc1e
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0xcc56
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0xcc56
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movq -0x28(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xcc5f
jmp 0xcc79
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xcc1e
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xcc98
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xcc98
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcd41
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xcccf
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xcccf
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
callq 0x6250
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcd41
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xccee
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xccee
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcd41
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq %rdx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
movl $0x2f, %esi
callq 0xcad0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xcd31
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
jmp 0xcd39
movq -0x18(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: convert_tilde
static bool convert_tilde(const char *path, char *buf)
{
	if (tilde_is_home(path)) {
		ssize_t len = xstrlen(home);
		ssize_t loclen = xstrlen(path);

		xstrsncpy(buf, home, len + 1);
		xstrsncpy(buf + len, path + 1, loclen);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd130
testb $0x1, %al
jne 0xd19f
jmp 0xd1f3
movq 0x1379a(%rip), %rdi     # 0x20940
callq 0x5cc0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5cc0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq 0x13779(%rip), %rsi     # 0x20940
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
callq 0x6250
movq -0x18(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movq -0x28(%rbp), %rdx
callq 0x6250
movb $0x1, -0x1(%rbp)
jmp 0xd1f7
movb $0x0, -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/jarun[P]nnn/src/nnn.c
// Function: printwait
static void printwait(const char *msg, int *presel)
{
	printmsg(msg);
	if (presel) {
		*presel = MSGWAIT;
		if (ndents)
			xstrsncpy(g_ctx[cfg.curctx].c_name, pdents[cur].name, NAME_MAX + 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd020
cmpq $0x0, -0x10(%rbp)
je 0xd28d
movq -0x10(%rbp), %rax
movl $0x24, (%rax)
cmpl $0x0, 0x14c4b(%rip)     # 0x21e8c
je 0xd28b
movl 0x13287(%rip), %eax     # 0x204d0
shrl $0xd, %eax
andl $0x7, %eax
movl %eax, %eax
leaq 0x14c38(%rip), %rdi     # 0x21e90
imulq $0x2138, %rax, %rax     # imm = 0x2138
addq %rax, %rdi
addq $0x2000, %rdi           # imm = 0x2000
movq 0x1d100(%rip), %rax     # 0x2a370
movslq 0x1d101(%rip), %rcx     # 0x2a378
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x6250
jmp 0xd28d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: init_fcolors
static bool init_fcolors(void)
{
	char *f_colors = getenv(env_cfg[NNN_FCOLORS]);

	if (!f_colors || !*f_colors)
		f_colors = gcolors;

	for (uchar_t id = C_BLK; *f_colors && id <= C_UND; ++id) {
		fcolors[id] = xchartohex(*f_colors) << 4;
		if (*++f_colors) {
			fcolors[id] += xchartohex(*f_colors);
			if (fcolors[id])
				init_pair(id, fcolors[id], -1);
		} else
			return FALSE;
		++f_colors;
	}

	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x126b9(%rip), %rdi     # 0x1f968
callq 0x4050
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd2c8
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xd2d3
leaq 0x134e1(%rip), %rax     # 0x207b0
movq %rax, -0x10(%rbp)
movb $0x5, -0x11(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x12(%rbp)
je 0xd2f5
movzbl -0x11(%rbp), %eax
cmpl $0x10, %eax
setle %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
testb $0x1, %al
jne 0xd301
jmp 0xd3bc
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0xd3d0
movzbl %al, %edx
shll $0x4, %edx
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x1d060(%rip), %rax     # 0x2a380
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpb $0x0, 0x1(%rax)
je 0xd39d
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0xd3d0
movzbl %al, %edx
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x1d02c(%rip), %rax     # 0x2a380
addl (%rax,%rcx,4), %edx
leaq 0x1d022(%rip), %rax     # 0x2a380
movl %edx, (%rax,%rcx,4)
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x1d012(%rip), %rax     # 0x2a380
cmpl $0x0, (%rax,%rcx,4)
je 0xd39b
movzbl -0x11(%rbp), %eax
movw %ax, %cx
movzbl -0x11(%rbp), %eax
movl %eax, %edx
leaq 0x1cff8(%rip), %rax     # 0x2a380
movl (%rax,%rdx,4), %eax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movswl %cx, %edi
movswl %ax, %esi
callq 0x4620
jmp 0xd3a3
movb $0x0, -0x1(%rbp)
jmp 0xd3c0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movb -0x11(%rbp), %al
addb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0xd2d7
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/jarun[P]nnn/src/nnn.c
// Function: xchartohex
static uchar_t xchartohex(uchar_t c)
{
	if (xisdigit(c))
		return c - '0';

	if (c >= 'a' && c <= 'f')
		return c - 'a' + 10;

	if (c >= 'A' && c <= 'F')
		return c - 'A' + 10;

	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
subl $0x30, %eax
cmpl $0x9, %eax
ja 0xd3f2
movzbl -0x2(%rbp), %eax
subl $0x30, %eax
movb %al, -0x1(%rbp)
jmp 0xd43a
movzbl -0x2(%rbp), %eax
cmpl $0x61, %eax
jl 0xd413
movzbl -0x2(%rbp), %eax
cmpl $0x66, %eax
jg 0xd413
movzbl -0x2(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movb %al, -0x1(%rbp)
jmp 0xd43a
movzbl -0x2(%rbp), %eax
cmpl $0x41, %eax
jl 0xd434
movzbl -0x2(%rbp), %eax
cmpl $0x46, %eax
jg 0xd434
movzbl -0x2(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movb %al, -0x1(%rbp)
jmp 0xd43a
movb -0x2(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: reventrycmp
static int reventrycmp(const void *va, const void *vb)
{
	if ((((pEntry)vb)->flags & DIR_OR_DIRLNK)
	    != (((pEntry)va)->flags & DIR_OR_DIRLNK)) {
		if (((pEntry)vb)->flags & DIR_OR_DIRLNK)
			return 1;
		return -1;
	}

	return -entrycmp(va, vb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
shrq $0x38, %rax
andl $0x1, %eax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
shrq $0x38, %rcx
andl $0x1, %ecx
cmpl %ecx, %eax
je 0xd498
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
shrq $0x38, %rax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xd48f
movl $0x1, -0x4(%rbp)
jmp 0xd4ae
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd4ae
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd4c0
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: xstricmp
static int xstricmp(const char * const s1, const char * const s2)
{
	char *p1, *p2;

	long long v1 = strtoll(s1, &p1, 10);
	long long v2 = strtoll(s2, &p2, 10);

	/* Check if at least 1 string is numeric */
	if (s1 != p1 || s2 != p2) {
		/* Handle both pure numeric */
		if (s1 != p1 && s2 != p2) {
			if (v2 > v1)
				return -1;

			if (v1 > v2)
				return 1;
		}

		/* Only first string non-numeric */
		if (s1 == p1)
			return 1;

		/* Only second string non-numeric */
		if (s2 == p2)
			return -1;
	}

	/* Handle 1. all non-numeric and 2. both same numeric value cases */
#ifndef NOLC
	return strcoll(s1, s2);
#else
	return strcasecmp(s1, s2);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0xa, %edx
callq 0x4500
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xa, %edx
callq 0x4500
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0xda90
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xdaf4
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0xdacc
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xdacc
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0xdab7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xdb04
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jle 0xdaca
movl $0x1, -0x4(%rbp)
jmp 0xdb04
jmp 0xdacc
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0xdadf
movl $0x1, -0x4(%rbp)
jmp 0xdb04
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0xdaf2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xdb04
jmp 0xdaf4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4640
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: create_tmp_file
static int create_tmp_file(void)
{
	xstrsncpy(g_tmpfpath + tmpfplen - 1, messages[STR_TMPFILE], TMP_LEN_MAX - tmpfplen);

	int fd = mkstemp(g_tmpfpath);

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

	return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movzbl 0x12c61(%rip), %eax     # 0x20a40
cltq
leaq 0x12c18(%rip), %rdi     # 0x20a00
addq %rax, %rdi
addq $-0x1, %rdi
movq 0x11c7a(%rip), %rsi     # 0x1fa70
movzbl 0x12c43(%rip), %ecx     # 0x20a40
movl $0x40, %eax
subl %ecx, %eax
movslq %eax, %rdx
callq 0x6250
leaq 0x12bed(%rip), %rdi     # 0x20a00
callq 0x4480
movl %eax, -0x4(%rbp)
cmpl $-0x1, -0x4(%rbp)
jne 0xde23
jmp 0xde23
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: writesel
static void writesel(const char *buf, const size_t buflen)
{
	if (!selpath)
		return;

	int fd = open(selpath, O_CREAT | O_WRONLY | O_TRUNC, S_IWUSR | S_IRUSR);

	if (fd != -1) {
		if (write(fd, buf, buflen) != (ssize_t)buflen)
			printwarn(NULL);
		close(fd);
	} else
		printwarn(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x126e0(%rip)     # 0x20828
jne 0xe14c
jmp 0xe1bd
movq 0x126d5(%rip), %rdi     # 0x20828
movl $0x241, %esi            # imm = 0x241
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x46c0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0xe1a5
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x4210
cmpq -0x10(%rbp), %rax
je 0xe19b
callq 0x40c0
movl (%rax), %edi
callq 0x4870
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd210
movl -0x14(%rbp), %edi
callq 0x43c0
jmp 0xe1bd
callq 0x40c0
movl (%rax), %edi
callq 0x4870
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd210
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: parseargs
static char *parseargs(char *cmd, char **argv, int *pindex)
{
	int count = 0;
	size_t len = xstrlen(cmd) + 1;
	char *line = malloc(len);

	if (!line) {
		DPRINTF_S("malloc()!");
		return NULL;
	}

	xstrsncpy(line, cmd, len);
	argv[count++] = line;
	cmd = line;

	while (*line) { // NOLINT
		if (ISBLANK(*line)) {
			*line++ = '\0';

			if (!*line) // NOLINT
				break;

			argv[count++] = line;
			if (count == EXEC_ARGS_MAX) {
				count = -1;
				break;
			}
		}

		++line;
	}

	if (count == -1 || count > (EXEC_ARGS_MAX - 4)) { /* 3 args and last NULL */
		free(cmd);
		cmd = NULL;
		DPRINTF_S("NULL or too many args");
	}

	*pindex = count;
	return cmd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5cc0
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x45e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xe21d
movq $0x0, -0x8(%rbp)
jmp 0xe2f5
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x6250
movq -0x38(%rbp), %rdx
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
cmpb $0x0, (%rax)
je 0xe2c7
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0xe271
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0xe2b9
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movb $0x0, (%rax)
movq -0x38(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xe28e
jmp 0xe2c7
movq -0x38(%rbp), %rdx
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
cmpl $0xa, -0x24(%rbp)
jne 0xe2b7
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
jmp 0xe2c7
jmp 0xe2b9
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xe250
cmpl $-0x1, -0x24(%rbp)
je 0xe2d3
cmpl $0x6, -0x24(%rbp)
jle 0xe2e4
movq -0x10(%rbp), %rdi
callq 0x4090
movq $0x0, -0x10(%rbp)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: xfork
static pid_t xfork(uchar_t flag)
{
	pid_t p = fork();

	if (p > 0) {
		/* the parent ignores the interrupt, quit and hangup signals */
		sigaction(SIGHUP, &(struct sigaction){.sa_handler = SIG_IGN}, &oldsighup);
		sigaction(SIGTSTP, &(struct sigaction){.sa_handler = SIG_DFL}, &oldsigtstp);
		sigaction(SIGWINCH, &(struct sigaction){.sa_handler = SIG_IGN}, &oldsigwinch);
	} else if (p == 0) {
		/* We create a grandchild to detach */
		if (flag & F_NOWAIT) {
			p = fork();

			if (p > 0)
				_exit(EXIT_SUCCESS);
			else if (p == 0) {
				enable_signals();
				setsid();
				return p;
			}

			perror("fork");
			_exit(EXIT_FAILURE);
		}

		/* So they can be used to stop the child */
		enable_signals();
	}

	/* This is the parent waiting for the child to create grandchild */
	if (flag & F_NOWAIT)
		waitpid(p, NULL, 0);

	if (p == -1)
		perror("fork");
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movb %dil, %al
movb %al, -0x5(%rbp)
callq 0x48c0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0xe3be
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x4380
movl $0x1, %eax
movq %rax, -0xa8(%rbp)
movl $0x1, %edi
leaq -0xa8(%rbp), %rsi
leaq 0x1c07b(%rip), %rdx     # 0x2a3d0
callq 0x4170
leaq -0x140(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x4380
movl $0x14, %edi
leaq -0x140(%rbp), %rsi
leaq 0x1c0e8(%rip), %rdx     # 0x2a468
callq 0x4170
leaq -0x1d8(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x4380
movl $0x1, %eax
movq %rax, -0x1d8(%rbp)
movl $0x1c, %edi
leaq -0x1d8(%rbp), %rsi
leaq 0x1c149(%rip), %rdx     # 0x2a500
callq 0x4170
jmp 0xe41c
cmpl $0x0, -0xc(%rbp)
jne 0xe41a
movzbl -0x5(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xe415
callq 0x48c0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0xe3e5
xorl %edi, %edi
callq 0x4110
cmpl $0x0, -0xc(%rbp)
jne 0xe3fd
callq 0xe500
callq 0x43f0
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe44e
jmp 0xe3ff
leaq 0xe23f(%rip), %rdi      # 0x1c645
callq 0x4750
movl $0x1, %edi
callq 0x4110
callq 0xe500
jmp 0xe41c
movzbl -0x5(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xe436
movl -0xc(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x4710
cmpl $-0x1, -0xc(%rbp)
jne 0xe448
leaq 0xe202(%rip), %rdi      # 0x1c645
callq 0x4750
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: join
static int join(pid_t p, uchar_t flag)
{
	int status = 0xFFFF;

	if (!(flag & F_NOWAIT)) {
		/* wait for the child to exit */
		do {
		} while (waitpid(p, &status, 0) == -1);

		if (WIFEXITED(status)) {
			status = WEXITSTATUS(status);
			DPRINTF_D(status);
		}
	}

	/* restore parent's signal handling */
	sigaction(SIGHUP, &oldsighup, NULL);
	sigaction(SIGTSTP, &oldsigtstp, NULL);
	sigaction(SIGWINCH, &oldsigwinch, NULL);

	return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
movb %al, -0x5(%rbp)
movl $0xffff, -0xc(%rbp)     # imm = 0xFFFF
movzbl -0x5(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0xe4b6
jmp 0xe486
jmp 0xe488
movl -0x4(%rbp), %edi
leaq -0xc(%rbp), %rsi
xorl %edx, %edx
callq 0x4710
cmpl $-0x1, %eax
je 0xe486
movl -0xc(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0xe4b4
movl -0xc(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0xc(%rbp)
jmp 0xe4b6
movl $0x1, %edi
leaq 0x1bf0e(%rip), %rsi     # 0x2a3d0
xorl %eax, %eax
movl %eax, %edx
callq 0x4170
movl $0x14, %edi
leaq 0x1bf91(%rip), %rsi     # 0x2a468
xorl %eax, %eax
movl %eax, %edx
callq 0x4170
movl $0x1c, %edi
leaq 0x1c014(%rip), %rsi     # 0x2a500
xorl %eax, %eax
movl %eax, %edx
callq 0x4170
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: enable_signals
static void enable_signals(void)
{
	struct sigaction dfl_act = {.sa_handler = SIG_DFL};

	sigaction(SIGHUP, &dfl_act, NULL);
	sigaction(SIGINT, &dfl_act, NULL);
	sigaction(SIGQUIT, &dfl_act, NULL);
	sigaction(SIGTSTP, &dfl_act, NULL);
	sigaction(SIGWINCH, &dfl_act, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x4380
movl $0x1, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4170
movl $0x2, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4170
movl $0x3, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4170
movl $0x14, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4170
movl $0x1c, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4170
addq $0xa0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: dentfree
static void dentfree(void)
{
	free(pnamebuf);
	free(pdents);
	free(mark);

	/* Thread data cleanup */
	free(core_blocks);
	free(core_data);
	free(core_files);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1c005(%rip), %rdi     # 0x2a5a0
callq 0x4090
movq 0x1bdc9(%rip), %rdi     # 0x2a370
callq 0x4090
movq 0x1bffd(%rip), %rdi     # 0x2a5b0
callq 0x4090
movq 0x1d011(%rip), %rdi     # 0x2b5d0
callq 0x4090
movq 0x1d00d(%rip), %rdi     # 0x2b5d8
callq 0x4090
movq 0x1d009(%rip), %rdi     # 0x2b5e0
callq 0x4090
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: printerr
static void printerr(int linenum)
{
	exitcurses();
	perror(xitoa(linenum));
	if (!g_state.picker && selpath)
		unlink(selpath);
	free(pselbuf);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x4890
movl -0x4(%rbp), %edi
callq 0x5df0
movq %rax, %rdi
callq 0x4750
movl 0x11cae(%rip), %eax     # 0x20824
shrl $0xc, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xeb97
cmpq $0x0, 0x11c9f(%rip)     # 0x20828
je 0xeb97
movq 0x11c96(%rip), %rdi     # 0x20828
callq 0x40d0
movq 0x131da(%rip), %rdi     # 0x21d78
callq 0x4090
movl $0x1, %edi
callq 0x4810
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: valid_parent
static void valid_parent(char *path, char *lastname)
{
	/* Save history */
	xstrsncpy(lastname, xbasename(path), NAME_MAX + 1);

	while (!istopdir(path))
		if (visit_parent(path, NULL, NULL))
			break;

	printwarn(NULL);
	xdelay(XDELAY_INTERVAL_MS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7240
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x6250
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0xec24
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xec2f
jmp 0xec49
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x10220
cmpq $0x0, %rax
je 0xec47
jmp 0xec49
jmp 0xec02
callq 0x40c0
movl (%rax), %edi
callq 0x4870
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd210
movl $0x55730, %edi          # imm = 0x55730
callq 0xd0a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: xterm_cfg
static void xterm_cfg(char *path)
{
	if (cfg.x11 && !g_state.picker) {
		/* Signal CWD change to terminal */
		printf("\033]7;file://%s%s\033\\", hostname, path);

		/* Set terminal window title */
		bool r = set_tilde_in_path(path);

		printf("\033]2;%s\007", r ? &path[homelen - 1] : path);
		fflush(stdout);

		if (r)
			reset_tilde_in_path(path);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl 0x1183e(%rip), %eax     # 0x204d0
shrl $0x1a, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xed37
movl 0x11b7d(%rip), %eax     # 0x20824
shrl $0xc, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xed37
movq -0x8(%rbp), %rdx
leaq 0xd9eb(%rip), %rdi      # 0x1c6ac
leaq 0x12fa8(%rip), %rsi     # 0x21c70
movb $0x0, %al
callq 0x4320
movq -0x8(%rbp), %rdi
callq 0x16370
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0xecfd
movq -0x8(%rbp), %rax
movzbl 0x11c5a(%rip), %ecx     # 0x20948
subl $0x1, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xed05
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0xd9ae(%rip), %rdi      # 0x1c6be
movb $0x0, %al
callq 0x4320
movq 0x11252(%rip), %rax     # 0x1ff70
movq (%rax), %rdi
callq 0x45f0
testb $0x1, -0x9(%rbp)
je 0xed35
movq -0x8(%rbp), %rdi
callq 0x163f0
jmp 0xed37
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: get_kv_key
static int get_kv_key(kv *kvarr, char *val, uchar_t max, uchar_t id)
{
	if (!kvarr)
		return -1;

	if (id != NNN_ORDER) /* For now this function supports only order string */
		return -1;

	for (int r = 0; r < max && kvarr[r].key; ++r) {
		if (xstrcmp((orderstr + kvarr[r].off), val) == 0)
			return kvarr[r].key;
	}

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %cl, -0x19(%rbp)
movb %al, -0x1a(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xed6d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xee33
movzbl -0x1a(%rbp), %eax
cmpl $0xb, %eax
je 0xed82
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xee33
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movzbl -0x19(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x21(%rbp)
jge 0xedab
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,8)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xedb4
jmp 0xee2c
movq 0x11bd5(%rip), %rax     # 0x20990
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movslq 0x4(%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0xede1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x28(%rbp)
jmp 0xee04
movq 0x11ba8(%rip), %rdi     # 0x20990
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movslq 0x4(%rax,%rcx,8), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x44e0
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl $0x0, %eax
jne 0xee1c
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movl %eax, -0x4(%rbp)
jmp 0xee33
jmp 0xee1e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xed89
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
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: populate
static void populate(char *path, char *lastname)
{
#ifdef DEBUG
	struct timespec ts1, ts2;

	clock_gettime(CLOCK_REALTIME, &ts1); /* Use CLOCK_MONOTONIC on FreeBSD */
#endif

	ndents = dentfill(path, &pdents);
	if (!ndents)
		return;

#ifndef NOSORT
	ENTSORT(pdents, ndents, entrycmpfn);
#endif

#ifdef DEBUG
	clock_gettime(CLOCK_REALTIME, &ts2);
	DPRINTF_U(ts2.tv_nsec - ts1.tv_nsec);
#endif

	/* Find cur from history */
	/* No NULL check for lastname, always points to an array */
	move_cursor(*lastname ? dentfind(lastname, ndents) : 0, 0);

	// Force full redraw
	last_curscroll = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1b515(%rip), %rsi     # 0x2a370
callq 0x16440
movl %eax, 0x13026(%rip)     # 0x21e8c
cmpl $0x0, 0x1301f(%rip)     # 0x21e8c
jne 0xee71
jmp 0xeecb
movq 0x1b4f8(%rip), %rdi     # 0x2a370
movslq 0x1300d(%rip), %rsi     # 0x21e8c
movq 0x1194a(%rip), %rcx     # 0x207d0
movl $0x30, %edx
callq 0x4150
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xeeb0
movq -0x10(%rbp), %rdi
movl 0x12fe6(%rip), %esi     # 0x21e8c
callq 0x12780
movl %eax, -0x14(%rbp)
jmp 0xeeb7
xorl %eax, %eax
movl %eax, -0x14(%rbp)
jmp 0xeeb7
movl -0x14(%rbp), %edi
xorl %esi, %esi
callq 0x10360
movl $0xffffffff, 0x1c71d(%rip) # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)