LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_sort.cpp
// Function: BamTools::SortTool::SortToolPrivate::SortBuffer(std::vector<BamTools::BamAlignment, std::allocator<BamTools::BamAlignment>>&)
void SortTool::SortToolPrivate::SortBuffer(vector<BamAlignment>& buffer) {
 
    // ** add further custom sort options later ?? **
    
    // sort buffer by desired method
    if ( m_settings->IsSortingByName )
        std::stable_sort( buffer.begin(), buffer.end(), Sort::ByName() );
    else
        std::stable_sort( buffer.begin(), buffer.end(), Sort::ByPosition() );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rax
movq (%rsi), %r14
movq 0x8(%rsi), %rbx
cmpb $0x1, 0x4(%rax)
jne 0x4e2f2
cmpq %rbx, %r14
je 0x4e375
movq %rbx, %rax
subq %r14, %rax
sarq $0x3, %rax
movabsq $-0x7d05f417d05f417d, %rcx # imm = 0x82FA0BE82FA0BE83
imulq %rax, %rcx
leaq 0x1(%rcx), %rax
shrq $0x3f, %rax
leaq (%rcx,%rax), %rdx
incq %rdx
sarq %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f50c
movq 0x10(%r15), %rdx
testq %rdx, %rdx
je 0x4e34f
movq 0x10(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0x4f633
jmp 0x4e36b
cmpq %rbx, %r14
je 0x4e375
movq %rbx, %rax
subq %r14, %rax
sarq $0x3, %rax
movabsq $-0x7d05f417d05f417d, %rcx # imm = 0x82FA0BE82FA0BE83
imulq %rax, %rcx
leaq 0x1(%rcx), %rax
shrq $0x3f, %rax
leaq (%rcx,%rax), %rdx
incq %rdx
sarq %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f50c
movq 0x10(%r15), %rdx
testq %rdx, %rdx
je 0x4e35e
movq 0x10(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0x518fb
jmp 0x4e36b
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4f58d
jmp 0x4e36b
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x51855
leaq 0x8(%rsp), %rdi
callq 0x4f722
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4f722
jmp 0x4e39d
jmp 0x4e3a5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4f722
movq %rbx, %rdi
callq 0x27b10
movq %rax, %rdi
callq 0x2e1cd
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_sort.cpp
// Function: BamTools::SortTool::SortToolPrivate::WriteTempFile(std::vector<BamTools::BamAlignment, std::allocator<BamTools::BamAlignment>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool SortTool::SortToolPrivate::WriteTempFile(const vector<BamAlignment>& buffer,
                                              const string& tempFilename)
{
    // open temp file for writing
    BamWriter tempWriter;
    if ( !tempWriter.Open(tempFilename, m_headerText, m_references) ) {
        cerr << "bamtools sort ERROR: could not open " << tempFilename
             << " for writing." << endl;
        return false;
    }
  
    // write data
    vector<BamAlignment>::const_iterator buffIter = buffer.begin();
    vector<BamAlignment>::const_iterator buffEnd  = buffer.end();
    for ( ; buffIter != buffEnd; ++buffIter )  {
        const BamAlignment& al = (*buffIter);
        tempWriter.SaveAlignment(al);
    }
  
    // close temp file & return success
    tempWriter.Close();
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x27360
leaq 0x30(%rbx), %rdx
addq $0x50, %rbx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x279a0
movl %eax, %ebx
testb %al, %al
je 0x4e416
movq (%r15), %r14
movq 0x8(%r15), %r12
cmpq %r12, %r14
je 0x4e40c
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x27bd0
addq $0x158, %r14            # imm = 0x158
cmpq %r12, %r14
jne 0x4e3f5
movq %rsp, %rdi
callq 0x27370
jmp 0x4e47f
movq 0x40bc3(%rip), %rdi     # 0x8efe0
leaq 0x266fb(%rip), %rsi     # 0x74b1f
movl $0x24, %edx
callq 0x276b0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x40ba4(%rip), %rdi     # 0x8efe0
callq 0x276b0
movq %rax, %r14
leaq 0x23a25(%rip), %rsi     # 0x71e70
movl $0xd, %edx
movq %rax, %rdi
callq 0x276b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x27590
movsbl %al, %esi
movq %r14, %rdi
callq 0x27040
movq %rax, %rdi
callq 0x27410
movq %rsp, %rdi
callq 0x27430
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4e499
jmp 0x4e499
movq %rax, %rbx
movq %rsp, %rdi
callq 0x27430
movq %rbx, %rdi
callq 0x27b10
movq %rax, %rdi
callq 0x2e1cd
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_sort.cpp
// Function: BamTools::SortTool::~SortTool()
SortTool::~SortTool(void) {

    delete m_settings;
    m_settings = 0;

    delete m_impl;
    m_impl = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3fcbc(%rip), %rax     # 0x8eb50
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x4eec4
movq 0x28(%r14), %rdi
leaq 0x38(%r14), %rax
cmpq %rax, %rdi
je 0x4eeb2
callq 0x27560
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x4eec4
callq 0x27560
movq %r14, %rdi
callq 0x27560
movq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x4eee5
movq %r14, %rdi
callq 0x4f18c
movq %r14, %rdi
callq 0x27560
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_sort.cpp
// Function: BamTools::SortTool::Run(int, char**)
int SortTool::Run(int argc, char* argv[]) {

    // parse command line arguments
    Options::Parse(argc, argv, 1);

    // initialize SortTool with settings
    m_impl = new SortToolPrivate(m_settings);

    // run SortTool, return success/fail
    if ( m_impl->Run() )
        return 0;
    else
        return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl $0x1, %ebx
movl %esi, %edi
movq %rdx, %rsi
movl $0x1, %edx
callq 0x63ac2
movl $0x80, %edi
callq 0x275c0
movq %rax, %r14
movq 0x8(%r15), %rsi
movq %rax, %rdi
callq 0x4dce4
movq %r14, 0x10(%r15)
movq %r14, %rdi
callq 0x4de02
testb %al, %al
je 0x4ef9a
movq %r14, %rdi
callq 0x4e4b4
xorb $0x1, %al
movzbl %al, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_split.cpp
// Function: BamTools::GetTimestampString[abi:cxx11]()
string GetTimestampString(void) {

    // get human readable timestamp
    time_t currentTime;
    time(&currentTime);
    stringstream timeStream("");
    timeStream << ctime(&currentTime);

    // convert whitespace to '_'
    string timeString = timeStream.str();
    size_t found = timeString.find(" ");
    while (found != string::npos) {
        timeString.replace(found, 1, "_");
        found = timeString.find(" ", found+1);
    }
    return timeString;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x27530
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x236d8(%rip), %rdx     # 0x76817
leaq 0x10(%rsp), %rdi
movq %rdx, %rsi
callq 0x2f1a0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x18, %edx
callq 0x279b0
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x5316f
callq 0x27560
leaq 0x40(%rsp), %r14
leaq 0x8(%rsp), %rdi
callq 0x27280
testq %rax, %rax
je 0x5319e
movq %rax, %r15
movq %rax, %rdi
callq 0x272f0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x276b0
jmp 0x531b9
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
addq %rax, %r14
movl 0x60(%rsp,%rax), %esi
orl $0x1, %esi
movq %r14, %rdi
callq 0x27a70
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x27990
leaq 0x22326(%rip), %rsi     # 0x754f3
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x27ad0
movq %rax, %r14
leaq 0x21b0e(%rip), %r15     # 0x74cf4
leaq 0x22306(%rip), %r12     # 0x754f3
cmpq $-0x1, %r14
je 0x53227
movl $0x1, %edx
movl $0x1, %r8d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x27680
incq %r14
movl $0x1, %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x27ad0
movq %rax, %r14
jmp 0x531ed
leaq 0x30(%rsp), %rdi
callq 0x27490
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x53263
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x53281
callq 0x27560
jmp 0x53281
movq %rax, %r14
jmp 0x53281
movq %rax, %r14
jmp 0x53277
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x53277
callq 0x27560
leaq 0x30(%rsp), %rdi
callq 0x27490
movq %r14, %rdi
callq 0x27b10
movq %rax, %rdi
callq 0x2e1cd
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_split.cpp
// Function: BamTools::SplitTool::SplitToolPrivate::DetermineOutputFilenameStub()
void SplitTool::SplitToolPrivate::DetermineOutputFilenameStub(void) {
  
    // if user supplied output filename stub, use that
    if ( m_settings->HasCustomOutputStub ) 
        m_outputFilenameStub = m_settings->CustomOutputStub;
    
    // else if user supplied input BAM filename, use that (minus ".bam" extension) as stub
    else if ( m_settings->HasInputFilename )
        m_outputFilenameStub = RemoveFilenameExtension(m_settings->InputFilename);
        
    // otherwise, user did not specify -stub, and input is coming from STDIN
    // generate stub from timestamp
    else m_outputFilenameStub = GetTimestampString();      
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
cmpb $0x1, 0x1(%r14)
jne 0x53304
addq $0x10, %r14
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x27350
cmpb $0x1, (%r14)
jne 0x5334d
addq $0x70, %r14
leaq 0x22e4c(%rip), %rsi     # 0x76161
movl $0x1, %ecx
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x27800
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x27600
addq $0x8, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x27350
jmp 0x53367
movq %rsp, %r14
movq %r14, %rdi
callq 0x53114
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27350
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5337a
callq 0x27560
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x53386
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5339c
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_split.cpp
// Function: BamTools::SplitTool::SplitToolPrivate::OpenReader()
bool SplitTool::SplitToolPrivate::OpenReader(void) {

    // attempt to open BAM file
    if ( !m_reader.Open(m_settings->InputFilename) ) {
        cerr << "bamtools split ERROR: could not open BAM file: " << m_settings->InputFilename << endl;
        return false;
    }

    // save file 'metadata' & return success
    m_header     = m_reader.GetHeaderText();
    m_references = m_reader.GetReferenceData();
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x28(%rdi), %r15
movq (%rdi), %rsi
addq $0x70, %rsi
movq %r15, %rdi
callq 0x27790
movl %eax, %ebx
testb %al, %al
je 0x53413
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x27200
leaq 0x30(%r14), %rdi
movq %r12, %rsi
callq 0x27350
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x533fa
callq 0x27560
movq %r15, %rdi
callq 0x27090
addq $0x50, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2e1d8
jmp 0x5346b
movq 0x3bbc6(%rip), %r15     # 0x8efe0
leaq 0x218db(%rip), %rsi     # 0x74cfc
movl $0x2f, %edx
movq %r15, %rdi
callq 0x276b0
movq (%r14), %rax
movq 0x70(%rax), %rsi
movq 0x78(%rax), %rdx
movq %r15, %rdi
callq 0x276b0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x27590
movsbl %al, %esi
movq %r14, %rdi
callq 0x27040
movq %rax, %rdi
callq 0x27410
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5348f
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_split.cpp
// Function: BamTools::SplitTool::SplitToolPrivate::Run()
bool SplitTool::SplitToolPrivate::Run(void) {
  
    // determine output stub
    DetermineOutputFilenameStub();

    // open up BamReader
    if ( !OpenReader() )
        return false;
    
    // determine split type from settings
    if ( m_settings->IsSplittingMapped )    return SplitMapped();
    if ( m_settings->IsSplittingPaired )    return SplitPaired();
    if ( m_settings->IsSplittingReference ) return SplitReference();
    if ( m_settings->IsSplittingTag )       return SplitTag();

    // if we get here, no property was specified 
    cerr << "bamtools split ERROR: no property given to split on... " << endl
         << "Please use -mapped, -paired, -reference, or -tag TAG to specify desired split behavior." << endl;
    return false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x532d2
movq %rbx, %rdi
callq 0x533a4
testb %al, %al
je 0x53570
movq (%rbx), %rax
cmpb $0x1, 0x5(%rax)
jne 0x534c3
movq %rbx, %rdi
popq %rbx
jmp 0x53574
cmpb $0x1, 0x6(%rax)
jne 0x534d2
movq %rbx, %rdi
popq %rbx
jmp 0x5387c
cmpb $0x1, 0x7(%rax)
jne 0x534e1
movq %rbx, %rdi
popq %rbx
jmp 0x53b84
cmpb $0x1, 0x8(%rax)
jne 0x534f0
movq %rbx, %rdi
popq %rbx
jmp 0x540be
movq 0x3bae9(%rip), %rbx     # 0x8efe0
leaq 0x2182e(%rip), %rsi     # 0x74d2c
movl $0x37, %edx
movq %rbx, %rdi
callq 0x276b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x27590
movsbl %al, %esi
movq %rbx, %rdi
callq 0x27040
movq %rax, %rdi
callq 0x27410
movq %rax, %rbx
leaq 0x21828(%rip), %rsi     # 0x74d64
movl $0x57, %edx
movq %rax, %rdi
callq 0x276b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x27590
movsbl %al, %esi
movq %rbx, %rdi
callq 0x27040
movq %rax, %rdi
callq 0x27410
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_split.cpp
// Function: BamTools::SplitTool::~SplitTool()
SplitTool::~SplitTool(void) {
    
    delete m_settings;
    m_settings = 0;
    
    delete m_impl;
    m_impl = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x39ea0(%rip), %rax     # 0x8eb98
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x54d7f
movq 0xb0(%r14), %rdi
leaq 0xc0(%r14), %rax
cmpq %rax, %rdi
je 0x54d1c
callq 0x27560
movq 0x90(%r14), %rdi
leaq 0xa0(%r14), %rax
cmpq %rax, %rdi
je 0x54d34
callq 0x27560
movq 0x70(%r14), %rdi
leaq 0x80(%r14), %rax
cmpq %rax, %rdi
je 0x54d49
callq 0x27560
movq 0x50(%r14), %rdi
leaq 0x60(%r14), %rax
cmpq %rax, %rdi
je 0x54d5b
callq 0x27560
movq 0x30(%r14), %rdi
leaq 0x40(%r14), %rax
cmpq %rax, %rdi
je 0x54d6d
callq 0x27560
movq 0x10(%r14), %rdi
leaq 0x20(%r14), %rax
cmpq %rax, %rdi
je 0x54d7f
callq 0x27560
movq %r14, %rdi
callq 0x27560
movq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x54da0
movq %r14, %rdi
callq 0x5c858
movq %r14, %rdi
callq 0x27560
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_split.cpp
// Function: BamTools::SplitTool::Run(int, char**)
int SplitTool::Run(int argc, char* argv[]) {
  
    // parse command line arguments
    Options::Parse(argc, argv, 1);
    
    // initialize SplitTool with settings
    m_impl = new SplitToolPrivate(m_settings);
    
    // run SplitTool, return success/fail
    if ( m_impl->Run() ) 
        return 0;
    else 
        return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %edi
movq %rdx, %rsi
movl $0x1, %edx
callq 0x63ac2
movl $0x68, %edi
callq 0x275c0
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x5c8fe
movq %r14, 0x10(%rbx)
movq %r14, %rdi
callq 0x53498
xorb $0x1, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_split.cpp
// Function: void BamTools::SplitTool::SplitToolPrivate::CloseWriters<bool>(std::map<bool, BamTools::BamWriter*, std::less<bool>, std::allocator<std::pair<bool const, BamTools::BamWriter*>>>&)
void SplitTool::SplitToolPrivate::CloseWriters(map<T, BamWriter*>& writers) {
  
    typedef map<T, BamWriter*> WriterMap;
    typedef typename WriterMap::iterator WriterMapIterator;
  
    // iterate over writers
    WriterMapIterator writerIter = writers.begin();
    WriterMapIterator writerEnd  = writers.end();
    for ( ; writerIter != writerEnd; ++writerIter ) {
        BamWriter* writer = (*writerIter).second;
        if ( writer == 0 ) continue;

        // close BamWriter
        writer->Close();

        // destroy BamWriter
        delete writer;
        writer = 0;
    }

    // clear the container (destroying the items doesn't remove them)
    writers.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rsi), %r14
leaq 0x8(%rsi), %r12
cmpq %r12, %r14
je 0x54ea9
movq 0x28(%r14), %r15
testq %r15, %r15
je 0x54e99
movq %r15, %rdi
callq 0x27370
movq %r15, %rdi
callq 0x27430
movq %r15, %rdi
callq 0x27560
movq %r14, %rdi
callq 0x27420
movq %rax, %r14
cmpq %r12, %rax
jne 0x54e78
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x5c962
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq %r12, 0x18(%rbx)
movq %r12, 0x20(%rbx)
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_stats.cpp
// Function: BamTools::StatsTool::StatsToolPrivate::ProcessAlignment(BamTools::BamAlignment const&)
void StatsTool::StatsToolPrivate::ProcessAlignment(const BamAlignment& al) {
  
    // increment total alignment counter
    ++m_numReads;
    
    // incrememt counters for pairing-independent flags
    if ( al.IsDuplicate() ) ++m_numDuplicates;
    if ( al.IsFailedQC()  ) ++m_numFailedQC;
    if ( al.IsMapped()    ) ++m_numMapped;
    
    // increment strand counters
    if ( al.IsReverseStrand() ) 
        ++m_numReverseStrand;
    else 
        ++m_numForwardStrand;
    
    // if alignment is paired-end
    if ( al.IsPaired() ) {
      
        // increment PE counter
        ++m_numPaired;
      
        // increment first mate/second mate counters
        if ( al.IsFirstMate()  ) ++m_numFirstMate;
        if ( al.IsSecondMate() ) ++m_numSecondMate;
        
        // if alignment is mapped, check mate status
        if ( al.IsMapped() ) {
            // if mate mapped
            if ( al.IsMateMapped() ) 
                ++m_numBothMatesMapped;
            // else singleton
            else 
                ++m_numSingletons;
        }
        
        // check for explicit proper pair flag
        if ( al.IsProperPair() )
            ++m_numProperPair;
        
        // store insert size for first mate 
        if ( m_settings->IsShowingInsertSizeSummary && al.IsFirstMate() && (al.InsertSize != 0) ) {
            int insertSize = abs(al.InsertSize);
            m_insertSizes.push_back( insertSize );
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
incl 0x8(%rdi)
movq %rsi, %rdi
callq 0x27b80
testb %al, %al
je 0x60218
incl 0x34(%rbx)
movq %r14, %rdi
callq 0x27630
testb %al, %al
je 0x60227
incl 0x30(%rbx)
movq %r14, %rdi
callq 0x270d0
testb %al, %al
je 0x60236
incl 0x14(%rbx)
movq %r14, %rdi
callq 0x277f0
testb %al, %al
je 0x60247
incl 0x20(%rbx)
jmp 0x6024a
incl 0x1c(%rbx)
movq %r14, %rdi
callq 0x27330
testb %al, %al
je 0x602fc
incl 0xc(%rbx)
movq %r14, %rdi
callq 0x272e0
testb %al, %al
je 0x6026c
incl 0x24(%rbx)
movq %r14, %rdi
callq 0x27b60
testb %al, %al
je 0x6027b
incl 0x28(%rbx)
movq %r14, %rdi
callq 0x270d0
testb %al, %al
je 0x6029b
movq %r14, %rdi
callq 0x276e0
testb %al, %al
je 0x60298
incl 0x18(%rbx)
jmp 0x6029b
incl 0x2c(%rbx)
movq %r14, %rdi
callq 0x27bf0
testb %al, %al
je 0x602aa
incl 0x10(%rbx)
movq (%rbx), %rax
cmpb $0x1, 0x2(%rax)
jne 0x602fc
movq %r14, %rdi
callq 0x272e0
testb %al, %al
je 0x602fc
movl 0xd8(%r14), %ecx
testl %ecx, %ecx
je 0x602fc
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
movl %eax, 0x4(%rsp)
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x602eb
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x40(%rbx)
jmp 0x602fc
addq $0x38, %rbx
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x4b9cc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_stats.cpp
// Function: BamTools::StatsTool::~StatsTool()
StatsTool::~StatsTool(void) {

    delete m_settings;
    m_settings = 0;
    
    delete m_impl;
    m_impl = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2e176(%rip), %rax     # 0x8ebe0
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x60a91
movq 0x20(%r14), %rdi
leaq 0x30(%r14), %rax
cmpq %rax, %rdi
je 0x60a88
callq 0x27560
leaq 0x8(%r14), %rdi
callq 0x2f0c0
movq %r14, %rdi
callq 0x27560
movq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x60ab8
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x60ab8
callq 0x27560
movq %r14, %rdi
callq 0x27560
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_stats.cpp
// Function: BamTools::StatsTool::Run(int, char**)
int StatsTool::Run(int argc, char* argv[]) {
  
    // parse command line arguments
    Options::Parse(argc, argv, 1);
    
    // initialize StatsTool with settings
    m_impl = new StatsToolPrivate(m_settings);
    
    // run StatsTool, return success/fail
    if ( m_impl->Run() )
        return 0;
    else
        return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %edi
movq %rdx, %rsi
movl $0x1, %edx
callq 0x63ac2
movl $0x50, %edi
callq 0x275c0
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x5f7c0
movq %r14, 0x10(%rbx)
movq %r14, %rdi
callq 0x60304
xorb $0x1, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/toolkit/bamtools.cpp
// Function: main
int main(int argc, char* argv[]) {

    // just 'bamtools'
    if ( argc == 1 ) return Help(argc, argv);
    
    // 'bamtools help', 'bamtools --help', or 'bamtools -h'
    if ( IsHelp(argv[1]) ) return Help(argc, argv); 
    
    // 'bamtools version', 'bamtools --version', or 'bamtools -v'
    if ( IsVersion(argv[1]) ) return Version(); 
        
    // determine desired sub-tool, run if found
    AbstractTool* tool = CreateTool( argv[1] );
    if ( tool ) return tool->Run(argc, argv);

    // no tool matched, show help
    return Help(argc, argv);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
cmpl $0x1, %edi
jne 0x61733
movl $0x1, %edi
jmp 0x6180a
movl %edi, %ebp
movq 0x8(%rbx), %r14
leaq 0x2edd8(%rip), %rdi     # 0x90518
movq %r14, %rsi
callq 0x271c0
testl %eax, %eax
je 0x61808
leaq 0x2ede1(%rip), %rdi     # 0x90538
movq %r14, %rsi
callq 0x271c0
testl %eax, %eax
je 0x61808
leaq 0x2edea(%rip), %rdi     # 0x90558
movq %r14, %rsi
callq 0x271c0
testl %eax, %eax
je 0x61808
movq 0x8(%rbx), %r14
leaq 0x2edef(%rip), %rdi     # 0x90578
movq %r14, %rsi
callq 0x271c0
testl %eax, %eax
je 0x6181a
leaq 0x2edf8(%rip), %rdi     # 0x90598
movq %r14, %rsi
callq 0x271c0
testl %eax, %eax
je 0x6181a
leaq 0x2ee05(%rip), %rdi     # 0x905b8
movq %r14, %rsi
callq 0x271c0
testl %eax, %eax
je 0x6181a
movq 0x8(%rbx), %rsi
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x272a0
movq %r14, %rdi
callq 0x60c94
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x617f3
callq 0x27560
testq %r14, %r14
je 0x6182a
movq (%r14), %rax
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq *0x18(%rax)
jmp 0x61821
movl %ebp, %edi
movq %rbx, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x60fb1
callq 0x6147b
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl %ebp, %edi
movq %rbx, %rsi
callq 0x60fb1
jmp 0x61821
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6184c
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/utils/bamtools_fasta.cpp
// Function: BamTools::Fasta::FastaPrivate::Close()
bool Fasta::FastaPrivate::Close(void) {
 
    // close fasta file
    if ( IsOpen ) {
        fclose(Stream);
        IsOpen = false;
    }

    // close index file
    if ( HasIndex && IsIndexOpen ) {
        fclose(IndexStream);
        HasIndex = false;
        IsIndexOpen = false;
    }
  
    // return success
    return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x6189a
movq (%rbx), %rdi
callq 0x275b0
movb $0x0, 0x8(%rbx)
cmpb $0x1, 0x18(%rbx)
jne 0x618b5
cmpb $0x1, 0x19(%rbx)
jne 0x618b5
movq 0x10(%rbx), %rdi
callq 0x275b0
movw $0x0, 0x18(%rbx)
movb $0x1, %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/utils/bamtools_fasta.cpp
// Function: BamTools::Fasta::FastaPrivate::Chomp(char*)
void Fasta::FastaPrivate::Chomp(char* sequence) {
  
    static const int CHAR_LF = 10;
    static const int CHAR_CR = 13;
  
    int seqLength = strlen(sequence);
    if ( seqLength == 0 ) return;
    --seqLength; // ignore null terminator
  
    while ( sequence[seqLength] == CHAR_LF || 
            sequence[seqLength] == CHAR_CR 
          ) 
    {
        sequence[seqLength] = 0;
        --seqLength;
        if (seqLength < 0) 
            break;
    }
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x272f0
testl %eax, %eax
je 0x618ec
cltq
incq %rax
movzbl -0x2(%rbx,%rax), %ecx
cmpl $0xd, %ecx
je 0x618de
cmpl $0xa, %ecx
jne 0x618ec
movb $0x0, -0x2(%rbx,%rax)
decq %rax
cmpq $0x1, %rax
jg 0x618cf
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/utils/bamtools_fasta.cpp
// Function: BamTools::Fasta::FastaPrivate::GetNextHeader(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool Fasta::FastaPrivate::GetNextHeader(string& header) {
  
    // validate input stream
    if ( !IsOpen || feof(Stream) ) 
        return false;
    
    // read in header line
    char buffer[1024];
    if ( fgets(buffer, 1024, Stream) == 0 ) {
        cerr << "FASTA error : could not read from file" << endl;
        return false;
    }
    
    // make sure it's a FASTA header
    if ( buffer[0] != '>' ) { 
        cerr << "FASTA error : expected header ('>'), instead : " << buffer[0] << endl;
        return false;
    }
  
    // import buffer contents to header string
    stringstream headerBuffer("");
    headerBuffer << buffer;
    header = headerBuffer.str();
  
    // return success
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x5b8, %rsp            # imm = 0x5B8
cmpb $0x1, 0x8(%rdi)
jne 0x61ea6
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x27900
testl %eax, %eax
jne 0x61ea6
movq (%r14), %rdx
leaq 0x1b0(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x27970
testq %rax, %rax
je 0x61e26
cmpb $0x3e, 0x1b0(%rsp)
jne 0x61e46
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x14a80(%rip), %rdx     # 0x76817
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x2f1a0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x18, %edx
callq 0x279b0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x61dc7
callq 0x27560
leaq 0x38(%rsp), %r14
leaq 0x1b0(%rsp), %r15
movq %r15, %rdi
callq 0x272f0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x276b0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x27990
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x27350
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x61e15
callq 0x27560
leaq 0x28(%rsp), %rdi
callq 0x27490
movb $0x1, %al
jmp 0x61ea8
movq 0x2d1b3(%rip), %rbx     # 0x8efe0
leaq 0x13dc1(%rip), %rsi     # 0x75bf5
movl $0x26, %edx
movq %rbx, %rdi
callq 0x276b0
movq (%rbx), %rax
jmp 0x61e82
movq 0x2d193(%rip), %rbx     # 0x8efe0
leaq 0x13dc8(%rip), %rsi     # 0x75c1c
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x276b0
movb 0x1b0(%rsp), %al
leaq 0x28(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x276b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x27590
movsbl %al, %esi
movq %rbx, %rdi
callq 0x27040
movq %rax, %rdi
callq 0x27410
xorl %eax, %eax
addq $0x5b8, %rsp            # imm = 0x5B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x61ed0
callq 0x27560
jmp 0x61ed0
jmp 0x61ecd
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x27490
jmp 0x61ef3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x61ef3
callq 0x27560
jmp 0x61ef3
movq %rax, %rbx
movq %rbx, %rdi
callq 0x27b10
movq %rax, %rdi
callq 0x2e1cd
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/utils/bamtools_fasta.cpp
// Function: BamTools::Fasta::FastaPrivate::GetNameFromHeader(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>>&)
bool Fasta::FastaPrivate::GetNameFromHeader(const string& header, string& name) {

    // get rid of the leading greater than sign
    string s = header.substr(1);

    // extract the first non-whitespace segment
    char* pName = (char*)s.data();
    unsigned int nameLen = (unsigned int)s.size();

    unsigned int start = 0;
    while ( (pName[start] == 32) || (pName[start] == 9) || (pName[start] == 10) || (pName[start] == 13) ) {
        start++;
        if ( start == nameLen ) 
            break;
    }

    unsigned int stop  = start;
    if ( stop < nameLen ) {
        while( (pName[stop] != 32) && (pName[stop] != 9) && (pName[stop] != 10) && (pName[stop] != 13) ) {
            stop++;
            if ( stop == nameLen ) 
                break;
        }
    }

    if ( start == stop ) {
        cerr << "FASTA error : could not parse read name from FASTA header" << endl;
        return false;
    }

    name = s.substr(start, stop - start).c_str();
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
leaq 0x20(%rsp), %r14
movl $0x1, %edx
movq %r14, %rdi
movq $-0x1, %rcx
callq 0x27600
movq (%r14), %rsi
movq 0x8(%r14), %rax
xorl %edx, %edx
movabsq $0x100002600, %rdi      # imm = 0x100002600
movzbl (%rsi,%rdx), %ecx
cmpq $0x20, %rcx
ja 0x61fba
btq %rcx, %rdi
jae 0x61fba
incq %rdx
cmpl %edx, %eax
jne 0x61f3c
movq 0x2d086(%rip), %rbx     # 0x8efe0
leaq 0x13ceb(%rip), %rsi     # 0x75c4c
movl $0x39, %edx
movq %rbx, %rdi
callq 0x276b0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x27590
movsbl %al, %esi
movq 0x2d054(%rip), %rdi     # 0x8efe0
callq 0x27040
movq %rax, %rdi
callq 0x27410
xorl %ebx, %ebx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61fae
callq 0x27560
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
cmpl %eax, %edx
jae 0x61f53
movl %edx, %ecx
movl %ecx, %r8d
movzbl (%rsi,%r8), %r8d
cmpq $0x20, %r8
ja 0x61fd4
btq %r8, %rdi
jb 0x61fdc
incl %ecx
cmpl %ecx, %eax
jne 0x61fc0
movl %eax, %ecx
cmpl %edx, %ecx
je 0x61f53
subl %edx, %ecx
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x27600
movq (%rsp), %r14
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0x272f0
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x278f0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62029
callq 0x27560
movb $0x1, %bl
jmp 0x61f9b
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6204d
callq 0x27560
jmp 0x6204d
jmp 0x6204a
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62060
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/utils/bamtools_fasta.cpp
// Function: BamTools::Fasta::FastaPrivate::GetNextSequence(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool Fasta::FastaPrivate::GetNextSequence(string& sequence) {
  
    // validate input stream
    if ( !IsOpen || feof(Stream) ) 
        return false;
    
    // read in sequence  
    char buffer[1024];
    ostringstream seqBuffer("");
    while(true) {
        
        char ch = fgetc(Stream);
        ungetc(ch, Stream);
        if( (ch == '>') || feof(Stream) ) 
              break;       
        
        if ( fgets(buffer, 1024, Stream) == 0 ) {
            cerr << "FASTA error : could not read from file" << endl;
            return false;
        }
        
        Chomp(buffer);
        seqBuffer << buffer;
    }
    
    // import buffer contents to sequence string
    sequence = seqBuffer.str();
  
    // return success
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5a8, %rsp            # imm = 0x5A8
cmpb $0x1, 0x8(%rdi)
jne 0x62091
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x27900
testl %eax, %eax
je 0x620a7
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x5a8, %rsp            # imm = 0x5A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x14760(%rip), %rdx     # 0x76817
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x2f1a0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x10, %edx
callq 0x27820
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x620e7
callq 0x27560
leaq 0x1a0(%rsp), %r15
leaq 0x28(%rsp), %r12
movq (%r14), %rdi
callq 0x27950
movsbl %al, %edi
movl %eax, %ebp
shll $0x18, %ebp
movq (%r14), %rsi
callq 0x270e0
cmpl $0x3e000000, %ebp       # imm = 0x3E000000
je 0x62155
movq (%r14), %rdi
callq 0x27900
testl %eax, %eax
jne 0x62155
movq (%r14), %rdx
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x27970
testq %rax, %rax
je 0x62184
movq %r15, %rsi
callq 0x618ba
movq %r15, %rdi
callq 0x272f0
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x276b0
jmp 0x620f4
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x27990
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x27350
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x62180
callq 0x27560
movb $0x1, %bl
jmp 0x621cc
movq 0x2ce55(%rip), %rbx     # 0x8efe0
leaq 0x13a63(%rip), %rsi     # 0x75bf5
movl $0x26, %edx
movq %rbx, %rdi
callq 0x276b0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x27590
movsbl %al, %esi
movq 0x2ce23(%rip), %rdi     # 0x8efe0
callq 0x27040
movq %rax, %rdi
callq 0x27410
xorl %ebx, %ebx
leaq 0x28(%rsp), %rdi
callq 0x27160
jmp 0x62093
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x6220f
callq 0x27560
jmp 0x6220f
jmp 0x6220c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x62219
callq 0x27560
jmp 0x62219
movq %rax, %rbx
jmp 0x62219
jmp 0x6220c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x27160
movq %rbx, %rdi
callq 0x27b10
movq %rax, %rdi
callq 0x2e1cd
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/utils/bamtools_fasta.cpp
// Function: BamTools::Fasta::FastaPrivate::Open(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&)
bool Fasta::FastaPrivate::Open(const string& filename, const string& indexFilename) {
 
    bool success = true;
  
    // open FASTA filename
    Stream = fopen(filename.c_str(), "rb");
    if ( !Stream ) {
        cerr << "FASTA error: Could not open " << filename << " for reading" << endl;
        return false;
    }
    IsOpen = true;
    success &= IsOpen;
    
    // open index file if it exists
    if ( !indexFilename.empty() ) {
        IndexStream = fopen(indexFilename.c_str(), "rb");
        if ( !IndexStream ) {
            cerr << "FASTA error : Could not open " << indexFilename << " for reading." << endl;
            return false;
        }
        IsIndexOpen = true;
        success &= IsIndexOpen;
        
        // attempt to load index data
        HasIndex = LoadIndexData();
        success &= HasIndex;
    }
    
    // return success status
    return success;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rdi
leaq 0xef8b(%rip), %rsi      # 0x71cf1
callq 0x27660
movq %rax, (%r14)
testq %rax, %rax
je 0x62dad
movb $0x1, 0x8(%r14)
cmpq $0x0, 0x8(%rbx)
je 0x62de8
movq (%rbx), %rdi
leaq 0xef68(%rip), %rsi      # 0x71cf1
callq 0x27660
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x62dec
movb $0x1, 0x19(%r14)
movq %r14, %rdi
callq 0x62b26
movb %al, 0x18(%r14)
jmp 0x62e56
movq 0x2c22c(%rip), %rbx     # 0x8efe0
leaq 0x1309c(%rip), %rsi     # 0x75e57
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x276b0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x276b0
movq %rax, %rbx
leaq 0x12f1f(%rip), %rsi     # 0x75d00
movl $0xc, %edx
jmp 0x62e25
movb $0x1, %al
jmp 0x62e56
movq 0x2c1ed(%rip), %r14     # 0x8efe0
leaq 0x12ecd(%rip), %rsi     # 0x75cc7
movl $0x1d, %edx
movq %r14, %rdi
callq 0x276b0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x276b0
movq %rax, %rbx
leaq 0xf01b(%rip), %rsi      # 0x71e3b
movl $0xd, %edx
movq %rax, %rdi
callq 0x276b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x27590
movsbl %al, %esi
movq %rbx, %rdi
callq 0x27040
movq %rax, %rdi
callq 0x27410
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/utils/bamtools_options.cpp
// Function: BamTools::Options::AddOption(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&, bool&, BamTools::OptionGroup*)
void Options::AddOption(const string& argument,
                        const string& optionDescription,
                        bool& foundArgument,
                        OptionGroup* group)
{
    Option o;
    o.Argument    = argument;
    o.Description = optionDescription;
    o.StoreValue  = false;
    group->Options.push_back(o);

    OptionValue ov;
    ov.pFoundArgument = &foundArgument;
    ov.StoreValue     = false;

    m_optionsMap[argument] = ov;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movb %al, (%rbp)
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
movw $0x1, 0x10(%r13)
movq %rax, 0x18(%r13)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x27350
leaq 0x48(%rsp), %rdi
movq %r12, %rsi
callq 0x27350
leaq 0x8(%rsp), %rsi
movb $0x0, 0x60(%rsi)
addq $0x20, %r15
movq %r15, %rdi
callq 0x2f796
leaq 0x98(%rsp), %r15
xorl %eax, %eax
movq %rax, -0x18(%r15)
movq %r15, -0x10(%r15)
movq %rax, -0x8(%r15)
movb %al, (%r15)
movw $0x0, 0x10(%r15)
movb %al, 0x12(%r15)
movq %rax, 0x18(%r15)
movq %r14, -0x20(%r15)
leaq 0x2d2d8(%rip), %rdi     # 0x90658
movq %rbx, %rsi
callq 0x2f8d6
movq %rax, %rbx
leaq 0x88(%rsp), %rsi
movups -0x10(%rsi), %xmm0
movups %xmm0, (%rax)
leaq 0x10(%rax), %rdi
callq 0x27350
leaq 0xa8(%rsp), %rax
leaq 0xb0(%rsp), %rsi
movb 0x2(%rax), %cl
movb %cl, 0x32(%rbx)
movzwl (%rax), %eax
movw %ax, 0x30(%rbx)
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x2f75a
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x633e5
decq 0x8(%rdi)
jne 0x633e5
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x88(%rsp), %rdi
cmpq %r15, %rdi
je 0x633f7
callq 0x27560
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x6340d
decq 0x8(%rdi)
jne 0x6340d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x6341c
callq 0x27560
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6342b
callq 0x27560
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6343f
callq 0x27560
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x63463
callq 0x27560
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x63472
callq 0x27560
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x634bb
callq 0x27560
jmp 0x634bb
movq %rax, %rbx
movq 0x88(%rsp), %rdi
cmpq %r15, %rdi
je 0x634b1
callq 0x27560
jmp 0x634b1
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x2fa84
jmp 0x634b1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2fada
movq %rbx, %rdi
callq 0x27b10
movq %rax, %rdi
callq 0x2e1cd
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/utils/bamtools_options.cpp
// Function: BamTools::Options::CreateOptionGroup(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
OptionGroup* Options::CreateOptionGroup(const string& groupName) {
    OptionGroup og;
    og.Name = groupName;
    m_optionGroups.push_back(og);
    return &m_optionGroups[m_optionGroups.size() - 1];
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %rax, 0x20(%r14)
movq %rsp, %rdi
callq 0x27350
leaq 0x2d13c(%rip), %rbx     # 0x90640
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x64200
leaq 0x20(%rsp), %rdi
movq 0x8(%rbx), %rbx
callq 0x64442
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x6352b
callq 0x27560
addq $-0x38, %rbx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x63558
callq 0x27560
jmp 0x63558
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6422a
movq %rbx, %rdi
callq 0x27b10
movq %rax, %rdi
callq 0x2e1cd
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/utils/bamtools_pileup_engine.cpp
// Function: BamTools::PileupEngine::PileupEnginePrivate::ApplyVisitors()
void PileupEngine::PileupEnginePrivate::ApplyVisitors(void) {
  
    // parse CIGAR data in BamAlignments to build up current pileup data
    CreatePileupData();
  
    // apply all visitors to current alignment set
    vector<PileupVisitor*>::const_iterator visitorIter = Visitors.begin();
    vector<PileupVisitor*>::const_iterator visitorEnd  = Visitors.end();
    for ( ; visitorIter != visitorEnd; ++visitorIter ) 
        (*visitorIter)->Visit(CurrentPileupData);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x64da4
movq 0x48(%rbx), %r14
movq 0x50(%rbx), %r15
cmpq %r15, %r14
je 0x64d9d
addq $0x20, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x64d88
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/utils/bamtools_pileup_engine.cpp
// Function: BamTools::PileupEngine::PileupEnginePrivate::CreatePileupData()
void PileupEngine::PileupEnginePrivate::CreatePileupData(void) {
  
    // remove any non-overlapping alignments
    ClearOldData();
  
    // set pileup refId, position to current markers
    CurrentPileupData.RefId = CurrentId;
    CurrentPileupData.Position = CurrentPosition;
    CurrentPileupData.PileupAlignments.clear();
    
    // parse CIGAR data in remaining alignments 
    vector<BamAlignment>::const_iterator alIter = CurrentAlignments.begin();
    vector<BamAlignment>::const_iterator alEnd  = CurrentAlignments.end(); 
    for ( ; alIter != alEnd; ++alIter )
        ParseAlignmentCigar( (*alIter) );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x64e10
movq (%rbx), %rax
movq 0x28(%rbx), %r15
movq %rax, 0x20(%rbx)
movq 0x30(%rbx), %r12
cmpq %r15, %r12
je 0x64de3
movq %r15, %r14
movq %r14, %rdi
callq 0x27920
addq $0x170, %r14            # imm = 0x170
cmpq %r12, %r14
jne 0x64dcb
movq %r15, 0x30(%rbx)
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %r15
cmpq %r15, %r14
je 0x64e04
movq %rbx, %rdi
movq %r14, %rsi
callq 0x65006
addq $0x158, %r14            # imm = 0x158
jmp 0x64deb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/utils/bamtools_utilities.cpp
// Function: BamTools::Utilities::Split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
vector<string> Utilities::Split(const string& source, const char delim) {

    stringstream ss(source);
    string field;
    vector<string> fields;

    while ( getline(ss, field, delim) )
        fields.push_back(field);
    return fields;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x279b0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movsbl %bpl, %ebp
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x27ba0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x66943
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2e190
jmp 0x6691b
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x66952
callq 0x27560
leaq 0x28(%rsp), %rdi
callq 0x27490
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f0c0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x66989
callq 0x27560
leaq 0x28(%rsp), %rdi
callq 0x27490
movq %r14, %rdi
callq 0x27b10
movq %rax, %rdi
callq 0x2e1cd
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/utils/bamtools_utilities.cpp
// Function: BamTools::Utilities::Split(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&)
vector<string> Utilities::Split(const string& source, const string& delims) {

    vector<string> fields;

    char* tok;
    char* cchars = new char[source.size()+1];
    char* cstr = &cchars[0];
    strcpy(cstr, source.c_str());
    tok = strtok(cstr, delims.c_str());
    while (tok != NULL) {
        fields.push_back(tok);
        tok = strtok(NULL, delims.c_str());
    }

    delete[] cchars;

    return fields;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rdi
incq %rdi
callq 0x27030
movq %rax, %r15
movq (%r12), %rsi
movq %rax, %rdi
callq 0x27550
movq (%r14), %rsi
movq %r15, %rdi
callq 0x27940
testq %rax, %rax
je 0x66a49
movq %rax, %r13
leaq 0x18(%rsp), %rbp
leaq 0x8(%rsp), %r12
movq %rbp, 0x8(%rsp)
movq %r13, %rdi
callq 0x272f0
leaq (%rax,%r13), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x2f1a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2e190
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x66a37
callq 0x27560
movq (%r14), %rsi
xorl %edi, %edi
callq 0x27940
movq %rax, %r13
testq %rax, %rax
jne 0x66a01
movq %r15, %rdi
callq 0x27750
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x66a65
movq %rax, %r14
jmp 0x66a7c
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x66a7c
callq 0x27560
movq %rbx, %rdi
callq 0x2f0c0
movq %r14, %rdi
callq 0x27b10
movq %rax, %rdi
callq 0x2e1cd