LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/LemonBoy[P]autobahn/xdiff/xdiffi.c
// Function: group_slide_up
static int group_slide_up(xdfile_t *xdf, struct xdlgroup *g, long flags)
{
	if (g->start > 0 &&
	    recs_match(xdf->recs[g->start - 1], xdf->recs[g->end - 1], flags)) {
		xdf->rchg[--g->start] = 1;
		xdf->rchg[--g->end] = 0;

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

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

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

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

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

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

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

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

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

	*xscr = cscr;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movq 0x38(%rdi), %r14
movq 0xc0(%rdi), %rbp
testq %rbp, %r14
js 0x25a6
movq 0x68(%rdi), %r12
movq 0xf0(%rdi), %r13
xorl %edi, %edi
cmpb $0x0, -0x1(%r12,%r14)
jne 0x24fe
cmpb $0x0, -0x1(%r13,%rbp)
je 0x2596
movq $-0x1, %rbx
incq %rbx
cmpb $0x0, -0x1(%r12,%r14)
leaq -0x1(%r14), %r14
jne 0x2505
movq %rdi, (%rsp)
leaq 0x1(%r14), %rax
movq %rax, 0x10(%rsp)
movq $-0x1, %r15
incq %r15
cmpb $0x0, -0x1(%r13,%rbp)
leaq -0x1(%rbp), %rbp
jne 0x2528
movl $0x30, %edi
callq 0x10f0
testq %rax, %rax
je 0x25c5
leaq 0x1(%rbp), %rcx
movq (%rsp), %rdx
movq %rdx, (%rax)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %r15, 0x20(%rax)
movl $0x0, 0x28(%rax)
movq %rbp, %rsi
movq %r14, %rdx
movq %rdi, %r14
movq %rax, %rdi
testq %r14, %r14
movq %rdx, %r14
jg 0x24ea
movq %rsi, %rbp
movq %rdx, %r14
testq %rcx, %rcx
jg 0x24ea
jmp 0x25a8
leaq -0x1(%r14), %rdx
leaq -0x1(%rbp), %rsi
movq %rbp, %rcx
movq %rsi, %rbp
jmp 0x2579
xorl %edi, %edi
movq 0x8(%rsp), %rax
movq %rdi, (%rax)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x25b3
movq (%rdi), %rbx
callq 0x1030
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x25d4
jmp 0x25b3
// File: /workspace/github_c_makefile_star2_O3/LemonBoy[P]autobahn/xdiff/xdiffi.c
// Function: xdl_diff
int xdl_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
	     xdemitconf_t const *xecfg, xdemitcb_t *ecb) {
	xdchange_t *xscr;
	xdfenv_t xe;
	emit_func_t ef = xecfg->hunk_func ? xdl_call_hunk_func : xdl_emit_diff;

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

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

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

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

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

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r12
cmpq $0x0, 0x28(%rcx)
jne 0x2628
leaq 0x9c8(%rip), %r15       # 0x2fee
jmp 0x262f
leaq 0x188(%rip), %r15       # 0x27b7
leaq 0x28(%rsp), %rcx
movq %r12, %rdx
callq 0x1d2d
testl %eax, %eax
js 0x279e
movq %r15, 0x18(%rsp)
leaq 0xb0(%rsp), %r15
movq (%r12), %rdx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x1ea7
movq (%r12), %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x1ea7
leaq 0x20(%rsp), %rsi
movq %r13, %rdi
callq 0x24b6
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x2792
movq 0x20(%rsp), %r15
testq %r15, %r15
je 0x277b
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq (%r12), %r12
testb %r12b, %r12b
jns 0x274e
movq %r15, %r13
cmpq $0x0, 0x18(%r13)
jle 0x26f6
movq 0x8(%r13), %r14
shlq $0x3, %r14
addq 0x88(%rsp), %r14
movl $0x1, %ebx
movq -0x8(%r14,%rbx,8), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movq %r12, %rdx
callq 0x42f6
cmpq 0x18(%r13), %rbx
jge 0x26fb
incq %rbx
testl %eax, %eax
jne 0x26d2
jmp 0x26fb
movl $0x1, %eax
cmpq $0x0, 0x20(%r13)
jle 0x273d
testl %eax, %eax
je 0x273d
movq 0x10(%r13), %r14
shlq $0x3, %r14
addq 0x110(%rsp), %r14
movl $0x1, %ebx
movq -0x8(%r14,%rbx,8), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movq %r12, %rdx
callq 0x42f6
cmpq 0x20(%r13), %rbx
jge 0x273d
incq %rbx
testl %eax, %eax
jne 0x271b
movl %eax, 0x28(%r13)
movq (%r13), %r13
testq %r13, %r13
jne 0x26b6
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq *0x18(%rsp)
testl %eax, %eax
js 0x277f
movq (%r15), %rbx
movq %r15, %rdi
callq 0x1030
movq %rbx, %r15
testq %rbx, %rbx
jne 0x2768
xorl %ebp, %ebp
jmp 0x2792
movq (%r15), %rbx
movq %r15, %rdi
callq 0x1030
movq %rbx, %r15
testq %rbx, %rbx
jne 0x277f
leaq 0x28(%rsp), %rdi
callq 0x4075
jmp 0x27a3
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/LemonBoy[P]autobahn/xdiff/xdiffi.c
// Function: xdl_call_hunk_func
static int xdl_call_hunk_func(xdfenv_t *xe, xdchange_t *xscr, xdemitcb_t *ecb,
			      xdemitconf_t const *xecfg)
{
	xdchange_t *xch, *xche;

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

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

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

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

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

		if (ret >= MAX_INDENT)
			return MAX_INDENT;
	}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %r14, %r14
jle 0x28e2
movq 0x8(%rdi), %r15
callq 0x1150
movq (%rax), %rax
xorl %edx, %edx
xorl %ecx, %ecx
movzbl (%r15,%rcx), %esi
testb $0x20, 0x1(%rax,%rsi,2)
je 0x28d9
cmpl $0x9, %esi
je 0x28b7
cmpl $0x20, %esi
jne 0x28cf
incl %edx
jmp 0x28c7
leal 0x7(%rdx), %esi
testl %edx, %edx
cmovnsl %edx, %esi
andl $-0x8, %esi
addl $0x8, %esi
movl %esi, %edx
cmpl $0xc8, %edx
jge 0x28dd
incq %rcx
cmpq %rcx, %r14
jne 0x289d
jmp 0x28e2
movl %edx, %ebx
jmp 0x28e2
movl $0xc8, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/LemonBoy[P]autobahn/xdiff/xemit.c
// Function: xdl_get_hunk
xdchange_t *xdl_get_hunk(xdchange_t **xscr, xdemitconf_t const *xecfg)
{
	xdchange_t *xch, *xchp, *lxch;
	long max_common = 2 * xecfg->ctxlen + xecfg->interhunkctxlen;
	long max_ignorable = xecfg->ctxlen;
	unsigned long ignored = 0; /* number of ignored blank lines */

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

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

	if (*xscr == NULL)
		return NULL;

	lxch = *xscr;

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

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

	return lxch;
}

// Assembly:
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x2fe7
movq (%rsi), %rcx
leaq (%rcx,%rcx), %r8
addq 0x8(%rsi), %r8
movq %rdx, %rax
cmpl $0x0, 0x28(%rax)
je 0x2f69
movq (%rax), %rsi
testq %rsi, %rsi
je 0x2f58
movq 0x8(%rsi), %r9
movq 0x8(%rax), %r10
addq 0x18(%rax), %r10
subq %r10, %r9
cmpq %rcx, %r9
jl 0x2f61
movq %rsi, (%rdi)
movq %rsi, %rdx
movq (%rax), %rsi
movq %rsi, %rax
testq %rsi, %rsi
jne 0x2f36
testq %rdx, %rdx
je 0x2fe7
movq (%rdx), %r9
testq %r9, %r9
je 0x2fea
movq 0x8(%rdx), %rsi
xorl %edi, %edi
movq %rdx, %rax
movq %rdx, %r10
movq %r9, %rdx
movq %rsi, %r11
addq 0x18(%r10), %r11
movq 0x8(%r9), %rsi
movq %rsi, %r9
subq %r11, %r9
cmpq %r8, %r9
jg 0x2fe6
cmpq %rcx, %r9
jge 0x2fbb
cmpl $0x0, 0x28(%rdx)
sete %r9b
cmpq %r10, %rax
sete %r10b
orb %r9b, %r10b
je 0x2fda
movq %rdx, %rax
xorl %edi, %edi
jmp 0x2fde
cmpq %r10, %rax
je 0x2fd4
movq 0x8(%rax), %r9
leaq (%rsi,%rdi), %r10
addq 0x18(%rax), %r9
subq %r9, %r10
cmpq %r8, %r10
ja 0x2fe6
cmpl $0x0, 0x28(%rdx)
je 0x2fb4
addq 0x20(%rdx), %rdi
movq (%rdx), %r9
testq %r9, %r9
jne 0x2f7f
retq
xorl %eax, %eax
retq
movq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/LemonBoy[P]autobahn/xdiff/xemit.c
// Function: is_empty_rec
static int is_empty_rec(xdfile_t *xdf, long ri)
{
	const char *rec;
	long len = xdl_get_rec(xdf, ri, &rec);

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
leaq 0x8(%rdx), %rax
testq %rdx, %rdx
leaq 0x7(%rsp), %r13
cmovneq %rax, %r13
movl $0x1, %eax
movl $0x50, %ebp
cmoveq %rax, %rbp
xorl %eax, %eax
cmpq %r8, %rcx
setle %cl
sete %dl
testq %rbx, %rbx
sets %sil
orb %dl, %sil
jne 0x36b7
movq %r8, %r15
movq %rdi, %r12
movb %cl, %al
leaq -0x1(,%rax,2), %rax
movq %rax, 0x8(%rsp)
subq %rax, %r15
cmpq 0x38(%r12), %rbx
jge 0x36b7
movq 0x60(%r12), %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
movq %rbp, %r8
callq 0x3566
testq %r14, %r14
je 0x36a6
testq %rax, %rax
jns 0x36d0
testq %rax, %rax
jns 0x36be
cmpq %rbx, %r15
je 0x36b7
addq 0x8(%rsp), %rbx
jns 0x367d
movq $-0x1, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%r14)
jmp 0x36be
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/LemonBoy[P]autobahn/xdiff/xprepare.c
// Function: xdl_clean_mmatch
static int xdl_clean_mmatch(char const *dis, long i, long s, long e) {
	long r, rdis0, rpdis0, rdis1, rpdis1;

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

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

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

// Assembly:
movq %rsi, %rax
subq %rdx, %rax
leaq -0x64(%rsi), %r8
cmpq $0x65, %rax
cmovlq %rdx, %r8
movq %rcx, %rax
subq %rsi, %rax
leaq 0x64(%rsi), %rdx
cmpq $0x65, %rax
cmovlq %rcx, %rdx
cmpq %rsi, %r8
jge 0x4141
leaq -0x1(%rsi), %r9
movl $0x1, %eax
xorl %ecx, %ecx
movzbl (%rdi,%r9), %r10d
cmpl $0x2, %r10d
je 0x40d8
testl %r10d, %r10d
jne 0x40e3
incq %rcx
jmp 0x40db
incq %rax
decq %r9
cmpq %r8, %r9
jge 0x40c3
testq %rcx, %rcx
setne %r8b
cmpq %rsi, %rdx
setg %r9b
andb %r8b, %r9b
cmpb $0x1, %r9b
jne 0x4141
incq %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
movzbl (%rdi,%rsi), %r10d
cmpl $0x2, %r10d
je 0x411b
testl %r10d, %r10d
jne 0x4126
incq %r9
jmp 0x411e
incq %r8
incq %rsi
cmpq %rdx, %rsi
jle 0x4106
testq %r9, %r9
je 0x4141
addq %rcx, %r9
addq %rax, %r8
addq %r8, %r9
shlq $0x2, %r8
xorl %eax, %eax
cmpq %r9, %r8
setl %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/LemonBoy[P]autobahn/xdiff/xutils.c
// Function: xdl_bogosqrt
long xdl_bogosqrt(long n) {
	long i;

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

	return i;
}

// Assembly:
movl $0x1, %eax
testq %rdi, %rdi
jle 0x4161
movq %rdi, %rcx
addq %rax, %rax
shrq $0x2, %rcx
cmpq $0x3, %rdi
movq %rcx, %rdi
ja 0x4151
retq
// File: /workspace/github_c_makefile_star2_O3/LemonBoy[P]autobahn/xdiff/xutils.c
// Function: xdl_emit_diffrec
int xdl_emit_diffrec(char const *rec, long size, char const *pre, long psize,
		     xdemitcb_t *ecb) {
	int i = 2;
	mmbuffer_t mb[3];

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

		return -1;
	}

	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdx, (%rsp)
movq %rcx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x2, %edx
testq %rsi, %rsi
jle 0x41a4
cmpb $0xa, -0x1(%rdi,%rsi)
je 0x41a4
leaq 0x2f8f(%rip), %rax      # 0x7120
movq %rax, 0x20(%rsp)
movq $0x1d, 0x28(%rsp)
movl $0x3, %edx
movq (%r8), %rdi
movq %rsp, %rsi
callq *0x8(%r8)
sarl $0x1f, %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4201
pushq %rbx
movq (%rdi), %rbx
callq 0x1030
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x41f0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/LemonBoy[P]autobahn/xdiff/xutils.c
// Function: xdl_cha_alloc
void *xdl_cha_alloc(chastore_t *cha) {
	chanode_t *ancur;
	void *data;

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

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

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

	return data;
}

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

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

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

	return nl + 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0x42e4
movq %rsi, %r15
movq 0x8(%rdi), %r14
testq %rsi, %rsi
setg %al
testq %r14, %r14
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x42e4
leaq (%r12,%r14), %r13
xorl %ebx, %ebx
movq %r12, %rdi
incq %rbx
movq %r13, %rdx
subq %rdi, %rdx
movl $0xa, %esi
callq 0x10a0
leaq 0x1(%rax), %rdi
testq %rax, %rax
cmoveq %r13, %rdi
cmpq %r15, %rbx
jge 0x42c7
cmpq %r13, %rdi
jb 0x429f
subq %r12, %rdi
je 0x42e6
movq %rdi, %rax
cqto
idivq %rbx
movq %rax, %rcx
movq %r14, %rax
cqto
idivq %rcx
movq %rax, %rbx
jmp 0x42e6
xorl %ebx, %ebx
incq %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/LemonBoy[P]autobahn/xdiff/xutils.c
// Function: xdl_blankline
int xdl_blankline(const char *line, long size, long flags)
{
	long i;

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

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

	return (i == size);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testb $0x1c, %dl
je 0x432d
testq %rbx, %rbx
jle 0x4336
movq %rdi, %r14
callq 0x1150
movq (%rax), %rcx
xorl %eax, %eax
movzbl (%r14,%rax), %edx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0x4338
incq %rax
cmpq %rax, %rbx
jne 0x4314
movq %rbx, %rax
jmp 0x4338
cmpq $0x2, %rbx
setl %al
jmp 0x433e
xorl %eax, %eax
cmpq %rbx, %rax
sete %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %r13
movl $0x1505, %r14d          # imm = 0x1505
testb $0x1c, %r12b
je 0x4698
cmpq %r15, %r13
jae 0x46d7
movzbl (%r13), %ebp
cmpq $0xa, %rbp
je 0x46df
callq 0x1150
movq (%rax), %rsi
testb $0x20, 0x1(%rsi,%rbp,2)
jne 0x45f9
movsbq %bpl, %rax
movq %r14, %rcx
shlq $0x5, %rcx
addq %r14, %rcx
xorq %rax, %rcx
movq %r13, %rax
movq %rcx, %r14
jmp 0x4674
leaq 0x1(%r13), %rdi
movl $0x1, %r8d
movq %rdi, %rax
movq %r8, %rcx
cmpq %r15, %rdi
jae 0x4635
movzbl (%rax), %edi
cmpl $0xa, %edi
sete %dl
je 0x4637
movzwl (%rsi,%rdi,2), %r9d
andl $0x2000, %r9d           # imm = 0x2000
leaq 0x1(%rax), %rdi
leaq 0x1(%rcx), %r8
testw %r9w, %r9w
jne 0x4603
jmp 0x4637
movb $0x1, %dl
decq %rax
testb $0x4, %r12b
jne 0x4674
testb $0x8, %r12b
sete %sil
orb %dl, %sil
je 0x4685
testb $0x10, %r12b
sete %sil
orb %dl, %sil
jne 0x4674
movq %r14, %rdx
shlq $0x5, %rdx
addq %r14, %rdx
movsbq (%r13), %r14
xorq %rdx, %r14
incq %r13
decq %rcx
jne 0x465a
incq %rax
movq %rax, %r13
cmpq %r15, %rax
jb 0x45c2
jmp 0x46e2
movq %r14, %rcx
shlq $0x5, %rcx
addq %r14, %rcx
xorq $0x20, %rcx
jmp 0x45f4
cmpq %r15, %r13
jae 0x46db
movb (%r13), %cl
movl $0x1, %edx
cmpb $0xa, %cl
je 0x46fd
incq %r13
movq %r13, %rax
movq %r14, %rdx
shlq $0x5, %rdx
addq %r14, %rdx
movsbq %cl, %r14
xorq %rdx, %r14
cmpq %r15, %r13
je 0x46f2
movb (%rax), %cl
leaq 0x1(%rax), %r13
cmpb $0xa, %cl
jne 0x46ae
decq %r13
jmp 0x46f5
xorl %ecx, %ecx
jmp 0x46ed
xorl %edx, %edx
jmp 0x46fd
movq %r13, %rax
xorl %ecx, %ecx
cmpl $0xa, %ebp
sete %cl
movq %rax, %r13
addq %rcx, %r13
jmp 0x4700
movq %r15, %r13
xorl %edx, %edx
cmpq %r15, %rax
setb %dl
addq %rdx, %r13
movq %r13, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rsi, %rdx
movb $0x0, -0x9(%rsp)
testq %rsi, %rsi
js 0x4750
je 0x47c1
leaq -0x9(%rsp), %rsi
jmp 0x475b
leaq -0xa(%rsp), %rsi
movb $0x2d, (%rsi)
negq %rdx
decq %rsi
leaq 0x29d9(%rip), %r8       # 0x713e
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
leaq -0x28(%rsp), %r11
movq %rdx, %rcx
movq %rdx, %rax
mulq %r9
shrq $0x3, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
movq %rcx, %r10
subq %rax, %r10
movb (%r8,%r10), %r10b
movb %r10b, (%rsi)
cmpq %r11, %rsi
seta %al
decq %rsi
cmpq $0xa, %rcx
jb 0x47a9
testb %al, %al
jne 0x4774
xorl %eax, %eax
movb %r10b, (%rdi,%rax)
movb 0x2(%rsi,%rax), %r10b
incq %rax
testb %r10b, %r10b
jne 0x47ab
addq %rdi, %rax
jmp 0x47c8
leaq 0x1(%rdi), %rax
movb $0x30, (%rdi)
movb $0x0, (%rax)
subl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/LemonBoy[P]autobahn/xdiff/xutils.c
// Function: xdl_emit_hunk_hdr
int xdl_emit_hunk_hdr(long s1, long c1, long s2, long c2,
		      const char *func, long funclen, xdemitcb_t *ecb) {
	int nb = 0;
	mmbuffer_t mb;
	char buf[128];

	memcpy(buf, "@@ -", 4);
	nb += 4;

	nb += xdl_num_out(buf + nb, c1 ? s1: s1 - 1);

	if (c1 != 1) {
		memcpy(buf + nb, ",", 1);
		nb += 1;

		nb += xdl_num_out(buf + nb, c1);
	}

	memcpy(buf + nb, " +", 2);
	nb += 2;

	nb += xdl_num_out(buf + nb, c2 ? s2: s2 - 1);

	if (c2 != 1) {
		memcpy(buf + nb, ",", 1);
		nb += 1;

		nb += xdl_num_out(buf + nb, c2);
	}

	memcpy(buf + nb, " @@", 3);
	nb += 3;
	if (func && funclen) {
		buf[nb++] = ' ';
		if (funclen > sizeof(buf) - nb - 1)
			funclen = sizeof(buf) - nb - 1;
		memcpy(buf + nb, func, funclen);
		nb += funclen;
	}
	buf[nb++] = '\n';

	mb.ptr = buf;
	mb.size = nb;
	if (ecb->outf(ecb->priv, &mb, 1) < 0)
		return -1;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rsi
leaq 0x4(%rsp), %rdi
movl $0x2d204040, -0x4(%rdi) # imm = 0x2D204040
cmpq $0x1, %r13
sbbq $0x0, %rsi
callq 0x473a
movslq %eax, %rbp
leaq 0x4(%rbp), %rax
cmpq $0x1, %r13
je 0x4833
movb $0x2c, (%rsp,%rax)
movq %rsp, %rax
leaq (%rax,%rbp), %rdi
addq $0x5, %rdi
movq %r13, %rsi
callq 0x473a
addl %ebp, %eax
addl $0x5, %eax
movslq %eax, %r13
leaq (%rsp,%r13), %rdi
addq $0x2, %rdi
movw $0x2b20, -0x2(%rdi)     # imm = 0x2B20
cmpq $0x1, %r15
sbbq $0x0, %r12
movq %r12, %rsi
callq 0x473a
addl %r13d, %eax
addl $0x2, %eax
cmpq $0x1, %r15
je 0x487b
movslq %eax, %r12
leaq (%rsp,%r12), %rdi
incq %rdi
movb $0x2c, -0x1(%rdi)
movq %r15, %rsi
callq 0x473a
addl %r12d, %eax
incl %eax
movq 0xd0(%rsp), %r12
movslq %eax, %r13
movb $0x40, 0x2(%rsp,%r13)
movw $0x4020, (%rsp,%r13)    # imm = 0x4020
leaq 0x3(%r13), %rax
testq %rbx, %rbx
sete %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
jne 0x48d8
movb $0x20, (%rsp,%rax)
movl $0x7b, %r15d
subq %r13, %r15
cmpq %r14, %r15
cmovaeq %r14, %r15
movq %rsp, %rax
leaq (%rax,%r13), %rdi
addq $0x4, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x10e0
leal (%r15,%r13), %eax
addl $0x4, %eax
movslq %eax, %rcx
incl %eax
movb $0xa, (%rsp,%rcx)
movq %rsp, %rcx
leaq 0x88(%rsp), %rsi
movq %rcx, (%rsi)
cltq
movq %rax, 0x8(%rsi)
movq (%r12), %rdi
movl $0x1, %edx
callq *0x8(%r12)
sarl $0x1f, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movl %r9d, %ebx
movl %ecx, %r15d
movl %edx, %eax
movq %rsi, %rdx
movq %rdi, %r14
movq 0x60(%rdi), %rcx
movslq %eax, %r12
movq -0x8(%rcx,%r12,8), %rax
movq 0x8(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leal (%r12,%r15), %esi
movslq %esi, %rsi
movq -0x10(%rcx,%rsi,8), %rcx
movq 0x8(%rcx), %rsi
addq 0x10(%rcx), %rsi
subq %rax, %rsi
movq %rsi, 0x8(%rdi)
movq 0xe8(%r14), %rax
movslq %r8d, %r13
movq -0x8(%rax,%r13,8), %rcx
movq 0x8(%rcx), %rcx
movq %rsp, %rsi
movq %rcx, (%rsi)
leal (%r13,%rbx), %r8d
movslq %r8d, %r8
movq -0x10(%rax,%r8,8), %rax
movq 0x8(%rax), %r8
addq 0x10(%rax), %r8
subq %rcx, %r8
movq %r8, 0x8(%rsi)
leaq 0x20(%rsp), %rcx
callq 0x1d2d
testl %eax, %eax
js 0x49f3
movq 0x68(%r14), %rax
leaq (%rax,%r12), %rdi
decq %rdi
leaq 0x20(%rsp), %r12
movq 0x68(%r12), %rsi
movslq %r15d, %rdx
callq 0x10e0
movq 0xf0(%r14), %rax
leaq (%rax,%r13), %rdi
decq %rdi
movq 0xf0(%r12), %rsi
movslq %ebx, %rdx
callq 0x10e0
movq %r12, %rdi
callq 0x4075
xorl %eax, %eax
jmp 0x49f8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r12
movq 0x58(%rsp), %rbp
movq 0x50(%rsp), %rdi
movq (%r12), %r13
testq %r13, %r13
je 0x554e
movq 0x10(%r13), %rax
movq 0x20(%r13), %rcx
addq %rax, %rcx
cmpq %r14, %rcx
jge 0x55a5
movq 0x28(%r13), %rcx
addq 0x18(%r13), %rcx
cmpq %rdi, %rcx
jge 0x55a5
movl %esi, 0xc(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x40, %edi
callq 0x10f0
testq %rax, %rax
je 0x55e4
movq $0x0, (%rax)
movl 0xc(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rax)
movq %r15, 0x38(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x20(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %rbp, 0x28(%rax)
testq %r13, %r13
je 0x559f
movq %rax, (%r13)
movq %rax, (%r12)
jmp 0x55d3
cmpl %esi, 0x8(%r13)
je 0x55b3
movl $0x0, 0x8(%r13)
addq %rdx, %r15
subq 0x30(%r13), %r15
movq %r15, 0x38(%r13)
addq %r14, %rbx
subq %rax, %rbx
movq %rbx, 0x20(%r13)
addq %rdi, %rbp
subq 0x18(%r13), %rbp
movq %rbp, 0x28(%r13)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x55d5
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
addq $0x88, %rdi
movq 0x10(%rdx), %rax
leal -0x1(%rax), %esi
xorl %ebx, %ebx
testq %rax, %rax
cmovel %ebx, %esi
callq 0x5d57
movl $0x0, %ebp
testl %eax, %eax
je 0x5c80
addq $0x88, %r15
movq 0x18(%r12), %rax
leal -0x1(%rax), %esi
xorl %ebp, %ebp
testq %rax, %rax
cmovel %ebp, %esi
movq %r15, %rdi
callq 0x5d57
testl %eax, %eax
je 0x5c80
movq %r14, %rdi
xorl %esi, %esi
callq 0x5d57
movl %eax, %ebp
testl %ebp, %ebp
cmovgl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x60(%rsi), %rax
addq $0xe8, %rsi
testl %edi, %edi
cmovneq %rax, %rsi
testl %ecx, %ecx
jle 0x5d44
movl %r9d, %r14d
movl %r8d, 0x4(%rsp)
movslq %edx, %r12
shlq $0x3, %r12
addq (%rsi), %r12
movq 0x40(%rsp), %r15
movl %ecx, %r13d
xorl %ebp, %ebp
xorl %ebx, %ebx
testq %r15, %r15
je 0x5cee
movslq %ebx, %rdi
addq %r15, %rdi
movq (%r12,%rbp,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
callq 0x10e0
movq (%r12,%rbp,8), %rax
incq %rbp
addl 0x10(%rax), %ebx
cmpq %rbp, %r13
jne 0x5cd2
testl %r14d, %r14d
je 0x5d46
movq -0x8(%r12,%r13,8), %rcx
movl 0x10(%rcx), %eax
testq %rax, %rax
je 0x5d1d
movq 0x8(%rcx), %rcx
decl %eax
cltq
cmpb $0xa, (%rcx,%rax)
je 0x5d46
cmpl $0x0, 0x4(%rsp)
je 0x5d33
testq %r15, %r15
je 0x5d31
movslq %ebx, %rax
movb $0xd, (%r15,%rax)
incl %ebx
testq %r15, %r15
je 0x5d40
movslq %ebx, %rax
movb $0xa, (%r15,%rax)
incl %ebx
jmp 0x5d46
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq %esi, %rdx
movq 0x38(%rdi), %rcx
leaq -0x1(%rcx), %rax
cmpq %rdx, %rax
jle 0x5d7b
movq 0x60(%rdi), %rax
movq (%rax,%rdx,8), %rax
movq 0x10(%rax), %rcx
cmpq $0x1, %rcx
jg 0x5dc0
jmp 0x5dce
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x5dcd
movq 0x60(%rdi), %rdi
movq (%rdi,%rdx,8), %rcx
movq 0x10(%rcx), %r8
testq %r8, %r8
je 0x5dad
movq 0x8(%rcx), %rcx
cmpb $0xa, -0x1(%rcx,%r8)
jne 0x5dad
cmpq $0x1, %r8
jle 0x5dce
addq %r8, %rcx
jmp 0x5dc4
testl %esi, %esi
je 0x5dcd
movq -0x8(%rdi,%rdx,8), %rax
movq 0x10(%rax), %rcx
cmpq $0x2, %rcx
jl 0x5dce
addq 0x8(%rax), %rcx
xorl %eax, %eax
cmpb $0xd, -0x2(%rcx)
sete %al
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
callq 0x36d8
testl %eax, %eax
js 0x5e19
movl 0x50(%rbx), %edx
movl 0x58(%rbx), %ecx
subl %edx, %ecx
incl %edx
incl %ecx
movl 0xd8(%rbx), %r8d
movl 0xe0(%rbx), %r9d
subl %r8d, %r9d
incl %r8d
incl %r9d
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5e26
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rax
callq 0x10f0
testq %rax, %rax
je 0x66d7
popq %rcx
retq
leaq 0xa6f(%rip), %rdi       # 0x714d
xorl %eax, %eax
callq 0x6630
// File: /workspace/github_c_makefile_star2_O3/LemonBoy[P]autobahn/main.c
// Function: print_ed_cmd
void print_ed_cmd (char cmd, long s1, long e1, long s2, long e2)
{
        // XXX Coalesce all the writes to stdio ?
        if (s1 == e1) printf("%ld", s1); else printf("%ld,%ld", s1, e1);
        putchar(cmd);
        if (s2 == e2) printf("%ld", s2); else printf("%ld,%ld", s2, e2);
        putchar('\n');
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %r8, %r14
movq %rcx, %rbx
movl %edi, %ebp
cmpq %rdx, %rsi
jne 0x6706
leaq 0xa63(%rip), %rdi       # 0x7160
xorl %eax, %eax
callq 0x1080
jmp 0x6714
leaq 0xa4f(%rip), %rdi       # 0x715c
xorl %eax, %eax
callq 0x1080
movsbl %bpl, %edi
callq 0x1040
cmpq %r14, %rbx
jne 0x6735
leaq 0xa37(%rip), %rdi       # 0x7160
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1080
jmp 0x6749
leaq 0xa20(%rip), %rdi       # 0x715c
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1080
movl $0xa, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O3/LemonBoy[P]autobahn/main.c
// Function: print_hunk
int print_hunk (long start_a, long count_a, long start_b, long count_b, void *cb_data)
{
        int s1, e1, s2, e2;

        // Adjust the start-end ranges
        s1 = count_a? start_a + 1: start_a;
        e1 = start_a + count_a;

        s2 = count_b? start_b + 1: start_b;
        e2 = start_b + count_b;

        if (count_b == 0)
                // Delete lines from a
                print_ed_cmd('d', s1, e1, e2, e2);
        else if (count_a == 0)
                // Add lines to a
                print_ed_cmd('a', e1, e1, s2, e2);
        else
                // Change lines
                print_ed_cmd('c', s1, e1, s2, e2);

        seen_hunk = 1;

        return 1;
}

// Assembly:
pushq %rax
cmpq $0x1, %rsi
movq %rdi, %r9
sbbq $-0x1, %r9
leaq (%rsi,%rdi), %r8
xorl %eax, %eax
testq %rcx, %rcx
setne %r10b
je 0x6792
movb %r10b, %al
addq %rdx, %rax
addq %rdx, %rcx
testq %rsi, %rsi
je 0x67a8
movslq %r9d, %rsi
movslq %r8d, %rdx
cltq
movslq %ecx, %r8
movl $0x63, %edi
jmp 0x67b8
movslq %r9d, %rsi
movslq %r8d, %rax
movslq %edx, %rcx
movl $0x64, %edi
movq %rax, %rdx
movq %rcx, %r8
jmp 0x67bb
movslq %edi, %rdx
cltq
movslq %ecx, %r8
movl $0x61, %edi
movq %rdx, %rsi
movq %rax, %rcx
callq 0x66e5
movl $0x1, 0x38fe(%rip)      # 0xa0c8
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/LemonBoy[P]autobahn/main.c
// Function: read_mmfile
void read_mmfile (mmfile_t *mf, const char *path)
{
        FILE *fp;
        struct stat st;
        size_t size;

        if (stat(path, &st))
                die("Could not stat %s\n", path);

        size = st.st_size;

        fp = fopen(path, "r");
        if (fp == NULL)
                die("Could not open %s\n", path);

        mf->ptr = xmalloc(size);
        mf->size = size;

        fread(mf->ptr, 1, size, fp);
        fclose(fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x10d0
testl %eax, %eax
jne 0x684f
movq 0x38(%rsp), %r15
leaq 0x975(%rip), %rsi       # 0x7177
movq %rbx, %rdi
callq 0x1120
testq %rax, %rax
je 0x6858
movq %rax, %r12
movq %r15, %rdi
callq 0x10f0
testq %rax, %rax
je 0x6869
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %r12, %rcx
callq 0x1050
movq %r12, %rdi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1060
leaq 0x90e(%rip), %rdi       # 0x7164
jmp 0x685f
leaq 0x91a(%rip), %rdi       # 0x7179
movq %rbx, %rsi
xorl %eax, %eax
callq 0x6630
leaq 0x8dd(%rip), %rdi       # 0x714d
xorl %eax, %eax
callq 0x6630
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/tests/pthread_mutex1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	while (1) {
		pthread_mutex_lock(&mutex);
		pthread_mutex_unlock(&mutex);

		(*iterations)++;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa49a(%rip), %r14      # 0xc1a8
movq %r14, %rdi
callq 0x1290
movq %r14, %rdi
callq 0x11b0
incq (%rbx)
jmp 0x1d0e
// File: /workspace/github_c_makefile_star2_O3/jalalium[P]graph_algorithms_task/src_scc_para/main_scc_para.c
// Function: generate_graph
t_graph *generate_graph()
{
	t_graph *new = (t_graph*)malloc(sizeof(t_graph));
	new->head = NULL;
	new->tail = NULL;
	new->components = 0;
	if (!get_dimensions(new))
		error(WRONG_INPUT);
	if (!get_edges(new))
		error(WRONG_EDGE);
	new->scc = (int*)malloc(sizeof(int)*new->vertx);
	new->vis = (int*)malloc(sizeof(int)*new->vertx);
	memset(new->scc, -1, sizeof(int) * new->vertx);
	memset(new->vis, 0, sizeof(int) * new->vertx);
	return (new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x40, %edi
callq 0x10b0
movq %rax, %rbx
movl $0x0, 0x30(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %rax, %rdi
callq 0x1a08
testl %eax, %eax
jne 0x1254
xorl %edi, %edi
callq 0x1c18
movq %rbx, %rdi
callq 0x1b3f
testl %eax, %eax
jne 0x126a
movl $0x1, %edi
callq 0x1c18
movslq 0x34(%rbx), %r14
shlq $0x2, %r14
movq %r14, %rdi
callq 0x10b0
movq %rax, %r15
movq %rax, 0x28(%rbx)
movl $0x1, %edi
movq %r14, %rsi
callq 0x1090
movq %rax, 0x20(%rbx)
movq %r15, %rdi
movl $0xff, %esi
movq %r14, %rdx
callq 0x1080
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jalalium[P]graph_algorithms_task/src_scc_para/main_scc_para.c
// Function: init_resource
t_resource	*init_resource(pthread_mutex_t *m, t_vect *v)
{
	t_resource *new = (t_resource*)malloc(sizeof(t_resource));
	new->mtx = m;
	new->list = v;
	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x10b0
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jalalium[P]graph_algorithms_task/src_scc_para/main_scc_para.c
// Function: find
int		find(t_vect *v, int r)
{
	int low = 0;
	int hi = v->used;
	while (low <= hi)
	{
		int mid = (low+hi)/2;
		if (v->tab[mid] == r)
			return 1;
		else if (v->tab[mid] > r)
			hi = mid-1;
		else
			low = mid+1;
	}
	return 0;
}

// Assembly:
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
js 0x1305
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
xorl %edx, %edx
leal (%rcx,%rdx), %edi
shrl %edi
movl (%rax,%rdi,4), %r8d
cmpl %esi, %r8d
je 0x1308
jg 0x12f9
incl %edi
movl %edi, %edx
jmp 0x12fd
decl %edi
movl %edi, %ecx
cmpl %ecx, %edx
jle 0x12e3
xorl %eax, %eax
jmp 0x130d
xorl %eax, %eax
retq
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jalalium[P]graph_algorithms_task/src_scc_para/main_scc_para.c
// Function: main
int main()
{
	pthread_t ol;
	pthread_mutex_t mutex;
	t_vect new;

	G = generate_graph();
	pthread_mutex_init(&mutex, NULL);
	//puts all vertices as the first problem
	initiate_vertices(&new);
	t_resource *res = init_resource(&mutex, &new);
	pthread_create(&ol, NULL, kernel, res);
	pthread_join(ol, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
callq 0x121c
movq %rax, 0x27bb(%rip)      # 0x40a8
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1100
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x1897
movl $0x10, %edi
callq 0x10b0
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
leaq -0x610(%rip), %rdx      # 0x130f
leaq -0x18(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rcx
callq 0x10c0
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x10f0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)