LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x518f1
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
testq %rdx, %rdx
je 0x518e9
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 0x518c0
incq %rdx
cmpq %rcx, %rdx
jne 0x518ad
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x57a08
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 0x57a17
movq (%rbx), %rcx
movb %al, (%rcx,%r12)
decq %r15
incq %r12
cmpq $0x1, %r15
ja 0x579e7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x57a5b
movl $0x16e34cf, %ecx        # imm = 0x16E34CF
btl %eax, %ecx
jae 0x57a5b
movl %eax, %eax
leaq 0x79e72(%rip), %rcx     # 0xd18b7
movb (%rax,%rcx), %al
testl %ebx, %ebx
je 0x57a54
movzbl %al, %edi
callq 0x8640
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x77757(%rip), %rdi     # 0xcf1b9
leaq 0x79e1b(%rip), %rsi     # 0xd1884
leaq 0x79e2a(%rip), %rcx     # 0xd189a
movl $0x32, %edx
callq 0x82c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5ed7b
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 0x5ed73
incl (%rax,%r8,4)
cmpl $0x2, 0x8(%rdx)
jl 0x5ed73
incl (%rsi,%r8,4)
incq %r8
cmpq %r8, %rcx
jne 0x5ed5e
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2fc8e
movq (%rbx), %r12
movq 0x8(%rbx), %r15
cmpq %r15, %r12
je 0x5edd2
movq %r15, %rax
subq %r12, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x5fd9c
movq %r12, %rdi
movq %r15, %rsi
callq 0x5fe70
movq (%rbx), %r12
movq 0x8(%rbx), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x605e5
subq (%rbx), %rax
sarq $0x5, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3e6a2
movq 0x8(%rbx), %rax
movq (%rbx), %rcx
movq %rax, %r15
subq %rcx, %r15
sarq $0x5, %r15
cmpq %rcx, %rax
je 0x5ee31
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 0x3c182
movl %ebp, (%rax)
incq %rbp
addq $0x20, %r13
cmpq %rbp, %r12
jne 0x5ee15
movq 0xa31b0(%rip), %rdi     # 0x101fe8
leaq 0x73e21(%rip), %rsi     # 0xd2c60
movl $0x2a, %edx
callq 0x84e0
movq 0xa3198(%rip), %rdi     # 0x101fe8
movq %r15, %rsi
callq 0x82f0
movq %rax, %r14
leaq 0x73e29(%rip), %rsi     # 0xd2c8b
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 0x5eeae
jmp 0x5eeae
jmp 0x5eeae
movq %rax, %r14
movq %rbx, %rdi
callq 0x2e784
movq %r14, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5fb94
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 0x6cbf4(%rip), %xmm0    # 0xcc710
testq %rsi, %rsi
je 0x5fb8c
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 0x5fb4b
testl %r11d, %r11d
je 0x5fb55
testl %edi, %edi
jne 0x5fb73
cmpl $0x1, %r11d
jne 0x5fb73
movq (%r8), %r11
movsd (%r11,%r14,4), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%r11,%r14,4)
addq $0x2, %r14
decq %r10
jne 0x5fb3d
jmp 0x5fb8c
movl %r11d, %ebp
xorl $0x1, %ebp
orl %r9d, %ebp
sete %bpl
orl %edi, %r11d
je 0x5fb68
testb %bpl, %bpl
jne 0x5fb68
jmp 0x5fba3
incq %rsi
cmpq %rcx, %rsi
jne 0x5fb1c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa243e(%rip), %r12     # 0x101fe8
leaq 0x731ce(%rip), %r13     # 0xd2d7f
movq %r12, %rdi
movq %r13, %rsi
callq 0x8460
movq %rax, %rdi
movq %r15, %rsi
callq 0x8120
leaq 0x731d6(%rip), %rbp     # 0xd2da4
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_O3/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 0x5fcf6
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 0x6ca8c(%rip), %xmm0    # 0xcc710
testq %r15, %r15
je 0x5fcee
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 0x5fcad
testl %r9d, %r9d
je 0x5fcb7
testl %esi, %esi
jne 0x5fcd4
cmpl $0x1, %r9d
jne 0x5fcd4
movq (%rdi), %r9
movsd (%r9,%r14,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%r9,%r14,8)
incq %r14
cmpq %r14, %r15
jne 0x5fc9f
jmp 0x5fcee
movl %r9d, %r10d
xorl $0x1, %r10d
orl %r8d, %r10d
sete %r10b
orl %esi, %r9d
je 0x5fcca
testb %r10b, %r10b
jne 0x5fcca
jmp 0x5fd05
incq %r15
cmpq %rcx, %r15
jne 0x5fc84
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa22dc(%rip), %r12     # 0x101fe8
leaq 0x7306c(%rip), %r13     # 0xd2d7f
movq %r12, %rdi
movq %r13, %rsi
callq 0x8460
movq %rax, %rdi
movq %r15, %rsi
callq 0x8120
leaq 0x73074(%rip), %rbp     # 0xd2da4
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_O3/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 0x63b7e
movq 0x88(%rbx), %rsi
subq %rdi, %rsi
callq 0x8480
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x63b93
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x8480
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x63ba8
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x8480
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x63bbd
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x8480
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x63bd2
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x8480
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x63be7
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x8480
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9cd43(%rip), %eax     # 0x102558
movl %eax, (%rsp)
movl %esi, %ecx
subl %eax, %ecx
cmpl %ecx, %eax
jg 0x658ae
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 0x66f22
cmpl $0x0, (%rsp)
js 0x6586c
movq $-0x1, %rax
movq 0x8(%rsp), %rcx
movl $0x0, 0x4(%rcx,%rax,4)
movslq (%rsp), %rdx
incq %rax
cmpq %rdx, %rax
jl 0x65858
movq %r14, %rdi
movq %r13, %rsi
callq 0x66fae
movq %rax, %rdi
movq %r15, %rsi
callq 0x30ee4
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x65899
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x8480
movl (%rsp), %ecx
leal 0x1(%rcx), %eax
movl %eax, (%rsp)
movl %ebx, %edx
subl 0x9ccae(%rip), %edx     # 0x102558
cmpl %edx, %ecx
jl 0x65836
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 0x658d6
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x8480
movq %rbx, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O3/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 0x65913
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 0x658fe
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x47e96
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x48a80
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 0x5f834(%rip), %rcx     # 0xcd9cb
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x86c0
movq 0x20(%rsp), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x6e218
leaq 0x10(%rsp), %r13
xorl %ebp, %ebp
movq %rsp, %r15
movslq (%rcx,%rbp,4), %rdx
movq 0x18(%rax), %rax
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 0x6e1fd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8480
incq %rbp
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rdx, %rbp
jb 0x6e1bc
leaq 0x20(%rsp), %rdi
callq 0x480b0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e236
movq %rax, %r14
jmp 0x6e254
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x6e254
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8480
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x6e268
movq (%r12), %rsi
incq %rsi
callq 0x8480
leaq 0x20(%rsp), %rdi
callq 0x480b0
movq %r14, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O3/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 0x75dae
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x8c215(%rip), %rsi     # 0x101f98
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 0x6072f(%rip), %rsi     # 0xd64f1
leaq 0x18(%rsp), %rdi
movq %r14, %rdx
callq 0x77736
leaq 0x6072d(%rip), %rsi     # 0xd6503
leaq 0x18(%rsp), %rdi
callq 0x88c0
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x75e01
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x75e0e
movq %rdx, 0x38(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x48(%rsp)
movq 0x8(%rax), %rdx
leaq 0x38(%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 0x8ac6c(%rip), %rax     # 0x100aa8
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x8ac38(%rip), %rsi     # 0x100a80
movq 0x8c161(%rip), %rdx     # 0x101fb0
movq %rbx, %rdi
callq 0x8800
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x75e71
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x8480
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x75e8c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x8480
testb %bpl, %bpl
jne 0x75eb6
jmp 0x75ec3
movq %rax, %r14
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x75eb6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x8480
jmp 0x75eb6
movq %rax, %r14
movq %rbx, %rdi
callq 0x8360
jmp 0x75ec3
movq %rax, %r14
movq 0x8c0ce(%rip), %rsi     # 0x101f98
leaq 0x58(%rsp), %rdi
callq 0x8620
leaq 0xd0(%rsp), %rdi
callq 0x8190
movq %r14, %rdi
callq 0x8840
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x75f23
movq (%rbx), %rcx
xorl %edx, %edx
xorl %ebp, %ebp
xorl %esi, %esi
cmpb $0x2e, (%rcx,%rdx)
sete %sil
addl %esi, %ebp
incq %rdx
cmpq %rdx, %rax
jne 0x75f0a
cmpl $0x3, %ebp
jg 0x75f36
addq $0x30, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c182
movl (%rax), %ebx
jmp 0x75f77
cmpl $0x4, %ebp
jne 0x75f84
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3be16
addq $0x30, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3c182
movl (%rax), %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x75f77
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8480
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8c05d(%rip), %r14     # 0x101fe8
leaq 0x60574(%rip), %rsi     # 0xd6506
movq %r14, %rdi
callq 0x8460
movq %rax, %rdi
movl %ebp, %esi
callq 0x8810
movq %rax, %rdi
callq 0x8200
leaq 0x6055d(%rip), %rsi     # 0xd6510
movq %r14, %rdi
callq 0x8460
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8400
movq %rax, %rdi
callq 0x8200
leaq 0x591e4(%rip), %rdi     # 0xcf1b9
leaq 0x5929d(%rip), %rsi     # 0xcf279
leaq 0x60540(%rip), %rcx     # 0xd6523
movl $0xe8, %edx
callq 0x82c0
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7600b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8480
movq %rbx, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8bfb7(%rip), %r12     # 0x101fe8
leaq 0x5ee58(%rip), %rbp     # 0xd4e90
movq 0x8(%r15), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x7605e
testq %rdx, %rdx
je 0x76174
movq (%rbx), %rsi
movq (%r15), %rdi
callq 0x8490
testl %eax, %eax
je 0x76174
movl $0x11, %edx
movq %r12, %rdi
leaq 0x5eded(%rip), %rsi     # 0xd4e5a
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 0x5edb2(%rip), %rsi     # 0xd4e6c
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 0x465f2
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 0x76038
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8480
jmp 0x76038
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 0x761a2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8480
movq %rbx, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4d690
movq 0x10(%rsp), %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x4d690
movq 0x8(%rsp), %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x4d690
movq (%rsp), %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x4d690
movq %r13, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x4d690
movq %r13, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x4d690
movq %rbp, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x4d690
movq %rbp, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x4d690
movq %r14, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x4d690
movq %r14, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x4d690
movq %r15, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x4d690
movq %r15, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x4d690
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x42ffa
movq %r14, %rdi
callq 0x42ffa
movq %rbp, %rdi
callq 0x42ffa
movq %r13, %rdi
callq 0x42ffa
movq (%rsp), %rdi
callq 0x42ffa
movq 0x8(%rsp), %rdi
callq 0x42ffa
movq 0x10(%rsp), %rdi
callq 0x42ffa
movq %rbx, %rdi
callq 0x42ffa
movq %r12, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7b839
movq (%rdi), %rdx
movb $0x1, %al
xorl %esi, %esi
movl $0x45, %edi
movzbl (%rdx,%rsi), %r8d
leal -0x41(%r8), %r9d
cmpl $0x6, %r9d
ja 0x7b824
btl %r9d, %edi
jb 0x7b82f
cmpb $0x54, %r8b
sete %r8b
andb %r8b, %al
incq %rsi
cmpq %rsi, %rcx
jne 0x7b80f
jmp 0x7b83b
movb $0x1, %al
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7b949
movl $0x208, %edi            # imm = 0x208
callq 0x8470
movq %rax, %r14
movq 0x87e4c(%rip), %rsi     # 0x1036d8
movq %rax, %rdi
movl $0x8, %edx
callq 0x8860
movq %rsp, %rsi
movq %r14, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x7bbdb
movq 0x86738(%rip), %rbx     # 0x101fe8
leaq 0x5b82d(%rip), %rsi     # 0xd70e4
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 0x86706(%rip), %rdi     # 0x101fe8
callq 0x8040
movq %rax, %rdi
callq 0x8300
cmpb $0x1, 0x87e02(%rip)     # 0x1036f8
jne 0x7b904
leaq 0x8(%rsp), %rdi
callq 0x7be75
jmp 0x7b90e
leaq 0x8(%rsp), %rdi
callq 0x7c3d0
leaq 0x8(%rsp), %rdi
callq 0x30870
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 0x7b941
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30870
movq %rbx, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O3/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 0x37978
movq (%r14), %rdi
movq 0x8(%r14), %rcx
movq %rcx, %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %rdi, %rcx
je 0x8282d
cmpq $0x1, %rax
movq %rax, %rcx
adcq $0x0, %rcx
xorpd %xmm3, %xmm3
xorl %edx, %edx
addsd (%rdi,%rdx,8), %xmm3
incq %rdx
cmpq %rdx, %rcx
jne 0x82815
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm3
jmp 0x8283f
cvtsi2sd %rax, %xmm0
xorpd %xmm3, %xmm3
divsd %xmm0, %xmm3
testq %rcx, %rcx
je 0x82858
movsd %xmm3, 0x8(%rsp)
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
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 0x8289c
cmpq $0x1, %rax
movq %rax, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm2
subsd %xmm3, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rsi
cmpq %rsi, %rdx
jne 0x82883
decq %rax
movq %rax, %xmm2
punpckldq 0x46804(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x4680c(%rip), %xmm2    # 0xc90c0
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
divsd %xmm3, %xmm0
ucomisd %xmm1, %xmm0
jb 0x828d0
sqrtsd %xmm0, %xmm0
jmp 0x828d5
callq 0x83a0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x88f10
movq %rsi, %r15
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%r14), %rdi
movq 0x8(%r14), %rsi
addq %r13, %rdx
callq 0x89c3d
movq %rax, %r12
cmpq 0x8(%r14), %rax
je 0x88f23
movq (%r14), %rbx
leaq (%rbx,%r13), %rsi
movq (%rsp), %rdi
callq 0x89b1c
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 0x88ec4
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x7a9cd(%rip)     # 0x1038f8
jne 0x88f4a
movq 0x790b4(%rip), %r14     # 0x101fe8
leaq 0x515a5(%rip), %rsi     # 0xda4e0
movl $0x53, %edx
movq %r14, %rdi
callq 0x84e0
jmp 0x88f7f
movq 0x79097(%rip), %rdi     # 0x101fe8
leaq 0x515dc(%rip), %rsi     # 0xda534
movl $0x45, %edx
callq 0x84e0
movq 0x7a987(%rip), %rsi     # 0x1038f0
movq 0x7a988(%rip), %rdx     # 0x1038f8
movq 0x79071(%rip), %rdi     # 0x101fe8
callq 0x84e0
movq %rax, %r14
movq %r14, %rdi
callq 0x8200
movl $0x1, %edi
callq 0x8530
jmp 0x88f95
jmp 0x88f95
movq %rax, %r14
movq (%rsp), %rdi
callq 0x89b98
movq %r14, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O3/millanek[P]evo/process_vcf_fst.cpp
// Function: calculateDxy(SetCounts const&, int, int)
double calculateDxy(const SetCounts& thisVarCounts, const int n1, const int n2) {
    double Dxy;
    int sumKij = 0;
    for (std::vector<std::string>::size_type i = 0; i != n1/2; i++) {
        for (std::vector<std::string>::size_type j = 0; j != n2/2; j++) {
            if (thisVarCounts.set1individualsWithVariant[i] == 0 && thisVarCounts.set2individualsWithVariant[j] == 0) {
            } else if (thisVarCounts.set1individualsWithVariant[i] == 1 && thisVarCounts.set2individualsWithVariant[j] == 0) {
                sumKij = sumKij + 2;
            } else if (thisVarCounts.set1individualsWithVariant[i] == 0 && thisVarCounts.set2individualsWithVariant[j] == 1) {
                sumKij = sumKij + 2;
            } else if (thisVarCounts.set1individualsWithVariant[i] == 1 && thisVarCounts.set2individualsWithVariant[j] == 1) {
                sumKij = sumKij + 2;
            } else if (thisVarCounts.set1individualsWithVariant[i] == 2 && thisVarCounts.set2individualsWithVariant[j] == 1) {
                sumKij = sumKij + 2;
            } else if (thisVarCounts.set1individualsWithVariant[i] == 1 && thisVarCounts.set2individualsWithVariant[j] == 2) {
                sumKij = sumKij + 2;
            } else if (thisVarCounts.set1individualsWithVariant[i] == 2 && thisVarCounts.set2individualsWithVariant[j] == 2) {
            } else if (thisVarCounts.set1individualsWithVariant[i] == 2 && thisVarCounts.set2individualsWithVariant[j] == 0) {
                sumKij = sumKij + 4;
            } else if (thisVarCounts.set1individualsWithVariant[i] == 0 && thisVarCounts.set2individualsWithVariant[j] == 2) {
                sumKij = sumKij + 4;
            }
        }
    }
    Dxy = (double)sumKij/(n1*n2);
    return Dxy;
}

// Assembly:
leal 0x1(%rsi), %eax
xorpd %xmm0, %xmm0
cmpl $0x3, %eax
jb 0x8da7e
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %eax
shrl $0x1f, %eax
addl %esi, %eax
sarl %eax
cltq
movl %edx, %ecx
shrl $0x1f, %ecx
addl %edx, %ecx
sarl %ecx
movslq %ecx, %rcx
leal 0x1(%rdx), %r8d
movq 0x90(%rdi), %r9
movq 0xa8(%rdi), %rdi
xorl %r10d, %r10d
xorl %r11d, %r11d
cmpl $0x3, %r8d
jb 0x8da68
movl (%r9,%r10,4), %ebx
xorl %r14d, %r14d
cmpl $0x2, %ebx
je 0x8da3f
cmpl $0x1, %ebx
je 0x8da29
testl %ebx, %ebx
jne 0x8da60
movl (%rdi,%r14,4), %ebp
testl %ebp, %ebp
je 0x8da60
cmpl $0x1, %ebp
je 0x8da4d
leal 0x4(%r11), %r15d
jmp 0x8da3a
movl (%rdi,%r14,4), %ebp
cmpl $0x1, %ebp
je 0x8da4d
testl %ebp, %ebp
je 0x8da4d
leal 0x2(%r11), %r15d
cmpl $0x2, %ebp
jmp 0x8da59
movl (%rdi,%r14,4), %ebp
cmpl $0x2, %ebp
je 0x8da60
cmpl $0x1, %ebp
jne 0x8da53
addl $0x2, %r11d
jmp 0x8da60
leal 0x4(%r11), %r15d
testl %ebp, %ebp
cmovnel %r11d, %r15d
movl %r15d, %r11d
incq %r14
cmpq %r14, %rcx
jne 0x8da08
incq %r10
cmpq %rax, %r10
jne 0x8d9fb
xorps %xmm0, %xmm0
cvtsi2sd %r11d, %xmm0
popq %rbx
popq %r14
popq %r15
popq %rbp
imull %esi, %edx
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x37978
movq (%r14), %rdi
movq 0x8(%r14), %rcx
movq %rcx, %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %rdi, %rcx
je 0x8dc93
cmpq $0x1, %rax
movq %rax, %rcx
adcq $0x0, %rcx
xorpd %xmm1, %xmm1
xorl %edx, %edx
addsd (%rdi,%rdx,8), %xmm1
incq %rdx
cmpq %rdx, %rcx
jne 0x8dc75
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
jmp 0x8dcab
cvtsi2sd %rax, %xmm0
xorpd %xmm1, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
testq %rcx, %rcx
je 0x8dcb8
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x8480
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37978
movq (%r14), %rdi
movq 0x8(%r14), %rcx
movq %rcx, %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %rdi, %rcx
je 0x8dd0a
cmpq $0x1, %rax
movq %rax, %rcx
adcq $0x0, %rcx
xorpd %xmm2, %xmm2
xorl %edx, %edx
addsd (%rdi,%rdx,8), %xmm2
incq %rdx
cmpq %rdx, %rcx
jne 0x8dcef
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm2
jmp 0x8dd1f
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
xorpd %xmm2, %xmm2
divsd %xmm0, %xmm2
testq %rcx, %rcx
je 0x8dd38
movsd %xmm2, 0x10(%rsp)
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x8480
movsd 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
divsd %xmm2, %xmm1
xorpd %xmm0, %xmm0
maxsd %xmm1, %xmm0
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
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
movsd %xmm1, 0x20(%rsp)
divsd %xmm1, %xmm0
movl 0xc4(%rsi), %r15d
movsd 0x3e976(%rip), %xmm2    # 0xcc710
movapd %xmm2, %xmm1
subsd %xmm0, %xmm1
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
leaq 0x40(%rsp), %rdx
movsd %xmm0, 0x18(%rsp)
movsd %xmm0, (%rdx)
xorl %esi, %esi
callq 0x79b8e
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
movsd %xmm1, 0x8(%rsp)
divsd %xmm1, %xmm0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
movsd 0x3e91b(%rip), %xmm2    # 0xcc710
movapd %xmm2, %xmm1
subsd %xmm0, %xmm1
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
subsd %xmm1, %xmm2
movsd %xmm2, 0x38(%rsp)
cmpq %rax, %rsi
movsd %xmm2, 0x10(%rsp)
je 0x8de2c
movsd %xmm2, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x8de41
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x79b8e
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
decl %r14d
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movsd 0x18(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x30(%rsp)
cmpq %rax, %rsi
je 0x8de75
movsd %xmm1, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x8de8a
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x79b8e
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
decl %ebp
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x28(%rsp)
cmpq %rax, %rsi
je 0x8debc
movsd %xmm1, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x8dec9
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x79b8e
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8dedd
jmp 0x8dedd
jmp 0x8dedd
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8def4
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x8480
movq %r14, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O3/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 0x97705
cmpq $0x0, 0x6c2cc(%rip)     # 0x1039a8
je 0x976e3
callq 0x8defc
cmpq $0x0, 0x6c37d(%rip)     # 0x103a68
je 0x976f2
callq 0x968dd
cmpq $0x0, 0x6c38e(%rip)     # 0x103a88
je 0x97701
callq 0x95303
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/millanek[P]evo/./process_vcf_stats_utils.h
// Function: fisher_exactTable(int, int, int, int)
inline double fisher_exactTable(int a, int b, int c, int d) {
    
    long double numerator = factorial(a+b) * factorial(c+d) * factorial(a+c) * factorial(b+d);
    long double denominator = factorial(a) * factorial(b) * factorial(c) * factorial(d) * factorial(a+b+c+d);
    
    double p = numerator/denominator;
    return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %r12d
addl %edi, %r12d
cvtsi2sd %r12d, %xmm0
js 0x99717
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
addsd 0x33179(%rip), %xmm0    # 0xcc710
callq 0x8090
movsd %xmm0, 0x8(%rsp)
movl %ebx, %r13d
addl %ebp, %r13d
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
js 0x99717
addsd 0x33152(%rip), %xmm0    # 0xcc710
callq 0x8090
movsd %xmm0, 0x38(%rsp)
movl %ebp, %eax
addl %r15d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
js 0x99717
addsd 0x3312d(%rip), %xmm0    # 0xcc710
callq 0x8090
movsd %xmm0, 0x30(%rsp)
movl %ebx, %eax
addl %r14d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
js 0x99717
addsd 0x33108(%rip), %xmm0    # 0xcc710
callq 0x8090
movsd %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
testl %r15d, %r15d
js 0x99717
addsd 0x330e4(%rip), %xmm0    # 0xcc710
callq 0x8090
movsd %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
testl %r14d, %r14d
js 0x99717
addsd 0x330c1(%rip), %xmm0    # 0xcc710
callq 0x8090
movsd %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
testl %ebp, %ebp
js 0x99717
addsd 0x3309f(%rip), %xmm0    # 0xcc710
callq 0x8090
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
testl %ebx, %ebx
js 0x99717
addsd 0x3307d(%rip), %xmm0    # 0xcc710
callq 0x8090
movsd (%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x38(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
fldl 0x50(%rsp)
fstpt 0x8(%rsp)
leal (%r12,%r13), %eax
incl %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
callq 0x8090
mulsd (%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
fldt 0x8(%rsp)
fdivl 0x48(%rsp)
fstpl 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x688ca(%rip), %rdi     # 0x101fe8
leaq 0x35b1a(%rip), %rsi     # 0xcf23f
movsd %xmm0, (%rsp)
callq 0x8460
movq %rax, %rdi
movsd (%rsp), %xmm0
callq 0x88b0
movq %rax, %rdi
callq 0x8200
movl $0x1, %edi
callq 0x8530