LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: set_time_type
static bool set_time_type(int *presel)
{
	bool ret = FALSE;
	char buf[] = "'a'ccess / 'c'hange / 'm'od [ ]";

	buf[sizeof(buf) - 3] = cfg.timetype == T_MOD ? 'm' : (cfg.timetype == T_ACCESS ? 'a' : 'c');

	int r = get_input(buf);

	if (r == 'a' || r == 'c' || r == 'm') {
		r = (r == 'm') ? T_MOD : ((r == 'a') ? T_ACCESS : T_CHANGE);
		if (cfg.timetype != r) {
			cfg.timetype = r;

			if (cfg.filtermode || g_ctx[cfg.curctx].c_fltr[1])
				*presel = FILTER;

			ret = TRUE;
		} else
			r = MSG_NOCHANGE;
	} else
		r = MSG_INVALID_KEY;

	if (!ret)
		printwait(messages[r], presel);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq 0x69b9(%rip), %rax      # 0x1c9e0
movq %rax, -0x30(%rbp)
movq 0x69b6(%rip), %rax      # 0x1c9e8
movq %rax, -0x28(%rbp)
movq 0x69b3(%rip), %rax      # 0x1c9f0
movq %rax, -0x20(%rbp)
movq 0x69b0(%rip), %rax      # 0x1c9f8
movq %rax, -0x18(%rbp)
movl 0xa47e(%rip), %eax      # 0x204d0
shrl $0x1b, %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x16067
movl $0x6d, %eax
movl %eax, -0x38(%rbp)
jmp 0x16086
movl 0xa463(%rip), %edx      # 0x204d0
shrl $0x1b, %edx
andl $0x3, %edx
movl $0x63, %eax
movl $0x61, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movb %al, -0x13(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10dc0
movl %eax, -0x34(%rbp)
cmpl $0x61, -0x34(%rbp)
je 0x160ae
cmpl $0x63, -0x34(%rbp)
je 0x160ae
cmpl $0x6d, -0x34(%rbp)
jne 0x16158
cmpl $0x6d, -0x34(%rbp)
jne 0x160be
movl $0x2, %eax
movl %eax, -0x3c(%rbp)
jmp 0x160d1
movl -0x34(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x61, %edx
cmovel %ecx, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl 0xa3f3(%rip), %eax      # 0x204d0
shrl $0x1b, %eax
andl $0x3, %eax
cmpl -0x34(%rbp), %eax
je 0x1614f
movl -0x34(%rbp), %ecx
movl 0xa3df(%rip), %eax      # 0x204d0
andl $0x3, %ecx
shll $0x1b, %ecx
andl $0xe7ffffff, %eax       # imm = 0xE7FFFFFF
orl %ecx, %eax
movl %eax, 0xa3cc(%rip)      # 0x204d0
movl 0xa3c6(%rip), %eax      # 0x204d0
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x1613f
movl 0xa3b8(%rip), %eax      # 0x204d0
shrl $0xd, %eax
andl $0x7, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xbd67(%rip), %rax      # 0x21e90
imulq $0x2138, %rcx, %rcx     # imm = 0x2138
addq %rcx, %rax
movsbl 0x2101(%rax), %eax
cmpl $0x0, %eax
je 0x16149
movq -0x8(%rbp), %rax
movl $0x2f, (%rax)
movb $0x1, -0x9(%rbp)
jmp 0x16156
movl $0x29, -0x34(%rbp)
jmp 0x1615f
movl $0x28, -0x34(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x1617d
movslq -0x34(%rbp), %rcx
leaq 0x98f0(%rip), %rax      # 0x1fa60
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rsi
callq 0xd210
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: setcfg
static void setcfg(settings newcfg)
{
	cfg = newcfg;
	/* Synchronize the global function pointers to match the new cfg. */
	entrycmpfn = cfg.reverse ? &reventrycmp : &entrycmp;
	namecmpfn = cfg.version ? &xstrverscasecmp : &xstricmp;
	filterfn = cfg.regex ? &visible_re : &visible_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0xa330(%rip)      # 0x204d0
movl 0xa32a(%rip), %edx      # 0x204d0
shrl $0xa, %edx
andl $0x1, %edx
leaq -0x8cf3(%rip), %rax     # 0xd4c0
leaq -0x8d7a(%rip), %rcx     # 0xd440
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, 0xa608(%rip)      # 0x207d0
movl 0xa302(%rip), %edx      # 0x204d0
shrl $0xb, %edx
andl $0x1, %edx
leaq -0x879b(%rip), %rax     # 0xda40
leaq -0x8a62(%rip), %rcx     # 0xd780
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, 0xa5e8(%rip)      # 0x207d8
movl 0xa2da(%rip), %edx      # 0x204d0
shrl $0x19, %edx
andl $0x1, %edx
leaq -0x97b3(%rip), %rax     # 0xca50
leaq -0x1051a(%rip), %rcx    # 0x5cf0
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, 0xa288(%rip)      # 0x204a0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: write_lastdir
static void write_lastdir(const char *curpath, const char *outfile)
{
	bool tilde = false, ok = false;
	if (!outfile)
		xstrsncpy(cfgpath + xstrlen(cfgpath), "/.lastd", 8);
	else
		tilde = convert_tilde(outfile, g_buf);

	int fd = open(outfile
			? (tilde ? g_buf : outfile)
			: cfgpath, O_CREAT | O_WRONLY | O_TRUNC, S_IWUSR | S_IRUSR);
	if (fd >= 0) {
		memcpy(g_buf, "cd ", 3);  // NOLINT
		ssize_t l = shell_escape(g_buf + 3, sizeof(g_buf) - 3, curpath);
		ok = l >= 0 && write(fd, g_buf, l + 3) == l + 3;
		close(fd);
	}
	if (!ok)
		errexit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x16270
movq 0xba22(%rip), %rax      # 0x21c68
movq %rax, -0x28(%rbp)
movq 0xba17(%rip), %rdi      # 0x21c68
callq 0x5cc0
movq -0x28(%rbp), %rdi
addq %rax, %rdi
leaq 0x675b(%rip), %rsi      # 0x1c9bf
movl $0x8, %edx
callq 0x6250
jmp 0x16285
movq -0x10(%rbp), %rdi
leaq 0xa7d5(%rip), %rsi      # 0x20a50
callq 0xd180
andb $0x1, %al
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x162b1
testb $0x1, -0x11(%rbp)
je 0x1629f
leaq 0xa7b7(%rip), %rax      # 0x20a50
movq %rax, -0x30(%rbp)
jmp 0x162a7
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x162bc
movq 0xb9b0(%rip), %rax      # 0x21c68
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x46c0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x16355
movw 0x66e6(%rip), %ax       # 0x1c9c7
movw %ax, 0xa768(%rip)       # 0x20a50
movb 0x66db(%rip), %al       # 0x1c9c9
movb %al, 0xa75e(%rip)       # 0x20a52
movq -0x8(%rbp), %rdx
leaq 0xa751(%rip), %rdi      # 0x20a50
addq $0x3, %rdi
movl $0x11fd, %esi           # imm = 0x11FD
callq 0x1a500
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x39(%rbp)
jl 0x16345
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rdx
addq $0x3, %rdx
leaq 0xa721(%rip), %rsi      # 0x20a50
callq 0x4210
movq -0x20(%rbp), %rcx
addq $0x3, %rcx
cmpq %rcx, %rax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x12(%rbp)
movl -0x18(%rbp), %edi
callq 0x43c0
testb $0x1, -0x12(%rbp)
jne 0x16365
movl $0xb35, %edi            # imm = 0xB35
callq 0xeb50
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: set_tilde_in_path
static bool set_tilde_in_path(char *path)
{
	if (is_prefix(path, home, homelen)) {
		home[homelen] = path[homelen - 1];
		path[homelen - 1] = '~';
		return TRUE;
	}

	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0xa5b9(%rip), %rsi      # 0x20940
movzbl 0xa5ba(%rip), %eax      # 0x20948
movl %eax, %edx
callq 0x7200
testb $0x1, %al
jne 0x1639b
jmp 0x163db
movq -0x10(%rbp), %rax
movzbl 0xa5a2(%rip), %ecx      # 0x20948
subl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq 0xa58a(%rip), %rax      # 0x20940
movzbl 0xa58b(%rip), %ecx      # 0x20948
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movzbl 0xa57d(%rip), %ecx      # 0x20948
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x7e, (%rax,%rcx)
movb $0x1, -0x1(%rbp)
jmp 0x163df
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: prep_threads
static bool prep_threads(void)
{
	if (!g_state.duinit) {
		/* drop MSB 1s */
		threadbmp >>= (32 - NUM_DU_THREADS);

		if (!core_blocks)
			core_blocks = calloc(NUM_DU_THREADS, sizeof(blkcnt_t));
		if (!core_data)
			core_data = calloc(NUM_DU_THREADS, sizeof(thread_data));
		if (!core_files)
			core_files = calloc(NUM_DU_THREADS, sizeof(ullong_t));

		if (!core_blocks || !core_data || !core_files) {
			printwarn(NULL);
			return FALSE;
		}
#ifndef __APPLE__
		/* Increase current open file descriptor limit */
		max_openfds();
#endif
		g_state.duinit = TRUE;
	} else {
		memset(core_blocks, 0, NUM_DU_THREADS * sizeof(blkcnt_t));
		memset(core_data, 0, NUM_DU_THREADS * sizeof(thread_data));
		memset(core_files, 0, NUM_DU_THREADS * sizeof(ullong_t));
	}
	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x9916(%rip), %eax      # 0x20824
shrl $0x4, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x16fe1
movl 0x98c9(%rip), %eax      # 0x207ec
sarl $0x1c, %eax
movl %eax, 0x98c0(%rip)      # 0x207ec
cmpq $0x0, 0x1469c(%rip)     # 0x2b5d0
jne 0x16f4c
movl $0x4, %edi
movl $0x8, %esi
callq 0x44d0
movq %rax, 0x14684(%rip)     # 0x2b5d0
cmpq $0x0, 0x14684(%rip)     # 0x2b5d8
jne 0x16f6c
movl $0x4, %edi
movl $0x1008, %esi           # imm = 0x1008
callq 0x44d0
movq %rax, 0x1466c(%rip)     # 0x2b5d8
cmpq $0x0, 0x1466c(%rip)     # 0x2b5e0
jne 0x16f8c
movl $0x4, %edi
movl $0x8, %esi
callq 0x44d0
movq %rax, 0x14654(%rip)     # 0x2b5e0
cmpq $0x0, 0x1463c(%rip)     # 0x2b5d0
je 0x16faa
cmpq $0x0, 0x1463a(%rip)     # 0x2b5d8
je 0x16faa
cmpq $0x0, 0x14638(%rip)     # 0x2b5e0
jne 0x16fc8
callq 0x40c0
movl (%rax), %edi
callq 0x4870
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd210
movb $0x0, -0x1(%rbp)
jmp 0x1701e
callq 0x172a0
movl 0x9851(%rip), %eax      # 0x20824
andl $-0x11, %eax
orl $0x10, %eax
movl %eax, 0x9845(%rip)      # 0x20824
jmp 0x1701a
movq 0x145e8(%rip), %rdi     # 0x2b5d0
xorl %esi, %esi
movl $0x20, %edx
callq 0x4380
movq 0x145dd(%rip), %rdi     # 0x2b5d8
xorl %esi, %esi
movl $0x4020, %edx           # imm = 0x4020
callq 0x4380
movq 0x145d2(%rip), %rdi     # 0x2b5e0
xorl %esi, %esi
movl $0x20, %edx
callq 0x4380
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: dirwalk
static void dirwalk(char *path, int entnum, bool mountpoint)
{
	/* Loop till any core is free */
	while (active_threads == NUM_DU_THREADS);

	if (g_state.interrupt)
		return;

	pthread_mutex_lock(&running_mutex);
	int core = ffs(threadbmp) - 1;

	threadbmp &= ~(1 << core);
	++active_threads;
	pthread_mutex_unlock(&running_mutex);

	xstrsncpy(core_data[core].path, path, PATH_MAX);
	core_data[core].entnum = entnum;
	core_data[core].core = (ushort_t)core;
	core_data[core].mntpoint = mountpoint;

	pthread_t tid = 0;

	pthread_create(&tid, NULL, du_thread, (void *)&(core_data[core]));

	tolastln();
	addstr(xbasename(path));
	addstr(" [^C aborts]\n");
	refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movl 0x145bc(%rip), %eax     # 0x2b608
cmpl $0x4, %eax
jne 0x17053
jmp 0x17046
movl 0x97cb(%rip), %eax      # 0x20824
shrl $0x8, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x17069
jmp 0x171dc
leaq 0x145a0(%rip), %rdi     # 0x2b610
callq 0x48e0
movl 0x9771(%rip), %edi      # 0x207ec
callq 0x4570
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
xorl $-0x1, %eax
andl 0x9753(%rip), %eax      # 0x207ec
movl %eax, 0x974d(%rip)      # 0x207ec
movl 0x14563(%rip), %eax     # 0x2b608
addl $0x1, %eax
movl %eax, 0x1455a(%rip)     # 0x2b608
leaq 0x1455b(%rip), %rdi     # 0x2b610
callq 0x45b0
movq 0x14517(%rip), %rdi     # 0x2b5d8
movslq -0x14(%rbp), %rax
imulq $0x1008, %rax, %rax     # imm = 0x1008
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x6250
movl -0xc(%rbp), %ecx
movq 0x144f1(%rip), %rax     # 0x2b5d8
movslq -0x14(%rbp), %rdx
imulq $0x1008, %rdx, %rdx     # imm = 0x1008
addq %rdx, %rax
movl %ecx, 0x1000(%rax)
movl -0x14(%rbp), %eax
movw %ax, %cx
movq 0x144d0(%rip), %rax     # 0x2b5d8
movslq -0x14(%rbp), %rdx
imulq $0x1008, %rdx, %rdx     # imm = 0x1008
addq %rdx, %rax
movw %cx, 0x1004(%rax)
movb -0xd(%rbp), %cl
movq 0x144b1(%rip), %rax     # 0x2b5d8
movslq -0x14(%rbp), %rdx
imulq $0x1008, %rdx, %rdx     # imm = 0x1008
addq %rdx, %rax
andb $0x1, %cl
movb %cl, 0x1006(%rax)
movq $0x0, -0x20(%rbp)
movq 0x1448b(%rip), %rcx     # 0x2b5d8
movslq -0x14(%rbp), %rax
imulq $0x1008, %rax, %rax     # imm = 0x1008
addq %rax, %rcx
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x186(%rip), %rdx       # 0x172f0
callq 0x46b0
movq 0x8e1a(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
movzwl 0xad08(%rip), %esi      # 0x21e88
subl $0x1, %esi
xorl %edx, %edx
callq 0x4070
movq 0x8dff(%rip), %rax      # 0x1ff90
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7240
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x41c0
movq 0x8dd7(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
leaq 0x5503(%rip), %rsi      # 0x1c6c6
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x41c0
movq 0x8dbc(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
callq 0x4440
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: test_set_bit
static bool test_set_bit(uint_t nr)
{
	nr &= HASH_BITS;

	pthread_mutex_lock(&hardlink_mutex);
	ullong_t *m = ihashbmp + (nr >> 6);

	if (*m & (1 << (nr & 63))) {
		pthread_mutex_unlock(&hardlink_mutex);
		return FALSE;
	}

	*m |= 1 << (nr & 63);
	pthread_mutex_unlock(&hardlink_mutex);

	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, -0x8(%rbp)
leaq 0x1442b(%rip), %rdi     # 0x2b638
callq 0x48e0
movq 0xab97(%rip), %rax      # 0x21db0
movl -0x8(%rbp), %ecx
shrl $0x6, %ecx
movl %ecx, %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x8(%rbp), %ecx
andl $0x3f, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x17260
leaq 0x143e3(%rip), %rdi     # 0x2b638
callq 0x45b0
movb $0x0, -0x1(%rbp)
jmp 0x1728a
movl -0x8(%rbp), %ecx
andl $0x3f, %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
leaq 0x143b7(%rip), %rdi     # 0x2b638
callq 0x45b0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: max_openfds
static void max_openfds(void)
{
	struct rlimit rl;

	if (!getrlimit(RLIMIT_NOFILE, &rl))
		if (rl.rlim_cur < rl.rlim_max) {
			rl.rlim_cur = rl.rlim_max;
			setrlimit(RLIMIT_NOFILE, &rl);
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x7, %edi
leaq -0x10(%rbp), %rsi
callq 0x45a0
cmpl $0x0, %eax
jne 0x172dd
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x172db
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x7, %edi
leaq -0x10(%rbp), %rsi
callq 0x4360
jmp 0x172dd
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: adjust_cols
static int adjust_cols(int n)
{
	/* Calculate the number of cols available to print entry name */
#ifdef ICONS_ENABLED
	n -= (g_state.oldcolor ? 0 : ICON_SIZE + ICON_PADDING_LEFT_LEN + ICON_PADDING_RIGHT_LEN);
#endif
	if (cfg.showdetail) {
		/* Fallback to light mode if less than 35 columns */
		if (n < 36)
			cfg.showdetail ^= 1;
		else /* 2 more accounted for below */
			n -= 32;
	}

	/* 2 columns for preceding space and indicator */
	return (n - 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl 0x8d73(%rip), %eax      # 0x204d0
shrl $0x8, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x177a3
cmpl $0x24, -0x4(%rbp)
jge 0x17798
movl 0x8d5c(%rip), %ecx      # 0x204d0
shrl $0x8, %ecx
andl $0x1, %ecx
xorl $0x1, %ecx
movl 0x8d4d(%rip), %eax      # 0x204d0
andl $0x1, %ecx
shll $0x8, %ecx
andl $0xfffffeff, %eax       # imm = 0xFFFFFEFF
orl %ecx, %eax
movl %eax, 0x8d3a(%rip)      # 0x204d0
jmp 0x177a1
movl -0x4(%rbp), %eax
subl $0x20, %eax
movl %eax, -0x4(%rbp)
jmp 0x177a3
movl -0x4(%rbp), %eax
subl $0x2, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: findmarkentry
static inline void findmarkentry(size_t len, struct entry *dentp)
{
	if (!(dentp->flags & FILE_SCANNED)) {
		if (findinsel(findselpos, len + xstrsncpy(g_sel + len, dentp->name, dentp->nlen)))
			dentp->flags |= FILE_SELECTED;
		dentp->flags |= FILE_SCANNED;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
shrq $0x38, %rax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x1789a
movq 0x13de1(%rip), %rax     # 0x2b5c0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x12dce(%rip), %rdi     # 0x2a5c0
addq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
shrq $0x28, %rdx
andq $0xffff, %rdx           # imm = 0xFFFF
callq 0x6250
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
movl %eax, %esi
callq 0x17c90
cmpq $0x0, %rax
je 0x17865
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
shrq $0x38, %rcx
orl $0x10, %ecx
movslq %ecx, %rdx
movq 0x20(%rax), %rcx
andq $0xff, %rdx
shlq $0x38, %rdx
movabsq $0xffffffffffffff, %rsi # imm = 0xFFFFFFFFFFFFFF
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
shrq $0x38, %rcx
orl $0x20, %ecx
movslq %ecx, %rdx
movq 0x20(%rax), %rcx
andq $0xff, %rdx
shlq $0x38, %rdx
movabsq $0xffffffffffffff, %rsi # imm = 0xFFFFFFFFFFFFFF
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: findinsel
static char *findinsel(char *startpos, int len)
{
	if (!selbufpos)
		return FALSE;

	if (!startpos)
		startpos = pselbuf;

	char *found = startpos;
	size_t buflen = selbufpos - (startpos - pselbuf);

	while (1) {
		/* memmem(3): not specified in POSIX.1, but present on a number of other systems. */
		found = memmem(found, buflen - (found - startpos), g_sel, len);
		if (!found)
			return NULL;
		if (found == startpos || *(found - 1) == '\0')
			return found;
		found += len; /* We found g_sel as a substring of a path, move forward */
		if (found >= startpos + buflen)
			return NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, 0xa0ca(%rip)      # 0x21d70
jne 0x17cb5
movq $0x0, -0x8(%rbp)
jmp 0x17d77
cmpq $0x0, -0x10(%rbp)
jne 0x17cc7
movq 0xa0b5(%rip), %rax      # 0x21d78
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0xa09b(%rip), %eax      # 0x21d70
movq -0x10(%rbp), %rcx
movq 0xa098(%rip), %rdx      # 0x21d78
subq %rdx, %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
subq %rax, %rsi
movslq -0x14(%rbp), %rcx
leaq 0x128b5(%rip), %rdx     # 0x2a5c0
callq 0x4530
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x17d25
movq $0x0, -0x8(%rbp)
jmp 0x17d77
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x17d3c
movq -0x20(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x17d46
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x17d77
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
addq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jb 0x17d72
movq $0x0, -0x8(%rbp)
jmp 0x17d77
jmp 0x17cea
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: print_time
static void print_time(const time_t *timep, const uchar_t flags)
{
	struct tm t;

	/* Highlight timestamp for entries 5 minutes young */
	if (flags & FILE_YOUNG)
		attron(A_REVERSE);

	localtime_r(timep, &t);
	printw("%s-%02d-%02d %02d:%02d",
		xitoa(t.tm_year + 1900), t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min);

	if (flags & FILE_YOUNG)
		attroff(A_REVERSE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x17e36
movq 0x816b(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %eax, %eax
movl %eax, %edx
callq 0x4120
movq -0x8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4100
movl -0x34(%rbp), %edi
addl $0x76c, %edi            # imm = 0x76C
callq 0x5df0
movq %rax, %rsi
movl -0x38(%rbp), %edx
addl $0x1, %edx
movl -0x3c(%rbp), %ecx
movl -0x40(%rbp), %r8d
movl -0x44(%rbp), %r9d
leaq 0x487a(%rip), %rdi      # 0x1c6e6
movb $0x0, %al
callq 0x4610
movzbl -0x9(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x17e97
movq 0x810a(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %eax, %eax
movl %eax, %edx
callq 0x4740
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: get_detail_ind
static char get_detail_ind(const mode_t mode)
{
	switch (mode & S_IFMT) {
	case S_IFDIR:  // fallthrough
	case S_IFREG:  return ' ';
	case S_IFLNK:  return '@';
	case S_IFSOCK: return '=';
	case S_IFIFO:  return '|';
	case S_IFBLK:  return 'b';
	case S_IFCHR:  return 'c';
	}
	return '?';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
movl %eax, -0xc(%rbp)
subl $0x1000, %eax           # imm = 0x1000
je 0x181b5
jmp 0x1815b
movl -0xc(%rbp), %eax
subl $0x2000, %eax           # imm = 0x2000
je 0x181c1
jmp 0x18167
movl -0xc(%rbp), %eax
subl $0x4000, %eax           # imm = 0x4000
je 0x181a3
jmp 0x18173
movl -0xc(%rbp), %eax
subl $0x6000, %eax           # imm = 0x6000
je 0x181bb
jmp 0x1817f
movl -0xc(%rbp), %eax
subl $0x8000, %eax           # imm = 0x8000
je 0x181a3
jmp 0x1818b
movl -0xc(%rbp), %eax
subl $0xa000, %eax           # imm = 0xA000
je 0x181a9
jmp 0x18197
movl -0xc(%rbp), %eax
subl $0xc000, %eax           # imm = 0xC000
je 0x181af
jmp 0x181c7
movb $0x20, -0x1(%rbp)
jmp 0x181cb
movb $0x40, -0x1(%rbp)
jmp 0x181cb
movb $0x3d, -0x1(%rbp)
jmp 0x181cb
movb $0x7c, -0x1(%rbp)
jmp 0x181cb
movb $0x62, -0x1(%rbp)
jmp 0x181cb
movb $0x63, -0x1(%rbp)
jmp 0x181cb
movb $0x3f, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: unescape
static wchar_t *unescape(const char *str, uint_t maxcols)
{
	wchar_t * const wbuf = (wchar_t *)g_buf;
	wchar_t *buf = wbuf;
	size_t len = mbstowcs(wbuf, str, maxcols); /* Convert multi-byte to wide char */

	len = wcswidth(wbuf, len);

	if (len >= maxcols) {
		size_t lencount = maxcols;

		while (len > maxcols) /* Reduce wide chars one by one till it fits */
			len = wcswidth(wbuf, --lencount);

		wbuf[lencount] = L'\0';
	}
#endif

	while (*buf) {
		if (*buf <= '\x1f' || *buf == '\x7f')
			*buf = '\?';

		++buf;
	}

	return wbuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x85fa(%rip), %rax      # 0x20a50
movq %rax, -0x18(%rbp)
leaq 0x85ef(%rip), %rax      # 0x20a50
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, %edx
leaq 0x85db(%rip), %rdi      # 0x20a50
callq 0x41d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq 0x85c7(%rip), %rdi      # 0x20a50
callq 0x4190
cltq
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
jb 0x184e5
movl -0xc(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x184d3
movq -0x30(%rbp), %rsi
addq $-0x1, %rsi
movq %rsi, -0x30(%rbp)
leaq 0x858a(%rip), %rdi      # 0x20a50
callq 0x4190
cltq
movq %rax, -0x28(%rbp)
jmp 0x184a7
movq -0x30(%rbp), %rcx
leaq 0x8572(%rip), %rax      # 0x20a50
movl $0x0, (%rax,%rcx,4)
jmp 0x184e7
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1851a
movq -0x20(%rbp), %rax
cmpl $0x1f, (%rax)
jle 0x18502
movq -0x20(%rbp), %rax
cmpl $0x7f, (%rax)
jne 0x1850c
movq -0x20(%rbp), %rax
movl $0x3f, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x184e7
leaq 0x852f(%rip), %rax      # 0x20a50
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: get_size
static off_t get_size(off_t size, off_t *pval, int comp)
{
	off_t rem = *pval;
	off_t quo = rem / 10;

	if ((rem - (quo * 10)) >= 5) {
		rem = quo + 1;
		if (rem == comp) {
			++size;
			rem = 0;
		}
	} else
		rem = quo;

	*pval = rem;
	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
imulq $0xa, -0x28(%rbp), %rcx
subq %rcx, %rax
cmpq $0x5, %rax
jl 0x1859d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
jne 0x1859b
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
jmp 0x185a5
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: get_fs_info
static size_t get_fs_info(const char *path, uchar_t type)
{
	struct statvfs svb;

	if (statvfs(path, &svb) == -1)
		return 0;

	if (type == VFS_AVAIL)
		return (size_t)svb.f_bavail << ffs((int)(svb.f_frsize >> 1));

	if (type == VFS_USED)
		return ((size_t)svb.f_blocks - (size_t)svb.f_bfree) << ffs((int)(svb.f_frsize >> 1));

	return (size_t)svb.f_blocks << ffs((int)(svb.f_frsize >> 1)); /* VFS_SIZE */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x4900
cmpl $-0x1, %eax
jne 0x185f7
movq $0x0, -0x8(%rbp)
jmp 0x18692
movzbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jne 0x1862d
movq -0x68(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x80(%rbp), %rax
shrq %rax
movl %eax, %edi
callq 0x4570
movl %eax, %ecx
movq -0x90(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x8(%rbp)
jmp 0x18692
movzbl -0x11(%rbp), %eax
cmpl $0x1, %eax
jne 0x18667
movq -0x78(%rbp), %rax
subq -0x70(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x80(%rbp), %rax
shrq %rax
movl %eax, %edi
callq 0x4570
movl %eax, %ecx
movq -0x98(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x8(%rbp)
jmp 0x18692
movq -0x78(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x80(%rbp), %rax
shrq %rax
movl %eax, %edi
callq 0x4570
movl %eax, %ecx
movq -0xa0(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: getorderstr
static int getorderstr(char *sort)
{
	int i = 0;

	if (cfg.showhidden)
		sort[i++] = 'H';

	if (cfg.timeorder)
		sort[i++] = (cfg.timetype == T_MOD) ? 'M' : ((cfg.timetype == T_ACCESS) ? 'A' : 'C');
	else if (cfg.sizeorder)
		sort[i++] = 'S';
	else if (cfg.extnorder)
		sort[i++] = 'E';

	if (entrycmpfn == &reventrycmp)
		sort[i++] = 'R';

	if (namecmpfn == &xstrverscasecmp)
		sort[i++] = 'V';

	if (i)
		sort[i] = ' ';

	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl 0x7e1b(%rip), %eax      # 0x204d0
shrl $0x6, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x186d6
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb $0x48, (%rax,%rcx)
movl 0x7df4(%rip), %eax      # 0x204d0
shrl %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1873c
movl 0x7de4(%rip), %eax      # 0x204d0
shrl $0x1b, %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x18701
movl $0x4d, %eax
movl %eax, -0x10(%rbp)
jmp 0x18720
movl 0x7dc9(%rip), %edx      # 0x204d0
shrl $0x1b, %edx
andl $0x3, %edx
movl $0x43, %eax
movl $0x41, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x18790
movl 0x7d8e(%rip), %eax      # 0x204d0
shrl $0x2, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x18765
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb $0x53, (%rax,%rcx)
jmp 0x1878e
movl 0x7d65(%rip), %eax      # 0x204d0
shrl $0x5, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1878c
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb $0x45, (%rax,%rcx)
jmp 0x1878e
jmp 0x18790
leaq -0xb357(%rip), %rax     # 0xd440
cmpq %rax, 0x8032(%rip)      # 0x207d0
jne 0x187b6
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb $0x52, (%rax,%rcx)
leaq -0xb03d(%rip), %rax     # 0xd780
cmpq %rax, 0x8014(%rip)      # 0x207d8
jne 0x187dc
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb $0x56, (%rax,%rcx)
cmpl $0x0, -0xc(%rbp)
je 0x187ee
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: getpwname
static char *getpwname(uid_t uid)
{
	static uint_t uidcache = UINT_MAX;
	static char *namecache;

	if (uidcache != uid) {
		struct passwd *pw = getpwuid(uid);

		uidcache = uid;
		namecache = pw ? pw->pw_name : NULL;
	}

	return namecache ? namecache : xitoa(uid);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl 0x7e1f(%rip), %eax      # 0x207f0
cmpl -0x4(%rbp), %eax
je 0x18a12
movl -0x4(%rbp), %edi
callq 0x4280
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x7e05(%rip)      # 0x207f0
cmpq $0x0, -0x10(%rbp)
je 0x189ff
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x18a07
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0x18a07
movq -0x18(%rbp), %rax
movq %rax, 0x12c6e(%rip)     # 0x2b680
cmpq $0x0, 0x12c66(%rip)     # 0x2b680
je 0x18a29
movq 0x12c5d(%rip), %rax     # 0x2b680
movq %rax, -0x20(%rbp)
jmp 0x18a35
movl -0x4(%rbp), %edi
callq 0x5df0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: getgrname
static char *getgrname(gid_t gid)
{
	static uint_t gidcache = UINT_MAX;
	static char *grpcache;

	if (gidcache != gid) {
		struct group *gr = getgrgid(gid);

		gidcache = gid;
		grpcache = gr ? gr->gr_name : NULL;
	}

	return grpcache ? grpcache : xitoa(gid);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl 0x7da3(%rip), %eax      # 0x207f4
cmpl -0x4(%rbp), %eax
je 0x18a92
movl -0x4(%rbp), %edi
callq 0x4340
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x7d89(%rip)      # 0x207f4
cmpq $0x0, -0x10(%rbp)
je 0x18a7f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x18a87
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0x18a87
movq -0x18(%rbp), %rax
movq %rax, 0x12bf6(%rip)     # 0x2b688
cmpq $0x0, 0x12bee(%rip)     # 0x2b688
je 0x18aa9
movq 0x12be5(%rip), %rax     # 0x2b688
movq %rax, -0x20(%rbp)
jmp 0x18ab5
movl -0x4(%rbp), %edi
callq 0x5df0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: plctrl_init
static bool plctrl_init(void)
{
	size_t len;

	/* g_tmpfpath is used to generate tmp file names */
	g_tmpfpath[tmpfplen - 1] = '\0';
	len = xstrsncpy(g_pipepath, g_tmpfpath, TMP_LEN_MAX);
	g_pipepath[len - 1] = '/';
	len = xstrsncpy(g_pipepath + len, "nnn-pipe.", TMP_LEN_MAX - len) + len;
	xstrsncpy(g_pipepath + len - 1, xitoa(getpid()), TMP_LEN_MAX - len);
	setenv(env_cfg[NNN_PIPE], g_pipepath, TRUE);

	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movzbl 0x7ef1(%rip), %eax      # 0x20a40
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x7ea4(%rip), %rax      # 0x20a00
movb $0x0, (%rax,%rcx)
leaq 0x92d9(%rip), %rdi      # 0x21e40
leaq 0x7e92(%rip), %rsi      # 0x20a00
movl $0x40, %edx
callq 0x6250
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
subq $0x1, %rcx
leaq 0x92b5(%rip), %rax      # 0x21e40
movb $0x2f, (%rax,%rcx)
leaq 0x92aa(%rip), %rdi      # 0x21e40
addq -0x8(%rbp), %rdi
movl $0x40, %edx
subq -0x8(%rbp), %rdx
leaq 0x3bb3(%rip), %rsi      # 0x1c75d
callq 0x6250
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0x9282(%rip), %rax      # 0x21e40
addq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
callq 0x4220
movl %eax, %edi
callq 0x5df0
movq -0x10(%rbp), %rdi
movq %rax, %rsi
movl $0x40, %edx
subq -0x8(%rbp), %rdx
callq 0x6250
movq 0x6d86(%rip), %rdi      # 0x1f978
leaq 0x9247(%rip), %rsi      # 0x21e40
movl $0x1, %edx
callq 0x4200
xorl %eax, %eax
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: run_cmd_as_plugin
static void run_cmd_as_plugin(const char *file, uchar_t flags)
{
	size_t len;

	xstrsncpy(g_buf, file, PATH_MAX);

	len = xstrlen(g_buf);
	if (len > 1 && g_buf[len - 1] == '*') {
		flags &= ~F_CONFIRM; /* Skip user confirmation */
		g_buf[len - 1] = '\0'; /* Get rid of trailing no confirmation symbol */
		--len;
	}

	if (flags & F_PAGE)
		get_output(utils[UTIL_SH_EXEC], g_buf, NULL, -1, TRUE);
	else
		spawn(utils[UTIL_SH_EXEC], g_buf, NULL, NULL, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x7bc3(%rip), %rdi      # 0x20a50
movl $0x1000, %edx           # imm = 0x1000
callq 0x6250
leaq 0x7bb2(%rip), %rdi      # 0x20a50
callq 0x5cc0
movq %rax, -0x18(%rbp)
cmpq $0x1, -0x18(%rbp)
jbe 0x18eef
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
leaq 0x7b93(%rip), %rax      # 0x20a50
movsbl (%rax,%rcx), %eax
cmpl $0x2a, %eax
jne 0x18eef
movzbl -0x9(%rbp), %eax
andl $-0x11, %eax
movb %al, -0x9(%rbp)
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
leaq 0x7b71(%rip), %rax      # 0x20a50
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x18f21
movq 0x6ae4(%rip), %rdi      # 0x1f9e8
leaq 0x7b45(%rip), %rsi      # 0x20a50
xorl %eax, %eax
movl %eax, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x1, %r8d
callq 0x10ba0
jmp 0x18f41
movq 0x6ac0(%rip), %rdi      # 0x1f9e8
movzbl -0x9(%rbp), %eax
leaq 0x7b1d(%rip), %rsi      # 0x20a50
xorl %ecx, %ecx
movq %rcx, %rdx
movzwl %ax, %r8d
callq 0xde30
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: read_nointr
static ssize_t read_nointr(int fd, void *buf, size_t count)
{
	ssize_t len;

	do
		len = read(fd, buf, count);
	while (len == -1 && errno == EINTR);

	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4460
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $-0x1, -0x20(%rbp)
movb %al, -0x21(%rbp)
jne 0x191f1
callq 0x40c0
cmpl $0x4, (%rax)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x191c3
movq -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: get_free_ctx
static uchar_t get_free_ctx(void)
{
	uchar_t r = cfg.curctx;

	do
		r = (r + 1) & ~CTX_MAX;
	while (g_ctx[r].c_cfg.ctxactive && (r != cfg.curctx));

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x72b6(%rip), %eax      # 0x204d0
shrl $0xd, %eax
andl $0x7, %eax
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
addl $0x1, %eax
andl $-0x5, %eax
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
movl %eax, %ecx
leaq 0x8c53(%rip), %rax      # 0x21e90
imulq $0x2138, %rcx, %rcx     # imm = 0x2138
addq %rcx, %rax
movl 0x2130(%rax), %ecx
shrl $0x9, %ecx
andl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2(%rbp)
je 0x19275
movzbl -0x1(%rbp), %eax
movl 0x7269(%rip), %ecx      # 0x204d0
shrl $0xd, %ecx
andl $0x7, %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
testb $0x1, %al
jne 0x19223
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: is_suffix
static bool is_suffix(const char *restrict str, const char *restrict suffix)
{
	if (!str || !suffix)
		return FALSE;

	size_t lenstr = xstrlen(str);
	size_t lensuffix = xstrlen(suffix);

	if (lensuffix > lenstr)
		return FALSE;

	return (xstrcmp(str + (lenstr - lensuffix), suffix) == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x192ee
cmpq $0x0, -0x18(%rbp)
jne 0x192f4
movb $0x0, -0x1(%rbp)
jmp 0x1936c
movq -0x10(%rbp), %rdi
callq 0x5cc0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5cc0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x1931e
movb $0x0, -0x1(%rbp)
jmp 0x1936c
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
subq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x19343
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x2c(%rbp)
jmp 0x1935e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
subq -0x28(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x44e0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: matches
static int matches(const char *fltr)
{
#ifdef PCRE2
	pcre2_code *pcre2x = NULL;

	/* Search filter */
	if (cfg.regex && setfilter(&pcre2x, fltr))
		return -1;

	ndents = fill(fltr, pcre2x);

	if (cfg.regex)
		pcre2_code_free(pcre2x);
#else
	regex_t re;

	/* Search filter */
	if (cfg.regex && setfilter(&re, fltr))
		return -1;

	ndents = fill(fltr, &re);

	if (cfg.regex)
		regfree(&re);
#endif

	ENTSORT(pdents, ndents, entrycmpfn);

	return ndents;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl 0x713e(%rip), %eax      # 0x204d0
shrl $0x19, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x193b8
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x7490
cmpl $0x0, %eax
je 0x193b8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1940d
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x19500
movl %eax, 0x8ac1(%rip)      # 0x21e8c
movl 0x70ff(%rip), %eax      # 0x204d0
shrl $0x19, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x193e5
leaq -0x50(%rbp), %rdi
callq 0x42a0
movq 0x10f84(%rip), %rdi     # 0x2a370
movslq 0x8a99(%rip), %rsi      # 0x21e8c
movq 0x73d6(%rip), %rcx      # 0x207d0
movl $0x30, %edx
callq 0x4150
movl 0x8a82(%rip), %eax      # 0x21e8c
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: showfilter
static void showfilter(char *str)
{
	attron(COLOR_PAIR(cfg.curctx + 1));
	showfilterinfo();
	printmsg_nc(str);
	attroff(COLOR_PAIR(cfg.curctx + 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x6b5d(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
movl 0x7094(%rip), %esi      # 0x204d0
shrl $0xd, %esi
andl $0x7, %esi
addl $0x1, %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
xorl %eax, %eax
movl %eax, %edx
callq 0x4120
callq 0x19630
movq -0x8(%rbp), %rdi
callq 0xd0d0
movq 0x6b24(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
movl 0x705b(%rip), %esi      # 0x204d0
shrl $0xd, %esi
andl $0x7, %esi
addl $0x1, %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
xorl %eax, %eax
movl %eax, %edx
callq 0x4740
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: handle_alt_key
static int handle_alt_key(wint_t *wch)
{
	timeout(0);

	int r = get_wch(wch);

	if (r == ERR)
		*wch = ESC;
	cleartimeout();

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x6add(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
xorl %esi, %esi
callq 0x4580
movq 0x6acc(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x48d0
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x194e3
movq -0x8(%rbp), %rax
movl $0x1b, (%rax)
movq 0x6aa6(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4580
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: fill
static int fill(const char *fltr, regex_t *re)
#endif
{
#ifdef PCRE2
	fltrexp_t fltrexp = { .pcre2x = pcre2x, .str = fltr };
#else
	fltrexp_t fltrexp = { .regex = re, .str = fltr };
#endif

	for (int count = 0; count < ndents; ++count) {
		if (filterfn(&fltrexp, pdents[count].name) == 0) {
			if (count != --ndents) {
				swap_ent(count, ndents);
				--count;
			}

			continue;
		}
	}

	return ndents;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl 0x895c(%rip), %eax      # 0x21e8c
jge 0x19595
movq 0x6f67(%rip), %rax      # 0x204a0
movq 0x10e30(%rip), %rcx     # 0x2a370
movslq -0x24(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rsi
leaq -0x20(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
jne 0x19588
movl -0x24(%rbp), %eax
movl 0x892a(%rip), %ecx      # 0x21e8c
addl $-0x1, %ecx
movl %ecx, 0x8921(%rip)      # 0x21e8c
cmpl %ecx, %eax
je 0x19586
movl -0x24(%rbp), %edi
movl 0x8914(%rip), %esi      # 0x21e8c
callq 0x195b0
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1958a
jmp 0x1958a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x19527
movl 0x88f1(%rip), %eax      # 0x21e8c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: swap_ent
static inline void swap_ent(int id1, int id2)
{
	struct entry _dent, *pdent1 = &pdents[id1], *pdent2 =  &pdents[id2];

	*(&_dent) = *pdent1;
	*pdent1 = *pdent2;
	*pdent2 = *(&_dent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq 0x10dab(%rip), %rax     # 0x2a370
movslq -0x4(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq 0x10d95(%rip), %rax     # 0x2a370
movslq -0x8(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movl $0x30, %edx
callq 0x4560
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl $0x30, %edx
callq 0x4560
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x30, %edx
callq 0x4560
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: showfilterinfo
static void showfilterinfo(void)
{
	int i = 0;
	char info[REGEX_MAX] = "\0\0\0\0\0";

	i = getorderstr(info);

	if (cfg.fileinfo && ndents && get_output("file", "-b", pdents[cur].name, -1, FALSE))
		mvaddstr(xlines - 2, 2, g_buf);
	else
		snprintf(info + i, REGEX_MAX - i - 1, "  %s [/], %s [:]",
			 (cfg.regex ? "reg" : "str"), ((fnstrstr == &strcasestr) ? "ic" : "noic"));

	mvaddstr(xlines - 2, xcols - xstrlen(info), info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x4380
leaq -0x40(%rbp), %rdi
callq 0x186a0
movl %eax, -0x4(%rbp)
movl 0x6e6f(%rip), %eax      # 0x204d0
shrl $0x11, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x196f4
cmpl $0x0, 0x8815(%rip)      # 0x21e8c
je 0x196f4
movq 0x10cf0(%rip), %rax     # 0x2a370
movslq 0x10cf1(%rip), %rcx     # 0x2a378
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x2fb2(%rip), %rdi      # 0x1c64a
leaq 0x3177(%rip), %rsi      # 0x1c816
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %r8d, %r8d
callq 0x10ba0
testb $0x1, %al
jne 0x196b2
jmp 0x196f4
movq 0x68d7(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
movzwl 0x87c5(%rip), %esi      # 0x21e88
subl $0x2, %esi
movl $0x2, %edx
callq 0x4070
cmpl $-0x1, %eax
jne 0x196d7
jmp 0x196f2
movq 0x68b2(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
leaq 0x7368(%rip), %rsi      # 0x20a50
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x41c0
jmp 0x1975f
leaq -0x40(%rbp), %rdi
movslq -0x4(%rbp), %rax
addq %rax, %rdi
movl $0x30, %eax
subl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
movl 0x6dbd(%rip), %edx      # 0x204d0
shrl $0x19, %edx
andl $0x1, %edx
leaq 0x30de(%rip), %rcx      # 0x1c7fe
leaq 0x30d3(%rip), %rax      # 0x1c7fa
cmpl $0x0, %edx
cmovneq %rax, %rcx
movq 0x6da3(%rip), %rdx      # 0x204d8
movq 0x688c(%rip), %r9       # 0x1ffc8
leaq 0x30bf(%rip), %r8       # 0x1c802
leaq 0x30ba(%rip), %rax      # 0x1c804
cmpq %r9, %rdx
cmoveq %rax, %r8
leaq 0x3091(%rip), %rdx      # 0x1c7e9
movb $0x0, %al
callq 0x4350
movq 0x682a(%rip), %rax      # 0x1ff90
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movzwl 0x8714(%rip), %eax      # 0x21e88
subl $0x2, %eax
movl %eax, -0x4c(%rbp)
movzwl 0x10e17(%rip), %eax     # 0x2a598
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5cc0
movq -0x58(%rbp), %rdi
movl -0x4c(%rbp), %esi
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq %rcx, %rax
movl %eax, %edx
callq 0x4070
cmpl $-0x1, %eax
jne 0x197ad
jmp 0x197c5
movq 0x67dc(%rip), %rax      # 0x1ff90
movq (%rax), %rdi
leaq -0x40(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x41c0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: entries_in_file
static uint_t entries_in_file(int fd, char *buf, size_t buflen, const char delim)
{
	ssize_t len;
	uint_t count = 0;

	while ((len = read(fd, buf, buflen)) > 0)
		while (len)
			count += (buf[--len] == delim);

	/* For all use cases 0 count is considered as error */
	return ((len < 0) ? 0 : ((delim != NUL_CHAR) ? count : ++count));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4460
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jle 0x19842
jmp 0x1980b
cmpq $0x0, -0x28(%rbp)
je 0x19840
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x28(%rbp)
movsbl -0x1(%rax,%rcx), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1980b
jmp 0x197ef
cmpq $0x0, -0x28(%rbp)
jge 0x19850
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x19873
movsbl -0x19(%rbp), %eax
cmpl $0x0, %eax
je 0x19861
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x1986d
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)