LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x42fc
cmpb $0xa, -0x1(%rdi,%rsi)
je 0x42fc
leaq 0x2e37(%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_O1/LemonBoy[P]autobahn/xdiff/xutils.c
// Function: xdl_cha_init
int xdl_cha_init(chastore_t *cha, long isize, long icount) {

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

	return 0;
}

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, 0x10(%rdi)
imulq %rsi, %rdx
movq %rdx, 0x18(%rdi)
movups %xmm0, 0x20(%rdi)
movq $0x0, 0x30(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4359
pushq %rbx
movq (%rdi), %rbx
callq 0x1030
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x4348
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4371
movq 0x8(%rax), %rcx
cmpq 0x18(%rbx), %rcx
jne 0x43a6
movq 0x18(%rbx), %rdi
addq $0x10, %rdi
callq 0x10e0
testq %rax, %rax
je 0x43bc
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x4395
movq %rax, (%rcx)
cmpq $0x0, (%rbx)
jne 0x439e
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
movq %rax, 0x20(%rbx)
movq 0x8(%rax), %rdx
leaq (%rax,%rdx), %rcx
addq $0x10, %rcx
addq 0x10(%rbx), %rdx
movq %rdx, 0x8(%rax)
jmp 0x43be
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq 0x8(%rdi), %rbx
testq %r12, %r12
je 0x4422
movq %rsi, %r15
testq %rsi, %rsi
setg %al
testq %rbx, %rbx
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x4429
leaq (%r12,%rbx), %r13
xorl %r14d, %r14d
movq %r12, %rdi
incq %r14
movq %r13, %rdx
subq %rdi, %rdx
movl $0xa, %esi
callq 0x10a0
leaq 0x1(%rax), %rdi
testq %rax, %rax
cmoveq %r13, %rdi
cmpq %r15, %r14
jge 0x442f
cmpq %r13, %rdi
jb 0x43f8
jmp 0x442f
xorl %edi, %edi
xorl %r14d, %r14d
jmp 0x4432
xorl %r14d, %r14d
movq %r12, %rdi
subq %r12, %rdi
testq %r14, %r14
je 0x4452
testq %rdi, %rdi
je 0x4452
movq %rdi, %rax
cqto
idivq %r14
movq %rax, %rcx
movq %rbx, %rax
cqto
idivq %rcx
movq %rax, %r14
incq %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4499
testq %rbx, %rbx
jle 0x44a2
movq %rdi, %r14
callq 0x1140
movq (%rax), %rcx
xorl %eax, %eax
movzbl (%r14,%rax), %edx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0x44a4
incq %rax
cmpq %rax, %rbx
jne 0x4480
movq %rbx, %rax
jmp 0x44a4
cmpq $0x2, %rbx
setl %al
jmp 0x44aa
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_O1/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 %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r12
cmpq %rsi, %r12
setb %dl
movl $0x1505, %eax           # imm = 0x1505
testb $0x1c, %r15b
je 0x48e1
cmpq %r14, %r12
jae 0x4927
movb (%r12), %bpl
movb $0x1, %dl
cmpb $0xa, %bpl
je 0x4927
callq 0x1140
movq (%rax), %rcx
movl $0x1505, %eax           # imm = 0x1505
movzbl %bpl, %edx
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x4830
movq %rax, %rdx
shlq $0x5, %rdx
addq %rax, %rdx
movsbq %bpl, %rax
xorq %rdx, %rax
movq %r12, %rdx
jmp 0x48c3
leaq 0x1(%r12), %r8
movl $0x1, %r9d
movq %r8, %rdx
movq %r9, %rsi
cmpq %r14, %r8
jae 0x4870
movzbl (%rdx), %r8d
cmpl $0xa, %r8d
sete %dil
je 0x4873
movzwl (%rcx,%r8,2), %r10d
andl $0x2000, %r10d          # imm = 0x2000
leaq 0x1(%rdx), %r8
leaq 0x1(%rsi), %r9
testw %r10w, %r10w
jne 0x483b
jmp 0x4873
movb $0x1, %dil
decq %rdx
testb $0x4, %r15b
jne 0x48c3
testb $0x8, %r15b
sete %r8b
orb %dil, %r8b
je 0x48b2
testb $0x10, %r15b
sete %r8b
orb %dil, %r8b
jne 0x48c3
movq %rax, %rdi
shlq $0x5, %rdi
addq %rax, %rdi
movsbq (%r12), %rax
xorq %rdi, %rax
incq %r12
decq %rsi
jne 0x4896
jmp 0x48c3
movq %rax, %rsi
shlq $0x5, %rsi
addq %rax, %rsi
xorq $0x20, %rsi
movq %rsi, %rax
movq %rdx, %r12
incq %r12
cmpq %r14, %r12
setb %dl
jae 0x4927
movb (%r12), %bpl
cmpb $0xa, %bpl
jne 0x480c
jmp 0x4927
cmpq %r14, %r12
jae 0x4927
movb (%r12), %sil
cmpb $0xa, %sil
je 0x4927
incq %r12
movq %r12, %rcx
movq %rax, %rdx
shlq $0x5, %rdx
addq %rax, %rdx
movsbq %sil, %rax
xorq %rdx, %rax
cmpq %r14, %r12
je 0x491e
movb (%rcx), %sil
leaq 0x1(%rcx), %r12
cmpb $0xa, %sil
jne 0x48f3
decq %r12
jmp 0x4921
movq %r14, %r12
cmpq %r14, %rcx
setb %dl
movzbl %dl, %ecx
addq %r12, %rcx
movq %rcx, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4972
leaq -0x9(%rsp), %rsi
jmp 0x497d
leaq -0xa(%rsp), %rsi
movb $0x2d, (%rsi)
negq %rdx
testq %rdx, %rdx
je 0x49d2
decq %rsi
leaq 0x27b2(%rip), %r8       # 0x713e
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
leaq -0x28(%rsp), %r10
movq %rdx, %rcx
movq %rdx, %rax
mulq %r9
shrq $0x3, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
movq %rcx, %r11
subq %rax, %r11
movb (%r8,%r11), %al
movb %al, (%rsi)
cmpq %r10, %rsi
seta %al
decq %rsi
cmpq $0xa, %rcx
jb 0x49cf
testb %al, %al
jne 0x499b
incq %rsi
cmpb $0x0, (%rsi)
je 0x49f6
movb (%rsi), %cl
movq %rdi, %rax
testb %cl, %cl
je 0x49fd
incq %rsi
movq %rdi, %rax
movb %cl, (%rax)
incq %rax
movb (%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0x49e6
jmp 0x49fd
leaq 0x1(%rdi), %rax
movb $0x30, (%rdi)
movb $0x0, (%rax)
subl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x495e
movslq %eax, %rbp
leaq 0x4(%rbp), %rax
cmpq $0x1, %r13
je 0x4a68
movb $0x2c, (%rsp,%rax)
movq %rsp, %rax
leaq (%rax,%rbp), %rdi
addq $0x5, %rdi
movq %r13, %rsi
callq 0x495e
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 0x495e
addl %r13d, %eax
addl $0x2, %eax
cmpq $0x1, %r15
je 0x4ab0
movslq %eax, %r12
leaq (%rsp,%r12), %rdi
incq %rdi
movb $0x2c, -0x1(%rdi)
movq %r15, %rsi
callq 0x495e
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 0x4b0d
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 0x10d0
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_O1/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 0x1d47
testl %eax, %eax
js 0x4c28
movq 0x68(%r14), %rax
leaq (%rax,%r12), %rdi
decq %rdi
leaq 0x20(%rsp), %r12
movq 0x68(%r12), %rsi
movslq %r15d, %rdx
callq 0x10d0
movq 0xf0(%r14), %rax
leaq (%rax,%r13), %rdi
decq %rdi
movq 0xf0(%r12), %rsi
movslq %ebx, %rdx
callq 0x10d0
movq %r12, %rdi
callq 0x41c6
xorl %eax, %eax
jmp 0x4c2d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x57da
movq 0x10(%r13), %rax
movq 0x20(%r13), %rcx
addq %rax, %rcx
cmpq %r14, %rcx
jge 0x5831
movq 0x28(%r13), %rcx
addq 0x18(%r13), %rcx
cmpq %rdi, %rcx
jge 0x5831
movl %esi, 0xc(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x40, %edi
callq 0x10e0
testq %rax, %rax
je 0x5870
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 0x582b
movq %rax, (%r13)
movq %rax, (%r12)
jmp 0x585f
cmpl %esi, 0x8(%r13)
je 0x583f
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 0x5861
// File: /workspace/github_c_makefile_star2_O1/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 0x5fdf
movl $0x0, %ebp
testl %eax, %eax
je 0x5f08
addq $0x88, %r15
movq 0x18(%r12), %rax
leal -0x1(%rax), %esi
xorl %ebp, %ebp
testq %rax, %rax
cmovel %ebp, %esi
movq %r15, %rdi
callq 0x5fdf
testl %eax, %eax
je 0x5f08
movq %r14, %rdi
xorl %esi, %esi
callq 0x5fdf
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_O1/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 0x5fcc
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 0x5f76
movslq %ebx, %rdi
addq %r15, %rdi
movq (%r12,%rbp,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
callq 0x10d0
movq (%r12,%rbp,8), %rax
incq %rbp
addl 0x10(%rax), %ebx
cmpq %rbp, %r13
jne 0x5f5a
testl %r14d, %r14d
je 0x5fce
movq -0x8(%r12,%r13,8), %rcx
movl 0x10(%rcx), %eax
testq %rax, %rax
je 0x5fa5
movq 0x8(%rcx), %rcx
decl %eax
cltq
cmpb $0xa, (%rcx,%rax)
je 0x5fce
cmpl $0x0, 0x4(%rsp)
je 0x5fbb
testq %r15, %r15
je 0x5fb9
movslq %ebx, %rax
movb $0xd, (%r15,%rax)
incl %ebx
testq %r15, %r15
je 0x5fc8
movslq %ebx, %rax
movb $0xa, (%r15,%rax)
incl %ebx
jmp 0x5fce
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_O1/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 0x6003
movq 0x60(%rdi), %rax
movq (%rax,%rdx,8), %rax
movq 0x10(%rax), %rcx
cmpq $0x1, %rcx
jg 0x6048
jmp 0x6056
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x6055
movq 0x60(%rdi), %rdi
movq (%rdi,%rdx,8), %rcx
movq 0x10(%rcx), %r8
testq %r8, %r8
je 0x6035
movq 0x8(%rcx), %rcx
cmpb $0xa, -0x1(%rcx,%r8)
jne 0x6035
cmpq $0x1, %r8
jle 0x6056
addq %r8, %rcx
jmp 0x604c
testl %esi, %esi
je 0x6055
movq -0x8(%rdi,%rdx,8), %rax
movq 0x10(%rax), %rcx
cmpq $0x2, %rcx
jl 0x6056
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_O1/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 0x37e4
testl %eax, %eax
js 0x60a1
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 0x60ae
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10e0
testq %rax, %rax
je 0x698f
popq %rcx
retq
leaq 0x7b7(%rip), %rdi       # 0x714d
xorl %eax, %eax
callq 0x68e8
// File: /workspace/github_c_makefile_star2_O1/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 0x69be
leaq 0x7ab(%rip), %rdi       # 0x7160
xorl %eax, %eax
callq 0x1080
jmp 0x69cc
leaq 0x797(%rip), %rdi       # 0x715c
xorl %eax, %eax
callq 0x1080
movsbl %bpl, %edi
callq 0x1040
cmpq %r14, %rbx
jne 0x69ed
leaq 0x77f(%rip), %rdi       # 0x7160
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1080
jmp 0x6a01
leaq 0x768(%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_O1/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 0x6a4a
movb %r10b, %al
addq %rdx, %rax
addq %rdx, %rcx
testq %rsi, %rsi
je 0x6a60
movslq %r9d, %rsi
movslq %r8d, %rdx
cltq
movslq %ecx, %r8
movl $0x63, %edi
jmp 0x6a70
movslq %r9d, %rsi
movslq %r8d, %rax
movslq %edx, %rcx
movl $0x64, %edi
movq %rax, %rdx
movq %rcx, %r8
jmp 0x6a73
movslq %edi, %rdx
cltq
movslq %ecx, %r8
movl $0x61, %edi
movq %rdx, %rsi
movq %rax, %rcx
callq 0x699d
movl $0x1, 0x363e(%rip)      # 0xa0c0
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10c0
testl %eax, %eax
jne 0x6b07
movq 0x38(%rsp), %r15
leaq 0x6bd(%rip), %rsi       # 0x7177
movq %rbx, %rdi
callq 0x1110
testq %rax, %rax
je 0x6b10
movq %rax, %r12
movq %r15, %rdi
callq 0x10e0
testq %rax, %rax
je 0x6b21
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 0x656(%rip), %rdi       # 0x7164
jmp 0x6b17
leaq 0x662(%rip), %rdi       # 0x7179
movq %rbx, %rsi
xorl %eax, %eax
callq 0x68e8
leaq 0x625(%rip), %rdi       # 0x714d
xorl %eax, %eax
callq 0x68e8
// File: /workspace/github_c_makefile_star2_O1/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 0xa53a(%rip), %r14      # 0xc1a8
movq %r14, %rdi
callq 0x1290
movq %r14, %rdi
callq 0x11b0
incq (%rbx)
jmp 0x1c6e
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movl $0x40, %edi
callq 0x10a0
movq %rax, %rbx
movl $0x0, 0x30(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %rax, %rdi
callq 0x1a56
testl %eax, %eax
jne 0x1245
xorl %edi, %edi
callq 0x1c94
movq %rbx, %rdi
callq 0x1b8d
testl %eax, %eax
jne 0x125b
movl $0x1, %edi
callq 0x1c94
movslq 0x34(%rbx), %r14
shlq $0x2, %r14
movq %r14, %rdi
callq 0x10a0
movq %rax, %r15
movq %rax, 0x28(%rbx)
movq %r14, %rdi
callq 0x10a0
movq %rax, %r12
movq %rax, 0x20(%rbx)
movq %r15, %rdi
movl $0xff, %esi
movq %r14, %rdx
callq 0x1080
movq %r12, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1080
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10a0
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rdi), %ecx
xorl %eax, %eax
xorl %edx, %edx
cmpl %ecx, %edx
jg 0x1309
leal (%rcx,%rdx), %r9d
shrl %r9d
movq (%rdi), %r8
movl (%r8,%r9,4), %r8d
cmpl %esi, %r8d
je 0x12ff
jg 0x12f9
incl %r9d
movl %r9d, %edx
jmp 0x12ff
decl %r9d
movl %r9d, %ecx
cmpl %esi, %r8d
jne 0x12d8
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x120c
movq %rax, 0x2794(%rip)      # 0x40a0
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10f0
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x18b6
movl $0x10, %edi
callq 0x10a0
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
leaq -0x633(%rip), %rdx      # 0x130b
leaq -0x18(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rcx
callq 0x10b0
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x10e0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jalalium[P]graph_algorithms_task/src_scc_para/create_graph.c
// Function: init_adj
int	init_adj(t_graph *g)
{
	if(!(g->adj = (t_vect*)malloc(sizeof(t_vect)*g->vertx)))
		return 0;
	if(!(g->rev_adj = (t_vect*)malloc(sizeof(t_vect)*g->vertx)))
		return 0;
	for (int i = 0; i < g->vertx; i++)
		if (!(init_vector(&g->adj[i])))
			return 0;
	for (int i = 0; i < g->vertx; i++)
		if (!(init_vector(&g->rev_adj[i])))
			return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x34(%rdi), %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %r15
movq %r15, %rdi
callq 0x10a0
movq %rax, (%rbx)
xorl %r14d, %r14d
testq %rax, %rax
je 0x1a44
movq %r15, %rdi
callq 0x10a0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x1a44
cmpl $0x0, 0x34(%rbx)
setg %r15b
jle 0x19fd
movq (%rbx), %rdi
callq 0x1d48
testl %eax, %eax
je 0x19f8
movl $0x18, %edi
xorl %r12d, %r12d
incq %r12
movslq 0x34(%rbx), %rax
cmpq %rax, %r12
setl %r15b
jge 0x19fd
leaq 0x18(%rdi), %r13
addq (%rbx), %rdi
callq 0x1d48
movq %r13, %rdi
testl %eax, %eax
jne 0x19d5
testb %r15b, %r15b
jne 0x1a44
cmpl $0x0, 0x34(%rbx)
setle %r14b
jle 0x1a40
movq 0x8(%rbx), %rdi
callq 0x1d48
testl %eax, %eax
je 0x1a40
movl $0x18, %edi
xorl %r15d, %r15d
incq %r15
movslq 0x34(%rbx), %rax
cmpq %rax, %r15
setge %r14b
jge 0x1a40
leaq 0x18(%rdi), %r12
addq 0x8(%rbx), %rdi
callq 0x1d48
movq %r12, %rdi
testl %eax, %eax
jne 0x1a1c
movzbl %r14b, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jalalium[P]graph_algorithms_task/src_scc_para/create_graph.c
// Function: get_dimensions
int		get_dimensions(t_graph *new)
{
	int n,m;

	scanf("%d %d", &n, &m);
	if (!valid_dimensions(n,m,new))
	{
		free(new);
		return 0;
	}
	if (!init_adj(new))
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x5b5(%rip), %rdi       # 0x2024
xorl %ebx, %ebx
leaq -0x28(%rbp), %r15
leaq -0x24(%rbp), %r12
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x10c0
movl (%r15), %edi
movl (%r12), %esi
movq %r14, %rdx
callq 0x1e2c
movq %r14, %rdi
testl %eax, %eax
je 0x1aa5
callq 0x196e
movl %eax, %ebx
jmp 0x1aaa
callq 0x1030
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jalalium[P]graph_algorithms_task/src_scc_para/stack.c
// Function: pop
void	pop(t_stack *stk)
{
	t_layer		*tmp;

	if (stk->size <= 0)
		return ;
	if (stk->size == 1)
	{
		free(stk->top);
		stk->size--;
		return ;
	}
	tmp = stk->top->prev;
	free(stk->top);
	stk->top = tmp;
	stk->top->next = NULL;
	stk->size--;
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1d01
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x1, %rax
jne 0x1ce3
movq (%rbx), %rdi
callq 0x1030
jmp 0x1cf9
movq (%rbx), %rdi
movq (%rdi), %r14
callq 0x1030
movq %r14, (%rbx)
movq $0x0, 0x8(%r14)
decq 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jalalium[P]graph_algorithms_task/src_scc_para/stack.c
// Function: push
void	push(t_stack *stk, int val)
{
	t_layer *new = (t_layer*)malloc(sizeof(t_layer));
	
	new->val = val;
	if (stk->size == 0)
		stk->top = new;
	else
	{
		new->next = NULL;
		new->prev = stk->top;
		stk->top->next = new;
		stk->top = new;
	}
	stk->size++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl $0x18, %edi
callq 0x10a0
movl %r14d, 0x10(%rax)
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x1d38
movq $0x0, 0x8(%rax)
movq (%rbx), %rdx
movq %rdx, (%rax)
movq %rax, 0x8(%rdx)
movq %rax, (%rbx)
incq %rcx
movq %rcx, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/jalalium[P]graph_algorithms_task/src_scc_para/validation.c
// Function: valid_edge
int		valid_edge(t_pair *got, int i, t_graph *g)
{
	got[i].x--;
	got[i].y--;
	if (got[i].x < 0 || got[i].x >= g->vertx)
	   return 0;
	if (got[i].y < 0 || got[i].y >= g->vertx)
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rax
movl (%rdi,%rax,8), %esi
movl 0x4(%rdi,%rax,8), %ecx
leal -0x1(%rsi), %r8d
movl %r8d, (%rdi,%rax,8)
leal -0x1(%rcx), %r8d
movl %r8d, 0x4(%rdi,%rax,8)
xorl %eax, %eax
testl %esi, %esi
jle 0x1e89
movl 0x34(%rdx), %edx
cmpl %edx, %esi
jg 0x1e89
testl %ecx, %ecx
setg %al
cmpl %edx, %ecx
setle %cl
andb %al, %cl
movzbl %cl, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/http-server.c
// Function: on_sock_connection
static int on_sock_connection(void *poller, struct poller_item *item)
{
	struct sockaddr addr;
	socklen_t len = sizeof(addr);
	struct loop_ctx *ctx = item->data;
	struct connection *conn;
	struct io_req *req;

	int rc, peer;

	peer = accept4(item->fd, &addr, &len, SOCK_CLOEXEC | SOCK_NONBLOCK);
	if (peer < 0) {
		switch (errno) {
		case EWOULDBLOCK:
			break;
		case EMFILE:
		case ENFILE:
		case ENOBUFS:
		case ENOMEM:
		default:
			err(EXIT_FAILURE, "accept4 failed: errno=%d\n", errno);

			return rc;
		}

		return 0;
	}

	conn = calloc(1, sizeof(*conn));
	assert(conn);

	conn->ctx = ctx;
	conn->sock = peer;
	io_queue_init(&conn->cli_q);

	rc = io_queue_bind(&conn->cli_q, poller, peer);
	assert(rc == 0);

	req = io_req_create(&conn->cli_q, REQ_RD, conn,
			    on_read__from_client);
	assert(req);

	req->buf = (struct io_buf){
		.iov_num  = 1,
		.is_vari_len = true
	};
	rc = io_queue_submit(req);
	assert(rc == 0);

	/* Do not propagate an error up to avoid IO loop exit */
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %rdx
movl $0x10, (%rdx)
movq 0x10(%rsi), %r15
movl (%rsi), %edi
leaq 0x8(%rsp), %rsi
movl $0x80800, %ecx          # imm = 0x80800
callq 0x10b0
testl %eax, %eax
js 0x1932
movl %eax, %ebp
movl $0x1, %edi
movl $0x198, %esi            # imm = 0x198
callq 0x1140
testq %rax, %rax
je 0x194b
movq %rax, %r14
movq %r15, (%rax)
movl %ebp, 0x190(%rax)
movq %rax, %r15
addq $0x8, %r15
movq %r15, %rdi
callq 0x2fcd
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x30bf
testl %eax, %eax
jne 0x196a
leaq 0x162(%rip), %rcx       # 0x1a1a
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x3c1c
testq %rax, %rax
je 0x1989
movq %rax, %rbx
movq %rax, %rdi
addq $0x28, %rdi
movl $0x120, %edx            # imm = 0x120
xorl %esi, %esi
callq 0x10e0
movq $0x1, 0x148(%rbx)
movb $0x1, 0x150(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x151(%rbx)
movups %xmm0, 0x160(%rbx)
movq %rbx, %rdi
callq 0x3941
testl %eax, %eax
je 0x193e
leaq 0x3864(%rip), %rdi      # 0x517e
leaq 0x376f(%rip), %rsi      # 0x5090
leaq 0x3821(%rip), %rcx      # 0x5149
movl $0xf5, %edx
callq 0x10d0
callq 0x1050
movl (%rax), %edx
cmpl $0xb, %edx
jne 0x19a8
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x37f2(%rip), %rdi      # 0x5144
leaq 0x3737(%rip), %rsi      # 0x5090
leaq 0x37e9(%rip), %rcx      # 0x5149
movl $0xe3, %edx
callq 0x10d0
leaq 0x380d(%rip), %rdi      # 0x517e
leaq 0x3718(%rip), %rsi      # 0x5090
leaq 0x37ca(%rip), %rcx      # 0x5149
movl $0xea, %edx
callq 0x10d0
leaq 0x38d3(%rip), %rdi      # 0x5263
leaq 0x36f9(%rip), %rsi      # 0x5090
leaq 0x37ab(%rip), %rcx      # 0x5149
movl $0xee, %edx
callq 0x10d0
leaq 0x377b(%rip), %rsi      # 0x512a
movl $0x1, %edi
xorl %eax, %eax
callq 0x1190
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/http-server.c
// Function: on_signal
static int on_signal(struct io_req *req, int err)
{
	struct signalfd_siginfo *siginfo;
	struct loop_ctx *ctx = req->data;

	if (err < 0)
		return err;

	assert(err == sizeof(struct signalfd_siginfo));
	siginfo = req->buf.iov[0].iov_base;
	assert(siginfo->ssi_signo == SIGINT);

	/* Graceful exit */
	ctx->shutdown = true;

	return err;
}

// Assembly:
pushq %rax
testl %esi, %esi
js 0x19d8
cmpl $0x80, %esi
jne 0x19dc
movq 0x28(%rdi), %rax
cmpl $0x2, (%rax)
jne 0x19fb
movq 0x18(%rdi), %rax
movb $0x1, (%rax)
movl %esi, %eax
popq %rcx
retq
leaq 0x3807(%rip), %rdi      # 0x51ea
leaq 0x36a6(%rip), %rsi      # 0x5090
leaq 0x3820(%rip), %rcx      # 0x5211
movl $0x49, %edx
callq 0x10d0
leaq 0x3833(%rip), %rdi      # 0x5235
leaq 0x3687(%rip), %rsi      # 0x5090
leaq 0x3801(%rip), %rcx      # 0x5211
movl $0x4b, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/http-server.c
// Function: on_read__from_client
static int on_read__from_client(struct io_req *req, int len)
{
	struct connection *conn = req->data;
	struct io_req *wr_req;
	int rc;

	if (len < 0) {
		io_req_put(req);
		list_add_tail(&conn->dead_entry, &conn->ctx->dead_conns);
		/* Propagate error up */
		return len;
	}
	if (!strnstr(req->buf.iov[0].iov_base, "\r\n\r\n", len)) {
		/* Not enough, continue */
		return 0;
	}
	io_req_put(req);

	wr_req = io_req_create(&conn->cli_q, REQ_WR, conn,
			       on_write__to_client);
	assert(wr_req);

	wr_req->buf = (struct io_buf){
		.iov[0] = {
			.iov_base = (void *)http_response,
			.iov_len  = strlen(http_response)
		},
		.iov_num  = 1,
	};
	rc = io_queue_submit(wr_req);
	assert(rc == 0);

	/* Request will be put by the queue */
	return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq 0x18(%rdi), %r14
testl %esi, %esi
js 0x1afb
cmpl $0x4, %ebx
jb 0x1af7
movl %ebx, %ecx
movq 0x28(%rdi), %rax
cmpl $0xa0d0a0d, (%rax)      # imm = 0xA0D0A0D
je 0x1a52
decq %rcx
incq %rax
cmpq $0x3, %rcx
ja 0x1a3c
xorl %eax, %eax
testq %rax, %rax
je 0x1af7
callq 0x3cb2
leaq 0x8(%r14), %rdi
leaq 0xe3(%rip), %rcx        # 0x1b4e
movl $0x1, %esi
movq %r14, %rdx
callq 0x3c1c
testq %rax, %rax
je 0x1b2f
movq %rax, %r14
movq 0x66a5(%rip), %r15      # 0x8130
movq %r15, %rdi
callq 0x10a0
movq %r15, 0x28(%r14)
movq %rax, 0x30(%r14)
movq %r14, %rdi
addq $0x38, %rdi
movl $0x110, %edx            # imm = 0x110
xorl %esi, %esi
callq 0x10e0
movq $0x1, 0x148(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%r14)
movups %xmm0, 0x160(%r14)
movq %r14, %rdi
callq 0x3941
testl %eax, %eax
je 0x1b27
leaq 0x369f(%rip), %rdi      # 0x517e
leaq 0x35aa(%rip), %rsi      # 0x5090
leaq 0x36a0(%rip), %rcx      # 0x518d
movl $0xc0, %edx
callq 0x10d0
xorl %ebx, %ebx
jmp 0x1b27
callq 0x3cb2
leaq 0x180(%r14), %rax
movq (%r14), %rcx
leaq 0x8(%rcx), %rdx
movq 0x10(%rcx), %rsi
movq %rax, 0x10(%rcx)
movq %rdx, 0x180(%r14)
movq %rsi, 0x188(%r14)
movq %rax, (%rsi)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3650(%rip), %rdi      # 0x5186
leaq 0x3553(%rip), %rsi      # 0x5090
leaq 0x3649(%rip), %rcx      # 0x518d
movl $0xb6, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/http-server.c
// Function: on_write__to_client
static int on_write__to_client(struct io_req *req, int len)
{
	struct connection *conn = req->data;
	int rc;

	io_req_put(req);
	if (len < 0) {
		list_add_tail(&conn->dead_entry, &conn->ctx->dead_conns);
	} else {
		req = io_req_create(&conn->cli_q, REQ_RD, conn,
				    on_read__from_client);
		assert(req);

		req->buf = (struct io_buf){
			.iov_num  = 1,
			.is_vari_len = true
		};
		rc = io_queue_submit(req);
		assert(rc == 0);
	}

	return len;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x18(%rdi), %r14
callq 0x3cb2
testl %ebx, %ebx
js 0x1bea
leaq 0x8(%r14), %rdi
leaq -0x156(%rip), %rcx      # 0x1a1a
xorl %esi, %esi
movq %r14, %rdx
callq 0x3c1c
testq %rax, %rax
je 0x1c1b
movq %rax, %r14
movq %rax, %rdi
addq $0x28, %rdi
movl $0x120, %edx            # imm = 0x120
xorl %esi, %esi
callq 0x10e0
movq $0x1, 0x148(%r14)
movb $0x1, 0x150(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x151(%r14)
movups %xmm0, 0x160(%r14)
movq %r14, %rdi
callq 0x3941
testl %eax, %eax
je 0x1c11
leaq 0x35ac(%rip), %rdi      # 0x517e
leaq 0x34b7(%rip), %rsi      # 0x5090
leaq 0x35dc(%rip), %rcx      # 0x51bc
movl $0x96, %edx
callq 0x10d0
leaq 0x180(%r14), %rax
movq (%r14), %rcx
leaq 0x8(%rcx), %rdx
movq 0x10(%rcx), %rsi
movq %rax, 0x10(%rcx)
movq %rdx, 0x180(%r14)
movq %rsi, 0x188(%r14)
movq %rax, (%rsi)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3641(%rip), %rdi      # 0x5263
leaq 0x3467(%rip), %rsi      # 0x5090
leaq 0x358c(%rip), %rcx      # 0x51bc
movl $0x8f, %edx
callq 0x10d0
nop
// File: /workspace/github_c_makefile_star2_O1/jkbenaim[P]psfrag/psfrag.c
// Function: print_usage
void print_usage()
{
	fprintf(stderr, PROGRAM_NAME " version " VERSION_STRING
			", Copyright (C) 2019 jrra.\n"
			"A utility for code fragments in the Pokemon Stadium games.\n\n"
			"usage: " PROGRAM_NAME " <cmd>\n\n"
			"Commands:\n"
		);
	int cmds_index = 0;
	while (cmds[cmds_index].command) {
		fprintf(stderr, "\t%s\n", cmds[cmds_index].help);
		cmds_index++;
	}
	fprintf(stderr, "\nReport bugs to " URL_STRING "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0xa1c44(%rip), %r14     # 0xa9ff0
movq (%r14), %rcx
leaq 0x7edfb(%rip), %rdi     # 0x871b1
pushq $0x1
popq %rdx
movl $0x88, %esi
callq 0x82e0
cmpq $0x0, 0xa1e15(%rip)     # 0xaa1e0
je 0x83f6
leaq 0xa1e24(%rip), %r15     # 0xaa1f8
leaq 0x7ee5f(%rip), %rbx     # 0x8723a
movq (%r14), %rdi
movq -0x10(%r15), %rdx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x81b0
cmpq $0x0, (%r15)
leaq 0x18(%r15), %r15
jne 0x83db
movq (%r14), %rcx
leaq 0x7ee3f(%rip), %rdi     # 0x8723f
pushq $0x33
popq %rsi
pushq $0x1
popq %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x82e0
// File: /workspace/github_c_makefile_star2_O1/jkbenaim[P]psfrag/psfrag.c
// Function: cmd_scan
char *cmd_scan(int argc, char **argv)
{
	__label__ out_return;
	struct MappedFile_s m;
	char *msg = NULL;
	int rc;

	if (argc < 3) {
		msg = "must specify a pokemon stadium rom";
		goto out_return;
	}

	rc = DB_Init(&db, ":memory:");
	if (rc != SQLITE_OK) {
		msg = "DB_Init oopsed";
		goto out_return;
	}

	m = MappedFile_Open(argv[2], false);
	if (m.data == NULL) {
		msg = "couldn't open rom";
		goto out_dbclose;
	}

	if (m.size < (1048576 + 4096)) {
		msg = "rom too small";
		goto out_unmap;
	}

	rc = DB_FragSearch(db, m.data, m.size);
	if (rc != SQLITE_OK) {
		msg = "DB_FragSearch oopsed";
		goto out_unmap;
	}

	dump_frags();

out_unmap:
	MappedFile_Close(m);
out_dbclose:
	DB_Close(db);
out_return:
	if (msg) {
		return msg;
	} else {
		return NULL;
	}
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
cmpl $0x3, %edi
jge 0x8562
leaq 0x7ee1f(%rip), %rbx     # 0x8737c
jmp 0x8604
movq %rsi, %rbx
leaq 0xa3c9c(%rip), %rdi     # 0xac208
leaq 0x7ee2c(%rip), %rsi     # 0x8739f
callq 0x939c
testl %eax, %eax
je 0x8585
leaq 0x7ee25(%rip), %rbx     # 0x873a8
jmp 0x8604
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x992d
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x85b7
movq 0x20(%rsp), %rdx
cmpq $0x101000, %rdx         # imm = 0x101000
jae 0x85c0
leaq 0x7ee14(%rip), %rbx     # 0x873c9
jmp 0x85e0
leaq 0x7edf9(%rip), %rbx     # 0x873b7
jmp 0x85f8
movq 0xa3c41(%rip), %rdi     # 0xac208
callq 0x96d2
testl %eax, %eax
je 0x85d9
leaq 0x7ee00(%rip), %rbx     # 0x873d7
jmp 0x85e0
callq 0x8e6e
xorl %ebx, %ebx
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x99be
movq 0xa3c09(%rip), %rdi     # 0xac208
callq 0x93c8
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/jkbenaim[P]psfrag/psfrag.c
// Function: get_cmd_from_name
struct cmd_s *get_cmd_from_name(char *needle)
{
	int cmds_index = 0;
	while (cmds[cmds_index].command) {
		if (!strcmp(cmds[cmds_index].command, needle))
			return &cmds[cmds_index];
		cmds_index++;
	}
	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa13af(%rip), %rdi     # 0xaa1e0
testq %rdi, %rdi
je 0x8e60
movq %rbx, %rsi
callq 0x8190
leaq 0xa139b(%rip), %r14     # 0xaa1e0
testl %eax, %eax
je 0x8e63
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x8e60
movq %rbx, %rsi
callq 0x8190
addq $0x18, %r14
jmp 0x8e45
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jkbenaim[P]psfrag/psfrag.c
// Function: main
int main(int argc, char **argv)
{
	__label__ out_return;
	char *msg = NULL;
	char *cmd_string = NULL;

	if (argc < 2) {
		print_usage();
		goto out_return;
	}

	cmd_string = argv[1];

	struct cmd_s *cmd = get_cmd_from_name(cmd_string);
	if (cmd != NULL) {
		if (cmd->handler)
			msg = cmd->handler(argc, argv);
		else
			msg = "command has no handler";
	} else {
		msg = "invalid command";
	}

out_return:
	if (msg) {
		fprintf(stderr, "%s: error: %s\n", argv[0], msg);
		return EXIT_FAILURE;
	} else {
		return EXIT_SUCCESS;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x1, %edi
jle 0x935d
movl %edi, %ebp
movq 0x8(%rbx), %rdi
callq 0x8e23
testq %rax, %rax
je 0x934b
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x9354
movl %ebp, %edi
movq %rbx, %rsi
callq *%rax
jmp 0x9364
leaq 0x7e4db(%rip), %rax     # 0x8782d
jmp 0x9364
leaq 0x7e4bb(%rip), %rax     # 0x87816
jmp 0x9364
callq 0x83a0
xorl %eax, %eax
xorl %ecx, %ecx
testq %rax, %rax
jne 0x9374
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xa0c75(%rip), %rcx     # 0xa9ff0
movq (%rcx), %rdi
movq (%rbx), %rdx
leaq 0x7e4b5(%rip), %rsi     # 0x8783d
movq %rax, %rcx
xorl %eax, %eax
callq 0x81b0
movl $0x1, %ecx
jmp 0x936b
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/jkbenaim[P]psfrag/db.c
// Function: DB_Init
int DB_Init(sqlite3 **db, char *filename) {
	int rc = SQLITE_OK;
	rc = sqlite3_open(filename, db);
	if (rc != SQLITE_OK) return rc;

	rc = sqlite3_exec(*db,
		"CREATE TABLE IF NOT EXISTS frags(pcode text, addr int, num int, entrypoint int, offset_code int, offset_relocs int, romsize int, ramsize int, vma int);",
		NULL, NULL, NULL
	);
	if (rc != SQLITE_OK) return rc;
	return SQLITE_OK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x19862
testl %eax, %eax
je 0x93b1
popq %rbx
retq
movq (%rbx), %rdi
leaq 0x7e4ea(%rip), %rsi     # 0x878a5
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
popq %rbx
jmp 0x14a2f