LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x8549(%rip), %r12d     # 0x1ba70
testq %r12, %r12
je 0x13579
movq %rdi, %rbx
testq %rdi, %rdi
movq 0x853f(%rip), %rax      # 0x1ba78
cmoveq %rax, %rbx
addq %rax, %r12
movslq %esi, %r14
leaq 0x10d76(%rip), %r15     # 0x242c0
movq %rbx, %rax
movq %r12, %rsi
subq %rax, %rsi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4520
testq %rax, %rax
je 0x13579
cmpq %rbx, %rax
je 0x1357b
cmpb $0x0, -0x1(%rax)
je 0x1357b
addq %r14, %rax
cmpq %r12, %rax
jb 0x1354d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
movq %rdi, %r14
testb $0x40, %bl
je 0x135f4
movq 0x69ab(%rip), %rax      # 0x19f90
movq (%rax), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %edx, %edx
callq 0x4120
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4100
movl $0x76c, %edi            # imm = 0x76C
addl 0x14(%r15), %edi
callq 0x5fa8
movl 0x10(%r15), %edx
incl %edx
movl 0xc(%r15), %ecx
movl 0x4(%r15), %r9d
movl 0x8(%r15), %r8d
leaq 0x2d22(%rip), %rdi      # 0x1634d
movq %rax, %rsi
xorl %eax, %eax
callq 0x45f0
testb $0x40, %bl
je 0x13650
movq 0x694f(%rip), %rax      # 0x19f90
movq (%rax), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %edx, %edx
callq 0x4730
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x70, %rsp
movl %esi, %ebx
movq %rsp, %rsi
callq 0x4900
cmpl $-0x1, %eax
je 0x138f1
cmpb $0x1, %bl
je 0x138f5
movzbl %bl, %eax
testl %eax, %eax
jne 0x13906
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rax
jmp 0x13910
xorl %eax, %eax
jmp 0x13923
movq 0x10(%rsp), %rax
subq 0x18(%rsp), %rax
movq 0x8(%rsp), %rdx
jmp 0x13910
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
shrq %rdx
bsfl %edx, %ecx
incb %cl
testl %edx, %edx
movzbl %cl, %ecx
cmovel %edx, %ecx
shlq %cl, %rax
addq $0x70, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
testb $0x40, 0x6b96(%rip)     # 0x1a4c8
je 0x1393c
movb $0x48, (%rdi)
movl $0x1, %eax
movl 0x6b86(%rip), %ecx      # 0x1a4c8
testb $0x2, %cl
jne 0x13957
movb $0x53, %dl
testb $0x4, %cl
jne 0x13973
movb $0x45, %dl
testb $0x20, %cl
jne 0x13973
jmp 0x1397a
shrl $0x1b, %ecx
andl $0x3, %ecx
setne %dl
addb %dl, %dl
orb $0x41, %dl
cmpl $0x2, %ecx
movzbl %dl, %ecx
movl $0x4d, %edx
cmovnel %ecx, %edx
movl %eax, %ecx
incl %eax
movb %dl, (%rdi,%rcx)
leaq -0x4940(%rip), %rcx     # 0xf041
cmpq %rcx, 0x6b58(%rip)      # 0x1a4e0
jne 0x13992
movl %eax, %ecx
incl %eax
movb $0x52, (%rdi,%rcx)
leaq -0x47de(%rip), %rcx     # 0xf1bb
cmpq %rcx, 0x6b48(%rip)      # 0x1a4e8
jne 0x139aa
movl %eax, %ecx
incl %eax
movb $0x56, (%rdi,%rcx)
testl %eax, %eax
je 0x139b4
movl %eax, %ecx
movb $0x20, (%rdi,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/jarun[P]nnn/src/nnn.c
// Function: setexports
static void setexports(const char *path)
{
	char dvar[] = "d0";
	char fvar[] = "f0";

	if (ndents) {
		setenv(envs[ENV_NCUR], pdents[cur].name, 1);
		xstrsncpy(g_ctx[cfg.curctx].c_name, pdents[cur].name, NAME_MAX + 1);
	} else if (g_ctx[cfg.curctx].c_name[0])
		g_ctx[cfg.curctx].c_name[0] = '\0';

	for (uchar_t i = 0; i < CTX_MAX; ++i) {
		if (g_ctx[i].c_cfg.ctxactive) {
			dvar[1] = fvar[1] = '1' + i;
			setenv(dvar, g_ctx[i].c_path, 1);

			if (g_ctx[i].c_name[0]) {
				mkpath(g_ctx[i].c_path, g_ctx[i].c_name, g_buf);
				setenv(fvar, g_buf, 1);
			}
		}
	}
	setenv("NNN_INCLUDE_HIDDEN", xitoa(cfg.showhidden), 1);
	setenv("NNN_PREFER_SELECTION", xitoa(cfg.prefersel), 1);
	setenv("PWD", path, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
xorl %eax, %eax
movb %al, 0xe(%rsp)
movw $0x3064, 0xc(%rsp)      # imm = 0x3064
movb %al, 0xa(%rsp)
movw $0x3066, 0x8(%rsp)      # imm = 0x3066
cmpl $0x0, 0x81a5(%rip)      # 0x1bb8c
je 0x13a75
movq 0x1067c(%rip), %rax     # 0x24070
movslq 0x1067d(%rip), %rcx     # 0x24078
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rsi
leaq 0x23aa(%rip), %rdi      # 0x15db8
movl $0x1, %edx
callq 0x4200
movl 0x6aaa(%rip), %eax      # 0x1a4c8
shrl $0xd, %eax
andl $0x7, %eax
imulq $0x2138, %rax, %rax     # imm = 0x2138
leaq 0x815e(%rip), %rcx      # 0x1bb90
leaq (%rax,%rcx), %r14
addq $0x2000, %r14           # imm = 0x2000
movq 0x1062c(%rip), %rax     # 0x24070
movslq 0x1062d(%rip), %rcx     # 0x24078
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rsi
movl $0x100, %ecx            # imm = 0x100
movq %r14, %rdi
xorl %edx, %edx
callq 0x4860
testq %rax, %rax
jne 0x13aa5
movb $0x0, 0xff(%r14)
jmp 0x13aa5
movl 0x6a4d(%rip), %eax      # 0x1a4c8
shrl $0xd, %eax
andl $0x7, %eax
imulq $0x2138, %rax, %rax     # imm = 0x2138
leaq 0x8101(%rip), %rcx      # 0x1bb90
cmpb $0x0, 0x2000(%rax,%rcx)
je 0x13aa5
addq %rcx, %rax
addq $0x2000, %rax           # imm = 0x2000
movb $0x0, (%rax)
leaq 0xa0e4(%rip), %r14      # 0x1db90
movq $-0x4, %rbx
leaq 0xc(%rsp), %r15
leaq 0x6c91(%rip), %r12      # 0x1a750
leaq 0x8(%rsp), %r13
testb $0x2, 0x131(%r14)
je 0x13b14
leaq -0x2000(%r14), %rbp
leal 0x35(%rbx), %eax
movb %al, 0x9(%rsp)
movb %al, 0xd(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
movl $0x1, %edx
callq 0x4200
cmpb $0x0, (%r14)
je 0x13b14
movq %rbp, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6dd5
movq %r13, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x4200
addq $0x2138, %r14           # imm = 0x2138
incq %rbx
jne 0x13ac4
movl 0x69a2(%rip), %edi      # 0x1a4c8
shrl $0x6, %edi
andl $0x1, %edi
callq 0x5fa8
leaq 0x2784(%rip), %rdi      # 0x162bc
movq %rax, %rsi
movl $0x1, %edx
callq 0x4200
movl 0x697d(%rip), %edi      # 0x1a4c8
shrl $0x10, %edi
andl $0x1, %edi
callq 0x5fa8
leaq 0x2772(%rip), %rdi      # 0x162cf
movq %rax, %rsi
movl $0x1, %edx
callq 0x4200
leaq 0x1c3f(%rip), %rdi      # 0x157b0
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x4200
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x6bb1(%rip), %r14      # 0x1a750
movl $0x1000, %ecx           # imm = 0x1000
movq %r14, %rdi
xorl %edx, %edx
callq 0x4860
testq %rax, %rax
jne 0x13bba
movb $0x0, 0x7b95(%rip)      # 0x1b74f
movq %r14, %rdi
xorl %esi, %esi
callq 0x4490
subq %r14, %rax
cmpq $0x2, %rax
jb 0x13bde
cmpb $0x2a, -0x1(%rax,%r14)
jne 0x13bde
andb $-0x11, %bl
movb $0x0, -0x1(%rax,%r14)
testb %bl, %bl
js 0x13c04
movzbl %bl, %r8d
leaq 0x226f(%rip), %rdi      # 0x15e5c
leaq 0x6b5c(%rip), %rsi      # 0x1a750
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf5fc
leaq 0x2251(%rip), %rdi      # 0x15e5c
leaq 0x6b3e(%rip), %rsi      # 0x1a750
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x1, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x117c7
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x6b12(%rip), %r14      # 0x1a750
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4460
movq %rax, %r15
cmpq $-0x1, %rax
jne 0x13c5e
callq 0x40c0
cmpl $0x4, (%rax)
je 0x13c3e
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x13cf6
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x4490
movq %rax, %r14
subq %rbx, %r14
leaq 0x2716(%rip), %r15      # 0x163d9
movq %r15, %rdi
xorl %esi, %esi
callq 0x4490
subq %r15, %rax
subq %rax, %r14
jb 0x13cf8
cmpb $0x2e, (%rbx,%r14)
jne 0x13cf6
addq %r14, %rbx
leaq 0x26f3(%rip), %rsi      # 0x163d9
movq %rbx, %rdi
callq 0x44d0
testl %eax, %eax
sete %bpl
jmp 0x13cf8
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
testb $0x2, 0x67b1(%rip)      # 0x1a4cb
je 0x13d3e
movl 0x67ba(%rip), %edx      # 0x1a4dc
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x4420
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x13e55
leaq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq %rbx, 0x8(%rsp)
movl 0x7e3a(%rip), %eax      # 0x1bb8c
testl %eax, %eax
jle 0x13e17
xorl %ebp, %ebp
movq %rsp, %rbx
movq 0x1030a(%rip), %rax     # 0x24070
movslq %ebp, %rcx
leaq (%rcx,%rcx,2), %r14
shlq $0x4, %r14
movq (%rax,%r14), %rsi
movq %rbx, %rdi
callq *0x671a(%rip)           # 0x1a498
testl %eax, %eax
jne 0x13e07
movslq 0x7dff(%rip), %rax      # 0x1bb8c
decq %rax
movl %eax, 0x7df6(%rip)      # 0x1bb8c
cmpl %eax, %ebp
je 0x13e07
movq 0x102cf(%rip), %rcx     # 0x24070
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movups (%rcx,%r14), %xmm0
movups 0x10(%rcx,%r14), %xmm1
movups 0x20(%rcx,%r14), %xmm2
movaps %xmm2, 0x30(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movups (%rcx,%rax), %xmm0
movups 0x10(%rcx,%rax), %xmm1
movups 0x20(%rcx,%rax), %xmm2
movups %xmm2, 0x20(%rcx,%r14)
movups %xmm1, 0x10(%rcx,%r14)
movups %xmm0, (%rcx,%r14)
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
movaps 0x30(%rsp), %xmm2
movups %xmm2, 0x20(%rcx,%rax)
movups %xmm1, 0x10(%rcx,%rax)
movups %xmm0, (%rcx,%rax)
decl %ebp
incl %ebp
movl 0x7d7d(%rip), %eax      # 0x1bb8c
cmpl %eax, %ebp
jl 0x13d5f
movl %eax, 0x7d6f(%rip)      # 0x1bb8c
testb $0x2, 0x66a7(%rip)      # 0x1a4cb
je 0x13e30
leaq 0x40(%rsp), %rdi
callq 0x42a0
movq 0x10239(%rip), %rdi     # 0x24070
movslq 0x7d4e(%rip), %rsi      # 0x1bb8c
movq 0x669b(%rip), %rcx      # 0x1a4e0
movl $0x30, %edx
callq 0x4150
movl 0x7d37(%rip), %eax      # 0x1bb8c
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x6117(%rip), %r12      # 0x19f90
movq (%r12), %rdi
movl 0x6645(%rip), %esi      # 0x1a4c8
shrl $0x5, %esi
andl $0x700, %esi            # imm = 0x700
addl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x4120
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x13929
movl %eax, %ebp
testb $0x2, 0x6612(%rip)      # 0x1a4ca
je 0x13f30
cmpl $0x0, 0x7ccb(%rip)      # 0x1bb8c
je 0x13f30
movq 0x101a6(%rip), %rax     # 0x24070
movslq 0x101a7(%rip), %rcx     # 0x24078
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rdx
leaq 0x23cd(%rip), %rdi      # 0x162b1
leaq 0x2592(%rip), %rsi      # 0x1647d
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %r8d, %r8d
callq 0x117c7
testb %al, %al
je 0x13f30
movq (%r12), %rdi
movzwl 0x7c81(%rip), %esi      # 0x1bb88
addl $-0x2, %esi
movl $0x2, %edx
callq 0x4070
cmpl $-0x1, %eax
je 0x13f89
movq (%r12), %rdi
leaq 0x682c(%rip), %rsi      # 0x1a750
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x41c0
jmp 0x13f89
movslq %ebp, %rax
leaq (%rsp,%rax), %rdi
movl $0x2f, %edx
subl %eax, %edx
btl $0x19, 0x6582(%rip)     # 0x1a4c8
leaq 0x2518(%rip), %rax      # 0x16465
leaq 0x250d(%rip), %rcx      # 0x16461
cmovaeq %rax, %rcx
movslq %edx, %rsi
movq 0x656e(%rip), %rax      # 0x1a4d0
cmpq 0x605f(%rip), %rax      # 0x19fc8
leaq 0x24fb(%rip), %rax      # 0x1646b
leaq 0x24f2(%rip), %r8       # 0x16469
cmoveq %rax, %r8
leaq 0x24ce(%rip), %rdx      # 0x16450
xorl %eax, %eax
callq 0x4350
movq (%r12), %r14
movzwl 0x7bf4(%rip), %ebp      # 0x1bb88
addl $-0x2, %ebp
movzwl 0x102f9(%rip), %r13d    # 0x24298
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x4490
addl %r13d, %r15d
subl %eax, %r15d
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x4070
cmpl $-0x1, %eax
je 0x13fd5
movq (%r12), %rdi
movq %rsp, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x41c0
movq (%r12), %rdi
movzwl 0x7ba8(%rip), %esi      # 0x1bb88
decl %esi
xorl %edx, %edx
callq 0x4070
movq (%r12), %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x41c0
movq (%r12), %rdi
callq 0x4840
movq (%r12), %rdi
movl 0x64bb(%rip), %esi      # 0x1a4c8
shrl $0x5, %esi
andl $0x700, %esi            # imm = 0x700
addl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x4730
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x5f50(%rip), %r14      # 0x19f90
movq (%r14), %rdi
xorl %esi, %esi
callq 0x4560
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x48d0
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x14062
movl $0x1b, (%rbx)
movq (%r14), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4560
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %r12d
callq 0x4460
xorl %ebp, %ebp
xorl %r13d, %r13d
testq %rax, %rax
jle 0x140c4
xorl %ecx, %ecx
cmpb %bl, -0x1(%r15,%rax)
leaq -0x1(%rax), %rdx
sete %cl
addl %ecx, %r13d
movq %rdx, %rax
testq %rdx, %rdx
jne 0x1409b
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4460
jmp 0x14096
cmpb $0x1, %bl
adcl $0x0, %r13d
testq %rax, %rax
cmovel %r13d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jarun[P]nnn/src/nnn.c
// Function: selbufrealloc
static void selbufrealloc(const size_t alloclen)
{
	if ((selbufpos + alloclen) > selbuflen) {
		selbuflen = ALIGN_UP(selbufpos + alloclen, PATH_MAX);
		pselbuf = xrealloc(pselbuf, selbuflen);
		if (!pselbuf)
			errexit();
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x790d(%rip), %esi      # 0x1ba70
addq %rdi, %rsi
movl 0xff60(%rip), %eax      # 0x240cc
cmpq %rax, %rsi
jbe 0x141a1
addl $0xfff, %esi            # imm = 0xFFF
andl $0xfffff000, %esi       # imm = 0xFFFFF000
movl %esi, 0xff49(%rip)      # 0x240cc
movq 0x78ee(%rip), %rbx      # 0x1ba78
movq %rbx, %rdi
callq 0x4640
movq %rax, %r14
testq %rax, %rax
je 0x141a9
movq %r14, 0x78d7(%rip)      # 0x1ba78
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x4090
movq %r14, 0x78c0(%rip)      # 0x1ba78
movl $0x674, %edi            # imm = 0x674
callq 0xff2e
// File: /workspace/github_c_makefile_star2_O1/jarun[P]nnn/src/nnn.c
// Function: confirm_force
static char confirm_force(bool selection, bool use_trash)
{
	char str[300];

	/* Count selection from file when nothing is selected */
	if (selection && (nselected == 0)) {
		int fd = open(selpath, O_RDONLY);

		if (fd != -1) {
			nselected = entries_in_file(fd, str, 300, NUL_CHAR);
			close(fd);
		} else {
			printwarn(NULL);
			return '\0';
		}
	}

	/* Note: ideally we should use utils[UTIL_RM_RF] instead of the "rm -rf" string */
	int r = snprintf(str, 20, "%s", use_trash ? utils[UTIL_GIO_TRASH] + 4 : "rm -rf");

	if (selection)
		snprintf(str + r, 280, " %d file(s)?", nselected);
	else
		snprintf(str + r, 280, " '%s'?", pdents[cur].name);

	r = get_input(str);

	if (r == ESC)
		return '\0'; /* cancel */
	if (r == 'y' || r == 'Y')
		return 'f'; /* forceful for rm */
	if (r == 'n' || r == 'N')
		return '\0'; /* cancel */
	return (use_trash ? '\0' : 'i'); /* interactive for rm */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movl %esi, %ebx
movl %edi, %ebp
testl %edi, %edi
je 0x14236
cmpl $0x0, 0x100d0(%rip)     # 0x242ac
jne 0x14236
movq 0x6343(%rip), %rdi      # 0x1a528
xorl %esi, %esi
xorl %eax, %eax
callq 0x46b0
movl %eax, %r14d
cmpl $-0x1, %eax
je 0x14218
movq %rsp, %rsi
movl $0x12c, %edx            # imm = 0x12C
movl %r14d, %edi
xorl %ecx, %ecx
callq 0x14076
movl %eax, 0x1009e(%rip)     # 0x242ac
movl %r14d, %edi
callq 0x43c0
jmp 0x1422c
callq 0x40c0
movl (%rax), %edi
callq 0x4870
movq %rax, %rdi
callq 0xee6f
cmpl $-0x1, %r14d
je 0x142c0
leaq 0x1c5b(%rip), %rax      # 0x15e98
leaq 0x22f0(%rip), %rcx      # 0x16534
testb %bl, %bl
cmovneq %rax, %rcx
leaq 0x200d(%rip), %rdx      # 0x1625e
movq %rsp, %rdi
movl $0x14, %esi
xorl %eax, %eax
callq 0x4350
cltq
leaq (%rsp,%rax), %rdi
testb %bpl, %bpl
je 0x14286
movl 0x1003b(%rip), %ecx     # 0x242ac
leaq 0x22c3(%rip), %rdx      # 0x1653b
movl $0x118, %esi            # imm = 0x118
xorl %eax, %eax
callq 0x4350
jmp 0x142b3
movq 0xfde3(%rip), %rax      # 0x24070
movslq 0xfde4(%rip), %rcx      # 0x24078
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rcx
leaq 0x22a1(%rip), %rdx      # 0x16548
movl $0x118, %esi            # imm = 0x118
xorl %eax, %eax
callq 0x4350
movq %rsp, %rdi
callq 0x11973
cmpl $0x1b, %eax
jne 0x142c4
xorl %eax, %eax
jmp 0x142e2
movl %eax, %ecx
andl $-0x21, %ecx
movb $0x66, %al
cmpl $0x59, %ecx
je 0x142e2
xorl %edx, %edx
testb %bl, %bl
movl $0x69, %eax
cmovnel %edx, %eax
cmpl $0x4e, %ecx
cmovel %edx, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/motet-a[P]libforks/tests/kill_all.c
// Function: main
int main() {
  libforks_ServerConn conn;
  check(libforks_start(&conn) == libforks_OK);

  int socket_fd;

  check(libforks_fork(
    conn,
    NULL, // pid_ptr
    &socket_fd, // socket_fd_ptr
    NULL, // exit_fd_ptr
    child_main
  ) == libforks_OK);

  // is the child ready to receive the signal?
  char c;
  check(read(socket_fd, &c, 1) == 1);
  check(c == 'r');

  check(libforks_kill_all(conn, SIGUSR1) == libforks_OK);

  check(read(socket_fd, &c, 1) == 1);
  check(c == 's');

  check(libforks_stop(conn) == libforks_OK);
  return 0;
}

// Assembly:
subq $0x18, %rsp
leaq 0x10(%rsp), %rdi
callq 0x1873
testl %eax, %eax
jne 0x13b8
movq 0x10(%rsp), %rdi
leaq 0x12d(%rip), %r8        # 0x146b
leaq 0xc(%rsp), %rdx
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x22c7
testl %eax, %eax
jne 0x13c9
movl 0xc(%rsp), %edi
leaq 0xb(%rsp), %rsi
movl $0x1, %edx
callq 0x10f0
cmpq $0x1, %rax
jne 0x13da
cmpb $0x72, 0xb(%rsp)
jne 0x13eb
movq 0x10(%rsp), %rdi
movl $0xa, %esi
callq 0x24c7
testl %eax, %eax
jne 0x13fc
movl 0xc(%rsp), %edi
leaq 0xb(%rsp), %rsi
movl $0x1, %edx
callq 0x10f0
cmpq $0x1, %rax
jne 0x140d
cmpb $0x73, 0xb(%rsp)
jne 0x141e
movq 0x10(%rsp), %rdi
callq 0x2482
testl %eax, %eax
jne 0x142f
xorl %eax, %eax
addq $0x18, %rsp
retq
leaq 0x1c45(%rip), %rdi      # 0x3004
movl $0x14, %esi
callq 0x1440
leaq 0x1c6a(%rip), %rdi      # 0x303a
movl $0x1e, %esi
callq 0x1440
leaq 0x1ca2(%rip), %rdi      # 0x3083
movl $0x22, %esi
callq 0x1440
leaq 0x1cad(%rip), %rdi      # 0x309f
movl $0x23, %esi
callq 0x1440
leaq 0x1ca5(%rip), %rdi      # 0x30a8
movl $0x25, %esi
callq 0x1440
leaq 0x1c6f(%rip), %rdi      # 0x3083
movl $0x27, %esi
callq 0x1440
leaq 0x1cb3(%rip), %rdi      # 0x30d8
movl $0x28, %esi
callq 0x1440
leaq 0x1cab(%rip), %rdi      # 0x30e1
movl $0x2a, %esi
callq 0x1440
// File: /workspace/github_c_makefile_star2_O1/motet-a[P]libforks/tests/kill_all.c
// Function: child_main
static void child_main(libforks_ServerConn conn, int socket_fd) {
  (void)conn;
  child_socket_fd = socket_fd;
  check(signal(SIGUSR1, child_handle_sigusr1) != SIG_ERR);
  check(write(socket_fd, "r", 1) == 1); // tell the parent process that we are ready
  sleep(999);
}

// Assembly:
pushq %rbx
movl %esi, %ebx
movl %esi, 0x4ca0(%rip)      # 0x6114
leaq 0x56(%rip), %rsi        # 0x14d1
movl $0xa, %edi
callq 0x1100
cmpq $-0x1, %rax
je 0x14af
leaq 0x2245(%rip), %rsi      # 0x36d7
movl $0x1, %edx
movl %ebx, %edi
callq 0x1080
cmpq $0x1, %rax
jne 0x14c0
movl $0x3e7, %edi            # imm = 0x3E7
popq %rbx
jmp 0x11e0
leaq 0x1c6a(%rip), %rdi      # 0x3120
movl $0xd, %esi
callq 0x1440
leaq 0x1c8a(%rip), %rdi      # 0x3151
movl $0xe, %esi
callq 0x1440
// File: /workspace/github_c_makefile_star2_O1/LemonBoy[P]autobahn/xdiff/xdiffi.c
// Function: group_slide_up
static int group_slide_up(xdfile_t *xdf, struct xdlgroup *g, long flags)
{
	if (g->start > 0 &&
	    recs_match(xdf->recs[g->start - 1], xdf->recs[g->end - 1], flags)) {
		xdf->rchg[--g->start] = 1;
		xdf->rchg[--g->end] = 0;

		while (xdf->rchg[g->start - 1])
			g->start--;

		return 0;
	} else {
		return -1;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rsi), %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rax, %rax
jle 0x239c
movq %rsi, %rbx
movq %rdi, %r14
movq 0x60(%rdi), %rcx
movq -0x8(%rcx,%rax,8), %rdi
movq 0x8(%rsi), %rax
movq -0x8(%rcx,%rax,8), %rsi
callq 0x28a5
testl %eax, %eax
je 0x239c
movq 0x68(%r14), %rax
movq (%rbx), %rcx
leaq -0x1(%rcx), %rdx
movq %rdx, (%rbx)
movb $0x1, -0x1(%rax,%rcx)
movq 0x68(%r14), %rax
movq 0x8(%rbx), %rcx
leaq -0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movb $0x0, -0x1(%rax,%rcx)
movq 0x68(%r14), %rax
movq (%rbx), %rcx
xorl %ebp, %ebp
cmpb $0x0, -0x1(%rax,%rcx)
je 0x239c
decq %rcx
movq %rcx, (%rbx)
cmpb $0x0, -0x1(%rax,%rcx)
leaq -0x1(%rcx), %rcx
jne 0x238e
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LemonBoy[P]autobahn/xdiff/xdiffi.c
// Function: measure_split
static void measure_split(const xdfile_t *xdf, long split,
			  struct split_measurement *m)
{
	long i;

	if (split >= xdf->nrec) {
		m->end_of_file = 1;
		m->indent = -1;
	} else {
		m->end_of_file = 0;
		m->indent = get_indent(xdf->recs[split]);
	}

	m->pre_blank = 0;
	m->pre_indent = -1;
	for (i = split - 1; i >= 0; i--) {
		m->pre_indent = get_indent(xdf->recs[i]);
		if (m->pre_indent != -1)
			break;
		m->pre_blank += 1;
		if (m->pre_blank == MAX_BLANKS) {
			m->pre_indent = 0;
			break;
		}
	}

	m->post_blank = 0;
	m->post_indent = -1;
	for (i = split + 1; i < xdf->nrec; i++) {
		m->post_indent = get_indent(xdf->recs[i]);
		if (m->post_indent != -1)
			break;
		m->post_blank += 1;
		if (m->post_blank == MAX_BLANKS) {
			m->post_indent = 0;
			break;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x38(%rdi), %r12
cmpq %rsi, %r12
jle 0x23d5
movl $0x0, (%rbx)
movq 0x60(%r15), %rax
movq (%rax,%r14,8), %rdi
callq 0x28de
jmp 0x23e0
movl $0x1, (%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x4(%rbx)
movabsq $-0x100000000, %r13     # imm = 0xFFFFFFFF00000000
movq %r13, 0x8(%rbx)
movq %r14, %rbp
testq %rbp, %rbp
jle 0x2426
movq 0x60(%r15), %rax
movq -0x8(%rax,%rbp,8), %rdi
callq 0x28de
movl %eax, 0xc(%rbx)
cmpl $-0x1, %eax
jne 0x2426
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
decq %rbp
cmpl $0x14, %eax
jne 0x23f4
movl $0x0, 0xc(%rbx)
movq %r13, 0x10(%rbx)
incq %r14
cmpq %r12, %r14
jge 0x245e
movq 0x60(%r15), %rax
movq (%rax,%r14,8), %rdi
callq 0x28de
movl %eax, 0x14(%rbx)
cmpl $-0x1, %eax
jne 0x245e
movl 0x10(%rbx), %eax
incl %eax
movl %eax, 0x10(%rbx)
incq %r14
cmpl $0x14, %eax
jne 0x242d
movl $0x0, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LemonBoy[P]autobahn/xdiff/xdiffi.c
// Function: xdl_build_script
int xdl_build_script(xdfenv_t *xe, xdchange_t **xscr) {
	xdchange_t *cscr = NULL, *xch;
	char *rchg1 = xe->xdf1.rchg, *rchg2 = xe->xdf2.rchg;
	long i1, i2, l1, l2;

	/*
	 * Trivial. Collects "groups" of changes and creates an edit script.
	 */
	for (i1 = xe->xdf1.nrec, i2 = xe->xdf2.nrec; i1 >= 0 || i2 >= 0; i1--, i2--)
		if (rchg1[i1 - 1] || rchg2[i2 - 1]) {
			for (l1 = i1; rchg1[i1 - 1]; i1--);
			for (l2 = i2; rchg2[i2 - 1]; i2--);

			if (!(xch = xdl_add_change(cscr, i1, i2, l1 - i1, l2 - i2))) {
				xdl_free_script(cscr);
				return -1;
			}
			cscr = xch;
		}

	*xscr = cscr;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x8(%rsp)
movq 0x38(%rdi), %rbx
movq 0xc0(%rdi), %r13
testq %r13, %rbx
js 0x260b
movq 0x68(%rdi), %r12
movq 0xf0(%rdi), %rax
leaq -0x1(%r12), %rcx
movq %rcx, 0x20(%rsp)
movq %rax, 0x10(%rsp)
decq %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
cmpb $0x0, -0x1(%r12,%rbx)
jne 0x257a
movq 0x10(%rsp), %rax
cmpb $0x0, -0x1(%rax,%r13)
je 0x2606
movq $-0x1, %r14
movq 0x20(%rsp), %rax
incq %r14
cmpb $0x0, (%rax,%rbx)
leaq -0x1(%rax), %rax
jne 0x2586
subq %r14, %rbx
movq $-0x1, %rbp
movq 0x18(%rsp), %rax
incq %rbp
cmpb $0x0, (%rax,%r13)
leaq -0x1(%rax), %rax
jne 0x25a2
movl $0x30, %edi
callq 0x10e0
subq %rbp, %r13
testq %rax, %rax
je 0x25de
movq %r15, (%rax)
movq %rbx, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbp, 0x20(%rax)
movl $0x0, 0x28(%rax)
jmp 0x25e0
xorl %eax, %eax
testq %rax, %rax
je 0x262a
testq %rbx, %rbx
leaq -0x1(%rbx), %rbx
setg %cl
testq %r13, %r13
leaq -0x1(%r13), %r13
setg %dl
orb %cl, %dl
movq %rax, %r15
jne 0x2561
jmp 0x260d
movq %r15, %rax
jmp 0x25e5
xorl %eax, %eax
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testq %r15, %r15
je 0x2618
movq (%r15), %rbx
movq %r15, %rdi
callq 0x1030
movq %rbx, %r15
testq %rbx, %rbx
jne 0x2635
jmp 0x2618
// File: /workspace/github_c_makefile_star2_O1/LemonBoy[P]autobahn/xdiff/xdiffi.c
// Function: xdl_diff
int xdl_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
	     xdemitconf_t const *xecfg, xdemitcb_t *ecb) {
	xdchange_t *xscr;
	xdfenv_t xe;
	emit_func_t ef = xecfg->hunk_func ? xdl_call_hunk_func : xdl_emit_diff;

	if (xdl_do_diff(mf1, mf2, xpp, &xe) < 0) {

		return -1;
	}
	if (xdl_change_compact(&xe.xdf1, &xe.xdf2, xpp->flags) < 0 ||
	    xdl_change_compact(&xe.xdf2, &xe.xdf1, xpp->flags) < 0 ||
	    xdl_build_script(&xe, &xscr) < 0) {

		xdl_free_env(&xe);
		return -1;
	}
	if (xscr) {
		if (xpp->flags & XDF_IGNORE_BLANK_LINES)
			xdl_mark_ignorable(xscr, &xe, xpp->flags);

		if (ef(&xe, xscr, ecb, xecfg) < 0) {

			xdl_free_script(xscr);
			xdl_free_env(&xe);
			return -1;
		}
		xdl_free_script(xscr);
	}
	xdl_free_env(&xe);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r12
cmpq $0x0, 0x28(%rcx)
jne 0x268c
leaq 0xa1c(%rip), %r15       # 0x30a6
jmp 0x2693
leaq 0x188(%rip), %r15       # 0x281b
leaq 0x28(%rsp), %rcx
movq %r12, %rdx
callq 0x1d47
testl %eax, %eax
js 0x2802
movq %r15, 0x18(%rsp)
leaq 0xb0(%rsp), %r15
movq (%r12), %rdx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x1ec1
movq (%r12), %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x1ec1
leaq 0x20(%rsp), %rsi
movq %r13, %rdi
callq 0x2515
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x27f6
movq 0x20(%rsp), %r15
testq %r15, %r15
je 0x27df
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq (%r12), %r12
testb %r12b, %r12b
jns 0x27b2
movq %r15, %r13
cmpq $0x0, 0x18(%r13)
jle 0x275a
movq 0x8(%r13), %r14
shlq $0x3, %r14
addq 0x88(%rsp), %r14
movl $0x1, %ebx
movq -0x8(%r14,%rbx,8), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movq %r12, %rdx
callq 0x4462
cmpq 0x18(%r13), %rbx
jge 0x275f
incq %rbx
testl %eax, %eax
jne 0x2736
jmp 0x275f
movl $0x1, %eax
cmpq $0x0, 0x20(%r13)
jle 0x27a1
testl %eax, %eax
je 0x27a1
movq 0x10(%r13), %r14
shlq $0x3, %r14
addq 0x110(%rsp), %r14
movl $0x1, %ebx
movq -0x8(%r14,%rbx,8), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movq %r12, %rdx
callq 0x4462
cmpq 0x20(%r13), %rbx
jge 0x27a1
incq %rbx
testl %eax, %eax
jne 0x277f
movl %eax, 0x28(%r13)
movq (%r13), %r13
testq %r13, %r13
jne 0x271a
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq *0x18(%rsp)
testl %eax, %eax
js 0x27e3
movq (%r15), %rbx
movq %r15, %rdi
callq 0x1030
movq %rbx, %r15
testq %rbx, %rbx
jne 0x27cc
xorl %ebp, %ebp
jmp 0x27f6
movq (%r15), %rbx
movq %r15, %rdi
callq 0x1030
movq %rbx, %r15
testq %rbx, %rbx
jne 0x27e3
leaq 0x28(%rsp), %rdi
callq 0x41c6
jmp 0x2807
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LemonBoy[P]autobahn/xdiff/xdiffi.c
// Function: xdl_call_hunk_func
static int xdl_call_hunk_func(xdfenv_t *xe, xdchange_t *xscr, xdemitcb_t *ecb,
			      xdemitconf_t const *xecfg)
{
	xdchange_t *xch, *xche;

	for (xch = xscr; xch; xch = xche->next) {
		xche = xdl_get_hunk(&xch, xecfg);
		if (!xch)
			break;
		if (xecfg->hunk_func(xch->i1, xche->i1 + xche->chg1 - xch->i1,
				     xch->i2, xche->i2 + xche->chg2 - xch->i2,
				     ecb->priv) < 0)
			return -1;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x2895
movq %rcx, %r14
movq %rdx, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2fe4
movq %rax, %r13
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x2895
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rdx
movq 0x8(%r13), %rsi
movq 0x10(%r13), %rcx
subq %rdi, %rsi
addq 0x18(%r13), %rsi
subq %rdx, %rcx
addq 0x20(%r13), %rcx
movq (%r15), %r8
callq *0x28(%r14)
testl %eax, %eax
js 0x2890
movq (%r13), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x283f
jmp 0x2895
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/LemonBoy[P]autobahn/xdiff/xdiffi.c
// Function: recs_match
static int recs_match(xrecord_t *rec1, xrecord_t *rec2, long flags)
{
	return (rec1->ha == rec2->ha &&
		xdl_recmatch(rec1->ptr, rec1->size,
			     rec2->ptr, rec2->size,
			     flags));
}

// Assembly:
movq 0x18(%rdi), %rcx
xorl %eax, %eax
cmpq 0x18(%rsi), %rcx
jne 0x28dd
pushq %rax
movq %rdx, %r8
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %r9
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %rcx
movq %rax, %rdi
movq %r9, %rsi
callq 0x44b5
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/LemonBoy[P]autobahn/xdiff/xdiffi.c
// Function: get_indent
static int get_indent(xrecord_t *rec)
{
	long i;
	int ret = 0;

	for (i = 0; i < rec->size; i++) {
		char c = rec->ptr[i];

		if (!XDL_ISSPACE(c))
			return ret;
		else if (c == ' ')
			ret += 1;
		else if (c == '\t')
			ret += 8 - ret % 8;
		/* ignore other whitespace characters */

		if (ret >= MAX_INDENT)
			return MAX_INDENT;
	}

	/* The line contains only whitespace. */
	return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %r14, %r14
jle 0x2959
movq 0x8(%rdi), %r15
callq 0x1140
movq (%rax), %rax
xorl %esi, %esi
movl $0xc8, %ecx
xorl %edx, %edx
movzbl (%r15,%rdx), %r8d
testb $0x20, 0x1(%rax,%r8,2)
jne 0x291a
xorl %r8d, %r8d
movl %esi, %edi
jmp 0x2948
cmpl $0x9, %r8d
je 0x292a
cmpl $0x20, %r8d
jne 0x293f
incl %esi
jmp 0x293f
leal 0x7(%rsi), %r8d
testl %esi, %esi
cmovnsl %esi, %r8d
andl $-0x8, %r8d
addl $0x8, %r8d
movl %r8d, %esi
cmpl %ecx, %esi
setl %r8b
cmovgel %ecx, %edi
testb %r8b, %r8b
je 0x2957
incq %rdx
cmpq %rdx, %r14
jne 0x2906
jmp 0x2959
movl %edi, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/LemonBoy[P]autobahn/xdiff/xpatience.c
// Function: insert_record
static void insert_record(int line, struct hashmap *map, int pass)
{
	xrecord_t **records = pass == 1 ?
		map->env->xdf1.recs : map->env->xdf2.recs;
	xrecord_t *record = records[line - 1], *other;
	/*
	 * After xdl_prepare_env() (or more precisely, due to
	 * xdl_classify_record()), the "ha" member of the records (AKA lines)
	 * is _not_ the hash anymore, but a linearized version of it.  In
	 * other words, the "ha" member is guaranteed to start with 0 and
	 * the second record's ha can only be 0 or 1, etc.
	 *
	 * So we multiply ha by 2 in the hope that the hashing was
	 * "unique enough".
	 */
	int index = (int)((record->ha << 1) % map->alloc);

	while (map->entries[index].line1) {
		other = map->env->xdf1.recs[map->entries[index].line1 - 1];
		if (map->entries[index].hash != record->ha ||
				!xdl_recmatch(record->ptr, record->size,
					other->ptr, other->size,
					map->xpp->flags)) {
			if (++index >= map->alloc)
				index = 0;
			continue;
		}
		if (pass == 2)
			map->has_matches = 1;
		if (pass == 1 || map->entries[index].line2)
			map->entries[index].line2 = NON_UNIQUE;
		else
			map->entries[index].line2 = line;
		return;
	}
	if (pass == 2)
		return;
	map->entries[index].line1 = line;
	map->entries[index].hash = record->ha;
	if (!map->first)
		map->first = map->entries + index;
	if (map->last) {
		map->last->next = map->entries + index;
		map->entries[index].previous = map->last;
	}
	map->last = map->entries + index;
	map->nr++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
cmpl $0x1, %edx
movq 0x8(%rsi), %rcx
movl $0x60, %eax
movl $0xe8, %edx
cmoveq %rax, %rdx
movq 0x38(%rsi), %rax
movq (%rax,%rdx), %rax
movslq %edi, %r15
movq -0x8(%rax,%r15,8), %r13
movq 0x18(%r13), %rax
addq %rax, %rax
movslq 0x4(%rsi), %rsi
xorl %edx, %edx
divq %rsi
movq %rdx, %r14
movslq %r14d, %r12
leaq (%r12,%r12,4), %rax
leaq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0x2f5b
movq (%rax), %rax
cmpq 0x18(%r13), %rax
jne 0x2f49
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %r8
movq 0x60(%rax), %rax
movq -0x8(%rax,%rdx,8), %rax
movq 0x8(%r13), %rdi
movq 0x10(%r13), %rsi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
movq (%r8), %r8
callq 0x44b5
testl %eax, %eax
jne 0x2f94
incl %r14d
cmpl 0x4(%rbx), %r14d
jl 0x2f55
xorl %r14d, %r14d
movq 0x8(%rbx), %rcx
jmp 0x2eff
cmpl $0x2, %ebp
je 0x2fc7
movq %r15, 0x8(%rax)
movq 0x18(%r13), %rdx
movq %rdx, (%rax)
cmpq $0x0, 0x10(%rbx)
jne 0x2f76
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdx
testq %rdx, %rdx
je 0x2f8c
movq %rax, 0x18(%rdx)
leaq (%r12,%r12,4), %rsi
movq %rdx, 0x20(%rcx,%rsi,8)
movq %rax, 0x18(%rbx)
incl (%rbx)
jmp 0x2fc7
cmpl $0x2, %ebp
jne 0x2fa1
movq $0x1, 0x20(%rbx)
cmpl $0x1, %ebp
je 0x2fb6
movq 0x8(%rbx), %rax
leaq (%r12,%r12,4), %rcx
cmpq $0x0, 0x10(%rax,%rcx,8)
je 0x2fd6
movq 0x8(%rbx), %rax
leaq (%r12,%r12,4), %rcx
movq $-0x1, 0x10(%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq (%rax,%rcx,8), %rax
addq $0x10, %rax
movq %r15, (%rax)
jmp 0x2fc7
nop
// File: /workspace/github_c_makefile_star2_O1/LemonBoy[P]autobahn/xdiff/xemit.c
// Function: xdl_get_hunk
xdchange_t *xdl_get_hunk(xdchange_t **xscr, xdemitconf_t const *xecfg)
{
	xdchange_t *xch, *xchp, *lxch;
	long max_common = 2 * xecfg->ctxlen + xecfg->interhunkctxlen;
	long max_ignorable = xecfg->ctxlen;
	unsigned long ignored = 0; /* number of ignored blank lines */

	/* remove ignorable changes that are too far before other changes */
	for (xchp = *xscr; xchp && xchp->ignore; xchp = xchp->next) {
		xch = xchp->next;

		if (xch == NULL ||
		    xch->i1 - (xchp->i1 + xchp->chg1) >= max_ignorable)
			*xscr = xch;
	}

	if (*xscr == NULL)
		return NULL;

	lxch = *xscr;

	for (xchp = *xscr, xch = xchp->next; xch; xchp = xch, xch = xch->next) {
		long distance = xch->i1 - (xchp->i1 + xchp->chg1);
		if (distance > max_common)
			break;

		if (distance < max_ignorable && (!xch->ignore || lxch == xchp)) {
			lxch = xch;
			ignored = 0;
		} else if (distance < max_ignorable && xch->ignore) {
			ignored += xch->chg2;
		} else if (lxch != xchp &&
			   xch->i1 + ignored - (lxch->i1 + lxch->chg1) > max_common) {
			break;
		} else if (!xch->ignore) {
			lxch = xch;
			ignored = 0;
		} else {
			ignored += xch->chg2;
		}
	}

	return lxch;
}

// Assembly:
movq (%rsi), %rcx
leaq (%rcx,%rcx), %rdx
addq 0x8(%rsi), %rdx
movq (%rdi), %rax
testq %rax, %rax
je 0x3021
cmpl $0x0, 0x28(%rax)
je 0x3021
movq (%rax), %rsi
testq %rsi, %rsi
je 0x3019
movq 0x8(%rsi), %r8
movq 0x8(%rax), %r9
addq 0x18(%rax), %r9
subq %r9, %r8
cmpq %rcx, %r8
jl 0x301c
movq %rsi, (%rdi)
movq (%rax), %rax
jmp 0x2ff2
movq (%rdi), %rax
testq %rax, %rax
je 0x30a3
xorl %edi, %edi
movq %rax, %rsi
movq %rsi, %r8
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x30a2
movq 0x8(%r8), %r11
addq 0x18(%r8), %r11
movq 0x8(%rsi), %r9
movq %r9, %r10
subq %r11, %r10
cmpq %rdx, %r10
jle 0x3055
xorl %r8d, %r8d
jmp 0x309d
cmpq %rcx, %r10
jge 0x3078
cmpl $0x0, 0x28(%rsi)
sete %r9b
cmpq %r8, %rax
sete %r8b
orb %r9b, %r8b
je 0x3096
movb $0x1, %r8b
movq %rsi, %rax
xorl %edi, %edi
jmp 0x309d
cmpq %r8, %rax
je 0x3090
movq 0x8(%rax), %r8
addq %rdi, %r9
addq 0x18(%rax), %r8
subq %r8, %r9
cmpq %rdx, %r9
ja 0x3050
cmpl $0x0, 0x28(%rsi)
je 0x306e
addq 0x20(%rsi), %rdi
movb $0x1, %r8b
testb %r8b, %r8b
jne 0x302e
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/LemonBoy[P]autobahn/xdiff/xemit.c
// Function: is_empty_rec
static int is_empty_rec(xdfile_t *xdf, long ri)
{
	const char *rec;
	long len = xdl_get_rec(xdf, ri, &rec);

	while (len > 0 && XDL_ISSPACE(*rec)) {
		rec++;
		len--;
	}
	return !len;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x60(%rdi), %rax
movq (%rax,%rsi,8), %rax
movq 0x10(%rax), %rbx
testq %rbx, %rbx
jle 0x364d
movq 0x8(%rax), %r14
callq 0x1140
movq (%rax), %rax
movzbl (%r14), %ecx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x364d
incq %r14
leaq -0x1(%rbx), %rcx
cmpq $0x1, %rbx
movq %rcx, %rbx
jg 0x3630
xorl %ebx, %ebx
xorl %eax, %eax
testq %rbx, %rbx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/LemonBoy[P]autobahn/xdiff/xemit.c
// Function: match_func_rec
static long match_func_rec(xdfile_t *xdf, xdemitconf_t const *xecfg, long ri,
			   char *buf, long sz)
{
	const char *rec;
	long len = xdl_get_rec(xdf, ri, &rec);
	if (!xecfg->find_func)
		return def_ff(rec, len, buf, sz, xecfg->find_func_priv);
	return xecfg->find_func(rec, len, buf, sz, xecfg->find_func_priv);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r13
movq %rcx, %rbx
movq 0x60(%rdi), %rax
movq (%rax,%rdx,8), %rax
movq 0x8(%rax), %r14
movq 0x10(%rax), %r15
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0x36a0
movq 0x20(%rsi), %r8
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r13, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
movq $-0x1, %r12
testq %r15, %r15
jle 0x3705
callq 0x1140
movq (%rax), %rax
movzbl (%r14), %ecx
movzwl (%rax,%rcx,2), %edx
btl $0xa, %edx
jb 0x36cc
cmpl $0x5f, %ecx
je 0x36cc
cmpl $0x24, %ecx
jne 0x3705
cmpq %r13, %r15
cmovgeq %r13, %r15
testq %r13, %r13
jle 0x36f4
movzbl -0x1(%r14,%r15), %ecx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x36f4
leaq -0x1(%r15), %r12
cmpq $0x1, %r15
movq %r12, %r15
jg 0x36d8
jmp 0x36f7
movq %r15, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x10d0
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/LemonBoy[P]autobahn/xdiff/xemit.c
// Function: get_func_line
static long get_func_line(xdfenv_t *xe, xdemitconf_t const *xecfg,
			  struct func_line *func_line, long start, long limit)
{
	long l, size, step = (start > limit) ? -1 : 1;
	char *buf, dummy[1];

	buf = func_line ? func_line->buf : dummy;
	size = func_line ? sizeof(func_line->buf) : sizeof(dummy);

	for (l = start; l != limit && 0 <= l && l < xe->xdf1.nrec; l += step) {
		long len = match_func_rec(&xe->xdf1, xecfg, l, buf, size);
		if (len >= 0) {
			if (func_line)
				func_line->len = len;
			return l;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, 0x20(%rsp)
leaq 0x8(%rdx), %rax
testq %rdx, %rdx
leaq 0xf(%rsp), %rcx
cmovneq %rax, %rcx
movq %rcx, 0x18(%rsp)
movl $0x1, %eax
movl $0x50, %r12d
cmoveq %rax, %r12
xorl %eax, %eax
cmpq %r8, %r14
setle %cl
sete %dl
testq %r14, %r14
sets %sil
movq $-0x1, %rbx
orb %dl, %sil
jne 0x37d2
movq %r8, %rbp
movq %rdi, %r13
movb %cl, %al
leaq -0x1(,%rax,2), %rax
movq %rax, 0x10(%rsp)
subq %rax, %rbp
cmpq 0x38(%r13), %r14
jge 0x37cb
movq %r13, %rdi
movq 0x20(%rsp), %rsi
movq %r14, %rdx
movq 0x18(%rsp), %rcx
movq %r12, %r8
callq 0x365d
testq %rax, %rax
cmovnsq %r14, %rbx
testq %r15, %r15
je 0x37ba
testq %rax, %rax
js 0x37ba
movq %rax, (%r15)
movq %r14, %rbx
testq %rax, %rax
jns 0x37d2
cmpq %r14, %rbp
je 0x37cb
addq 0x10(%rsp), %r14
jns 0x3785
movq $-0x1, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LemonBoy[P]autobahn/xdiff/xprepare.c
// Function: xdl_free_ctx
static void xdl_free_ctx(xdfile_t *xdf) {

	xdl_free(xdf->rhash);
	xdl_free(xdf->rindex);
	xdl_free(xdf->rchg - 1);
	xdl_free(xdf->ha);
	xdl_free(xdf->recs);
	xdl_cha_free(&xdf->rcha);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
callq 0x1030
movq 0x70(%rbx), %rdi
callq 0x1030
movq 0x68(%rbx), %rdi
decq %rdi
callq 0x1030
movq 0x80(%rbx), %rdi
callq 0x1030
movq 0x60(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
popq %rbx
jmp 0x433f
// File: /workspace/github_c_makefile_star2_O1/LemonBoy[P]autobahn/xdiff/xprepare.c
// Function: xdl_clean_mmatch
static int xdl_clean_mmatch(char const *dis, long i, long s, long e) {
	long r, rdis0, rpdis0, rdis1, rpdis1;

	/*
	 * Limits the window the is examined during the similar-lines
	 * scan. The loops below stops when dis[i - r] == 1 (line that
	 * has no match), but there are corner cases where the loop
	 * proceed all the way to the extremities by causing huge
	 * performance penalties in case of big files.
	 */
	if (i - s > XDL_SIMSCAN_WINDOW)
		s = i - XDL_SIMSCAN_WINDOW;
	if (e - i > XDL_SIMSCAN_WINDOW)
		e = i + XDL_SIMSCAN_WINDOW;

	/*
	 * Scans the lines before 'i' to find a run of lines that either
	 * have no match (dis[j] == 0) or have multiple matches (dis[j] > 1).
	 * Note that we always call this function with dis[i] > 1, so the
	 * current line (i) is already a multimatch line.
	 */
	for (r = 1, rdis0 = 0, rpdis0 = 1; (i - r) >= s; r++) {
		if (!dis[i - r])
			rdis0++;
		else if (dis[i - r] == 2)
			rpdis0++;
		else
			break;
	}
	/*
	 * If the run before the line 'i' found only multimatch lines, we
	 * return 0 and hence we don't make the current line (i) discarded.
	 * We want to discard multimatch lines only when they appear in the
	 * middle of runs with nomatch lines (dis[j] == 0).
	 */
	if (rdis0 == 0)
		return 0;
	for (r = 1, rdis1 = 0, rpdis1 = 1; (i + r) <= e; r++) {
		if (!dis[i + r])
			rdis1++;
		else if (dis[i + r] == 2)
			rpdis1++;
		else
			break;
	}
	/*
	 * If the run after the line 'i' found only multimatch lines, we
	 * return 0 and hence we don't make the current line (i) discarded.
	 */
	if (rdis1 == 0)
		return 0;
	rdis1 += rdis0;
	rpdis1 += rpdis0;

	return rpdis1 * XDL_KPDIS_RUN < (rpdis1 + rdis1);
}

// Assembly:
movq %rsi, %rax
subq %rdx, %rax
leaq -0x64(%rsi), %r9
cmpq $0x65, %rax
cmovlq %rdx, %r9
movq %rcx, %rax
subq %rsi, %rax
leaq 0x64(%rsi), %r8
cmpq $0x65, %rax
cmovlq %rcx, %r8
xorl %eax, %eax
cmpq %rsi, %r9
jge 0x4234
leaq -0x1(%rsi), %r10
movl $0x1, %ecx
xorl %edx, %edx
movzbl (%rdi,%r10), %r11d
cmpl $0x2, %r11d
je 0x4227
testl %r11d, %r11d
jne 0x423b
incq %rdx
jmp 0x422a
incq %rcx
decq %r10
cmpq %r9, %r10
jge 0x4212
jmp 0x423b
movl $0x1, %ecx
xorl %edx, %edx
testq %rdx, %rdx
je 0x4298
xorl %eax, %eax
cmpq %rsi, %r8
jle 0x4275
incq %rsi
movl $0x1, %r9d
xorl %r10d, %r10d
movzbl (%rdi,%rsi), %r11d
cmpl $0x2, %r11d
je 0x4268
testl %r11d, %r11d
jne 0x427e
incq %r10
jmp 0x426b
incq %r9
incq %rsi
cmpq %r8, %rsi
jle 0x4253
jmp 0x427e
movl $0x1, %r9d
xorl %r10d, %r10d
testq %r10, %r10
je 0x4298
addq %rdx, %r10
addq %rcx, %r9
addq %r9, %r10
shlq $0x2, %r9
xorl %eax, %eax
cmpq %r10, %r9
setl %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/LemonBoy[P]autobahn/xdiff/xutils.c
// Function: xdl_bogosqrt
long xdl_bogosqrt(long n) {
	long i;

	/*
	 * Classical integer square root approximation using shifts.
	 */
	for (i = 1; n > 0; n >>= 2)
		i <<= 1;

	return i;
}

// Assembly:
movl $0x1, %eax
testq %rdi, %rdi
jle 0x42b9
movq %rdi, %rcx
addq %rax, %rax
shrq $0x2, %rcx
cmpq $0x3, %rdi
movq %rcx, %rdi
ja 0x42a9
retq