LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x83ee(%rip), %eax      # 0x21d70
addq -0x8(%rbp), %rax
movl 0x10a40(%rip), %ecx     # 0x2a3cc
cmpq %rcx, %rax
jbe 0x199e4
movl 0x83d9(%rip), %eax      # 0x21d70
addq -0x8(%rbp), %rax
addq $0x1000, %rax           # imm = 0x1000
subq $0x1, %rax
shrq $0xc, %rax
shlq $0xc, %rax
movl %eax, 0x10a19(%rip)     # 0x2a3cc
movq 0x83be(%rip), %rdi      # 0x21d78
movl 0x10a0c(%rip), %eax     # 0x2a3cc
movl %eax, %esi
callq 0xcb00
movq %rax, 0x83aa(%rip)      # 0x21d78
cmpq $0x0, 0x83a2(%rip)      # 0x21d78
jne 0x199e2
movl $0x673, %edi            # imm = 0x673
callq 0xeb50
jmp 0x199e4
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: listselfile
static bool listselfile(void)
{
	if (isselfileempty())
		return FALSE;

	snprintf(g_buf, CMD_LEN_MAX, "tr \'\\0\' \'\\n\' < %s", selpath);
	spawn(utils[UTIL_SH_EXEC], g_buf, NULL, NULL, F_CLI | F_CONFIRM);

	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x18af0
testb $0x1, %al
jne 0x19a03
jmp 0x19a09
movb $0x0, -0x1(%rbp)
jmp 0x19a4e
movq 0x6e18(%rip), %rcx      # 0x20828
leaq 0x7039(%rip), %rdi      # 0x20a50
movl $0x1200, %esi           # imm = 0x1200
leaq 0x2e95(%rip), %rdx      # 0x1c8b8
movb $0x0, %al
callq 0x4350
movq 0x5fb7(%rip), %rdi      # 0x1f9e8
leaq 0x7018(%rip), %rsi      # 0x20a50
xorl %eax, %eax
movl %eax, %ecx
movl $0x19, %r8d
movq %rcx, %rdx
callq 0xde30
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: 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
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movb %sil, %al
movb %dil, %cl
andb $0x1, %cl
movb %cl, -0x2(%rbp)
andb $0x1, %al
movb %al, -0x3(%rbp)
testb $0x1, -0x2(%rbp)
je 0x19af9
cmpl $0x0, 0x10b23(%rip)     # 0x2a5ac
jne 0x19af9
movq 0x6d96(%rip), %rdi      # 0x20828
xorl %esi, %esi
movb $0x0, %al
callq 0x46c0
movl %eax, -0x134(%rbp)
cmpl $-0x1, -0x134(%rbp)
je 0x19ad6
movl -0x134(%rbp), %edi
leaq -0x130(%rbp), %rsi
movl $0x12c, %edx            # imm = 0x12C
xorl %ecx, %ecx
callq 0x197d0
movl %eax, 0x10ae3(%rip)     # 0x2a5ac
movl -0x134(%rbp), %edi
callq 0x43c0
jmp 0x19af7
callq 0x40c0
movl (%rax), %edi
callq 0x4870
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd210
movb $0x0, -0x1(%rbp)
jmp 0x19c07
jmp 0x19af9
leaq -0x130(%rbp), %rdi
movb -0x3(%rbp), %dl
movq 0x5f3e(%rip), %rax      # 0x1fa48
addq $0x4, %rax
leaq 0x2db8(%rip), %rcx      # 0x1c8cd
testb $0x1, %dl
cmovneq %rax, %rcx
movl $0x14, %esi
leaq 0x2acf(%rip), %rdx      # 0x1c5f7
movb $0x0, %al
callq 0x4350
movl %eax, -0x138(%rbp)
testb $0x1, -0x2(%rbp)
je 0x19b67
leaq -0x130(%rbp), %rdi
movslq -0x138(%rbp), %rax
addq %rax, %rdi
movl 0x10a5a(%rip), %ecx     # 0x2a5ac
movl $0x118, %esi            # imm = 0x118
leaq 0x2d76(%rip), %rdx      # 0x1c8d4
movb $0x0, %al
callq 0x4350
jmp 0x19ba3
leaq -0x130(%rbp), %rdi
movslq -0x138(%rbp), %rax
addq %rax, %rdi
movq 0x107f1(%rip), %rax     # 0x2a370
movslq 0x107f2(%rip), %rcx     # 0x2a378
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movl $0x118, %esi            # imm = 0x118
leaq 0x2d45(%rip), %rdx      # 0x1c8e1
movb $0x0, %al
callq 0x4350
leaq -0x130(%rbp), %rdi
callq 0x10dc0
movl %eax, -0x138(%rbp)
cmpl $0x1b, -0x138(%rbp)
jne 0x19bc4
movb $0x0, -0x1(%rbp)
jmp 0x19c07
cmpl $0x79, -0x138(%rbp)
je 0x19bd6
cmpl $0x59, -0x138(%rbp)
jne 0x19bdc
movb $0x66, -0x1(%rbp)
jmp 0x19c07
cmpl $0x6e, -0x138(%rbp)
je 0x19bee
cmpl $0x4e, -0x138(%rbp)
jne 0x19bf4
movb $0x0, -0x1(%rbp)
jmp 0x19c07
movb -0x3(%rbp), %dl
movl $0x69, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: rmmulstr
static bool rmmulstr(char *buf, bool use_trash)
{
	char r = confirm_force(TRUE, use_trash);
	if (!r)
		return FALSE;

	if (!use_trash)
		snprintf(buf, CMD_LEN_MAX, "xargs -0 sh -c 'rm -%cvr -- \"$0\" \"$@\" < /dev/tty' < %s",
			 r, selpath);
	else
		snprintf(buf, CMD_LEN_MAX, "xargs -0 %s < %s",
			 trashcmd, selpath);

	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movl $0x1, %edi
andb $0x1, %al
movzbl %al, %esi
callq 0x19a60
movb %al, -0x12(%rbp)
cmpb $0x0, -0x12(%rbp)
jne 0x19ee5
movb $0x0, -0x1(%rbp)
jmp 0x19f38
testb $0x1, -0x11(%rbp)
jne 0x19f0f
movq -0x10(%rbp), %rdi
movsbl -0x12(%rbp), %ecx
movq 0x692e(%rip), %r8       # 0x20828
movl $0x1200, %esi           # imm = 0x1200
leaq 0x2a29(%rip), %rdx      # 0x1c92f
movb $0x0, %al
callq 0x4350
jmp 0x19f34
movq -0x10(%rbp), %rdi
movq 0x7d46(%rip), %rcx      # 0x21c60
movq 0x6907(%rip), %r8       # 0x20828
movl $0x1200, %esi           # imm = 0x1200
leaq 0x2a39(%rip), %rdx      # 0x1c966
movb $0x0, %al
callq 0x4350
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: getcmdfromhist
static char *getcmdfromhist(bool up)
{
	if (lastcmdpos == INVALID_POS) /* No entry in history */
		return NULL;

	if (selcmdpos == INVALID_POS) /* Initial position at prompt */
		selcmdpos = up ? lastcmdpos : 0;
	else if (up)
		selcmdpos = (selcmdpos == 0) ? lastcmdpos : selcmdpos - 1;
	else
		selcmdpos = (selcmdpos == lastcmdpos) ? 0 : selcmdpos + 1;

	return cmd_hist[selcmdpos];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movzbl 0x683d(%rip), %eax      # 0x207a0
cmpl $0xff, %eax
jne 0x19f77
movq $0x0, -0x8(%rbp)
jmp 0x1a028
movzbl 0x687a(%rip), %eax      # 0x207f8
cmpl $0xff, %eax
jne 0x19fa9
testb $0x1, -0x9(%rbp)
je 0x19f97
movzbl 0x680e(%rip), %eax      # 0x207a0
movl %eax, -0x10(%rbp)
jmp 0x19f9e
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0x19f9e
movl -0x10(%rbp), %eax
movb %al, 0x6851(%rip)       # 0x207f8
jmp 0x1a010
testb $0x1, -0x9(%rbp)
je 0x19fdf
movzbl 0x6842(%rip), %eax      # 0x207f8
cmpl $0x0, %eax
jne 0x19fc7
movzbl 0x67de(%rip), %eax      # 0x207a0
movl %eax, -0x14(%rbp)
jmp 0x19fd4
movzbl 0x682a(%rip), %eax      # 0x207f8
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movb %al, 0x681b(%rip)       # 0x207f8
jmp 0x1a00e
movzbl 0x6812(%rip), %eax      # 0x207f8
movzbl 0x67b3(%rip), %ecx      # 0x207a0
cmpl %ecx, %eax
jne 0x19ff8
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x1a005
movzbl 0x67f9(%rip), %eax      # 0x207f8
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movb %al, 0x67ea(%rip)       # 0x207f8
jmp 0x1a010
movzbl 0x67e1(%rip), %eax      # 0x207f8
movl %eax, %ecx
leaq 0x7da0(%rip), %rax      # 0x21dc0
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: launch_app
static bool launch_app(char *newpath)
{
	int r = F_NORMAL;
	char *tmp = newpath;

	mkpath(plgpath, utils[UTIL_LAUNCH], newpath);

	if (!getutil(utils[UTIL_FZF]) || access(newpath, X_OK) < 0) {
		tmp = xreadline(NULL, messages[MSG_APP_NAME]);
		r = F_NOWAIT | F_NOTRACE | F_MULTI;
	}

	if (tmp && *tmp) // NOLINT
		spawn(tmp, (r == F_NORMAL) ? "0" : NULL, NULL, NULL, r);

	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x8, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x7d4e(%rip), %rdi      # 0x21da0
movq 0x5987(%rip), %rsi      # 0x1f9e0
movq -0x8(%rbp), %rdx
callq 0x74c0
movq 0x59b7(%rip), %rdi      # 0x1fa20
callq 0x12930
testb $0x1, %al
jne 0x1a074
jmp 0x1a087
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x4720
cmpl $0x0, %eax
jge 0x1a0a2
movq 0x5ad2(%rip), %rsi      # 0x1fb60
xorl %eax, %eax
movl %eax, %edi
callq 0x144a0
movq %rax, -0x18(%rbp)
movl $0x7, -0xc(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1a0df
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1a0df
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %ecx
xorl %eax, %eax
movl %eax, %esi
leaq 0x2642(%rip), %rax      # 0x1c709
cmpl $0x8, %ecx
cmoveq %rax, %rsi
movl -0xc(%rbp), %eax
xorl %ecx, %ecx
movq %rcx, %rdx
movzwl %ax, %r8d
callq 0xde30
xorl %eax, %eax
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: shell_escape
static ssize_t shell_escape(char *output, size_t outlen, const char *s)
{
	size_t n = xstrlen(s), w = 0;

	if (s == output || outlen < 3) {
		errno = EINVAL;
		return -1;
	}

	output[w++] = '\''; /* begin single quote */
	for (size_t r = 0; r < n; ++r) {
		/* potentially too big: 4 for the single quote case, 2 from
		 * outside the loop */
		if (w + 6 >= outlen) {
			errno = ENAMETOOLONG;
			return -1;
		}

		switch (s[r]) {
		/* the only thing that has special meaning inside single
		 * quotes are single quotes themselves. */
		case '\'':
			output[w++] = '\''; /* end single quote */
			output[w++] = '\\'; /* put \' so it's treated as literal single quote */
			output[w++] = '\'';
			output[w++] = '\''; /* start single quoting again */
			break;
		default:
			output[w++] = s[r];
			break;
		}
	}
	output[w++] = '\''; /* end single quote */
	output[w]   = '\0'; /* nul terminator */
	return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5cc0
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x1a53a
cmpq $0x3, -0x18(%rbp)
jae 0x1a552
callq 0x40c0
movl $0x16, (%rax)
movq $-0x1, -0x8(%rbp)
jmp 0x1a673
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb $0x27, (%rax,%rcx)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1a648
movq -0x30(%rbp), %rax
addq $0x6, %rax
cmpq -0x18(%rbp), %rax
jb 0x1a5a5
callq 0x40c0
movl $0x24, (%rax)
movq $-0x1, -0x8(%rbp)
jmp 0x1a673
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movb (%rax,%rcx), %al
subb $0x27, %al
jne 0x1a614
jmp 0x1a5b6
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb $0x27, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb $0x5c, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb $0x27, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb $0x27, (%rax,%rcx)
jmp 0x1a635
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x1a637
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1a571
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb $0x27, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1bc0
cmpl $0x0, %eax
jne 0x132f
jmp 0x1347
leaq 0x2cce(%rip), %rdi      # 0x4004
leaq 0x2cec(%rip), %rsi      # 0x4029
movl $0x14, %edx
callq 0x1490
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x14(%rbp), %rdx
leaq 0x176(%rip), %r8        # 0x14d0
movq %rcx, %rsi
callq 0x2390
cmpl $0x0, %eax
jne 0x1369
jmp 0x1381
leaq 0x2cca(%rip), %rdi      # 0x403a
leaq 0x2cb2(%rip), %rsi      # 0x4029
movl $0x1e, %edx
callq 0x1490
movl -0x14(%rbp), %edi
leaq -0x15(%rbp), %rsi
movl $0x1, %edx
callq 0x1100
cmpq $0x1, %rax
jne 0x139a
jmp 0x13b2
leaq 0x2ce2(%rip), %rdi      # 0x4083
leaq 0x2c81(%rip), %rsi      # 0x4029
movl $0x22, %edx
callq 0x1490
movsbl -0x15(%rbp), %eax
cmpl $0x72, %eax
jne 0x13bd
jmp 0x13d5
leaq 0x2cdb(%rip), %rdi      # 0x409f
leaq 0x2c5e(%rip), %rsi      # 0x4029
movl $0x23, %edx
callq 0x1490
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0x26d0
cmpl $0x0, %eax
jne 0x13ea
jmp 0x1402
leaq 0x2cb7(%rip), %rdi      # 0x40a8
leaq 0x2c31(%rip), %rsi      # 0x4029
movl $0x25, %edx
callq 0x1490
movl -0x14(%rbp), %edi
leaq -0x15(%rbp), %rsi
movl $0x1, %edx
callq 0x1100
cmpq $0x1, %rax
jne 0x141b
jmp 0x1433
leaq 0x2c61(%rip), %rdi      # 0x4083
leaq 0x2c00(%rip), %rsi      # 0x4029
movl $0x27, %edx
callq 0x1490
movsbl -0x15(%rbp), %eax
cmpl $0x73, %eax
jne 0x143e
jmp 0x1456
leaq 0x2c93(%rip), %rdi      # 0x40d8
leaq 0x2bdd(%rip), %rsi      # 0x4029
movl $0x28, %edx
callq 0x1490
movq -0x10(%rbp), %rdi
callq 0x2620
cmpl $0x0, %eax
jne 0x1466
jmp 0x147e
leaq 0x2c74(%rip), %rdi      # 0x40e1
leaq 0x2bb5(%rip), %rsi      # 0x4029
movl $0x2a, %edx
callq 0x1490
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0x5c34(%rip)      # 0x711c
movl $0xa, %edi
leaq 0x7c(%rip), %rsi        # 0x1570
callq 0x1110
movq $-0x1, %rcx
cmpq %rcx, %rax
je 0x1507
jmp 0x151f
leaq 0x2c12(%rip), %rdi      # 0x4120
leaq 0x2b14(%rip), %rsi      # 0x4029
movl $0xd, %edx
callq 0x1490
movl -0xc(%rbp), %edi
leaq 0x31d2(%rip), %rsi      # 0x46fb
movl $0x1, %edx
callq 0x1080
cmpq $0x1, %rax
jne 0x153b
jmp 0x1553
leaq 0x2c0f(%rip), %rdi      # 0x4151
leaq 0x2ae0(%rip), %rsi      # 0x4029
movl $0xe, %edx
callq 0x1490
movl $0x3e7, %edi            # imm = 0x3E7
callq 0x11f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jle 0x2b1c
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rsi
movq 0x8(%rsp), %rdx
callq 0x37e0
cmpl $0x0, %eax
je 0x2b1c
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x10(%rsp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $-0x1, %rsi
movq %rsi, (%rdx)
movb $0x1, -0x1(%rax,%rcx)
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x10(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $-0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $0x0, -0x1(%rax,%rcx)
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x2b12
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
jmp 0x2ae6
movl $0x0, 0x24(%rsp)
jmp 0x2b24
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xdiffi.c
// Function: group_previous
static inline int group_previous(xdfile_t *xdf, struct xdlgroup *g)
{
	if (g->start == 0)
		return -1;

	g->end = g->start - 1;
	for (g->start = g->end; xdf->rchg[g->start - 1]; g->start--)
		;

	return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x2b4f
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x2bab
movq -0x18(%rsp), %rax
movq (%rax), %rcx
subq $0x1, %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq 0x68(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x2ba3
jmp 0x2b92
movq -0x18(%rsp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
jmp 0x2b75
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xdiffi.c
// Function: group_slide_down
static int group_slide_down(xdfile_t *xdf, struct xdlgroup *g, long flags)
{
	if (g->end < xdf->nrec &&
	    recs_match(xdf->recs[g->start], xdf->recs[g->end], flags)) {
		xdf->rchg[g->start++] = 0;
		xdf->rchg[g->end++] = 1;

		while (xdf->rchg[g->end])
			g->end++;

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jge 0x2cba
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x8(%rsp), %rdx
callq 0x37e0
cmpl $0x0, %eax
je 0x2cba
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x10(%rsp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb $0x0, (%rax,%rcx)
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x10(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $0x1, (%rax,%rcx)
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x2cb0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x2c85
movl $0x0, 0x24(%rsp)
jmp 0x2cc2
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xdiffi.c
// Function: group_next
static inline int group_next(xdfile_t *xdf, struct xdlgroup *g)
{
	if (g->end == xdf->nrec)
		return -1;

	g->start = g->end + 1;
	for (g->end = g->start; xdf->rchg[g->end]; g->end++)
		;

	return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jne 0x2cf8
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x2d53
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
movq (%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rax
movq 0x68(%rax), %rax
movq -0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x2d4b
jmp 0x2d38
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x2d1e
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jl 0x2d9c
movq 0x10(%rsp), %rax
movl $0x1, (%rax)
movq 0x10(%rsp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
jmp 0x2dc8
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
movq 0x20(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3860
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movq 0x18(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jl 0x2e5d
movq 0x20(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3860
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rax
cmpl $-0x1, 0xc(%rax)
je 0x2e24
jmp 0x2e5d
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
cmpl $0x14, 0x8(%rax)
jne 0x2e4b
movq 0x10(%rsp), %rax
movl $0x0, 0xc(%rax)
jmp 0x2e5d
jmp 0x2e4d
movq 0x8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2dee
movq 0x10(%rsp), %rax
movl $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jge 0x2efa
movq 0x20(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3860
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x10(%rsp), %rax
cmpl $-0x1, 0x14(%rax)
je 0x2ec1
jmp 0x2efa
movq 0x10(%rsp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rax
cmpl $0x14, 0x10(%rax)
jne 0x2ee8
movq 0x10(%rsp), %rax
movl $0x0, 0x14(%rax)
jmp 0x2efa
jmp 0x2eea
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2e83
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xdiffi.c
// Function: score_cmp
static int score_cmp(struct split_score *s1, struct split_score *s2)
{
	/* -1 if s1.effective_indent < s2->effective_indent, etc. */
	int cmp_indents = ((s1->effective_indent > s2->effective_indent) -
			   (s1->effective_indent < s2->effective_indent));

	return INDENT_WEIGHT * cmp_indents + (s1->penalty - s2->penalty);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %eax
movq -0x10(%rsp), %rcx
cmpl (%rcx), %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movq -0x8(%rsp), %rcx
movl (%rcx), %ecx
movq -0x10(%rsp), %rdx
cmpl (%rdx), %ecx
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x14(%rsp)
imull $0x3c, -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
movl 0x4(%rcx), %ecx
movq -0x10(%rsp), %rdx
subl 0x4(%rdx), %ecx
addl %ecx, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq 0x68(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rax
movq 0xf0(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rax
movq 0xc0(%rax), %rax
movq %rax, 0x20(%rsp)
movb $0x1, %al
cmpq $0x0, 0x28(%rsp)
movb %al, 0xf(%rsp)
jge 0x3180
cmpq $0x0, 0x20(%rsp)
setge %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x318d
jmp 0x3293
movq 0x38(%rsp), %rax
movq 0x28(%rsp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x31bf
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3270
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x28(%rsp), %rcx
subq $0x1, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x31ef
jmp 0x31df
movq 0x28(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x31c9
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
subq $0x1, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x321f
jmp 0x320f
movq 0x20(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x31f9
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
subq 0x28(%rsp), %rcx
movq 0x10(%rsp), %r8
subq 0x20(%rsp), %r8
callq 0x32c0
movq %rax, 0x40(%rsp)
cmpq $0x0, %rax
jne 0x3266
movq 0x48(%rsp), %rdi
callq 0x3360
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x32a8
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
jmp 0x3272
movq 0x28(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x3165
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xdiffi.c
// Function: xdl_add_change
static xdchange_t *xdl_add_change(xdchange_t *xscr, long i1, long i2, long chg1, long chg2) {
	xdchange_t *xch;

	if (!(xch = (xdchange_t *) xdl_malloc(sizeof(xdchange_t))))
		return NULL;

	xch->next = xscr;
	xch->i1 = i1;
	xch->i2 = i2;
	xch->chg1 = chg1;
	xch->chg2 = chg2;
	xch->ignore = 0;

	return xch;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movl $0x30, %edi
callq 0x10f0
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x32fc
movq $0x0, 0x30(%rsp)
jmp 0x3350
movq 0x28(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
movl $0x0, 0x28(%rax)
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3392
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1030
jmp 0x3369
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x148(%rsp)
movq %rsi, 0x140(%rsp)
movq %rdx, 0x138(%rsp)
movq %rcx, 0x130(%rsp)
movq %r8, 0x128(%rsp)
movq 0x130(%rsp), %rax
movq 0x28(%rax), %rdx
leaq 0x14de(%rip), %rax      # 0x48c0
leaq 0x187(%rip), %rcx       # 0x3570
cmpq $0x0, %rdx
cmovneq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x148(%rsp), %rdi
movq 0x140(%rsp), %rsi
movq 0x138(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x2330
cmpl $0x0, %eax
jge 0x342d
movl $0xffffffff, 0x154(%rsp) # imm = 0xFFFFFFFF
jmp 0x355c
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
addq $0x88, %rsi
movq 0x138(%rsp), %rax
movq (%rax), %rdx
callq 0x2690
cmpl $0x0, %eax
jl 0x3490
leaq 0x10(%rsp), %rdi
addq $0x88, %rdi
leaq 0x10(%rsp), %rsi
movq 0x138(%rsp), %rax
movq (%rax), %rdx
callq 0x2690
cmpl $0x0, %eax
jl 0x3490
leaq 0x10(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0x3110
cmpl $0x0, %eax
jge 0x34aa
leaq 0x10(%rsp), %rdi
callq 0x6080
movl $0xffffffff, 0x154(%rsp) # imm = 0xFFFFFFFF
jmp 0x355c
cmpq $0x0, 0x120(%rsp)
je 0x3547
movq 0x138(%rsp), %rax
movq (%rax), %rax
andq $0x80, %rax
cmpq $0x0, %rax
je 0x34ed
movq 0x120(%rsp), %rdi
movq 0x138(%rsp), %rax
movq (%rax), %rdx
leaq 0x10(%rsp), %rsi
callq 0x3650
movq 0x8(%rsp), %rax
movq 0x120(%rsp), %rsi
movq 0x128(%rsp), %rdx
movq 0x130(%rsp), %rcx
leaq 0x10(%rsp), %rdi
callq *%rax
cmpl $0x0, %eax
jge 0x353a
movq 0x120(%rsp), %rdi
callq 0x3360
leaq 0x10(%rsp), %rdi
callq 0x6080
movl $0xffffffff, 0x154(%rsp) # imm = 0xFFFFFFFF
jmp 0x355c
movq 0x120(%rsp), %rdi
callq 0x3360
leaq 0x10(%rsp), %rdi
callq 0x6080
movl $0x0, 0x154(%rsp)
movl 0x154(%rsp), %eax
addq $0x158, %rsp            # imm = 0x158
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x3634
movq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x4670
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x35bb
jmp 0x3634
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdi
movq (%rsp), %rcx
movq 0x8(%rcx), %rsi
movq (%rsp), %rcx
addq 0x18(%rcx), %rsi
movq 0x8(%rsp), %rcx
subq 0x8(%rcx), %rsi
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rdx
movq (%rsp), %rcx
movq 0x10(%rcx), %rcx
movq (%rsp), %r8
addq 0x20(%r8), %rcx
movq 0x8(%rsp), %r8
subq 0x10(%r8), %rcx
movq 0x18(%rsp), %r8
movq (%r8), %r8
callq *%rax
cmpl $0x0, %eax
jge 0x3621
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x363c
jmp 0x3623
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x3592
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xdiffi.c
// Function: xdl_mark_ignorable
static void xdl_mark_ignorable(xdchange_t *xscr, xdfenv_t *xe, long flags)
{
	xdchange_t *xch;

	for (xch = xscr; xch; xch = xch->next) {
		int ignore = 1;
		xrecord_t **rec;
		long i;

		rec = &xe->xdf1.recs[xch->i1];
		for (i = 0; i < xch->chg1 && ignore; i++)
			ignore = xdl_blankline(rec[i]->ptr, rec[i]->size, flags);

		rec = &xe->xdf2.recs[xch->i2];
		for (i = 0; i < xch->chg2 && ignore; i++)
			ignore = xdl_blankline(rec[i]->ptr, rec[i]->size, flags);

		xch->ignore = ignore;
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x37cc
movl $0x1, 0x24(%rsp)
movq 0x38(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rdx
xorl %eax, %eax
cmpq 0x18(%rdx), %rcx
movb %al, 0xf(%rsp)
jge 0x36ca
cmpl $0x0, 0x24(%rsp)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x36d4
jmp 0x3716
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
movq 0x30(%rsp), %rdx
callq 0x70d0
movl %eax, 0x24(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x36a8
movq 0x38(%rsp), %rax
movq 0xe8(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rdx
xorl %eax, %eax
cmpq 0x20(%rdx), %rcx
movb %al, 0xe(%rsp)
jge 0x3762
cmpl $0x0, 0x24(%rsp)
setne %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x376c
jmp 0x37ae
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
movq 0x30(%rsp), %rdx
callq 0x70d0
movl %eax, 0x24(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x3740
movl 0x24(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x366d
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x18(%rsp), %rdx
xorl %eax, %eax
cmpq 0x18(%rdx), %rcx
movb %al, 0xf(%rsp)
jne 0x3845
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %r8
callq 0x7190
cmpl $0x0, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x3934
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0xb(%rsp)
callq 0x1140
movq (%rax), %rax
movzbl 0xb(%rsp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x38cb
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x393c
movsbl 0xb(%rsp), %eax
cmpl $0x20, %eax
jne 0x38e2
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3909
movsbl 0xb(%rsp), %eax
cmpl $0x9, %eax
jne 0x3907
movl 0xc(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl $0x8, %eax
subl %edx, %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x3909
jmp 0x390b
cmpl $0xc8, 0xc(%rsp)
jl 0x391f
movl $0xc8, 0x24(%rsp)
jmp 0x393c
jmp 0x3921
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x387a
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xpatience.c
// Function: xdl_do_patience_diff
int xdl_do_patience_diff(mmfile_t *file1, mmfile_t *file2,
		xpparam_t const *xpp, xdfenv_t *env)
{
	if (xdl_prepare_env(file1, file2, xpp, env) < 0)
		return -1;

	/* environment is cleaned up in xdl_diff() */
	return patience_diff(file1, file2, xpp, env,
			1, env->xdf1.nrec, 1, env->xdf2.nrec);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x5770
cmpl $0x0, %eax
jge 0x3990
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x39d6
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movl %eax, %r9d
movq 0x10(%rsp), %rax
movq 0xc0(%rax), %rax
movl $0x1, %r8d
movl $0x1, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x39e0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xpatience.c
// Function: fill_hashmap
static int fill_hashmap(mmfile_t *file1, mmfile_t *file2,
		xpparam_t const *xpp, xdfenv_t *env,
		struct hashmap *result,
		int line1, int count1, int line2, int count2)
{
	result->file1 = file1;
	result->file2 = file2;
	result->xpp = xpp;
	result->env = env;

	/* We know exactly how large we want the hash map */
	result->alloc = count1 * 2;
	result->entries = (struct entry *)
		xdl_malloc(result->alloc * sizeof(struct entry));
	if (!result->entries)
		return -1;
	memset(result->entries, 0, result->alloc * sizeof(struct entry));

	/* First, fill with entries from the first file */
	while (count1--)
		insert_record(line1++, result, 1);

	/* Then search for matches in the second file */
	while (count2--)
		insert_record(line2++, result, 2);

	return 0;
}

// Assembly:
subq $0x38, %rsp
movl 0x50(%rsp), %eax
movl 0x48(%rsp), %eax
movl 0x40(%rsp), %eax
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movl %r9d, 0x4(%rsp)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movl 0x40(%rsp), %ecx
shll %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x8(%rsp), %rax
movslq 0x4(%rax), %rax
imulq $0x28, %rax, %rdi
callq 0x10f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3d3b
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x3dc2
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rax
movslq 0x4(%rax), %rax
imulq $0x28, %rax, %rdx
xorl %esi, %esi
callq 0x1090
movl 0x40(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x40(%rsp)
cmpl $0x0, %eax
je 0x3d88
movl 0x4(%rsp), %edi
movl %edi, %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x4290
jmp 0x3d58
jmp 0x3d8a
movl 0x50(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x50(%rsp)
cmpl $0x0, %eax
je 0x3dba
movl 0x48(%rsp), %edi
movl %edi, %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
movq 0x8(%rsp), %rsi
movl $0x2, %edx
callq 0x4290
jmp 0x3d8a
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xpatience.c
// Function: find_longest_common_sequence
static struct entry *find_longest_common_sequence(struct hashmap *map)
{
	struct entry **sequence = xdl_malloc(map->nr * sizeof(struct entry *));
	int longest = 0, i;
	struct entry *entry;

	for (entry = map->first; entry; entry = entry->next) {
		if (!entry->line2 || entry->line2 == NON_UNIQUE)
			continue;
		i = binary_search(sequence, longest, entry);
		entry->previous = i < 0 ? NULL : sequence[i];
		sequence[++i] = entry;
		if (i == longest)
			longest++;
	}

	/* No common unique lines were found */
	if (!longest) {
		xdl_free(sequence);
		return NULL;
	}

	/* Iterate starting at the last element, adjusting the "next" members */
	entry = sequence[longest - 1];
	entry->next = NULL;
	while (entry->previous) {
		entry->previous->next = entry;
		entry = entry->previous;
	}
	xdl_free(sequence);
	return entry;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x10f0
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x3eb9
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3e29
movq 0x10(%rsp), %rax
cmpq $-0x1, 0x10(%rax)
jne 0x3e2b
jmp 0x3ea6
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0x4560
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x18(%rsp)
jge 0x3e52
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x3e65
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rax
movl 0x18(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rsp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jne 0x3ea4
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3ea6
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x3e05
cmpl $0x0, 0x1c(%rsp)
jne 0x3ed5
movq 0x20(%rsp), %rdi
callq 0x1030
movq $0x0, 0x30(%rsp)
jmp 0x3f3c
movq 0x20(%rsp), %rax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3f28
movq 0x10(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x3efa
movq 0x20(%rsp), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xpatience.c
// Function: fall_back_to_classic_diff
static int fall_back_to_classic_diff(struct hashmap *map,
		int line1, int count1, int line2, int count2)
{
	xpparam_t xpp;
	xpp.flags = map->xpp->flags & ~XDF_DIFF_ALGORITHM_MASK;

	return xdl_fall_back_diff(map->env, &xpp,
				  line1, count1, line2, count2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq (%rax), %rax
andq $-0x61, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rdi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
movl 0x14(%rsp), %r8d
movl 0x10(%rsp), %r9d
leaq 0x8(%rsp), %rsi
callq 0x7f10
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xpatience.c
// Function: binary_search
static int binary_search(struct entry **sequence, int longest,
		struct entry *entry)
{
	int left = -1, right = longest;

	while (left + 1 < right) {
		int middle = (left + right) / 2;
		/* by construction, no two entries can be equal */
		if (sequence[middle]->line2 > entry->line2)
			right = middle;
		else
			left = middle;
	}
	/* return the index in "sequence", _not_ the sequence length */
	return left;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movl $0xffffffff, -0x1c(%rsp) # imm = 0xFFFFFFFF
movl -0xc(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
cmpl -0x20(%rsp), %eax
jge 0x45d0
movl -0x1c(%rsp), %eax
addl -0x20(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rsp)
movq -0x8(%rsp), %rax
movslq -0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x45c6
movl -0x24(%rsp), %eax
movl %eax, -0x20(%rsp)
jmp 0x45ce
movl -0x24(%rsp), %eax
movl %eax, -0x1c(%rsp)
jmp 0x457e
movl -0x1c(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x60(%rax), %rax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movq 0xe8(%rax), %rax
movl 0x18(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq (%rax), %r8
callq 0x7190
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x5610
movq %rax, 0x8(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x8(%rsp)
movb %al, 0x7(%rsp)
jle 0x534b
callq 0x1140
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x5355
jmp 0x5373
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x5317
cmpq $0x0, 0x8(%rsp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)