LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/src/gzReader.hpp
// Function: readDouble(std::istream&)
double readDouble(istream& in)
{
  int num = sizeof(int64_t)/sizeof(char);
  char* s = new char [num];
  in.read(s, num);
  int64_t d = *((int64_t*)s);
  swap_endian(d);
  double ans = *((double*)&d);
  delete[] s;
  return ans;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl $0x8, %edi
callq 0xc040
movq %rax, %rbx
movl $0x8, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0xc6f0
movq (%rbx), %rcx
leaq 0xf(%rsp), %rax
movq %rcx, -0x7(%rax)
xorl %ecx, %ecx
movb 0x8(%rsp,%rcx), %dl
movb (%rax), %sil
movb %sil, 0x8(%rsp,%rcx)
movb %dl, (%rax)
incq %rcx
decq %rax
cmpq $0x4, %rcx
jne 0x12308
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
callq 0xc710
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/src/gzReader.hpp
// Function: readString[abi:cxx11](std::istream&)
string readString(istream& in)
{
  int num = sizeof(int16_t)/sizeof(char);
  char* s = new char [num];
  in.read(s, num);
  int16_t d = *((int16_t*)s);
  swap_endian(d);
  delete[] s;
  s = new char [d+1];
  in.read(s, d);
  s[d]='\0';
  string ss = string(s);
  delete[] s;
  return ss;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x2, %edi
callq 0xc040
movq %rax, %r15
movl $0x2, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0xc6f0
movzwl (%r15), %ebp
movq %r15, %rdi
callq 0xc710
rolw $0x8, %bp
movswq %bp, %r15
leaq 0x1(%r15), %rdi
callq 0xc040
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xc6f0
movb $0x0, (%r12,%r15)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r12, %rdi
callq 0xc250
leaq (%rax,%r12), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x278dc
movq %r12, %rdi
callq 0xc710
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/src/gzReader.hpp
// Function: gaussianDensity(double*, int, double, double, double)
double gaussianDensity(double* spec, int s, double omega, double sigsq, double norm)
{
  double d = 1e-30;
  for(int i=0; i<s; i++) 
    d += norm * fastpow2(1.442695040f * -((omega - spec[i]) * (omega - spec[i])) / sigsq);
  return d;
}

// Assembly:
testl %esi, %esi
jle 0x124c2
movl %esi, %eax
movsd 0x35cb2(%rip), %xmm3    # 0x48098
xorl %ecx, %ecx
xorps %xmm5, %xmm5
movss 0x35ded(%rip), %xmm6    # 0x481e0
movss 0x35de9(%rip), %xmm4    # 0x481e4
movss 0x35de4(%rip), %xmm8    # 0x481e8
movss 0x35ddf(%rip), %xmm9    # 0x481ec
movss 0x35dda(%rip), %xmm10   # 0x481f0
movss 0x35dd5(%rip), %xmm11   # 0x481f4
movss 0x35dd0(%rip), %xmm12   # 0x481f8
movapd %xmm0, %xmm13
subsd (%rdi,%rcx,8), %xmm13
mulsd %xmm13, %xmm13
mulsd 0x35c5f(%rip), %xmm13   # 0x480a0
divsd %xmm1, %xmm13
cvtsd2ss %xmm13, %xmm13
movaps %xmm4, %xmm7
maxss %xmm13, %xmm7
cmpltss %xmm5, %xmm13
cvttps2dq %xmm7, %xmm15
cvtdq2ps %xmm15, %xmm15
andps %xmm6, %xmm13
movaps %xmm7, %xmm14
subss %xmm15, %xmm14
addss %xmm13, %xmm14
movaps %xmm9, %xmm13
subss %xmm14, %xmm13
movaps %xmm10, %xmm15
divss %xmm13, %xmm15
addss %xmm8, %xmm7
addss %xmm7, %xmm15
mulss %xmm11, %xmm14
addss %xmm15, %xmm14
mulss %xmm12, %xmm14
cvttss2si %xmm14, %rdx
movd %edx, %xmm7
cvtss2sd %xmm7, %xmm7
mulsd %xmm2, %xmm7
addsd %xmm7, %xmm3
incq %rcx
cmpq %rcx, %rax
jne 0x12428
jmp 0x124ca
movsd 0x35bce(%rip), %xmm3    # 0x48098
movapd %xmm3, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movups %xmm1, (%rdi)
movq $0x0, 0x10(%rdi)
ucomisd 0x35bb9(%rip), %xmm0    # 0x480b0
jbe 0x12509
movsd 0x35ba7(%rip), %xmm1    # 0x480a8
movapd %xmm1, 0x10(%rsp)
jmp 0x1253b
movsd 0x35b9f(%rip), %xmm2    # 0x480b0
mulsd %xmm0, %xmm2
addsd 0x35b9b(%rip), %xmm2    # 0x480b8
movsd 0x35b33(%rip), %xmm1    # 0x48058
mulsd %xmm1, %xmm2
cvttpd2dq %xmm2, %xmm2
cvtdq2pd %xmm2, %xmm2
divsd %xmm1, %xmm2
movapd %xmm2, 0x10(%rsp)
movapd %xmm0, %xmm1
addsd %xmm0, %xmm1
movapd %xmm0, 0x20(%rsp)
mulsd %xmm0, %xmm1
movsd 0x35b73(%rip), %xmm0    # 0x480c8
movsd %xmm1, 0x40(%rsp)
mulsd %xmm1, %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x1256f
sqrtsd %xmm0, %xmm0
jmp 0x12578
callq 0xc3f0
xorpd %xmm2, %xmm2
movapd 0x10(%rsp), %xmm1
ucomisd %xmm2, %xmm1
jbe 0x1269f
movsd 0x35b30(%rip), %xmm1    # 0x480c0
movapd 0x20(%rsp), %xmm3
mulsd %xmm3, %xmm1
cvttpd2dq %xmm1, %xmm1
cvtdq2pd %xmm1, %xmm1
divsd 0x35aae(%rip), %xmm1    # 0x48058
cmpltsd 0x35afd(%rip), %xmm3    # 0x480b0
movsd 0x35acd(%rip), %xmm2    # 0x48088
andpd %xmm3, %xmm2
andnpd %xmm1, %xmm3
orpd %xmm2, %xmm3
movapd %xmm3, 0x20(%rsp)
movsd 0x35a8b(%rip), %xmm1    # 0x48060
divsd %xmm0, %xmm1
movsd %xmm1, 0x38(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
leaq 0x50(%rsp), %r15
movq %r14, %rdi
movl %ebp, %esi
movsd %xmm0, 0x48(%rsp)
movsd 0x40(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
callq 0x123d4
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, 0x50(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x12633
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1263e
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3365e
movsd (%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x48(%rsp), %xmm1
addsd 0x20(%rsp), %xmm1
movapd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movapd %xmm1, %xmm0
ja 0x125ed
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
movsd (%rsp), %xmm1
je 0x1269f
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x12689
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x126c4
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0xc550
movq %r14, %rdi
callq 0xc9c0
// File: /workspace/github_cpp_makefile_star2_O3/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:
xorpd %xmm0, %xmm0
xorpd %xmm3, %xmm3
testl %edx, %edx
jle 0x12d8d
movl %edx, %eax
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
movsd 0x3540b(%rip), %xmm2    # 0x480d8
movss 0x35527(%rip), %xmm4    # 0x481fc
movss 0x35523(%rip), %xmm5    # 0x48200
movss 0x3551f(%rip), %xmm6    # 0x48204
movss 0x3551b(%rip), %xmm7    # 0x48208
movss 0x35516(%rip), %xmm8    # 0x4820c
movsd (%rdi,%rcx,8), %xmm9
movsd (%rsi,%rcx,8), %xmm10
movapd %xmm9, %xmm11
mulsd %xmm10, %xmm11
ucomisd %xmm1, %xmm11
jbe 0x12d81
movapd %xmm9, %xmm11
mulsd %xmm2, %xmm11
divsd %xmm10, %xmm9
cvtsd2ss %xmm9, %xmm9
movd %xmm9, %edx
xorps %xmm9, %xmm9
cvtsi2ss %rdx, %xmm9
andl $0x7fffff, %edx         # imm = 0x7FFFFF
orl $0x3f000000, %edx       # imm = 0x3F000000
mulss %xmm4, %xmm9
addss %xmm5, %xmm9
movd %edx, %xmm10
movdqa %xmm10, %xmm12
mulss %xmm6, %xmm12
addss %xmm9, %xmm12
addss %xmm7, %xmm10
movaps %xmm8, %xmm9
divss %xmm10, %xmm9
addss %xmm12, %xmm9
cvtss2sd %xmm9, %xmm9
mulsd %xmm11, %xmm9
addsd %xmm9, %xmm3
incq %rcx
cmpq %rcx, %rax
jne 0x12cf6
maxsd %xmm3, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %rcx
andq $-0x10, %rcx
subq %rcx, %r15
movq %r15, %rsp
testl %edx, %edx
jle 0x12de3
xorl %ecx, %ecx
movsd 0x3531a(%rip), %xmm0    # 0x480e0
movsd (%rdi,%rcx,8), %xmm1
addsd (%r14,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%r15,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x12dc6
movq %r15, %rsi
movl %ebx, %edx
callq 0x12cad
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x12cad
movsd 0x352d9(%rip), %xmm1    # 0x480e0
mulsd %xmm1, %xmm0
movsd -0x20(%rbp), %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
movapd %xmm2, %xmm0
jb 0x12e35
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 0xc3f0
// File: /workspace/github_cpp_makefile_star2_O3/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
testl %edx, %edx
jle 0x12eb5
movq %rsi, %r14
movq %rdi, %r15
movl %ebx, %eax
shlq $0x4, %rax
leaq (%rax,%rax,4), %r12
xorpd %xmm1, %xmm1
xorl %r13d, %r13d
movsd %xmm1, 0x8(%rsp)
movq 0x30(%r15,%r13), %rdi
movq 0x38(%r15,%r13), %rax
subq %rdi, %rax
shrq $0x3, %rax
movq 0x30(%r14,%r13), %rsi
movq 0x38(%r14,%r13), %rdx
subq %rsi, %rdx
shrq $0x3, %rdx
cmpl %edx, %eax
cmovll %eax, %edx
callq 0x12d92
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
addq $0x50, %r13
cmpq %r13, %r12
jne 0x12e6e
jmp 0x12eb9
xorpd %xmm1, %xmm1
xorps %xmm0, %xmm0
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_O3/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:
testq %rsi, %rsi
je 0x15a24
xorl %eax, %eax
movq (%rdi,%rax,8), %rcx
movss (%rcx), %xmm0
cmpq $0x2, %rdx
jb 0x159fc
movl $0x1, %r8d
movaps %xmm0, %xmm1
movss (%rcx,%r8,4), %xmm0
minss %xmm1, %xmm0
incq %r8
movaps %xmm0, %xmm1
cmpq %r8, %rdx
jne 0x159e5
jmp 0x15a01
testq %rdx, %rdx
je 0x15a1c
xorl %r8d, %r8d
movss (%rcx,%r8,4), %xmm1
subss %xmm0, %xmm1
movss %xmm1, (%rcx,%r8,4)
incq %r8
cmpq %r8, %rdx
jne 0x15a04
incq %rax
cmpq %rsi, %rax
jne 0x159ce
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0xc040
movq %rax, %r12
testq %r14, %r14
je 0x15a89
xorl %r13d, %r13d
movq %rbx, %rdi
callq 0xc040
movq %rax, (%r12,%r13,8)
testq %rbx, %rbx
je 0x15a81
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0xc2e0
incq %r13
cmpq %r13, %r14
jne 0x15a63
movq %r14, %rdi
callq 0xc040
movq %rax, %r13
movq %rbx, %rdi
callq 0xc040
movq %rax, %rbp
testq %r14, %r14
je 0x15abe
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0xc2e0
movq %rbp, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0xc2e0
testq %rbx, %rbx
je 0x15ad0
movq %rbp, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0xc2e0
testq %r14, %r14
je 0x15b27
xorl %eax, %eax
xorps %xmm0, %xmm0
testq %rbx, %rbx
je 0x15b1f
movb (%r13,%rax), %dl
xorl %ecx, %ecx
testb %dl, %dl
jne 0x15b17
cmpb $0x0, (%rbp,%rcx)
je 0x15af5
xorl %edx, %edx
jmp 0x15b17
movq (%r15,%rax,8), %rdx
movss (%rdx,%rcx,4), %xmm1
ucomiss %xmm0, %xmm1
jne 0x15af1
jp 0x15af1
movq (%r12,%rax,8), %rsi
movb $0x1, %dl
movb %dl, (%rsi,%rcx)
movb %dl, (%r13,%rax)
movb %dl, (%rbp,%rcx)
incq %rcx
cmpq %rcx, %rbx
jne 0x15ae6
incq %rax
cmpq %r14, %rax
jne 0x15ada
movq %r13, %rdi
callq 0xc710
movq %rbp, %rdi
callq 0xc710
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_O3/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
testq %rcx, %rcx
je 0x15b8d
testq %rdx, %rdx
je 0x15b71
xorl %r8d, %r8d
movq (%rdi,%r8,8), %r9
cmpb $0x1, (%r9,%rax)
je 0x15b6d
incq %r8
cmpq %r8, %rdx
jne 0x15b58
jmp 0x15b71
movb $0x1, (%rsi,%rax)
incq %rax
cmpq %rcx, %rax
jne 0x15b50
xorl %eax, %eax
xorl %edi, %edi
cmpb $0x1, (%rsi,%rdi)
sbbq $-0x1, %rax
incq %rdi
cmpq %rdi, %rcx
jne 0x15b7d
cmpq %rdx, %rax
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rcx, %rcx
je 0x16284
movss 0x3201d(%rip), %xmm0    # 0x48210
xorl %eax, %eax
testq %r8, %r8
sete %r9b
cmpb $0x0, (%rsi,%rax)
setne %r10b
orb %r9b, %r10b
jne 0x1622d
xorl %r9d, %r9d
cmpb $0x0, (%rdx,%r9)
jne 0x16225
movq (%rdi,%rax,8), %r10
movss (%r10,%r9,4), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x16225
movaps %xmm1, %xmm0
incq %r9
cmpq %r9, %r8
jne 0x1620c
incq %rax
cmpq %rcx, %rax
jne 0x161f5
xorl %eax, %eax
testq %r8, %r8
je 0x1627c
xorl %r9d, %r9d
cmpb $0x0, (%rsi,%rax)
je 0x16259
movq (%rdi,%rax,8), %r10
movss (%r10,%r9,4), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%r10,%r9,4)
cmpb $0x0, (%rdx,%r9)
jne 0x16274
movq (%rdi,%rax,8), %r10
movss (%r10,%r9,4), %xmm1
subss %xmm0, %xmm1
movss %xmm1, (%r10,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x1623f
incq %rax
cmpq %rcx, %rax
jne 0x16237
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rax
shrq $0x3d, %rax
leaq (,%rsi,8), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0xc040
movq %rax, %r12
testq %r14, %r14
je 0x162f7
xorl %r13d, %r13d
movl $0x10, %edi
callq 0xc040
movq %rax, (%r12,%r13,8)
testq %rbx, %rbx
je 0x162ef
movq (%r15,%r13,8), %rcx
xorl %edx, %edx
cmpb $0x1, (%rcx,%rdx)
jne 0x162e7
movq %r13, (%rax)
movq %rdx, 0x8(%rax)
incq %rdx
cmpq %rdx, %rbx
jne 0x162da
incq %r13
cmpq %r14, %r13
jne 0x162c1
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rbp
shrq $0x6, %rbp
andl $0x3f, %esi
cmpq $0x1, %rsi
sbbq $-0x1, %rbp
leaq (,%rbp,8), %r14
movq %r14, %rdi
callq 0xc040
movq %rax, %r13
movq %rax, (%rbx)
leaq 0x8(,%rbp,8), %r12
movq %r12, %rdi
callq 0xc040
movq %rax, %r15
movq %rax, 0x10(%rbx)
movq %r12, %rdi
callq 0xc040
movq %rax, %r12
movq %rax, 0x18(%rbx)
movl $0x8, %edi
callq 0xc520
movq %rax, 0x8(%rbx)
movq $0x0, (%rax)
testq %rbp, %rbp
je 0x163a1
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0xc2e0
movq %r12, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0xc2e0
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0xc2e0
xorl %eax, %eax
movq %rax, (%r12,%rbp,8)
movq %rax, (%r15,%rbp,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16444
leaq 0x10(%rsp), %rax
movq (%rax), %rax
movq -0x8(%rax,%rbx,8), %rax
decq %rbx
movq %rax, %rdi
negq %rdi
andq %rax, %rdi
callq 0x164b1
shlq $0x6, %rbx
addq %rax, %rbx
jmp 0x1644b
movq $-0x1, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq $-0x2, %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 0x164b0
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 0x164b0
movq %rax, (%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movsd %xmm0, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq (%rsi), %rbx
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rdi
callq 0x27846
leaq 0x58(%rsp), %r15
leaq 0x68(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x27846
leaq 0x78(%rsp), %r12
movsd 0x2fea5(%rip), %xmm1    # 0x48060
subsd 0x10(%rsp), %xmm1
movupd 0x40(%rbx), %xmm0
mulsd 0x2fea2(%rip), %xmm1    # 0x48070
movsd %xmm1, 0x10(%rsp)
movupd %xmm0, (%r12)
leaq 0x20(%rsp), %r13
leaq 0x38(%rsp), %rbp
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rsi, %rax
subq %rdi, %rax
cmpq $0x51, %rax
jl 0x1820c
addq $-0x50, %rsi
movq %rsi, %rdx
leaq 0xf(%rsp), %rcx
callq 0x45a70
movq 0x8(%r14), %rsi
addq $-0x50, %rsi
movq %rsi, 0x8(%r14)
movq %r14, %rdi
callq 0x3ffca
callq 0xc190
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
ucomisd 0x10(%rsp), %xmm0
jbe 0x1826e
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x1826e
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1dbaa
movq (%r14), %rbx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xc2d0
leaq 0x20(%rbx), %rsi
movq %r15, %rdi
callq 0xc2d0
movupd 0x40(%rbx), %xmm0
movupd %xmm0, (%r12)
jmp 0x181e4
leaq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rdi
callq 0x27606
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x1829e
movq 0x68(%rsp), %rsi
incq %rsi
callq 0xc550
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x182ba
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xc550
leaq 0x20(%rsp), %rdi
callq 0x1dc0a
movq 0x18(%rsp), %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18303
movq %rax, %rbx
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x18310
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xc550
jmp 0x18310
movq %rax, %rbx
jmp 0x18310
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x1dbd4
leaq 0x20(%rsp), %rdi
callq 0x1dc0a
movq %rbx, %rdi
callq 0xc9c0
// File: /workspace/github_cpp_makefile_star2_O3/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, 0xc(%rsp)
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x5efa1(%rip), %rdi     # 0x77f98
leaq 0x2f9f0(%rip), %rsi     # 0x489ee
movl $0x13, %edx
callq 0xc620
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq (%r12), %r13
cmpq 0x8(%r12), %r13
je 0x1904e
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x1dbaa
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1e4d4
addq $0x50, %r13
cmpq 0x8(%r12), %r13
jne 0x19029
leaq 0xf8c7(%rip), %rdi      # 0x2891c
callq 0x28826
movq %rax, 0x38(%rsp)
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movl 0xc(%rsp), %r8d
movsd 0x30(%rsp), %xmm0
callq 0x18322
movq 0x5ef14(%rip), %rdi     # 0x77f98
leaq 0x2f977(%rip), %rsi     # 0x48a02
movl $0x8, %edx
callq 0xc620
movq 0x8(%rbx), %rax
movq 0x70(%rax), %rsi
movq 0x5eef4(%rip), %rdi     # 0x77f98
callq 0xc360
movq %rax, %r12
leaq 0x2f958(%rip), %rsi     # 0x48a0b
movl $0xa, %edx
movq %rax, %rdi
callq 0xc620
leaq 0xf855(%rip), %rdi      # 0x2891c
callq 0x28826
leaq 0x40(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x38(%rsp), %rsi
callq 0x20fc4
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x7, %rdx
addq %rdx, %rsi
movq %r12, %rdi
callq 0xc4c0
leaq 0x2f6f5(%rip), %rsi     # 0x487fd
movl $0xe, %edx
movq %rax, %rdi
callq 0xc620
movq %r15, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x18afb
leaq 0x10(%rsp), %rdi
callq 0x1dc0a
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x19154
jmp 0x19143
movq %rax, %r14
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x27696
jmp 0x19157
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x1dc0a
movq %r14, %rdi
callq 0xc9c0
// File: /workspace/github_cpp_makefile_star2_O3/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)
movl 0x58(%rsp), %eax
testl %eax, %eax
jle 0x191f1
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %rbp
movl %eax, %eax
movq %rax, (%rsp)
xorl %r15d, %r15d
movq %rdi, 0x8(%rsp)
movq %rbp, %r14
movq %r13, %rbp
movq %rbx, %r13
movq 0x50(%rsp), %rax
movq (%rax,%r15,8), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc2d0
leaq 0x20(%rbx), %rdi
movq 0x10(%rsp), %rsi
callq 0xc2d0
movq %rbx, %rdi
movq %r13, %rbx
movq %rbp, %r13
movq %r14, %rbp
movq 0x8(%rsp), %rsi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
callq 0x1e6fc
incq %r15
cmpq %r15, (%rsp)
jne 0x1919e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/include/Eigen/src/Core/Transpositions.h
// Function: void Eigen::internal::transposition_matrix_product_retval<Eigen::Transpositions<-1, -1, int>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, 1, false>::evalTo<Eigen::Matrix<double, -1, 1, 0, -1, 1>>(Eigen::Matrix<double, -1, 1, 0, -1, 1>&) const
inline void evalTo(Dest& dst) const
    {
      const int size = m_transpositions.size();
      Index j = 0;

      if(!(is_same<MatrixTypeNestedCleaned,Dest>::value && extract_data(dst) == extract_data(m_matrix)))
        dst = m_matrix;

      for(int k=(Transposed?size-1:0) ; Transposed?k>=0:k<size ; Transposed?--k:++k)
        if((j=m_transpositions.coeff(k))!=k)
        {
          if(Side==OnTheLeft)
            dst.row(k).swap(dst.row(j));
          else if(Side==OnTheRight)
            dst.col(k).swap(dst.col(j));
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %r15
movq 0x8(%rax), %r12
movq (%rsi), %rax
cmpq (%r15), %rax
je 0x2b736
movq %rbx, %rdi
movq %r15, %rsi
callq 0x297f0
movq 0x8(%rbx), %rax
cmpq 0x8(%r15), %rax
jne 0x2b7b1
movq %rax, %rcx
shrq $0x3f, %rcx
addq %rax, %rcx
andq $-0x2, %rcx
cmpq $0x2, %rax
jl 0x2b719
xorl %edx, %edx
movq (%r15), %rsi
movaps (%rsi,%rdx,8), %xmm0
movq (%rbx), %rsi
movaps %xmm0, (%rsi,%rdx,8)
addq $0x2, %rdx
cmpq %rcx, %rdx
jl 0x2b702
cmpq %rax, %rcx
jge 0x2b736
movq (%r15), %rdx
movq (%rbx), %rsi
movsd (%rdx,%rcx,8), %xmm0
movsd %xmm0, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x2b724
testl %r12d, %r12d
jle 0x2b786
movq (%r14), %rax
movq (%rax), %rax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %esi, %esi
movl (%rax,%rsi,4), %edi
cmpq %rdi, %rsi
je 0x2b77e
cmpq %rsi, %rdx
jle 0x2b792
testl %edi, %edi
js 0x2b792
movslq %edi, %rdi
cmpq %rdi, %rdx
jle 0x2b792
movsd (%rcx,%rsi,8), %xmm0
movsd (%rcx,%rdi,8), %xmm1
movsd %xmm1, (%rcx,%rsi,8)
movsd %xmm0, (%rcx,%rdi,8)
incq %rsi
cmpq %rsi, %r12
jne 0x2b751
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x21a37(%rip), %rdi     # 0x4d1d0
leaq 0x216f1(%rip), %rsi     # 0x4ce91
leaq 0x24288(%rip), %rcx     # 0x4fa2f
movl $0x76, %edx
callq 0xc340
leaq 0x20b27(%rip), %rdi     # 0x4c2df
leaq 0x20b51(%rip), %rsi     # 0x4c310
leaq 0x20ffd(%rip), %rcx     # 0x4c7c3
movl $0x1f2, %edx            # imm = 0x1F2
callq 0xc340
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/include/Eigen/src/Core/PlainObjectBase.h
// Function: void Eigen::PlainObjectBase<Eigen::Matrix<double, 1, -1, 1, 1, -1>>::resizeLike<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, 1, -1, 1, 1, -1>>>(Eigen::EigenBase<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, 1, -1, 1, 1, -1>>> const&)
EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
    {
      const OtherDerived& other = _other.derived();
      internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.rows(), other.cols());
      const Index othersize = other.rows()*other.cols();
      if(RowsAtCompileTime == 1)
      {
        eigen_assert(other.rows() == 1 || other.cols() == 1);
        resize(1, othersize);
      }
      else if(ColsAtCompileTime == 1)
      {
        eigen_assert(other.rows() == 1 || other.cols() == 1);
        resize(othersize, 1);
      }
      else resize(other.rows(), other.cols());
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x2cd4b
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %r14
testq %rax, %rax
jle 0x2cd79
testq %r14, %r14
js 0x2cdb8
cmpq %r14, 0x8(%rbx)
je 0x2cdac
movq (%rbx), %rdi
callq 0xc660
testq %r14, %r14
je 0x2cda7
movq %r14, %rax
shrq $0x3d, %rax
jne 0x2cd79
leaq (,%r14,8), %rdi
callq 0xc750
testq %rax, %rax
jne 0x2cda9
movl $0x8, %edi
callq 0xc260
movq 0x4b1e6(%rip), %rcx     # 0x77f70
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x4b208(%rip), %rsi     # 0x77fa0
movq 0x4b1a1(%rip), %rdx     # 0x77f40
movq %rax, %rdi
callq 0xc990
xorl %eax, %eax
movq %rax, (%rbx)
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1f30c(%rip), %rdi     # 0x4c0cb
leaq 0x1f2dc(%rip), %rsi     # 0x4c0a2
leaq 0x2370f(%rip), %rcx     # 0x504dc
movl $0xf1, %edx
callq 0xc340
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/include/Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<double, -1, -1, -1, 0>::resize(long, long, long)
void resize(DenseIndex size, DenseIndex nbRows, DenseIndex nbCols)
    {
      if(size != m_rows*m_cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols);
        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;
      m_cols = nbCols;
    }
    inline const T *data() const { return m_data; }
    inline T *data() { return m_data; }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rax
imulq 0x8(%rdi), %rax
cmpq %rsi, %rax
je 0x2e132
movq %rsi, %r12
movq (%r15), %rdi
callq 0xc660
testq %r12, %r12
je 0x2e12d
movq %r12, %rax
shrq $0x3d, %rax
jne 0x2e0ff
shlq $0x3, %r12
movq %r12, %rdi
callq 0xc750
testq %rax, %rax
jne 0x2e12f
movl $0x8, %edi
callq 0xc260
movq 0x49e60(%rip), %rcx     # 0x77f70
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x49e82(%rip), %rsi     # 0x77fa0
movq 0x49e1b(%rip), %rdx     # 0x77f40
movq %rax, %rdi
callq 0xc990
xorl %eax, %eax
movq %rax, (%r15)
movq %r14, 0x8(%r15)
movq %rbx, 0x10(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/include/Eigen/src/Core/TriangularMatrix.h
// Function: void Eigen::TriangularView<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 10u>::lazyAssign<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>>>(Eigen::MatrixBase<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>>> const&)
void TriangularView<MatrixType, Mode>::lazyAssign(const MatrixBase<OtherDerived>& other)
{
  enum {
    unroll = MatrixType::SizeAtCompileTime != Dynamic
          && internal::traits<OtherDerived>::CoeffReadCost != Dynamic
          && MatrixType::SizeAtCompileTime*internal::traits<OtherDerived>::CoeffReadCost/2 <= EIGEN_UNROLLING_LIMIT
  };
  eigen_assert(m_matrix.rows() == other.rows() && m_matrix.cols() == other.cols());

  internal::triangular_assignment_selector
    <MatrixType, OtherDerived, int(Mode),
    unroll ? int(MatrixType::SizeAtCompileTime) : Dynamic,
    false // do not change the opposite triangular part
    >::run(m_matrix.const_cast_derived(), other.derived());
}

// Assembly:
pushq %rax
movq (%rdi), %rdx
movq 0x8(%rdx), %rax
cmpq (%rsi), %rax
jne 0x322ba
movq 0x10(%rdx), %rcx
cmpq 0x8(%rsi), %rcx
jne 0x322ba
testq %rcx, %rcx
jle 0x322b8
movq (%rdx), %rdx
addq $0x8, %rdx
leaq (,%rax,8), %rdi
xorl %r8d, %r8d
movdqa 0x15fb0(%rip), %xmm0    # 0x481a0
movdqa 0x15fb8(%rip), %xmm1    # 0x481b0
pcmpeqd %xmm2, %xmm2
movdqa 0x15fbc(%rip), %xmm3    # 0x481c0
cmpq %r8, %rax
movq %r8, %r9
cmovlq %rax, %r9
testq %r9, %r9
jle 0x322a9
incq %r9
andq $-0x2, %r9
cmpq %r8, %rax
movq %r8, %r10
cmovlq %rax, %r10
movsd 0x10(%rsi), %xmm4
decq %r10
movq %r10, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
pxor %xmm1, %xmm5
xorl %r10d, %r10d
movdqa %xmm0, %xmm6
movdqa %xmm6, %xmm7
pxor %xmm1, %xmm7
movdqa %xmm7, %xmm8
pcmpgtd %xmm5, %xmm8
pcmpeqd %xmm5, %xmm7
pshufd $0xf5, %xmm7, %xmm9     # xmm9 = xmm7[1,1,3,3]
pand %xmm8, %xmm9
pshufd $0xf5, %xmm8, %xmm7     # xmm7 = xmm8[1,1,3,3]
por %xmm9, %xmm7
movd %xmm7, %r11d
notl %r11d
testb $0x1, %r11b
je 0x32286
movsd %xmm4, -0x8(%rdx,%r10,8)
pxor %xmm2, %xmm7
pextrw $0x4, %xmm7, %r11d
testb $0x1, %r11b
je 0x3229c
movsd %xmm4, (%rdx,%r10,8)
addq $0x2, %r10
paddq %xmm3, %xmm6
cmpq %r10, %r9
jne 0x32245
incq %r8
addq %rdi, %rdx
cmpq %rcx, %r8
jne 0x32204
popq %rax
retq
leaq 0x2001c(%rip), %rdi     # 0x522dd
leaq 0x20058(%rip), %rsi     # 0x52320
leaq 0x223c7(%rip), %rcx     # 0x54696
movl $0x269, %edx            # imm = 0x269
callq 0xc340
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/include/Eigen/src/Core/Dot.h
// Function: Eigen::internal::scalar_product_traits<double, Eigen::internal::traits<Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>, -1, 1, false>>::Scalar>::ReturnType Eigen::MatrixBase<Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false>>::dot<Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>, -1, 1, false>>(Eigen::MatrixBase<Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>, -1, 1, false>> const&) const
typename internal::scalar_product_traits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType
MatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& other) const
{
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
  EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived)
  typedef internal::scalar_conj_product_op<Scalar,typename OtherDerived::Scalar> func;
  EIGEN_CHECK_BINARY_COMPATIBILIY(func,Scalar,typename OtherDerived::Scalar);

  eigen_assert(size() == other.size());

  return internal::dot_nocheck<Derived,OtherDerived>::run(*this, other);
}

// Assembly:
subq $0x88, %rsp
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0x2fb3b
movups (%rdi), %xmm0
movaps %xmm0, 0x10(%rsp)
movups 0x18(%rdi), %xmm0
movups %xmm0, 0x28(%rsp)
movups (%rsi), %xmm0
movups %xmm0, 0x38(%rsp)
movups 0x18(%rsi), %xmm0
movaps %xmm0, 0x50(%rsp)
movups 0x30(%rsi), %xmm0
movups %xmm0, 0x68(%rsp)
movq 0x40(%rsi), %rax
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x2fb30
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rsi
callq 0x3071e
jmp 0x2fb33
xorps %xmm0, %xmm0
addq $0x88, %rsp
retq
leaq 0x2397f(%rip), %rdi     # 0x534c1
leaq 0x2398f(%rip), %rsi     # 0x534d8
leaq 0x239a5(%rip), %rcx     # 0x534f5
movl $0x47, %edx
callq 0xc340
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/include/Eigen/src/Jacobi/Jacobi.h
// Function: Eigen::JacobiRotation<double>::makeGivens(double const&, double const&, double*, Eigen::internal::false_type)
void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::false_type)
{
  using std::sqrt;
  using std::abs;
  if(q==Scalar(0))
  {
    m_c = p<Scalar(0) ? Scalar(-1) : Scalar(1);
    m_s = Scalar(0);
    if(r) *r = abs(p);
  }
  else if(p==Scalar(0))
  {
    m_c = Scalar(0);
    m_s = q<Scalar(0) ? Scalar(1) : Scalar(-1);
    if(r) *r = abs(q);
  }
  else if(abs(p) > abs(q))
  {
    Scalar t = q/p;
    Scalar u = sqrt(Scalar(1) + numext::abs2(t));
    if(p<Scalar(0))
      u = -u;
    m_c = Scalar(1)/u;
    m_s = -t * m_c;
    if(r) *r = p * u;
  }
  else
  {
    Scalar t = p/q;
    Scalar u = sqrt(Scalar(1) + numext::abs2(t));
    if(q<Scalar(0))
      u = -u;
    m_s = -Scalar(1)/u;
    m_c = -t * m_s;
    if(r) *r = q * u;
  }

}

// Assembly:
movsd (%rdx), %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
movsd (%rsi), %xmm1
jne 0x332b8
jp 0x332b8
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
leaq 0x14f34(%rip), %rdx     # 0x481d0
movsd (%rdx,%rax,8), %xmm0
movsd %xmm0, (%rdi)
movq $0x0, 0x8(%rdi)
testq %rcx, %rcx
je 0x332f6
movsd (%rsi), %xmm0
jmp 0x332ea
ucomisd %xmm0, %xmm1
jne 0x332f7
jp 0x332f7
movq $0x0, (%rdi)
xorl %eax, %eax
ucomisd (%rdx), %xmm0
seta %al
leaq 0x14eb9(%rip), %rsi     # 0x48190
movsd (%rsi,%rax,8), %xmm0
movsd %xmm0, 0x8(%rdi)
testq %rcx, %rcx
je 0x332f6
movsd (%rdx), %xmm0
andpd 0x14e3e(%rip), %xmm0    # 0x48130
movsd %xmm0, (%rcx)
retq
movapd 0x14e31(%rip), %xmm0    # 0x48130
movapd %xmm1, %xmm3
andpd %xmm0, %xmm3
andpd %xmm2, %xmm0
ucomisd %xmm0, %xmm3
jbe 0x33372
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
mulsd %xmm2, %xmm0
movsd 0x14d3b(%rip), %xmm3    # 0x48060
addsd %xmm3, %xmm0
sqrtsd %xmm0, %xmm0
movapd 0x14e0b(%rip), %xmm4    # 0x48140
xorpd %xmm5, %xmm5
cmpltsd %xmm5, %xmm1
movapd %xmm1, %xmm5
andnpd %xmm0, %xmm5
xorpd %xmm4, %xmm0
andpd %xmm1, %xmm0
orpd %xmm5, %xmm0
divsd %xmm0, %xmm3
movsd %xmm3, (%rdi)
xorpd %xmm4, %xmm2
mulsd %xmm3, %xmm2
movsd %xmm2, 0x8(%rdi)
testq %rcx, %rcx
je 0x332f6
mulsd (%rsi), %xmm0
jmp 0x332f2
divsd %xmm2, %xmm1
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addsd 0x14cda(%rip), %xmm0    # 0x48060
sqrtsd %xmm0, %xmm0
movapd 0x14dae(%rip), %xmm3    # 0x48140
xorpd %xmm4, %xmm4
cmpltsd %xmm4, %xmm2
movapd %xmm2, %xmm4
andnpd %xmm0, %xmm4
xorpd %xmm3, %xmm0
andpd %xmm2, %xmm0
orpd %xmm4, %xmm0
movsd 0x14cc1(%rip), %xmm2    # 0x48078
divsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rdi)
xorpd %xmm3, %xmm1
mulsd %xmm2, %xmm1
movsd %xmm1, (%rdi)
testq %rcx, %rcx
je 0x332f6
mulsd (%rdx), %xmm0
jmp 0x332f2
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/include/./threadpool/./detail/pool_core.hpp
// Function: boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>::wait(unsigned long) const volatile
void wait(size_t const task_threshold = 0) const volatile
    {
      const pool_type* self = const_cast<const pool_type*>(this);
      recursive_mutex::scoped_lock lock(self->m_monitor);

      if(0 == task_threshold)
      {
        while(0 != self->m_active_worker_count || !self->m_scheduler.empty())
        { 
          self->m_worker_idle_or_terminated_event.wait(lock);
        }
      }
      else
      {
        while(task_threshold < self->m_active_worker_count + self->m_scheduler.size())
        { 
          self->m_worker_idle_or_terminated_event.wait(lock);
        }
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa0(%rdi), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0x34a28
testq %r14, %r14
je 0x347ab
leaq 0xc8(%rbx), %r15
leaq 0x8(%rsp), %r12
movq 0x70(%rbx), %rax
movq %rax, %rcx
subq 0x50(%rbx), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
shlq $0x4, %rcx
movq 0x48(%rbx), %rax
movq 0x58(%rbx), %rdx
subq 0x60(%rbx), %rdx
sarq $0x5, %rdx
subq 0x38(%rbx), %rax
sarq $0x5, %rax
addq %rcx, %rax
addq 0x20(%rbx), %rdx
addq %rax, %rdx
cmpq %r14, %rdx
jbe 0x347d5
movq %r15, %rdi
movq %r12, %rsi
callq 0x34926
jmp 0x3475c
leaq 0xc8(%rbx), %r14
leaq 0x8(%rsp), %r15
cmpq $0x0, 0x20(%rbx)
jne 0x347c8
movq 0x58(%rbx), %rax
cmpq 0x38(%rbx), %rax
je 0x347d5
movq %r14, %rdi
movq %r15, %rsi
callq 0x34926
jmp 0x347b7
cmpb $0x1, 0x10(%rsp)
jne 0x347e6
movq 0x8(%rsp), %rdi
callq 0x35340
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x347f4
movq %rax, %rbx
cmpb $0x1, 0x10(%rsp)
jne 0x34808
movq 0x8(%rsp), %rdi
callq 0x35340
movq %rbx, %rdi
callq 0xc9c0
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/include/./threadpool/./detail/pool_core.hpp
// Function: boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>::terminate_all_workers(bool) volatile
void terminate_all_workers(bool const wait) volatile
    {
      pool_type* self = const_cast<pool_type*>(this);
      recursive_mutex::scoped_lock lock(self->m_monitor);

      self->m_terminate_all_workers = true;

      m_target_worker_count = 0;
      self->m_task_or_terminate_workers_event.notify_all();

      if(wait)
      {
        while(m_active_worker_count > 0)
        {
          self->m_worker_idle_or_terminated_event.wait(lock);
        }

        for(typename std::vector<shared_ptr<worker_type> >::iterator it = self->m_terminated_workers.begin();
          it != self->m_terminated_workers.end();
          ++it)
        {
          (*it)->join();
        }
        self->m_terminated_workers.clear();
      }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xa0(%rdi), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0x34a28
movb $0x1, 0x80(%rbx)
movq $0x0, 0x18(%rbx)
leaq 0x120(%rbx), %rdi
callq 0x35770
testl %ebp, %ebp
je 0x348cc
leaq 0xc8(%rbx), %r14
movq %rsp, %r15
cmpq $0x0, 0x20(%rbx)
je 0x34874
movq %r14, %rdi
movq %r15, %rsi
callq 0x34926
jmp 0x34860
movq 0x88(%rbx), %r14
cmpq 0x90(%rbx), %r14
je 0x348cc
movq (%r14), %rdi
testq %rdi, %rdi
je 0x348e9
callq 0x357c8
addq $0x10, %r14
cmpq 0x90(%rbx), %r14
jne 0x34884
movq 0x88(%rbx), %r15
cmpq %r15, %r14
je 0x348cc
addq $-0x10, %r14
leaq -0x10(%r15), %r12
leaq 0x18(%r12), %rdi
callq 0x21c42
addq $0x10, %r12
cmpq %r12, %r14
jne 0x348b2
movq %r15, 0x90(%rbx)
cmpb $0x1, 0x8(%rsp)
jne 0x348dc
movq (%rsp), %rdi
callq 0x35340
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15c67(%rip), %rdi     # 0x4a557
leaq 0x15c68(%rip), %rsi     # 0x4a55f
leaq 0x23bd0(%rip), %rcx     # 0x584ce
movl $0x2d8, %edx            # imm = 0x2D8
callq 0xc340
jmp 0x3490a
movq %rax, %rbx
cmpb $0x1, 0x8(%rsp)
jne 0x3491d
movq (%rsp), %rdi
callq 0x35340
movq %rbx, %rdi
callq 0xc9c0
nop