LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x180fc
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x180ec
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd 0xa401f(%rip), %xmm0    # 0xbc0c0
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
divsd (%rax,%rcx,8), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x18130
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
cvtss2sd %xmm1, %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x180ee
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x18062
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0x18110
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x1811a
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Kingsford-Group[P]ghost2/src/spectralToDistance.hpp
// Function: fastlog2(float)
static inline float fastlog2 (float x)
{
  union { float f; uint32_t i; } vx = { x };
  union { uint32_t i; float f; } mx = { (vx.i & 0x007FFFFF) | 0x3f000000 };
  float y = vx.i;
  y *= 1.1920928955078125e-7f;
  return y - 124.22551499f
           - 1.498030302f * mx.f
           - 1.72587999f / (0.3520887068f + mx.f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x7fffff, %eax         # imm = 0x7FFFFF
orl $0x3f000000, %eax       # imm = 0x3F000000
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, -0x10(%rbp)
movss 0xa4024(%rip), %xmm0    # 0xbc18c
mulss -0x10(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm1
movss 0xa4009(%rip), %xmm0    # 0xbc188
subss %xmm0, %xmm1
movss -0xc(%rbp), %xmm0
movss 0xa3ff4(%rip), %xmm2    # 0xbc184
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss 0xa3fe0(%rip), %xmm2    # 0xbc180
addss -0xc(%rbp), %xmm2
movss 0xa3fcf(%rip), %xmm1    # 0xbc17c
divss %xmm2, %xmm1
subss %xmm1, %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, %rsp
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x18247
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm1
movq -0x10(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
addsd (%rcx,%rdx,8), %xmm1
movsd 0xa3e99(%rip), %xmm0    # 0xbc0c8
mulsd %xmm1, %xmm0
movslq -0x2c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x18201
movq -0x38(%rbp), %rsi
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
callq 0x18040
movq -0x38(%rbp), %rsi
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
callq 0x18040
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movsd 0xa3e4c(%rip), %xmm1    # 0xbc0c8
mulsd %xmm2, %xmm1
movsd 0xa3e40(%rip), %xmm2    # 0xbc0c8
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x10560
movq -0x20(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x18382
movq -0x8(%rbp), %rdi
movslq -0x24(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x25500
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x25500
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x24(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rdi
addq $0x30, %rdi
callq 0x254e0
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rdi
addq $0x30, %rdi
callq 0x254e0
movl -0x3c(%rbp), %edi
movl %eax, %esi
callq 0x18010
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl %eax, %edx
callq 0x181c0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x182d2
movsd -0x20(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
divsd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x1b418
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1b3ca
movss -0x2c(%rbp), %xmm0
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
ucomiss (%rax,%rcx,4), %xmm0
jbe 0x1b3ba
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x2c(%rbp)
jmp 0x1b3bc
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1b38b
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1b405
movss -0x2c(%rbp), %xmm1
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
subss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1b3d2
jmp 0x1b407
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1b358
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x1b6b1
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1b6a1
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
movsbq (%rax,%rcx), %rax
cmpq $0x1, %rax
jne 0x1b691
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x1, (%rax,%rcx)
jmp 0x1b6a1
jmp 0x1b693
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1b65e
jmp 0x1b6a3
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1b64c
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x1b6f5
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x1b6e5
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1b6e7
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1b6c1
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
sete %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movss 0xa0000(%rip), %xmm0    # 0xbc190
movss %xmm0, -0x3c(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x1c233
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x1c220
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1c21e
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x1c20e
movss -0x3c(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rbp), %rcx
ucomiss (%rax,%rcx,4), %xmm0
jbe 0x1c20e
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x3c(%rbp)
jmp 0x1c210
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1c1c1
jmp 0x1c220
jmp 0x1c222
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1c19d
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x1c2df
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1c2cc
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x1c288
movss -0x3c(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rbp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x1c2bc
movss -0x3c(%rbp), %xmm1
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
subss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x1c2be
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1c251
jmp 0x1c2ce
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1c23b
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x10040
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x1c3d3
movl $0x10, %edi
callq 0x10040
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1c3c0
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
movsbq (%rax,%rcx), %rax
cmpq $0x1, %rax
jne 0x1c3b0
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x8(%rax)
jmp 0x1c3b2
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1c364
jmp 0x1c3c2
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1c335
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
andq $0x3f, %rax
cmpq $0x0, %rax
je 0x1c41a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x10040
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x10040
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x10040
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x8, %edi
callq 0x106e0
movq -0x28(%rbp), %rcx
movq %rax, 0x8(%rcx)
movq $0x0, (%rax)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x1c51d
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rdx
movq $0x0, (%rcx,%rdx,8)
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rdx
movq $0x0, (%rcx,%rdx,8)
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1c4d2
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x18(%rcx), %rdx
movq -0x10(%rbp), %rsi
movq $0x0, (%rdx,%rsi,8)
movq 0x10(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq $0x0, (%rcx,%rdx,8)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Kingsford-Group[P]ghost2/include/hungarian.hpp
// Function: BitSet_set(BitSet, unsigned long)
void BitSet_set(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++;
	*(this_.prev + *(this_.first)) = j;
	*(this_.prev + j) = 0;
	*(this_.next + j) = *(this_.first);
	*(this_.first) = j;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
shrq $0x6, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %esi
shlq %cl, %rsi
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
orq (%rcx,%rdx,8), %rsi
movq %rsi, (%rcx,%rdx,8)
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpq $0x0, -0x18(%rbp)
setne %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
je 0x1c619
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq 0x10(%rax), %rcx
movq 0x8(%rax), %rdx
movq (%rdx), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rdx
movq $0x0, (%rcx,%rdx,8)
movq 0x8(%rax), %rcx
movq (%rcx), %rsi
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq -0x10(%rbp), %rcx
movq 0x8(%rax), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rax
cmpq $0x0, (%rax)
jne 0x1c644
movq $-0x1, -0x8(%rbp)
jmp 0x1c686
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
subq (%rcx,%rdx,8), %rax
andq %rax, %rdi
callq 0x1c780
movq -0x10(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
shrq $0x6, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %esi
shlq %cl, %rsi
xorq $-0x1, %rsi
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
andq (%rcx,%rdx,8), %rsi
movq %rsi, (%rcx,%rdx,8)
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpq $0x0, -0x18(%rbp)
setne %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
je 0x1c77a
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, -0x20(%rbp)
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rsi
movq 0x10(%rax), %rcx
movq -0x28(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq -0x28(%rbp), %rsi
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x1c778
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rax), %rax
movq %rcx, (%rax)
jmp 0x1c77a
popq %rbp
retq
nopl (%rax)
// File: Kingsford-Group[P]ghost2/include/hungarian.hpp
// Function: lb(long)
size_t lb(llong value)
{
    size_t rc = 0;
    llong v = value;
    
    if (v & (int_fast64_t)0xFFFFFFFF00000000LL)  {  rc |= 32L;  v >>= 32LL;  }
    if (v & (int_fast64_t)0x00000000FFFF0000LL)  {  rc |= 16L;  v >>= 16LL;  }
    if (v & (int_fast64_t)0x000000000000FF00LL)  {  rc |=  8L;  v >>=  8LL;  }
    if (v & (int_fast64_t)0x00000000000000F0LL)  {  rc |=  4L;  v >>=  4LL;  }
    if (v & (int_fast64_t)0x000000000000000CLL)  {  rc |=  2L;  v >>=  2LL;  }
    if (v & (int_fast64_t)0x0000000000000002LL)     rc |=  1L;
    
    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq -0x18(%rbp), %rax
cmpq $0x0, %rax
je 0x1c7c4
movq -0x10(%rbp), %rax
orq $0x20, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
sarq $0x20, %rax
movq %rax, -0x18(%rbp)
movabsq $0xffff0000, %rax       # imm = 0xFFFF0000
andq -0x18(%rbp), %rax
cmpq $0x0, %rax
je 0x1c7f0
movq -0x10(%rbp), %rax
orq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
sarq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0xff00, %rax           # imm = 0xFF00
cmpq $0x0, %rax
je 0x1c818
movq -0x10(%rbp), %rax
orq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
sarq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0xf0, %rax
cmpq $0x0, %rax
je 0x1c840
movq -0x10(%rbp), %rax
orq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
sarq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0xc, %rax
cmpq $0x0, %rax
je 0x1c866
movq -0x10(%rbp), %rax
orq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
sarq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x1c880
movq -0x10(%rbp), %rax
orq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x27ed0
movq -0x18(%rbp), %rdi
callq 0x290e0
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0x28950
jmp 0x1e879
jmp 0x1e87b
jmp 0x1e87d
movq -0x18(%rbp), %rdi
callq 0x275a0
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
callq 0x27610
movq %rax, -0xa0(%rbp)
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x29850
jmp 0x1e8b2
movq -0x18(%rbp), %rdi
callq 0x29180
callq 0x101f0
cvtsi2sd %eax, %xmm0
movsd 0x9d7a4(%rip), %xmm1    # 0xbc070
subsd -0x10(%rbp), %xmm1
movsd 0x9d807(%rip), %xmm2    # 0xbc0e0
mulsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1e94b
movq -0x18(%rbp), %rdi
callq 0x27750
cmpq $0x0, %rax
jbe 0x1e94b
leaq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x27f30
jmp 0x1e901
movq -0x18(%rbp), %rdi
callq 0x290e0
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0x289f0
jmp 0x1e918
jmp 0x1e94d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x1e98a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x27fc0
jmp 0x1e98a
jmp 0x1e952
jmp 0x1e87b
movq -0xb8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x298c0
jmp 0x1e968
leaq -0x80(%rbp), %rdi
callq 0x27fc0
leaq -0x30(%rbp), %rdi
callq 0x27ff0
movq -0xb0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x27ff0
movq -0x88(%rbp), %rdi
callq 0x10cc0
nop
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %r9, -0x50(%rbp)
movq %r8, -0x48(%rbp)
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl 0x18(%rbp), %eax
jge 0x1fb70
movq -0x48(%rbp), %rsi
movq 0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x10070
movq -0x50(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0x10070
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x29f90
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1fb16
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x30(%rbp)
xorl %eax, %eax
testb $0x1, 0x3c(%rcx)
movb %al, -0x21(%rbp)
je 0x2487a
movb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x2487a
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x24883
jmp 0x24885
jmp 0x248a4
leaq 0x9f97d(%rip), %rdi     # 0xc4209
leaq 0x9c969(%rip), %rsi     # 0xc11fc
movl $0xbc, %edx
leaq 0x9f998(%rip), %rcx     # 0xc4237
callq 0x104a0
movq -0x30(%rbp), %rdi
callq 0x24690
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4add0
movq -0x40(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x31(%rbp)
jne 0x248d2
movb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x248d2
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x248db
jmp 0x248dd
jmp 0x248fc
leaq 0x9fa7f(%rip), %rdi     # 0xc4363
leaq 0x9c911(%rip), %rsi     # 0xc11fc
movl $0xbe, %edx
leaq 0x9f940(%rip), %rcx     # 0xc4237
callq 0x104a0
movq -0x20(%rbp), %rdi
callq 0x4aec0
movq -0x30(%rbp), %rsi
movq %rax, %rdx
leaq -0x10(%rbp), %rdi
callq 0x58500
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
callq 0x28d70
movq -0xc8(%rbp), %rdi
addq $0x60, %rdi
leaq 0x9181c(%rip), %rsi     # 0xbc88c
callq 0x23540
testb $0x1, %al
jne 0x2b07b
jmp 0x2b096
movq -0xc8(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
addq $0x60, %rsi
callq 0x28d70
movq -0xc8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq %rsi, %rdx
addq $0x40, %rdx
leaq -0x50(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x28f40
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x28e90
jmp 0x2b0d8
leaq -0x50(%rbp), %rdi
callq 0x28f70
movq -0xc8(%rbp), %rdi
addq $0x60, %rdi
leaq 0x91799(%rip), %rsi     # 0xbc88c
callq 0x23540
testb $0x1, %al
jne 0x2b101
jmp 0x2b18c
movq -0xc8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq %rdx, %rsi
addq $0x60, %rsi
addq $0x20, %rdx
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x28f40
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
callq 0x28e90
jmp 0x2b14d
leaq -0xb0(%rbp), %rdi
callq 0x28f70
jmp 0x2b18c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x28f70
jmp 0x2b1a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x28f70
jmp 0x2b1a8
movq -0xc8(%rbp), %rsi
movq %rsi, %rdi
addq $0x60, %rdi
callq 0x10070
addq $0xf0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x10cc0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rax, -0x8(%rbp)
jbe 0x4a7f9
callq 0x4a840
movq -0x10(%rbp), %rdi
shlq $0x3, %rdi
callq 0x4a820
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rcx), %rcx
shlq $0x0, %rcx
cmpq %rcx, %rax
je 0x4adbe
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
shlq $0x0, %rsi
callq 0x32390
cmpq $0x0, -0x10(%rbp)
je 0x4adb1
movq -0x10(%rbp), %rdi
callq 0x4a7d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4adbc
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
jmp 0x4adbe
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: Kingsford-Group[P]ghost2/include/Eigen/src/Core/SelfCwiseBinaryOp.h
// Function: Eigen::DenseBase<Eigen::Matrix<double, -1, 1, 0, -1, 1>>::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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4a950
movq %rax, -0x60(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x4b1a0
movq -0x60(%rbp), %rsi
leaq -0x20(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x4b1b0
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd 0x70f25(%rip), %xmm0    # 0xbc070
divsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x4add0
movq -0x50(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x4ae00
movq -0x58(%rbp), %rsi
movq %rax, %rdx
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rcx
callq 0x4b1f0
leaq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4b250
movq -0x50(%rbp), %rdi
callq 0x4a950
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Kingsford-Group[P]ghost2/include/Eigen/src/Cholesky/LDLT.h
// Function: Eigen::LDLT<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1>::compute(Eigen::Matrix<double, -1, -1, 0, -1, -1> const&)
LDLT<MatrixType,_UpLo>& LDLT<MatrixType,_UpLo>::compute(const MatrixType& a)
{
  eigen_assert(a.rows()==a.cols());
  const Index size = a.rows();

  m_matrix = a;

  m_transpositions.resize(size);
  m_isInitialized = false;
  m_temporary.resize(size);

  internal::ldlt_inplace<UpLo>::unblocked(m_matrix, m_transpositions, m_temporary, m_sign);

  m_isInitialized = true;
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x24690
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x286d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0x4cf4c
jmp 0x4cf6b
leaq 0x74296(%rip), %rdi     # 0xc11e9
leaq 0x742a2(%rip), %rsi     # 0xc11fc
movl $0x1c1, %edx            # imm = 0x1C1
leaq 0x742b8(%rip), %rcx     # 0xc121e
callq 0x104a0
movq -0x10(%rbp), %rdi
callq 0x24690
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x286f0
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
callq 0x4d1b0
movq -0x28(%rbp), %rdi
movb $0x0, 0x3c(%rdi)
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x4d1e0
movq -0x28(%rbp), %rdi
movq %rdi, %rsi
addq $0x18, %rsi
movq %rdi, %rdx
addq $0x28, %rdx
movq %rdi, %rcx
addq $0x38, %rcx
callq 0x4d240
movq -0x28(%rbp), %rax
movb $0x1, 0x3c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x51490
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x51630
movq -0x58(%rbp), %rax
movapd %xmm0, -0x30(%rbp)
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x516e0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movapd %xmm0, -0x40(%rbp)
leaq -0x40(%rbp), %rdx
callq 0x51680
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x51730
addq $0x60, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq (%rax), %rdi
callq 0x59450
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x59480
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x68(%rbp)
movq 0x8(%rax), %rdi
callq 0x59480
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
je 0x593e4
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdi
callq 0x594a0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5944a
movq -0x70(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x594d0
movl (%rax), %eax
movl %eax, -0x18(%rbp)
cmpl -0x1c(%rbp), %eax
je 0x5943d
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x58ee0
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x58ee0
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
xorl %edx, %edx
callq 0x59500
jmp 0x5943f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x593eb
addq $0x70, %rsp
popq %rbp
retq
// File: Kingsford-Group[P]ghost2/include/Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<double, -1, 1, -1, 1>::resize(long, long, long)
EIGEN_STRONG_INLINE void resize(DenseIndex size, DenseIndex, DenseIndex nbCols)
    {
      if(size != _Rows*m_cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _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_cols = nbCols;
    }
    inline const T *data() const { return m_data; }
    inline T *data() { return m_data; }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rcx), %rcx
shlq $0x0, %rcx
cmpq %rcx, %rax
je 0x6297e
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
shlq $0x0, %rsi
callq 0x32390
cmpq $0x0, -0x10(%rbp)
je 0x62971
movq -0x10(%rbp), %rdi
callq 0x4a7d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x6297c
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
jmp 0x6297e
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: Kingsford-Group[P]ghost2/include/Eigen/src/Core/GeneralProduct.h
// Function: void Eigen::internal::gemv_selector<1, 0, true>::run<Eigen::GeneralProduct<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 4>, Eigen::Matrix<double, 1, -1, 1, 1, -1>>(Eigen::GeneralProduct<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 4> const&, Eigen::Matrix<double, 1, -1, 1, 1, -1>&, Eigen::GeneralProduct<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 4>::Scalar const&)
static void run(const ProductType& prod, Dest& dest, const typename ProductType::Scalar& alpha)
  {
    Transpose<Dest> destT(dest);
    enum { OtherStorageOrder = StorageOrder == RowMajor ? ColMajor : RowMajor };
    gemv_selector<OnTheRight,OtherStorageOrder,BlasCompatible>
      ::run(GeneralProduct<Transpose<const typename ProductType::_RhsNested>,Transpose<const typename ProductType::_LhsNested>, GemvProduct>
        (prod.rhs().transpose(), prod.lhs().transpose()), destT, alpha);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x635e0
movq -0x8(%rbp), %rdi
callq 0x638d0
movq %rax, %rdi
callq 0x5e500
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x638f0
movq %rax, %rdi
callq 0x63900
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
leaq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x63930
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x63610
jmp 0x635a7
leaq -0x40(%rbp), %rdi
callq 0x63960
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x63960
movq -0x58(%rbp), %rdi
callq 0x10cc0
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rdx), %rcx
imulq 0x10(%rdx), %rcx
cmpq %rcx, %rax
je 0x68110
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
imulq 0x10(%rax), %rsi
callq 0x32390
cmpq $0x0, -0x10(%rbp)
je 0x68103
movq -0x10(%rbp), %rdi
callq 0x4a7d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x6810e
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
jmp 0x68110
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Kingsford-Group[P]ghost2/include/Eigen/src/Core/TriangularMatrix.h
// Function: Eigen::internal::triangular_assignment_selector<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1u, -1, true>::run(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::Matrix<double, -1, -1, 0, -1, -1> const&)
static inline void run(Derived1 &dst, const Derived2 &src)
  {
    for(Index j = 0; j < dst.cols(); ++j)
    {
      for(Index i = j; i < dst.rows(); ++i)
        dst.copyCoeff(i, j, src);
      Index maxi = (std::min)(j, dst.rows());
      if (ClearOpposite)
        for(Index i = 0; i < maxi; ++i)
          dst.coeffRef(i, j) = static_cast<typename Derived1::Scalar>(0);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x286d0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jge 0x69afd
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24690
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jge 0x69a91
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x69b40
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x69a51
movq -0x8(%rbp), %rdi
callq 0x24690
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x37360
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x69aea
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4cc60
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x69aba
jmp 0x69aec
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x69a28
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)