LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/MCMCobject_admixture.cpp
// Function: MCMCobject_admixture::d_logLikeGroup()
void MCMCobject_admixture::d_logLikeGroup() {
    
    // Multinomial-Dirichlet likelihood
    logLikeGroup = 0;
    for (int k=0; k<K; k++) {
        for (int l=0; l<loci; l++) {
            for (int j=0; j<J[l]; j++) {
                logLikeGroup += my_lgamma(lambda + alleleCounts[k][l][j]) - my_lgamma(lambda);
            }
            logLikeGroup += my_lgamma(J[l]*lambda) - my_lgamma(J[l]*lambda + alleleCountsTotals[k][l]);
        }
    }
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x1e8(%rdi)
xorl %r14d, %r14d
movslq 0x1c(%rbx), %rax
cmpq %rax, %r14
jge 0x9331
imulq $0x18, %r14, %r15
xorl %r12d, %r12d
movslq 0x24(%rbx), %rax
cmpq %rax, %r12
jge 0x9329
imulq $0x18, %r12, %r13
xorl %ebp, %ebp
movq 0x28(%rbx), %rax
movslq (%rax,%r12,4), %rax
cmpq %rax, %rbp
jge 0x92c8
movq 0x110(%rbx), %rax
movq (%rax,%r15), %rax
movq (%rax,%r13), %rax
cvtsi2sdl (%rax,%rbp,4), %xmm0
addsd 0x78(%rbx), %xmm0
callq 0x32a0
movsd %xmm0, (%rsp)
movsd 0x78(%rbx), %xmm0
callq 0x32a0
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
addsd 0x1e8(%rbx), %xmm1
movsd %xmm1, 0x1e8(%rbx)
incq %rbp
jmp 0x9270
cvtsi2sd %eax, %xmm0
mulsd 0x78(%rbx), %xmm0
callq 0x32a0
movq 0x28(%rbx), %rax
cvtsi2sdl (%rax,%r12,4), %xmm1
movq 0x128(%rbx), %rax
movq (%rax,%r15), %rax
cvtsi2sdl (%rax,%r12,4), %xmm2
movsd %xmm0, (%rsp)
mulsd 0x78(%rbx), %xmm1
addsd %xmm2, %xmm1
movapd %xmm1, %xmm0
callq 0x32a0
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
addsd 0x1e8(%rbx), %xmm1
movsd %xmm1, 0x1e8(%rbx)
incq %r12
jmp 0x925d
incq %r14
jmp 0x9249
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/MCMCobject_admixture.cpp
// Function: MCMCobject_admixture::drawFreqs()
void MCMCobject_admixture::drawFreqs() {
    
    // draw allele frequencies
    double randSum;
    for (int k=0; k<K; k++) {
        for (int l=0; l<loci; l++) {
            randSum = 0;
            for (int j=0; j<J[l]; j++) {
                alleleFreqs[k][l][j] = rgamma1(alleleCounts[k][l][j]+lambda, 1.0);
                randSum += alleleFreqs[k][l][j];
            }
            for (int j=0; j<J[l]; j++) {
                alleleFreqs[k][l][j] /= randSum;
            }
            
        }
    }
    
    // draw admixture proportions
    for (int i=0; i<n; i++) {
        randSum = 0;
        for (int k=0; k<K; k++) {
            admixFreqs[i][k] = rgamma1(admixCounts[i][k]+alpha, 1.0);
            randSum += admixFreqs[i][k];
        }
        for (int k=0; k<K; k++) {
            admixFreqs[i][k] /= randSum;
        }
    }
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %ecx, %ecx
movslq 0x1c(%rbx), %rax
cmpq %rax, %rcx
jge 0x942b
movq %rcx, 0x10(%rsp)
imulq $0x18, %rcx, %r12
xorl %r13d, %r13d
movslq 0x24(%rbx), %rax
cmpq %rax, %r13
jge 0x941e
xorpd %xmm1, %xmm1
imulq $0x18, %r13, %rbp
xorl %r15d, %r15d
movq 0x28(%rbx), %rax
movslq (%rax,%r13,4), %rax
cmpq %rax, %r15
jge 0x93e5
movq 0x110(%rbx), %rax
movq (%rax,%r12), %rax
movq (%rax,%rbp), %rax
cvtsi2sdl (%rax,%r15,4), %xmm0
addsd 0x78(%rbx), %xmm0
movsd %xmm1, 0x8(%rsp)
movsd 0x1de54(%rip), %xmm1    # 0x27210
callq 0x1709f
movsd 0x8(%rsp), %xmm1
movq 0x140(%rbx), %rax
movq (%rax,%r12), %rax
movq (%rax,%rbp), %rax
movsd %xmm0, (%rax,%r15,8)
addsd %xmm0, %xmm1
incq %r15
jmp 0x9387
movq 0x140(%rbx), %rcx
addq %r12, %rcx
testl %eax, %eax
cmovlel %r14d, %eax
xorl %edx, %edx
cmpq %rdx, %rax
je 0x9416
movq (%rcx), %rsi
movq (%rsi,%rbp), %rsi
movsd (%rsi,%rdx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rsi,%rdx,8)
incq %rdx
jmp 0x93f7
incq %r13
jmp 0x936f
movq 0x10(%rsp), %rcx
incq %rcx
jmp 0x9356
xorl %r14d, %r14d
movslq 0x20(%rbx), %rcx
cmpq %rcx, %r14
jge 0x94d3
xorpd %xmm1, %xmm1
imulq $0x18, %r14, %r15
xorl %r12d, %r12d
movslq %eax, %rcx
cmpq %rcx, %r12
jge 0x949d
movq 0x188(%rbx), %rax
movq (%rax,%r15), %rax
cvtsi2sdl (%rax,%r12,4), %xmm0
addsd 0x88(%rbx), %xmm0
movsd %xmm1, 0x8(%rsp)
movsd 0x1dd9b(%rip), %xmm1    # 0x27210
callq 0x1709f
movsd 0x8(%rsp), %xmm1
movq 0x1b8(%rbx), %rax
movq (%rax,%r15), %rax
movsd %xmm0, (%rax,%r12,8)
addsd %xmm0, %xmm1
incq %r12
movl 0x1c(%rbx), %eax
jmp 0x9446
addq 0x1b8(%rbx), %r15
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x94cb
movq (%r15), %rsi
movsd (%rsi,%rdx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rsi,%rdx,8)
incq %rdx
jmp 0x94b0
incq %r14
jmp 0x942e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/MCMCobject_admixture.cpp
// Function: MCMCobject_admixture::d_logLikeJoint()
void MCMCobject_admixture::d_logLikeJoint() {
    
    // calculate likelihood
    logLikeJoint = 0;
    double temp1;
    for (int i=0; i<n; i++) {
        for (int l=0; l<loci; l++) {
            for (int p=0; p<ploidy_vec[i]; p++) {
                if (data[i][l][p]!=0) {
                    temp1 = 0;
                    for (int k=0; k<K; k++) {
                        temp1 += admixFreqs[i][k]*alleleFreqs[k][l][data[i][l][p]-1];
                    }
                    logLikeJoint += log(temp1);
                }
            }
        }
    }
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x218(%rdi)
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq 0x20(%rbx), %rax
cmpq %rax, %r15
jge 0x95c4
imulq $0x18, %r15, %r12
xorl %ecx, %ecx
movslq 0x24(%rbx), %rax
cmpq %rax, %rcx
jge 0x95bc
movq %rcx, (%rsp)
imulq $0x18, %rcx, %rbp
xorl %r13d, %r13d
movq 0x40(%rbx), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %r13
jge 0x95b0
movq (%rbx), %rax
movq (%rax,%r12), %rax
movq (%rax,%rbp), %rax
movslq (%rax,%r13,4), %rax
testq %rax, %rax
je 0x95a8
movl 0x1c(%rbx), %ecx
movq 0x1b8(%rbx), %rdx
addq %r12, %rdx
movq 0x140(%rbx), %rsi
testl %ecx, %ecx
cmovlel %r14d, %ecx
xorpd %xmm0, %xmm0
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x9593
movq (%rdx), %r8
movsd (%r8,%rdi,8), %xmm1
movq (%rsi), %r8
movq (%r8,%rbp), %r8
mulsd -0x8(%r8,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rdi
addq $0x18, %rsi
jmp 0x956a
callq 0x32d0
addsd 0x218(%rbx), %xmm0
movsd %xmm0, 0x218(%rbx)
incq %r13
jmp 0x9529
movq (%rsp), %rcx
incq %rcx
jmp 0x9511
incq %r15
jmp 0x94fe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/MCMCobject_noAdmixture.cpp
// Function: MCMCobject_noAdmixture::produceQmatrix()
void MCMCobject_noAdmixture::produceQmatrix() {
    
    // populate Qmatrix_ind_new
    for (int i=0; i<n; i++) {
        logProbVecSum = log(double(0));
        for (int k=0; k<K; k++) {
            d_logLikeConditional(i, k);   // update logProbVec[k]
            logProbVecSum = logSum(logProbVecSum, logProbVec[k]);
        }
        for (int k=0; k<K; k++) {
            logQmatrix_ind_new[i][k] = logProbVec[k]-logProbVecSum;
        }
    }
    
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
xorl %r14d, %r14d
movslq 0x20(%rbx), %rax
cmpq %rax, %r14
jge 0xbe23
xorpd %xmm0, %xmm0
callq 0x32d0
movsd %xmm0, 0x188(%rbx)
xorl %r15d, %r15d
movslq 0x1c(%rbx), %rax
cmpq %rax, %r15
jge 0xbde2
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0xc4cc
movsd 0x188(%rbx), %xmm0
movq 0x170(%rbx), %rax
movsd (%rax,%r15,8), %xmm1
callq 0x14ce5
movsd %xmm0, 0x188(%rbx)
incq %r15
jmp 0xbda4
movq 0x170(%rbx), %rcx
imulq $0x18, %r14, %rdx
addq 0x1d0(%rbx), %rdx
testl %eax, %eax
cmovlel %r12d, %eax
xorl %esi, %esi
cmpq %rsi, %rax
je 0xbe1b
movsd (%rcx,%rsi,8), %xmm0
subsd 0x188(%rbx), %xmm0
movq (%rdx), %rdi
movsd %xmm0, (%rdi,%rsi,8)
incq %rsi
jmp 0xbdfc
incq %r14
jmp 0xbd83
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/MCMCobject_noAdmixture.cpp
// Function: MCMCobject_noAdmixture::storeQmatrix()
void MCMCobject_noAdmixture::storeQmatrix() {
    
    // store individual-level Qmatrix
    for (int i=0; i<n; i++) {
        for (int k=0; k<K; k++) {
            logQmatrix_ind[i][k] = logSum(logQmatrix_ind[i][k], logQmatrix_ind_new[i][k]);
        }
    }
    
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0x20(%rbx), %rax
cmpq %rax, %r14
jge 0xc1bb
imulq $0x18, %r14, %r15
xorl %r12d, %r12d
movslq 0x1c(%rbx), %rax
cmpq %rax, %r12
jge 0xc1b6
movq 0x1d0(%rbx), %rax
movq 0x200(%rbx), %rcx
movq (%rcx,%r15), %rcx
movsd (%rcx,%r12,8), %xmm0
movq (%rax,%r15), %rax
movsd (%rax,%r12,8), %xmm1
callq 0x14ce5
movq 0x200(%rbx), %rax
movq (%rax,%r15), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0xc170
incq %r14
jmp 0xc160
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/MCMCobject_noAdmixture.cpp
// Function: MCMCobject_noAdmixture::drawFreqs()
void MCMCobject_noAdmixture::drawFreqs() {

    double randSum;
    for (int k=0; k<K; k++) {
        for (int l=0; l<loci; l++) {
            randSum = 0;
            for (int j=0; j<J[l]; j++) {
                alleleFreqs[k][l][j] = rgamma1(alleleCounts[k][l][j]+lambda, 1.0);
                randSum += alleleFreqs[k][l][j];
            }
            for (int j=0; j<J[l]; j++) {
                alleleFreqs[k][l][j] /= randSum;
            }
            
        }
    }
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %ecx, %ecx
movslq 0x1c(%rbx), %rax
cmpq %rax, %rcx
jge 0xc3c3
movq %rcx, 0x8(%rsp)
imulq $0x18, %rcx, %r12
xorl %r13d, %r13d
movslq 0x24(%rbx), %rax
cmpq %rax, %r13
jge 0xc3b6
xorpd %xmm1, %xmm1
imulq $0x18, %r13, %rbp
xorl %r15d, %r15d
movq 0x28(%rbx), %rax
movslq (%rax,%r13,4), %rax
cmpq %rax, %r15
jge 0xc37d
movq 0xa8(%rbx), %rax
movq (%rax,%r12), %rax
movq (%rax,%rbp), %rax
cvtsi2sdl (%rax,%r15,4), %xmm0
addsd 0x70(%rbx), %xmm0
movsd %xmm1, 0x10(%rsp)
movsd 0x1aebc(%rip), %xmm1    # 0x27210
callq 0x1709f
movsd 0x10(%rsp), %xmm1
movq 0xd8(%rbx), %rax
movq (%rax,%r12), %rax
movq (%rax,%rbp), %rax
movsd %xmm0, (%rax,%r15,8)
addsd %xmm0, %xmm1
incq %r15
jmp 0xc31f
movq 0xd8(%rbx), %rcx
addq %r12, %rcx
testl %eax, %eax
cmovlel %r14d, %eax
xorl %edx, %edx
cmpq %rdx, %rax
je 0xc3ae
movq (%rcx), %rsi
movq (%rsi,%rbp), %rsi
movsd (%rsi,%rdx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rsi,%rdx,8)
incq %rdx
jmp 0xc38f
incq %r13
jmp 0xc307
movq 0x8(%rsp), %rcx
incq %rcx
jmp 0xc2ee
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/MCMCobject_noAdmixture.cpp
// Function: MCMCobject_noAdmixture::d_logLikeJoint()
void MCMCobject_noAdmixture::d_logLikeJoint() {
    
    // calculate likelihood
    logLikeJoint = 0;
    double running = 1.0;
    for (int i=0; i<n; i++) {
        for (int l=0; l<loci; l++) {
            for (int p=0; p<ploidy_vec[i]; p++) {
                if (data[i][l][p]!=0) {
                    running *= alleleFreqs[group[i]-1][l][data[i][l][p]-1];
                }
                if (running<UNDERFLO) {
                    logLikeJoint += log(running);
                    running = 1.0;
                }
            }
        }
    }
    logLikeJoint += log(running);
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x150(%rdi)
movsd 0x1ae20(%rip), %xmm0    # 0x27210
xorl %r14d, %r14d
movsd 0x1ae35(%rip), %xmm1    # 0x27230
movslq 0x20(%rbx), %rax
cmpq %rax, %r14
jge 0xc4a8
imulq $0x18, %r14, %r15
xorl %r12d, %r12d
movslq 0x24(%rbx), %rax
cmpq %rax, %r12
jge 0xc4a0
imulq $0x18, %r12, %r13
xorl %ebp, %ebp
movq 0x40(%rbx), %rax
movslq (%rax,%r14,4), %rax
cmpq %rax, %rbp
jge 0xc498
movq (%rbx), %rax
movq (%rax,%r15), %rax
movq (%rax,%r13), %rax
movslq (%rax,%rbp,4), %rax
testq %rax, %rax
je 0xc468
movq 0x90(%rbx), %rcx
movq 0xd8(%rbx), %rdx
movslq (%rcx,%r14,4), %rcx
imulq $0x18, %rcx, %rcx
movq -0x18(%rdx,%rcx), %rcx
movq (%rcx,%r13), %rcx
mulsd -0x8(%rcx,%rax,8), %xmm0
ucomisd %xmm0, %xmm1
jbe 0xc493
callq 0x32d0
movsd 0x1adb5(%rip), %xmm1    # 0x27230
addsd 0x150(%rbx), %xmm0
movsd %xmm0, 0x150(%rbx)
movsd 0x1ad7d(%rip), %xmm0    # 0x27210
incq %rbp
jmp 0xc422
incq %r12
jmp 0xc40f
incq %r14
jmp 0xc3fb
callq 0x32d0
addsd 0x150(%rbx), %xmm0
movsd %xmm0, 0x150(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/exhaustive.cpp
// Function: exhaustive_admix(globals&, int)
void exhaustive_admix(globals &globals, int Kindex) {
    
    // alpha fixed
    if (globals.fixAlpha_on) {
        
        globals.logEvidence_exhaustive[Kindex] = exhaustive_admix_fixedAlpha(globals, Kindex, globals.alpha[Kindex]);
        
    // alpha variable (integrate over alpha by brute force)
    } else {
        
        double logEvidence_total = log(double(0));
        for (int i=0; i<100; i++) {
            double alpha = (i+1)/10.0;
            logEvidence_total = logSum(logEvidence_total, exhaustive_admix_fixedAlpha(globals, Kindex, alpha));
        }
        logEvidence_total -= log(100.0);
        globals.logEvidence_exhaustive[Kindex] = logEvidence_total;
        
    }
    
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x1, 0x2bd1(%rdi)
jne 0xd9fa
movslq %ebp, %r14
movq 0x2bd8(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
movq %rbx, %rdi
movl %ebp, %esi
callq 0xda5f
jmp 0xda49
xorpd %xmm0, %xmm0
callq 0x32d0
pushq $0x1
popq %r14
cmpl $0x65, %r14d
je 0xda3e
movsd %xmm0, 0x8(%rsp)
cvtsi2sd %r14d, %xmm0
divsd 0x197f8(%rip), %xmm0    # 0x27218
movq %rbx, %rdi
movl %ebp, %esi
callq 0xda5f
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x14ce5
incl %r14d
jmp 0xda07
addsd 0x19822(%rip), %xmm0    # 0x27268
movslq %ebp, %r14
movq 0x2e00(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/misc.cpp
// Function: logSum(double, double)
double logSum(double logA, double logB) {
    if (logA-logB > 100) {
        return(logA);
    } else if (logB-logA > 100) {
        return(logB);
    }
    double output = (logA<logB) ? logB + log(1+exp(logA-logB)) : logA + log(1+exp(logB-logA));
    return(output);
}

// Assembly:
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
ucomisd 0x12e53(%rip), %xmm2    # 0x27b48
ja 0x14d4c
movapd %xmm1, %xmm3
subsd %xmm0, %xmm3
ucomisd 0x12e41(%rip), %xmm3    # 0x27b48
jbe 0x14d0e
movapd %xmm1, %xmm0
retq
pushq %rax
movapd %xmm0, %xmm4
cmpltsd %xmm1, %xmm4
andpd %xmm4, %xmm2
andnpd %xmm3, %xmm4
orpd %xmm2, %xmm4
maxsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movapd %xmm4, %xmm0
callq 0x35c0
addsd 0x124d2(%rip), %xmm0    # 0x27210
callq 0x32d0
addsd (%rsp), %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/misc.cpp
// Function: harmonicMean(std::vector<double, std::allocator<double>>&)
double harmonicMean(vector<double> &x) {
    double output = 0;
    double minVal =  *min_element(begin(x),end(x));
    for (int i=0; i<int(x.size()); i++)
        output += 1.0/exp(x[i]-minVal);
    output = minVal- log(output/x.size());
    return(output);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
callq 0x63eb
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
xorpd %xmm2, %xmm2
xorl %r14d, %r14d
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
movq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %r14
jge 0x14dbf
movsd (%rcx,%r14,8), %xmm0
subsd 0x8(%rsp), %xmm0
movsd %xmm2, 0x10(%rsp)
callq 0x35c0
movsd 0x10(%rsp), %xmm2
movsd 0x1245e(%rip), %xmm1    # 0x27210
divsd %xmm0, %xmm1
addsd %xmm1, %xmm2
incq %r14
jmp 0x14d74
sarq $0x3, %rax
movq %rax, %xmm0
punpckldq 0x12d40(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x12d48(%rip), %xmm0    # 0x27b20
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
callq 0x32d0
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/misc.cpp
// Function: normalise_log(std::vector<double, std::allocator<double>>)
vector<double> normalise_log(vector<double> x) {
    
    vector<double> output(x.size());
    double maxVal = *max_element(begin(x),end(x));
    double sumVal = 0;
    for (int i=0; i<int(x.size()); i++) {
        output[i] = exp(x[i]-maxVal);
        sumVal += output[i];
    }
    for (int i=0; i<int(x.size()); i++) {
        output[i] /= sumVal;
    }
    return(output);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
leaq 0xf(%rsp), %rdx
callq 0x4f6c
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0xc694
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
xorpd %xmm1, %xmm1
xorl %r15d, %r15d
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
shrq $0x3, %rax
movslq %eax, %rdx
cmpq %rdx, %r15
jge 0x14e8d
movsd (%rcx,%r15,8), %xmm0
subsd 0x10(%rsp), %xmm0
movsd %xmm1, 0x18(%rsp)
callq 0x35c0
movsd 0x18(%rsp), %xmm1
movq (%rbx), %rax
movsd %xmm0, (%rax,%r15,8)
addsd %xmm0, %xmm1
incq %r15
jmp 0x14e48
movq (%rbx), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x14eaf
movsd (%rcx,%rdx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
jmp 0x14e97
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/misc.cpp
// Function: StirlingFirst(int)
vector<int> StirlingFirst(int n) {
    
    vector<int> oldVec(2,1);
    vector<int> newVec(2);
    
    // simple answer if n<=0, n==1 or n==2
    if (n<=0)
        return(vector<int>(1));
    else if (n==1)
        return(vector<int>(1,1));
    else if (n==2)
        return(oldVec);
    
    // otherwise calculate by looping
    for (int i=2; i<n; i++) {
        newVec[0] = oldVec[0]*i;
        for (int j=1; j<int(oldVec.size()); j++) {
            newVec[j] = oldVec[j]*i + oldVec[j-1];
        }
        newVec.push_back(1);
        oldVec = vector<int>(newVec);
    }
    
    return(newVec);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0x30(%rsp), %rdi
pushq $0x2
popq %r14
leaq 0x50(%rsp), %rcx
movq %r14, %rsi
callq 0x5f08
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movq %r14, %rsi
callq 0x5f7c
testl %ebp, %ebp
jle 0x152e5
cmpl $0x1, %ebp
je 0x152fa
cmpl $0x2, %ebp
jne 0x1531a
movaps 0x30(%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
jmp 0x153d0
pushq $0x1
popq %rsi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x5f7c
jmp 0x153d0
leaq 0x50(%rsp), %rdx
movl $0x1, (%rdx)
pushq $0x1
popq %rsi
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
callq 0x5f08
jmp 0x153d0
movq %rbx, 0x48(%rsp)
pushq $0x2
popq %r13
pushq $0x1
popq %rbx
leaq 0x10(%rsp), %r14
leaq 0x50(%rsp), %r15
leaq 0x30(%rsp), %r12
cmpl %ebp, %r13d
jge 0x153ac
movq 0x30(%rsp), %rax
movl (%rax), %edx
imull %r13d, %edx
movq 0x10(%rsp), %rcx
movl %edx, (%rcx)
movq 0x38(%rsp), %rdx
subq %rax, %rdx
shrq $0x2, %rdx
movslq %edx, %rdx
movq %rbx, %rsi
cmpq %rdx, %rsi
jge 0x15376
movl (%rax,%rsi,4), %edi
imull %r13d, %edi
addl -0x4(%rax,%rsi,4), %edi
movl %edi, (%rcx,%rsi,4)
incq %rsi
jmp 0x1535e
movl $0x1, 0x50(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x16e6e
movq %r15, %rdi
movq %r14, %rsi
callq 0x5fce
movq %r12, %rdi
movq %r15, %rsi
callq 0x6266
movq %r15, %rdi
callq 0x61d0
incl %r13d
jmp 0x15335
movaps 0x10(%rsp), %xmm0
movq 0x48(%rsp), %rbx
movups %xmm0, (%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x61d0
leaq 0x30(%rsp), %rdi
callq 0x61d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15401
jmp 0x15401
movq %rax, %rbx
jmp 0x1540e
jmp 0x15401
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x61d0
leaq 0x30(%rsp), %rdi
callq 0x61d0
movq %rbx, %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/misc.cpp
// Function: StirlingSecond(int)
vector<double> StirlingSecond(int n) {
    
    vector<double> oldVec(2,0);
    vector<double> newVec(2,0);
    
    // simple answer if n<=0, n==1 or n==2
    if (n<=0)
        return(vector<double>(1,log(0.0)));
    else if (n==1)
        return(vector<double>(1));
    else if (n==2)
        return(oldVec);
    
    // otherwise calculate by looping
    for (int i=2; i<n; i++) {
        for (int j=1; j<int(oldVec.size()); j++) {
            newVec[j] = logSum(oldVec[j-1],oldVec[j]+log(double(j+1)));
        }
        newVec.push_back(0);
        oldVec = vector<double>(newVec);
    }
    
    return(newVec);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x30(%rsp), %rdi
pushq $0x2
popq %r14
leaq 0x60(%rsp), %r15
movq %r14, %rsi
movq %r15, %rcx
callq 0x5120
andq $0x0, (%r15)
leaq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rdx
leaq 0xf(%rsp), %rcx
movq %r14, %rsi
callq 0x5120
testl %ebp, %ebp
jle 0x154a2
cmpl $0x1, %ebp
je 0x154c8
cmpl $0x2, %ebp
jne 0x154dd
movaps 0x30(%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
jmp 0x155bb
xorps %xmm0, %xmm0
callq 0x32d0
leaq 0x60(%rsp), %rdx
movsd %xmm0, (%rdx)
pushq $0x1
popq %rsi
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
callq 0x5120
jmp 0x155bb
pushq $0x1
popq %rsi
leaq 0x60(%rsp), %rdx
movq %rbx, %rdi
callq 0x4f6c
jmp 0x155bb
movq %rbx, 0x48(%rsp)
pushq $0x2
popq %r13
leaq 0x10(%rsp), %r14
leaq 0x60(%rsp), %r15
cmpl %ebp, %r13d
jge 0x15597
pushq $0x1
popq %rbx
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbx
jge 0x1555e
movsd -0x8(%rax,%rbx,8), %xmm0
movsd %xmm0, 0x58(%rsp)
movsd (%rax,%rbx,8), %xmm0
movsd %xmm0, 0x50(%rsp)
leaq 0x1(%rbx), %r12
cvtsi2sd %r12d, %xmm0
callq 0x32d0
movsd 0x50(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x58(%rsp), %xmm0
callq 0x14ce5
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax,%rbx,8)
movq %r12, %rbx
jmp 0x154fc
andq $0x0, 0x60(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x16f4e
movq %r15, %rdi
movq %r14, %rsi
callq 0x537e
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x55b8
movq %r15, %rdi
callq 0x51a2
incl %r13d
jmp 0x154f0
movaps 0x10(%rsp), %xmm0
movq 0x48(%rsp), %rbx
movups %xmm0, (%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x51a2
leaq 0x30(%rsp), %rdi
callq 0x51a2
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x155ec
jmp 0x155ec
movq %rax, %rbx
jmp 0x155f9
jmp 0x155ec
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x51a2
leaq 0x30(%rsp), %rdi
callq 0x51a2
movq %rbx, %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/misc.cpp
// Function: printMatrix_exp(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
void printMatrix_exp(vector< vector<int> > &M) {
    for (int i=0; i<int(M.size()); i++) {
        for (int j=0; j<int(M[i].size()); j++) {
            cout << exp(double(M[i][j])) << " ";
        }
        cout << "\n";
    }
    cout << "\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r13d, %r13d
movq 0x1e88f(%rip), %r14     # 0x33fb8
leaq 0x14313(%rip), %r15     # 0x29a43
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cltq
cmpq %rax, %r13
jge 0x157a2
imulq $0x18, %r13, %rbp
xorl %r12d, %r12d
movq (%rcx,%rbp), %rax
movq 0x8(%rcx,%rbp), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r12
jge 0x1578e
cvtsi2sdl (%rax,%r12,4), %xmm0
callq 0x35c0
movq %r14, %rdi
callq 0x34d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x3350
incq %r12
movq (%rbx), %rcx
jmp 0x15750
movq %r14, %rdi
leaq 0x12123(%rip), %rsi     # 0x278bb
callq 0x3350
incq %r13
jmp 0x15730
movq 0x1e80f(%rip), %rdi     # 0x33fb8
leaq 0x1210b(%rip), %rsi     # 0x278bb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/misc.cpp
// Function: printMatrix_exp(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
void printMatrix_exp(vector< vector<double> > &M) {
    for (int i=0; i<int(M.size()); i++) {
        for (int j=0; j<int(M[i].size()); j++) {
            cout << exp(M[i][j]) << " ";
        }
        cout << "\n";
    }
    cout << "\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r13d, %r13d
movq 0x1e7dd(%rip), %r14     # 0x33fb8
leaq 0x14261(%rip), %r15     # 0x29a43
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cltq
cmpq %rax, %r13
jge 0x15854
imulq $0x18, %r13, %rbp
xorl %r12d, %r12d
movq (%rcx,%rbp), %rax
movq 0x8(%rcx,%rbp), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r12
jge 0x15840
movsd (%rax,%r12,8), %xmm0
callq 0x35c0
movq %r14, %rdi
callq 0x34d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x3350
incq %r12
movq (%rbx), %rcx
jmp 0x15802
movq %r14, %rdi
leaq 0x12071(%rip), %rsi     # 0x278bb
callq 0x3350
incq %r13
jmp 0x157e2
movq 0x1e75d(%rip), %rdi     # 0x33fb8
leaq 0x12059(%rip), %rsi     # 0x278bb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/misc.cpp
// Function: printArray_exp(std::vector<std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>, std::allocator<std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>>>&)
void printArray_exp(vector< vector< vector<int> > > &x) {
    for (int i=0; i<int(x.size()); i++) {
        cout << "--- slice " << i+1 << " ---\n";
        for (int j=0; j<int(x[i].size()); j++) {
            for (int k=0; k<int(x[i][j].size()); k++) {
                cout << exp(double(x[i][j][k])) << " ";
            }
            cout << "\n";
        }
        cout << "\n";
    }
    cout << "\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x1e728(%rip), %r14     # 0x33fb8
leaq 0x141ac(%rip), %r13     # 0x29a43
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cltq
cmpq %rax, %r15
jge 0x15987
movq %r14, %rdi
leaq 0x12305(%rip), %rsi     # 0x27bc0
callq 0x3350
leaq 0x1(%r15), %rsi
movq %rax, %rdi
movq %rsi, 0x8(%rsp)
callq 0x3570
movq %rax, %rdi
leaq 0x122f0(%rip), %rsi     # 0x27bcb
callq 0x3350
imulq $0x18, %r15, %r15
xorl %edi, %edi
movq (%rbx), %rax
movq (%rax,%r15), %rcx
movq 0x8(%rax,%r15), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cltq
cmpq %rax, %rdi
jge 0x1596e
movq %rdi, 0x10(%rsp)
imulq $0x18, %rdi, %rbp
xorl %r12d, %r12d
movq (%rcx,%rbp), %rax
movq 0x8(%rcx,%rbp), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r12
jge 0x15952
cvtsi2sdl (%rax,%r12,4), %xmm0
callq 0x35c0
movq %r14, %rdi
callq 0x34d0
movq %rax, %rdi
movq %r13, %rsi
callq 0x3350
incq %r12
movq (%rbx), %rax
movq (%rax,%r15), %rcx
jmp 0x15910
movq %r14, %rdi
leaq 0x11f5f(%rip), %rsi     # 0x278bb
callq 0x3350
movq 0x10(%rsp), %rdi
incq %rdi
jmp 0x158e6
movq %r14, %rdi
leaq 0x11f43(%rip), %rsi     # 0x278bb
callq 0x3350
movq 0x8(%rsp), %r15
jmp 0x15897
movq 0x1e62a(%rip), %rdi     # 0x33fb8
leaq 0x11f26(%rip), %rsi     # 0x278bb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/misc.cpp
// Function: printArray_exp(std::vector<std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>, std::allocator<std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>>>&)
void printArray_exp(vector< vector< vector<double> > > &x) {
    for (int i=0; i<int(x.size()); i++) {
        cout << "--- slice " << i+1 << " ---\n";
        for (int j=0; j<int(x[i].size()); j++) {
            for (int k=0; k<int(x[i][j].size()); k++) {
                cout << exp(x[i][j][k]) << " ";
            }
            cout << "\n";
        }
        cout << "\n";
    }
    cout << "\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x1e5f5(%rip), %r14     # 0x33fb8
leaq 0x14079(%rip), %r13     # 0x29a43
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cltq
cmpq %rax, %r15
jge 0x15aba
movq %r14, %rdi
leaq 0x121d2(%rip), %rsi     # 0x27bc0
callq 0x3350
leaq 0x1(%r15), %rsi
movq %rax, %rdi
movq %rsi, 0x8(%rsp)
callq 0x3570
movq %rax, %rdi
leaq 0x121bd(%rip), %rsi     # 0x27bcb
callq 0x3350
imulq $0x18, %r15, %r15
xorl %edi, %edi
movq (%rbx), %rax
movq (%rax,%r15), %rcx
movq 0x8(%rax,%r15), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cltq
cmpq %rax, %rdi
jge 0x15aa1
movq %rdi, 0x10(%rsp)
imulq $0x18, %rdi, %rbp
xorl %r12d, %r12d
movq (%rcx,%rbp), %rax
movq 0x8(%rcx,%rbp), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r12
jge 0x15a85
movsd (%rax,%r12,8), %xmm0
callq 0x35c0
movq %r14, %rdi
callq 0x34d0
movq %rax, %rdi
movq %r13, %rsi
callq 0x3350
incq %r12
movq (%rbx), %rax
movq (%rax,%r15), %rcx
jmp 0x15a43
movq %r14, %rdi
leaq 0x11e2c(%rip), %rsi     # 0x278bb
callq 0x3350
movq 0x10(%rsp), %rdi
incq %rdi
jmp 0x15a19
movq %r14, %rdi
leaq 0x11e10(%rip), %rsi     # 0x278bb
callq 0x3350
movq 0x8(%rsp), %r15
jmp 0x159ca
movq 0x1e4f7(%rip), %rdi     # 0x33fb8
leaq 0x11df3(%rip), %rsi     # 0x278bb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/misc.cpp
// Function: checkInteger(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::basic_ofstream<char, std::char_traits<char>>&)
void checkInteger(string param_string, int &param_final, string param_name, bool writeErrorToFile, ofstream &logFileStream) {
    double param_double;
    istringstream(param_string) >> param_double;
    if (my_round(double(param_double))==param_double) {
        param_final = int(param_double);
    } else {
        cerrAndLog("\nError: '"+param_name+"' parameter must be an integer\n", writeErrorToFile, logFileStream);
        exit(1);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rsi
leaq 0x30(%rsp), %r12
pushq $0x8
popq %rdx
movq %r12, %rdi
callq 0x3520
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x3220
leaq 0x30(%rsp), %rdi
callq 0x3180
movsd 0x8(%rsp), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
movsd %xmm1, (%rsp)
jbe 0x15e00
movsd 0x11cfb(%rip), %xmm0    # 0x27af0
addsd %xmm1, %xmm0
callq 0x3070
jmp 0x15e11
movsd 0x11440(%rip), %xmm0    # 0x27248
addsd %xmm1, %xmm0
callq 0x3530
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x15e3d
jp 0x15e3d
cvttsd2si %xmm1, %eax
movl %eax, (%r15)
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11de0(%rip), %rsi     # 0x27c24
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0xcf4d
leaq 0x11e36(%rip), %rdx     # 0x27c91
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0xcf2e
movzbl %bpl, %esi
leaq 0x10(%rsp), %rdi
movq %rbx, %rdx
callq 0x176c7
leaq 0x10(%rsp), %rdi
callq 0x3170
leaq 0x30(%rsp), %rdi
callq 0x3170
pushq $0x1
popq %rdi
callq 0x33e0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3170
jmp 0x15ea7
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3170
jmp 0x15ec0
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3180
movq %rbx, %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/misc.cpp
// Function: increment_restrictedGrowth(std::vector<int, std::allocator<int>>&, int)
void increment_restrictedGrowth(vector<int> &group, int maxVal) {
    
    // special escape condition if maxVal==1
    if (maxVal==1) {
        group[0] = 0;
        return;
    }
    
    // starting at the far right end, keep incrementing individual elements until restricted growth function condition is met.
    int target = int(group.size());
    group[target-1] ++;
    int targetMax = *max_element(begin(group),begin(group)+target-1);
    while ((group[target-1]>(targetMax+1)) || group[target-1]>maxVal) {
        group[target-1] = 1;
        target --;
        group[target-1] ++;
        targetMax = *max_element(begin(group),begin(group)+target-1);
    }
    if (target==1) {
        group[0] = 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, %esi
jne 0x16123
movq (%rbx), %rdi
jmp 0x161aa
movl %esi, %ebp
movq (%rbx), %rdi
movq 0x8(%rbx), %r14
subq %rdi, %r14
movq %r14, %rax
shlq $0x1e, %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
addq %rax, %rcx
sarq $0x1e, %rcx
incl (%rdi,%rcx)
sarq $0x1e, %rax
leaq (%rdi,%rax), %rsi
addq $-0x4, %rsi
callq 0xe459
shrq $0x2, %r14
movslq %r14d, %r14
leaq -0x8(,%r14,4), %r15
decq %r14
movl (%rax), %eax
movq (%rbx), %rdi
movl (%rdi,%r14,4), %ecx
incl %eax
cmpl %eax, %ecx
setle %al
cmpl %ebp, %ecx
setle %cl
testb %cl, %al
jne 0x161a5
movl $0x1, (%rdi,%r14,4)
incl -0x4(%rdi,%r14,4)
leaq (%rdi,%r15), %rsi
callq 0xe459
decq %r14
addq $-0x4, %r15
jmp 0x1616d
testq %r14, %r14
jne 0x161ad
andl $0x0, (%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/misc.cpp
// Function: process_nan[abi:cxx11](double)
string process_nan(double x) {
    string s = to_string((long double)x);
    if (my_isnan(x))
        s = "NA";
    return(s);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x18(%rsp)
movq %rdi, %rbx
movsd %xmm0, 0x20(%rsp)
fldl 0x20(%rsp)
fstpt (%rsp)
callq 0x16889
movsd 0x18(%rsp), %xmm0
ucomisd %xmm0, %xmm0
jp 0x161f1
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x137fb(%rip), %rsi     # 0x299f3
movq %rbx, %rdi
callq 0x3600
jmp 0x161e6
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/misc.cpp
// Function: approx_lgamma(double)
double approx_lgamma(double x) {

	if (x <= 0.0)
	{
		std::stringstream os;
        os << "Invalid input argument " << x <<  ". Argument must be positive.";
        throw std::invalid_argument( os.str() );
	}
    
    if (x < 12.0)
    {
        return log(fabs(approx_gamma(x)));
    }
    
	// Abramowitz and Stegun 6.1.41
    // Asymptotic series should be good to at least 11 or 12 figures
    // For error analysis, see Whittiker and Watson
    // A Course in Modern Analysis (1927), page 252
    
    static const double c[8] =
    {
        1.0/12.0,
		-1.0/360.0,
		1.0/1260.0,
		-1.0/1680.0,
		1.0/1188.0,
		-691.0/360360.0,
		1.0/156.0,
		-3617.0/122400.0
    };
    double z = 1.0/(x*x);
    double sum = c[7];
    for (int i=6; i >= 0; i--)
    {
        sum *= z;
        sum += c[i];
    }
    double series = sum/x;
    
    static const double halfLogTwoPi = 0.91893853320467274178032973640562;
    double loggamma = (x - 0.5)*log(x) - x + halfLogTwoPi + series;
	return loggamma;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x167c8
movsd 0x11437(%rip), %xmm1    # 0x27b58
ucomisd %xmm0, %xmm1
jbe 0x16744
callq 0x164f4
andpd 0x113cc(%rip), %xmm0    # 0x27b00
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %rbp
jmp 0x32d0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd 0x10abc(%rip), %xmm2    # 0x27210
divsd %xmm1, %xmm2
pushq $0x6
popq %rax
movsd 0x1141d(%rip), %xmm1    # 0x27b80
leaq 0x11686(%rip), %rcx     # 0x27df0
testl %eax, %eax
js 0x1677d
mulsd %xmm2, %xmm1
movl %eax, %edx
addsd (%rcx,%rdx,8), %xmm1
decl %eax
jmp 0x1676a
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x11361(%rip), %xmm1    # 0x27af0
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
callq 0x32d0
mulsd 0x8(%rsp), %xmm0
subsd (%rsp), %xmm0
addsd 0x113d2(%rip), %xmm0    # 0x27b88
addsd 0x10(%rsp), %xmm0
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %rbp
retq
movsd %xmm0, (%rsp)
leaq 0x38(%rsp), %rdi
callq 0x3250
leaq 0x48(%rsp), %rdi
leaq 0x11528(%rip), %rsi     # 0x27d0b
callq 0x3350
movq %rax, %rdi
movsd (%rsp), %xmm0
callq 0x34d0
leaq 0x11527(%rip), %rsi     # 0x27d23
movq %rax, %rdi
callq 0x3350
pushq $0x10
popq %rdi
callq 0x3190
movq %rax, %rbx
leaq 0x50(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x34b0
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x3580
xorl %ebp, %ebp
movq 0x1d799(%rip), %rsi     # 0x33fd0
movq 0x1d782(%rip), %rdx     # 0x33fc0
movq %rbx, %rdi
callq 0x3560
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x3170
testb %bpl, %bpl
jne 0x1685d
jmp 0x1686a
movq %rax, %r14
movq %rbx, %rdi
callq 0x3270
jmp 0x1686a
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x3290
movq %r14, %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/probability.cpp
// Function: rgamma1(double, double)
double rgamma1(double shape, double rate) {
    gamma_distribution<double> rgamma(shape,1/rate);
	double x = rgamma(generator);

	// check for zero or infinite values (catches bug present in Visual Studio 2010)
	if (x==0)
		x = pow(10.0,-300.0);
	while ((1.0/x)==0)
		x = rgamma(generator);

    return(x);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movsd 0x10162(%rip), %xmm2    # 0x27210
divsd %xmm1, %xmm2
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movapd %xmm2, %xmm1
callq 0x17222
leaq 0x1e63e(%rip), %r14     # 0x35708
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1724e
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
movapd %xmm1, %xmm2
cmpeqsd %xmm0, %xmm2
movsd 0x10d42(%rip), %xmm0    # 0x27e30
andpd %xmm2, %xmm0
andnpd %xmm1, %xmm2
orpd %xmm2, %xmm0
movsd 0x1010e(%rip), %xmm1    # 0x27210
divsd %xmm0, %xmm1
ucomisd 0xff6a(%rip), %xmm1     # 0x27078
jne 0x1711f
jp 0x1711f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1724e
jmp 0x170fa
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/probability.cpp
// Function: sample1(std::vector<double, std::allocator<double>>&, double)
int sample1(vector<double> &p, double pSum) {
    double rand = pSum*uniform_0_1(generator);
    double z = 0;
    for (int i=0; i<int(p.size()); i++) {
        z += p[i];
        if (rand<z)
            return i+1;
    }
    return(0);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x1e5d4(%rip), %rdi     # 0x35710
leaq 0x1e5c5(%rip), %rsi     # 0x35708
callq 0x1721a
mulsd 0x8(%rsp), %xmm0
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
shrq $0x3, %rdx
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
xorpd %xmm1, %xmm1
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x17182
addsd (%rcx,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x1717e
incq %rsi
jmp 0x17169
incl %esi
movl %esi, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/readIn.cpp
// Function: coutAndLog(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::basic_ofstream<char, std::char_traits<char>>&)
void coutAndLog(string message, bool writeToFile, ofstream &fileStream) {
    cout << message;
    if (writeToFile) {
        fileStream << message;
        fileStream.flush();
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x1c919(%rip), %rdi     # 0x33fb8
movq %r14, %rsi
callq 0x3310
testl %ebp, %ebp
je 0x176c2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3310
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3230
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/readIn.cpp
// Function: cerrAndLog(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::basic_ofstream<char, std::char_traits<char>>&)
void cerrAndLog(string message, bool writeToFile, ofstream &logFileStream) {
    cerr << message;
    if (writeToFile) {
        logFileStream << message;
        logFileStream.flush();
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x1c916(%rip), %rdi     # 0x33ff0
movq %r14, %rsi
callq 0x3310
testl %ebp, %ebp
je 0x176fd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3310
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3230
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/readIn.cpp
// Function: safe_ifstream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::basic_ofstream<char, std::char_traits<char>>&)
ifstream safe_ifstream(string fileName, bool writeToFile, ofstream &logFileStream) {
    ifstream fileStream(fileName);
    if (!fileStream.is_open()) {
        cerrAndLog("\nError: failed to read from file: "+fileName+string("\n"), writeToFile, logFileStream);
        exit(1);
    }
    return(fileStream);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x8
popq %rdx
callq 0x34e0
leaq 0x78(%rbx), %rdi
callq 0x30b0
testb %al, %al
je 0x1773a
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10737(%rip), %rsi     # 0x27e78
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0xcf4d
leaq 0x10166(%rip), %rsi     # 0x278bb
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3130
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x601b
movzbl %bpl, %esi
leaq 0x48(%rsp), %rdi
movq %r14, %rdx
callq 0x176c7
leaq 0x48(%rsp), %rdi
callq 0x3170
leaq 0x8(%rsp), %rdi
callq 0x3170
leaq 0x28(%rsp), %rdi
callq 0x3170
pushq $0x1
popq %rdi
callq 0x33e0
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x3170
jmp 0x177c1
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3170
jmp 0x177d0
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3170
jmp 0x177df
movq %rax, %r14
movq %rbx, %rdi
callq 0x30e0
movq %r14, %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/readIn.cpp
// Function: stringToDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::basic_ofstream<char, std::char_traits<char>>&)
double stringToDouble(string s, bool writeToFile, ofstream &logFileStream) {
    double output;
    istringstream ss(s);
    ss >> output;
    if (!output) {
        cerrAndLog("\nError: cannot convert data element '"+s+string("' to type double\n"), writeToFile, logFileStream);
        exit(1);
    }
    return(output);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x78(%rsp), %r15
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3520
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x3220
movsd 0x10(%rsp), %xmm1
xorpd %xmm0, %xmm0
movsd %xmm1, 0x8(%rsp)
ucomisd %xmm0, %xmm1
jne 0x1783c
jnp 0x1785a
leaq 0x78(%rsp), %rdi
callq 0x3180
movsd 0x8(%rsp), %xmm0
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1063a(%rip), %rsi     # 0x27e9b
leaq 0x38(%rsp), %rdi
movq %r14, %rdx
callq 0xcf4d
leaq 0x1064c(%rip), %rsi     # 0x27ec1
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3130
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x601b
movzbl %bpl, %esi
leaq 0x58(%rsp), %rdi
movq %rbx, %rdx
callq 0x176c7
leaq 0x58(%rsp), %rdi
callq 0x3170
leaq 0x18(%rsp), %rdi
callq 0x3170
leaq 0x38(%rsp), %rdi
callq 0x3170
pushq $0x1
popq %rdi
callq 0x33e0
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x3170
jmp 0x178e1
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x3170
jmp 0x178f0
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x3170
jmp 0x17901
jmp 0x178fe
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x3180
movq %rbx, %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/readIn.cpp
// Function: doubleToInt(double, bool, std::basic_ofstream<char, std::char_traits<char>>&)
int doubleToInt(double x, bool writeToFile, ofstream &logFileStream) {
    double intpart;
    if (modf(x, &intpart)!=0.0) {
        cerrAndLog("\nError: cannot convert data element "+to_string((long long)x)+string(" to type integer\n"), writeToFile, logFileStream);
        exit(1);
    }
    return(int(intpart));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x18(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
callq 0x35b0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x17951
jp 0x17951
cvttsd2si 0x18(%rsp), %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cvttsd2si 0x10(%rsp), %rsi
leaq 0x80(%rsp), %r14
movq %r14, %rdi
callq 0x60a6
leaq 0x10564(%rip), %rsi     # 0x27ed3
leaq 0x40(%rsp), %rdi
movq %r14, %rdx
callq 0x6082
leaq 0x10575(%rip), %rsi     # 0x27ef8
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3130
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x601b
movzbl %bpl, %esi
leaq 0x60(%rsp), %rdi
movq %rbx, %rdx
callq 0x176c7
leaq 0x60(%rsp), %rdi
callq 0x3170
leaq 0x20(%rsp), %rdi
callq 0x3170
leaq 0x40(%rsp), %rdi
callq 0x3170
leaq 0x80(%rsp), %rdi
callq 0x3170
pushq $0x1
popq %rdi
callq 0x33e0
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x3170
jmp 0x179fc
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3170
jmp 0x17a0b
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x3170
jmp 0x17a1a
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/readIn.cpp
// Function: safe_getline(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
istream& safe_getline(istream& is, string& t) {
	t.clear();
	istream::sentry se(is, true);
	streambuf* sb = is.rdbuf();
	for (;;) {
		int c = sb->sbumpc();
		switch(c) {
            case '\n':
                return is;
            case '\r':
                if (sb->sgetc()=='\n')
                    sb->sbumpc();
                return is;
            case EOF:
                if (t.empty())
                    is.setstate(ios::eofbit);
                return is;
            default:
                t += (char)c;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
andq $0x0, 0x8(%rsi)
movq %rdi, %rbx
movq (%rsi), %rax
movb $0x0, (%rax)
leaq 0xf(%rsp), %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0x34a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rbx,%rax), %r15
movq %r15, %rdi
callq 0x31e0
cmpl $-0x1, %eax
je 0x17a8c
cmpl $0xa, %eax
je 0x17abc
cmpl $0xd, %eax
je 0x17aa7
movsbl %al, %esi
movq %r14, %rdi
callq 0x32f0
jmp 0x17a68
cmpq $0x0, 0x8(%r14)
jne 0x17abc
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
pushq $0x2
popq %rsi
callq 0x3210
jmp 0x17abc
movq %r15, %rdi
callq 0x3470
cmpl $0xa, %eax
jne 0x17abc
movq %r15, %rdi
callq 0x31e0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq