LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, %r14
leaq 0x50(%rsp), %rbx
pushq $0x8
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x87e0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8300
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x5a361
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x50(%rsp), %rdi
callq 0x8220
movsd (%rsp), %xmm0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x8240
movq %rax, %rbx
leaq 0x4a6ba(%rip), %rsi     # 0xa4a2d
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
callq 0x5b784
leaq 0x4a6b8(%rip), %rdx     # 0xa4a3f
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x28a29
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x5b7fa
xorl %ebp, %ebp
leaq 0x816f1(%rip), %rsi     # 0xdbaa0
movq 0x82bfa(%rip), %rdx     # 0xdcfb0
movq %rbx, %rdi
callq 0x8830
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x8978
jmp 0x5a3d3
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x8978
testb %bpl, %bpl
jne 0x5a3e7
jmp 0x5a3f4
movq %rax, %r14
movq %rbx, %rdi
callq 0x8390
jmp 0x5a3f4
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x8220
movq %r14, %rdi
callq 0x8870
// File: /workspace/github_cpp_makefile_star2_O2/millanek[P]evo/./process_vcf_annotation_tools.h
// Function: Annotation::getTranscriptCount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int getTranscriptCount(const std::string& geneOrTranscript) {
        int numTranscripts = 0;
        int numDots = (int)std::count(geneOrTranscript.begin(), geneOrTranscript.end(), '.');
        if (numDots < 4)
            numTranscripts = geneTranscriptCounts[geneOrTranscript];
        else if (numDots == 4) {
            //std::vector<std::string> transcriptVec = split(geneOrTranscript,'.');
            //std::string geneName = transcriptVec[0] + "." + transcriptVec[1] + "." + transcriptVec[2] + "." + transcriptVec[3];
            std::string geneName = geneFromTranscript(geneOrTranscript);
            numTranscripts = geneTranscriptCounts[geneName];
        } else {
            std::cerr << "NumDots: " << numDots << std::endl;
            std::cerr << "geneOrTranscript: " << geneOrTranscript << std::endl;
            assert(false);
        }
        return numTranscripts;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
