LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: bobverity[P]MavericK/Hungarian.cpp
// Function: augmentRight(int, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
vector<int> augmentRight(int j, vector< vector<double> > &M, vector<int> &edgesRight, vector<int> &blockedLeft, vector<int> &blockedRight) {
    
    blockedRight[j] = 1;
    vector<int> output(1);
    
    // if node j is unmatched then return j as start of augmented path
    if (edgesRight[j]<0) {
        output[0] = j;
        return(output);
    }
    
    // otherwise continue chain of augmenting
    output = augmentLeft(edgesRight[j], M, edgesRight, blockedLeft, blockedRight);
    if (output[0]>=0) {
        output.push_back(j);
    }
    return(output);
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movslq 0x7c(%rsp), %rsi
callq 0x8ba0
movl $0x1, (%rax)
movb $0x0, 0x57(%rsp)
leaq 0x56(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xc5e0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl $0x1, %esi
callq 0xc7b0
jmp 0xb413
leaq 0x56(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rdi
movslq 0x7c(%rsp), %rsi
callq 0x8ba0
cmpl $0x0, (%rax)
jge 0xb47c
movq 0x18(%rsp), %rdi
movl 0x7c(%rsp), %eax
movl %eax, 0xc(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x8ba0
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movb $0x1, 0x57(%rsp)
movl $0x1, 0x40(%rsp)
jmp 0xb513
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x56(%rsp), %rdi
callq 0xc670
jmp 0xb531
movq 0x68(%rsp), %rdi
movslq 0x7c(%rsp), %rsi
callq 0x8ba0
movl (%rax), %esi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
movq 0x60(%rsp), %r8
movq 0x58(%rsp), %r9
leaq 0x28(%rsp), %rdi
callq 0xb170
jmp 0xb4ad
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xc6a0
leaq 0x28(%rsp), %rdi
callq 0xc6e0
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8ba0
cmpl $0x0, (%rax)
jl 0xb506
movq 0x18(%rsp), %rdi
leaq 0x7c(%rsp), %rsi
callq 0xc740
jmp 0xb4ea
jmp 0xb506
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0xc6e0
jmp 0xb531
movb $0x1, 0x57(%rsp)
movl $0x1, 0x40(%rsp)
testb $0x1, 0x57(%rsp)
jne 0xb524
movq 0x18(%rsp), %rdi
callq 0xc6e0
movq 0x10(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x4730
nopl (%rax,%rax)
// File: bobverity[P]MavericK/MCMCobject_admixture.cpp
// Function: MCMCobject_admixture::updateQmatrix(int)
void MCMCobject_admixture::updateQmatrix(int rep) {
    
    // add logQmatrix_gene_new to logQmatrix_gene_running
    for (int i=0; i<geneCopies; i++) {
        for (int k=0; k<K; k++) {
            logQmatrix_gene_running[i][k] = logSum(logQmatrix_gene_running[i][k], logQmatrix_gene_new[i][k]);
        }
    }
    
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x28(%rsp)
movq 0x18(%rsp), %rcx
movl 0x28(%rsp), %eax
cmpl 0x70(%rcx), %eax
jge 0x156cf
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x156bd
movq 0x18(%rsp), %rdi
addq $0x2c8, %rdi            # imm = 0x2C8
movslq 0x28(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x24(%rsp), %rsi
callq 0x8c20
movq 0x18(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0x298, %rdi            # imm = 0x298
movslq 0x28(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x24(%rsp), %rsi
callq 0x8c20
movsd 0x8(%rsp), %xmm0
movsd (%rax), %xmm1
callq 0x339b0
movq 0x18(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
addq $0x2c8, %rdi            # imm = 0x2C8
movslq 0x28(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x24(%rsp), %rsi
callq 0x8c20
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x15609
jmp 0x156bf
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x155ef
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: bobverity[P]MavericK/MCMCobject_admixture.cpp
// Function: MCMCobject_admixture::storeQmatrix()
void MCMCobject_admixture::storeQmatrix() {
    
    // store individual-level Qmatrix
    groupIndex=-1;
    for (int ind=0; ind<n; ind++) {
        for (int l=0; l<loci; l++) {
            for (int p=0; p<ploidy_vec[ind]; p++) {
                groupIndex++;
                for (int k=0; k<K; k++) {
                    logQmatrix_gene[groupIndex][k] = logSum(logQmatrix_gene[groupIndex][k], logQmatrix_gene_new[groupIndex][k]);
                }
            }
        }
    }
    
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0xffffffff, 0x108(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0x2c(%rsp)
movq 0x18(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x20(%rcx), %eax
jge 0x15879
movl $0x0, 0x28(%rsp)
movq 0x18(%rsp), %rcx
movl 0x28(%rsp), %eax
cmpl 0x24(%rcx), %eax
jge 0x15867
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
addq $0x40, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x8ba0
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl (%rcx), %eax
jge 0x15855
movq 0x18(%rsp), %rax
movl 0x108(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x108(%rax)
movl $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movl 0x20(%rsp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x15843
movq 0x18(%rsp), %rax
movq %rax, %rdi
addq $0x2e0, %rdi            # imm = 0x2E0
movslq 0x108(%rax), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x20(%rsp), %rsi
callq 0x8c20
movq %rax, %rcx
movq 0x18(%rsp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, (%rsp)
movq %rax, %rdi
addq $0x298, %rdi            # imm = 0x298
movslq 0x108(%rax), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x20(%rsp), %rsi
callq 0x8c20
movsd (%rsp), %xmm0
movsd (%rax), %xmm1
callq 0x339b0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x8(%rsp)
movq %rax, %rdi
addq $0x2e0, %rdi            # imm = 0x2E0
movslq 0x108(%rax), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x20(%rsp), %rsi
callq 0x8c20
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x1577f
jmp 0x15845
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x15739
jmp 0x15857
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x1571f
jmp 0x15869
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x15705
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1e8(%rax)
movl $0x0, 0x4c(%rsp)
movq 0x38(%rsp), %rcx
movl 0x4c(%rsp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x15a74
movl $0x0, 0x48(%rsp)
movq 0x38(%rsp), %rcx
movl 0x48(%rsp), %eax
cmpl 0x24(%rcx), %eax
jge 0x15a62
movl $0x0, 0x44(%rsp)
movq 0x38(%rsp), %rdi
movl 0x44(%rsp), %eax
movl %eax, 0x34(%rsp)
addq $0x28, %rdi
movslq 0x48(%rsp), %rsi
callq 0x8ba0
movq %rax, %rcx
movl 0x34(%rsp), %eax
cmpl (%rcx), %eax
jge 0x15999
movq 0x38(%rsp), %rdi
movsd 0x78(%rdi), %xmm0
movsd %xmm0, 0x20(%rsp)
addq $0x110, %rdi            # imm = 0x110
movslq 0x4c(%rsp), %rsi
callq 0x8c40
movq %rax, %rdi
movslq 0x48(%rsp), %rsi
callq 0x8c60
movq %rax, %rdi
movslq 0x44(%rsp), %rsi
callq 0x8ba0
movsd 0x20(%rsp), %xmm0
cvtsi2sdl (%rax), %xmm1
addsd %xmm1, %xmm0
callq 0x4340
movq 0x38(%rsp), %rax
movsd %xmm0, 0x28(%rsp)
movsd 0x78(%rax), %xmm0
callq 0x4340
movq 0x38(%rsp), %rax
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
subsd %xmm1, %xmm0
addsd 0x1e8(%rax), %xmm0
movsd %xmm0, 0x1e8(%rax)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x158da
movq 0x38(%rsp), %rdi
addq $0x28, %rdi
movslq 0x48(%rsp), %rsi
callq 0x8ba0
movq %rax, %rcx
movq 0x38(%rsp), %rax
cvtsi2sdl (%rcx), %xmm0
mulsd 0x78(%rax), %xmm0
callq 0x4340
movq 0x38(%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
addq $0x28, %rdi
movslq 0x48(%rsp), %rsi
callq 0x8ba0
movq 0x38(%rsp), %rdi
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x78(%rdi), %xmm0
movsd %xmm0, 0x10(%rsp)
addq $0x128, %rdi            # imm = 0x128
movslq 0x4c(%rsp), %rsi
callq 0x8c60
movq %rax, %rdi
movslq 0x48(%rsp), %rsi
callq 0x8ba0
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm2
cvtsi2sdl (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x4340
movq 0x38(%rsp), %rax
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
subsd %xmm1, %xmm0
addsd 0x1e8(%rax), %xmm0
movsd %xmm0, 0x1e8(%rax)
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x158c0
jmp 0x15a64
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x158a6
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x218(%rax)
movl $0x0, 0x34(%rsp)
movq 0x20(%rsp), %rcx
movl 0x34(%rsp), %eax
cmpl 0x20(%rcx), %eax
jge 0x15fed
movl $0x0, 0x30(%rsp)
movq 0x20(%rsp), %rcx
movl 0x30(%rsp), %eax
cmpl 0x24(%rcx), %eax
jge 0x15fdb
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x1c(%rsp)
addq $0x40, %rdi
movslq 0x34(%rsp), %rsi
callq 0x8ba0
movq %rax, %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jge 0x15fc9
movq 0x20(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0x8c40
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x8c60
movq %rax, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x8ba0
cmpl $0x0, (%rax)
je 0x15fb7
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
movl $0x0, 0x28(%rsp)
movq 0x20(%rsp), %rcx
movl 0x28(%rsp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x15f97
movq 0x20(%rsp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
movslq 0x34(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x28(%rsp), %rsi
callq 0x8c20
movq 0x20(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
addq $0x140, %rdi            # imm = 0x140
movslq 0x28(%rsp), %rsi
callq 0x8ae0
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x8bc0
movq 0x20(%rsp), %rdi
movq %rax, 0x8(%rsp)
movslq 0x34(%rsp), %rsi
callq 0x8c40
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x8c60
movq %rax, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x8ba0
movq 0x8(%rsp), %rdi
movl (%rax), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x8c20
movsd 0x10(%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x38(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x15ec7
movsd 0x38(%rsp), %xmm0
callq 0x4390
movq 0x20(%rsp), %rax
addsd 0x218(%rax), %xmm0
movsd %xmm0, 0x218(%rax)
jmp 0x15fb9
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x15e5a
jmp 0x15fcb
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x15e40
jmp 0x15fdd
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x15e26
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x18(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x20(%rcx), %eax
jge 0x1fe71
xorps %xmm0, %xmm0
callq 0x4390
movq 0x18(%rsp), %rax
movsd %xmm0, 0x188(%rax)
movl $0x0, 0x28(%rsp)
movq 0x18(%rsp), %rcx
movl 0x28(%rsp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x1fde7
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
callq 0x20d00
movq 0x18(%rsp), %rdi
movsd 0x188(%rdi), %xmm0
movsd %xmm0, 0x10(%rsp)
addq $0x170, %rdi            # imm = 0x170
movslq 0x28(%rsp), %rsi
callq 0x8c20
movsd 0x10(%rsp), %xmm0
movsd (%rax), %xmm1
callq 0x339b0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x188(%rax)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x1fd7a
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x1fe5f
movq 0x18(%rsp), %rdi
addq $0x170, %rdi            # imm = 0x170
movslq 0x24(%rsp), %rsi
callq 0x8c20
movq 0x18(%rsp), %rdi
movsd (%rax), %xmm0
subsd 0x188(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0x1d0, %rdi            # imm = 0x1D0
movslq 0x2c(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x24(%rsp), %rsi
callq 0x8c20
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1fdef
jmp 0x1fe61
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1fd4b
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x20(%rcx), %eax
jge 0x206f9
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x206e7
movq 0x10(%rsp), %rdi
addq $0x200, %rdi            # imm = 0x200
movslq 0x1c(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x18(%rsp), %rsi
callq 0x8c20
movq 0x10(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
addq $0x1d0, %rdi            # imm = 0x1D0
movslq 0x1c(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x18(%rsp), %rsi
callq 0x8c20
movsd (%rsp), %xmm0
movsd (%rax), %xmm1
callq 0x339b0
movq 0x10(%rsp), %rdi
movsd %xmm0, 0x8(%rsp)
addq $0x200, %rdi            # imm = 0x200
movslq 0x1c(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x18(%rsp), %rsi
callq 0x8c20
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x20635
jmp 0x206e9
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2061b
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x20(%rsp), %rcx
movl 0x34(%rsp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x20b0b
movl $0x0, 0x30(%rsp)
movq 0x20(%rsp), %rcx
movl 0x30(%rsp), %eax
cmpl 0x24(%rcx), %eax
jge 0x20af9
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x1c(%rsp)
addq $0x28, %rdi
movslq 0x30(%rsp), %rsi
callq 0x8ba0
movq %rax, %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jge 0x20a60
movq 0x20(%rsp), %rdi
addq $0xa8, %rdi
movslq 0x34(%rsp), %rsi
callq 0x8c40
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x8c60
movq %rax, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x8ba0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cvtsi2sdl (%rcx), %xmm0
addsd 0x70(%rax), %xmm0
movsd 0x3b835(%rip), %xmm1    # 0x5c200
callq 0x39190
movq 0x20(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
addq $0xd8, %rdi
movslq 0x34(%rsp), %rsi
callq 0x8ae0
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x8c20
movsd 0x10(%rsp), %xmm0
movq 0x20(%rsp), %rdi
movsd %xmm0, (%rax)
addq $0xd8, %rdi
movslq 0x34(%rsp), %rsi
callq 0x8ae0
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x8c20
movsd (%rax), %xmm0
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x20958
movl $0x0, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x28, %rdi
movslq 0x30(%rsp), %rsi
callq 0x8ba0
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jge 0x20ae7
movq 0x20(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
movsd %xmm0, (%rsp)
addq $0xd8, %rdi
movslq 0x34(%rsp), %rsi
callq 0x8ae0
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x28(%rsp), %rsi
callq 0x8c20
movsd (%rsp), %xmm1
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x20a68
jmp 0x20ae9
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x20935
jmp 0x20afb
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x2091b
addq $0x48, %rsp
retq
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x150(%rax)
movsd 0x3b6ca(%rip), %xmm0    # 0x5c200
movsd %xmm0, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x20(%rsp), %rcx
movl 0x34(%rsp), %eax
cmpl 0x20(%rcx), %eax
jge 0x20cdb
movl $0x0, 0x30(%rsp)
movq 0x20(%rsp), %rcx
movl 0x30(%rsp), %eax
cmpl 0x24(%rcx), %eax
jge 0x20cc9
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x1c(%rsp)
addq $0x40, %rdi
movslq 0x34(%rsp), %rsi
callq 0x8ba0
movq %rax, %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jge 0x20cb7
movq 0x20(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0x8c40
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x8c60
movq %rax, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x8ba0
cmpl $0x0, (%rax)
je 0x20c67
movq 0x20(%rsp), %rdi
movq %rdi, %rax
addq $0xd8, %rax
movq %rax, 0x8(%rsp)
addq $0x90, %rdi
movslq 0x34(%rsp), %rsi
callq 0x8ba0
movq 0x8(%rsp), %rdi
movl (%rax), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x8ae0
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x8bc0
movq 0x20(%rsp), %rdi
movq %rax, 0x10(%rsp)
movslq 0x34(%rsp), %rsi
callq 0x8c40
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x8c60
movq %rax, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x8ba0
movq 0x10(%rsp), %rdi
movl (%rax), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x8c20
movsd (%rax), %xmm0
mulsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x3b5b1(%rip), %xmm0    # 0x5c220
ucomisd 0x38(%rsp), %xmm0
jbe 0x20ca5
movsd 0x38(%rsp), %xmm0
callq 0x4390
movq 0x20(%rsp), %rax
addsd 0x150(%rax), %xmm0
movsd %xmm0, 0x150(%rax)
movsd 0x3b561(%rip), %xmm0    # 0x5c200
movsd %xmm0, 0x38(%rsp)
jmp 0x20ca7
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x20b78
jmp 0x20cb9
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x20b5e
jmp 0x20ccb
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x20b44
movsd 0x38(%rsp), %xmm0
callq 0x4390
movq 0x20(%rsp), %rax
addsd 0x150(%rax), %xmm0
movsd %xmm0, 0x150(%rax)
addq $0x48, %rsp
retq
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq 0x50(%rsp), %rax
testb $0x1, 0x2bd1(%rax)
je 0x24170
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x50(%rsp), %rdi
addq $0x2bd8, %rdi           # imm = 0x2BD8
movslq 0x4c(%rsp), %rsi
callq 0x8c20
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %esi
movsd (%rax), %xmm0
callq 0x24240
movsd %xmm0, 0x28(%rsp)
movq 0x50(%rsp), %rdi
addq $0x2e00, %rdi           # imm = 0x2E00
movslq 0x4c(%rsp), %rsi
callq 0x8c20
movsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x24237
xorps %xmm0, %xmm0
callq 0x4390
movsd %xmm0, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
cmpl $0x64, 0x3c(%rsp)
jge 0x241eb
movl 0x3c(%rsp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movsd 0x38068(%rip), %xmm1    # 0x5c208
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
movsd 0x30(%rsp), %xmm0
callq 0x24240
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
callq 0x339b0
movsd %xmm0, 0x40(%rsp)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x24186
movsd 0x3805d(%rip), %xmm0    # 0x5c250
callq 0x4390
movaps %xmm0, %xmm1
movsd 0x40(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x50(%rsp), %rdi
addq $0x2e00, %rdi           # imm = 0x2E00
movslq 0x4c(%rsp), %rsi
callq 0x8c20
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
addq $0x58, %rsp
retq
nopl (%rax)
// File: bobverity[P]MavericK/./misc.h
// Function: double var<double>(std::vector<double, std::allocator<double>>&, double, bool)
double var(std::vector<TYPE> &x, double mu=0, bool sampleMean=true) {
    int n = int(x.size());
    if (n==1)
        return(0);
    double xSum=0, xSumSquare=0;
    for (int i=0; i<n; i++) {
        xSum += x[i];
        xSumSquare += x[i]*x[i];
    }
    double output = sampleMean ? (xSumSquare-xSum*xSum/n)/(n-1) : (xSumSquare-2*mu*xSum+n*mu*mu)/n;
    output = (output<0) ? 0 : output;
    return(output);
}

// Assembly:
subq $0x58, %rsp
movb %sil, %al
movq %rdi, 0x48(%rsp)
movsd %xmm0, 0x40(%rsp)
andb $0x1, %al
movb %al, 0x3f(%rsp)
movq 0x48(%rsp), %rdi
callq 0x9b80
movl %eax, 0x38(%rsp)
cmpl $0x1, 0x38(%rsp)
jne 0x3341b
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x33595
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x38(%rsp), %eax
jge 0x334b1
movq 0x48(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x8c20
movsd (%rax), %xmm0
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x8c20
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x8c20
movsd 0x10(%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x28(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x33435
testb $0x1, 0x3f(%rsp)
je 0x334ef
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
mulsd 0x30(%rsp), %xmm1
cvtsi2sdl 0x38(%rsp), %xmm2
divsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movl 0x38(%rsp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x33552
movsd 0x28(%rsp), %xmm0
movsd 0x28b0b(%rip), %xmm1    # 0x5c008
mulsd 0x40(%rsp), %xmm1
movsd 0x30(%rsp), %xmm2
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvtsi2sdl 0x38(%rsp), %xmm0
mulsd 0x40(%rsp), %xmm0
movsd 0x40(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsi2sdl 0x38(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x18(%rsp), %xmm0
jbe 0x33573
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
jmp 0x3357e
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x58, %rsp
retq
// File: 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:
subq $0x38, %rsp
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
movsd 0x2887c(%rip), %xmm1    # 0x5c250
ucomisd %xmm1, %xmm0
jbe 0x339eb
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x33aca
movsd 0x20(%rsp), %xmm0
subsd 0x28(%rsp), %xmm0
movsd 0x28851(%rip), %xmm1    # 0x5c250
ucomisd %xmm1, %xmm0
jbe 0x33a16
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x33aca
jmp 0x33a18
movsd 0x28(%rsp), %xmm1
movsd 0x20(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x33a70
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
callq 0x4760
movaps %xmm0, %xmm1
movsd 0x287ae(%rip), %xmm0    # 0x5c200
addsd %xmm1, %xmm0
callq 0x4390
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x33ab2
movsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x20(%rsp), %xmm0
subsd 0x28(%rsp), %xmm0
callq 0x4760
movaps %xmm0, %xmm1
movsd 0x28769(%rip), %xmm0    # 0x5c200
addsd %xmm1, %xmm0
callq 0x4390
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0xc880
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
callq 0xc8b0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xc830
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xc8e0
movsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x9b80
movq %rax, %rcx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jge 0x33ba3
movq 0x40(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x8c20
movsd (%rax), %xmm0
subsd 0x30(%rsp), %xmm0
callq 0x4760
movaps %xmm0, %xmm1
movsd 0x2867a(%rip), %xmm0    # 0x5c200
divsd %xmm1, %xmm0
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x33b40
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x40(%rsp), %rdi
callq 0x9b80
movsd (%rsp), %xmm0
movq %rax, %xmm1
movaps 0x28f0b(%rip), %xmm2    # 0x5cae0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x28f0f(%rip), %xmm2    # 0x5caf0
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x4390
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x38(%rsp), %xmm0
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rsi, 0x38(%rsp)
movq %rdi, %rax
movq 0x38(%rsp), %rdi
movq %rax, 0x48(%rsp)
movq %rax, %rcx
movq %rcx, 0x40(%rsp)
movq %rax, 0xb0(%rsp)
movq %rdi, 0xa8(%rsp)
movb $0x0, 0xa7(%rsp)
callq 0x9b80
movq %rax, 0x50(%rsp)
leaq 0xa6(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x8780
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x8790
jmp 0x33c8b
leaq 0xa6(%rsp), %rdi
callq 0x8910
movq 0x38(%rsp), %rdi
callq 0xc880
movq %rax, 0x30(%rsp)
jmp 0x33ca9
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x78(%rsp)
callq 0xc8b0
movq %rax, 0x28(%rsp)
jmp 0x33cc4
movq 0x28(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x21080
movq %rax, 0x20(%rsp)
jmp 0x33ce4
movq 0x20(%rsp), %rax
movq %rax, 0x80(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xc8e0
movsd (%rax), %xmm0
movsd %xmm0, 0x88(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x68(%rsp)
movl $0x0, 0x64(%rsp)
movq 0x38(%rsp), %rdi
movl 0x64(%rsp), %eax
movl %eax, 0x1c(%rsp)
callq 0x9b80
movq %rax, %rcx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jge 0x33df5
movq 0x38(%rsp), %rdi
movslq 0x64(%rsp), %rsi
callq 0x8c20
movsd (%rax), %xmm0
subsd 0x88(%rsp), %xmm0
callq 0x4760
movq 0x48(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
movslq 0x64(%rsp), %rsi
callq 0x8c20
movsd 0x10(%rsp), %xmm0
movq 0x48(%rsp), %rdi
movsd %xmm0, (%rax)
movslq 0x64(%rsp), %rsi
callq 0x8c20
movsd (%rax), %xmm0
addsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x68(%rsp)
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x33d1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xa6(%rsp), %rdi
callq 0x8910
jmp 0x33e7b
movq 0x48(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0x88b0
jmp 0x33e7b
movl $0x0, 0x60(%rsp)
movq 0x38(%rsp), %rdi
movl 0x60(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x9b80
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x33e52
movq 0x48(%rsp), %rdi
movsd 0x68(%rsp), %xmm0
movsd %xmm0, (%rsp)
movslq 0x60(%rsp), %rsi
callq 0x8c20
movsd (%rsp), %xmm1
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x33dfd
movb $0x1, 0xa7(%rsp)
testb $0x1, 0xa7(%rsp)
jne 0x33e6e
movq 0x48(%rsp), %rdi
callq 0x88b0
movq 0x40(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x98(%rsp), %rdi
callq 0x4730
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
callq 0x18010
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x35042
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, (%rsp)
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x8c60
movq %rax, %rdi
callq 0xb030
movq %rax, %rcx
movl (%rsp), %eax
cmpl %ecx, %eax
jge 0x3501f
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x8c60
movq %rax, %rdi
movslq 0x8(%rsp), %rsi
callq 0x8ba0
cvtsi2sdl (%rax), %xmm0
callq 0x4760
movq 0x37fba(%rip), %rdi     # 0x6cfb8
callq 0x4790
movq %rax, %rdi
leaq 0x299ee(%rip), %rsi     # 0x5e9fb
callq 0x4430
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x34faa
movq 0x37f92(%rip), %rdi     # 0x6cfb8
leaq 0x27865(%rip), %rsi     # 0x5c892
callq 0x4430
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x34f81
movq 0x37f6f(%rip), %rdi     # 0x6cfb8
leaq 0x27842(%rip), %rsi     # 0x5c892
callq 0x4430
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x35132
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, (%rsp)
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
callq 0x9b80
movq %rax, %rcx
movl (%rsp), %eax
cmpl %ecx, %eax
jge 0x3510f
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x8(%rsp), %rsi
callq 0x8c20
movsd (%rax), %xmm0
callq 0x4760
movq 0x37eca(%rip), %rdi     # 0x6cfb8
callq 0x4790
movq %rax, %rdi
leaq 0x298fe(%rip), %rsi     # 0x5e9fb
callq 0x4430
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3509a
movq 0x37ea2(%rip), %rdi     # 0x6cfb8
leaq 0x27775(%rip), %rsi     # 0x5c892
callq 0x4430
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x35071
movq 0x37e7f(%rip), %rdi     # 0x6cfb8
leaq 0x27752(%rip), %rsi     # 0x5c892
callq 0x4430
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x178d0
movq %rax, %rcx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jge 0x352cb
movq 0x37e2f(%rip), %rdi     # 0x6cfb8
leaq 0x279c8(%rip), %rsi     # 0x5cb58
callq 0x4430
movq %rax, %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
callq 0x4700
movq %rax, %rdi
leaq 0x279b5(%rip), %rsi     # 0x5cb63
callq 0x4430
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x8c40
movq %rax, %rdi
callq 0x18010
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x352a8
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x8c40
movq %rax, %rdi
movslq 0x18(%rsp), %rsi
callq 0x8c60
movq %rax, %rdi
callq 0xb030
movq %rax, %rcx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jge 0x35285
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x8c40
movq %rax, %rdi
movslq 0x18(%rsp), %rsi
callq 0x8c60
movq %rax, %rdi
movslq 0x14(%rsp), %rsi
callq 0x8ba0
cvtsi2sdl (%rax), %xmm0
callq 0x4760
movq 0x37d57(%rip), %rdi     # 0x6cfb8
callq 0x4790
movq %rax, %rdi
leaq 0x2978b(%rip), %rsi     # 0x5e9fb
callq 0x4430
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x351f1
movq 0x37d2c(%rip), %rdi     # 0x6cfb8
leaq 0x275ff(%rip), %rsi     # 0x5c892
callq 0x4430
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x351bb
movq 0x37d09(%rip), %rdi     # 0x6cfb8
leaq 0x275dc(%rip), %rsi     # 0x5c892
callq 0x4430
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x35161
movq 0x37ce6(%rip), %rdi     # 0x6cfb8
leaq 0x275b9(%rip), %rsi     # 0x5c892
callq 0x4430
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x36f60
movq %rax, %rcx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jge 0x3546b
movq 0x37c8f(%rip), %rdi     # 0x6cfb8
leaq 0x27828(%rip), %rsi     # 0x5cb58
callq 0x4430
movq %rax, %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
callq 0x4700
movq %rax, %rdi
leaq 0x27815(%rip), %rsi     # 0x5cb63
callq 0x4430
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x8ae0
movq %rax, %rdi
callq 0xc680
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x35448
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x8ae0
movq %rax, %rdi
movslq 0x18(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
callq 0x9b80
movq %rax, %rcx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jge 0x35425
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x8ae0
movq %rax, %rdi
movslq 0x18(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x14(%rsp), %rsi
callq 0x8c20
movsd (%rax), %xmm0
callq 0x4760
movq 0x37bb7(%rip), %rdi     # 0x6cfb8
callq 0x4790
movq %rax, %rdi
leaq 0x295eb(%rip), %rsi     # 0x5e9fb
callq 0x4430
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x35391
movq 0x37b8c(%rip), %rdi     # 0x6cfb8
leaq 0x2745f(%rip), %rsi     # 0x5c892
callq 0x4430
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x3535b
movq 0x37b69(%rip), %rdi     # 0x6cfb8
leaq 0x2743c(%rip), %rsi     # 0x5c892
callq 0x4430
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x35301
movq 0x37b46(%rip), %rdi     # 0x6cfb8
leaq 0x27419(%rip), %rsi     # 0x5c892
callq 0x4430
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x218, %rsp            # imm = 0x218
movl %ecx, %eax
movq %rdx, 0x8(%rsp)
movq %rsi, %rcx
movq %rdi, %rsi
movq %rsi, 0x210(%rsp)
movq %rcx, 0x208(%rsp)
movq %rdx, 0x200(%rsp)
andb $0x1, %al
movb %al, 0x1ff(%rsp)
movq %r8, 0x1f0(%rsp)
leaq 0x68(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x8, %edx
callq 0x46a0
movq 0x10(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
callq 0x36fb0
jmp 0x35825
leaq 0x68(%rsp), %rdi
callq 0x41c0
movsd 0x1e8(%rsp), %xmm0
callq 0x33950
cvtsi2sd %eax, %xmm0
ucomisd 0x1e8(%rsp), %xmm0
jne 0x35883
jp 0x35883
cvttsd2si 0x1e8(%rsp), %ecx
movq 0x208(%rsp), %rax
movl %ecx, (%rax)
jmp 0x35925
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x41c0
jmp 0x3592d
movq 0x8(%rsp), %rdx
leaq 0x2732d(%rip), %rsi     # 0x5cbbc
leaq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x22950
movq (%rsp), %rsi
leaq 0x27381(%rip), %rdx     # 0x5cc29
leaq 0x38(%rsp), %rdi
callq 0x22900
jmp 0x358b4
movq 0x1f0(%rsp), %rdx
movzbl 0x1ff(%rsp), %esi
andl $0x1, %esi
leaq 0x38(%rsp), %rdi
callq 0x3a1b0
jmp 0x358d3
leaq 0x38(%rsp), %rdi
callq 0x4270
leaq 0x18(%rsp), %rdi
callq 0x4270
movl $0x1, %edi
callq 0x44f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x35919
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4270
leaq 0x18(%rsp), %rdi
callq 0x4270
jmp 0x3592d
addq $0x218, %rsp            # imm = 0x218
retq
movq 0x60(%rsp), %rdi
callq 0x4730
nopw (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
cmpl $0x1, 0x6c(%rsp)
jne 0x35d0d
movq 0x70(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8ba0
movl $0x0, (%rax)
jmp 0x35ebf
movq 0x70(%rsp), %rdi
callq 0xb030
movl %eax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movl 0x68(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x8ba0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x70(%rsp), %rdi
callq 0x258c0
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rdi
callq 0x258c0
movq %rax, 0x38(%rsp)
movslq 0x68(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x18f70
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x36fe0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x25870
movq %rax, 0x58(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x25920
movl (%rax), %eax
movl %eax, 0x64(%rsp)
movq 0x70(%rsp), %rdi
movl 0x68(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x8ba0
movl (%rax), %ecx
movl 0x64(%rsp), %edx
addl $0x1, %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, 0xf(%rsp)
jg 0x35de8
movq 0x70(%rsp), %rdi
movl 0x68(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x8ba0
movl (%rax), %eax
cmpl 0x6c(%rsp), %eax
setg %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x35df5
jmp 0x35ea4
movq 0x70(%rsp), %rdi
movl 0x68(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x8ba0
movl $0x1, (%rax)
movl 0x68(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movl 0x68(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x8ba0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x70(%rsp), %rdi
callq 0x258c0
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
callq 0x258c0
movq %rax, 0x10(%rsp)
movslq 0x68(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x18f70
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x36fe0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x25870
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x25920
movl (%rax), %eax
movl %eax, 0x64(%rsp)
jmp 0x35da0
cmpl $0x1, 0x68(%rsp)
jne 0x35ebf
movq 0x70(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8ba0
movl $0x0, (%rax)
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movb $0x0, 0x37(%rsp)
fldl 0x38(%rsp)
movq %rsp, %rax
fstpt (%rax)
callq 0x37030
movsd 0x38(%rsp), %xmm0
callq 0x37080
movb %al, 0x23(%rsp)
jmp 0x35f10
movb 0x23(%rsp), %al
testb $0x1, %al
jne 0x35f1a
jmp 0x35f49
movq 0x10(%rsp), %rdi
leaq 0x28a85(%rip), %rsi     # 0x5e9ab
callq 0x4570
jmp 0x35f2d
jmp 0x35f49
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x4270
jmp 0x35f69
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x35f5f
movq 0x10(%rsp), %rdi
callq 0x4270
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x4730
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movsd %xmm0, 0x50(%rsp)
movsd %xmm1, 0x48(%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0x23052(%rip), %xmm1    # 0x5c200
divsd 0x48(%rsp), %xmm1
leaq 0x8(%rsp), %rdi
callq 0x394b0
leaq 0x8(%rsp), %rdi
leaq 0x35616(%rip), %rsi     # 0x6e7e0
callq 0x39500
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x391fe
jp 0x391fe
movsd 0x2301c(%rip), %xmm0    # 0x5c208
movsd 0x23be4(%rip), %xmm1    # 0x5cdd8
callq 0x4720
movsd %xmm0, (%rsp)
jmp 0x39200
movsd 0x22ff8(%rip), %xmm0    # 0x5c200
divsd (%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x39230
jp 0x39230
leaq 0x8(%rsp), %rdi
leaq 0x355bc(%rip), %rsi     # 0x6e7e0
callq 0x39500
movsd %xmm0, (%rsp)
jmp 0x39200
movsd (%rsp), %xmm0
addq $0x58, %rsp
retq
nopw (%rax,%rax)