LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x651b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x83186
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x83173
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x651e0
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3ec30
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x651e0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3ec30
movsd -0x30(%rbp), %xmm0
divsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x651e0
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3ec30
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x651e0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3ec30
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x830cc
jmp 0x83175
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x830a4
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: millanek[P]evo/./process_vcf_stats_utils.h
// Function: pearson_chi_sq_goodness_of_fit(std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>, int, bool)
inline double pearson_chi_sq_goodness_of_fit(std::vector<double> observed, std::vector<double> expected, int df, bool lowerTail = true) {
    assert(observed.size() == expected.size());
    double chi_sq = 0;
    // Sum:
    for (int i = 0; i < (int)observed.size(); i++) {
        chi_sq = chi_sq + (pow((observed[i]-expected[i]),2)/expected[i]);
    }
    
    double p = chisq_cdf(df, chi_sq);
    if (lowerTail)
        p = 1-p;
    
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x48(%rbp)
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
callq 0x3ebf0
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x3ebf0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0x836b2
jmp 0x836d1
leaq 0xb7d81(%rip), %rdi     # 0x13b43a
leaq 0xb7d9d(%rip), %rsi     # 0x13b45d
movl $0x99, %edx
leaq 0xb7dad(%rip), %rcx     # 0x13b479
callq 0xa390
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x48(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x4c(%rbp)
callq 0x3ebf0
movq %rax, %rcx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jge 0x83770
movq -0x48(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x3ec30
movq -0x40(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x3ec30
movsd -0x68(%rbp), %xmm0
subsd (%rax), %xmm0
movl $0x2, %edi
callq 0x835c0
movq -0x40(%rbp), %rdi
movsd %xmm0, -0x60(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x3ec30
movsd -0x60(%rbp), %xmm1
movsd -0x58(%rbp), %xmm0
divsd (%rax), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x836e0
cvtsi2sdl -0x14(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x84860
movsd %xmm0, -0x30(%rbp)
testb $0x1, -0x15(%rbp)
je 0x8379c
movsd 0xaeb26(%rip), %xmm0    # 0x1322b8
subsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa930
movq %rax, -0x40(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xab60
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rcx
movl $0x41, %edx
callq 0x8edf0
jmp 0x8e7e1
leaq -0x12(%rbp), %rdi
callq 0xa640
movq -0x10(%rbp), %rdi
callq 0xa930
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x8e87b
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0xa670
movsbl (%rax), %edi
callq 0x8e8b0
movb %al, -0x51(%rbp)
jmp 0x8e81f
movq -0x48(%rbp), %rdi
movl -0x28(%rbp), %eax
movl -0x2c(%rbp), %ecx
subl %ecx, %eax
movslq %eax, %rsi
callq 0xac60
movq %rax, -0x60(%rbp)
jmp 0x8e839
movq -0x60(%rbp), %rax
movb -0x51(%rbp), %cl
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x8e7ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0xa640
jmp 0x8e898
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xac88
jmp 0x8e898
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8e88e
movq -0x48(%rbp), %rdi
callq 0xac88
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, -0x2(%rbp)
movsbl -0x1(%rbp), %edi
callq 0xa790
testl %eax, %eax
setne -0x3(%rbp)
movsbl -0x1(%rbp), %edi
callq 0xac90
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x18, %eax
ja 0x8e956
movq -0x10(%rbp), %rax
leaq 0xad7c5(%rip), %rcx     # 0x13c0b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x54, -0x2(%rbp)
jmp 0x8e975
movb $0x47, -0x2(%rbp)
jmp 0x8e975
movb $0x43, -0x2(%rbp)
jmp 0x8e975
movb $0x41, -0x2(%rbp)
jmp 0x8e975
movb $0x4b, -0x2(%rbp)
jmp 0x8e975
movb $0x59, -0x2(%rbp)
jmp 0x8e975
movb $0x57, -0x2(%rbp)
jmp 0x8e975
movb $0x53, -0x2(%rbp)
jmp 0x8e975
movb $0x52, -0x2(%rbp)
jmp 0x8e975
movb $0x4d, -0x2(%rbp)
jmp 0x8e975
movb $0x42, -0x2(%rbp)
jmp 0x8e975
movb $0x44, -0x2(%rbp)
jmp 0x8e975
movb $0x48, -0x2(%rbp)
jmp 0x8e975
movb $0x56, -0x2(%rbp)
jmp 0x8e975
movb $0x4e, -0x2(%rbp)
jmp 0x8e975
leaq 0xaad60(%rip), %rdi     # 0x1396bd
leaq 0xad7b8(%rip), %rsi     # 0x13c11c
movl $0x32, %edx
leaq 0xad7c2(%rip), %rcx     # 0x13c132
callq 0xa390
testb $0x1, -0x3(%rbp)
je 0x8e987
movsbl -0x2(%rbp), %edi
callq 0xa8c0
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x467f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x9baa7
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
addq $0x70, %rdi
movq -0x20(%rbp), %rsi
callq 0x4d100
cmpl $0x1, (%rax)
jne 0x9ba97
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4d100
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jle 0x9ba95
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4d100
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x9ba97
jmp 0x9ba99
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x9ba2c
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: millanek[P]evo/process_vcf_stats_functions.cpp
// Function: initializeDoubletons(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, 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>>>>)
void initializeDoubletons(std::vector<std::vector<int> >& d, const std::vector<std::string> populationsUnique) {
    std::vector<std::string>::size_type n_pop = populationsUnique.size();
    
    // Initialize doubletons
    for (int i = 0; i < n_pop; i++) { 
        std::vector<int> v(n_pop,0);
        d.push_back(v);
    }
#ifdef TESTING
    std::cerr << "Doubletons initialised with size: " << n_pop << std::endl;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, %rax
movq -0x58(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x3ffd0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x9bfb6
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x0, -0x3c(%rbp)
leaq -0x3d(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x46300
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rcx
leaq -0x38(%rbp), %rdi
leaq -0x3c(%rbp), %rdx
callq 0x83540
jmp 0x9bf5c
leaq -0x3d(%rbp), %rdi
callq 0x483e0
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6ccd0
jmp 0x9bf74
leaq -0x38(%rbp), %rdi
callq 0x48290
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9bf1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x3d(%rbp), %rdi
callq 0x483e0
jmp 0x9bfbc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x48290
jmp 0x9bfbc
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
// File: millanek[P]evo/./process_vcf_utils.h
// Function: MassokoMalawiResult::init(unsigned long)
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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movl $0x0, -0x14(%rbp)
leaq -0x14(%rbp), %rdx
callq 0x838d0
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movl $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rdx
callq 0x838d0
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
movl $0x0, -0x1c(%rbp)
leaq -0x1c(%rbp), %rdx
callq 0x838d0
movq -0x30(%rbp), %rdi
addq $0x48, %rdi
movq -0x10(%rbp), %rsi
movl $0x0, -0x20(%rbp)
leaq -0x20(%rbp), %rdx
callq 0x838d0
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rsi
movl $0x0, -0x24(%rbp)
leaq -0x24(%rbp), %rdx
callq 0x838d0
movq -0x30(%rbp), %rdi
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
movl $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rdx
callq 0x838d0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0xf589b(%rip), %eax     # 0x199830
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
subl 0xf588c(%rip), %ecx     # 0x199830
cmpl %ecx, %eax
jg 0xa4074
movl -0x10(%rbp), %eax
incl %eax
cltq
movq %rax, -0x50(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x46300
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0xa5450
jmp 0xa3fd7
leaq -0x29(%rbp), %rdi
callq 0x483e0
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0xa4024
movslq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4d100
movl $0x0, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xa3fe7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x483e0
jmp 0xa407a
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa54c0
movq %rax, -0x58(%rbp)
jmp 0xa4037
movq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x46440
jmp 0xa4046
leaq -0x28(%rbp), %rdi
callq 0x48290
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xa3f98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x48290
jmp 0xa407a
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
addq $0x70, %rdi
callq 0x467f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0xa4103
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
addq $0x70, %rdi
movq -0x18(%rbp), %rsi
callq 0x4d100
cmpl $0x1, (%rax)
jne 0xa40f3
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa40f5
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xa40ab
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x6cd40
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x70490
movq -0x80(%rbp), %rdi
movb $0x0, -0x39(%rbp)
callq 0xa820
movq -0x20(%rbp), %rdi
callq 0xa930
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0xa980
jmp 0xad59a
movq -0x80(%rbp), %rdi
leaq 0x8893a(%rip), %rsi     # 0x135edf
callq 0xa810
jmp 0xad5ac
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x705d0
movq %rax, %rdi
callq 0x467f0
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0xad6de
movq -0x20(%rbp), %rax
movq %rax, -0xa8(%rbp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0xb0(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x705d0
movq %rax, %rdi
movq -0x58(%rbp), %rsi
callq 0x4d100
movq -0xb8(%rbp), %rdi
movslq (%rax), %rax
movq %rax, -0xa0(%rbp)
movl $0x1, %esi
callq 0x705d0
movq %rax, %rdi
movq -0x58(%rbp), %rsi
callq 0x4d100
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movl (%rax), %eax
movl %eax, -0x94(%rbp)
callq 0x705d0
movq %rax, %rdi
movq -0x58(%rbp), %rsi
callq 0x4d100
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq %rax, %rcx
movl -0x94(%rbp), %eax
movl (%rcx), %ecx
subl %ecx, %eax
movslq %eax, %rcx
leaq -0x78(%rbp), %rdi
callq 0xa5f0
jmp 0xad690
movq -0x80(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xac20
jmp 0xad69f
leaq -0x78(%rbp), %rdi
callq 0xac88
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xad5b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xad70a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xac88
jmp 0xad70a
movb $0x1, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0xad6f1
movq -0x80(%rbp), %rdi
callq 0xac88
leaq -0x38(%rbp), %rdi
callq 0x6d0b0
movq -0x88(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0xac88
leaq -0x38(%rbp), %rdi
callq 0x6d0b0
movq -0x48(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
movl $0x8, %edx
callq 0xaaa0
movq -0x1f8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0xa4b0
movq %rax, -0x1f0(%rbp)
jmp 0xb7627
movq -0x1f0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa280
movb %al, -0x1f9(%rbp)
jmp 0xb7645
movb -0x1f9(%rbp), %al
testb $0x1, %al
jne 0xb7654
jmp 0xb775e
movb $0x1, -0x1e1(%rbp)
movl $0x10, %edi
callq 0xa2a0
movq %rax, -0x208(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x89a9e(%rip), %rsi     # 0x141115
leaq -0x1e0(%rbp), %rdi
callq 0xba820
jmp 0xb7685
leaq 0x89a9b(%rip), %rdx     # 0x141127
leaq -0x1c0(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x3e020
jmp 0xb76a1
movq -0x208(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0xba930
jmp 0xb76b6
movq -0x208(%rbp), %rdi
movb $0x0, -0x1e1(%rbp)
leaq 0xe03d5(%rip), %rsi     # 0x197aa0
leaq 0x329e(%rip), %rdx      # 0xba970
callq 0xab00
jmp 0xb77a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0xb778b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0xb7745
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0xb7739
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0xac88
leaq -0x1e0(%rbp), %rdi
callq 0xac88
testb $0x1, -0x1e1(%rbp)
jne 0xb7750
jmp 0xb775c
movq -0x208(%rbp), %rdi
callq 0xa430
jmp 0xb778b
movsd -0x190(%rbp), %xmm0
movsd %xmm0, -0x210(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xa290
movsd -0x210(%rbp), %xmm0
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
leaq -0x188(%rbp), %rdi
callq 0xa290
movq -0x198(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa570
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xabc0
movq %rax, -0x28(%rbp)
movb $0x2e, -0x29(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x29(%rbp), %rdx
callq 0xbaa20
movl %eax, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0xb7895
movq -0x68(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x59b00
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xb7970
cmpl $0x4, -0x18(%rbp)
jne 0xb78f4
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x598c0
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rsi
addq $0x30, %rdi
callq 0x59b00
movq %rax, -0x70(%rbp)
jmp 0xb78c3
movq -0x70(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xac88
jmp 0xb796e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xac88
jmp 0xb797c
movq 0xe16f5(%rip), %rdi     # 0x198ff0
leaq 0x89828(%rip), %rsi     # 0x14112a
callq 0xa5c0
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0xab20
movq %rax, %rdi
movq 0xe166c(%rip), %rsi     # 0x198f88
callq 0xa610
movq 0xe16c8(%rip), %rdi     # 0x198ff0
leaq 0x89805(%rip), %rsi     # 0x141134
callq 0xa5c0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xa520
movq %rax, %rdi
movq 0xe163e(%rip), %rsi     # 0x198f88
callq 0xa610
leaq 0x81d67(%rip), %rdi     # 0x1396bd
leaq 0x81e20(%rip), %rsi     # 0x13977d
movl $0xe8, %edx
leaq 0x897de(%rip), %rcx     # 0x141147
callq 0xa390
jmp 0xb7970
movl -0x14(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x56980
testb $0x1, %al
jne 0xb79ba
jmp 0xb7a8a
movq 0xe162f(%rip), %rdi     # 0x198ff0
movq %rdi, -0x58(%rbp)
leaq 0x881a2(%rip), %rsi     # 0x13fb6e
callq 0xa5c0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xa520
movq %rax, %rdi
movq 0xe15a1(%rip), %rsi     # 0x198f88
movq %rsi, -0x60(%rbp)
callq 0xa610
movq -0x58(%rbp), %rdi
leaq 0x88185(%rip), %rsi     # 0x13fb80
callq 0xa5c0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xa520
movq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0xa610
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x6a7e0
movq -0x58(%rbp), %rdi
leaq 0x88170(%rip), %rsi     # 0x13fba4
callq 0xa5c0
movq %rax, -0x50(%rbp)
jmp 0xb7a3f
movq -0x50(%rbp), %rdi
movq 0xe153e(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0xb7a51
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0xa130
jmp 0xb7a65
leaq -0x38(%rbp), %rdi
callq 0xac88
jmp 0xb79a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xac88
jmp 0xb7a90
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xab50
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x65060
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x60(%rbp)
callq 0x65060
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x58(%rbp)
callq 0x65060
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x50(%rbp)
callq 0x65060
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x48(%rbp)
callq 0x65060
movq -0x28(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0x40(%rbp)
callq 0x65060
movq -0x28(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0x38(%rbp)
callq 0x65060
movq -0x28(%rbp), %rdi
addq $0xa8, %rdi
movq %rdi, -0x30(%rbp)
callq 0x65060
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x7bc60
jmp 0xb7c50
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x7bc60
jmp 0xb7c64
movq -0x68(%rbp), %rdi
addq $0x30, %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x7bc60
jmp 0xb7c78
movq -0x68(%rbp), %rdi
addq $0x48, %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x7bc60
jmp 0xb7c8c
movq -0x68(%rbp), %rdi
addq $0x60, %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x7bc60
jmp 0xb7ca0
movq -0x68(%rbp), %rdi
addq $0x60, %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x7bc60
jmp 0xb7cb4
movq -0x68(%rbp), %rdi
addq $0x78, %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x7bc60
jmp 0xb7cc8
movq -0x68(%rbp), %rdi
addq $0x78, %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x7bc60
jmp 0xb7cdc
movq -0x68(%rbp), %rdi
addq $0x90, %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x7bc60
jmp 0xb7cf3
movq -0x68(%rbp), %rdi
addq $0x90, %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x7bc60
jmp 0xb7d0a
movq -0x68(%rbp), %rdi
addq $0xa8, %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x7bc60
jmp 0xb7d21
movq -0x68(%rbp), %rdi
addq $0xa8, %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x7bc60
jmp 0xb7d38
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x65200
movq -0x38(%rbp), %rdi
callq 0x65200
movq -0x40(%rbp), %rdi
callq 0x65200
movq -0x48(%rbp), %rdi
callq 0x65200
movq -0x50(%rbp), %rdi
callq 0x65200
movq -0x58(%rbp), %rdi
callq 0x65200
movq -0x60(%rbp), %rdi
callq 0x65200
movq -0x28(%rbp), %rdi
callq 0x65200
movq -0x18(%rbp), %rdi
callq 0xab50
nopl (%rax,%rax)
// File: millanek[P]evo/./process_vcf_IUPAC.h
// Function: disambiguateIUPAC(char, char)
inline char disambiguateIUPAC(char refBase, char IUPACbase) {
    char altBase;
    switch (IUPACbase)
    {
        case 'K': altBase = (refBase == 'G') ? 'T' : 'G'; break;
        case 'M': altBase = (refBase == 'A') ? 'C' : 'A'; break;
        case 'R': altBase = (refBase == 'A') ? 'G' : 'A'; break;
        case 'S': altBase = (refBase == 'C') ? 'G' : 'C'; break;
        case 'W': altBase = (refBase == 'A') ? 'T' : 'A'; break;
        case 'Y': altBase = (refBase == 'C') ? 'T' : 'C'; break;
        default: assert(false);
    }
    return altBase;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
addl $-0x4b, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0xe, %eax
ja 0xba1dd
movq -0x10(%rbp), %rax
leaq 0x86763(%rip), %rcx     # 0x140868
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsbl -0x1(%rbp), %ecx
movb $0x54, %al
movb $0x47, %dl
movb %dl, -0x12(%rbp)
cmpl $0x47, %ecx
movb %al, -0x11(%rbp)
je 0xba127
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x3(%rbp)
jmp 0xba1fc
movsbl -0x1(%rbp), %ecx
movb $0x43, %al
movb $0x41, %dl
movb %dl, -0x14(%rbp)
cmpl $0x41, %ecx
movb %al, -0x13(%rbp)
je 0xba14b
movb -0x14(%rbp), %al
movb %al, -0x13(%rbp)
movb -0x13(%rbp), %al
movb %al, -0x3(%rbp)
jmp 0xba1fc
movsbl -0x1(%rbp), %ecx
movb $0x47, %al
movb $0x41, %dl
movb %dl, -0x16(%rbp)
cmpl $0x41, %ecx
movb %al, -0x15(%rbp)
je 0xba16f
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
movb %al, -0x3(%rbp)
jmp 0xba1fc
movsbl -0x1(%rbp), %ecx
movb $0x47, %al
movb $0x43, %dl
movb %dl, -0x18(%rbp)
cmpl $0x43, %ecx
movb %al, -0x17(%rbp)
je 0xba193
movb -0x18(%rbp), %al
movb %al, -0x17(%rbp)
movb -0x17(%rbp), %al
movb %al, -0x3(%rbp)
jmp 0xba1fc
movsbl -0x1(%rbp), %ecx
movb $0x54, %al
movb $0x41, %dl
movb %dl, -0x1a(%rbp)
cmpl $0x41, %ecx
movb %al, -0x19(%rbp)
je 0xba1b4
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
movb %al, -0x3(%rbp)
jmp 0xba1fc
movsbl -0x1(%rbp), %ecx
movb $0x54, %al
movb $0x43, %dl
movb %dl, -0x1c(%rbp)
cmpl $0x43, %ecx
movb %al, -0x1b(%rbp)
je 0xba1d5
movb -0x1c(%rbp), %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
movb %al, -0x3(%rbp)
jmp 0xba1fc
leaq 0x7f4d9(%rip), %rdi     # 0x1396bd
leaq 0x80b13(%rip), %rsi     # 0x13acfe
movl $0x22, %edx
leaq 0x87110(%rip), %rcx     # 0x141307
callq 0xa390
movb -0x3(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: millanek[P]evo/./process_vcf_IUPAC.h
// Function: isDNAonlySeq(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool isDNAonlySeq(const std::string& seq) {
    bool DNAonly;
    for (std::string::size_type i = 0; i != seq.length(); i++) {
        DNAonly = isDNAonly(seq[i]);
        if (!DNAonly)
            return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa930
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0xba737
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa670
movsbl (%rax), %edi
callq 0x7a5a0
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xba727
movb $0x0, -0x1(%rbp)
jmp 0xba73b
jmp 0xba729
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xba6e4
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: millanek[P]evo/./process_vcf_coding_sequences.h
// Function: getCodonDistance(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&)
inline int getCodonDistance(const std::string& refCdn, const std::string& altCdn) {
    int numDiffs = 0;
    assert(refCdn.length() == altCdn.length());
    for (std::string::size_type i = 0; i != refCdn.length(); i++) {
        if (refCdn[i] != altCdn[i]) {
            numDiffs = numDiffs + 1;
        }
    }
    return numDiffs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa930
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa930
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jne 0xba78b
jmp 0xba7aa
leaq 0x86a55(%rip), %rdi     # 0x1411e7
leaq 0x7c5d9(%rip), %rsi     # 0x136d72
movl $0x218, %edx            # imm = 0x218
leaq 0x86b85(%rip), %rcx     # 0x14132a
callq 0xa390
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa930
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0xba815
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa670
movsbl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa670
movq %rax, %rcx
movl -0x34(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0xba805
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xba807
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xba7b2
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x1, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa930
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0xc2280
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa670
movsbl (%rax), %eax
cmpl $0x41, %eax
je 0xc226d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa670
movsbl (%rax), %eax
cmpl $0x43, %eax
je 0xc226d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa670
movsbl (%rax), %eax
cmpl $0x47, %eax
je 0xc226d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa670
movsbl (%rax), %eax
cmpl $0x54, %eax
je 0xc226d
movb $0x0, -0x9(%rbp)
jmp 0xc226f
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xc21f8
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xc23e0
movl $0x208, %edi            # imm = 0x208
callq 0xa5d0
movq %rax, -0x60(%rbp)
movq %rax, -0x68(%rbp)
leaq 0xd88b4(%rip), %rdi     # 0x19abc8
callq 0xa220
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0xab90
jmp 0xc232c
movq -0x68(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xc2690
movq 0xd6ca8(%rip), %rdi     # 0x198ff0
leaq 0x8046d(%rip), %rsi     # 0x1427bc
callq 0xa5c0
movq %rax, -0x70(%rbp)
jmp 0xc235a
movq -0x70(%rbp), %rdi
movq 0xd6c23(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0xc236c
testb $0x1, 0xd8875(%rip)     # 0x19abe8
je 0xc23b5
leaq -0x58(%rbp), %rdi
callq 0xc28f0
jmp 0xc2380
jmp 0xc23c2
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x208, %esi            # imm = 0x208
callq 0xa5e0
jmp 0xc23d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3f5b0
jmp 0xc23d3
leaq -0x58(%rbp), %rdi
callq 0xc2f30
jmp 0xc23c0
jmp 0xc23c2
leaq -0x58(%rbp), %rdi
callq 0x3f5b0
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xab50
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, %rsi
movq %rsi, -0x68(%rbp)
movq %rsi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x53120
movq -0x60(%rbp), %rdi
callq 0x53060
movsd %xmm0, -0x58(%rbp)
jmp 0xcadc3
leaq -0x28(%rbp), %rdi
callq 0x3ecb0
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x68(%rbp), %rdi
movslq -0x44(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x3ebf0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0xcae51
movq -0x68(%rbp), %rdi
movslq -0x44(%rbp), %rsi
callq 0x3ec30
movsd (%rax), %xmm0
subsd -0x10(%rbp), %xmm0
movsd 0x688a8(%rip), %xmm1    # 0x1336c8
callq 0xab30
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xcade5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3ecb0
jmp 0xcaeaf
movq -0x68(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
callq 0x3ebf0
movsd -0x78(%rbp), %xmm0
decq %rax
movq %rax, %xmm1
movaps 0x632e8(%rip), %xmm2    # 0x12e160
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x632ec(%rip), %xmm2    # 0x12e170
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0xa480
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xab50
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x53120
movq -0x78(%rbp), %rdi
callq 0x53060
movsd %xmm0, -0x70(%rbp)
jmp 0xd9b84
leaq -0x30(%rbp), %rdi
callq 0x3ecb0
movsd -0x70(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x53120
movq -0x88(%rbp), %rdi
callq 0x53060
movsd %xmm0, -0x80(%rbp)
jmp 0xd9bbe
leaq -0x60(%rbp), %rdi
callq 0x3ecb0
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x18(%rbp), %xmm0
divsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x68(%rbp), %xmm0
jbe 0xd9c22
xorps %xmm0, %xmm0
movsd %xmm0, -0x68(%rbp)
jmp 0xd9c22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3ecb0
jmp 0xd9c30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ecb0
jmp 0xd9c30
movsd -0x68(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xab50
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x48410
movq -0x10(%rbp), %rax
cvtsi2sdl 0xc0(%rax), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cvtsi2sdl 0xc4(%rax), %xmm0
cvtsi2sdl -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0xe2dd0
movsd %xmm0, -0x68(%rbp)
jmp 0xd9cb2
movq -0x78(%rbp), %rdi
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xb77b0
jmp 0xd9ccb
movsd -0x30(%rbp), %xmm0
callq 0xe2dd0
movsd %xmm0, -0x80(%rbp)
jmp 0xd9cdc
movq -0x78(%rbp), %rdi
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0xb77b0
jmp 0xd9cf5
movsd -0x28(%rbp), %xmm0
movl -0x14(%rbp), %edi
callq 0xe2e40
movsd %xmm0, -0x88(%rbp)
jmp 0xd9d0c
movq -0x78(%rbp), %rdi
movsd -0x88(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
leaq -0x58(%rbp), %rsi
callq 0xb77b0
jmp 0xd9d28
movsd -0x30(%rbp), %xmm0
movl -0x18(%rbp), %edi
callq 0xe2e40
movsd %xmm0, -0x90(%rbp)
jmp 0xd9d3f
movq -0x78(%rbp), %rdi
movsd -0x90(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0xb77b0
jmp 0xd9d5b
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xd9d87
jmp 0xd9d7e
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3ecb0
jmp 0xd9d94
movq -0x78(%rbp), %rdi
callq 0x3ecb0
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xab50
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xe2730
leaq 0xb87a6(%rip), %rdi     # 0x19ae88
callq 0xaa70
testb $0x1, %al
jne 0xe26f0
callq 0xd9da0
leaq 0xb8851(%rip), %rdi     # 0x19af48
callq 0xaa70
testb $0x1, %al
jne 0xe2705
callq 0xe1770
leaq 0xb885c(%rip), %rdi     # 0x19af68
callq 0xaa70
testb $0x1, %al
jne 0xe271a
callq 0xe02e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: millanek[P]evo/./process_vcf_fst.h
// Function: calculateExpectedHeterozygosityNei78(double, int)
inline double calculateExpectedHeterozygosityNei78(const double p, const int n) {
    double q = 1 - p;
    double simpleHeterozygosity = 1 - (pow(p,2)+pow(q,2));
    double heterozygosity = (n*simpleHeterozygosity)/(n-1);
    return heterozygosity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movsd 0x4f460(%rip), %xmm0    # 0x1322b8
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movl $0x2, %edi
callq 0x835c0
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
movl $0x2, %edi
callq 0x835c0
movsd -0x30(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd 0x4f422(%rip), %xmm0    # 0x1322b8
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
movl -0xc(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: millanek[P]evo/./process_vcf_fst.h
// Function: calculateFstNumerator(double, double, int, int)
inline double calculateFstNumerator(const double p1, const double p2, const int n1, const int n2) {
    double power = pow((p1-p2), 2);
    double fraction1 = (p1*(1-p1))/(n1-1);
    double fraction2 = (p2*(1-p2))/(n2-1);
    double numerator = power - fraction1 - fraction2;
    return numerator;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movl $0x2, %edi
callq 0x835c0
movsd %xmm0, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x4ef9a(%rip), %xmm1    # 0x1322b8
subsd -0x8(%rbp), %xmm1
mulsd %xmm1, %xmm0
movl -0x14(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x4ef71(%rip), %xmm1    # 0x1322b8
subsd -0x10(%rbp), %xmm1
mulsd %xmm1, %xmm0
movl -0x18(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: millanek[P]evo/./process_vcf_utils.h
// Function: double vector_average_withRegion<std::vector<double, std::allocator<double>>>(std::vector<double, std::allocator<double>>, int)
double vector_average_withRegion(T vector, int regionLength) {
    double sum = 0;
    for (int i = 0; i < vector.size(); i++) {
        sum += vector[i];
    }
    double average = (double)sum / (double)regionLength;
    return average;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x3ebf0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0xe39d5
movq -0x30(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3ec30
movsd (%rax), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xe3992
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: millanek[P]evo/./process_vcf_utils.h
// Function: SetCounts::reset()
void reset() {
        overall = 0;
        set1Count = 0;
        set2Count = 0;
        fisher_pval = 0;
        chi_sq_pval = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, 0xc0(%rax)
movl $0x0, 0xc4(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0xd8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0xe0(%rax)
popq %rbp
retq
nop