LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_utils.cpp
// Function: readMultiFastaToOneString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
std::string readMultiFastaToOneString(const string& fileName, int bytes) {
    std::string fastaSeqs; fastaSeqs.reserve(bytes); fastaSeqs = "";
    string line;
    std::ifstream* fastaFile = new std::ifstream(fileName.c_str());
    getline(*fastaFile, line);
    string currentScaffold = line.substr(1,string::npos);
    while (getline(*fastaFile, line)) {
        if (line[0] != '>') {
            fastaSeqs.append(line);
        } else {
            continue;
        }
    }
    return fastaSeqs;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movslq %edx, %rsi
callq 0x86f0
movq 0x8(%rbx), %rdx
leaq 0x7df8a(%rip), %rcx     # 0xd1c7f
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x86c0
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movl $0x208, %edi            # imm = 0x208
callq 0x8470
movq %rax, %r14
movq (%r15), %rsi
movq %rax, %rdi
movl $0x8, %edx
callq 0x8860
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x8450
movsbl %al, %edx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x8870
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl $0x1, %edx
movq $-0x1, %rcx
callq 0x84a0
movq %rsp, %r15
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x8450
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x8870
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x53dbb
movq (%rsp), %rsi
cmpb $0x3e, (%rsi)
je 0x53d73
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8180
jmp 0x53d73
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53dd6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8480
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x53dec
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8480
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x53e11
movq %rax, %r15
movl $0x208, %esi            # imm = 0x208
movq %r14, %rdi
jmp 0x53e2f
movq %rax, %r15
jmp 0x53e4a
movq %rax, %r15
jmp 0x53e34
movq %rax, %r15
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53e34
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8480
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x53e4a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8480
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x53e5e
movq (%r12), %rsi
incq %rsi
callq 0x8480
movq %r15, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_utils.cpp
// Function: GeneralSetCounts::probabilitiesFromLikelihoods(std::vector<double, std::allocator<double>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<double> GeneralSetCounts::probabilitiesFromLikelihoods(const std::vector<double>& thisLikelihoods, const string& species) {
    std::vector<double> thisProbabilities; thisProbabilities.assign(3, 0.0);
    double multiple0 = thisLikelihoods[0]*setHWEpriorsFromAAFfromGT[species][0];
    double multiple1 = thisLikelihoods[1]*setHWEpriorsFromAAFfromGT[species][1];
    double multiple2 = thisLikelihoods[2]*setHWEpriorsFromAAFfromGT[species][2];
    double sum = multiple0 + multiple1 + multiple2;
    
    thisProbabilities[0] = multiple0/sum;
    thisProbabilities[1] = multiple1/sum;
    thisProbabilities[2] = multiple2/sum;
    
    return thisProbabilities;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
movl $0x3, %esi
callq 0x560ee
movq (%r12), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
addq $0x1e0, %r15            # imm = 0x1E0
movq %r15, %rdi
movq %r14, %rsi
callq 0x55096
movq (%rax), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq (%r12), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x55096
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%r12), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x55096
movsd 0x28(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
movq (%rax), %rax
movsd 0x10(%rsp), %xmm3
mulsd 0x10(%rax), %xmm3
movsd 0x20(%rsp), %xmm2
mulsd 0x8(%rsp), %xmm2
movapd %xmm1, %xmm0
addsd %xmm2, %xmm0
addsd %xmm3, %xmm0
divsd %xmm0, %xmm1
movq (%rbx), %rax
movsd %xmm1, (%rax)
divsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rax)
divsd %xmm0, %xmm3
movsd %xmm3, 0x10(%rax)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x5404e
jmp 0x5404e
jmp 0x5404e
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x54065
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x8480
movq %r14, %rdi
callq 0x8840
nop
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_utils.cpp
// Function: GeneralSetCounts::returnFormatTagPosition(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int GeneralSetCounts::returnFormatTagPosition(std::vector<std::string>& format, const std::string& tag) {
    // Find the position of GQ (genotype quality) in the genotypeData vector below
    std::vector<std::string>::iterator TAGit; int TAGi = std::numeric_limits<int>::min();
    TAGit = find (format.begin(), format.end(), tag);
    if (TAGit == format.end()) {
        // std::cerr << "This variant hasn't got associated per-sample GQ info" << std::endl;
    } else {
        TAGi = (int)std::distance( format.begin(), TAGit );
        //hasGQ = true;
    }
    return TAGi;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0x575e4
