LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2458c(%rip), %rdx     # 0x7781b
leaq 0x10(%rsp), %rdi
movq %rdx, %rsi
callq 0x2f1b2
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x18, %edx
callq 0x279c0
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x532bf
callq 0x27560
leaq 0x40(%rsp), %r14
leaq 0x8(%rsp), %rdi
callq 0x27280
testq %rax, %rax
je 0x532ee
movq %rax, %r15
movq %rax, %rdi
callq 0x272f0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x276c0
jmp 0x53309
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
addq %rax, %r14
movl 0x60(%rsp,%rax), %esi
orl $0x1, %esi
movq %r14, %rdi
callq 0x27a80
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x279a0
leaq 0x231d6(%rip), %rsi     # 0x764f3
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x27ae0
movq %rax, %r14
leaq 0x229cc(%rip), %r15     # 0x75d02
leaq 0x231b6(%rip), %r12     # 0x764f3
cmpq $-0x1, %r14
je 0x53377
movl $0x1, %edx
movl $0x1, %r8d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x27690
incq %r14
movl $0x1, %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x27ae0
movq %rax, %r14
jmp 0x5333d
leaq 0x30(%rsp), %rdi
callq 0x27490
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x533b3
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x533d1
callq 0x27560
jmp 0x533d1
movq %rax, %r14
jmp 0x533d1
movq %rax, %r14
jmp 0x533c7
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x533c7
callq 0x27560
leaq 0x30(%rsp), %rdi
callq 0x27490
movq %r14, %rdi
callq 0x27b20
movq %rax, %rdi
callq 0x2e1ed
// File: /workspace/github_cpp_makefile_star2_O1/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 0x53454
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 0x5349d
addq $0x70, %r14
leaq 0x23cfc(%rip), %rsi     # 0x77161
movl $0x1, %ecx
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x27810
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 0x534b7
movq %rsp, %r14
movq %r14, %rdi
callq 0x53264
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27350
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x534ca
callq 0x27560
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x534d6
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x534ec
callq 0x27560
movq %rbx, %rdi
callq 0x27b20
// File: /workspace/github_cpp_makefile_star2_O1/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 0x277a0
movl %eax, %ebx
testb %al, %al
je 0x53563
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 0x5354a
callq 0x27560
movq %r15, %rdi
callq 0x27090
addq $0x50, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2e1f8
jmp 0x535bb
movq 0x3ca76(%rip), %r15     # 0x8ffe0
leaq 0x22799(%rip), %rsi     # 0x75d0a
movl $0x2f, %edx
movq %r15, %rdi
callq 0x276c0
movq (%r14), %rax
movq 0x70(%rax), %rsi
movq 0x78(%rax), %rdx
movq %r15, %rdi
callq 0x276c0
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 0x535df
callq 0x27560
movq %rbx, %rdi
callq 0x27b20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x53422
movq %rbx, %rdi
callq 0x534f4
testb %al, %al
je 0x536c0
movq (%rbx), %rax
cmpb $0x1, 0x5(%rax)
jne 0x53613
movq %rbx, %rdi
popq %rbx
jmp 0x536c4
cmpb $0x1, 0x6(%rax)
jne 0x53622
movq %rbx, %rdi
popq %rbx
jmp 0x539c8
cmpb $0x1, 0x7(%rax)
jne 0x53631
movq %rbx, %rdi
popq %rbx
jmp 0x53ccc
cmpb $0x1, 0x8(%rax)
jne 0x53640
movq %rbx, %rdi
popq %rbx
jmp 0x54224
movq 0x3c999(%rip), %rbx     # 0x8ffe0
leaq 0x226ec(%rip), %rsi     # 0x75d3a
movl $0x37, %edx
movq %rbx, %rdi
callq 0x276c0
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 0x226e6(%rip), %rsi     # 0x75d72
movl $0x57, %edx
movq %rax, %rdi
callq 0x276c0
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_O1/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 0x3ad2e(%rip), %rax     # 0x8fb98
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x54efd
movq 0xb0(%r14), %rdi
leaq 0xc0(%r14), %rax
cmpq %rax, %rdi
je 0x54e92
callq 0x27560
movq 0x90(%r14), %rdi
leaq 0xa0(%r14), %rax
cmpq %rax, %rdi
je 0x54eaa
callq 0x27560
movq 0x70(%r14), %rdi
leaq 0x80(%r14), %rax
cmpq %rax, %rdi
je 0x54ebf
callq 0x27560
movq 0x50(%r14), %rdi
leaq 0x60(%r14), %rax
cmpq %rax, %rdi
je 0x54ed1
callq 0x27560
movq 0x30(%r14), %rdi
leaq 0x40(%r14), %rax
cmpq %rax, %rdi
je 0x54ee3
callq 0x27560
movq 0x10(%r14), %rdi
leaq 0x20(%r14), %rax
cmpq %rax, %rdi
je 0x54ef5
callq 0x27560
movq %r14, %rdi
callq 0x27560
movq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x54f1e
movq %r14, %rdi
callq 0x5c988
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 0x27b20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x64002
movl $0x68, %edi
callq 0x275c0
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x5ca2e
movq %r14, 0x10(%rbx)
movq %r14, %rdi
callq 0x535e8
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 0x27b20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5501f
movq 0x28(%r14), %r15
testq %r15, %r15
je 0x5500f
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 0x54fee
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x5ca92
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 0x27b20
// File: /workspace/github_cpp_makefile_star2_O1/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 0x27b90
testb %al, %al
je 0x60730
incl 0x34(%rbx)
movq %r14, %rdi
callq 0x27630
testb %al, %al
je 0x6073f
incl 0x30(%rbx)
movq %r14, %rdi
callq 0x270d0
testb %al, %al
je 0x6074e
incl 0x14(%rbx)
movq %r14, %rdi
callq 0x27800
testb %al, %al
je 0x6075f
incl 0x20(%rbx)
jmp 0x60762
incl 0x1c(%rbx)
movq %r14, %rdi
callq 0x27330
testb %al, %al
je 0x60814
incl 0xc(%rbx)
movq %r14, %rdi
callq 0x272e0
testb %al, %al
je 0x60784
incl 0x24(%rbx)
movq %r14, %rdi
callq 0x27b70
testb %al, %al
je 0x60793
incl 0x28(%rbx)
movq %r14, %rdi
callq 0x270d0
testb %al, %al
je 0x607b3
movq %r14, %rdi
callq 0x276f0
testb %al, %al
je 0x607b0
incl 0x18(%rbx)
jmp 0x607b3
incl 0x2c(%rbx)
movq %r14, %rdi
callq 0x27c00
testb %al, %al
je 0x607c2
incl 0x10(%rbx)
movq (%rbx), %rax
cmpb $0x1, 0x2(%rax)
jne 0x60814
movq %r14, %rdi
callq 0x272e0
testb %al, %al
je 0x60814
movl 0xd8(%r14), %ecx
testl %ecx, %ecx
je 0x60814
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
movl %eax, 0x4(%rsp)
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x60803
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x40(%rbx)
jmp 0x60814
addq $0x38, %rbx
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x4baba
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ec5e(%rip), %rax     # 0x8fbe0
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x60fb1
movq 0x20(%r14), %rdi
leaq 0x30(%r14), %rax
cmpq %rax, %rdi
je 0x60fa0
callq 0x27560
leaq 0x8(%r14), %rdi
callq 0x2f0de
movq %r14, %rdi
callq 0x27560
movq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x60fd8
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x60fd0
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 0x27b20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x64002
movl $0x50, %edi
callq 0x275c0
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x5fce8
movq %r14, 0x10(%rbx)
movq %r14, %rdi
callq 0x6081c
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 0x27b20
// File: /workspace/github_cpp_makefile_star2_O1/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 0x61c51
movl $0x1, %edi
jmp 0x61d28
movl %edi, %ebp
movq 0x8(%rbx), %r14
leaq 0x2f8c2(%rip), %rdi     # 0x91520
movq %r14, %rsi
callq 0x271c0
testl %eax, %eax
je 0x61d26
leaq 0x2f8cb(%rip), %rdi     # 0x91540
movq %r14, %rsi
callq 0x271c0
testl %eax, %eax
je 0x61d26
leaq 0x2f8d4(%rip), %rdi     # 0x91560
movq %r14, %rsi
callq 0x271c0
testl %eax, %eax
je 0x61d26
movq 0x8(%rbx), %r14
leaq 0x2f8d9(%rip), %rdi     # 0x91580
movq %r14, %rsi
callq 0x271c0
testl %eax, %eax
je 0x61d38
leaq 0x2f8e2(%rip), %rdi     # 0x915a0
movq %r14, %rsi
callq 0x271c0
testl %eax, %eax
je 0x61d38
leaq 0x2f8ef(%rip), %rdi     # 0x915c0
movq %r14, %rsi
callq 0x271c0
testl %eax, %eax
je 0x61d38
movq 0x8(%rbx), %rsi
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x272a0
movq %r14, %rdi
callq 0x611ac
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61d11
callq 0x27560
testq %r14, %r14
je 0x61d48
movq (%r14), %rax
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq *0x18(%rax)
jmp 0x61d3f
movl %ebp, %edi
movq %rbx, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x614c9
callq 0x61999
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl %ebp, %edi
movq %rbx, %rsi
callq 0x614c9
jmp 0x61d3f
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61d6a
callq 0x27560
movq %rbx, %rdi
callq 0x27b20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x61dba
movq (%rbx), %rdi
callq 0x275b0
movb $0x0, 0x8(%rbx)
cmpb $0x1, 0x18(%rbx)
jne 0x61dd5
cmpb $0x1, 0x19(%rbx)
jne 0x61dd5
movq 0x10(%rbx), %rdi
callq 0x275b0
movw $0x0, 0x18(%rbx)
movb $0x1, %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x61e0c
cltq
incq %rax
movzbl -0x2(%rbx,%rax), %ecx
cmpl $0xd, %ecx
je 0x61dfe
cmpl $0xa, %ecx
jne 0x61e0c
movb $0x0, -0x2(%rbx,%rax)
decq %rax
cmpq $0x1, %rax
jg 0x61def
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x623c6
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x27910
testl %eax, %eax
jne 0x623c6
movq (%r14), %rdx
leaq 0x1b0(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x27980
testq %rax, %rax
je 0x62346
cmpb $0x3e, 0x1b0(%rsp)
jne 0x62366
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x15564(%rip), %rdx     # 0x7781b
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x2f1b2
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x18, %edx
callq 0x279c0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x622e7
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 0x276c0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x279a0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x27350
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x62335
callq 0x27560
leaq 0x28(%rsp), %rdi
callq 0x27490
movb $0x1, %al
jmp 0x623c8
movq 0x2dc93(%rip), %rbx     # 0x8ffe0
leaq 0x148a1(%rip), %rsi     # 0x76bf5
movl $0x26, %edx
movq %rbx, %rdi
callq 0x276c0
movq (%rbx), %rax
jmp 0x623a2
movq 0x2dc73(%rip), %rbx     # 0x8ffe0
leaq 0x148a8(%rip), %rsi     # 0x76c1c
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x276c0
movb 0x1b0(%rsp), %al
leaq 0x28(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x276c0
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 0x623f0
callq 0x27560
jmp 0x623f0
jmp 0x623ed
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x27490
jmp 0x62413
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x62413
callq 0x27560
jmp 0x62413
movq %rax, %rbx
movq %rbx, %rdi
callq 0x27b20
movq %rax, %rdi
callq 0x2e1ed
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
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), %rcx
movq 0x8(%r14), %rax
xorl %r12d, %r12d
movabsq $0x100002600, %rdx      # imm = 0x100002600
movzbl (%rcx,%r12), %esi
cmpq $0x20, %rsi
ja 0x6247c
btq %rsi, %rdx
jae 0x6247c
incq %r12
cmpl %r12d, %eax
jne 0x62460
movl %eax, %r12d
movl %r12d, %ebp
cmpl %eax, %r12d
jae 0x624a1
movl %r12d, %ebp
movl %ebp, %esi
movzbl (%rcx,%rsi), %esi
cmpq $0x20, %rsi
ja 0x62499
btq %rsi, %rdx
jb 0x624a1
incl %ebp
cmpl %ebp, %eax
jne 0x62487
movl %eax, %ebp
movl %ebp, %ecx
subl %r12d, %ecx
je 0x624f0
movl %r12d, %edx
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 0x27900
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62536
callq 0x27560
jmp 0x62536
movq 0x2dae9(%rip), %rbx     # 0x8ffe0
leaq 0x1474e(%rip), %rsi     # 0x76c4c
movl $0x39, %edx
movq %rbx, %rdi
callq 0x276c0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x27590
movsbl %al, %esi
movq 0x2dab7(%rip), %rdi     # 0x8ffe0
callq 0x27040
movq %rax, %rdi
callq 0x27410
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62549
callq 0x27560
cmpl %r12d, %ebp
setne %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62579
callq 0x27560
jmp 0x62579
jmp 0x62576
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6258c
callq 0x27560
movq %rbx, %rdi
callq 0x27b20
// File: /workspace/github_cpp_makefile_star2_O1/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 0x625bd
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x27910
testl %eax, %eax
je 0x625d3
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), %r15
movq %r15, -0x10(%r15)
leaq 0x15238(%rip), %rdx     # 0x7781b
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x2f1b2
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x10, %edx
callq 0x27830
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x62613
callq 0x27560
leaq 0x1a0(%rsp), %r15
movq 0x2d9be(%rip), %r12     # 0x8ffe0
movq (%r14), %rdi
callq 0x27960
movl %eax, %ebp
movsbl %bpl, %edi
shll $0x18, %ebp
movq (%r14), %rsi
callq 0x270e0
movl $0x3, %r13d
cmpl $0x3e000000, %ebp       # imm = 0x3E000000
je 0x626d5
movq (%r14), %rdi
callq 0x27910
testl %eax, %eax
jne 0x626d5
movq (%r14), %rdx
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x27980
testq %rax, %rax
je 0x62693
movq %r15, %rsi
callq 0x61dda
movq %r15, %rdi
callq 0x272f0
xorl %r13d, %r13d
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x276c0
jmp 0x626d5
movl $0x26, %edx
movq %r12, %rdi
leaq 0x14553(%rip), %rsi     # 0x76bf5
callq 0x276c0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x27590
movsbl %al, %esi
movq %r12, %rdi
callq 0x27040
movl $0x1, %r13d
movq %rax, %rdi
callq 0x27410
testl %r13d, %r13d
je 0x62622
cmpl $0x3, %r13d
jne 0x62718
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x279a0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
leaq 0x18(%rsp), %r14
callq 0x27350
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x62714
callq 0x27560
movb $0x1, %bl
jmp 0x6271a
xorl %ebx, %ebx
leaq 0x28(%rsp), %rdi
callq 0x27160
jmp 0x625bf
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x6275b
callq 0x27560
jmp 0x6275b
jmp 0x62758
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x62765
callq 0x27560
jmp 0x62765
movq %rax, %rbx
jmp 0x62765
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x27160
movq %rbx, %rdi
callq 0x27b20
movq %rax, %rdi
callq 0x2e1ed
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfa49(%rip), %rsi      # 0x72cf1
callq 0x27670
movq %rax, (%r14)
testq %rax, %rax
je 0x632ef
movb $0x1, 0x8(%r14)
cmpq $0x0, 0x8(%rbx)
je 0x6332a
movq (%rbx), %rdi
leaq 0xfa26(%rip), %rsi      # 0x72cf1
callq 0x27670
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x6332e
movb $0x1, 0x19(%r14)
movq %r14, %rdi
callq 0x63070
movb %al, 0x18(%r14)
jmp 0x63398
movq 0x2ccea(%rip), %rbx     # 0x8ffe0
leaq 0x13b5a(%rip), %rsi     # 0x76e57
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x276c0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x276c0
movq %rax, %rbx
leaq 0x139dd(%rip), %rsi     # 0x76d00
movl $0xc, %edx
jmp 0x63367
movb $0x1, %al
jmp 0x63398
movq 0x2ccab(%rip), %r14     # 0x8ffe0
leaq 0x1398b(%rip), %rsi     # 0x76cc7
movl $0x1d, %edx
movq %r14, %rdi
callq 0x276c0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x276c0
movq %rax, %rbx
leaq 0xfad9(%rip), %rsi      # 0x72e3b
movl $0xd, %edx
movq %rax, %rdi
callq 0x276c0
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_O1/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 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x30(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movb %al, (%rbp)
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
movw $0x1, 0x10(%r13)
movq %rax, 0x18(%r13)
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x27350
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
callq 0x27350
movq %rsp, %rsi
movb $0x0, 0x60(%rsi)
addq $0x20, %r15
movq %r15, %rdi
callq 0x2f7a2
leaq 0x90(%rsp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%r15)
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
movb %al, 0x10(%r15)
movq %rax, 0x18(%r15)
movq %r14, -0x20(%r15)
movw $0x0, 0x11(%r15)
leaq 0x2dd9c(%rip), %rdi     # 0x91660
movq %rbx, %rsi
callq 0x2f8e8
movq %rax, %rbx
leaq 0x80(%rsp), %rsi
movaps -0x10(%rsi), %xmm0
movups %xmm0, (%rax)
leaq 0x10(%rax), %rdi
callq 0x27350
leaq 0xa0(%rsp), %rax
leaq 0xa8(%rsp), %rsi
movb 0x2(%rax), %cl
movb %cl, 0x32(%rbx)
movzwl (%rax), %eax
movw %ax, 0x30(%rbx)
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x2f766
movq 0xa8(%rsp), %rdi
testq %rdi, %rdi
je 0x63929
decq 0x8(%rdi)
jne 0x63929
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0x6393b
callq 0x27560
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x63951
decq 0x8(%rdi)
jne 0x63951
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x63960
callq 0x27560
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6396f
callq 0x27560
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x63982
callq 0x27560
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x639a6
callq 0x27560
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x639b5
callq 0x27560
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x639fb
callq 0x27560
jmp 0x639fb
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0x639f3
callq 0x27560
jmp 0x639f3
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2fa94
jmp 0x639f3
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2faea
movq %rbx, %rdi
callq 0x27b20
movq %rax, %rdi
callq 0x2e1ed
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2dc04(%rip), %rbx     # 0x91648
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x64740
leaq 0x20(%rsp), %rdi
movq 0x8(%rbx), %rbx
callq 0x64982
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x63a6b
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 0x63a98
callq 0x27560
jmp 0x63a98
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6476a
movq %rbx, %rdi
callq 0x27b20
movq %rax, %rdi
callq 0x2e1ed
// File: /workspace/github_cpp_makefile_star2_O1/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 0x652ce
movq 0x48(%rbx), %r14
movq 0x50(%rbx), %r15
cmpq %r15, %r14
je 0x652c7
addq $0x20, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x652b2
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6533a
movq (%rbx), %rax
movq 0x28(%rbx), %r15
movq %rax, 0x20(%rbx)
movq 0x30(%rbx), %r12
cmpq %r15, %r12
je 0x6530d
movq %r15, %r14
movq %r14, %rdi
callq 0x27930
addq $0x170, %r14            # imm = 0x170
cmpq %r12, %r14
jne 0x652f5
movq %r15, 0x30(%rbx)
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %r15
cmpq %r15, %r14
je 0x6532e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x65530
addq $0x158, %r14            # imm = 0x158
jmp 0x65315
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/zeeev[P]DASVC/bamtools/src/utils/bamtools_utilities.cpp
// Function: BamTools::Utilities::ReverseComplement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Utilities::ReverseComplement(string& sequence) {
    
    // do complement, in-place
    size_t seqLength = sequence.length();
    for ( size_t i = 0; i < seqLength; ++i )
        sequence.replace(i, 1, 1, REVCOMP_LOOKUP[(int)sequence.at(i) - 65]);
    
    // reverse it
    Reverse(sequence);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x66e12
xorl %r14d, %r14d
leaq 0x10392(%rip), %r12     # 0x77170
movq 0x8(%rbx), %rdx
cmpq %r14, %rdx
jbe 0x66e5f
movq (%rbx), %rax
movsbq (%rax,%r14), %rax
movsbl -0x41(%rax,%r12), %r8d
movl $0x1, %edx
movl $0x1, %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27a10
incq %r14
cmpq %r14, %r15
jne 0x66dde
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
setne %dl
addq %rax, %rcx
decq %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x66e53
incq %rax
movb -0x1(%rax), %dl
movb (%rcx), %sil
movb %sil, -0x1(%rax)
movb %dl, (%rcx)
decq %rcx
leaq 0x1(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x66e38
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xb8a2(%rip), %rdi      # 0x72708
movq %r14, %rsi
xorl %eax, %eax
callq 0x278c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x279c0
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 0x27bb0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x66ee7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2e1b0
jmp 0x66ebf
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x66ef6
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 0x2f0de
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x66f2d
callq 0x27560
leaq 0x28(%rsp), %rdi
callq 0x27490
movq %r14, %rdi
callq 0x27b20
movq %rax, %rdi
callq 0x2e1ed
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x27950
testq %rax, %rax
je 0x66fed
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 0x2f1b2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2e1b0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x66fdb
callq 0x27560
movq (%r14), %rsi
xorl %edi, %edi
callq 0x27950
movq %rax, %r13
testq %rax, %rax
jne 0x66fa5
movq %r15, %rdi
callq 0x27760
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x67009
movq %rax, %r14
jmp 0x67020
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x67020
callq 0x27560
movq %rbx, %rdi
callq 0x2f0de
movq %r14, %rdi
callq 0x27b20
movq %rax, %rdi
callq 0x2e1ed
// File: /workspace/github_cpp_makefile_star2_O1/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Json::Value&, bool)
bool
Reader::parse( const std::string &document, 
               Value &root,
               bool collectComments )
{
   document_ = document;
   const char *begin = document_.c_str();
   const char *end = begin + document_.length();
   return parse( begin, end, root, collectComments );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
addq $0xa0, %rdi
callq 0x27350
movq 0xa0(%r15), %rsi
movq 0xa8(%r15), %rdx
addq %rsi, %rdx
movq %r15, %rdi
movq %r14, %rcx
movl %ebx, %r8d
popq %rbx
popq %r14
popq %r15
jmp 0x672f4
nop
// File: /workspace/github_cpp_makefile_star2_O1/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::parse(char const*, char const*, Json::Value&, bool)
bool 
Reader::parse( const char *beginDoc, const char *endDoc, 
               Value &root,
               bool collectComments )
{
   if ( !features_.allowComments_ )
   {
      collectComments = false;
   }

   begin_ = beginDoc;
   end_ = endDoc;
   collectComments_ = collectComments;
   current_ = begin_;
   lastValueEnd_ = 0;
   lastValue_ = 0;
   commentsBefore_ = "";
   errors_.clear();
   while ( !nodes_.empty() )
      nodes_.pop();
   nodes_.push( &root );
   
   bool successful = readValue();
   Token token;
   skipCommentTokens( token );
   if ( collectComments_  &&  !commentsBefore_.empty() )
      root.setComment( commentsBefore_, commentAfter );
   if ( features_.strictRoot_ )
   {
      if ( !root.isArray()  &&  !root.isObject() )
      {
         // Set error location to start of doc, ideally should be first token found in doc
         token.type_ = tokenError;
         token.start_ = beginDoc;
         token.end_ = endDoc;
         addError( "A valid JSON document must be either an array or an object value.",
                   token );
         return false;
      }
   }
   return successful;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
andb 0x108(%rdi), %r8b
movq %rsi, 0xc0(%rdi)
movq %rdx, 0xc8(%rdi)
movb %r8b, 0x10a(%rdi)
movq %rsi, 0xd0(%rdi)
leaq 0xe8(%rdi), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rdi)
movq 0xf0(%rdi), %rdx
leaq 0x104cb(%rip), %rcx     # 0x7781b
movq %r13, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x27900
leaq 0x50(%rbx), %rdi
movups 0x60(%rbx), %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movups 0x70(%rbx), %xmm0
movaps %xmm0, 0x10(%rsi)
callq 0x69d14
movq 0x30(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x6738c
movq %rbx, %rdi
callq 0x69d8c
jmp 0x67378
movq %r12, (%rsp)
movq 0x40(%rbx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x673a7
movq %r12, (%rax)
addq $0x8, 0x30(%rbx)
jmp 0x673b2
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x69dd4
movq %rbx, %rdi
callq 0x67536
movl %eax, %ebp
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x67764
cmpb $0x1, 0x10a(%rbx)
jne 0x673ec
cmpq $0x0, 0xf0(%rbx)
je 0x673ec
movq %r12, %rdi
movq %r13, %rsi
movl $0x2, %edx
callq 0x6d74c
cmpb $0x1, 0x109(%rbx)
jne 0x67466
movq %r12, %rdi
callq 0x6ce5a
testb %al, %al
jne 0x67466
movq %r12, %rdi
callq 0x6ce6e
testb %al, %al
jne 0x67466
leaq 0x20(%rsp), %r12
movl $0xd, (%r12)
movq %r15, 0x8(%r12)
movq %r14, 0x10(%r12)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xfe00(%rip), %rsi      # 0x77234
leaq 0xfe3a(%rip), %rdx      # 0x77275
movq %rsp, %r14
movq %r14, %rdi
callq 0x2f1b2
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x677a2
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x67464
callq 0x27560
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x67488
callq 0x27560
movq %rbx, %rdi
callq 0x27b20
// File: /workspace/github_cpp_makefile_star2_O1/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::parse(std::istream&, Json::Value&, bool)
bool
Reader::parse( std::istream& sin,
               Value &root,
               bool collectComments )
{
   //std::istream_iterator<char> begin(sin);
   //std::istream_iterator<char> end;
   // Those would allow streamed input from a file, if parse() were a
   // template function.

   // Since std::string is reference-counted, this at least does not
   // create an extra copy.
   std::string doc;
   std::getline(sin, doc, (char)EOF);
   return parse( doc, root, collectComments );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x27bb0
leaq 0xa0(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x27350
movq 0xa0(%r14), %rsi
movq 0xa8(%r14), %rdx
addq %rsi, %rdx
movzbl %bpl, %r8d
movq %r14, %rdi
movq %rbx, %rcx
callq 0x672f4
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6750e
callq 0x27560
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6752d
callq 0x27560
movq %rbx, %rdi
callq 0x27b20
nop