addq %rdi, %rsi
movq %rsp, %rdx
movb $0x2e, (%rdx)
callq 0x5b825
movq %rax, %r15
cmpl $0x3, %r15d
jg 0x5a468
addq $0x30, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x32a8a
movl (%rax), %ebx
jmp 0x5a495
cmpl $0x4, %r15d
jne 0x5a4a1
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3293a
addq $0x30, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x32a8a
movl (%rax), %ebx
movq %rsp, %rdi
callq 0x8978
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x82b40(%rip), %r14     # 0xdcfe8
leaq 0x4a593(%rip), %rsi     # 0xa4a42
movq %r14, %rdi
callq 0x8480
movq %rax, %rdi
movl %r15d, %esi
callq 0x8840
movq %rax, %rdi
callq 0x8230
leaq 0x4a57b(%rip), %rsi     # 0xa4a4c
movq %r14, %rdi
callq 0x8480
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8430
movq %rax, %rdi
callq 0x8230
leaq 0x43bfa(%rip), %rdi     # 0x9e0ed
leaq 0x43cb3(%rip), %rsi     # 0x9e1ad
leaq 0x4a55e(%rip), %rcx     # 0xa4a5f
movl $0xe8, %edx
callq 0x82f0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8978
movq %rbx, %rdi
callq 0x8870
// File: /workspace/github_cpp_makefile_star2_O2/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 0x82aac(%rip), %r12     # 0xdcfe8
leaq 0x8(%rsp), %r13
pushq $0x1
popq %rbp
movq %r15, %rdi
movq %rbx, %rsi
callq 0x311fd
testb %al, %al
je 0x5a5da
movq %r12, %rdi
leaq 0x49039(%rip), %rsi     # 0xa359a
callq 0x8480
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8430
movq %rax, %rdi
callq 0x8230
movq %r12, %rdi
leaq 0x49029(%rip), %rsi     # 0xa35ac
callq 0x8480
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8430
movq %rax, %rdi
callq 0x8230
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3a53b
movq %r12, %rdi
leaq 0x4901d(%rip), %rsi     # 0xa35d0
callq 0x8480
movq %rax, %rdi
callq 0x8230
movq %rbx, %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x8100
movq %r13, %rdi
callq 0x8978
jmp 0x5a544
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8978
movq %rbx, %rdi
callq 0x8870
// File: /workspace/github_cpp_makefile_star2_O2/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 0x82b0
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x40386
movq 0x10(%rsp), %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x40386
movq 0x8(%rsp), %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x40386
movq (%rsp), %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x40386
movq %r13, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x40386
movq %r13, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x40386
movq %rbp, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x40386
movq %rbp, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x40386
movq %r14, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x40386
movq %r14, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x40386
movq %r15, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x40386
movq %r15, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x40386
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x37c74
movq %r14, %rdi
callq 0x37c74
movq %rbp, %rdi
callq 0x37c74
movq %r13, %rdi
callq 0x37c74
movq (%rsp), %rdi
callq 0x37c74
movq 0x8(%rsp), %rdi
callq 0x37c74
movq 0x10(%rsp), %rdi
callq 0x37c74
movq %rbx, %rdi
callq 0x37c74
movq %r12, %rdi
callq 0x8870
// File: /workspace/github_cpp_makefile_star2_O2/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:
addl $-0x4b, %esi
cmpl $0xe, %esi
ja 0x5b6c3
leaq 0x48c0b(%rip), %rax     # 0xa4280
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
cmpb $0x47, %dil
pushq $0x54
popq %rcx
pushq $0x47
jmp 0x5b6b1
cmpb $0x41, %dil
pushq $0x54
jmp 0x5b6ae
cmpb $0x41, %dil
sete %al
addb %al, %al
orb $0x41, %al
retq
cmpb $0x43, %dil
pushq $0x54
popq %rcx
pushq $0x43
jmp 0x5b6b1
cmpb $0x41, %dil
pushq $0x47
popq %rcx
pushq $0x41
popq %rax
cmovel %ecx, %eax
retq
cmpb $0x43, %dil
sete %al
shlb $0x2, %al
orb $0x43, %al
retq
pushq %rax
leaq 0x42a22(%rip), %rdi     # 0x9e0ed
leaq 0x43518(%rip), %rsi     # 0x9ebea
leaq 0x49546(%rip), %rcx     # 0xa4c1f
pushq $0x22
popq %rdx
callq 0x82f0
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
xorl %edx, %edx
movl $0x80045, %esi          # imm = 0x80045
cmpq %rdx, %rax
je 0x5b72b
movzbl (%rcx,%rdx), %edi
addl $-0x41, %edi
cmpl $0x13, %edi
ja 0x5b72b
btl %edi, %esi
jae 0x5b72b
incq %rdx
jmp 0x5b710
cmpq %rdx, %rax
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq 0x8(%rdi), %rcx
cmpq 0x8(%rsi), %rcx
jne 0x5b765
movq (%rdi), %rdx
movq (%rsi), %rsi
xorl %eax, %eax
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x5b763
movb (%rdx,%rdi), %r8b
xorl %r9d, %r9d
cmpb (%rsi,%rdi), %r8b
setne %r9b
addl %r9d, %eax
incq %rdi
jmp 0x5b747
popq %rcx
retq
leaq 0x49393(%rip), %rdi     # 0xa4aff
leaq 0x3f53f(%rip), %rsi     # 0x9acb2
leaq 0x494c8(%rip), %rcx     # 0xa4c42
movl $0x218, %edx            # imm = 0x218
callq 0x82f0
// File: /workspace/github_cpp_makefile_star2_O2/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 (%rdi), %rcx
movq 0x8(%rdi), %rdx
movb $0x1, %al
xorl %esi, %esi
pushq $0x45
popq %rdi
cmpq %rsi, %rdx
je 0x5eb2e
movzbl (%rcx,%rsi), %r8d
leal -0x41(%r8), %r9d
cmpl $0x6, %r9d
ja 0x5eb1e
btl %r9d, %edi
jb 0x5eb29
cmpb $0x54, %r8b
sete %r8b
andb %r8b, %al
incq %rsi
jmp 0x5eb04
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5ec08
movl $0x208, %edi            # imm = 0x208
callq 0x8490
movq %rax, %rbx
movq 0x7fb90(%rip), %rsi     # 0xde708
pushq $0x8
popq %rdx
movq %rax, %rdi
callq 0x8890
movq %rsp, %rsi
movq %rbx, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x5edb1
movq 0x7e44e(%rip), %rdi     # 0xdcfe8
leaq 0x4773b(%rip), %rsi     # 0xa62dc
callq 0x8480
movq %rax, %rdi
callq 0x8230
cmpb $0x1, 0x7fb73(%rip)     # 0xde728
jne 0x5ebc3
leaq 0x8(%rsp), %rdi
callq 0x5ef52
jmp 0x5ebcd
leaq 0x8(%rsp), %rdi
callq 0x5f2f5
leaq 0x8(%rsp), %rdi
callq 0x2a588
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x208, %esi            # imm = 0x208
movq %rbx, %rdi
callq 0x84a0
jmp 0x5ec00
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2a588
movq %r14, %rdi
callq 0x8870
// File: /workspace/github_cpp_makefile_star2_O2/millanek[P]evo/process_vcf_use_map.cpp
// Function: parseMapOptions(int, char**)
void parseMapOptions(int argc, char** argv) {
    bool die = false;
    for (char c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;)
    {
        std::istringstream arg(optarg != NULL ? optarg : "");
        switch (c)
        {
            case '?': die = true; break;
            case 'v': opt::bVCF = true; break;
            case 'h':
                std::cout << MAP_USAGE_MESSAGE;
                exit(EXIT_SUCCESS);
        }
    }
    if (argc - optind < 2) {
        std::cerr << "missing arguments\n";
        die = true;
    }
    else if (argc - optind > 2)
    {
        std::cerr << "too many arguments\n";
        die = true;
    }
    
    if (die) {
        std::cout << "\n" << MAP_USAGE_MESSAGE;
        exit(EXIT_FAILURE);
    }
    
    // Parse the input filenames
    opt::inputFile = argv[optind++];
    opt::LGfile = argv[optind++];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %rbx
movl %edi, %ebp
movq $0x0, 0x10(%rsp)
leaq 0x18(%rsp), %r12
leaq 0x38(%rsp), %r14
pushq $0x8
popq %r15
movl %ebp, %edi
movq %rbx, %rsi
leaq 0x47733(%rip), %rdx     # 0xa6374
leaq 0x7cef8(%rip), %rcx     # 0xdbb40
xorl %r8d, %r8d
callq 0x8790
movl %eax, %r13d
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
je 0x5eccd
movq 0x7e32c(%rip), %rax     # 0xdcf90
movq (%rax), %rsi
testq %rsi, %rsi
leaq 0x3b1ae(%rip), %rax     # 0x99e1f
cmoveq %rax, %rsi
movq %r12, %rdi
leaq 0xf(%rsp), %rdx
callq 0x21904
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x87e0
movsbl %r13b, %r13d
movq %r12, %rdi
callq 0x8978
cmpl $0x3f, %r13d
je 0x5ecb9
cmpl $0x76, %r13d
je 0x5ecb0
cmpl $0x68, %r13d
jne 0x5ecc0
jmp 0x5ed28
movb $0x1, 0x7fa71(%rip)     # 0xde728
jmp 0x5ecc0
movb $0x1, %al
movq %rax, 0x10(%rsp)
movq %r14, %rdi
callq 0x8220
jmp 0x5ec35
movq 0x7e2ec(%rip), %r14     # 0xdcfc0
movslq (%r14), %rax
subl %eax, %ebp
cmpl $0x2, %ebp
jl 0x5ed42
jne 0x5ed4b
testb $0x1, 0x10(%rsp)
jne 0x5ed5e
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
movq (%rbx,%rax,8), %rsi
leaq 0x7f9f0(%rip), %rdi     # 0xde6e8
callq 0x88f0
movslq (%r14), %rax
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
movq (%rbx,%rax,8), %rsi
leaq 0x7f9f7(%rip), %rdi     # 0xde708
callq 0x88f0
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x7e289(%rip), %rdi     # 0xdcfb8
leaq 0x4764a(%rip), %rsi     # 0xa6380
callq 0x8480
xorl %edi, %edi
callq 0x8540
leaq 0x375d9(%rip), %rsi     # 0x96322
jmp 0x5ed52
leaq 0x375e3(%rip), %rsi     # 0x96335
movq 0x7e28f(%rip), %rdi     # 0xdcfe8
callq 0x8480
movq 0x7e253(%rip), %rdi     # 0xdcfb8
leaq 0x34be1(%rip), %rsi     # 0x9394d
callq 0x8480
leaq 0x47608(%rip), %rsi     # 0xa6380
movq %rax, %rdi
callq 0x8480
pushq $0x1
popq %rdi
callq 0x8540
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x8220
jmp 0x5eda9
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8978
jmp 0x5eda9
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8870
// File: /workspace/github_cpp_makefile_star2_O2/millanek[P]evo/process_vcf_use_map.cpp
// Function: loadLinkageGroupMap[abi:cxx11](std::basic_ifstream<char, std::char_traits<char>>*&)
std::map<string, std::vector<std::vector<string> > > loadLinkageGroupMap(std::ifstream*& LGfile) {
    std::map<string, std::vector<std::vector<string> > > LGmap;
    std::vector<std::vector<string> > scaffoldsInLG;
    string currentLG;
    string line;
    getline(*LGfile, line);
    currentLG = line.substr(1, std::string::npos);
    while (getline(*LGfile, line)) {
        if (line[0] == '>') {
            LGmap[currentLG] = scaffoldsInLG;
            currentLG = line.substr(1, std::string::npos);
            scaffoldsInLG.clear();
        } else {
            std::vector<string> thisScaffold = split(line, '\t');
            scaffoldsInLG.push_back(thisScaffold);
        } 
    }
    return LGmap;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
andq $0x0, 0x30(%rsp)
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %r14
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movb %cl, (%rax)
movq (%rsi), %rdi
movq %rsp, %rsi
callq 0x80a0
leaq 0x58(%rsp), %rdi
movq %rsp, %rsi
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
callq 0x84b0
leaq 0x38(%rsp), %r15
leaq 0x58(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x8550
movq %r12, %rdi
callq 0x8978
movq %rsp, %r13
leaq 0x20(%rsp), %rbp
movq (%r14), %rdi
movq %r13, %rsi
callq 0x80a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x5eede
movq (%rsp), %rax
cmpb $0x3e, (%rax)
jne 0x5eeb8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2957c
movq %rax, %rdi
movq %rbp, %rsi
callq 0x295e2
movq %r12, %rdi
movq %r13, %rsi
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
callq 0x84b0
movq %r15, %rdi
movq %r12, %rsi
callq 0x8550
movq %r12, %rdi
callq 0x8978
movq %rbp, %rdi
callq 0x296c0
jmp 0x5ee52
movq %r12, %rdi
movq %r13, %rsi
pushq $0x9
popq %rdx
callq 0x40349
movq %rbp, %rdi
movq %r12, %rsi
callq 0x29502
movq %r12, %rdi
callq 0x28a08
jmp 0x5ee52
movq %rsp, %rdi
callq 0x8978
leaq 0x38(%rsp), %rdi
callq 0x8978
leaq 0x20(%rsp), %rdi
callq 0x29054
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5ef23
jmp 0x5ef23
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x28a08
jmp 0x5ef26
jmp 0x5ef23
jmp 0x5ef23
movq %rax, %r14
movq %rsp, %rdi
callq 0x8978
leaq 0x38(%rsp), %rdi
callq 0x8978
leaq 0x20(%rsp), %rdi
callq 0x29054
movq %rbx, %rdi
callq 0x2a588
movq %r14, %rdi
callq 0x8870
// File: /workspace/github_cpp_makefile_star2_O2/millanek[P]evo/process_vcf_search_sex.cpp
// Function: getSetVariantDepths(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<unsigned long, std::allocator<unsigned long>> const&, std::vector<unsigned long, std::allocator<unsigned long>> const&)
SetDepths getSetVariantDepths(const std::vector<std::string>& fields, const std::vector<size_t>& set1_loci, const std::vector<size_t>& set2_loci) {
    SetDepths thisVariantDepths;
    for (std::vector<std::string>::size_type i = NUM_NON_GENOTYPE_COLUMNS; i != fields.size(); i++) {
        std::vector<string> genotype_field = split(fields[i], ':');
        if (std::find(set1_loci.begin(), set1_loci.end(), i-NUM_NON_GENOTYPE_COLUMNS) != set1_loci.end()) { thisVariantDepths.set1Depths.push_back(atoi(genotype_field[2].c_str())); }
        if (std::find(set2_loci.begin(), set2_loci.end(), i-NUM_NON_GENOTYPE_COLUMNS) != set2_loci.end()) { thisVariantDepths.set2Depths.push_back(atoi(genotype_field[2].c_str())); }
    }
    thisVariantDepths.fillMeanDepths();
    return thisVariantDepths;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdi, 0x10(%rsp)
leaq 0x18(%rdi), %rax
movq %rax, 0x18(%rsp)
pushq $0x9
popq %r13
movl $0x120, %ebp            # imm = 0x120
leaq 0x8(%rsp), %rbx
movq (%r12), %rsi
movq 0x8(%r12), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rax, %r13
je 0x61dab
addq %rbp, %rsi
leaq 0x20(%rsp), %rdi
pushq $0x3a
popq %rdx
callq 0x40349
movq (%r15), %rdi
movq 0x8(%r15), %rsi
addq $-0x9, %r13
movq %r13, 0x8(%rsp)
movq %rbx, %rdx
callq 0x45ac4
cmpq 0x8(%r15), %rax
je 0x61d5b
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x86f0
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x2c80c
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %r13, 0x8(%rsp)
movq %rbx, %rdx
callq 0x45ac4
cmpq 0x8(%r14), %rax
je 0x61d94
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x86f0
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x2c80c
leaq 0x20(%rsp), %rdi
callq 0x28a08
addq $0x20, %rbp
addq $0xa, %r13
jmp 0x61cf5
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x62cf2
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x61dd0
jmp 0x61dd7
jmp 0x61dd7
movq %rax, %rbx
jmp 0x61de4
jmp 0x61dd7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x28a08
movq 0x10(%rsp), %rdi
callq 0x62d50
movq %rbx, %rdi
callq 0x8870
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2f816
movq %r14, %rdi
callq 0x2f7e9
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x2b43c
movsd 0x8(%rsp), %xmm2
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
sarq $0x3, %rax
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %rax
je 0x6343c
movsd (%rcx,%rdx,8), %xmm1
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
jmp 0x63421
decq %rax
movq %rax, %xmm1
punpckldq 0x2edf4(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2edfc(%rip), %xmm1    # 0x92250
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x63474
sqrtsd %xmm0, %xmm0
jmp 0x63479
callq 0x83d0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/millanek[P]evo/process_vcf_stats_testing.cpp
// Function: parseStatsTestingOptions(int, char**)
void parseStatsTestingOptions(int argc, char** argv) {
    bool die = false;
    for (char c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;)
    {
        std::istringstream arg(optarg != NULL ? optarg : "");
        switch (c)
        {
            case '?': die = true; break;
            case 'h':
                std::cout << STATS_TEST_MESSAGE;
                exit(EXIT_SUCCESS);
        }
    }
    if (argc - optind < 1) {
        std::cerr << "missing arguments\n";
        die = true;
    }
    else if (argc - optind > 2)
    {
        std::cerr << "too many arguments\n";
        die = true;
    }
    
    if (die) {
        std::cout << "\n" << STATS_TEST_MESSAGE;
        exit(EXIT_FAILURE);
    }
    
    // Parse the input filenames
    
    opt::inputFile = argv[optind++];
    
    if (argc - optind == 1) {
        opt::secondFile = argv[optind++];
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %rbx
movl %edi, %ebp
movq $0x0, 0x10(%rsp)
leaq 0x18(%rsp), %r12
leaq 0x38(%rsp), %r14
pushq $0x8
popq %r15
movl %ebp, %edi
movq %rbx, %rsi
leaq 0x2a4c9(%rip), %rdx     # 0x92686
leaq 0x73b5c(%rip), %rcx     # 0xdbd20
xorl %r8d, %r8d
callq 0x8790
movl %eax, %r13d
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
je 0x6823a
movq 0x74db0(%rip), %rax     # 0xdcf90
movq (%rax), %rsi
testq %rsi, %rsi
leaq 0x31c32(%rip), %rax     # 0x99e1f
cmoveq %rax, %rsi
movq %r12, %rdi
leaq 0xf(%rsp), %rdx
callq 0x21904
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x87e0
movsbl %r13b, %r13d
movq %r12, %rdi
callq 0x8978
cmpl $0x3f, %r13d
je 0x68226
cmpl $0x68, %r13d
jne 0x6822d
jmp 0x6829e
movb $0x1, %al
movq %rax, 0x10(%rsp)
movq %r14, %rdi
callq 0x8220
jmp 0x681b1
movq 0x74d7f(%rip), %r14     # 0xdcfc0
movslq (%r14), %rax
movl %ebp, %ecx
subl %eax, %ecx
jle 0x682b8
cmpl $0x2, %ecx
ja 0x682c1
testb $0x1, 0x10(%rsp)
jne 0x682d4
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
movq (%rbx,%rax,8), %rsi
leaq 0x76629(%rip), %rdi     # 0xde890
callq 0x88f0
movslq (%r14), %rax
subl %eax, %ebp
cmpl $0x1, %ebp
jne 0x6828c
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
movq (%rbx,%rax,8), %rsi
leaq 0x76629(%rip), %rdi     # 0xde8b0
callq 0x88f0
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x74d13(%rip), %rdi     # 0xdcfb8
leaq 0x41383(%rip), %rsi     # 0xa962f
callq 0x8480
xorl %edi, %edi
callq 0x8540
leaq 0x2e063(%rip), %rsi     # 0x96322
jmp 0x682c8
leaq 0x2e06d(%rip), %rsi     # 0x96335
movq 0x74d19(%rip), %rdi     # 0xdcfe8
callq 0x8480
movq 0x74cdd(%rip), %rdi     # 0xdcfb8
leaq 0x2b66b(%rip), %rsi     # 0x9394d
callq 0x8480
leaq 0x41341(%rip), %rsi     # 0xa962f
movq %rax, %rdi
callq 0x8480
pushq $0x1
popq %rdi
callq 0x8540
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x8220
jmp 0x6831f
movq %rax, %rbx
jmp 0x6831f
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8978
movq %rbx, %rdi
callq 0x8870
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
movl %edx, %ecx
movl $0x2, %r9d
movl %esi, %eax
cltd
idivl %r9d
movslq %eax, %r8
movl %ecx, %eax
cltd
idivl %r9d
cltq
movq 0x90(%rdi), %rdx
movq 0xa8(%rdi), %rdi
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpq %r8, %r10
je 0x6b1eb
xorl %r11d, %r11d
cmpq %r11, %rax
je 0x6b1e6
movl (%rdx,%r10,4), %ebx
cmpl $0x2, %ebx
je 0x6b1c0
cmpl $0x1, %ebx
je 0x6b1aa
testl %ebx, %ebx
jne 0x6b1e1
movl (%rdi,%r11,4), %ebx
testl %ebx, %ebx
je 0x6b1e1
cmpl $0x1, %ebx
je 0x6b1ce
leal 0x4(%r9), %ebp
jmp 0x6b1bb
movl (%rdi,%r11,4), %ebx
cmpl $0x1, %ebx
je 0x6b1ce
testl %ebx, %ebx
je 0x6b1ce
leal 0x2(%r9), %ebp
cmpl $0x2, %ebx
jmp 0x6b1da
movl (%rdi,%r11,4), %ebx
cmpl $0x2, %ebx
je 0x6b1e1
cmpl $0x1, %ebx
jne 0x6b1d4
addl $0x2, %r9d
jmp 0x6b1e1
leal 0x4(%r9), %ebp
testl %ebx, %ebx
cmovnel %r9d, %ebp
movl %ebp, %r9d
incq %r11
jmp 0x6b180
incq %r10
jmp 0x6b178
cvtsi2sd %r9d, %xmm0
imull %esi, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2f816
movq %r14, %rdi
callq 0x2f7e9
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
callq 0x2b43c
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2f816
movq %r14, %rdi
callq 0x2f7e9
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x2b43c
movsd 0x10(%rsp), %xmm1
divsd 0x8(%rsp), %xmm1
xorpd %xmm0, %xmm0
maxsd %xmm1, %xmm0
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/millanek[P]evo/process_vcf_fst.cpp
// Function: getSetHeterozygozities(SetCounts const&, int, int)
std::vector<double> getSetHeterozygozities(const SetCounts& thisVarCounts, const int n1, const int n2) {
    std::vector<double> heterozygosities;
    double p1 = (double)thisVarCounts.set1Count/n1;
    double p2 = (double)thisVarCounts.set2Count/n2;
    double het1 = calculateExpectedHeterozygositySimple(p1); heterozygosities.push_back(het1);
    double het2 = calculateExpectedHeterozygositySimple(p2); heterozygosities.push_back(het2);
    double hetNei1 = calculateExpectedHeterozygosityNei78(p1,n1); heterozygosities.push_back(hetNei1);
    double hetNei2 = calculateExpectedHeterozygosityNei78(p2,n2); heterozygosities.push_back(hetNei2);
    return heterozygosities;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cvtsi2sdl 0xc0(%rsi), %xmm1
cvtsi2sd %edx, %xmm0
cvtsi2sdl 0xc4(%rsi), %xmm2
movsd %xmm2, (%rsp)
divsd %xmm0, %xmm1
movsd 0x2c1e8(%rip), %xmm2    # 0x975f0
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
movsd %xmm1, 0x8(%rsp)
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movapd %xmm2, %xmm1
subsd %xmm0, %xmm1
leaq 0x28(%rsp), %rsi
movsd %xmm1, (%rsi)
callq 0x5a406
cvtsi2sd %ebp, %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0x2c1a3(%rip), %xmm2    # 0x975f0
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
movsd %xmm1, (%rsp)
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
subsd %xmm0, %xmm2
leaq 0x20(%rsp), %rsi
movsd %xmm2, (%rsi)
movq %rbx, %rdi
callq 0x5a406
movsd 0x8(%rsp), %xmm0
movl %r14d, %edi
callq 0x70d06
leaq 0x18(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x5a406
movsd (%rsp), %xmm0
movl %ebp, %edi
callq 0x70d06
leaq 0x10(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x5a406
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x6b4c9
jmp 0x6b4c9
jmp 0x6b4c9
movq %rax, %r14
movq %rbx, %rdi
callq 0x2b43c
movq %r14, %rdi
callq 0x8870
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7093b
cmpq $0x0, 0x6e0be(%rip)     # 0xde9d0
je 0x70919
callq 0x6b4dc
cmpq $0x0, 0x6e16f(%rip)     # 0xdea90
je 0x70928
callq 0x700be
cmpq $0x0, 0x6e180(%rip)     # 0xdeab0
je 0x70937
callq 0x6f323
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movsd 0x268e2(%rip), %xmm1    # 0x975f0
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
mulsd %xmm0, %xmm0
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
subsd %xmm2, %xmm1
cvtsi2sd %edi, %xmm0
mulsd %xmm1, %xmm0
decl %edi
cvtsi2sd %edi, %xmm1
divsd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movapd 0x266a5(%rip), %xmm1    # 0x975e0
subpd %xmm0, %xmm1
movd %esi, %xmm3
movd %edi, %xmm4
punpckldq %xmm3, %xmm4    # xmm4 = xmm4[0],xmm3[0],xmm4[1],xmm3[1]
pcmpeqd %xmm3, %xmm3
paddd %xmm4, %xmm3
mulpd %xmm0, %xmm1
cvtdq2pd %xmm3, %xmm0
divpd %xmm0, %xmm1
subsd %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
subsd %xmm1, %xmm2
movapd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x71278
addsd (%rax,%rdx,8), %xmm0
incq %rdx
jmp 0x71269
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/millanek[P]evo/./process_vcf_stats_utils.h
// Function: pearson_chi_sq_indep(int, int, int, int)
inline double pearson_chi_sq_indep(int a, int b, int c, int d) {
    // Expected values for a,b,c,and d: (RowTotal*ColTotal)/GridTotal
    double n = (double)a+b+c+d;
    double exp_a = (double)((a+b)*(a+c))/n;
    double exp_b = (double)((a+b)*(b+d))/n;
    double exp_c = (double)((c+d)*(a+c))/n;
    double exp_d = (double)((c+d)*(b+d))/n;
    //std::cerr << "exp_a: " << exp_a << "exp_b: " << exp_b << "exp_c: " << exp_c << "exp_d: " << exp_d << std::endl;
    double chi_sq = pow((a-exp_a),2.0)/exp_a + pow((b-exp_b),2.0)/exp_b + pow((c-exp_c),2.0)/exp_c + pow((d-exp_d),2.0)/exp_d;
    //std::cerr << "Chisq stat: " << chi_sq << std::endl;
    double df = 1.0;
    double p = (1-chisq_cdf(df, chi_sq));
    return p;
}

// Assembly:
pushq %rax
movd %edi, %xmm0
movd %esi, %xmm3
punpckldq %xmm0, %xmm3    # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1]
cvtdq2pd %xmm3, %xmm1
movd %edx, %xmm0
movd %ecx, %xmm2
punpckldq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
cvtdq2pd %xmm2, %xmm0
addl %edi, %esi
paddd %xmm3, %xmm2
addl %edx, %ecx
movd %esi, %xmm3
movdqa %xmm2, %xmm4
pmuludq %xmm3, %xmm4
pshufd $0x55, %xmm2, %xmm5     # xmm5 = xmm2[1,1,1,1]
pmuludq %xmm5, %xmm3
punpckldq %xmm3, %xmm4    # xmm4 = xmm4[0],xmm3[0],xmm4[1],xmm3[1]
cvtdq2pd %xmm4, %xmm3
movapd %xmm1, %xmm4
unpckhpd %xmm1, %xmm4            # xmm4 = xmm4[1],xmm1[1]
addsd %xmm1, %xmm4
movapd %xmm0, %xmm6
unpckhpd %xmm0, %xmm6            # xmm6 = xmm6[1],xmm0[1]
addsd %xmm4, %xmm6
addsd %xmm0, %xmm6
unpcklpd %xmm6, %xmm6            # xmm6 = xmm6[0,0]
divpd %xmm6, %xmm3
subpd %xmm3, %xmm1
mulpd %xmm1, %xmm1
movd %ecx, %xmm4
pmuludq %xmm4, %xmm2
pmuludq %xmm5, %xmm4
punpckldq %xmm4, %xmm2    # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
cvtdq2pd %xmm2, %xmm2
divpd %xmm3, %xmm1
divpd %xmm6, %xmm2
subpd %xmm2, %xmm0
mulpd %xmm0, %xmm0
divpd %xmm2, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x25e1e(%rip), %xmm0    # 0x975f0
callq 0x43f6f
movsd 0x25e11(%rip), %xmm1    # 0x975f0
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movl %ecx, %ebx
movl %edx, %r14d
movl %esi, %r15d
movl %edi, %r12d
leal (%r15,%r12), %ebp
cvtsi2sd %ebp, %xmm0
callq 0x3c270
movsd %xmm0, 0x10(%rsp)
leal (%rbx,%r14), %r13d
cvtsi2sd %r13d, %xmm0
callq 0x3c270
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leal (%r14,%r12), %eax
cvtsi2sd %eax, %xmm0
callq 0x3c270
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leal (%rbx,%r15), %eax
cvtsi2sd %eax, %xmm0
callq 0x3c270
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
fldl 0x30(%rsp)
fstpt 0x10(%rsp)
cvtsi2sd %r12d, %xmm0
callq 0x3c270
movsd %xmm0, 0x8(%rsp)
cvtsi2sd %r15d, %xmm0
callq 0x3c270
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
cvtsi2sd %r14d, %xmm0
callq 0x3c270
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
cvtsi2sd %ebx, %xmm0
callq 0x3c270
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
addl %ebp, %r13d
cvtsi2sd %r13d, %xmm0
callq 0x3c270
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
fldt 0x10(%rsp)
fdivl 0x28(%rsp)
fstpl 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/millanek[P]evo/process_vcf_shortRNA.cpp
// Function: parseShortRNAOptions(int, char**)
void parseShortRNAOptions(int argc, char** argv) {
    bool die = false;
    for (char c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;)
    {
        std::istringstream arg(optarg != NULL ? optarg : "");
        switch (c)
        {
            case '?': die = true; break;
            case 'o': arg >> opt::out; break;
            case 'h':
                std::cout << SMALL_RNA_USAGE_MESSAGE;
                exit(EXIT_SUCCESS);
        }
    }
    if (argc - optind < 1) {
        std::cerr << "missing arguments\n";
        die = true;
    }
    else if (argc - optind > 1)
    {
        std::cerr << "too many arguments\n";
        die = true;
    }
    
    if (die) {
        std::cout << "\n" << SMALL_RNA_USAGE_MESSAGE;
        exit(EXIT_FAILURE);
    }
    
    // Parse the input filenames
    opt::smallRNAFile = argv[optind++];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %rbx
movl %edi, %ebp
movq $0x0, 0x10(%rsp)
leaq 0x18(%rsp), %r12
leaq 0x38(%rsp), %r14
pushq $0x8
popq %r15
movl %ebp, %edi
movq %rbx, %rsi
leaq 0x29b71(%rip), %rdx     # 0x9ce39
leaq 0x68e91(%rip), %rcx     # 0xdc160
xorl %r8d, %r8d
callq 0x8790
movl %eax, %r13d
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
je 0x7335c
movq 0x69ca5(%rip), %rax     # 0xdcf90
movq (%rax), %rsi
testq %rsi, %rsi
leaq 0x26b27(%rip), %rax     # 0x99e1f
cmoveq %rax, %rsi
movq %r12, %rdi
leaq 0xf(%rsp), %rdx
callq 0x21904
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x87e0
movsbl %r13b, %r13d
movq %r12, %rdi
callq 0x8978
cmpl $0x3f, %r13d
je 0x73348
cmpl $0x6f, %r13d
je 0x73337
cmpl $0x68, %r13d
jne 0x7334f
jmp 0x7339d
movq %r14, %rdi
leaq 0x6b867(%rip), %rsi     # 0xdeba8
callq 0x8570
jmp 0x7334f
movb $0x1, %al
movq %rax, 0x10(%rsp)
movq %r14, %rdi
callq 0x8220
jmp 0x732bc
movq 0x69c5d(%rip), %rax     # 0xdcfc0
movslq (%rax), %rcx
subl %ecx, %ebp
jle 0x733b7
cmpl $0x1, %ebp
jne 0x733c0
testb $0x1, 0x10(%rsp)
jne 0x733d3
leal 0x1(%rcx), %edx
movl %edx, (%rax)
movq (%rbx,%rcx,8), %rsi
leaq 0x6b802(%rip), %rdi     # 0xdeb88
callq 0x88f0
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x69c14(%rip), %rdi     # 0xdcfb8
leaq 0x397de(%rip), %rsi     # 0xacb89
callq 0x8480
xorl %edi, %edi
callq 0x8540
leaq 0x22f64(%rip), %rsi     # 0x96322
jmp 0x733c7
leaq 0x22f6e(%rip), %rsi     # 0x96335
movq 0x69c1a(%rip), %rdi     # 0xdcfe8
callq 0x8480
movq 0x69bde(%rip), %rdi     # 0xdcfb8
leaq 0x2056c(%rip), %rsi     # 0x9394d
callq 0x8480
leaq 0x3979c(%rip), %rsi     # 0xacb89
movq %rax, %rdi
callq 0x8480
pushq $0x1
popq %rdi
callq 0x8540
jmp 0x733ff
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x8220
jmp 0x73420
movq %rax, %rbx
jmp 0x73420
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8978
movq %rbx, %rdi
callq 0x8870
// File: /workspace/github_cpp_makefile_star2_O2/millanek[P]evo/process_vcf_linkGeneNames.cpp
// Function: getSpeciesColumn(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline int getSpeciesColumn(const string& species) {
    if (species == "mz") { return 0; }
    if (species == "pn") { return 1; }
    if (species == "ab") { return 2; }
    if (species == "nb") { return 3; }
    if (species == "on") { return 4; }
    return -1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x36700(%rip), %rsi     # 0xacd00
callq 0x2193f
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0x76651
leaq 0x36948(%rip), %rsi     # 0xacf5c
movq %rbx, %rdi
callq 0x2193f
testb %al, %al
je 0x76624
pushq $0x1
jmp 0x76650
leaq 0x36934(%rip), %rsi     # 0xacf5f
movq %rbx, %rdi
callq 0x2193f
testb %al, %al
je 0x7663b
pushq $0x2
jmp 0x76650
leaq 0x36920(%rip), %rsi     # 0xacf62
movq %rbx, %rdi
callq 0x2193f
testb %al, %al
je 0x76653
pushq $0x3
popq %rax
popq %rbx
retq
leaq 0x3706f(%rip), %rsi     # 0xad6c9
movq %rbx, %rdi
callq 0x2193f
movzbl %al, %eax
decl %eax
orl $0x4, %eax
jmp 0x76651
// File: /workspace/github_cpp_makefile_star2_O2/millanek[P]evo/remove_lowercase.cpp
// Function: removeLcLetters[abi:cxx11](std::basic_ifstream<char, std::char_traits<char>>&, int)
std::string removeLcLetters(std::ifstream& fastaFile, int bytes) {
    std::string filteredSeq; filteredSeq.reserve(bytes); filteredSeq = "";
    string line;
    while (getline(fastaFile, line)) {
        for (int i = 0; i != line.length(); i++) {
            if (isupper(line[i])) {
                filteredSeq += line[i];
            }
        }
    }
    return filteredSeq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movslq %edx, %rsi
callq 0x8700
leaq 0x23166(%rip), %rsi     # 0x99e1f
movq %rbx, %rdi
callq 0x88f0
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x80a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x76d1b
xorl %r12d, %r12d
cmpq 0x8(%rsp), %r12
je 0x76cd5
movq (%rsp), %rax
movsbl (%rax,%r12), %ebp
movl %ebp, %edi
callq 0x83a0
testl %eax, %eax
je 0x76d16
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8400
incq %r12
jmp 0x76cf1
movq %rsp, %rdi
callq 0x8978
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x76d45
jmp 0x76d3a
movq %rax, %r14
movq %rsp, %rdi
callq 0x8978
movq %rbx, %rdi
callq 0x8978
movq %r14, %rdi
callq 0x8870
// File: /workspace/github_cpp_makefile_star2_O2/millanek[P]evo/remove_lowercase.cpp
// Function: removeLcMain(int, char**)
int removeLcMain(int argc, char** argv) {
    parseRemoveLcOptions(argc, argv);
    
    std::ifstream* fastaFile = new std::ifstream(opt::fastaFile.c_str());
    string description; getline(*fastaFile, description);
    
    string finalSequence = removeLcLetters(*fastaFile, 500000000);
    
    if (opt::out.empty()) {
        std::cout << description << std::endl;
        print80bpPerLineStdOut(std::cout, finalSequence);
    } else {
        string outFN = opt::out + ".joined.fa";
        std::ofstream* outFilteredFile = new std::ofstream(outFN.c_str());
        *outFilteredFile << description << std::endl;
        print80bpPerLineFile(outFilteredFile, finalSequence);
    }
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
callq 0x76f1c
movl $0x208, %edi            # imm = 0x208
callq 0x8490
movq %rax, %r14
movq 0x67f68(%rip), %rsi     # 0xdece0
pushq $0x8
popq %rdx
movq %rax, %rdi
callq 0x8890
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x80a0
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movl $0x1dcd6500, %edx       # imm = 0x1DCD6500
callq 0x76c88
cmpq $0x0, 0x67f4d(%rip)     # 0xded08
je 0x76e38
leaq 0x67f3c(%rip), %rsi     # 0xded00
leaq 0x2811d(%rip), %rdx     # 0x9eee8
leaq 0x68(%rsp), %rdi
callq 0x28806
movl $0x200, %edi            # imm = 0x200
callq 0x8490
movq %rax, %r14
movq 0x68(%rsp), %rsi
pushq $0x10
popq %rdx
movq %rax, %rdi
callq 0x84e0
movq %r14, (%rsp)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x8430
movq %rax, %rdi
callq 0x8230
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x8600
movq %rsp, %rdi
leaq 0x48(%rsp), %rsi
callq 0x42730
leaq 0x48(%rsp), %rdi
callq 0x8978
leaq 0x68(%rsp), %rdi
jmp 0x76e7f
movq 0x66179(%rip), %rdi     # 0xdcfb8
leaq 0x8(%rsp), %rsi
callq 0x8430
movq %rax, %rdi
callq 0x8230
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x8600
movq 0x6614e(%rip), %rdi     # 0xdcfb8
leaq 0x88(%rsp), %rsi
callq 0x426a5
leaq 0x88(%rsp), %rdi
callq 0x8978
leaq 0x28(%rsp), %rdi
callq 0x8978
leaq 0x8(%rsp), %rdi
callq 0x8978
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
jmp 0x76efb
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x8978
jmp 0x76ef6
movq %rax, %rbx
movl $0x200, %esi            # imm = 0x200
movq %r14, %rdi
callq 0x84a0
jmp 0x76ef6
jmp 0x76eee
jmp 0x76ed7
movq %rax, %rbx
jmp 0x76f0a
movq %rax, %rbx
movl $0x208, %esi            # imm = 0x208
movq %r14, %rdi
callq 0x84a0
jmp 0x76f14
movq %rax, %rbx
jmp 0x76f00
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x8978
leaq 0x28(%rsp), %rdi
callq 0x8978
leaq 0x8(%rsp), %rdi
callq 0x8978
movq %rbx, %rdi
callq 0x8870