movq %rax, %rcx
subq (%rbx), %rcx
shrq $0x5, %rcx
cmpq 0x8(%rbx), %rax
movl $0x80000000, %eax       # imm = 0x80000000
cmovnel %ecx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_utils.cpp
// Function: finalize_diffs_Hets_vs_Homs_proportions(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
void finalize_diffs_Hets_vs_Homs_proportions(std::vector<std::vector<double> >& diffs_Hets_vs_Homs){
    for (std::vector<std::vector<int> >::size_type i = 0; i < diffs_Hets_vs_Homs.size(); i++) {
        for (int j = 0; j < i; j++) {
            diffs_Hets_vs_Homs[i][j] = (diffs_Hets_vs_Homs[i][j]/diffs_Hets_vs_Homs[j][i]);
            diffs_Hets_vs_Homs[j][i] = 0;
        }    
    }
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
subq %rax, %rdx
je 0x54a85
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
testq %rdx, %rdx
je 0x54a7d
leaq (%rdx,%rdx,2), %rsi
movq (%rax,%rsi,8), %rsi
movq %rax, %rdi
xorl %r8d, %r8d
movsd (%rsi,%r8,8), %xmm0
movq (%rdi), %r9
divsd (%r9,%rdx,8), %xmm0
movsd %xmm0, (%rsi,%r8,8)
movq $0x0, (%r9,%rdx,8)
incq %r8
addq $0x18, %rdi
cmpq %r8, %rdx
jne 0x54a54
incq %rdx
cmpq %rcx, %rdx
jne 0x54a41
retq
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_IUPAC.cpp
// Function: reverseComplementIUPAC(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string reverseComplementIUPAC(const std::string& seq)
{
    std::string out(seq.length(), 'A');
    int last_pos = (int)seq.length() - 1;
    for(int i = last_pos; i >= 0; --i)
    {
        out[last_pos - i] = complementIUPAC(seq[i]);
    }
    return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movl $0x41, %edx
callq 0x8500
movq 0x8(%r14), %rax
testl %eax, %eax
jle 0x5789c
movl %eax, %r15d
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
decl %eax
movslq %eax, %r12
subq %r15, %r12
incq %r15
incq %r12
movq (%r14), %rax
movsbl -0x2(%rax,%r15), %edi
callq 0x578ab
movq (%rbx), %rcx
movb %al, (%rcx,%r12)
decq %r15
incq %r12
cmpq $0x1, %r15
jg 0x5787b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_IUPAC.cpp
// Function: complementIUPAC(char)
char complementIUPAC(char c)
{
    char cmp = '\0';
    bool is_lc = std::islower(c);
    
    switch(std::toupper(c)) {
        case 'A': cmp = 'T'; break;
        case 'C': cmp = 'G'; break;
        case 'G': cmp = 'C'; break;
        case 'T': cmp = 'A'; break;
        case 'M': cmp = 'K'; break;
        case 'R': cmp = 'Y'; break;
        case 'W': cmp = 'W'; break;
        case 'S': cmp = 'S'; break;
        case 'Y': cmp = 'R'; break;
        case 'K': cmp = 'M'; break;
        case 'V': cmp = 'B'; break;
        case 'H': cmp = 'D'; break;
        case 'D': cmp = 'H'; break;
        case 'B': cmp = 'V'; break;
        case 'N': cmp = 'N'; break;
        default:
            assert(false);
    }
    
    if(is_lc)
        cmp = std::tolower(cmp);
    return cmp;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
callq 0x8580
movl %eax, %ebx
movl %ebp, %edi
callq 0x8880
addl $-0x41, %eax
cmpl $0x19, %eax
jae 0x578ef
movl $0x16e34cf, %ecx        # imm = 0x16E34CF
btl %eax, %ecx
jae 0x578ef
movl %eax, %eax
leaq 0x804a0(%rip), %rcx     # 0xd7d79
movb (%rax,%rcx), %al
testl %ebx, %ebx
je 0x578e8
movzbl %al, %edi
callq 0x8640
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x7e657(%rip), %rdi     # 0xd5f4d
leaq 0x80449(%rip), %rsi     # 0xd7d46
leaq 0x80458(%rip), %rcx     # 0xd7d5c
movl $0x32, %edx
callq 0x82c0
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_stats_functions.cpp
// Function: het_analysis(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, FilterResult&)
void het_analysis(std::vector<int>& hetCounts, std::vector<int>& sharedHetCounts, FilterResult& result) {
    for (std::vector<int>::size_type i = 0; i < hetCounts.size(); i++) {
        if (result.counts.individualsWithVariant[i] == 1) {
            hetCounts[i]++;
            if (result.counts.overall > 1) {
                sharedHetCounts[i]++;
            }
        }
    }
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x5ec67
sarq $0x2, %rcx
movq 0x78(%rdx), %rdi
movq (%rsi), %rsi
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %r8d, %r8d
cmpl $0x1, (%rdi,%r8,4)
jne 0x5ec5f
incl (%rax,%r8,4)
cmpl $0x2, 0x8(%rdx)
jl 0x5ec5f
incl (%rsi,%r8,4)
incq %r8
cmpq %r8, %rcx
jne 0x5ec4a
retq
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_stats_functions.cpp
// Function: initialisePopulationMap(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>&)
std::vector<string> initialisePopulationMap(const std::vector<std::string> populations, std::map<std::string,int>& fp_map) {
    std::vector<std::string> pop_unique = populations;
    std::sort(pop_unique.begin(), pop_unique.end());
    std::vector<std::string>::iterator it = std::unique(pop_unique.begin(), pop_unique.end());
    pop_unique.resize(std::distance(pop_unique.begin(), it));
    std::vector<std::string>::size_type n_pop = pop_unique.size();
    // Initialize fields to populations map
    for (int i = 0; i < n_pop; i++) {
        fp_map[pop_unique[i]] = i;
    }
    std::cerr << "Initialised the population map; there are " << n_pop << " populations" << std::endl;
    return pop_unique;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
callq 0x3273a
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x5ecb7
movq %r12, %rax
subq %r15, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5fd29
movq %r15, %rdi
movq %r12, %rsi
callq 0x5fe0d
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x605a3
subq (%rbx), %rax
sarq $0x5, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x415c4
movq 0x8(%rbx), %rax
movq (%rbx), %rcx
movq %rax, %r15
subq %rcx, %r15
sarq $0x5, %r15
cmpq %rcx, %rax
je 0x5ed17
cmpq $0x1, %r15
movq %r15, %r12
adcq $0x0, %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%rbx), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x3f0a2
movl %ebp, (%rax)
incq %rbp
addq $0x20, %r13
cmpq %rbp, %r12
jne 0x5ecfb
movq 0xac2ca(%rip), %rdi     # 0x10afe8
leaq 0x7a3fb(%rip), %rsi     # 0xd9120
movl $0x2a, %edx
callq 0x84e0
movq 0xac2b2(%rip), %rdi     # 0x10afe8
movq %r15, %rsi
callq 0x82f0
movq %rax, %r14
leaq 0x7a403(%rip), %rsi     # 0xd914b
movl $0xc, %edx
movq %rax, %rdi
callq 0x84e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x8450
movsbl %al, %esi
movq %r14, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8300
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5ed94
jmp 0x5ed94
jmp 0x5ed94
movq %rax, %r14
movq %rbx, %rdi
callq 0x3123c
movq %r14, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_stats_functions.cpp
// Function: diffs_between_H1(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, FilterResult&)
void diffs_between_H1(std::vector<std::vector<double> >& H1diffs, FilterResult& result) {
    for (std::vector<std::vector<int> >::size_type i = 0; i < H1diffs.size(); i++) {
        for (int j = 0; j < i; j++) {
            const int ind_i = result.counts.haplotypesWithVariant[2*i];
            const int ind_j = result.counts.haplotypesWithVariant[2*j];
            
            if ((ind_i == 1 && ind_j == 0) || (ind_i == 0 && ind_j == 1)) {
                H1diffs[i][j]++;
            } else if ((ind_i == 0 && ind_j == 0) || (ind_i == 1 && ind_j == 1)) { // one is hom for reference allele the other is hom for alternative allele
                
            } else {
                std::cerr << "result.counts.haplotypesWithVariant[" << 2*i << "]=" << result.counts.haplotypesWithVariant[2*i] << std::endl;
                std::cerr << "result.counts.haplotypesWithVariant[" << 2*j << "]=" << result.counts.haplotypesWithVariant[2*j] << std::endl;
                exit(EXIT_FAILURE);
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
subq %rax, %rdx
je 0x5fb21
movq %rsi, %rbx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
movq 0xc0(%rsi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
movsd 0x6f997(%rip), %xmm0    # 0xcf440
testq %rsi, %rsi
je 0x5fb19
leaq (%rsi,%rsi), %r15
movl (%rdx,%rsi,8), %edi
leaq (%rsi,%rsi,2), %r8
leaq (%rax,%r8,8), %r8
movl %edi, %r9d
xorl $0x1, %r9d
movq %rsi, %r10
xorl %r14d, %r14d
movl (%rdx,%r14,4), %r11d
cmpl $0x1, %edi
jne 0x5fad8
testl %r11d, %r11d
je 0x5fae2
testl %edi, %edi
jne 0x5fb00
cmpl $0x1, %r11d
jne 0x5fb00
movq (%r8), %r11
movsd (%r11,%r14,4), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%r11,%r14,4)
addq $0x2, %r14
decq %r10
jne 0x5faca
jmp 0x5fb19
movl %r11d, %ebp
xorl $0x1, %ebp
orl %r9d, %ebp
sete %bpl
orl %edi, %r11d
je 0x5faf5
testb %bpl, %bpl
jne 0x5faf5
jmp 0x5fb30
incq %rsi
cmpq %rcx, %rsi
jne 0x5faa9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xab4b1(%rip), %r12     # 0x10afe8
leaq 0x79701(%rip), %r13     # 0xd923f
movq %r12, %rdi
movq %r13, %rsi
callq 0x8460
movq %rax, %rdi
movq %r15, %rsi
callq 0x8120
leaq 0x79709(%rip), %rbp     # 0xd9264
movq %rax, %rdi
movq %rbp, %rsi
callq 0x8460
movq 0xc0(%rbx), %rcx
movl (%rcx,%r15,4), %esi
movq %rax, %rdi
callq 0x8810
movq %rax, %rdi
callq 0x8200
movq %r12, %rdi
movq %r13, %rsi
callq 0x8460
movq %rax, %rdi
movl %r14d, %esi
callq 0x8810
movq %rax, %rdi
movq %rbp, %rsi
callq 0x8460
movq 0xc0(%rbx), %rcx
movl (%rcx,%r14,4), %esi
movq %rax, %rdi
callq 0x8810
movq %rax, %rdi
callq 0x8200
movl $0x1, %edi
callq 0x8530
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_stats_functions.cpp
// Function: diffs_between_AllH(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, FilterResult&)
void diffs_between_AllH(std::vector<std::vector<double> >& AllHdiffs, FilterResult& result) {
    for (std::vector<std::vector<int> >::size_type i = 0; i < AllHdiffs.size(); i++) {
        for (int j = 0; j < i; j++) {
            const int ind_i = result.counts.haplotypesWithVariant[i];
            const int ind_j = result.counts.haplotypesWithVariant[j];
            
            if ((ind_i == 1 && ind_j == 0) || (ind_i == 0 && ind_j == 1)) {
                AllHdiffs[i][j]++;
            } else if ((ind_i == 0 && ind_j == 0) || (ind_i == 1 && ind_j == 1)) { // one is hom for reference allele the other is hom for alternative allele
                
            } else {
                std::cerr << "result.counts.haplotypesWithVariant[" << i << "]=" << result.counts.haplotypesWithVariant[i] << std::endl;
                std::cerr << "result.counts.haplotypesWithVariant[" << j << "]=" << result.counts.haplotypesWithVariant[j] << std::endl;
                exit(EXIT_FAILURE);
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
subq %rax, %rdx
je 0x5fc83
movq %rsi, %rbx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
movq 0xc0(%rsi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %r15d, %r15d
movsd 0x6f82f(%rip), %xmm0    # 0xcf440
testq %r15, %r15
je 0x5fc7b
movl (%rdx,%r15,4), %esi
leaq (%r15,%r15,2), %rdi
leaq (%rax,%rdi,8), %rdi
movl %esi, %r8d
xorl $0x1, %r8d
xorl %r14d, %r14d
movl (%rdx,%r14,4), %r9d
cmpl $0x1, %esi
jne 0x5fc3a
testl %r9d, %r9d
je 0x5fc44
testl %esi, %esi
jne 0x5fc61
cmpl $0x1, %r9d
jne 0x5fc61
movq (%rdi), %r9
movsd (%r9,%r14,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%r9,%r14,8)
incq %r14
cmpq %r14, %r15
jne 0x5fc2c
jmp 0x5fc7b
movl %r9d, %r10d
xorl $0x1, %r10d
orl %r8d, %r10d
sete %r10b
orl %esi, %r9d
je 0x5fc57
testb %r10b, %r10b
jne 0x5fc57
jmp 0x5fc92
incq %r15
cmpq %rcx, %r15
jne 0x5fc11
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xab34f(%rip), %r12     # 0x10afe8
leaq 0x7959f(%rip), %r13     # 0xd923f
movq %r12, %rdi
movq %r13, %rsi
callq 0x8460
movq %rax, %rdi
movq %r15, %rsi
callq 0x8120
leaq 0x795a7(%rip), %rbp     # 0xd9264
movq %rax, %rdi
movq %rbp, %rsi
callq 0x8460
movq 0xc0(%rbx), %rcx
movl (%rcx,%r15,4), %esi
movq %rax, %rdi
callq 0x8810
movq %rax, %rdi
callq 0x8200
movq %r12, %rdi
movq %r13, %rsi
callq 0x8460
movq %rax, %rdi
movl %r14d, %esi
callq 0x8810
movq %rax, %rdi
movq %rbp, %rsi
callq 0x8460
movq 0xc0(%rbx), %rcx
movl (%rcx,%r14,4), %esi
movq %rax, %rdi
callq 0x8810
movq %rax, %rdi
callq 0x8200
movl $0x1, %edi
callq 0x8530
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/./process_vcf_utils.h
// Function: MassokoMalawiResult::~MassokoMalawiResult()
void init(std::vector<int>::size_type size) {
        absentWithBlue.assign(size, 0);
        hetsWithBlue.assign(size, 0);
        homsWithBlue.assign(size, 0);
        absentWithYellow.assign(size, 0);
        hetsWithYellow.assign(size, 0);
        homsWithYellow.assign(size, 0);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0x63d4e
movq 0x88(%rbx), %rsi
subq %rdi, %rsi
callq 0x8480
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x63d63
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x8480
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x63d78
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x8480
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x63d8d
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x8480
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x63da2
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x8480
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x63db7
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x8480
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_massoko.cpp
// Function: initializeCountsBlue(std::map<int, std::vector<int, std::allocator<int>>, std::less<int>, std::allocator<std::pair<int const, std::vector<int, std::allocator<int>>>>>&, int)
void initializeCountsBlue(std::map<int, std::vector<int> >& countsBlue, int numChr) {
    for (int i = opt::min_copies; i <= numChr - opt::min_copies; i++) {
        std::vector<int> v(i+1);
        for (int j = 0; j <= i; j++) { v[j] = 0; }
        countsBlue[i] = v;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl 0xa5aa8(%rip), %eax     # 0x10b558
movl %eax, (%rsp)
movl %esi, %ecx
subl %eax, %ecx
cmpl %ecx, %eax
jg 0x65b49
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r12
movq %rsp, %r13
incl %eax
movslq %eax, %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x6726a
cmpl $0x0, (%rsp)
js 0x65b07
movq $-0x1, %rax
movq 0x8(%rsp), %rcx
movl $0x0, 0x4(%rcx,%rax,4)
movslq (%rsp), %rdx
incq %rax
cmpq %rdx, %rax
jl 0x65af3
movq %r14, %rdi
movq %r13, %rsi
callq 0x672f4
movq %rax, %rdi
movq %r15, %rsi
callq 0x33980
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x65b34
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x8480
movl (%rsp), %ecx
leal 0x1(%rcx), %eax
movl %eax, (%rsp)
movl %ebx, %edx
subl 0xa5a13(%rip), %edx     # 0x10b558
cmpl %edx, %ecx
jl 0x65ad1
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x65b71
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x8480
movq %rbx, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_massoko.cpp
// Function: getNumHets(MassokoFilterResult&)
int getNumHets(MassokoFilterResult& result) {
    int num_hets = 0;
    for (std::vector<std::vector<int> >::size_type i = 0; i < result.counts.individualsWithVariant.size(); i++) {
        if (result.counts.individualsWithVariant[i] == 1)
            num_hets++;
    }
    return num_hets;
}

// Assembly:
movq 0x78(%rdi), %rcx
movq 0x80(%rdi), %rdx
subq %rcx, %rdx
je 0x65bae
sarq $0x2, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
xorl %eax, %eax
xorl %edi, %edi
cmpl $0x1, (%rcx,%rsi,4)
sete %dil
addl %edi, %eax
incq %rsi
cmpq %rsi, %rdx
jne 0x65b99
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/./process_vcf_annotation_tools.h
// Function: AccessibleGenome::getAccessibleSeqForScaffold(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string getAccessibleSeqForScaffold(const string& scaffold, const string& fullString) {
        std::vector<std::vector<int> > aGThisSc = BedFeatureMap[scaffold];
        
        string accessibleString; accessibleString.reserve(fullString.length()); accessibleString = "";
        for (std::vector<int>::size_type i = 0; i < aGThisSc[0].size(); i++) {
            accessibleString.append(fullString.substr(aGThisSc[0][i],aGThisSc[1][i]- aGThisSc[0][i]));
        }
        return accessibleString;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x8(%rsi), %rdi
movq %rdx, %rsi
callq 0x4aeb0
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x4ba8c
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x86f0
movq 0x8(%rbx), %rdx
leaq 0x637b4(%rip), %rcx     # 0xd1c7f
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x86c0
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x6e54c
leaq 0x10(%rsp), %r13
xorl %ebp, %ebp
movq %rsp, %r15
movq (%rax), %rcx
movq 0x18(%rax), %rax
movslq (%rcx,%rbp,4), %rdx
movslq (%rax,%rbp,4), %rcx
subq %rdx, %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x84a0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8180
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x6e534
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8480
incq %rbp
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x2, %rcx
cmpq %rcx, %rbp
jb 0x6e4f0
leaq 0x20(%rsp), %rdi
callq 0x4b0a4
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e56a
movq %rax, %r14
jmp 0x6e588
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x6e588
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8480
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x6e59c
movq (%r12), %rsi
incq %rsi
callq 0x8480
leaq 0x20(%rsp), %rdi
callq 0x4b0a4
movq %r14, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/./process_vcf_utils.h
// Function: convertToDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline double convertToDouble(std::string const& s)
{
    std::istringstream i(s);
    double x;
    if (!(i >> x))
        throw BadConversion("convertToDouble(\"" + s + "\")");
    return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, %r14
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x87b0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x82d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x7615c
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x94e67(%rip), %rsi     # 0x10af98
leaq 0x58(%rsp), %rdi
callq 0x8620
leaq 0xd0(%rsp), %rdi
callq 0x8190
movsd 0x8(%rsp), %xmm0
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x8210
movq %rax, %rbx
leaq 0x672f1(%rip), %rsi     # 0xdd461
leaq 0x38(%rsp), %rdi
movq %r14, %rdx
callq 0x77abc
leaq 0x672ef(%rip), %rsi     # 0xdd473
leaq 0x38(%rsp), %rdi
callq 0x88c0
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x761af
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x761bc
movq %rdx, 0x18(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x28(%rsp)
movq 0x8(%rax), %rdx
leaq 0x18(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x8550
leaq 0x938be(%rip), %rax     # 0x109aa8
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x9388a(%rip), %rsi     # 0x109a80
movq 0x94db3(%rip), %rdx     # 0x10afb0
movq %rbx, %rdi
callq 0x8800
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x76227
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x8480
jmp 0x76227
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7624a
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x8480
jmp 0x7624a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x7625c
movq %rbx, %rdi
callq 0x8360
jmp 0x7625c
movq %rax, %r14
movq 0x94d35(%rip), %rsi     # 0x10af98
leaq 0x58(%rsp), %rdi
callq 0x8620
leaq 0xd0(%rsp), %rdi
callq 0x8190
movq %r14, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/./process_vcf_annotation_tools.h
// Function: Annotation::getTranscriptCount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int getTranscriptCount(const std::string& geneOrTranscript) {
        int numTranscripts = 0;
        int numDots = (int)std::count(geneOrTranscript.begin(), geneOrTranscript.end(), '.');
        if (numDots < 4)
            numTranscripts = geneTranscriptCounts[geneOrTranscript];
        else if (numDots == 4) {
            //std::vector<std::string> transcriptVec = split(geneOrTranscript,'.');
            //std::string geneName = transcriptVec[0] + "." + transcriptVec[1] + "." + transcriptVec[2] + "." + transcriptVec[3];
            std::string geneName = geneFromTranscript(geneOrTranscript);
            numTranscripts = geneTranscriptCounts[geneName];
        } else {
            std::cerr << "NumDots: " << numDots << std::endl;
            std::cerr << "geneOrTranscript: " << geneOrTranscript << std::endl;
            assert(false);
        }
        return numTranscripts;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x762b9
movq (%rbx), %rcx
xorl %edx, %edx
xorl %r15d, %r15d
xorl %esi, %esi
cmpb $0x2e, (%rcx,%rdx)
sete %sil
addq %rsi, %r15
incq %rdx
cmpq %rdx, %rax
jne 0x762a2
jmp 0x762bc
xorl %r15d, %r15d
cmpl $0x3, %r15d
jg 0x762d5
addq $0x30, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3f0a2
movl (%rax), %ebx
jmp 0x76315
cmpl $0x4, %r15d
jne 0x76321
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3ed36
addq $0x30, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3f0a2
movl (%rax), %ebx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x76315
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8480
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x94cc0(%rip), %r14     # 0x10afe8
leaq 0x67147(%rip), %rsi     # 0xdd476
movq %r14, %rdi
callq 0x8460
movq %rax, %rdi
movl %r15d, %esi
callq 0x8810
movq %rax, %rdi
callq 0x8200
leaq 0x6712f(%rip), %rsi     # 0xdd480
movq %r14, %rdi
callq 0x8460
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8400
movq %rax, %rdi
callq 0x8200
leaq 0x5fbda(%rip), %rdi     # 0xd5f4d
leaq 0x5fc93(%rip), %rsi     # 0xd600d
leaq 0x67112(%rip), %rcx     # 0xdd493
movl $0xe8, %edx
callq 0x82c0
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x763a9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8480
movq %rbx, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/./process_vcf_seq_utils.h
// Function: forwardGenomeToScaffold(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::basic_ifstream<char, std::char_traits<char>>*&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline void forwardGenomeToScaffold(const std::string& thisInVCF, std::ifstream*& genomeFile, std::string& nextInGenome) {
    while (thisInVCF != nextInGenome) {
        std::cerr << "Starting to read " << nextInGenome << std::endl;
        std::cerr << "No variants in " << nextInGenome << std::endl;
        std::string currentScaffoldReference = readScaffold(genomeFile, nextInGenome);
        std::cerr << "Finished reading" << std::endl;
        nextInGenome.erase(0,1);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x94c19(%rip), %r12     # 0x10afe8
leaq 0x64f7a(%rip), %rbp     # 0xdb350
movq 0x8(%r15), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x763fc
testq %rdx, %rdx
je 0x76512
movq (%rbx), %rsi
movq (%r15), %rdi
callq 0x8490
testl %eax, %eax
je 0x76512
movl $0x11, %edx
movq %r12, %rdi
leaq 0x64f0f(%rip), %rsi     # 0xdb31a
callq 0x84e0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r12, %rdi
callq 0x84e0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x8450
movsbl %al, %esi
movq %r13, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8300
movl $0xf, %edx
movq %r12, %rdi
leaq 0x64ed4(%rip), %rsi     # 0xdb32c
callq 0x84e0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r12, %rdi
callq 0x84e0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x8450
movsbl %al, %esi
movq %r13, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8300
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4956e
movl $0x10, %edx
movq %r12, %rdi
movq %rbp, %rsi
callq 0x84e0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x8450
movsbl %al, %esi
movq %r12, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8300
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8100
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x763d6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8480
jmp 0x763d6
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x76540
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8480
movq %rbx, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/./process_vcf_coding_sequences.h
// Function: CDSComparisonMatrices::CDSComparisonMatrices(int)
CDSComparisonMatrices(int numSamples) {
        initialize_matrix_double(N_d_jk, numSamples); initialize_matrix_double(N_jk, numSamples);
        initialize_matrix_double(S_d_jk, numSamples); initialize_matrix_double(S_jk, numSamples);
        initialize_matrix_double(tS_N_jk, numSamples); initialize_matrix_double(tS_N_jk, numSamples);
        initialize_matrix_double(tS_S_jk, numSamples); initialize_matrix_double(tS_S_jk, numSamples);
        initialize_matrix_double(tV_N_jk, numSamples); initialize_matrix_double(tV_N_jk, numSamples);
        initialize_matrix_double(tV_S_jk, numSamples); initialize_matrix_double(tV_S_jk, numSamples);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r12d
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rdi), %rax
movq %rax, (%rsp)
leaq 0x60(%rdi), %r13
leaq 0x78(%rdi), %rbp
leaq 0x90(%rdi), %r14
leaq 0xa8(%rdi), %r15
movl $0xc0, %edx
xorl %esi, %esi
callq 0x8280
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x50664
movq 0x10(%rsp), %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x50664
movq 0x8(%rsp), %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x50664
movq (%rsp), %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x50664
movq %r13, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x50664
movq %r13, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x50664
movq %rbp, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x50664
movq %rbp, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x50664
movq %r14, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x50664
movq %r14, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x50664
movq %r15, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x50664
movq %r15, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x50664
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x45f06
movq %r14, %rdi
callq 0x45f06
movq %rbp, %rdi
callq 0x45f06
movq %r13, %rdi
callq 0x45f06
movq (%rsp), %rdi
callq 0x45f06
movq 0x8(%rsp), %rdi
callq 0x45f06
movq 0x10(%rsp), %rdi
callq 0x45f06
movq %rbx, %rdi
callq 0x45f06
movq %r12, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_sequenom.cpp
// Function: checkAllDNA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool checkAllDNA(const std::string& seq) {
    //std::cerr << seq << std::endl;
    bool bDNA = true;
    for (std::string::size_type i = 0; i != seq.length(); i++) {
        if (seq[i] != 'A' && seq[i] != 'C' && seq[i] != 'G' && seq[i] != 'T') {
            bDNA = false;
        }
    }
    return bDNA;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x7bc65
movq (%rdi), %rdx
movb $0x1, %al
xorl %esi, %esi
movl $0x45, %edi
xorl %r8d, %r8d
movzbl (%rdx,%r8), %r9d
leal -0x41(%r9), %r10d
cmpl $0x6, %r10d
ja 0x7bc51
btl %r10d, %edi
jb 0x7bc5b
cmpb $0x54, %r9b
movzbl %al, %eax
cmovnel %esi, %eax
incq %r8
cmpq %r8, %rcx
jne 0x7bc3c
jmp 0x7bc67
movb $0x1, %al
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_use_map.cpp
// Function: mapMain(int, char**)
int mapMain(int argc, char** argv) {
    parseMapOptions(argc, argv);
    
    // Open connections to read from the vcf and reference genome files
    std::ifstream* LGfile = new std::ifstream(opt::LGfile.c_str());
    
    std::map<string, std::vector<std::vector<string> > > LGmap = loadLinkageGroupMap(LGfile);
    std::cerr << "LG map loaded" << std::endl;
    
    if (opt::bVCF) {
        processVCF(LGmap);
    } else {
        processGenome(LGmap);
    }
    
    return 0;

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
callq 0x7bd75
movl $0x208, %edi            # imm = 0x208
callq 0x8470
movq %rax, %r14
movq 0x90a18(%rip), %rsi     # 0x10c6d0
movq %rax, %rdi
movl $0x8, %edx
callq 0x8860
movq %rsp, %rsi
movq %r14, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x7c00a
movq 0x8f30c(%rip), %rbx     # 0x10afe8
leaq 0x62371(%rip), %rsi     # 0xde054
movl $0xd, %edx
movq %rbx, %rdi
callq 0x84e0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x8450
movsbl %al, %esi
movq 0x8f2da(%rip), %rdi     # 0x10afe8
callq 0x8040
movq %rax, %rdi
callq 0x8300
cmpb $0x1, 0x909ce(%rip)     # 0x10c6f0
jne 0x7bd30
leaq 0x8(%rsp), %rdi
callq 0x7c2a4
jmp 0x7bd3a
leaq 0x8(%rsp), %rdi
callq 0x7c804
leaq 0x8(%rsp), %rdi
callq 0x33302
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x208, %esi            # imm = 0x208
movq %r14, %rdi
callq 0x8480
jmp 0x7bd6d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x33302
movq %rbx, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/./process_vcf_stats_utils.h
// Function: double std_dev<std::vector<double, std::allocator<double>>>(std::vector<double, std::allocator<double>>)
double std_dev(T vector) {
    double mean = vector_average(vector);
    double sum = 0;
    for (int i = 0; i < vector.size(); i++) {
        sum += pow((vector[i] - mean), 2.0);
    }
    double std_dev = sqrt((double)sum/(double)(vector.size()-1));
    return std_dev;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a864
movq (%r14), %rdi
movq 0x8(%r14), %rax
movq %rax, %r14
subq %rdi, %r14
sarq $0x3, %r14
cmpq %rdi, %rax
je 0x82c2c
cmpq $0x1, %r14
movq %r14, %rax
adcq $0x0, %rax
xorpd %xmm3, %xmm3
xorl %ecx, %ecx
addsd (%rdi,%rcx,8), %xmm3
incq %rcx
cmpq %rcx, %rax
jne 0x82c1d
jmp 0x82c30
xorpd %xmm3, %xmm3
testq %rdi, %rdi
je 0x82c4e
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
movsd %xmm3, 0x8(%rsp)
callq 0x8480
movsd 0x8(%rsp), %xmm3
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
cmpq %rcx, %rdx
je 0x82cbb
movq %r14, %xmm0
punpckldq 0x47527(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x4752f(%rip), %xmm0    # 0xca1b0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
divsd %xmm2, %xmm3
cmpq $0x1, %rax
movq %rax, %rdx
adcq $0x0, %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm2
subsd %xmm3, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rsi
cmpq %rsi, %rdx
jne 0x82ca2
decq %rax
movq %rax, %xmm2
punpckldq 0x474d5(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x474dd(%rip), %xmm2    # 0xca1b0
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
divsd %xmm3, %xmm0
ucomisd %xmm1, %xmm0
jb 0x82cef
sqrtsd %xmm0, %xmm0
jmp 0x82cf4
callq 0x83a0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_reorder.cpp
// Function: linkVectors(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
std::map<string,size_t> linkVectors(const std::vector<string>& newOrder, const std::vector<string> oldOrder) {
    std::map<string,size_t> link;
    for (std::vector<string>::size_type i = 0; i != newOrder.size(); i++) {
        std::vector<string>::const_iterator it = std::find(oldOrder.begin(), oldOrder.end(), newOrder[i]);
        if (it == oldOrder.end()) {
            if (opt::sampleNameFile.empty())
                std::cerr << "The column names in NEW_ORDER_FILE.txt do not correspond to names in the VCF header" << std::endl;
            else
                std::cerr << "The column names in NEW_ORDER_FILE.txt do not correspond to names in " << opt::sampleNameFile << std::endl;
            exit(1);
        }
        size_t pos = std::distance(oldOrder.begin(), it);
        link[oldOrder[i]] = pos;
    }
    return link;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rdi, (%rsp)
movq %rcx, 0x28(%rdi)
movq (%rsi), %rdx
cmpq %rdx, 0x8(%rsi)
je 0x89558
movq %rsi, %r15
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%r14), %rdi
movq 0x8(%r14), %rsi
addq %r13, %rdx
callq 0x8a291
movq %rax, %r12
cmpq 0x8(%r14), %rax
je 0x8956b
movq (%r14), %rbx
leaq (%rbx,%r13), %rsi
movq (%rsp), %rdi
callq 0x8a170
subq %rbx, %r12
sarq $0x5, %r12
movq %r12, (%rax)
incq %rbp
movq (%r15), %rdx
movq 0x8(%r15), %rax
subq %rdx, %rax
sarq $0x5, %rax
addq $0x20, %r13
cmpq %rax, %rbp
jne 0x8950c
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x83375(%rip)     # 0x10c8e8
jne 0x89592
movq 0x81a6c(%rip), %r14     # 0x10afe8
leaq 0x5897d(%rip), %rsi     # 0xe1f00
movl $0x53, %edx
movq %r14, %rdi
callq 0x84e0
jmp 0x895c7
movq 0x81a4f(%rip), %rdi     # 0x10afe8
leaq 0x589b4(%rip), %rsi     # 0xe1f54
movl $0x45, %edx
callq 0x84e0
movq 0x8332f(%rip), %rsi     # 0x10c8e0
movq 0x83330(%rip), %rdx     # 0x10c8e8
movq 0x81a29(%rip), %rdi     # 0x10afe8
callq 0x84e0
movq %rax, %r14
movq %r14, %rdi
callq 0x8200
movl $0x1, %edi
callq 0x8530
jmp 0x895dd
jmp 0x895dd
movq %rax, %r14
movq (%rsp), %rdi
callq 0x8a1ec
movq %r14, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_fst.cpp
// Function: calculateFst(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
double calculateFst(const std::vector<double>& fstNumerators, const std::vector<double>& fstDenominators) {
    double numeratorAverage = vector_average(fstNumerators);
    double denominatorAverage = vector_average(fstDenominators);
    double Fst = numeratorAverage/denominatorAverage;
    if (Fst < 0) Fst = 0;
    return Fst;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x3a864
movq (%r14), %rdi
movq 0x8(%r14), %rax
movq %rax, %r15
subq %rdi, %r15
sarq $0x3, %r15
cmpq %rdi, %rax
je 0x8e3a0
cmpq $0x1, %r15
movq %r15, %rax
adcq $0x0, %rax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
addsd (%rdi,%rcx,8), %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x8e391
jmp 0x8e3a4
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
testq %rdi, %rdi
je 0x8e3bc
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x8480
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a864
movq (%r14), %rdi
movq 0x8(%r14), %rax
movq %rax, %rbx
subq %rdi, %rbx
sarq $0x3, %rbx
cmpq %rdi, %rax
je 0x8e402
cmpq $0x1, %rbx
movq %rbx, %rax
adcq $0x0, %rax
xorpd %xmm4, %xmm4
xorl %ecx, %ecx
addsd (%rdi,%rcx,8), %xmm4
incq %rcx
cmpq %rcx, %rax
jne 0x8e3f3
jmp 0x8e406
xorpd %xmm4, %xmm4
testq %rdi, %rdi
je 0x8e422
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
movsd %xmm4, (%rsp)
callq 0x8480
movsd (%rsp), %xmm4
movq %rbx, %xmm0
movq 0x3bd71(%rip), %xmm1    # 0xca1a0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x3bd75(%rip), %xmm2    # 0xca1b0
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
divsd %xmm3, %xmm4
movq %r15, %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm2
divsd %xmm1, %xmm2
divsd %xmm4, %xmm2
xorpd %xmm0, %xmm0
maxsd %xmm2, %xmm0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_fst.cpp
// Function: getSetHeterozygozities(SetCounts const&, int, int)
std::vector<double> getSetHeterozygozities(const SetCounts& thisVarCounts, const int n1, const int n2) {
    std::vector<double> heterozygosities;
    double p1 = (double)thisVarCounts.set1Count/n1;
    double p2 = (double)thisVarCounts.set2Count/n2;
    double het1 = calculateExpectedHeterozygositySimple(p1); heterozygosities.push_back(het1);
    double het2 = calculateExpectedHeterozygositySimple(p2); heterozygosities.push_back(het2);
    double hetNei1 = calculateExpectedHeterozygosityNei78(p1,n1); heterozygosities.push_back(hetNei1);
    double hetNei2 = calculateExpectedHeterozygosityNei78(p2,n2); heterozygosities.push_back(hetNei2);
    return heterozygosities;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %r14d
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
cvtsi2sdl 0xc0(%rsi), %xmm0
cvtsi2sd %edx, %xmm1
movl %ecx, %ebp
movsd %xmm1, 0x18(%rsp)
divsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl 0xc4(%rsi), %xmm1
movsd %xmm1, (%rsp)
movsd 0x40f69(%rip), %xmm2    # 0xcf440
movapd %xmm2, %xmm1
subsd %xmm0, %xmm1
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
subsd %xmm1, %xmm2
movsd %xmm2, 0x38(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
movsd %xmm2, 0x10(%rsp)
je 0x8e513
movsd %xmm2, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x8e520
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x79f34
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm2
divsd %xmm0, %xmm2
movsd 0x40f02(%rip), %xmm1    # 0xcf440
movapd %xmm1, %xmm0
subsd %xmm2, %xmm0
mulsd %xmm2, %xmm2
mulsd %xmm0, %xmm0
addsd %xmm2, %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, 0x30(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
movsd %xmm1, (%rsp)
je 0x8e579
movsd %xmm1, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x8e586
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x79f34
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
decl %r14d
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, 0x28(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x8e5bf
movsd %xmm1, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x8e5cc
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x79f34
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
decl %ebp
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, 0x20(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x8e602
movsd %xmm1, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x8e60f
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x79f34
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x8e621
jmp 0x8e621
jmp 0x8e621
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8e638
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x8480
movq %r14, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O1/millanek[P]evo/process_vcf_fst.cpp
// Function: fstMain(int, char**)
int fstMain(int argc, char** argv) {
    parseFstOptions(argc, argv);
    
    if (!opt::vcfFile.empty())
        getFstFromVCF();
    if (!opt::eigensoftFile.empty())
        summariseEigensoft();
    if (!opt::msFile.empty())
        getFstFromMs();
    
    return 0;
}

// Assembly:
pushq %rax
callq 0x98139
cmpq $0x0, 0x74888(%rip)     # 0x10c998
je 0x98117
callq 0x8e640
cmpq $0x0, 0x74939(%rip)     # 0x10ca58
je 0x98126
callq 0x9730e
cmpq $0x0, 0x7494a(%rip)     # 0x10ca78
je 0x98135
callq 0x95c5d
xorl %eax, %eax
popq %rcx
retq