LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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, 0x92fe(%rip)      # 0x1ab8c
je 0x118fc
movq 0x117d9(%rip), %rax     # 0x23070
movslq 0x117da(%rip), %rcx     # 0x23078
imulq $0x30, %rcx, %rcx
movq (%rax,%rcx), %rsi
leaq 0x2509(%rip), %rdi      # 0x13db6
pushq $0x1
popq %rdx
callq 0x4200
movl 0x7c0d(%rip), %eax      # 0x194c8
shrl $0xd, %eax
andl $0x7, %eax
imulq $0x2138, %rax, %rax     # imm = 0x2138
leaq 0x92c1(%rip), %rcx      # 0x1ab90
leaq (%rax,%rcx), %rdi
addq $0x2000, %rdi           # imm = 0x2000
movq 0x1178f(%rip), %rax     # 0x23070
movslq 0x11790(%rip), %rcx     # 0x23078
imulq $0x30, %rcx, %rcx
movq (%rax,%rcx), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x6016
jmp 0x1192c
movl 0x7bc6(%rip), %eax      # 0x194c8
shrl $0xd, %eax
andl $0x7, %eax
imulq $0x2138, %rax, %rax     # imm = 0x2138
leaq 0x927a(%rip), %rcx      # 0x1ab90
cmpb $0x0, 0x2000(%rax,%rcx)
je 0x1192c
addq %rcx, %rax
addq $0x2000, %rax           # imm = 0x2000
movb $0x0, (%rax)
pushq $-0x4
popq %r13
leaq 0xb259(%rip), %r14      # 0x1cb90
leaq 0xc(%rsp), %r15
pushq $0x1
popq %rbp
leaq 0x7e0a(%rip), %r12      # 0x19750
testq %r13, %r13
je 0x119a4
testb $0x2, 0x131(%r14)
je 0x11998
leaq -0x2000(%r14), %rbx
leal 0x35(%r13), %eax
movb %al, 0x9(%rsp)
movb %al, 0xd(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x4200
cmpb $0x0, (%r14)
je 0x11998
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6a9f
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x4200
incq %r13
addq $0x2138, %r14           # imm = 0x2138
jmp 0x11946
movl 0x7b1e(%rip), %edi      # 0x194c8
shrl $0x6, %edi
andl $0x1, %edi
callq 0x5d9b
leaq 0x28fe(%rip), %rdi      # 0x142ba
pushq $0x1
popq %rbx
movq %rax, %rsi
movl %ebx, %edx
callq 0x4200
movl 0x7af9(%rip), %edi      # 0x194c8
shrl $0x10, %edi
andl $0x1, %edi
callq 0x5d9b
leaq 0x28ec(%rip), %rdi      # 0x142cd
movq %rax, %rsi
movl %ebx, %edx
callq 0x4200
leaq 0x1dbe(%rip), %rdi      # 0x137b0
movq 0x10(%rsp), %rsi
movl %ebx, %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_O2/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 0x7d33(%rip), %r14      # 0x19750
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
callq 0x6016
movq %r14, %rdi
callq 0x5d70
cmpq $0x2, %rax
jb 0x11a49
cmpb $0x2a, -0x1(%rax,%r14)
jne 0x11a49
andb $-0x11, %bl
movb $0x0, -0x1(%rax,%r14)
testb %bl, %bl
js 0x11a6f
movzbl %bl, %r8d
leaq 0x2402(%rip), %rdi      # 0x13e5a
leaq 0x7cf1(%rip), %rsi      # 0x19750
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xdcb4
leaq 0x23e4(%rip), %rdi      # 0x13e5a
leaq 0x7cd3(%rip), %rsi      # 0x19750
pushq $-0x1
popq %rcx
pushq $0x1
popq %r8
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf969
// File: /workspace/github_c_makefile_star2_O2/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 0x7cab(%rip), %r14      # 0x19750
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4460
movq %rax, %r15
cmpq $-0x1, %rax
jne 0x11ac5
callq 0x40c0
cmpl $0x4, (%rax)
je 0x11aa5
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x79ef(%rip), %ecx      # 0x194c8
shrl $0xd, %ecx
andl $0x7, %ecx
leaq 0x90aa(%rip), %rdx      # 0x1ab90
movl %ecx, %eax
movl %eax, %esi
incl %esi
movl %esi, %eax
andl $0x1fb, %eax            # imm = 0x1FB
andl $0xfb, %esi
imulq $0x2138, %rsi, %rdi     # imm = 0x2138
testb $0x2, 0x2131(%rdi,%rdx)
je 0x11b0e
cmpl %ecx, %esi
jne 0x11ae8
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x11b88
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5d70
movq %rax, %r14
leaq 0x2883(%rip), %rdi      # 0x143d7
callq 0x5d70
subq %rax, %r14
jb 0x11b7e
cmpb $0x2e, (%rbx,%r14)
jne 0x11b7e
addq %r14, %rbx
leaq 0x2868(%rip), %rsi      # 0x143d7
movq %rbx, %rdi
callq 0x44d0
testl %eax, %eax
sete %al
jmp 0x11b80
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
testb $0x2, 0x792b(%rip)      # 0x194cb
je 0x11bbb
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x6a94
testl %eax, %eax
je 0x11bbb
pushq $-0x1
popq %rax
jmp 0x11cb5
leaq 0x40(%rsp), %rax
leaq 0x30(%rsp), %rbx
movq %rax, (%rbx)
movq %r14, 0x8(%rbx)
xorl %ebp, %ebp
movl 0x8fb8(%rip), %eax      # 0x1ab8c
cmpl %eax, %ebp
jge 0x11c7d
movq 0x1148d(%rip), %rax     # 0x23070
movslq %ebp, %rcx
imulq $0x30, %rcx, %r14
movq (%rax,%r14), %rsi
movq %rbx, %rdi
callq *0x78a1(%rip)           # 0x19498
testl %eax, %eax
jne 0x11c76
movslq 0x8f8a(%rip), %rax      # 0x1ab8c
decq %rax
movl %eax, 0x8f81(%rip)      # 0x1ab8c
cmpl %eax, %ebp
je 0x11c76
movq 0x1145a(%rip), %rcx     # 0x23070
imulq $0x30, %rax, %rax
movups (%rcx,%r14), %xmm0
movups 0x10(%rcx,%r14), %xmm1
movups 0x20(%rcx,%r14), %xmm2
movaps %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%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 (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movups %xmm2, 0x20(%rcx,%rax)
movups %xmm1, 0x10(%rcx,%rax)
movups %xmm0, (%rcx,%rax)
decl %ebp
incl %ebp
jmp 0x11bce
testb $0x2, 0x7847(%rip)      # 0x194cb
je 0x11c96
leaq 0x40(%rsp), %rdi
callq 0x42a0
movl 0x8ef6(%rip), %eax      # 0x1ab8c
movq 0x113d3(%rip), %rdi     # 0x23070
movslq %eax, %rsi
movq 0x7839(%rip), %rcx      # 0x194e0
pushq $0x30
popq %rdx
callq 0x4150
movl 0x8ed7(%rip), %eax      # 0x1ab8c
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x72b9(%rip), %r12      # 0x18f90
movq (%r12), %rdi
movl 0x77e7(%rip), %esi      # 0x194c8
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 0x1179c
movl %eax, %ebp
movl 0x77b3(%rip), %eax      # 0x194c8
btl $0x11, %eax
jae 0x11d8d
cmpl $0x0, 0x8e6a(%rip)      # 0x1ab8c
je 0x11d8d
movq 0x11345(%rip), %rax     # 0x23070
movslq 0x11346(%rip), %rcx     # 0x23078
imulq $0x30, %rcx, %rcx
movq (%rax,%rcx), %rdx
leaq 0x256e(%rip), %rdi      # 0x142af
leaq 0x2733(%rip), %rsi      # 0x1447b
pushq $-0x1
popq %rcx
xorl %r8d, %r8d
callq 0xf969
testb %al, %al
je 0x11d87
movq (%r12), %rdi
movzwl 0x8e26(%rip), %esi      # 0x1ab88
addl $-0x2, %esi
pushq $0x2
popq %rdx
callq 0x4070
cmpl $-0x1, %eax
je 0x11de0
movq (%r12), %rdi
leaq 0x79d3(%rip), %rsi      # 0x19750
pushq $-0x1
popq %rdx
callq 0x41c0
jmp 0x11de0
movl 0x773b(%rip), %eax      # 0x194c8
movslq %ebp, %rcx
leaq (%rsp,%rcx), %rdi
pushq $0x2f
popq %rdx
subl %ecx, %edx
btl $0x19, %eax
leaq 0x26bf(%rip), %rax      # 0x14463
leaq 0x26b4(%rip), %rcx      # 0x1445f
cmovaeq %rax, %rcx
movslq %edx, %rsi
movq 0x7717(%rip), %rax      # 0x194d0
cmpq 0x7208(%rip), %rax      # 0x18fc8
leaq 0x26a2(%rip), %rax      # 0x14469
leaq 0x2699(%rip), %r8       # 0x14467
cmoveq %rax, %r8
leaq 0x2675(%rip), %rdx      # 0x1444e
xorl %eax, %eax
callq 0x4350
movq (%r12), %r14
movzwl 0x8d9d(%rip), %ebp      # 0x1ab88
addl $-0x2, %ebp
movzwl 0x114a2(%rip), %r15d    # 0x23298
movq %rsp, %rdi
callq 0x5d70
subl %eax, %r15d
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x4070
cmpl $-0x1, %eax
je 0x11e22
movq (%r12), %rdi
movq %rsp, %rsi
pushq $-0x1
popq %rdx
callq 0x41c0
movq %rbx, %rdi
callq 0xd631
movq (%r12), %rdi
movl 0x7694(%rip), %esi      # 0x194c8
shrl $0x5, %esi
andl $0x700, %esi            # imm = 0x700
addl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x4730
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x712b(%rip), %r14      # 0x18f90
movq (%r14), %rdi
xorl %esi, %esi
callq 0x4560
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x48d0
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x11e87
movl $0x1b, (%rbx)
movq (%r14), %rdi
pushq $-0x1
popq %rsi
callq 0x4560
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
xorl %r12d, %r12d
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4460
testq %rax, %rax
jle 0x11edb
movq %rax, %rcx
subq $0x1, %rcx
jb 0x11eae
xorl %edx, %edx
cmpb %bl, -0x1(%r15,%rax)
sete %dl
addl %edx, %r12d
movq %rcx, %rax
jmp 0x11ec3
cmpb $0x1, %bl
adcl $0x0, %r12d
xorl %ecx, %ecx
testq %rax, %rax
cmovel %r12d, %ecx
movl %ecx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movl 0x8b00(%rip), %esi      # 0x1aa70
addq %rdi, %rsi
movl 0x11153(%rip), %eax     # 0x230cc
cmpq %rax, %rsi
jbe 0x11fa8
addl $0xfff, %esi            # imm = 0xFFF
andl $0xfffff000, %esi       # imm = 0xFFFFF000
movl %esi, 0x1113c(%rip)     # 0x230cc
movq 0x8ae1(%rip), %rdi      # 0x1aa78
callq 0xd572
movq %rax, 0x8ad5(%rip)      # 0x1aa78
testq %rax, %rax
je 0x11faa
popq %rax
retq
movl $0x674, %edi            # imm = 0x674
callq 0xe555
// File: /workspace/github_c_makefile_star2_O2/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 0x1200b
cmpl $0x0, 0x112de(%rip)     # 0x232ac
jne 0x1200b
movq 0x7551(%rip), %rdi      # 0x19528
xorl %esi, %esi
xorl %eax, %eax
callq 0x46b0
cmpl $-0x1, %eax
je 0x120ad
movl %eax, %r14d
movq %rsp, %rsi
movl $0x12c, %edx            # imm = 0x12C
movl %eax, %edi
xorl %ecx, %ecx
callq 0x11e99
movl %eax, 0x112a9(%rip)     # 0x232ac
movl %r14d, %edi
callq 0x43c0
leaq 0x1e84(%rip), %rax      # 0x13e96
leaq 0x2519(%rip), %rcx      # 0x14532
testb %bl, %bl
cmovneq %rax, %rcx
leaq 0x2236(%rip), %rdx      # 0x1425c
movq %rsp, %rdi
pushq $0x14
popq %rsi
xorl %eax, %eax
callq 0x4350
cltq
leaq (%rsp,%rax), %rdi
testb %bpl, %bpl
je 0x12059
movl 0x11268(%rip), %ecx     # 0x232ac
leaq 0x24ee(%rip), %rdx      # 0x14539
movl $0x118, %esi            # imm = 0x118
xorl %eax, %eax
callq 0x4350
jmp 0x12082
movq 0x11010(%rip), %rax     # 0x23070
movslq 0x11011(%rip), %rcx     # 0x23078
imulq $0x30, %rcx, %rcx
movq (%rax,%rcx), %rcx
leaq 0x24d0(%rip), %rdx      # 0x14546
movl $0x118, %esi            # imm = 0x118
xorl %eax, %eax
callq 0x4350
movq %rsp, %rdi
callq 0xfb15
cmpl $0x1b, %eax
je 0x120c1
movl %eax, %ecx
andl $-0x21, %ecx
movb $0x66, %al
cmpl $0x59, %ecx
je 0x120c3
xorl %edx, %edx
testb %bl, %bl
pushq $0x69
popq %rax
cmovnel %edx, %eax
cmpl $0x4e, %ecx
cmovel %edx, %eax
jmp 0x120c3
callq 0x40c0
movl (%rax), %edi
callq 0x4870
movq %rax, %rdi
callq 0xd5b9
xorl %eax, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17f6
testl %eax, %eax
jne 0x1392
movq 0x10(%rsp), %rdi
leaq 0xfb(%rip), %r8         # 0x1419
leaq 0xc(%rsp), %rdx
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x20f2
testl %eax, %eax
jne 0x139d
movl 0xc(%rsp), %edi
leaq 0xb(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x10f0
cmpq $0x1, %rax
jne 0x13a8
cmpb $0x72, 0xb(%rsp)
jne 0x13b3
movq 0x10(%rsp), %rdi
pushq $0xa
popq %rsi
callq 0x22d7
testl %eax, %eax
jne 0x13be
movl 0xc(%rsp), %edi
leaq 0xb(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x10f0
cmpq $0x1, %rax
jne 0x13c9
cmpb $0x73, 0xb(%rsp)
jne 0x13d4
movq 0x10(%rsp), %rdi
callq 0x2296
testl %eax, %eax
jne 0x13df
xorl %eax, %eax
addq $0x18, %rsp
retq
leaq 0x1c6b(%rip), %rdi      # 0x3004
pushq $0x14
jmp 0x13e8
leaq 0x1c96(%rip), %rdi      # 0x303a
pushq $0x1e
jmp 0x13e8
leaq 0x1cd4(%rip), %rdi      # 0x3083
pushq $0x22
jmp 0x13e8
leaq 0x1ce5(%rip), %rdi      # 0x309f
pushq $0x23
jmp 0x13e8
leaq 0x1ce3(%rip), %rdi      # 0x30a8
pushq $0x25
jmp 0x13e8
leaq 0x1cb3(%rip), %rdi      # 0x3083
pushq $0x27
jmp 0x13e8
leaq 0x1cfd(%rip), %rdi      # 0x30d8
pushq $0x28
jmp 0x13e8
leaq 0x1cfb(%rip), %rdi      # 0x30e1
pushq $0x2a
popq %rsi
callq 0x13ee
// File: /workspace/github_c_makefile_star2_O2/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, 0x4cf2(%rip)      # 0x6114
leaq 0x4a(%rip), %rsi        # 0x1473
pushq $0xa
popq %rdi
callq 0x1100
cmpq $-0x1, %rax
je 0x1459
leaq 0x2267(%rip), %rsi      # 0x36a5
pushq $0x1
popq %rdx
movl %ebx, %edi
callq 0x1080
cmpq $0x1, %rax
jne 0x1464
movl $0x3e7, %edi            # imm = 0x3E7
popq %rbx
jmp 0x11e0
leaq 0x1cc0(%rip), %rdi      # 0x3120
pushq $0xd
jmp 0x146d
leaq 0x1ce6(%rip), %rdi      # 0x3151
pushq $0xe
popq %rsi
callq 0x13ee
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rbp
testq %rax, %rax
jle 0x1f84
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 0x244e
testl %eax, %eax
je 0x1f84
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
decq %rcx
cmpb $0x0, (%rax,%rcx)
je 0x1f82
movq %rcx, (%rbx)
jmp 0x1f74
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r13
movq %rdi, %r15
movq 0x38(%rdi), %r12
cmpq %rsi, %r12
jle 0x202f
andl $0x0, (%rbx)
movq 0x60(%r15), %rax
movq (%rax,%r13,8), %rdi
callq 0x2487
jmp 0x2038
movl $0x1, (%rbx)
pushq $-0x1
popq %rax
movl %eax, 0x4(%rbx)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x8(%rbx)
pushq $0x1
popq %rbp
movq %r13, %r14
testq %r14, %r14
jle 0x207b
movq 0x60(%r15), %rax
movq -0x8(%rax,%r14,8), %rdi
callq 0x2487
movl %eax, 0xc(%rbx)
cmpl $-0x1, %eax
jne 0x207b
movl %ebp, 0x8(%rbx)
incl %ebp
decq %r14
cmpl $0x15, %ebp
jne 0x204f
andl $0x0, 0xc(%rbx)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x10(%rbx)
incq %r13
pushq $0x1
popq %rbp
cmpq %r12, %r13
jge 0x20ba
movq 0x60(%r15), %rax
movq (%rax,%r13,8), %rdi
callq 0x2487
movl %eax, 0x14(%rbx)
cmpl $-0x1, %eax
jne 0x20ba
movl %ebp, 0x10(%rbx)
incl %ebp
incq %r13
cmpl $0x15, %ebp
jne 0x208f
andl $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_O2/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 $0x18, %rsp
movq %rsi, 0x8(%rsp)
movq 0x38(%rdi), %r14
movq 0x68(%rdi), %r12
movq 0xf0(%rdi), %r13
movq 0xc0(%rdi), %rbx
xorl %ecx, %ecx
pushq $-0x1
popq %r15
testq %rbx, %r14
js 0x2217
cmpb $0x0, -0x1(%r12,%r14)
jne 0x21b0
cmpb $0x0, -0x1(%r13,%rbx)
jne 0x21b0
decq %r14
decq %rbx
jmp 0x2193
movq %r15, %rbp
incq %rbp
cmpb $0x0, -0x1(%r12,%r14)
leaq -0x1(%r14), %r14
jne 0x21b3
movq %rcx, (%rsp)
leaq 0x1(%r14), %rax
movq %rax, 0x10(%rsp)
incq %r15
cmpb $0x0, -0x1(%r13,%rbx)
leaq -0x1(%rbx), %rbx
jne 0x21cf
pushq $0x30
popq %rdi
callq 0x10f0
testq %rax, %rax
je 0x2230
leaq 0x1(%rbx), %rcx
movq (%rsp), %rdx
movq %rdx, (%rax)
movq 0x10(%rsp), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rbp, 0x18(%rax)
movq %r15, 0x20(%rax)
andl $0x0, 0x28(%rax)
movq %rax, %rcx
jmp 0x218f
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rdi
callq 0x223e
pushq $-0x1
popq %rax
jmp 0x2221
// File: /workspace/github_c_makefile_star2_O2/LemonBoy[P]autobahn/xdiff/xdiffi.c
// Function: xdl_free_script
void xdl_free_script(xdchange_t *xscr) {
	xdchange_t *xch;

	while ((xch = xscr) != NULL) {
		xscr = xscr->next;
		xdl_free(xch);
	}
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x2251
movq (%rdi), %rbx
callq 0x1030
movq %rbx, %rdi
jmp 0x223f
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x227d
leaq 0x8ab(%rip), %r15       # 0x2b26
jmp 0x2284
leaq 0x14a(%rip), %r15       # 0x23ce
leaq 0x28(%rsp), %rcx
movq %r12, %rdx
callq 0x1a70
testl %eax, %eax
js 0x2334
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
leaq 0xb0(%rsp), %r15
movq (%r12), %rdx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x1bf4
movq (%r12), %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x1bf4
leaq 0x20(%rsp), %rsi
movq %r13, %rdi
callq 0x2164
pushq $-0x1
popq %rbp
testl %eax, %eax
js 0x2328
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2326
movq %rax, (%rsp)
movq (%r12), %r12
testb %r12b, %r12b
js 0x234b
leaq 0x28(%rsp), %rdi
movq (%rsp), %r14
movq %r14, %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq *0x8(%rsp)
movl %eax, %ebx
movq %r14, %rdi
callq 0x223e
testl %ebx, %ebx
js 0x2328
xorl %ebp, %ebp
leaq 0x28(%rsp), %rdi
callq 0x3a52
jmp 0x2337
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %r13
movq (%rsp), %r15
testq %r15, %r15
je 0x22fe
movq 0x8(%r15), %r14
shlq $0x3, %r14
addq 0x88(%rsp), %r14
movl %r13d, %eax
xorl %ebx, %ebx
cmpq 0x18(%r15), %rbx
jge 0x2390
testl %eax, %eax
je 0x2390
movq (%r14,%rbx,8), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movq %r12, %rdx
callq 0x3c9f
incq %rbx
jmp 0x236d
movq 0x10(%r15), %r14
shlq $0x3, %r14
addq 0x110(%rsp), %r14
xorl %ebx, %ebx
cmpq 0x20(%r15), %rbx
jge 0x23c5
testl %eax, %eax
je 0x23c5
movq (%r14,%rbx,8), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movq %r12, %rdx
callq 0x3c9f
incq %rbx
jmp 0x23a2
movl %eax, 0x28(%r15)
movq (%r15), %r15
jmp 0x2353
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsp, %r15
pushq $-0x1
popq %r13
xorl %ebp, %ebp
movq %rsi, (%rsp)
testq %rsi, %rsi
je 0x243d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2a7c
movq %rax, %r12
movq (%rsp), %rax
testq %rax, %rax
je 0x243d
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rdx
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rcx
subq %rdi, %rsi
addq 0x18(%r12), %rsi
subq %rdx, %rcx
addq 0x20(%r12), %rcx
movq (%r14), %r8
callq *0x28(%rbx)
testl %eax, %eax
js 0x243a
movq (%r12), %rsi
jmp 0x23e8
movl %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_O2/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 0x2486
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 0x3d01
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10(%rdi), %r12
xorl %r13d, %r13d
testq %r12, %r12
cmovleq %r13, %r12
pushq $-0x1
popq %rbx
xorl %r15d, %r15d
cmpq %r13, %r12
je 0x24fd
movq 0x8(%r14), %rax
movzbl (%rax,%r13), %ebp
callq 0x1150
movq (%rax), %rax
testb $0x20, 0x1(%rax,%rbp,2)
je 0x24fa
cmpl $0x9, %ebp
je 0x24d5
cmpl $0x20, %ebp
jne 0x24e7
incl %r15d
jmp 0x24e7
movl %r15d, %eax
cltd
pushq $0x8
popq %rcx
idivl %ecx
negl %edx
addl %edx, %r15d
addl $0x8, %r15d
incq %r13
cmpl $0xc8, %r15d
jl 0x24a9
movl $0xc8, %ebx
jmp 0x24fd
movl %r15d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x60
popq %rax
movl $0xe8, %ecx
cmoveq %rax, %rcx
movq 0x38(%rsi), %rax
movq (%rax,%rcx), %rax
movslq %edi, %rcx
movq %rcx, (%rsp)
movq -0x8(%rax,%rcx,8), %r13
movq 0x18(%r13), %rax
addq %rax, %rax
movslq 0x4(%rsi), %rcx
xorl %r15d, %r15d
xorl %edx, %edx
divq %rcx
movq %rdx, %r14
movq 0x8(%rbx), %rdx
movslq %r14d, %rax
imulq $0x28, %rax, %r12
leaq (%rdx,%r12), %rax
movq 0x8(%rdx,%r12), %rsi
testq %rsi, %rsi
je 0x29bc
movq (%rax), %rax
cmpq 0x18(%r13), %rax
jne 0x29b0
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %r8
movq 0x60(%rax), %rax
movq -0x8(%rax,%rsi,8), %rax
movq 0x8(%r13), %rdi
movq 0x10(%r13), %rsi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
movq (%r8), %r8
callq 0x3d01
testl %eax, %eax
jne 0x29f5
movl 0x4(%rbx), %ecx
incl %r14d
cmpl %ecx, %r14d
cmovgel %r15d, %r14d
jmp 0x295e
cmpl $0x2, %ebp
je 0x2a31
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%r13), %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x10(%rbx)
jne 0x29db
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x29ed
movq %rax, 0x18(%rcx)
movq %rcx, 0x20(%rdx,%r12)
movq %rax, 0x18(%rbx)
incl (%rbx)
jmp 0x2a31
cmpl $0x2, %ebp
jne 0x2a04
movq $0x1, 0x20(%rbx)
jmp 0x2a0f
cmpl $0x1, %ebp
jne 0x2a0f
movq 0x8(%rbx), %rax
jmp 0x2a1b
movq 0x8(%rbx), %rax
cmpq $0x0, 0x10(%rax,%r12)
je 0x2a23
orq $-0x1, 0x10(%rax,%r12)
jmp 0x2a31
addq %r12, %rax
addq $0x10, %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/LemonBoy[P]autobahn/xdiff/xpatience.c
// Function: match
static int match(struct hashmap *map, int line1, int line2)
{
	xrecord_t *record1 = map->env->xdf1.recs[line1 - 1];
	xrecord_t *record2 = map->env->xdf2.recs[line2 - 1];
	return xdl_recmatch(record1->ptr, record1->size,
		record2->ptr, record2->size, map->xpp->flags);
}

// Assembly:
movslq %esi, %rax
movq 0x38(%rdi), %rcx
movq 0x40(%rdi), %r8
movq 0x60(%rcx), %rsi
movq 0xe8(%rcx), %rcx
movq -0x8(%rsi,%rax,8), %rax
movslq %edx, %rdx
movq -0x8(%rcx,%rdx,8), %rcx
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %rcx
movq (%r8), %r8
jmp 0x3d01
nop
// File: /workspace/github_c_makefile_star2_O2/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
movq (%rax), %rax
testq %rax, %rax
je 0x2ab9
cmpl $0x0, 0x28(%rax)
je 0x2ab9
movq (%rax), %rsi
testq %rsi, %rsi
je 0x2ab4
movq 0x8(%rsi), %r8
movq 0x8(%rax), %r9
addq 0x18(%rax), %r9
subq %r9, %r8
cmpq %rcx, %r8
jl 0x2a8a
movq %rsi, (%rdi)
jmp 0x2a8a
movq (%rdi), %rax
testq %rax, %rax
je 0x2b23
movq %rax, %r8
xorl %esi, %esi
movq (%r8), %rdi
testq %rdi, %rdi
je 0x2b25
movq 0x8(%r8), %r11
addq 0x18(%r8), %r11
movq 0x8(%rdi), %r9
movq %r9, %r10
subq %r11, %r10
cmpq %rdx, %r10
jg 0x2b25
cmpq %rcx, %r10
jge 0x2af7
cmpl $0x0, 0x28(%rdi)
je 0x2b1e
cmpq %r8, %rax
jne 0x2b15
jmp 0x2b1e
cmpq %r8, %rax
je 0x2b0f
movq 0x8(%rax), %r8
addq %rsi, %r9
addq 0x18(%rax), %r8
subq %r8, %r9
cmpq %rdx, %r9
ja 0x2b25
cmpl $0x0, 0x28(%rdi)
je 0x2b1e
addq 0x20(%rdi), %rsi
movq %rdi, %r8
jmp 0x2ac6
movq %rdi, %rax
jmp 0x2ac1
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x60(%rdi), %rax
movq (%rax,%rsi,8), %rax
movq 0x8(%rax), %r14
movq 0x10(%rax), %r15
movq %r15, %rbx
sarq $0x3f, %rbx
andq %r15, %rbx
pushq $0x1
popq %r12
testq %r15, %r15
jle 0x2ff0
callq 0x1150
movq (%rax), %rax
movzbl (%r14), %ecx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x2fed
incq %r14
decq %r15
jmp 0x2fcd
movq %r12, %rbx
xorl %eax, %eax
testq %rbx, %rbx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rcx, %rbx
movq 0x60(%rdi), %rax
movq (%rax,%rdx,8), %rax
movq 0x8(%rax), %r15
movq 0x10(%rax), %r13
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0x3047
movq 0x20(%rsi), %r8
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r14, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
pushq $-0x1
popq %r12
testq %r13, %r13
jle 0x30a9
callq 0x1150
movq (%rax), %rax
movzbl (%r15), %ecx
movzwl (%rax,%rcx,2), %edx
btl $0xa, %edx
jb 0x3070
cmpl $0x5f, %ecx
je 0x3070
cmpl $0x24, %ecx
jne 0x30a9
cmpq %r14, %r13
cmovlq %r13, %r14
movq %r14, %r12
sarq $0x3f, %r12
andq %r14, %r12
testq %r14, %r14
jle 0x309b
movzbl -0x1(%r15,%r14), %ecx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x3098
decq %r14
jmp 0x3081
movq %r14, %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x10e0
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x18, %rsp
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
xorl %eax, %eax
cmpq %r8, %rcx
setle %al
leaq -0x1(,%rax,2), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rdx), %rax
testq %rdx, %rdx
leaq 0x7(%rsp), %rbp
cmovneq %rax, %rbp
pushq $0x1
popq %rax
pushq $0x50
popq %r12
cmoveq %rax, %r12
cmpq %rbx, %r15
je 0x3141
testq %rbx, %rbx
js 0x3141
cmpq 0x38(%r13), %rbx
jge 0x3141
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
movq %rbp, %rcx
movq %r12, %r8
callq 0x3004
testq %r14, %r14
je 0x3135
testq %rax, %rax
jns 0x3146
testq %rax, %rax
jns 0x3149
addq 0x8(%rsp), %rbx
jmp 0x3105
pushq $-0x1
popq %rbx
jmp 0x3149
movq %rax, (%r14)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/LemonBoy[P]autobahn/xdiff/xemit.c
// Function: xdl_emit_record
static int xdl_emit_record(xdfile_t *xdf, long ri, char const *pre, xdemitcb_t *ecb) {
	long size, psize = strlen(pre);
	char const *rec;

	size = xdl_get_rec(xdf, ri, &rec);
	if (xdl_emit_diffrec(rec, size, pre, psize, ecb) < 0) {

		return -1;
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rdi
callq 0x1070
movq 0x60(%r12), %rcx
movq (%rcx,%r15,8), %rcx
movq 0x8(%rcx), %rdi
movq 0x10(%rcx), %rsi
movq %r14, %rdx
movq %rax, %rcx
movq %rbx, %r8
callq 0x3b1a
sarl $0x1f, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x3b98
// File: /workspace/github_c_makefile_star2_O2/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), %r8
cmpq $0x65, %rax
cmovlq %rdx, %r8
movq %rcx, %rax
subq %rsi, %rax
leaq 0x64(%rsi), %rdx
cmpq $0x65, %rax
cmovlq %rcx, %rdx
leaq -0x1(%rsi), %r9
pushq $0x1
popq %rax
xorl %ecx, %ecx
cmpq %r8, %r9
jl 0x3ab7
movzbl (%rdi,%r9), %r10d
cmpl $0x2, %r10d
je 0x3aaf
testl %r10d, %r10d
jne 0x3ab7
incq %rcx
jmp 0x3ab2
incq %rax
decq %r9
jmp 0x3a95
testq %rcx, %rcx
je 0x3b03
incq %rsi
pushq $0x1
popq %r8
xorl %r9d, %r9d
cmpq %rdx, %rsi
jg 0x3ae8
movzbl (%rdi,%rsi), %r10d
cmpl $0x2, %r10d
je 0x3ae0
testl %r10d, %r10d
jne 0x3ae8
incq %r9
jmp 0x3ae3
incq %r8
incq %rsi
jmp 0x3ac6
testq %r9, %r9
je 0x3b03
addq %rcx, %r9
addq %rax, %r8
addq %r8, %r9
shlq $0x2, %r8
xorl %eax, %eax
cmpq %r9, %r8
setl %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/LemonBoy[P]autobahn/xdiff/xutils.c
// Function: xdl_emit_diffrec
int xdl_emit_diffrec(char const *rec, long size, char const *pre, long psize,
		     xdemitcb_t *ecb) {
	int i = 2;
	mmbuffer_t mb[3];

	mb[0].ptr = (char *) pre;
	mb[0].size = psize;
	mb[1].ptr = (char *) rec;
	mb[1].size = size;
	if (size > 0 && rec[size - 1] != '\n') {
		mb[2].ptr = (char *) "\n\\ No newline at end of file\n";
		mb[2].size = strlen(mb[2].ptr);
		i++;
	}
	if (ecb->outf(ecb->priv, mb, i) < 0) {

		return -1;
	}

	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdx, (%rsp)
movq %rcx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
pushq $0x2
popq %rdx
testq %rsi, %rsi
jle 0x3b58
cmpb $0xa, -0x1(%rdi,%rsi)
je 0x3b58
leaq 0x35d9(%rip), %rax      # 0x7120
movq %rax, 0x20(%rsp)
movq $0x1d, 0x28(%rsp)
pushq $0x3
popq %rdx
movq (%r8), %rdi
movq %rsp, %rsi
callq *0x8(%r8)
sarl $0x1f, %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/LemonBoy[P]autobahn/xdiff/xutils.c
// Function: xdl_cha_init
int xdl_cha_init(chastore_t *cha, long isize, long icount) {

	cha->head = cha->tail = NULL;
	cha->isize = isize;
	cha->nsize = icount * isize;
	cha->ancur = cha->sncur = NULL;
	cha->scurr = 0;

	return 0;
}

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, 0x10(%rdi)
imulq %rsi, %rdx
movq %rdx, 0x18(%rdi)
movups %xmm0, 0x20(%rdi)
andq $0x0, 0x30(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/LemonBoy[P]autobahn/xdiff/xutils.c
// Function: xdl_cha_free
void xdl_cha_free(chastore_t *cha) {
	chanode_t *cur, *tmp;

	for (cur = cha->head; (tmp = cur) != NULL;) {
		cur = cur->next;
		xdl_free(tmp);
	}
}

// Assembly:
pushq %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x3bae
movq (%rdi), %rbx
callq 0x1030
movq %rbx, %rdi
jmp 0x3b9c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/LemonBoy[P]autobahn/xdiff/xutils.c
// Function: xdl_cha_alloc
void *xdl_cha_alloc(chastore_t *cha) {
	chanode_t *ancur;
	void *data;

	if (!(ancur = cha->ancur) || ancur->icurr == cha->nsize) {
		if (!(ancur = (chanode_t *) xdl_malloc(sizeof(chanode_t) + cha->nsize))) {

			return NULL;
		}
		ancur->icurr = 0;
		ancur->next = NULL;
		if (cha->tail)
			cha->tail->next = ancur;
		if (!cha->head)
			cha->head = ancur;
		cha->tail = ancur;
		cha->ancur = ancur;
	}

	data = (char *) ancur + sizeof(chanode_t) + ancur->icurr;
	ancur->icurr += cha->isize;

	return data;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x3bc9
movq 0x8(%rax), %rdi
cmpq 0x18(%rbx), %rdi
je 0x3bcd
jmp 0x3c00
movq 0x18(%rbx), %rdi
addq $0x10, %rdi
callq 0x10f0
testq %rax, %rax
je 0x3c12
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x3bed
movq %rax, (%rcx)
cmpq $0x0, (%rbx)
jne 0x3bf6
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
movq %rax, 0x20(%rbx)
xorl %edi, %edi
leaq (%rax,%rdi), %rcx
addq $0x10, %rcx
addq 0x10(%rbx), %rdi
movq %rdi, 0x8(%rax)
jmp 0x3c14
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/LemonBoy[P]autobahn/xdiff/xutils.c
// Function: xdl_guess_lines
long xdl_guess_lines(mmfile_t *mf, long sample) {
	long nl = 0, size, tsize = 0;
	char const *data, *cur, *top;

	if ((cur = data = xdl_mmfile_first(mf, &size)) != NULL) {
		for (top = data + size; nl < sample && cur < top; ) {
			nl++;
			if (!(cur = memchr(cur, '\n', top - cur)))
				cur = top;
			else
				cur++;
		}
		tsize += (long) (cur - data);
	}

	if (nl && tsize)
		nl = xdl_mmfile_size(mf) / (tsize / nl);

	return nl + 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
testq %r12, %r12
je 0x3c88
movq %rsi, %r15
movq 0x8(%rdi), %r14
leaq (%r12,%r14), %r13
xorl %ebx, %ebx
pushq $0xa
popq %rbp
movq %r12, %rdi
cmpq %r15, %rbx
jge 0x3c66
cmpq %r13, %rdi
jae 0x3c66
incq %rbx
movq %r13, %rdx
subq %rdi, %rdx
movl %ebp, %esi
callq 0x10a0
leaq 0x1(%rax), %rdi
testq %rax, %rax
cmoveq %r13, %rdi
jmp 0x3c3f
testq %rbx, %rbx
je 0x3c8a
subq %r12, %rdi
je 0x3c8a
movq %rdi, %rax
cqto
idivq %rbx
movq %rax, %rcx
movq %r14, %rax
cqto
idivq %rcx
movq %rax, %rbx
jmp 0x3c8a
xorl %ebx, %ebx
incq %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/LemonBoy[P]autobahn/xdiff/xutils.c
// Function: xdl_blankline
int xdl_blankline(const char *line, long size, long flags)
{
	long i;

	if (!(flags & XDF_WHITESPACE_FLAGS))
		return (size <= 1);

	for (i = 0; i < size && XDL_ISSPACE(line[i]); i++)
		;

	return (i == size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testb $0x1c, %dl
je 0x3ce0
movq %rdi, %r14
xorl %r12d, %r12d
testq %rbx, %rbx
movl $0x0, %r15d
cmovgq %rbx, %r15
cmpq %r12, %r15
je 0x3cec
callq 0x1150
movq (%rax), %rax
movzbl (%r14,%r12), %ecx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x3ce9
incq %r12
jmp 0x3cc2
cmpq $0x2, %rbx
setl %al
jmp 0x3cf2
movq %r12, %r15
cmpq %rbx, %r15
sete %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq