LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/gzReader.hpp
// Function: ipsenMikhailovVector(double*, int, double)
vector<double> ipsenMikhailovVector(double* spectrum, int s, double gamma)
{
  double c = 0;
  vector<double> dens;
  double ub = gamma>.1?2.01:(int)((2 + .1*gamma)*100)/100.0;
  double step = gamma<.1?.01:(int)(10*gamma)/100.0;
  double sigsq = 2.0*gamma*gamma;
  double norm = 1.0/sqrt(PI * sigsq);
  for(double i = 0; i < ub; i += step){
    double d = gaussianDensity(spectrum, s, i, sigsq, norm);
    c += d;
    dens.push_back(d);
  }
  for(int i=0; i < dens.size(); i++) dens[i] /= c;
  return dens;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm1, %xmm1
andq $0x0, 0x10(%rdi)
movups %xmm1, (%rdi)
ucomisd 0x2dace(%rip), %xmm0    # 0x400a8
jbe 0x125e6
movsd 0x2dabc(%rip), %xmm1    # 0x400a0
jmp 0x12612
movsd 0x2daba(%rip), %xmm1    # 0x400a8
mulsd %xmm0, %xmm1
addsd 0x2dab6(%rip), %xmm1    # 0x400b0
movsd 0x2da56(%rip), %xmm2    # 0x40058
mulsd %xmm2, %xmm1
cvttpd2dq %xmm1, %xmm1
cvtdq2pd %xmm1, %xmm1
divsd %xmm2, %xmm1
movapd %xmm1, 0x30(%rsp)
movsd 0x2da98(%rip), %xmm1    # 0x400b8
mulsd %xmm0, %xmm1
cvttpd2dq %xmm1, %xmm1
cvtdq2pd %xmm1, %xmm1
divsd 0x2da24(%rip), %xmm1    # 0x40058
movapd %xmm0, %xmm3
cmpltsd 0x2da67(%rip), %xmm3    # 0x400a8
movsd 0x2da1f(%rip), %xmm2    # 0x40068
andpd %xmm3, %xmm2
andnpd %xmm1, %xmm3
orpd %xmm2, %xmm3
movapd %xmm3, 0x40(%rsp)
movapd %xmm0, %xmm1
addsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd 0x2da51(%rip), %xmm0    # 0x400c0
movsd %xmm1, 0x8(%rsp)
mulsd %xmm1, %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x12689
sqrtsd %xmm0, %xmm0
jmp 0x12692
callq 0xe430
xorpd %xmm2, %xmm2
movsd 0x2d9d6(%rip), %xmm1    # 0x40070
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
leaq 0x28(%rsp), %r15
xorpd %xmm1, %xmm1
movapd 0x30(%rsp), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x1270e
movsd %xmm1, 0x20(%rsp)
movq %r14, %rdi
movl %ebp, %esi
movapd %xmm2, %xmm0
movsd 0x8(%rsp), %xmm1
movsd %xmm2, 0x18(%rsp)
movsd (%rsp), %xmm2
callq 0x124c4
movsd %xmm0, 0x10(%rsp)
movsd %xmm0, 0x28(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x18f0c
movsd 0x20(%rsp), %xmm1
addsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
addsd 0x40(%rsp), %xmm2
jmp 0x126ac
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x12736
movsd (%rax,%rdx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0x1271e
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x29310
movq %r14, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/spectralToDistance.hpp
// Function: klDiv(double*, double*, int)
double klDiv(double *p1, double *p2, int count)
{
  double s = 0;
  for(int i = 0; i < count; i++)
    if(p1[i] * p2[i] > 0)
      s += p1[i] * 0.69314718f * fastlog2(p1[i]/p2[i]);
  return s<0?0:s;
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
xorpd %xmm0, %xmm0
movsd 0x2d51e(%rip), %xmm1    # 0x400d0
movss 0x2d622(%rip), %xmm2    # 0x401dc
movss 0x2d61e(%rip), %xmm3    # 0x401e0
movss 0x2d61a(%rip), %xmm4    # 0x401e4
movss 0x2d616(%rip), %xmm6    # 0x401e8
movss 0x2d612(%rip), %xmm7    # 0x401ec
xorpd %xmm5, %xmm5
cmpq %rax, %rdx
je 0x12c76
movsd (%rdi,%rax,8), %xmm8
movsd (%rsi,%rax,8), %xmm9
movapd %xmm8, %xmm10
mulsd %xmm9, %xmm10
ucomisd %xmm0, %xmm10
jbe 0x12c6e
movapd %xmm8, %xmm10
mulsd %xmm1, %xmm10
divsd %xmm9, %xmm8
cvtsd2ss %xmm8, %xmm8
movd %xmm8, %ecx
cvtsi2ss %rcx, %xmm8
andl $0x7fffff, %ecx         # imm = 0x7FFFFF
orl $0x3f000000, %ecx       # imm = 0x3F000000
mulss %xmm2, %xmm8
addss %xmm3, %xmm8
movd %ecx, %xmm9
movdqa %xmm9, %xmm11
mulss %xmm4, %xmm11
addss %xmm8, %xmm11
addss %xmm6, %xmm9
movaps %xmm7, %xmm8
divss %xmm9, %xmm8
addss %xmm11, %xmm8
cvtss2sd %xmm8, %xmm8
mulsd %xmm10, %xmm8
addsd %xmm8, %xmm5
incq %rax
jmp 0x12bde
xorpd %xmm0, %xmm0
maxsd %xmm5, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/spectralToDistance.hpp
// Function: jsDist(double*, double*, int)
double jsDist(double *p1, double *p2, int s)
{
  double avg[s];
  for(int i = 0; i < s; i++)
    avg[i] = .5 * (p1[i] + p2[i]);
  return sqrt(.5 * klDiv(p1, avg, s) + .5 * klDiv(p2, avg, s));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl %edx, %eax
movq %rsp, %r15
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
cmpq %rax, %rcx
je 0x12cd4
movsd (%rdi,%rax,8), %xmm0
addsd (%r14,%rax,8), %xmm0
mulsd 0x2d40f(%rip), %xmm0    # 0x400d8
movsd %xmm0, (%r15,%rax,8)
incq %rax
jmp 0x12cb1
movq %r15, %rsi
movl %ebx, %edx
callq 0x12b9f
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x12b9f
movsd 0x2d3e0(%rip), %xmm2    # 0x400d8
mulsd %xmm2, %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
movapd %xmm1, %xmm0
jb 0x12d26
sqrtsd %xmm0, %xmm0
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe430
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/spectralToDistance.hpp
// Function: DTopo(LevelInfo*, LevelInfo*, int)
double DTopo(LevelInfo *v1, LevelInfo *v2, int s)
{
  double dist = 0;
  for(int i = 0; i < s; i++)
    dist += jsDist(&(v1[i].signature)[0], &(v2[i].signature)[0],
        min(v1[i].signature.size(), v2[i].signature.size()));
  return dist/s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
testl %edx, %edx
movl $0x0, %eax
cmovgl %edx, %eax
imulq $0x50, %rax, %r13
xorpd %xmm1, %xmm1
cmpq %r12, %r13
je 0x12da6
movq 0x30(%r15,%r12), %rdi
movq 0x38(%r15,%r12), %rax
subq %rdi, %rax
shrq $0x3, %rax
movq 0x30(%r14,%r12), %rsi
movq 0x38(%r14,%r12), %rdx
subq %rsi, %rdx
shrq $0x3, %rdx
cmpl %edx, %eax
cmovll %eax, %edx
movsd %xmm1, 0x8(%rsp)
callq 0x12c7f
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
addq $0x50, %r12
jmp 0x12d5f
cvtsi2sd %ebx, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/adjacency_graph.hpp
// Function: AdjGraph::init(Graph*)
void AdjGraph::init(Graph *G)
{
  itsm = (*G).nodes();
  s = itsm.size();
  m.resize(s,s);
  m.fill(0);
  for(int i=0;i<s;i++)
    stim[itsm[i]] = i;
  for(int i=0;i<s;i++)
  {
    string src=itsm[i];
    vlist v = (*G).neighbors(src);
    vlist::iterator it=v.begin(), vend=v.end();
    for(;it!=vend;it++)
      m(stim[src],stim[*it])=1;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r15
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
movq %rsi, 0x10(%rsp)
callq 0xf448
leaq 0x20(%r15), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x39f4e
movq %rbx, %rdi
callq 0x18718
movq 0x28(%r15), %rax
subq 0x20(%r15), %rax
shrq $0x5, %rax
movl %eax, (%r15)
leaq 0x8(%r15), %r12
movslq %eax, %rdx
movq %r12, %rdi
movq %rdx, %rsi
callq 0x18db6
andq $0x0, (%rbx)
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
callq 0x29b8e
leaq 0x38(%r15), %r13
xorl %ebx, %ebx
xorl %r14d, %r14d
movslq (%r15), %rax
cmpq %rax, %r14
jge 0x13e0b
movq (%rbp), %rsi
addq %rbx, %rsi
movq %r13, %rdi
callq 0x19d20
movl %r14d, (%rax)
incq %r14
addq $0x20, %rbx
jmp 0x13de8
movq %rbp, 0x18(%rsp)
movq %r15, 0x8(%rsp)
xorl %esi, %esi
leaq 0x78(%rsp), %rbp
leaq 0x28(%rsp), %rbx
leaq 0x48(%rsp), %r15
cltq
cmpq %rax, %rsi
jge 0x13ee6
movq %rsi, 0x20(%rsp)
shlq $0x5, %rsi
movq 0x18(%rsp), %rax
addq (%rax), %rsi
movq %rbp, %rdi
callq 0xe7a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xe7a0
movq %r15, %r14
movq %r15, %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x19d86
movq %rbx, %rdi
callq 0xe290
movq %r14, %rdi
callq 0x1873a
movq %r14, %rdi
movq %rax, %r14
testq %r14, %r14
je 0x13ec0
movq %r13, %rdi
movq %rbp, %rsi
callq 0x19d20
movslq (%rax), %rbx
leaq 0x10(%r14), %rsi
movq %r13, %rdi
callq 0x19d20
movslq (%rax), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x18b38
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
movq (%r14), %r14
movq %r15, %rdi
jmp 0x13e7e
callq 0x2187e
movq %rbp, %rdi
callq 0xe290
movq 0x20(%rsp), %rsi
incq %rsi
movq 0x8(%rsp), %rax
movl (%rax), %eax
leaq 0x28(%rsp), %rbx
jmp 0x13e26
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xe290
jmp 0x13f19
movq %rax, %rbx
jmp 0x13f19
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2187e
leaq 0x78(%rsp), %rdi
callq 0xe290
movq %rbx, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/hungarian.hpp
// Function: kuhn_reduceRows(float**, unsigned long, unsigned long)
void kuhn_reduceRows(cell** t, size_t n, size_t m)
{
    size_t i, j;
    cell min;
    cell* ti;
    for (i = 0; i < n; i++)
    {
        ti = *(t + i);
        min = *ti;
	for (j = 1; j < m; j++)
	    if (min > *(ti + j))
	        min = *(ti + j);
	
	for (j = 0; j < m; j++)
	    *(ti + j) -= min;
    }
}

// Assembly:
xorl %eax, %eax
pushq $0x1
popq %rcx
cmpq %rsi, %rax
je 0x14811
movq (%rdi,%rax,8), %r8
movss (%r8), %xmm0
movq %rcx, %r9
cmpq %rdx, %r9
jae 0x147ef
movss (%r8,%r9,4), %xmm1
minss %xmm0, %xmm1
incq %r9
movaps %xmm1, %xmm0
jmp 0x147d8
xorl %r9d, %r9d
cmpq %r9, %rdx
je 0x1480c
movss (%r8,%r9,4), %xmm1
subss %xmm0, %xmm1
movss %xmm1, (%r8,%r9,4)
incq %r9
jmp 0x147f2
incq %rax
jmp 0x147c7
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/hungarian.hpp
// Function: kuhn_mark(float**, unsigned long, unsigned long)
byte** kuhn_mark(cell** t, size_t n, size_t m)
{
    size_t i, j;
    byte** marks = new byte*[n];
    byte* marksi;
    for (i = 0; i < n; i++)
    {
      marksi = *(marks + i) = new byte[m];
        for (j = 0; j < m; j++)
 	    *(marksi + j) = UNMARKED;
    }
    
    boolean* rowCovered = new boolean[n];
    boolean* colCovered = new boolean[m];
    for (i = 0; i < n; i++)
    {
        *(rowCovered + i) = false;
        *(colCovered + i) = false;
    }
    for (i = 0; i < m; i++)
        *(colCovered + i) = false;
    
    for (i = 0; i < n; i++)
        for (j = 0; j < m; j++)
	    if ((!*(rowCovered + i)) && (!*(colCovered + j)) && (*(*(t + i) + j) == 0))
	    {
	        *(*(marks + i) + j) = MARKED;
		*(rowCovered + i) = true;
		*(colCovered + j) = true;
	    }
    
    delete[](rowCovered);
    delete[](colCovered);
    return marks;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rax
shrq $0x3d, %rax
leaq (,%rsi,8), %rcx
xorl %r13d, %r13d
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0xe040
movq %rax, %r12
cmpq %r14, %r13
je 0x14874
movq %rbx, %rdi
callq 0xe040
movq %rax, (%r12,%r13,8)
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x1486f
movb $0x0, (%rax,%rcx)
incq %rcx
jmp 0x14861
incq %r13
jmp 0x1484e
movq %r14, %rdi
callq 0xe040
movq %rax, %r13
movq %rbx, %rdi
callq 0xe040
movq %rax, %rbp
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x148a1
movb %al, (%r13,%rcx)
movb %al, (%rbp,%rcx)
incq %rcx
jmp 0x1488e
xorl %eax, %eax
cmpq %rax, %rbx
je 0x148b2
movb $0x0, (%rbp,%rax)
incq %rax
jmp 0x148a3
xorl %eax, %eax
xorps %xmm0, %xmm0
movb $0x1, %cl
cmpq %r14, %rax
je 0x148fe
xorl %edx, %edx
cmpq %rdx, %rbx
je 0x148f9
cmpb $0x0, (%r13,%rax)
jne 0x148f4
cmpb $0x0, (%rbp,%rdx)
jne 0x148f4
movq (%r15,%rax,8), %rsi
movss (%rsi,%rdx,4), %xmm1
ucomiss %xmm0, %xmm1
jne 0x148f4
jp 0x148f4
movq (%r12,%rax,8), %rsi
movb %cl, (%rsi,%rdx)
movb %cl, (%r13,%rax)
movb %cl, (%rbp,%rdx)
incq %rdx
jmp 0x148c0
incq %rax
jmp 0x148b9
movq %r13, %rdi
callq 0xe720
movq %rbp, %rdi
callq 0xe720
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/hungarian.hpp
// Function: kuhn_isDone(signed char**, signed char*, unsigned long, unsigned long)
boolean kuhn_isDone(byte** marks, boolean* colCovered, size_t n, size_t m)
{
    size_t i, j;
    for (j = 0; j < m; j++)
        for (i = 0; i < n; i++)
	    if (*(*(marks + i) + j) == MARKED)
	    {
	        *(colCovered + j) = true;
		break;
	    }
    
    size_t count = 0;
    for (j = 0; j < m; j++)
        if (*(colCovered + j))
	    count++;
    
    return count == n;
}

// Assembly:
xorl %eax, %eax
cmpq %rcx, %rax
je 0x14946
xorl %r8d, %r8d
cmpq %r8, %rdx
je 0x14941
movq (%rdi,%r8,8), %r9
incq %r8
cmpb $0x1, (%r9,%rax)
jne 0x1492a
movb $0x1, (%rsi,%rax)
incq %rax
jmp 0x14922
xorl %eax, %eax
xorl %edi, %edi
cmpq %rax, %rcx
je 0x1495c
cmpb $0x1, (%rsi,%rax)
sbbq $-0x1, %rdi
incq %rax
jmp 0x1494a
cmpq %rdx, %rdi
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/hungarian.hpp
// Function: kuhn_altMarks(signed char**, unsigned long*, unsigned long*, long*, long*, unsigned long*, unsigned long, unsigned long)
void kuhn_altMarks(byte** marks, size_t* altRow, size_t* altCol, ssize_t* colMarks, ssize_t* rowPrimes, size_t* prime, size_t n, size_t m)
{
    size_t index = 0, i, j;
    *altRow = *prime;
    *altCol = *(prime + 1);
    
    for (i = 0; i < n; i++)
    {
        *(rowPrimes + i) = -1;
        *(colMarks + i) = -1;
    }
    for (i = n; i < m; i++)
        *(colMarks + i) = -1;
    
    for (i = 0; i < n; i++)
        for (j = 0; j < m; j++)
	    if (*(*(marks + i) + j) == MARKED)
	        *(colMarks + j) = (ssize_t)i;
	    else if (*(*(marks + i) + j) == PRIME)
	        *(rowPrimes + i) = (ssize_t)j;
    
    ssize_t row, col;
    for (;;)
    {
        row = *(colMarks + *(altCol + index));
	if (row < 0)
	    break;
	
	index++;
	*(altRow + index) = (size_t)row;
	*(altCol + index) = *(altCol + index - 1);
	
	col = *(rowPrimes + *(altRow + index));
	
	index++;
	*(altRow + index) = *(altRow + index - 1);
	*(altCol + index) = (size_t)col;
    }
    
    byte* markx;
    for (i = 0; i <= index; i++)
    {
        markx = *(marks + *(altRow + i)) + *(altCol + i);
        if (*markx == MARKED)
	    *markx = UNMARKED;
	else
	    *markx = MARKED;
    }
    
    byte* marksi;
    for (i = 0; i < n; i++)
    {
        marksi = *(marks + i);
        for (j = 0; j < m; j++)
	    if (*(marksi + j) == PRIME)
	        *(marksi + j) = UNMARKED;
    }
}

// Assembly:
pushq %rbx
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %r10
movq (%r9), %r11
movq %r11, (%rsi)
movq 0x8(%r9), %r9
movq %r9, (%rdx)
xorl %r9d, %r9d
cmpq %r9, %r10
je 0x14d8b
orq $-0x1, (%r8,%r9,8)
orq $-0x1, (%rcx,%r9,8)
incq %r9
jmp 0x14d77
movq %r10, %r9
cmpq %rax, %r9
jae 0x14d9d
orq $-0x1, (%rcx,%r9,8)
incq %r9
jmp 0x14d8e
xorl %r9d, %r9d
cmpq %r10, %r9
je 0x14dd4
xorl %r11d, %r11d
cmpq %r11, %rax
je 0x14dcf
movq (%rdi,%r9,8), %rbx
movzbl (%rbx,%r11), %ebx
cmpl $0x2, %ebx
je 0x14dc6
cmpl $0x1, %ebx
jne 0x14dca
movq %r9, (%rcx,%r11,8)
jmp 0x14dca
movq %r11, (%r8,%r9,8)
incq %r11
jmp 0x14da8
incq %r9
jmp 0x14da0
movq (%rdx), %r11
movabsq $0x1, %r9
movq (%rcx,%r11,8), %r11
testq %r11, %r11
js 0x14e0f
movq %r11, (%rsi,%r9,8)
movq -0x8(%rdx,%r9,8), %r11
movq %r11, (%rdx,%r9,8)
movq (%rsi,%r9,8), %rbx
movq (%r8,%rbx,8), %r11
movq %rbx, 0x8(%rsi,%r9,8)
movq %r11, 0x8(%rdx,%r9,8)
addq $0x2, %r9
jmp 0x14de1
xorl %ecx, %ecx
cmpq %rcx, %r9
je 0x14e31
movq (%rsi,%rcx,8), %r8
movq (%rdi,%r8,8), %r8
movq (%rdx,%rcx,8), %r11
cmpb $0x1, (%r8,%r11)
setne (%r8,%r11)
incq %rcx
jmp 0x14e11
xorl %ecx, %ecx
cmpq %r10, %rcx
je 0x14e57
movq (%rdi,%rcx,8), %rdx
xorl %esi, %esi
cmpq %rsi, %rax
je 0x14e52
cmpb $0x2, (%rdx,%rsi)
jne 0x14e4d
movb $0x0, (%rdx,%rsi)
incq %rsi
jmp 0x14e3e
incq %rcx
jmp 0x14e33
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/hungarian.hpp
// Function: kuhn_addAndSubtract(float**, signed char*, signed char*, unsigned long, unsigned long)
void kuhn_addAndSubtract(cell** t, boolean* rowCovered, boolean* colCovered, size_t n, size_t m)
{
    size_t i, j;
    cell min = 0x7FFFffffL;
    for (i = 0; i < n; i++)
        if (!*(rowCovered + i))
	    for (j = 0; j < m; j++)
	        if ((!*(colCovered + j)) && (min > *(*(t + i) + j)))
		    min = *(*(t + i) + j);
    
    for (i = 0; i < n; i++)
        for (j = 0; j < m; j++)
	{
	    if (*(rowCovered + i))
	        *(*(t + i) + j) += min;
	    if (*(colCovered + j) == false)
	        *(*(t + i) + j) -= min;
	}
}

// Assembly:
movss 0x2b393(%rip), %xmm0    # 0x401f4
xorl %eax, %eax
cmpq %rcx, %rax
je 0x14e99
cmpb $0x0, (%rsi,%rax)
je 0x14e73
incq %rax
jmp 0x14e63
xorl %r9d, %r9d
cmpq %r9, %r8
je 0x14e6e
cmpb $0x0, (%rdx,%r9)
jne 0x14e94
movq (%rdi,%rax,8), %r10
movss (%r10,%r9,4), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x14e94
movaps %xmm1, %xmm0
incq %r9
jmp 0x14e76
xorl %eax, %eax
cmpq %rcx, %rax
je 0x14ee7
xorl %r9d, %r9d
cmpq %r9, %r8
je 0x14ee2
cmpb $0x0, (%rsi,%rax)
je 0x14ec2
movq (%rdi,%rax,8), %r10
movss (%r10,%r9,4), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%r10,%r9,4)
cmpb $0x0, (%rdx,%r9)
jne 0x14edd
movq (%rdi,%rax,8), %r10
movss (%r10,%r9,4), %xmm1
subss %xmm0, %xmm1
movss %xmm1, (%r10,%r9,4)
incq %r9
jmp 0x14ea3
incq %rax
jmp 0x14e9b
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/hungarian.hpp
// Function: kuhn_assign(signed char**, unsigned long, unsigned long)
ssize_t** kuhn_assign(byte** marks, size_t n, size_t m)
{
    ssize_t** assignment = new ssize_t*[n];
    
    size_t i, j;
    for (i = 0; i < n; i++)
    {
        *(assignment + i) = new ssize_t[2];
        for (j = 0; j < m; j++)
	    if (*(*(marks + i) + j) == MARKED)
	    {
		**(assignment + i) = (ssize_t)i;
		*(*(assignment + i) + 1) = (ssize_t)j;
	    }
    }
    
    return assignment;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rax
shrq $0x3d, %rax
leaq (,%rsi,8), %rcx
xorl %ebp, %ebp
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0xe040
movq %rax, %r12
pushq $0x10
popq %r13
cmpq %r14, %rbp
je 0x14f5a
movq %r13, %rdi
callq 0xe040
movq %rax, (%r12,%rbp,8)
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x14f55
movq (%r15,%rbp,8), %rdx
cmpb $0x1, (%rdx,%rcx)
jne 0x14f50
movq %rbp, (%rax)
movq %rcx, 0x8(%rax)
incq %rcx
jmp 0x14f3a
incq %rbp
jmp 0x14f27
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/hungarian.hpp
// Function: new_BitSet(unsigned long)
BitSet new_BitSet(size_t size)
{
    BitSet this_;
    
    size_t c = size >> 6L;
    if (size & 63L)
        c++;
    
    this_.limbs = new llong[c];
    this_.prev = new size_t[c+1];
    this_.next = new size_t[c+1];
    *(this_.first = new size_t) = 0;
    
    size_t i;
    for (i = 0; i < c; i++)
    {
        *(this_.limbs + i) = 0LL;
        *(this_.prev + i) = *(this_.next + i) = 0L;
    }
    *(this_.prev + c) = *(this_.next + c) = 0L;
    
    return this_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq %rsi, %r13
shrq $0x6, %r13
andl $0x3f, %esi
cmpq $0x1, %rsi
sbbq $-0x1, %r13
leaq (,%r13,8), %rdi
callq 0xe040
movq %rax, %r14
movq %rax, (%rbx)
leaq 0x8(,%r13,8), %r12
movq %r12, %rdi
callq 0xe040
movq %rax, %r15
movq %rax, 0x10(%rbx)
movq %r12, %rdi
callq 0xe040
movq %rax, %r12
movq %rax, 0x18(%rbx)
pushq $0x8
popq %rdi
callq 0xe560
movq %rax, 0x8(%rbx)
andq $0x0, (%rax)
xorl %eax, %eax
cmpq %rax, %r13
je 0x14fee
andq $0x0, (%r14,%rax,8)
andq $0x0, (%r12,%rax,8)
andq $0x0, (%r15,%rax,8)
incq %rax
jmp 0x14fd5
andq $0x0, (%r12,%r13,8)
andq $0x0, (%r15,%r13,8)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/hungarian.hpp
// Function: BitSet_any(BitSet)
ssize_t BitSet_any(BitSet this_)
{
    if (*(this_.first) == 0L)
        return -1;
    
    size_t i = *(this_.first) - 1;
    return (ssize_t)(lb(*(this_.limbs + i) & -*(this_.limbs + i)) + (i << 6L));
}

// Assembly:
pushq %rbx
movq 0x18(%rsp), %rax
movq (%rax), %rbx
testq %rbx, %rbx
je 0x15089
leaq 0x10(%rsp), %rax
movq (%rax), %rax
movq -0x8(%rax,%rbx,8), %rax
decq %rbx
movq %rax, %rdi
negq %rdi
andq %rax, %rdi
callq 0x150ee
shlq $0x6, %rbx
addq %rax, %rbx
jmp 0x1508c
pushq $-0x1
popq %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/hungarian.hpp
// Function: BitSet_unset(BitSet, unsigned long)
void BitSet_unset(BitSet this_, size_t i)
{
    size_t j = i >> 6L;
    llong old = *(this_.limbs + j);
    
    *(this_.limbs + j) &= ~(1LL << (llong)(i & 63L));
    
    if ((!*(this_.limbs + j)) ^ (!old))
    {
        j++;
	size_t p = *(this_.prev + j);
	size_t n = *(this_.next + j);
	*(this_.prev + n) = p;
	*(this_.next + p) = n;
	if (*(this_.first) == j)
	    *(this_.first) = n;
    }
}

// Assembly:
movq %rdi, %rcx
movq %rdi, %rax
shrq $0x6, %rax
pushq $-0x2
popq %rdx
rolq %cl, %rdx
movq 0x8(%rsp), %rcx
movq (%rcx,%rax,8), %rsi
andq %rsi, %rdx
movq %rdx, (%rcx,%rax,8)
setne %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x150ed
leaq 0x8(%rsp), %rcx
leaq 0x1(%rax), %rdx
movq 0x10(%rcx), %rsi
movq 0x18(%rcx), %rdi
movq 0x8(%rsi,%rax,8), %r8
movq 0x8(%rdi,%rax,8), %rax
movq %r8, (%rsi,%rax,8)
movq %rax, (%rdi,%r8,8)
movq 0x8(%rcx), %rcx
cmpq %rdx, (%rcx)
jne 0x150ed
movq %rax, (%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/alignmentExtender.hpp
// Function: adjustWeights(Graph&, Graph&, boost::bimaps::bimap<boost::bimaps::unordered_set_of<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, boost::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, boost::bimaps::unordered_set_of<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, boost::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, mpl_::na, mpl_::na, mpl_::na>*, std::vector<D_alpha, std::allocator<D_alpha>>*)
void adjustWeights(Graph &g1, Graph &g2, bmap *align, vector<D_alpha> *matches){
  for(int i = 0; i < matches->size(); i++){
    int count = 0;
    vlist *adj1 = g1.neighbors2((*matches)[i].get_n1());
    vlist *adj2 = g2.neighbors2((*matches)[i].get_n2());
    for(auto it = adj1->begin(); it != adj1->end(); it++){
      auto mapped = align->left.find(*it);
      if(mapped != align->left.end() && adj2->find(mapped->second) != adj2->end()) count++;
    }
    D_alpha d = (*matches)[i];
    d.set_da(d.get_da() / (count/2.0 + 1));
    (*matches)[i] = d;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, (%rsp)
movq %rdi, 0x8(%rsp)
addq $0x98, %r14
xorl %ebx, %ebx
leaq 0x18(%rsp), %r15
movq (%r13), %rsi
movq 0x8(%r13), %rax
subq %rsi, %rax
cqto
pushq $0x50
popq %rcx
idivq %rcx
cmpq %rbx, %rax
jbe 0x152d1
imulq $0x50, %rbx, %r12
addq %r12, %rsi
movq %r15, %rdi
callq 0xe7a0
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1b558
movq %rax, %rbp
movq %rbx, 0x10(%rsp)
movq %r15, %rdi
callq 0xe290
movq %r13, %rbx
movq (%r13), %rax
leaq (%rax,%r12), %rsi
addq $0x20, %rsi
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0xe7a0
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x1b558
movq %rax, %r13
addq $0x30, %rbp
addq $0x30, %r13
movq %r15, %rdi
callq 0xe290
movq %rbp, %rdi
callq 0x1873a
movq %rax, %rbp
xorl %r15d, %r15d
testq %rbp, %rbp
je 0x1526c
leaq 0x10(%rbp), %rsi
movq %r14, %rdi
callq 0x19f1e
movq (%r14), %rcx
cmpq -0x8(%rcx), %rax
je 0x15266
addq $0x20, %rax
movq %r13, %rdi
movq %rax, %rsi
callq 0x2910c
cmpq $0x1, %rax
sbbl $-0x1, %r15d
movq (%rbp), %rbp
jmp 0x15235
movq %rbx, %r13
movq (%rbx), %rsi
addq %r12, %rsi
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
callq 0x19f6e
movsd 0x98(%rsp), %xmm0
cvtsi2sd %r15d, %xmm1
mulsd 0x2ae40(%rip), %xmm1    # 0x400d8
addsd 0x2add0(%rip), %xmm1    # 0x40070
divsd %xmm1, %xmm0
movsd %xmm0, 0x98(%rsp)
addq (%r13), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x19fae
movq %rbx, %rdi
callq 0x19ce8
movq 0x10(%rsp), %rbx
incq %rbx
jmp 0x1519f
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x19ce8
jmp 0x15309
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x15304
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xe290
movq %rbx, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/alignGraphs.hpp
// Function: getNextSeed(double, std::vector<D_alpha, std::allocator<D_alpha>>*)
pair<D_alpha, vector<D_alpha>> getNextSeed(double skipProb, vector<D_alpha> *minP)
{
  vector<D_alpha> skipped;
  D_alpha d = minP->front();
  while(1){
    pop_heap (minP->begin(), minP->end(),CompareD_alphaG());
    minP->pop_back();
    if(rand() > ((1.0-skipProb)*RAND_MAX) && minP->size() > 0){
      skipped.push_back(d);
      d = minP->front();
    }else break;
  }
  return std::make_pair(d, skipped);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq (%rsi), %rsi
leaq 0x28(%rsp), %rdi
callq 0x19f6e
movsd 0x29ef2(%rip), %xmm0    # 0x40070
subsd 0x8(%rsp), %xmm0
mulsd 0x29f64(%rip), %xmm0    # 0x400f0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r15
leaq 0x28(%rsp), %r12
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x1a386
movq %r14, %rdi
callq 0x1a1f4
callq 0xe1b0
cvtsi2sd %eax, %xmm0
ucomisd 0x8(%rsp), %xmm0
jbe 0x161e2
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x161e2
movq %r15, %rdi
movq %r12, %rsi
callq 0x19cbc
movq (%r14), %rsi
movq %r12, %rdi
callq 0x19fae
jmp 0x1619c
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x21a60
leaq 0x28(%rsp), %rdi
callq 0x19ce8
leaq 0x10(%rsp), %rdi
callq 0x19cfe
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1621e
movq %rax, %rbx
jmp 0x1622b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x19ce8
leaq 0x10(%rsp), %rdi
callq 0x19cfe
movq %rbx, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/alignGraphs.hpp
// Function: printMap(boost::bimaps::bimap<boost::bimaps::unordered_set_of<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, boost::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, boost::bimaps::unordered_set_of<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, boost::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, mpl_::na, mpl_::na, mpl_::na>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void printMap(bmap f, string gname, string hname)
{
  ofstream fout (gname+"_vs_"+hname+".af");
  bmap::left_const_iterator iter = f.left.begin(),
  iend = f.left.end();
  for(; iter != iend; ++iter)
  {
    fout << iter->first << "\t" << iter->second << "\n";
  }
  fout.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x260, %rsp            # imm = 0x260
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x2a4a2(%rip), %rdx     # 0x40984
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x1a505
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1a4e6
leaq 0x2a4aa(%rip), %rdx     # 0x409ae
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x1874a
leaq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x10
popq %rdx
callq 0xead0
leaq 0x20(%rsp), %rdi
callq 0xe290
movq %rsp, %rdi
callq 0xe290
leaq 0x40(%rsp), %rdi
callq 0xe290
movq 0x98(%rbx), %rax
movq -0x8(%rax), %r13
movq 0x48(%r13), %rax
movq (%rax), %rax
leaq 0x60(%rsp), %rbx
leaq 0x2a36a(%rip), %r14     # 0x408c7
leaq 0x2a11f(%rip), %r15     # 0x40683
leaq -0x40(%rax), %r12
testq %rax, %rax
cmoveq %rax, %r12
cmpq %r13, %r12
je 0x165b7
movq %rbx, %rdi
movq %r12, %rsi
callq 0xe4a0
movq %rax, %rdi
movq %r14, %rsi
callq 0xe540
leaq 0x20(%r12), %rsi
movq %rax, %rdi
callq 0xe4a0
movq %rax, %rdi
movq %r15, %rsi
callq 0xe540
movq 0x48(%r12), %rcx
addq $0x40, %r12
movq (%rcx), %rax
cmpq %r12, %rax
cmoveq %rcx, %rax
jmp 0x16564
leaq 0x60(%rsp), %rdi
callq 0xe7f0
leaq 0x60(%rsp), %rdi
callq 0xe850
addq $0x260, %rsp            # imm = 0x260
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x16609
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xe290
jmp 0x165f0
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe290
jmp 0x165fd
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xe290
jmp 0x16616
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xe850
movq %rbx, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/alignGraphs.hpp
// Function: alignGraphs[abi:cxx11](Graph&, Graph&, std::vector<D_alpha, std::allocator<D_alpha>>&, int, double)
bmap alignGraphs(Graph& G, Graph& H, vector<D_alpha>& distances, int k, double skipProb)
{
  cout << "aligning graphs...\n";
  vector<D_alpha> minP;  // empty vector is a heap
  for(auto it = distances.begin(); it != distances.end(); it++)
  {
    minP.push_back(*it);
    push_heap(minP.begin(),minP.end(),CompareD_alphaG());
  }

  ptime t = bclock::local_time();
  bmap result = seedAndExtend(G, H, minP, k, skipProb);
  cout << "aligned " << result.size() << " nodes in " << (bclock::local_time()-t).total_milliseconds() << " milliseconds\n";

  printICS(G, H, result);
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movsd %xmm0, 0x30(%rsp)
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
movq 0x66612(%rip), %rdi     # 0x7cf98
leaq 0x2a045(%rip), %rsi     # 0x409d2
callq 0xe540
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r13
movaps %xmm0, (%r13)
andq $0x0, 0x10(%r13)
movq (%r12), %r14
cmpq 0x8(%r12), %r14
je 0x169cf
movq %r13, %rdi
movq %r14, %rsi
callq 0x19cbc
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1a432
addq $0x50, %r14
jmp 0x169a8
callq 0x1889e
movq %rax, 0x38(%rsp)
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
movl %ebp, %r8d
movsd 0x30(%rsp), %xmm0
callq 0x1623d
movq 0x6659a(%rip), %rdi     # 0x7cf98
leaq 0x29fe1(%rip), %rsi     # 0x409e6
callq 0xe540
movq 0x8(%rbx), %rcx
movq 0x70(%rcx), %rsi
movq %rax, %rdi
callq 0xe3a0
leaq 0x29fce(%rip), %rsi     # 0x409ef
movq %rax, %rdi
callq 0xe540
movq %rax, %r12
callq 0x1889e
leaq 0x40(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x38(%rsp), %rsi
callq 0x1c4fa
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %r12, %rdi
movq %rax, %rsi
callq 0xe500
leaq 0x29d82(%rip), %rsi     # 0x407e1
movq %rax, %rdi
callq 0xe540
movq %r15, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x1661e
leaq 0x10(%rsp), %rdi
callq 0x19cfe
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16aa8
jmp 0x16a97
movq %rax, %r14
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x21a96
jmp 0x16aab
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x19cfe
movq %r14, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/localImprove.hpp
// Function: calcScoresWorker(Graph*, Graph*, boost::unordered::unordered_map<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, double, boost::hash<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::equal_to<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::pair<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const, double>>>*, boost::bimaps::bimap<boost::bimaps::unordered_set_of<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, boost::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, boost::bimaps::unordered_set_of<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, boost::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, mpl_::na, mpl_::na, mpl_::na>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, move**, int)
void calcScoresWorker(Graph *G, Graph *H, blastmap *dists, bmap *f, string u, string w, move **ms, int count)
{
  for(int i = 0; i < count; i++){
    move *m = ms[i];
    m->u = u;
    m->w = w;
    m->calcScores(G, H, dists, f);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, (%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movl 0x58(%rsp), %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x16b34
movq 0x50(%rsp), %rax
movq (%rax,%r15,8), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0xe300
leaq 0x20(%rbx), %rdi
movq 0x10(%rsp), %rsi
callq 0xe300
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq (%rsp), %r8
callq 0x1a53e
incq %r15
jmp 0x16af1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/GHOST.cpp
// Function: readAlignment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bmap readAlignment(string file)
{
  bmap result;
  ifstream fin(file);
  char c = fin.get();
  int alen = 0;
  int blen = 0;
  char a[128];
  char b[128];
  bool fillinga = true;
  while(fin.good()){
    if(c == '\n'){
      b[blen] = '\0';
      result.insert(bmap::value_type(string(a), string(b)));
      alen = blen = 0;
      fillinga = true;
    }
    else if(c == '\r'){}
    else if (c == '\t'){
      a[alen] = '\0';
      fillinga = false;
    }
    else if(fillinga) a[alen++] = c;
    else b[blen++] = c;
    c = fin.get();
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x398, %rsp            # imm = 0x398
movq %rsi, %r14
leaq 0x190(%rsp), %rsi
movq %rdi, 0x8(%rsp)
callq 0x1a404
leaq 0x190(%rsp), %rdi
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0xe950
leaq 0x190(%rsp), %rdi
callq 0xe680
movb $0x1, %bl
xorl %r13d, %r13d
leaq 0x190(%rsp), %r14
leaq 0x10(%rsp), %rbp
leaq 0x50(%rsp), %r12
xorl %r15d, %r15d
movq 0x190(%rsp), %rcx
movq -0x18(%rcx), %rcx
cmpl $0x0, 0x1b0(%rsp,%rcx)
jne 0x17577
movslq %r13d, %rcx
cmpb $0x9, %al
je 0x1753f
movzbl %al, %esi
cmpl $0xd, %esi
je 0x1756a
movslq %r15d, %rdx
cmpl $0xa, %esi
jne 0x17549
movb $0x0, 0x90(%rsp,%rdx)
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
leaq 0x110(%rsp), %rsi
leaq 0x7(%rsp), %rdx
callq 0x1866e
movq %rbp, %rdi
leaq 0x90(%rsp), %rsi
leaq 0x6(%rsp), %rdx
callq 0x1866e
movq %r12, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x3c3b8
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $-0x10, %rdi
movq %r12, %rsi
callq 0x3c3ee
movq %r12, %rdi
callq 0x1a11c
movq %rbp, %rdi
callq 0xe290
movq %rbx, %rdi
callq 0xe290
movb $0x1, %bl
xorl %r13d, %r13d
xorl %r15d, %r15d
jmp 0x1756a
movb $0x0, 0x110(%rsp,%rcx)
jmp 0x17568
testb $0x1, %bl
je 0x1755d
leal 0x1(%rcx), %r13d
movb %al, 0x110(%rsp,%rcx)
movb $0x1, %bl
jmp 0x1756a
leal 0x1(%rdx), %r15d
movb %al, 0x90(%rsp,%rdx)
xorl %ebx, %ebx
movq %r14, %rdi
callq 0xe680
jmp 0x17486
leaq 0x190(%rsp), %rdi
callq 0xe170
movq 0x8(%rsp), %rax
addq $0x398, %rsp            # imm = 0x398
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x175d1
movq %rax, %r14
jmp 0x175e1
movq %rax, %r14
jmp 0x175bb
movq %rax, %r14
jmp 0x175c5
jmp 0x175d1
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x1a11c
leaq 0x10(%rsp), %rdi
callq 0xe290
leaq 0x30(%rsp), %rdi
callq 0xe290
jmp 0x175d4
movq %rax, %r14
leaq 0x190(%rsp), %rdi
callq 0xe170
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x21a96
movq %r14, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/GHOST.cpp
// Function: main
int main(int argc, char** argv)
{
  ConfigData c;

  // read in options
  for(int i=1; i<argc; i++)
  {
    if(string(argv[i]) == "-c")
      if((i+1)<argc)
        c.configure(string(argv[i+1]));
    if(string(argv[i]) == "-k")
      if((i+1)<argc)
        c.hops = atoi(argv[i+1]);
    if(string(argv[i]) == "-p")
      if((i+1)<argc)
        c.numProcessors = atoi(argv[i+1]);
  }

  if(c.Ggraph == "" || c.Hgraph == "") // required input
    { cout << "gexf files not provided\n"; return 0; }

  // and here we go!
  computeAlignment(c);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp            # imm = 0x2C8
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x58(%rsp), %rdi
callq 0x1add2
movslq %ebp, %rax
movq %rax, 0x10(%rsp)
pushq $0x2
popq %r13
leaq 0x38(%rsp), %r15
leaq 0x18(%rsp), %r12
leaq -0x1(%r13), %rax
cmpq 0x10(%rsp), %rax
jge 0x1859a
movq -0x8(%rbx,%r13,8), %rsi
movq %r15, %rdi
leaq 0xf(%rsp), %rdx
callq 0x1866e
movq %r15, %rdi
leaq 0x285d0(%rip), %rsi     # 0x40a94
callq 0x18661
movl %eax, %r14d
movq %r15, %rdi
callq 0xe290
testb %r14b, %r14b
je 0x18505
cmpl %ebp, %r13d
jge 0x18505
movq (%rbx,%r13,8), %rsi
movq %r12, %r14
movq %r12, %rdi
movq %r15, %rdx
callq 0x1866e
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0xf2d8
movq %r14, %rdi
callq 0xe290
movq -0x8(%rbx,%r13,8), %rsi
movq %r15, %rdi
leaq 0xf(%rsp), %rdx
callq 0x1866e
movq %r15, %rdi
leaq 0x28576(%rip), %rsi     # 0x40a97
callq 0x18661
movl %eax, %r14d
movq %r15, %rdi
callq 0xe290
testb %r14b, %r14b
je 0x1854b
cmpl %ebp, %r13d
jge 0x1854b
movq (%rbx,%r13,8), %rdi
callq 0xe8e0
movl %eax, 0x15c(%rsp)
movq -0x8(%rbx,%r13,8), %rsi
movq %r15, %rdi
leaq 0xf(%rsp), %rdx
callq 0x1866e
movq %r15, %rdi
leaq 0x28533(%rip), %rsi     # 0x40a9a
callq 0x18661
movl %eax, %r14d
movq %r15, %rdi
callq 0xe290
cmpl %ebp, %r13d
setl %al
testb %al, %r14b
je 0x18592
movq (%rbx,%r13,8), %rdi
callq 0xe8e0
movl %eax, 0x158(%rsp)
incq %r13
jmp 0x18499
leaq 0x28327(%rip), %rsi     # 0x408c8
leaq 0x58(%rsp), %rdi
callq 0x18661
testb %al, %al
jne 0x185c4
leaq 0x78(%rsp), %rdi
leaq 0x2830d(%rip), %rsi     # 0x408c8
callq 0x18661
testb %al, %al
je 0x185d9
movq 0x649cd(%rip), %rdi     # 0x7cf98
leaq 0x284cb(%rip), %rsi     # 0x40a9d
callq 0xe540
jmp 0x18605
leaq 0x190(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x1af60
leaq 0x190(%rsp), %rdi
callq 0x175f7
leaq 0x190(%rsp), %rdi
callq 0x1b0ae
leaq 0x58(%rsp), %rdi
callq 0x1b0ae
xorl %eax, %eax
addq $0x2c8, %rsp            # imm = 0x2C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x190(%rsp), %rdi
callq 0x1b0ae
jmp 0x1864f
jmp 0x1864c
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xe290
jmp 0x1864f
jmp 0x1864c
jmp 0x1864c
jmp 0x1864c
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x1b0ae
movq %rbx, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Cholesky/LDLT.h
// Function: Eigen::internal::solve_retval<Eigen::LDLT<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>> const Eigen::LDLT<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1>::solve<Eigen::Matrix<double, -1, 1, 0, -1, 1>>(Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1>> const&) const
inline const internal::solve_retval<LDLT, Rhs>
    solve(const MatrixBase<Rhs>& b) const
    {
      eigen_assert(m_isInitialized && "LDLT is not initialized.");
      eigen_assert(m_matrix.rows()==b.rows()
                && "LDLT::solve(): invalid number of rows of the right hand side matrix b");
      return internal::solve_retval<LDLT, Rhs>(*this, b.derived());
    }

// Assembly:
pushq %rax
cmpb $0x0, 0x3c(%rdi)
je 0x18bdd
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0x18bfc
movq %rdi, %rax
movq %rsi, %rdx
popq %rcx
retq
leaq 0x2e8bb(%rip), %rdi     # 0x4749f
leaq 0x2c304(%rip), %rsi     # 0x44eef
leaq 0x2e8db(%rip), %rcx     # 0x474cd
movl $0xbc, %edx
callq 0xe380
leaq 0x2e9b0(%rip), %rdi     # 0x475b3
leaq 0x2c2e5(%rip), %rsi     # 0x44eef
leaq 0x2e8bc(%rip), %rcx     # 0x474cd
movl $0xbe, %edx
callq 0xe380
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/DenseCoeffsBase.h
// Function: Eigen::DenseCoeffsBase<Eigen::Matrix<double, -1, 1, 0, -1, 1>, 1>::operator[](long)
EIGEN_STRONG_INLINE Scalar&
    operator[](Index index)
    {
      #ifndef EIGEN2_SUPPORT
      EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime,
                          THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD)
      #endif
      eigen_assert(index >= 0 && index < size());
      return derived().coeffRef(index);
    }

// Assembly:
testq %rsi, %rsi
js 0x18ccc
cmpq %rsi, 0x8(%rdi)
jle 0x18ccc
shlq $0x3, %rsi
addq (%rdi), %rsi
movq %rsi, %rax
retq
pushq %rax
leaq 0x2fadf(%rip), %rdi     # 0x487b3
leaq 0x2c023(%rip), %rsi     # 0x44cfe
leaq 0x31d96(%rip), %rcx     # 0x4aa78
movl $0x17a, %edx            # imm = 0x17A
callq 0xe380
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/localImprove.hpp
// Function: move::apply(boost::bimaps::bimap<boost::bimaps::unordered_set_of<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, boost::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, boost::bimaps::unordered_set_of<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, boost::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, mpl_::na, mpl_::na, mpl_::na>*)
void apply(bmap *f)
  {
    f->left.erase(u);
    if(up != "") f->left.erase(up);
    f->insert(bmap::value_type(u, v));
    if(up != "") f->insert(bmap::value_type(up, w));
    up = u;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x98(%rsi), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1a07c
leaq 0x60(%rbx), %r14
leaq 0x25c44(%rip), %rsi     # 0x408c8
movq %r14, %rdi
callq 0x186d2
testb %al, %al
je 0x1ac9b
movq %r12, %rdi
movq %r14, %rsi
callq 0x1a07c
leaq 0x40(%rbx), %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3c3b8
movq 0x8(%r15), %rdi
addq $-0x10, %rdi
movq %r12, %rsi
callq 0x3c3ee
leaq 0x8(%rsp), %rdi
callq 0x1a11c
leaq 0x25bf8(%rip), %rsi     # 0x408c8
movq %r14, %rdi
callq 0x186d2
testb %al, %al
je 0x1ad0a
leaq 0x20(%rbx), %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3c3b8
movq 0x8(%r15), %rdi
addq $-0x10, %rdi
movq %r12, %rsi
callq 0x3c3ee
leaq 0x8(%rsp), %rdi
callq 0x1a11c
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe300
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1ad23
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a11c
movq %rbx, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/util/Memory.h
// Function: double* Eigen::internal::conditional_aligned_new_auto<double, true>(unsigned long)
inline T* conditional_aligned_new_auto(size_t size)
{
  check_size_for_overflow<T>(size);
  T *result = reinterpret_cast<T*>(conditional_aligned_malloc<Align>(sizeof(T)*size));
  if(NumTraits<T>::RequireInitialization)
    construct_elements_of_array(result, size);
  return result;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rdi, %rax
shrq $0x3d, %rax
je 0x23667
callq 0x23674
shlq $0x3, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x236a1
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<double, -1, -1, 1, 0>::resize(long, long, long)
EIGEN_STRONG_INLINE void resize(DenseIndex size, DenseIndex nbRows, DenseIndex)
    {
      if(size != m_rows*_Cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows);
        if (size)
          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
        else
          m_data = 0;
        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN
      }
      m_rows = nbRows;
    }
    inline const T *data() const { return m_data; }
    inline T *data() { return m_data; }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
cmpq %rsi, 0x8(%rdi)
je 0x2379a
movq %rsi, %r15
movq (%r14), %rdi
callq 0xe670
testq %r15, %r15
je 0x23795
movq %r15, %rdi
callq 0x23655
jmp 0x23797
xorl %eax, %eax
movq %rax, (%r14)
movq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/SelfCwiseBinaryOp.h
// Function: Eigen::DenseBase<Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, 1, 1, false>>::operator/=(double const&)
inline Derived& DenseBase<Derived>::operator/=(const Scalar& other)
{
  typedef typename internal::conditional<NumTraits<Scalar>::IsInteger,
                                        internal::scalar_quotient_op<Scalar>,
                                        internal::scalar_product_op<Scalar> >::type BinOp;
  typedef typename Derived::PlainObject PlainObject;
  SelfCwiseBinaryOp<BinOp, Derived, typename PlainObject::ConstantReturnType> tmp(derived());
  Scalar actual_other;
  if(NumTraits<Scalar>::IsInteger)  actual_other = other;
  else                              actual_other = Scalar(1)/other;
  tmp = PlainObject::Constant(rows(),cols(), actual_other);
  return derived();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movsd 0x19f98(%rip), %xmm0    # 0x40070
divsd (%rsi), %xmm0
movq %rsp, %rcx
movsd %xmm0, (%rcx)
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x26ae8
movsd 0x8(%r14), %xmm0
movq (%rbx), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/Swap.h
// Function: void Eigen::SwapWrapper<Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>, -1, 1, false>>::copyPacket<Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>, -1, 1, false>, 1, 0>(long, Eigen::DenseBase<Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>, -1, 1, false>> const&)
void copyPacket(Index index, const DenseBase<OtherDerived>& other)
    {
      OtherDerived& _other = other.const_cast_derived();
      eigen_internal_assert(index >= 0 && index < m_expression.size());
      Packet tmp = m_expression.template packet<StoreMode>(index);
      m_expression.template writePacket<StoreMode>(index,
        _other.template packet<LoadMode>(index)
      );
      _other.template writePacket<LoadMode>(index, tmp);
    }

// Assembly:
movq (%rdi), %rax
movq (%rax), %rax
movaps (%rax,%rsi,8), %xmm0
movq (%rdx), %rcx
movups (%rcx,%rsi,8), %xmm1
movaps %xmm1, (%rax,%rsi,8)
movq (%rdx), %rax
movups %xmm0, (%rax,%rsi,8)
retq
nop