LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: millanek[P]evo/./process_vcf_IUPAC.h
// Function: isDNAonly(char)
inline bool isDNAonly(char base) {
    bool DNAonly;
    switch (base)
    {
        case 'A': DNAonly = true; break;
        case 'C': DNAonly = true; break;
        case 'G': DNAonly = true; break;
        case 'T': DNAonly = true; break;
        default: DNAonly = false;
    }
    return DNAonly;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x13, %eax
ja 0x7a5e8
movq -0x10(%rbp), %rax
leaq 0xc0581(%rip), %rcx     # 0x13ab48
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x2(%rbp)
jmp 0x7a5ec
movb $0x1, -0x2(%rbp)
jmp 0x7a5ec
movb $0x1, -0x2(%rbp)
jmp 0x7a5ec
movb $0x1, -0x2(%rbp)
jmp 0x7a5ec
movb $0x0, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: millanek[P]evo/./process_vcf_IUPAC.h
// Function: returnHetIUPAC[abi:cxx11](char)
inline std::string returnHetIUPAC(char IUPACbase) {
    char firstBase; char secondBase;
    switch (std::toupper(IUPACbase))
    {
        case 'K': firstBase = 'T'; secondBase = 'G'; break;
        case 'M': firstBase = 'C'; secondBase = 'A'; break;
        case 'R': firstBase = 'G'; secondBase = 'A'; break;
        case 'S': firstBase = 'G'; secondBase = 'C'; break;
        case 'W': firstBase = 'T'; secondBase = 'A'; break;
        case 'Y': firstBase = 'T'; secondBase = 'C'; break;
        default: assert(false);
    }
    std::string bases = ""; bases = firstBase + secondBase;
    return bases;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %edi
callq 0xac90
addl $-0x4b, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0xe, %eax
ja 0x7a684
movq -0x28(%rbp), %rax
leaq 0xc0559(%rip), %rcx     # 0x13ab98
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x54, -0xa(%rbp)
movb $0x47, -0xb(%rbp)
jmp 0x7a6a3
movb $0x43, -0xa(%rbp)
movb $0x41, -0xb(%rbp)
jmp 0x7a6a3
movb $0x47, -0xa(%rbp)
movb $0x41, -0xb(%rbp)
jmp 0x7a6a3
movb $0x47, -0xa(%rbp)
movb $0x43, -0xb(%rbp)
jmp 0x7a6a3
movb $0x54, -0xa(%rbp)
movb $0x41, -0xb(%rbp)
jmp 0x7a6a3
movb $0x54, -0xa(%rbp)
movb $0x43, -0xb(%rbp)
jmp 0x7a6a3
leaq 0xbf032(%rip), %rdi     # 0x1396bd
leaq 0xc066c(%rip), %rsi     # 0x13acfe
movl $0x32, %edx
leaq 0xc0676(%rip), %rcx     # 0x13ad14
callq 0xa390
movb $0x0, -0xc(%rbp)
leaq -0xd(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xab60
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0xbb81c(%rip), %rsi     # 0x135edf
callq 0x2d6c0
jmp 0x7a6ca
leaq -0xd(%rbp), %rdi
callq 0xa640
movq -0x38(%rbp), %rdi
movzbl -0xa(%rbp), %eax
movzbl -0xb(%rbp), %ecx
addl %ecx, %eax
movsbl %al, %esi
callq 0xaa60
jmp 0x7a6eb
movb $0x1, -0xc(%rbp)
testb $0x1, -0xc(%rbp)
jne 0x7a72e
jmp 0x7a725
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0xa640
jmp 0x7a738
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xac88
jmp 0x7a738
movq -0x38(%rbp), %rdi
callq 0xac88
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: millanek[P]evo/process_vcf_join_multiFasta.cpp
// Function: processMultiFastaMain(int, char**)
int processMultiFastaMain(int argc, char** argv) {
    parseMultiFastaOptions(argc, argv);
    
    string allSequences = readMultiFastaToOneString(opt::fastaFile, 500000000);
    
    if (opt::out.empty()) {
        print80bpPerLineStdOut(std::cout, allSequences);
    } else {
        string outFN = opt::out + ".joined.fa";
        std::ofstream* outAncestralFile = new std::ofstream(outFN.c_str());
        print80bpPerLineFile(outAncestralFile, allSequences);
    }
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x7a9b0
leaq -0x30(%rbp), %rdi
leaq 0x11fe6f(%rip), %rsi    # 0x19a698
movl $0x1dcd6500, %edx       # imm = 0x1DCD6500
callq 0x81ca0
leaq 0x11fe7e(%rip), %rdi    # 0x19a6b8
callq 0xaa70
testb $0x1, %al
jne 0x7a845
jmp 0x7a89f
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa250
jmp 0x7a854
movq 0x11e75d(%rip), %rdi    # 0x198fb8
leaq -0x50(%rbp), %rsi
callq 0x81090
jmp 0x7a866
leaq -0x50(%rbp), %rdi
callq 0xac88
jmp 0x7a986
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7a99a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xac88
jmp 0x7a99a
leaq 0x11fe12(%rip), %rsi    # 0x19a6b8
leaq 0xc0731(%rip), %rdx     # 0x13afde
leaq -0x80(%rbp), %rdi
callq 0x3da80
jmp 0x7a8b8
movl $0x200, %edi            # imm = 0x200
callq 0xa5d0
movq %rax, -0xb0(%rbp)
jmp 0x7a8cb
leaq -0x80(%rbp), %rdi
callq 0xa220
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0xa650
jmp 0x7a8ea
movq -0xb0(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa250
jmp 0x7a90a
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x81170
jmp 0x7a91f
leaq -0xa8(%rbp), %rdi
callq 0xac88
leaq -0x80(%rbp), %rdi
callq 0xac88
jmp 0x7a986
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7a97b
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movl $0x200, %esi            # imm = 0x200
callq 0xa5e0
jmp 0x7a97b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xac88
leaq -0x80(%rbp), %rdi
callq 0xac88
jmp 0x7a99a
leaq -0x30(%rbp), %rdi
callq 0xac88
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0xac88
movq -0x58(%rbp), %rdi
callq 0xab50
nopl (%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: GeneralSetCounts::getSetVariantCountsSimple(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::map<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
void GeneralSetCounts::getSetVariantCountsSimple(const std::vector<std::string>& genotypes, const std::map<size_t, string>& posToSpeciesMap) {
    // std::cerr << fields[0] << "\t" << fields[1] << std::endl;
    getBasicCounts(genotypes, posToSpeciesMap);
    
    // Now fill in the allele frequencies
    for(std::map<string,int>::iterator it = setAltCounts.begin(); it != setAltCounts.end(); ++it) {
        if (setAlleleCounts.at(it->first) > 0) {
            setAAFs[it->first] = (double)setAltCounts.at(it->first)/setAlleleCounts.at(it->first);
        }
    }
}

// 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 %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7b270
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
callq 0x83230
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
callq 0x59dd0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x83260
testb $0x1, %al
jne 0x7b591
jmp 0x7b65a
movq -0x30(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x83290
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x83190
cmpl $0x0, (%rax)
jle 0x7b64a
movq -0x30(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x83290
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x83190
movq %rax, %rcx
movq -0x30(%rbp), %rax
cvtsi2sdl (%rcx), %xmm0
movsd %xmm0, -0x50(%rbp)
addq $0x68, %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x83290
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x83190
movsd -0x50(%rbp), %xmm0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cvtsi2sdl (%rcx), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0xe0, %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x83290
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x832b0
movsd -0x40(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0x7b64c
leaq -0x20(%rbp), %rdi
callq 0x5ac30
jmp 0x7b56a
addq $0x60, %rsp
popq %rbp
retq
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, 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 split(const std::string &s, char delim, std::vector<std::string> &elems) {
    std::stringstream ss(s);
    std::string item;
    while (std::getline(ss, item, delim)) {
        elems.push_back(item);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x83430
movq -0x1d8(%rbp), %rsi
movl %eax, %edx
leaq -0x1a0(%rbp), %rdi
callq 0xa9b0
leaq -0x1c0(%rbp), %rdi
callq 0xa820
movsbl -0x9(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0xaba0
movq %rax, -0x1e0(%rbp)
jmp 0x7b884
movq -0x1e0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa740
movb %al, -0x1e1(%rbp)
jmp 0x7b8a2
movb -0x1e1(%rbp), %al
testb $0x1, %al
jne 0x7b8ae
jmp 0x7b8ee
movq -0x18(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x48dc0
jmp 0x7b8c0
jmp 0x7b864
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0xac88
leaq -0x1a0(%rbp), %rdi
callq 0xa450
jmp 0x7b90f
leaq -0x1c0(%rbp), %rdi
callq 0xac88
leaq -0x1a0(%rbp), %rdi
callq 0xa450
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1c8(%rbp), %rdi
callq 0xab50
nopl (%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: splitToDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<double, std::allocator<double>>&)
void splitToDouble(const std::string &s, char delim, std::vector<double> &elems) {
    std::stringstream ss(s);
    std::string item;
    while (std::getline(ss, item, delim)) {
        elems.push_back(stringToDouble(item));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x200(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x83430
movq -0x200(%rbp), %rsi
movl %eax, %edx
leaq -0x1a0(%rbp), %rdi
callq 0xa9b0
leaq -0x1c0(%rbp), %rdi
callq 0xa820
movsbl -0x9(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0xaba0
movq %rax, -0x208(%rbp)
jmp 0x7b994
movq -0x208(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa740
movb %al, -0x209(%rbp)
jmp 0x7b9b2
movb -0x209(%rbp), %al
testb $0x1, %al
jne 0x7b9c1
jmp 0x7ba61
movq -0x18(%rbp), %rax
movq %rax, -0x218(%rbp)
leaq -0x1f8(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0xa250
jmp 0x7b9e1
leaq -0x1f8(%rbp), %rdi
callq 0x7bab0
movsd %xmm0, -0x220(%rbp)
jmp 0x7b9f7
movq -0x218(%rbp), %rdi
movsd -0x220(%rbp), %xmm0
movsd %xmm0, -0x1d8(%rbp)
leaq -0x1d8(%rbp), %rsi
callq 0x48450
jmp 0x7ba1c
leaq -0x1f8(%rbp), %rdi
callq 0xac88
jmp 0x7b974
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
jmp 0x7ba82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0xac88
jmp 0x7ba82
leaq -0x1c0(%rbp), %rdi
callq 0xac88
leaq -0x1a0(%rbp), %rdi
callq 0xa450
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
leaq -0x1c0(%rbp), %rdi
callq 0xac88
leaq -0x1a0(%rbp), %rdi
callq 0xa450
movq -0x1c8(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: stringToDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
double stringToDouble(std::string s) {
    double d;
    std::stringstream ss(s); //turn the string into a stream
    ss >> d; //convert
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x83430
movq -0x1b8(%rbp), %rsi
movl %eax, %edx
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0xa9b0
movq -0x1b0(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa4b0
jmp 0x7bb03
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x1c0(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xa450
movsd -0x1c0(%rbp), %xmm0
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xa450
movq -0x1a0(%rbp), %rdi
callq 0xab50
nopw (%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: initialize_matrix_double(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, int, int)
void initialize_matrix_double(std::vector<std::vector<double> >& m, int m_rows, int m_columns) {
    if (m_columns == 0)
        m_columns = m_rows;
    for (int i = 0; i < m_columns; i++) {
        std::vector<double> v(m_rows,0);
        m.push_back(v);
    }       
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x7bc7e
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x7bd1f
movslq -0xc(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x38(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x484d0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rcx
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x83450
jmp 0x7bcc5
leaq -0x39(%rbp), %rdi
callq 0x4a130
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x834d0
jmp 0x7bcdd
leaq -0x30(%rbp), %rdi
callq 0x3ecb0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7bc85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x4a130
jmp 0x7bd25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3ecb0
jmp 0x7bd25
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xab50
nop
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: initialize_matrix_int(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, int, int)
void initialize_matrix_int(std::vector<std::vector<int> >& m, int m_rows, int m_columns) {
    if (m_columns == 0)
        m_columns = m_rows;
    for (int i = 0; i < m_columns; i++) {
        std::vector<int> v(m_rows,0);
        m.push_back(v);
    }       
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x7bd4e
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x7bdee
movslq -0xc(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0x35(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x46300
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rcx
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rdx
callq 0x83540
jmp 0x7bd94
leaq -0x35(%rbp), %rdi
callq 0x483e0
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6ccd0
jmp 0x7bdac
leaq -0x30(%rbp), %rdi
callq 0x48290
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7bd55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x35(%rbp), %rdi
callq 0x483e0
jmp 0x7bdf4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x48290
jmp 0x7bdf4
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xab50
nopl (%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: stripPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string stripPath(const std::string& filename)
{
    size_t slashPos = filename.find_last_of('/');
    if(slashPos == std::string::npos)
        return filename; // no path
    else
        return filename.substr(slashPos+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0xabf0
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x7be4a
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa250
jmp 0x7be66
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
movq $-0x1, %rcx
callq 0xa5f0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: stripExtension(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string stripExtension(const std::string& filename)
{
    size_t suffixPos = filename.find_last_of('.');
    if(suffixPos == std::string::npos)
        return filename; // no suffix
    else
        return filename.substr(0, suffixPos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0xabf0
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x7beba
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa250
jmp 0x7becf
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0xa5f0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: isDPinfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isDPinfo (std::string infoField) {
    if (infoField.find("DP=") == string::npos)
        return false;
    else
        return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xbf370(%rip), %rsi     # 0x13b263
xorl %eax, %eax
movl %eax, %edx
callq 0xac50
cmpq $-0x1, %rax
jne 0x7bf08
movb $0x0, -0x1(%rbp)
jmp 0x7bf0c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: isFSinfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isFSinfo (std::string infoField) {
    if (infoField.find("FS=") == string::npos)
        return false;
    else
        return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xbf334(%rip), %rsi     # 0x13b267
xorl %eax, %eax
movl %eax, %edx
callq 0xac50
cmpq $-0x1, %rax
jne 0x7bf48
movb $0x0, -0x1(%rbp)
jmp 0x7bf4c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: isMQSBinfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isMQSBinfo (std::string infoField) {
    if (infoField.find("MQSB=") == string::npos)
        return false;
    else
        return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xbf2f8(%rip), %rsi     # 0x13b26b
xorl %eax, %eax
movl %eax, %edx
callq 0xac50
cmpq $-0x1, %rax
jne 0x7bf88
movb $0x0, -0x1(%rbp)
jmp 0x7bf8c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: isSGBinfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isSGBinfo (std::string infoField) {
    if (infoField.find("SGB=") == string::npos)
        return false;
    else
        return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xbf2be(%rip), %rsi     # 0x13b271
xorl %eax, %eax
movl %eax, %edx
callq 0xac50
cmpq $-0x1, %rax
jne 0x7bfc8
movb $0x0, -0x1(%rbp)
jmp 0x7bfcc
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: randomisePhase(char&, char&)
void randomisePhase(char& v1, char& v2) {
    if (v1 != v2) {
        char temp;
        double r = ((double) rand() / (RAND_MAX));
        if (r > 0.5) {
            temp = v1;
            v1 = v2; v2 = temp;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x7c70f
callq 0xa180
cvtsi2sd %eax, %xmm0
movsd 0xbea55(%rip), %xmm1    # 0x13b128
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0xb1a1f(%rip), %xmm1    # 0x12e108
ucomisd %xmm1, %xmm0
jbe 0x7c70d
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x7c70f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: MultiallelicCounts::getHeterozygosityThisVariant()
double MultiallelicCounts::getHeterozygosityThisVariant() {
    
    std::vector<int> nonMissingHets = individualsHets;
    nonMissingHets.erase(std::remove(nonMissingHets.begin(), nonMissingHets.end(), -1), nonMissingHets.end());
    
    int numNonMisInds = (int) nonMissingHets.size();
    int numHets = vector_sum(nonMissingHets);
    
    double hetThisVar = (double)numHets/(double)numNonMisInds;
    return hetThisVar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x4cf20
movq -0xa8(%rbp), %rdi
callq 0x46a90
movq -0xa8(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x46ac0
movq %rax, -0x40(%rbp)
movl $0xffffffff, -0x44(%rbp) # imm = 0xFFFFFFFF
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x44(%rbp), %rdx
callq 0x83840
movq %rax, -0xa0(%rbp)
jmp 0x7cb28
movq -0xa0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x83890
leaq -0x20(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x46ac0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x83890
movq -0xb8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x837b0
movq %rax, -0xb0(%rbp)
jmp 0x7cb7e
movq -0xb0(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x467f0
movq -0xc0(%rbp), %rsi
movl %eax, -0x74(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4cf20
jmp 0x7cbb1
leaq -0x90(%rbp), %rdi
callq 0x4ceb0
movsd %xmm0, -0xc8(%rbp)
jmp 0x7cbc7
movsd -0xc8(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0xd4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x48290
movl -0xd4(%rbp), %eax
movl %eax, -0x78(%rbp)
cvtsi2sdl -0x78(%rbp), %xmm0
cvtsi2sdl -0x74(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x98(%rbp)
movsd -0x98(%rbp), %xmm0
movsd %xmm0, -0xd0(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x48290
movsd -0xd0(%rbp), %xmm0
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x7cc54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x48290
leaq -0x20(%rbp), %rdi
callq 0x48290
movq -0x50(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: testOverallReadDepth(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool testOverallReadDepth(const int maxReadDepth,const int minReadDepth, const std::string& infoField) {
    std::vector<std::string> info = split(infoField, ';');
    if (info[0] == "INDEL") {
        split(info[1], '=', info);
    } else {
        split(info[0], '=', info);
    }
    int DP = atoi((info.back()).c_str());
    if (DP <= maxReadDepth && DP >= minReadDepth) { return true; }
    else { return false; }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0x3b, %edx
callq 0x7bbe0
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3d940
movq %rax, %rdi
leaq 0xb3633(%rip), %rsi     # 0x133782
callq 0x2d770
movb %al, -0x45(%rbp)
jmp 0x80159
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0x80162
jmp 0x801a0
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x1, %esi
callq 0x3d940
movq -0x58(%rbp), %rdx
movq %rax, %rdi
movl $0x3d, %esi
callq 0x7b810
jmp 0x80187
jmp 0x801c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3dfa0
jmp 0x8021e
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3d940
movq -0x60(%rbp), %rdx
movq %rax, %rdi
movl $0x3d, %esi
callq 0x7b810
jmp 0x801c4
jmp 0x801c6
leaq -0x30(%rbp), %rdi
callq 0x5fcc0
movq %rax, %rdi
callq 0xa220
movq %rax, %rdi
callq 0xa970
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x8(%rbp), %eax
jg 0x801ff
movl -0x40(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x801ff
movb $0x1, -0x1(%rbp)
movl $0x1, -0x44(%rbp)
jmp 0x8020a
movb $0x0, -0x1(%rbp)
movl $0x1, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3dfa0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xab50
nopw (%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: tabulateVector(std::vector<int, std::allocator<int>>&)
std::map<int, int> tabulateVector(std::vector<int>& vec) {
    std::vector<int> vecCopy(vec); 
    std::sort(vecCopy.begin(), vecCopy.end());
    std::vector<int>::iterator it = std::unique(vecCopy.begin(), vecCopy.end());
    vecCopy.resize(std::distance(vecCopy.begin(), it));
    
    std::map<int, int>  table;
    //int pos = 0;
    for (std::vector<int>::size_type i = 0; i != vecCopy.size(); i++) {
        int mycount = std::count(vec.begin(), vec.end(), vecCopy[i]);
        table[vecCopy[i]] = mycount;
        //pos = pos + mycount;
    }
    return table;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x4cf20
movq -0xa0(%rbp), %rdi
callq 0x46a90
movq -0xa0(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x46ac0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x83bb0
jmp 0x80417
leaq -0x28(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x46a90
movq -0xc0(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x46ac0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x83bf0
movq %rax, -0xb8(%rbp)
jmp 0x80451
movq -0xb8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x46a90
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x70630
movq %rax, -0xc8(%rbp)
jmp 0x80487
movq -0xc8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x83c30
jmp 0x80499
movq -0xb0(%rbp), %rdi
movb $0x0, -0x71(%rbp)
callq 0x83cc0
movq $0x0, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x467f0
movq %rax, %rcx
movq -0xd0(%rbp), %rax
cmpq %rcx, %rax
je 0x805aa
movq -0x10(%rbp), %rdi
callq 0x46a90
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0x46ac0
movq %rax, -0x98(%rbp)
movq -0x80(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4d100
movq %rax, %rdx
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x83ce0
movq %rax, -0xd8(%rbp)
jmp 0x80524
movq -0xd8(%rbp), %rax
movl %eax, -0x84(%rbp)
movl -0x84(%rbp), %eax
movl %eax, -0xe4(%rbp)
movq -0x80(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4d100
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
callq 0x83d30
movq %rax, -0xe0(%rbp)
jmp 0x80562
movq -0xe0(%rbp), %rax
movl -0xe4(%rbp), %ecx
movl %ecx, (%rax)
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x804b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x805d9
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x83e10
jmp 0x805d9
movb $0x1, -0x71(%rbp)
testb $0x1, -0x71(%rbp)
jne 0x805c0
movq -0xb0(%rbp), %rdi
callq 0x83e10
leaq -0x28(%rbp), %rdi
callq 0x48290
movq -0xa8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x48290
movq -0x40(%rbp), %rdi
callq 0xab50
nopl (%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: rearrange_doubletons(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
void rearrange_doubletons(std::vector<std::vector<int> >& doubletons){
    for (std::vector<std::vector<int> >::size_type i = 0; i < doubletons.size(); i++) {
        for (int j = 0; j < i; j++) {
            doubletons[i][j] = doubletons[i][j] + doubletons[j][i];
            doubletons[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 0x6d780
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x806da
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x806c7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x705d0
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4d100
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x705d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x4d100
movq %rax, %rcx
movl -0x28(%rbp), %eax
addl (%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x705d0
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4d100
movl -0x24(%rbp), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x705d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x4d100
movl $0x0, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8062c
jmp 0x806c9
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x80604
addq $0x30, %rsp
popq %rbp
retq
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: readSampleNamesFromTextFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<string> readSampleNamesFromTextFile(const std::string& sampleNameFile) {
    std::vector<string> sampleNames;
    std::ifstream* sampleFile = new std::ifstream(sampleNameFile.c_str());
    string line;
    while (getline(*sampleFile, line)) {
        sampleNames.push_back(line);
    }
    return sampleNames;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x48da0
movl $0x208, %edi            # imm = 0x208
callq 0xa5d0
movq %rax, -0x58(%rbp)
jmp 0x80ad7
movq -0x10(%rbp), %rdi
callq 0xa220
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0xab90
jmp 0x80af3
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa820
movq -0x20(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa0d0
movq %rax, -0x70(%rbp)
jmp 0x80b17
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa740
movb %al, -0x71(%rbp)
jmp 0x80b2f
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x80b38
jmp 0x80b8a
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x48dc0
jmp 0x80b47
jmp 0x80b04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x80bb3
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x208, %esi            # imm = 0x208
callq 0xa5e0
jmp 0x80bb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xac88
jmp 0x80bb3
movb $0x1, -0x11(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xac88
testb $0x1, -0x11(%rbp)
jne 0x80ba6
movq -0x68(%rbp), %rdi
callq 0x3dfa0
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3dfa0
movq -0x28(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: isGzip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool isGzip(const std::string& filename)
{
    size_t suffix_length = sizeof(GZIP_EXT) - 1;
    
    // Assume files without an extension are not compressed
    if(filename.length() < suffix_length)
        return false;
    
    std::string extension = suffix(filename, suffix_length);
    return extension == GZIP_EXT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq $0x3, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa930
cmpq -0x18(%rbp), %rax
jae 0x80c89
movb $0x0, -0x1(%rbp)
jmp 0x80cdd
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x80bd0
movq -0x50(%rbp), %rdi
leaq 0xb9f38(%rip), %rsi     # 0x13abe1
callq 0x2d770
movb %al, -0x45(%rbp)
jmp 0x80cb3
movb -0x45(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xac88
jmp 0x80cdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xac88
jmp 0x80ce8
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: createReader(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::_Ios_Openmode)
std::istream* createReader(const std::string& filename, std::ios_base::openmode mode)
{
    if(isGzip(filename))
    {
        igzstream* pGZ = new igzstream(filename.c_str(), mode);
        assertGZOpen(*pGZ, filename);
        return pGZ;
    }
    else
    {
        std::ifstream* pReader = new std::ifstream(filename.c_str(), mode);
        assertFileOpen(*pReader, filename);
        return pReader;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x80c60
testb $0x1, %al
jne 0x80e51
jmp 0x80edd
movl $0x2a0, %edi            # imm = 0x2A0
callq 0xa5d0
movq %rax, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa220
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
callq 0x83e30
jmp 0x80e7d
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x80dc0
movq -0x20(%rbp), %rcx
movq %rcx, -0x58(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x50(%rbp)
je 0x80eb4
movq -0x58(%rbp), %rax
addq $0x188, %rax            # imm = 0x188
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x80f44
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x2a0, %esi            # imm = 0x2A0
callq 0xa5e0
jmp 0x80f4e
movl $0x208, %edi            # imm = 0x208
callq 0xa5d0
movq %rax, -0x60(%rbp)
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa220
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
callq 0xab90
jmp 0x80f09
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x80d00
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x80f44
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x208, %esi            # imm = 0x208
callq 0xa5e0
jmp 0x80f4e
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xab50
nopw (%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: createWriter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::_Ios_Openmode)
std::ostream* createWriter(const std::string& filename,
                           std::ios_base::openmode mode)
{
    if(isGzip(filename))
    {
        ogzstream* pGZ = new ogzstream(filename.c_str(), mode);
        assertGZOpen(*pGZ, filename);
        return pGZ;
    }
    else
    {
        std::ofstream* pWriter = new std::ofstream(filename.c_str(), mode);
        assertFileOpen(*pWriter, filename);
        return pWriter;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x80c60
testb $0x1, %al
jne 0x80f81
jmp 0x8100d
movl $0x298, %edi            # imm = 0x298
callq 0xa5d0
movq %rax, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa220
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
callq 0x83f40
jmp 0x80fad
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x80dc0
movq -0x20(%rbp), %rcx
movq %rcx, -0x58(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x50(%rbp)
je 0x80fe4
movq -0x58(%rbp), %rax
addq $0x188, %rax            # imm = 0x188
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x81074
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x298, %esi            # imm = 0x298
callq 0xa5e0
jmp 0x8107e
movl $0x200, %edi            # imm = 0x200
callq 0xa5d0
movq %rax, -0x60(%rbp)
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa220
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
callq 0xa650
jmp 0x81039
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x80d60
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x81074
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x200, %esi            # imm = 0x200
callq 0xa5e0
jmp 0x8107e
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xab50
nopw (%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: complementIndices(unsigned long, std::vector<unsigned long, std::allocator<unsigned long>> const&)
std::vector<size_t> complementIndices(const size_t fullVectorSize, const std::vector<size_t>& originalIndices) {
    std::vector<size_t> indexComplement;
    std::vector<bool> isInOriginal(fullVectorSize, false);
    for (const size_t j : originalIndices) {
        isInOriginal[j] = true;
    }
    indexComplement.reserve(fullVectorSize - originalIndices.size());
    for (size_t i = 0; i < fullVectorSize; i++) {
        if (!isInOriginal[i])
        indexComplement.push_back(i);
    }
    return indexComplement;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x50c10
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movb $0x0, -0x49(%rbp)
leaq -0x4a(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x84110
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rcx
leaq -0x48(%rbp), %rdi
leaq -0x49(%rbp), %rdx
callq 0x84130
jmp 0x814fd
leaq -0x4a(%rbp), %rdi
callq 0x841a0
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x83b30
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0x83b60
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x83aa0
testb $0x1, %al
jne 0x8153e
jmp 0x815d7
leaq -0x70(%rbp), %rdi
callq 0x841c0
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x83940
movq %rdx, -0xd8(%rbp)
movq %rax, -0xd0(%rbp)
jmp 0x8156b
movq -0xd8(%rbp), %rax
movq -0xd0(%rbp), %rcx
movq %rcx, -0x90(%rbp)
movq %rax, -0x88(%rbp)
leaq -0x90(%rbp), %rdi
movl $0x1, %esi
callq 0x480d0
leaq -0x70(%rbp), %rdi
callq 0x841e0
jmp 0x81528
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x4a(%rbp), %rdi
callq 0x841a0
jmp 0x816ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x48270
jmp 0x816ce
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x83b90
movq -0xe0(%rbp), %rsi
movq -0xc8(%rbp), %rdi
subq %rax, %rsi
callq 0x84200
jmp 0x81603
movq $0x0, -0x98(%rbp)
movq -0x98(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x8169f
movq -0x98(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x83940
movq %rdx, -0xf0(%rbp)
movq %rax, -0xe8(%rbp)
jmp 0x8163f
movq -0xf0(%rbp), %rax
movq -0xe8(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movq %rax, -0xa0(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x481b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x8166f
jmp 0x81686
movq -0xc8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x840a0
jmp 0x81684
jmp 0x81686
jmp 0x81688
movq -0x98(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x98(%rbp)
jmp 0x8160e
movb $0x1, -0x19(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x48270
testb $0x1, -0x19(%rbp)
jne 0x816be
movq -0xc8(%rbp), %rdi
callq 0x50d40
movq -0xc0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0x50d40
movq -0x58(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: locateOneSample(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
size_t locateOneSample(std::vector<std::string>& sample_names, const std::string toFind) {
    size_t pos = 0;
    std::vector<std::string>::iterator it = std::find(sample_names.begin(), sample_names.end(), toFind);
    if (it == sample_names.end()) {
        std::cerr << "Did not find the sample: " << toFind << std::endl;
    } else {
        pos = std::distance(sample_names.begin(), it);
    }
    return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x44030
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x44060
movq -0x50(%rbp), %rdx
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x84050
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x44060
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x83a10
testb $0x1, %al
jne 0x8175b
jmp 0x8178b
movq 0x11788e(%rip), %rdi    # 0x198ff0
leaq 0xb9ca8(%rip), %rsi     # 0x13b411
callq 0xa5c0
movq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0xa520
movq %rax, %rdi
movq 0x117804(%rip), %rsi    # 0x198f88
callq 0xa610
jmp 0x817b1
movq -0x8(%rbp), %rdi
callq 0x44030
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x75450
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: readMultiFastaToOneString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
std::string readMultiFastaToOneString(const string& fileName, int bytes) {
    std::string fastaSeqs; fastaSeqs.reserve(bytes); fastaSeqs = "";
    string line;
    std::ifstream* fastaFile = new std::ifstream(fileName.c_str());
    getline(*fastaFile, line);
    string currentScaffold = line.substr(1,string::npos);
    while (getline(*fastaFile, line)) {
        if (line[0] != '>') {
            fastaSeqs.append(line);
        } else {
            continue;
        }
    }
    return fastaSeqs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0xa820
movq -0x78(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0xa980
jmp 0x81cd9
movq -0x78(%rbp), %rdi
leaq 0xb41fb(%rip), %rsi     # 0x135edf
callq 0xa810
jmp 0x81ceb
leaq -0x48(%rbp), %rdi
callq 0xa820
movl $0x208, %edi            # imm = 0x208
callq 0xa5d0
movq %rax, -0x88(%rbp)
jmp 0x81d07
movq -0x10(%rbp), %rdi
callq 0xa220
movq -0x88(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0xab90
jmp 0x81d26
movq -0x88(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xa0d0
jmp 0x81d40
leaq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0x1, %edx
movq $-0x1, %rcx
callq 0xa5f0
jmp 0x81d5b
jmp 0x81d5d
movq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xa0d0
movq %rax, -0x90(%rbp)
jmp 0x81d73
movq -0x90(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa740
movb %al, -0x91(%rbp)
jmp 0x81d91
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x81da0
jmp 0x81e35
xorl %eax, %eax
movl %eax, %esi
leaq -0x48(%rbp), %rdi
callq 0xac60
movq %rax, -0xa0(%rbp)
jmp 0x81db6
movq -0xa0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3e, %eax
je 0x81e2b
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xac20
jmp 0x81dd4
jmp 0x81e30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x81e74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x81e53
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x208, %esi            # imm = 0x208
callq 0xa5e0
jmp 0x81e53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xac88
jmp 0x81e53
jmp 0x81d5d
jmp 0x81d5d
movb $0x1, -0x15(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xac88
leaq -0x48(%rbp), %rdi
callq 0xac88
testb $0x1, -0x15(%rbp)
jne 0x81e67
jmp 0x81e5e
leaq -0x48(%rbp), %rdi
callq 0xac88
jmp 0x81e74
movq -0x78(%rbp), %rdi
callq 0xac88
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0xac88
movq -0x20(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
// File: millanek[P]evo/process_vcf_utils.cpp
// Function: GeneralSetCounts::returnFormatTagPosition(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int GeneralSetCounts::returnFormatTagPosition(std::vector<std::string>& format, const std::string& tag) {
    // Find the position of GQ (genotype quality) in the genotypeData vector below
    std::vector<std::string>::iterator TAGit; int TAGi = std::numeric_limits<int>::min();
    TAGit = find (format.begin(), format.end(), tag);
    if (TAGit == format.end()) {
        // std::cerr << "This variant hasn't got associated per-sample GQ info" << std::endl;
    } else {
        TAGi = (int)std::distance( format.begin(), TAGit );
        //hasGQ = true;
    }
    return TAGi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x839a0
callq 0x353a0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44030
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44060
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x84050
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44060
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x83a10
testb $0x1, %al
jne 0x82d5c
jmp 0x82d5e
jmp 0x82d83
movq -0x10(%rbp), %rdi
callq 0x44030
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x75450
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)