LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x5610
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x53fb
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq 0x20(%rax), %r8
callq 0x5660
movq %rax, 0x40(%rsp)
jmp 0x5428
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x20(%r8), %r8
callq *%rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovgl %ecx, %eax
cltq
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x5496
movq 0x58(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
jmp 0x54a0
leaq 0x27(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdx
movl $0x1, %eax
movl $0x50, %ecx
cmpq $0x0, %rdx
cmovneq %rcx, %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rcx
xorl %eax, %eax
cmpq 0x48(%rsp), %rcx
movb %al, 0xf(%rsp)
je 0x5506
xorl %eax, %eax
xorl %ecx, %ecx
cmpq 0x40(%rsp), %rcx
movb %al, 0xf(%rsp)
jg 0x5506
movq 0x40(%rsp), %rax
movq 0x68(%rsp), %rcx
cmpq 0x38(%rcx), %rax
setl %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x5510
jmp 0x5572
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %r8
callq 0x5390
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jl 0x555c
cmpq $0x0, 0x58(%rsp)
je 0x5550
movq 0x18(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x557b
jmp 0x555e
movq 0x30(%rsp), %rax
addq 0x40(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x54d0
movq $-0x1, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1070
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x5610
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0x6ca0
cmpl $0x0, %eax
jge 0x55fd
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x5605
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xemit.c
// Function: def_ff
static long def_ff(const char *rec, long len, char *buf, long sz, void *priv)
{
	if (len > 0 &&
			(isalpha((unsigned char)*rec) || /* identifier? */
			 *rec == '_' || /* also identifier? */
			 *rec == '$')) { /* identifiers from VMS and other esoterico */
		if (len > sz)
			len = sz;
		while (0 < len && isspace((unsigned char)rec[len - 1]))
			len--;
		memcpy(buf, rec, len);
		return len;
	}
	return -1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jle 0x5759
callq 0x1140
movq (%rax), %rax
movq 0x28(%rsp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x56c8
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
je 0x56c8
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x24, %eax
jne 0x5759
movq 0x20(%rsp), %rax
cmpq 0x10(%rsp), %rax
jle 0x56de
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x56e0
xorl %eax, %eax
xorl %ecx, %ecx
cmpq 0x20(%rsp), %rcx
movb %al, 0x7(%rsp)
jge 0x571f
callq 0x1140
movq (%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %rdx
subq $0x1, %rdx
movzbl (%rcx,%rdx), %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 0x5729
jmp 0x5739
movq 0x20(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x56e0
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x10e0
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x5762
movq $-0x1, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xprepare.c
// Function: xdl_init_classifier
static int xdl_init_classifier(xdlclassifier_t *cf, long size, long flags) {
	cf->flags = flags;

	cf->hbits = xdl_hashbits((unsigned int) size);
	cf->hsize = 1 << cf->hbits;

	if (xdl_cha_init(&cf->ncha, sizeof(xdlclass_t), size / 4 + 1) < 0) {

		return -1;
	}
	if (!(cf->rchash = (xdlclass_t **) xdl_malloc(cf->hsize * sizeof(xdlclass_t *)))) {

		xdl_cha_free(&cf->ncha);
		return -1;
	}
	memset(cf->rchash, 0, cf->hsize * sizeof(xdlclass_t *));

	cf->alloc = size;
	if (!(cf->rcrecs = (xdlclass_t **) xdl_malloc(cf->alloc * sizeof(xdlclass_t *)))) {

		xdl_free(cf->rchash);
		xdl_cha_free(&cf->ncha);
		return -1;
	}

	cf->count = 0;

	return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x68(%rax)
movq 0x10(%rsp), %rax
movl %eax, %edi
callq 0x79f0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
movq 0x10(%rsp), %rax
movl $0x4, %ecx
cqto
idivq %rcx
movq %rax, %rdx
addq $0x1, %rdx
movl $0x38, %esi
callq 0x6db0
cmpl $0x0, %eax
jge 0x5a5b
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x5b1e
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
shlq $0x3, %rdi
callq 0x10f0
movq 0x18(%rsp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x5a97
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0x6e30
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x5b1e
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x1090
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rdi
shlq $0x3, %rdi
callq 0x10f0
movq 0x18(%rsp), %rcx
movq %rax, 0x50(%rcx)
cmpq $0x0, %rax
jne 0x5b09
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0x6e30
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x5b1e
movq 0x18(%rsp), %rax
movq $0x0, 0x60(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x68(%rax), %rdi
addq $-0x1, %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x80(%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x1030
movq (%rsp), %rdi
callq 0x6e30
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xprepare.c
// Function: xdl_optimize_ctxs
static int xdl_optimize_ctxs(xdlclassifier_t *cf, xdfile_t *xdf1, xdfile_t *xdf2) {

	if (xdl_trim_ends(xdf1, xdf2) < 0 ||
	    xdl_cleanup_records(cf, xdf1, xdf2) < 0) {

		return -1;
	}

	return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x6390
cmpl $0x0, %eax
jl 0x6060
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x6560
cmpl $0x0, %eax
jge 0x606a
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x6072
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xprepare.c
// Function: xdl_trim_ends
static int xdl_trim_ends(xdfile_t *xdf1, xdfile_t *xdf2) {
	long i, lim;
	xrecord_t **recs1, **recs2;

	recs1 = xdf1->recs;
	recs2 = xdf2->recs;
	for (i = 0, lim = XDL_MIN(xdf1->nrec, xdf2->nrec); i < lim;
	     i++, recs1++, recs2++)
		if ((*recs1)->ha != (*recs2)->ha)
			break;

	xdf1->dstart = xdf2->dstart = i;

	recs1 = xdf1->recs + xdf1->nrec - 1;
	recs2 = xdf2->recs + xdf2->nrec - 1;
	for (lim -= i, i = 0; i < lim; i++, recs1--, recs2--)
		if ((*recs1)->ha != (*recs2)->ha)
			break;

	xdf1->dend = xdf1->nrec - i - 1;
	xdf2->dend = xdf2->nrec - i - 1;

	return 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jge 0x63e3
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x38(%rsp)
jmp 0x63f1
movq -0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
cmpq -0x20(%rsp), %rax
jge 0x6451
movq -0x28(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x30(%rsp), %rcx
movq (%rcx), %rcx
cmpq 0x18(%rcx), %rax
je 0x6423
jmp 0x6451
jmp 0x6425
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
movq -0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rsp)
movq -0x30(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rsp)
jmp 0x63fb
movq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rsp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rsp), %rax
movq 0x60(%rax), %rax
movq -0x8(%rsp), %rcx
movq 0x38(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq 0x60(%rax), %rax
movq -0x10(%rsp), %rcx
movq 0x38(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq -0x20(%rsp), %rax
jge 0x651d
movq -0x28(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x30(%rsp), %rcx
movq (%rcx), %rcx
cmpq 0x18(%rcx), %rax
je 0x64ef
jmp 0x651d
jmp 0x64f1
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
movq -0x28(%rsp), %rax
addq $-0x8, %rax
movq %rax, -0x28(%rsp)
movq -0x30(%rsp), %rax
addq $-0x8, %rax
movq %rax, -0x30(%rsp)
jmp 0x64c7
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rcx
subq -0x18(%rsp), %rcx
subq $0x1, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rsp), %rax
movq 0x38(%rax), %rcx
subq -0x18(%rsp), %rcx
subq $0x1, %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x58(%rax)
xorl %eax, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xutils.c
// Function: xdl_bogosqrt
long xdl_bogosqrt(long n) {
	long i;

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

	return i;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq $0x1, -0x10(%rsp)
cmpq $0x0, -0x8(%rsp)
jle 0x6c93
movq -0x10(%rsp), %rax
shlq %rax
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rax
sarq $0x2, %rax
movq %rax, -0x8(%rsp)
jmp 0x6c6e
movq -0x10(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movl $0x2, 0x34(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x50(%rsp)
jle 0x6d31
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x6d31
leaq 0x53f3(%rip), %rax      # 0xc105
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1070
movq %rax, 0x28(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rsp), %rcx
movq (%rcx), %rdi
movq %rsp, %rsi
movl 0x34(%rsp), %edx
callq *%rax
cmpl $0x0, %eax
jge 0x6d5a
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x6d62
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rsp), %rcx
imulq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
xorl %eax, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x6e6d
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
callq 0x1030
jmp 0x6e46
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x6eb5
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x6f4a
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
addq $0x10, %rdi
callq 0x10f0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0x6ee0
movq $0x0, 0x20(%rsp)
jmp 0x6f81
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6f16
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x6f2e
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq 0x10(%rsp), %rcx
addq 0x8(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x6d70
movq %rax, 0x28(%rsp)
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x7077
movq 0x28(%rsp), %rax
addq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rcx
xorl %eax, %eax
cmpq 0x48(%rsp), %rcx
movb %al, 0x17(%rsp)
jge 0x7005
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
setb %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x700f
jmp 0x7060
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
subq %rax, %rdx
movl $0xa, %esi
callq 0x10a0
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
jne 0x7050
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x705e
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x6fe2
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
addq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x70b4
cmpq $0x0, 0x30(%rsp)
je 0x70b4
movq 0x50(%rsp), %rdi
callq 0x6da0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
cqto
idivq 0x40(%rsp)
movq %rax, %rcx
movq 0x8(%rsp), %rax
cqto
idivq %rcx
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x1, %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rax
andq $0x1c, %rax
cmpq $0x0, %rax
jne 0x7106
cmpq $0x1, 0x20(%rsp)
setle %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
jmp 0x717f
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x20(%rsp), %rcx
movb %al, 0xf(%rsp)
jge 0x714d
callq 0x1140
movq (%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x7157
jmp 0x7169
jmp 0x7159
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x710f
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xutils.c
// Function: xdl_hash_record
unsigned long xdl_hash_record(char const **data, char const *top, long flags) {
	unsigned long ha = 5381;
	char const *ptr = *data;

	if (flags & XDF_WHITESPACE_FLAGS)
		return xdl_hash_record_with_whitespace(data, top, flags);

	for (; ptr < top && *ptr != '\n'; ptr++) {
		ha += (ha << 5);
		ha ^= (unsigned long) *ptr;
	}
	*data = ptr < top ? ptr + 1: ptr;

	return ha;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq $0x1505, 0x20(%rsp)     # imm = 0x1505
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
andq $0x1c, %rax
cmpq $0x0, %rax
je 0x76d6
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x7790
movq %rax, 0x40(%rsp)
jmp 0x7779
jmp 0x76d8
movq 0x18(%rsp), %rcx
xorl %eax, %eax
cmpq 0x30(%rsp), %rcx
movb %al, 0x17(%rsp)
jae 0x76fc
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x7706
jmp 0x773c
movq 0x20(%rsp), %rax
shlq $0x5, %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
movsbq (%rax), %rax
xorq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x76d8
movq 0x18(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x7758
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x7762
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xutils.c
// Function: xdl_num_out
int xdl_num_out(char *out, long val) {
	char *ptr, *str = out;
	char buf[32];

	ptr = buf + sizeof(buf) - 1;
	*ptr = '\0';
	if (val < 0) {
		*--ptr = '-';
		val = -val;
	}
	for (; val && ptr > buf; val /= 10)
		*--ptr = "0123456789"[val % 10];
	if (*ptr)
		for (; *ptr; ptr++, str++)
			*str = *ptr;
	else
		*str++ = '0';
	*str = '\0';

	return str - out;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
leaq -0x48(%rsp), %rax
addq $0x20, %rax
addq $-0x1, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0x10(%rsp)
jge 0x7ac7
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rsp)
movb $0x2d, -0x1(%rax)
xorl %eax, %eax
subq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
jmp 0x7ac9
xorl %eax, %eax
cmpq $0x0, -0x10(%rsp)
movb %al, -0x49(%rsp)
je 0x7aeb
movq -0x18(%rsp), %rax
leaq -0x48(%rsp), %rcx
cmpq %rcx, %rax
seta %al
movb %al, -0x49(%rsp)
movb -0x49(%rsp), %al
testb $0x1, %al
jne 0x7af5
jmp 0x7b38
movq -0x10(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
leaq 0x4618(%rip), %rax      # 0xc123
movb (%rax,%rdx), %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, -0x1(%rax)
movq -0x10(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x10(%rsp)
jmp 0x7ac9
movq -0x18(%rsp), %rax
cmpb $0x0, (%rax)
je 0x7b7c
jmp 0x7b44
movq -0x18(%rsp), %rax
cmpb $0x0, (%rax)
je 0x7b7a
movq -0x18(%rsp), %rax
movb (%rax), %cl
movq -0x20(%rsp), %rax
movb %cl, (%rax)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x7b44
jmp 0x7b90
movq -0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rsp)
movb $0x30, (%rax)
movq -0x20(%rsp), %rax
movb $0x0, (%rax)
movq -0x20(%rsp), %rax
movq -0x8(%rsp), %rcx
subq %rcx, %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xutils.c
// Function: xdl_fall_back_diff
int xdl_fall_back_diff(xdfenv_t *diff_env, xpparam_t const *xpp,
		int line1, int count1, int line2, int count2)
{
	/*
	 * This probably does not work outside Git, since
	 * we have a very simple mmfile structure.
	 *
	 * Note: ideally, we would reuse the prepared environment, but
	 * the libxdiff interface does not (yet) allow for diffing only
	 * ranges of lines instead of the whole files.
	 */
	mmfile_t subfile1, subfile2;
	xdfenv_t env;

	subfile1.ptr = (char *)diff_env->xdf1.recs[line1 - 1]->ptr;
	subfile1.size = diff_env->xdf1.recs[line1 + count1 - 2]->ptr +
		diff_env->xdf1.recs[line1 + count1 - 2]->size - subfile1.ptr;
	subfile2.ptr = (char *)diff_env->xdf2.recs[line2 - 1]->ptr;
	subfile2.size = diff_env->xdf2.recs[line2 + count2 - 2]->ptr +
		diff_env->xdf2.recs[line2 + count2 - 2]->size - subfile2.ptr;
	if (xdl_do_diff(&subfile1, &subfile2, xpp, &env) < 0)
		return -1;

	memcpy(diff_env->xdf1.rchg + line1 - 1, env.xdf1.rchg, count1);
	memcpy(diff_env->xdf2.rchg + line2 - 1, env.xdf2.rchg, count2);

	xdl_free_env(&env);

	return 0;
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x148(%rsp)
movq %rsi, 0x140(%rsp)
movl %edx, 0x13c(%rsp)
movl %ecx, 0x138(%rsp)
movl %r8d, 0x134(%rsp)
movl %r9d, 0x130(%rsp)
movq 0x148(%rsp), %rax
movq 0x60(%rax), %rax
movl 0x13c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x120(%rsp)
movq 0x148(%rsp), %rax
movq 0x60(%rax), %rax
movl 0x13c(%rsp), %ecx
addl 0x138(%rsp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq 0x148(%rsp), %rcx
movq 0x60(%rcx), %rcx
movl 0x13c(%rsp), %edx
addl 0x138(%rsp), %edx
subl $0x2, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
addq 0x10(%rcx), %rax
movq 0x120(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x128(%rsp)
movq 0x148(%rsp), %rax
movq 0xe8(%rax), %rax
movl 0x134(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x110(%rsp)
movq 0x148(%rsp), %rax
movq 0xe8(%rax), %rax
movl 0x134(%rsp), %ecx
addl 0x130(%rsp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq 0x148(%rsp), %rcx
movq 0xe8(%rcx), %rcx
movl 0x134(%rsp), %edx
addl 0x130(%rsp), %edx
subl $0x2, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
addq 0x10(%rcx), %rax
movq 0x110(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x118(%rsp)
movq 0x140(%rsp), %rdx
leaq 0x120(%rsp), %rdi
leaq 0x110(%rsp), %rsi
movq %rsp, %rcx
callq 0x2330
cmpl $0x0, %eax
jge 0x8098
movl $0xffffffff, 0x154(%rsp) # imm = 0xFFFFFFFF
jmp 0x810b
movq 0x148(%rsp), %rax
movq 0x68(%rax), %rdi
movslq 0x13c(%rsp), %rax
addq %rax, %rdi
addq $-0x1, %rdi
movq 0x68(%rsp), %rsi
movslq 0x138(%rsp), %rdx
callq 0x10e0
movq 0x148(%rsp), %rax
movq 0xf0(%rax), %rdi
movslq 0x134(%rsp), %rax
addq %rax, %rdi
addq $-0x1, %rdi
movq 0xf0(%rsp), %rsi
movslq 0x130(%rsp), %rdx
callq 0x10e0
movq %rsp, %rdi
callq 0x6080
movl $0x0, 0x154(%rsp)
movl 0x154(%rsp), %eax
addq $0x158, %rsp            # imm = 0x158
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xmerge.c
// Function: xdl_append_merge
static int xdl_append_merge(xdmerge_t **merge, int mode,
			    long i0, long chg0,
			    long i1, long chg1,
			    long i2, long chg2)
{
	xdmerge_t *m = *merge;
	if (m && (i1 <= m->i1 + m->chg1 || i2 <= m->i2 + m->chg2)) {
		if (mode != m->mode)
			m->mode = 0;
		m->chg0 = i0 + chg0 - m->i0;
		m->chg1 = i1 + chg1 - m->i1;
		m->chg2 = i2 + chg2 - m->i2;
	} else {
		m = xdl_malloc(sizeof(xdmerge_t));
		if (!m)
			return -1;
		m->next = NULL;
		m->mode = mode;
		m->i0 = i0;
		m->chg0 = chg0;
		m->i1 = i1;
		m->chg1 = chg1;
		m->i2 = i2;
		m->chg2 = chg2;
		if (*merge)
			(*merge)->next = m;
		*merge = m;
	}
	return 0;
}

// Assembly:
subq $0x48, %rsp
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rax
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x8f6f
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rsp), %rdx
addq 0x20(%rdx), %rcx
cmpq %rcx, %rax
jle 0x8efc
movq 0x50(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq 0x8(%rsp), %rdx
addq 0x28(%rdx), %rcx
cmpq %rcx, %rax
jg 0x8f6f
movl 0x34(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
je 0x8f16
movq 0x8(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x28(%rsp), %rcx
addq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
subq 0x30(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x18(%rsp), %rcx
addq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
subq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x50(%rsp), %rcx
addq 0x58(%rsp), %rcx
movq 0x8(%rsp), %rax
subq 0x18(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
jmp 0x9027
movl $0x40, %edi
callq 0x10f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x8f93
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x902f
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movl 0x34(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x50(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x58(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x38(%rsp), %rax
cmpq $0x0, (%rax)
je 0x901a
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xmerge.c
// Function: xdl_cleanup_merge
static int xdl_cleanup_merge(xdmerge_t *c)
{
	int count = 0;
	xdmerge_t *next_c;

	/* were there conflicts? */
	for (; c; c = next_c) {
		if (c->mode == 0)
			count++;
		next_c = c->next;
		free(c);
	}
	return count;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x9090
movq 0x10(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x906f
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x1030
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x9051
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xmerge.c
// Function: xdl_merge_cmp_lines
static int xdl_merge_cmp_lines(xdfenv_t *xe1, int i1, xdfenv_t *xe2, int i2,
		int line_count, long flags)
{
	int i;
	xrecord_t **rec1 = xe1->xdf2.recs + i1;
	xrecord_t **rec2 = xe2->xdf2.recs + i2;

	for (i = 0; i < line_count; i++) {
		int result = xdl_recmatch(rec1[i]->ptr, rec1[i]->size,
			rec2[i]->ptr, rec2[i]->size, flags);
		if (!result)
			return -1;
	}
	return 0;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
movl %r8d, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0xe8(%rax), %rax
movslq 0x44(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0xe8(%rax), %rax
movslq 0x34(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x9182
movq 0x18(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
movq 0x10(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rcx
movq 0x28(%rsp), %r8
callq 0x7190
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x9173
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x918a
jmp 0x9175
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x9102
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xmerge.c
// Function: xdl_simplify_non_conflicts
static int xdl_simplify_non_conflicts(xdfenv_t *xe1, xdmerge_t *m,
				      int simplify_if_no_alnum)
{
	int result = 0;

	if (!m)
		return result;
	for (;;) {
		xdmerge_t *next_m = m->next;
		int begin, end;

		if (!next_m)
			return result;

		begin = m->i1 + m->chg1;
		end = next_m->i1;

		if (m->mode != 0 || next_m->mode != 0 ||
		    (end - begin > 3 &&
		     (!simplify_if_no_alnum ||
		      lines_contain_alnum(xe1, begin, end - begin)))) {
			m = next_m;
		} else {
			result++;
			xdl_merge_two_conflicts(m);
		}
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x962f
movl 0x18(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x96e1
jmp 0x9631
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x9653
movl 0x18(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x96e1
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
addq 0x20(%rcx), %rax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x96bb
movq 0x10(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x96bb
movl 0x8(%rsp), %eax
subl 0xc(%rsp), %eax
cmpl $0x3, %eax
jle 0x96c7
cmpl $0x0, 0x1c(%rsp)
je 0x96bb
movq 0x28(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
subl 0xc(%rsp), %edx
callq 0x9b30
cmpl $0x0, %eax
je 0x96c7
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x96dc
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x9bc0
jmp 0x9631
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xmerge.c
// Function: lines_contain_alnum
static int lines_contain_alnum(xdfenv_t *xe, int i, int chg)
{
	for (; chg; chg--, i++)
		if (line_contains_alnum(xe->xdf2.recs[i]->ptr,
				xe->xdf2.recs[i]->size))
			return 1;
	return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl %edx, (%rsp)
cmpl $0x0, (%rsp)
je 0x9ba4
movq 0x8(%rsp), %rax
movq 0xe8(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0xe8(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
callq 0x9c40
cmpl $0x0, %eax
je 0x9b8c
movl $0x1, 0x14(%rsp)
jmp 0x9bac
jmp 0x9b8e
movl (%rsp), %eax
addl $-0x1, %eax
movl %eax, (%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x9b40
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xmerge.c
// Function: xdl_merge_two_conflicts
static void xdl_merge_two_conflicts(xdmerge_t *m)
{
	xdmerge_t *next_m = m->next;
	m->chg1 = next_m->i1 + next_m->chg1 - m->i1;
	m->chg2 = next_m->i2 + next_m->chg2 - m->i2;
	m->next = next_m->next;
	free(next_m);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
addq 0x20(%rax), %rcx
movq 0x10(%rsp), %rax
subq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x8(%rsp), %rax
addq 0x28(%rax), %rcx
movq 0x10(%rsp), %rax
subq 0x18(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
callq 0x1030
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xmerge.c
// Function: line_contains_alnum
static int line_contains_alnum(const char *ptr, long size)
{
	while (size--)
		if (isalnum((unsigned char)*(ptr++)))
			return 1;
	return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, (%rsp)
cmpq $0x0, %rax
je 0x9c99
callq 0x1140
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x9c97
movl $0x1, 0x14(%rsp)
jmp 0x9ca1
jmp 0x9c4d
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xmerge.c
// Function: is_cr_needed
static int is_cr_needed(xdfenv_t *xe1, xdfenv_t *xe2, xdmerge_t *m)
{
	int needs_cr;

	/* Match post-images' preceding, or first, lines' end-of-line style */
	needs_cr = is_eol_crlf(&xe1->xdf2, m->i1 ? m->i1 - 1 : 0);
	if (needs_cr)
		needs_cr = is_eol_crlf(&xe2->xdf2, m->i2 ? m->i2 - 1 : 0);
	/* Look at pre-image's first line, unless we already settled on LF */
	if (needs_cr)
		needs_cr = is_eol_crlf(&xe1->xdf1, 0);
	/* If still undecided, use LF-only */
	return needs_cr < 0 ? 0 : needs_cr;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
addq $0x88, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0xa523
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
subq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xa52c
xorl %eax, %eax
movq %rax, 0x18(%rsp)
jmp 0xa52c
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl %eax, %esi
callq 0xa7d0
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0xa596
movq 0x38(%rsp), %rax
addq $0x88, %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0xa578
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0xa581
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xa581
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl %eax, %esi
callq 0xa7d0
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0xa5ad
movq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0xa7d0
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jge 0xa5bc
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0xa5c4
movl 0x2c(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xmerge.c
// Function: xdl_recs_copy_0
static int xdl_recs_copy_0(int use_orig, xdfenv_t *xe, int i, int count, int needs_cr, int add_nl, char *dest)
{
	xrecord_t **recs;
	int size = 0;

	recs = (use_orig ? xe->xdf1.recs : xe->xdf2.recs) + i;

	if (count < 1)
		return 0;

	for (i = 0; i < count; size += recs[i++]->size)
		if (dest)
			memcpy(dest + size, recs[i]->ptr, recs[i]->size);
	if (add_nl) {
		i = recs[count - 1]->size;
		if (i == 0 || recs[count - 1]->ptr[i - 1] != '\n') {
			if (needs_cr) {
				if (dest)
					dest[size] = '\r';
				size++;
			}

			if (dest)
				dest[size] = '\n';
			size++;
		}
	}
	return size;
}

// Assembly:
subq $0x38, %rsp
movq 0x40(%rsp), %rax
movl %edi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movl %r9d, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0x30(%rsp)
je 0xa662
movq 0x28(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, (%rsp)
jmp 0xa672
movq 0x28(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movslq 0x24(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
cmpl $0x1, 0x20(%rsp)
jge 0xa69b
movl $0x0, 0x34(%rsp)
jmp 0xa7c2
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0xa718
cmpq $0x0, 0x40(%rsp)
je 0xa6eb
movq 0x40(%rsp), %rdi
movslq 0xc(%rsp), %rax
addq %rax, %rdi
movq 0x10(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdx
callq 0x10e0
jmp 0xa6ed
movq 0x10(%rsp), %rax
movl 0x24(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x24(%rsp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rcx
movslq 0xc(%rsp), %rax
addq %rcx, %rax
movl %eax, 0xc(%rsp)
jmp 0xa6a3
cmpl $0x0, 0x18(%rsp)
je 0xa7ba
movq 0x10(%rsp), %rax
movl 0x20(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0xa76f
movq 0x10(%rsp), %rax
movl 0x20(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0xa7b8
cmpl $0x0, 0x1c(%rsp)
je 0xa797
cmpq $0x0, 0x40(%rsp)
je 0xa78c
movq 0x40(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb $0xd, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0xa7ad
movq 0x40(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb $0xa, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xa7ba
movl 0xc(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xmerge.c
// Function: is_eol_crlf
static int is_eol_crlf(xdfile_t *file, int i)
{
	long size;

	if (i < file->nrec - 1)
		/* All lines before the last *must* end in LF */
		return (size = file->recs[i]->size) > 1 &&
			file->recs[i]->ptr[size - 2] == '\r';
	if (!file->nrec)
		/* Cannot determine eol style from empty file */
		return -1;
	if ((size = file->recs[i]->size) &&
			file->recs[i]->ptr[size - 1] == '\n')
		/* Last line; ends in LF; Is it CR/LF? */
		return size > 1 &&
			file->recs[i]->ptr[size - 2] == '\r';
	if (!i)
		/* The only line has no eol */
		return -1;
	/* Determine eol from second-to-last line */
	return (size = file->recs[i - 1]->size) > 1 &&
		file->recs[i - 1]->ptr[size - 2] == '\r';
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movslq -0x14(%rsp), %rax
movq -0x10(%rsp), %rcx
movq 0x38(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0xa856
movq -0x10(%rsp), %rax
movq 0x60(%rax), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x20(%rsp)
xorl %eax, %eax
cmpq $0x1, %rcx
movb %al, -0x21(%rsp)
jle 0xa844
movq -0x10(%rsp), %rax
movq 0x60(%rax), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq -0x20(%rsp), %rcx
subq $0x2, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
sete %al
movb %al, -0x21(%rsp)
movb -0x21(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
jmp 0xa97e
movq -0x10(%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xa86f
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0xa97e
movq -0x10(%rsp), %rax
movq 0x60(%rax), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, %rax
je 0xa902
movq -0x10(%rsp), %rax
movq 0x60(%rax), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq -0x20(%rsp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0xa902
xorl %eax, %eax
cmpq $0x1, -0x20(%rsp)
movb %al, -0x22(%rsp)
jle 0xa8f3
movq -0x10(%rsp), %rax
movq 0x60(%rax), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq -0x20(%rsp), %rcx
subq $0x2, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
sete %al
movb %al, -0x22(%rsp)
movb -0x22(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
jmp 0xa97e
cmpl $0x0, -0x14(%rsp)
jne 0xa913
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0xa97e
movq -0x10(%rsp), %rax
movq 0x60(%rax), %rax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x20(%rsp)
xorl %eax, %eax
cmpq $0x1, %rcx
movb %al, -0x23(%rsp)
jle 0xa971
movq -0x10(%rsp), %rax
movq 0x60(%rax), %rax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq -0x20(%rsp), %rcx
subq $0x2, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
sete %al
movb %al, -0x23(%rsp)
movb -0x23(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xhistogram.c
// Function: xdl_do_histogram_diff
int xdl_do_histogram_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;

	return histogram_diff(xpp, env,
		env->xdf1.dstart + 1, env->xdf1.dend - env->xdf1.dstart + 1,
		env->xdf2.dstart + 1, env->xdf2.dend - env->xdf2.dstart + 1);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
callq 0x5770
cmpl $0x0, %eax
jge 0xa9ce
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xaa33
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq (%rsp), %rax
movq 0x50(%rax), %rax
addq $0x1, %rax
movl %eax, %edx
movq (%rsp), %rax
movq 0x58(%rax), %rax
movq (%rsp), %rcx
subq 0x50(%rcx), %rax
addq $0x1, %rax
movl %eax, %ecx
movq (%rsp), %rax
movq 0xd8(%rax), %rax
addq $0x1, %rax
movl %eax, %r8d
movq (%rsp), %rax
movq 0xe0(%rax), %rax
movq (%rsp), %r9
subq 0xd8(%r9), %rax
addq $0x1, %rax
movl %eax, %r9d
callq 0xaa40
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/xdiff/xhistogram.c
// Function: find_lcs
static int find_lcs(struct histindex *index, struct region *lcs,
	int line1, int count1, int line2, int count2) {
	int b_ptr;

	if (scanA(index, line1, count1))
		return -1;

	index->cnt = index->max_chain_length + 1;

	for (b_ptr = line2; b_ptr <= LINE_END(2); )
		b_ptr = try_lcs(index, lcs, b_ptr, line1, count1, line2, count2);

	return index->has_common && index->max_chain_length < index->cnt;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl %ecx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movl %r9d, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0xb060
cmpl $0x0, %eax
je 0xaf64
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xaff5
movq 0x28(%rsp), %rax
movl 0x5c(%rax), %ecx
addl $0x1, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x68(%rax)
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl 0x14(%rsp), %ecx
addl 0x10(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0xafc0
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0xc(%rsp), %edx
movl 0x1c(%rsp), %ecx
movl 0x18(%rsp), %r8d
movl 0x14(%rsp), %r9d
movl 0x10(%rsp), %eax
movl %eax, (%rsp)
callq 0xb2e0
movl %eax, 0xc(%rsp)
jmp 0xaf7f
movq 0x28(%rsp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x6c(%rcx)
movb %al, 0xb(%rsp)
je 0xafe8
movq 0x28(%rsp), %rax
movl 0x5c(%rax), %eax
movq 0x28(%rsp), %rcx
cmpl 0x68(%rcx), %eax
setb %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LemonBoy[P]autobahn/main.c
// Function: xmalloc
void *
xmalloc(size_t len)
{
	void *p = malloc(len);

	if (!p)
		die("Out of memory\n");

	return p;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x10f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xb94e
leaq 0x7f5(%rip), %rdi       # 0xc13c
movb $0x0, %al
callq 0xb860
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)