LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rax, %rdi
addq $0x28, %rdi
movq (%rax), %rsi
addq $0x70, %rsi
callq 0x86980
testb $0x1, %al
jne 0xe50f7
movq 0x7ff1f(%rip), %rdi     # 0x164fe0
leaq 0x4ddaa(%rip), %rsi     # 0x132e72
callq 0x86700
movq %rax, %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
addq $0x70, %rsi
callq 0x86640
movq %rax, %rdi
movq 0x7fe85(%rip), %rsi     # 0x164f70
callq 0x86770
movb $0x0, 0x57(%rsp)
jmp 0xe5170
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x86250
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x30, %rdi
callq 0x86070
jmp 0xe5124
leaq 0x28(%rsp), %rdi
callq 0x86f68
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
callq 0x860a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
addq $0x50, %rdi
callq 0x912a0
movb $0x1, 0x57(%rsp)
jmp 0xe5170
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x86f68
jmp 0xe516e
jmp 0xe517b
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xe4f90
movq (%rsp), %rdi
callq 0xe5090
testb $0x1, %al
jne 0xe51be
movb $0x0, 0x17(%rsp)
jmp 0xe5281
movq (%rsp), %rax
movq (%rax), %rax
testb $0x1, 0x5(%rax)
je 0xe51df
movq (%rsp), %rdi
callq 0xe5290
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0xe5281
movq (%rsp), %rax
movq (%rax), %rax
testb $0x1, 0x6(%rax)
je 0xe5200
movq (%rsp), %rdi
callq 0xe5750
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0xe5281
movq (%rsp), %rax
movq (%rax), %rax
testb $0x1, 0x7(%rax)
je 0xe521e
movq (%rsp), %rdi
callq 0xe5c10
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0xe5281
movq (%rsp), %rax
movq (%rax), %rax
testb $0x1, 0x8(%rax)
je 0xe523c
movq (%rsp), %rdi
callq 0xe6340
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0xe5281
movq 0x7fd9d(%rip), %rdi     # 0x164fe0
leaq 0x4dc58(%rip), %rsi     # 0x132ea2
callq 0x86700
movq %rax, %rdi
movq 0x7fd17(%rip), %rsi     # 0x164f70
callq 0x86770
movq %rax, %rdi
leaq 0x4dc72(%rip), %rsi     # 0x132eda
callq 0x86700
movq %rax, %rdi
movq 0x7fcf9(%rip), %rsi     # 0x164f70
callq 0x86770
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x7cc36(%rip), %rcx     # 0x164b90
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0xe7f86
movq 0x18(%rsp), %rdi
callq 0xf4180
jmp 0xe7f7c
movq 0x18(%rsp), %rdi
callq 0x866a0
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xe7fb8
movq 0x8(%rsp), %rdi
callq 0xf42c0
jmp 0xe7fae
movq 0x8(%rsp), %rdi
callq 0x866a0
movq 0x10(%rsp), %rdi
movq $0x0, 0x10(%rdi)
callq 0x92a20
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x866a0
jmp 0xe8001
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x866a0
movq 0x10(%rsp), %rdi
callq 0x92a20
jmp 0xe800d
jmp 0xe800f
movq 0x28(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
movl $0x1, %edx
callq 0x10e260
movl $0x68, %edi
callq 0x86720
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rsi
callq 0xf43c0
jmp 0xe80e4
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0xe5190
testb $0x1, %al
jne 0xe8101
jmp 0xe8125
movl $0x0, 0x44(%rsp)
jmp 0xe812d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x866a0
jmp 0xe8136
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x86d80
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0xf5480
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0xe81c0
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf54b0
testb $0x1, %al
jne 0xe8311
jmp 0xe838d
leaq 0x30(%rsp), %rdi
callq 0xe82b0
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xe832e
jmp 0xe8367
movq 0x20(%rsp), %rdi
callq 0x86410
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xe835e
movq 0x8(%rsp), %rdi
callq 0x86510
jmp 0xe8354
movq 0x8(%rsp), %rdi
callq 0x866a0
movq $0x0, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xf54d0
jmp 0xe82fc
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x866a0
jmp 0xe839c
movq 0x38(%rsp), %rdi
callq 0xf5500
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x86d80
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_stats.cpp
// Function: BamTools::StatsTool::StatsToolPrivate::CalculateMedian(std::vector<int, std::allocator<int>>&, double&)
bool StatsTool::StatsToolPrivate::CalculateMedian(vector<int>& data, double& median) { 
  
    // skip if data empty
    if ( data.empty() )
        return false;

    // find middle element
    size_t middleIndex = data.size() / 2;
    vector<int>::iterator target = data.begin() + middleIndex;
    nth_element(data.begin(), target, data.end());
    
    // odd number of elements
    if ( (data.size() % 2) != 0) {
        median = (double)(*target);
        return true;
    }
    
    // even number of elements
    else {
        double rightTarget = (double)(*target);
        vector<int>::iterator leftTarget = target - 1;
        nth_element(data.begin(), leftTarget, data.end());
        median = (double)((rightTarget+*leftTarget)/2.0);
        return true;
    }
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0xcf350
testb $0x1, %al
jne 0x106fc6
jmp 0x106fd3
movb $0x0, 0x87(%rsp)
jmp 0x107121
movq 0x70(%rsp), %rdi
callq 0xcf3a0
shrq %rax
movq %rax, 0x60(%rsp)
movq 0x70(%rsp), %rdi
callq 0xcf300
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0xd50a0
movq %rax, 0x58(%rsp)
movq 0x70(%rsp), %rdi
callq 0xcf300
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x70(%rsp), %rdi
callq 0xcf230
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x1089e0
movq 0x70(%rsp), %rdi
callq 0xcf3a0
andq $0x1, %rax
cmpq $0x0, %rax
je 0x10707c
leaq 0x58(%rsp), %rdi
callq 0xd7060
cvtsi2sdl (%rax), %xmm0
movq 0x68(%rsp), %rax
movsd %xmm0, (%rax)
movb $0x1, 0x87(%rsp)
jmp 0x107121
leaq 0x58(%rsp), %rdi
callq 0xd7060
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
leaq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0xd7680
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
callq 0xcf300
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rdi
callq 0xcf230
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1089e0
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd7060
movsd 0x8(%rsp), %xmm0
cvtsi2sdl (%rax), %xmm1
addsd %xmm1, %xmm0
movsd 0x2c414(%rip), %xmm1    # 0x133520
divsd %xmm1, %xmm0
movq 0x68(%rsp), %rax
movsd %xmm0, (%rax)
movb $0x1, 0x87(%rsp)
movb 0x87(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x5c3de(%rip), %rcx     # 0x164bd8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x108826
movq 0x18(%rsp), %rdi
callq 0x108b60
jmp 0x10881c
movq 0x18(%rsp), %rdi
callq 0x866a0
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x108858
movq 0x8(%rsp), %rdi
callq 0x108bd0
jmp 0x10884e
movq 0x8(%rsp), %rdi
callq 0x866a0
movq 0x10(%rsp), %rdi
movq $0x0, 0x10(%rdi)
callq 0x92a20
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x866a0
jmp 0x1088a1
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x866a0
movq 0x10(%rsp), %rdi
callq 0x92a20
jmp 0x1088ad
jmp 0x1088af
movq 0x28(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
movl $0x1, %edx
callq 0x10e260
movl $0x50, %edi
callq 0x86720
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rsi
callq 0x106ed0
jmp 0x108984
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0x1079f0
testb $0x1, %al
jne 0x1089a1
jmp 0x1089c5
movl $0x0, 0x44(%rsp)
jmp 0x1089cd
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x866a0
jmp 0x1089d6
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x86d80
// File: 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:
subq $0x68, %rsp
movl $0x0, 0x64(%rsp)
movl %edi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
cmpl $0x1, 0x60(%rsp)
jne 0x109923
movl 0x60(%rsp), %edi
movq 0x58(%rsp), %rsi
callq 0x1092c0
movl %eax, 0x64(%rsp)
jmp 0x109a3e
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x109a60
testb $0x1, %al
jne 0x109937
jmp 0x10994e
movl 0x60(%rsp), %edi
movq 0x58(%rsp), %rsi
callq 0x1092c0
movl %eax, 0x64(%rsp)
jmp 0x109a3e
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x109ad0
testb $0x1, %al
jne 0x109962
jmp 0x109970
callq 0x109630
movl %eax, 0x64(%rsp)
jmp 0x109a3e
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x86da0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x86a00
jmp 0x1099a3
leaq 0x30(%rsp), %rdi
callq 0x108da0
movq %rax, (%rsp)
jmp 0x1099b3
leaq 0x30(%rsp), %rdi
callq 0x86f68
jmp 0x1099bf
leaq 0x2f(%rsp), %rdi
callq 0x867b0
movq (%rsp), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x109a2c
movq 0x50(%rsp), %rdi
movl 0x60(%rsp), %esi
movq 0x58(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, 0x64(%rsp)
jmp 0x109a3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x109a20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x86f68
jmp 0x109a1e
jmp 0x109a20
leaq 0x2f(%rsp), %rdi
callq 0x867b0
jmp 0x109a47
movl 0x60(%rsp), %edi
movq 0x58(%rsp), %rsi
callq 0x1092c0
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x8(%rax)
je 0x109c1f
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x86710
movq 0x8(%rsp), %rax
movb $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
testb $0x1, 0x18(%rax)
je 0x109c50
movq 0x8(%rsp), %rax
testb $0x1, 0x19(%rax)
je 0x109c50
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x86710
movq 0x8(%rsp), %rax
movb $0x0, 0x18(%rax)
movb $0x0, 0x19(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x86360
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x109c85
jmp 0x109cef
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, 0x3(%rsp)
je 0x109cc1
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
sete %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x109ccb
jmp 0x109cef
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x109ced
jmp 0x109cef
jmp 0x109c90
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq %rcx, 0xd8(%rsp)
leaq 0x68(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x94840
movq 0x10(%rsp), %rdi
movq 0xf0(%rsp), %rsi
callq 0x86070
jmp 0x10d2ea
movq 0xe8(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
callq 0x86070
jmp 0x10d301
movb $0x0, 0xc8(%rsp)
movq 0xd8(%rsp), %rdi
addq $0x20, %rdi
leaq 0x68(%rsp), %rsi
callq 0x94a80
jmp 0x10d321
leaq 0x18(%rsp), %rdi
callq 0x94af0
jmp 0x10d32d
movq 0xe0(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x49(%rsp)
movq 0xf0(%rsp), %rsi
leaq 0x5949a(%rip), %rdi     # 0x1667e8
callq 0x94d50
movq %rax, 0x8(%rsp)
jmp 0x10d35a
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x94f10
jmp 0x10d36b
leaq 0x18(%rsp), %rdi
callq 0x94f80
jmp 0x10d377
leaq 0x68(%rsp), %rdi
callq 0x94ff0
addq $0xf8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x10d3b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x94f80
jmp 0x10d3b3
jmp 0x10d3b5
leaq 0x68(%rsp), %rdi
callq 0x94ff0
jmp 0x10d3c1
jmp 0x10d3c3
movq 0x60(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x10f350
movq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x86070
jmp 0x10d409
leaq 0x593c0(%rip), %rdi     # 0x1667d0
leaq 0x28(%rsp), %rsi
callq 0x10f3b0
jmp 0x10d41c
leaq 0x593ad(%rip), %rdi     # 0x1667d0
callq 0x10f440
movq %rax, 0x8(%rsp)
jmp 0x10d42f
movq 0x8(%rsp), %rsi
decq %rsi
leaq 0x59392(%rip), %rdi     # 0x1667d0
callq 0x10f420
movq %rax, (%rsp)
jmp 0x10d449
leaq 0x28(%rsp), %rdi
callq 0x10f460
movq (%rsp), %rax
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x10f460
jmp 0x10d476
jmp 0x10d478
movq 0x20(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x111580
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0x111e90
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x111ec0
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0x111f00
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x111ec0
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x111f30
testb $0x1, %al
jne 0x111551
jmp 0x111579
leaq 0x28(%rsp), %rdi
callq 0x111f70
movq 0x8(%rsp), %rsi
movq (%rax), %rdi
addq $0x20, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x28(%rsp), %rdi
callq 0x111f80
jmp 0x11153c
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x111640
movq 0x8(%rsp), %rdi
movl (%rdi), %eax
movl %eax, 0x20(%rdi)
movl 0x4(%rdi), %eax
movl %eax, 0x24(%rdi)
addq $0x20, %rdi
addq $0x8, %rdi
callq 0x112080
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0xdd280
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1120a0
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0xdd2b0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1120a0
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xdd3e0
testb $0x1, %al
jne 0x11160e
jmp 0x111631
leaq 0x28(%rsp), %rdi
callq 0xdd420
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x1117f0
leaq 0x28(%rsp), %rdi
callq 0xdd430
jmp 0x1115f9
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/utils/bamtools_pileup_engine.cpp
// Function: BamTools::PileupEngine::PileupEnginePrivate::ClearOldData()
void PileupEngine::PileupEnginePrivate::ClearOldData(void) {
 
    // remove any alignments that end before our CurrentPosition
    // N.B. - BAM positions are 0-based, half-open. GetEndPosition() returns a 1-based position,
    //        while our CurrentPosition is 0-based. For example, an alignment with 'endPosition' of
    //        100 does not overlap a 'CurrentPosition' of 100, and should be discarded.

    size_t i = 0;
    size_t j = 0;
    const size_t numAlignments = CurrentAlignments.size();
    while ( i < numAlignments ) {

        // skip over alignment if its (1-based) endPosition is <= to (0-based) CurrentPosition
        // i.e. this entry will not be saved upon vector resize
        const int endPosition = CurrentAlignments[i].GetEndPosition();
        if ( endPosition <= CurrentPosition ) {
            ++i;
            continue;
        }

        // otherwise alignment ends after CurrentPosition
        // move it towards vector beginning, at index j
        if ( i != j )
            CurrentAlignments[j] = CurrentAlignments[i];

        // increment our indices
        ++i;
        ++j;
    }

    // 'squeeze' vector to size j, discarding all remaining alignments in the container
    CurrentAlignments.resize(j);
}

// Assembly:
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, 0x1b0(%rsp)
movq 0x1b0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq $0x0, 0x1a8(%rsp)
movq $0x0, 0x1a0(%rsp)
addq $0x8, %rdi
callq 0xdd090
movq %rax, 0x198(%rsp)
movq 0x1a8(%rsp), %rax
cmpq 0x198(%rsp), %rax
jae 0x111768
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movq 0x1a8(%rsp), %rsi
callq 0x111fa0
movq %rax, %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x86660
movq 0x20(%rsp), %rcx
movl %eax, 0x194(%rsp)
movl 0x194(%rsp), %eax
cmpl 0x4(%rcx), %eax
jg 0x1116eb
movq 0x1a8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x1a8(%rsp)
jmp 0x111685
movq 0x1a8(%rsp), %rax
cmpq 0x1a0(%rsp), %rax
je 0x11173b
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movq 0x1a8(%rsp), %rsi
callq 0x111fa0
movq 0x20(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x8, %rdi
movq 0x1a0(%rsp), %rsi
callq 0x111fa0
movq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0xdede0
movq 0x1a8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x1a8(%rsp)
movq 0x1a0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x1a0(%rsp)
jmp 0x111685
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, (%rsp)
movq 0x1a0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x86260
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x111fc0
jmp 0x1117a6
leaq 0x38(%rsp), %rdi
callq 0x86b30
addq $0x1b8, %rsp            # imm = 0x1B8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x86b30
jmp 0x1117d2
jmp 0x1117d4
movq 0x30(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x86ac0
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x115cba
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x86ee0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movsbl (%rax), %eax
subl $0x41, %eax
movslq %eax, %r8
movl $0x1, %ecx
leaq 0x1e653(%rip), %rax     # 0x1342f0
movq %rcx, %rdx
movsbl (%rax,%r8), %r8d
callq 0x86c40
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x115c51
movq 0x20(%rsp), %rdi
callq 0x115bf0
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, 0x10(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x18(%rsp)
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movb %al, 0x1e7(%rsp)
movq 0x1e8(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x928c0
movq 0x20(%rsp), %rsi
movl %eax, %edx
leaq 0x58(%rsp), %rdi
callq 0x86be0
leaq 0x38(%rsp), %rdi
callq 0x86a30
jmp 0x115d36
movq 0x10(%rsp), %rdi
movb $0x0, 0x2b(%rsp)
callq 0x92a40
jmp 0x115d47
jmp 0x115d49
movsbl 0x1e7(%rsp), %edx
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x86e50
movq %rax, 0x8(%rsp)
jmp 0x115d67
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x86b60
movq %rax, (%rsp)
jmp 0x115d81
movq (%rsp), %rax
cmpq $0x0, %rax
je 0x115dd8
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x91220
jmp 0x115d9c
jmp 0x115d49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x115e25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x115e17
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x92a50
jmp 0x115dfe
movb $0x1, 0x2b(%rsp)
testb $0x1, 0x2b(%rsp)
jne 0x115df2
movq 0x10(%rsp), %rdi
callq 0x92a50
jmp 0x115df0
jmp 0x115df2
leaq 0x38(%rsp), %rdi
callq 0x86f68
jmp 0x115e00
jmp 0x115e17
leaq 0x58(%rsp), %rdi
callq 0x86580
movq 0x18(%rsp), %rax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
leaq 0x38(%rsp), %rdi
callq 0x86f68
jmp 0x115e23
jmp 0x115e25
leaq 0x58(%rsp), %rdi
callq 0x86580
jmp 0x115e31
jmp 0x115e33
movq 0x30(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0x50(%rsp)
movq %rdi, %rax
movq %rax, 0x58(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movb $0x0, 0xbf(%rsp)
callq 0x92a40
movq 0xc8(%rsp), %rdi
callq 0x86500
movq %rax, 0x60(%rsp)
jmp 0x115e9d
movq 0x60(%rsp), %rdi
incq %rdi
callq 0x86040
movq %rax, 0x48(%rsp)
jmp 0x115eb1
movq 0x48(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x86320
movq %rax, 0x40(%rsp)
jmp 0x115eef
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdi
callq 0x86690
movq 0x90(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x86320
movq %rax, 0x30(%rsp)
jmp 0x115f1f
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0x86b50
movq %rax, 0xb0(%rsp)
cmpq $0x0, 0xb0(%rsp)
je 0x11602a
movq 0xb0(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x86da0
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x70(%rsp), %rdi
callq 0x86a00
jmp 0x115f77
movq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x91220
jmp 0x115f88
leaq 0x70(%rsp), %rdi
callq 0x86f68
jmp 0x115f94
leaq 0x6f(%rsp), %rdi
callq 0x867b0
movq 0xc0(%rsp), %rdi
callq 0x86320
movq %rax, 0x10(%rsp)
jmp 0x115fb2
movq 0x10(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x86b50
movq %rax, 0xb0(%rsp)
jmp 0x115f36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x116070
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x11601e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x86f68
jmp 0x11601c
jmp 0x11601e
leaq 0x6f(%rsp), %rdi
callq 0x867b0
jmp 0x116070
movq 0xa8(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x116047
movq 0x8(%rsp), %rdi
callq 0x86930
movb $0x1, 0xbf(%rsp)
testb $0x1, 0xbf(%rsp)
jne 0x116063
movq 0x50(%rsp), %rdi
callq 0x92a50
movq 0x58(%rsp), %rax
addq $0xd8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x92a50
jmp 0x11607c
jmp 0x11607e
movq 0xa0(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Features::strictMode()
Features 
Features::strictMode()
{
   Features features;
   features.allowComments_ = false;
   features.strictRoot_ = true;
   return features;
}

// Assembly:
pushq %rax
leaq 0x6(%rsp), %rdi
callq 0x116370
movb $0x0, 0x6(%rsp)
movb $0x1, 0x7(%rsp)
movw 0x6(%rsp), %ax
popq %rcx
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movb %cl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x38(%rsp), %rsi
addq $0xa0, %rdi
callq 0x86070
movq 0x8(%rsp), %rdi
addq $0xa0, %rdi
callq 0x86320
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0xa0, %rdi
callq 0x86ac0
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x30(%rsp), %rcx
movb 0x2f(%rsp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x116730
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::skipCommentTokens(Json::Reader::Token&)
void 
Reader::skipCommentTokens( Token &token )
{
   if ( features_.allowComments_ )
   {
      do
      {
         readToken( token );
      }
      while ( token.type_ == tokenComment );
   }
   else
   {
      readToken( token );
   }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x108(%rax)
je 0x116e3c
jmp 0x116e22
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x117f80
movq 0x8(%rsp), %rax
cmpl $0xc, (%rax)
je 0x116e22
jmp 0x116e4a
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x117f80
addq $0x18, %rsp
retq
nop
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::addError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Json::Reader::Token&, char const*)
bool 
Reader::addError( const std::string &message, 
                  Token &token,
                  Location extra )
{
   ErrorInfo info;
   info.token_ = token;
   info.message_ = message;
   info.extra_ = extra;
   errors_.push_back( info );
   return false;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x11a6f0
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x30(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x78(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x86070
jmp 0x116eac
movq 0x8(%rsp), %rdi
movq 0x68(%rsp), %rax
movq %rax, 0x58(%rsp)
addq $0x50, %rdi
leaq 0x20(%rsp), %rsi
callq 0x11a710
jmp 0x116ecb
leaq 0x20(%rsp), %rdi
callq 0xa8db0
xorl %eax, %eax
andb $0x1, %al
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xa8db0
jmp 0x116efb
jmp 0x116efd
movq 0x18(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nop
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::decodeString(Json::Reader::Token&)
bool 
Reader::decodeString( Token &token )
{
   std::string decoded;
   if ( !decodeString( token, decoded ) )
      return false;
   currentValue() = decoded;
   return true;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x86a30
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x70(%rsp), %rsi
callq 0x118a30
movb %al, 0x27(%rsp)
jmp 0x117ea4
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x117ed6
jmp 0x117eae
movb $0x0, 0x87(%rsp)
movl $0x1, 0x40(%rsp)
jmp 0x117f43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x117f5e
leaq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1215c0
jmp 0x117ee7
movq 0x10(%rsp), %rdi
callq 0x116f10
movq %rax, 0x8(%rsp)
jmp 0x117ef8
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x121b00
jmp 0x117f09
leaq 0x28(%rsp), %rdi
callq 0x121950
jmp 0x117f15
movb $0x1, 0x87(%rsp)
movl $0x1, 0x40(%rsp)
jmp 0x117f43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x121950
jmp 0x117f41
jmp 0x117f5e
leaq 0x50(%rsp), %rdi
callq 0x86f68
movb 0x87(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
retq
leaq 0x50(%rsp), %rdi
callq 0x86f68
jmp 0x117f6a
jmp 0x117f6c
movq 0x48(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nop
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::expectToken(Json::Reader::TokenType, Json::Reader::Token&, char const*)
bool 
Reader::expectToken( TokenType type, Token &token, const char *message )
{
   readToken( token );
   if ( token.type_ != type )
      return addError( message, token );
   return true;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movl %esi, 0x74(%rsp)
movq %rdx, 0x68(%rsp)
movq %rcx, 0x60(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x68(%rsp), %rsi
callq 0x117f80
movq 0x68(%rsp), %rax
movl (%rax), %eax
cmpl 0x74(%rsp), %eax
je 0x118249
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x86da0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x86a00
jmp 0x1181ce
movq 0x20(%rsp), %rdi
movq 0x68(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
leaq 0x40(%rsp), %rsi
callq 0x116e50
movb %al, 0xf(%rsp)
jmp 0x1181ec
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x87(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x86f68
jmp 0x118205
leaq 0x3f(%rsp), %rdi
callq 0x867b0
jmp 0x118251
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x11823d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x86f68
jmp 0x11823b
jmp 0x11823d
leaq 0x3f(%rsp), %rdi
callq 0x867b0
jmp 0x118262
movb $0x1, 0x87(%rsp)
movb 0x87(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::skipSpaces()
void 
Reader::skipSpaces()
{
   while ( current_ != end_ )
   {
      Char c = *current_;
      if ( c == ' '  ||  c == '\t'  ||  c == '\r'  ||  c == '\n' )
         ++current_;
      else
         break;
   }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rcx
movq 0xd0(%rcx), %rax
cmpq 0xc8(%rcx), %rax
je 0x1182fb
movq -0x18(%rsp), %rax
movq 0xd0(%rax), %rax
movb (%rax), %al
movb %al, -0x9(%rsp)
movsbl -0x9(%rsp), %eax
cmpl $0x20, %eax
je 0x1182de
movsbl -0x9(%rsp), %eax
cmpl $0x9, %eax
je 0x1182de
movsbl -0x9(%rsp), %eax
cmpl $0xd, %eax
je 0x1182de
movsbl -0x9(%rsp), %eax
cmpl $0xa, %eax
jne 0x1182f7
movq -0x18(%rsp), %rax
movq 0xd0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xd0(%rax)
jmp 0x1182f9
jmp 0x1182fb
jmp 0x11828f
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::readString()
bool
Reader::readString()
{
   Char c = 0;
   while ( current_ != end_ )
   {
      c = getNextChar();
      if ( c == '\\' )
         getNextChar();
      else if ( c == '"' )
         break;
   }
   return c == '"';
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movb $0x0, 0xf(%rsp)
movq (%rsp), %rcx
movq 0xd0(%rcx), %rax
cmpq 0xc8(%rcx), %rax
je 0x1183ad
movq (%rsp), %rdi
callq 0x118300
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0x5c, %eax
jne 0x11839d
movq (%rsp), %rdi
callq 0x118300
jmp 0x1183ab
movsbl 0xf(%rsp), %eax
cmpl $0x22, %eax
jne 0x1183a9
jmp 0x1183ad
jmp 0x1183ab
jmp 0x118367
movsbl 0xf(%rsp), %eax
cmpl $0x22, %eax
sete %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::readComment()
bool
Reader::readComment()
{
   Location commentBegin = current_ - 1;
   Char c = getNextChar();
   bool successful = false;
   if ( c == '*' )
      successful = readCStyleComment();
   else if ( c == '/' )
      successful = readCppStyleComment();
   if ( !successful )
      return false;

   if ( collectComments_ )
   {
      CommentPlacement placement = commentBefore;
      if ( lastValueEnd_  &&  !containsNewLine( lastValueEnd_, commentBegin ) )
      {
         if ( c != '*'  ||  !containsNewLine( commentBegin, current_ ) )
            placement = commentAfterOnSameLine;
      }

      addComment( commentBegin, current_, placement );
   }
   return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movq 0xd0(%rdi), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
callq 0x118300
movb %al, 0xf(%rsp)
movb $0x0, 0xe(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0x2a, %eax
jne 0x11840b
movq (%rsp), %rdi
callq 0x118630
andb $0x1, %al
movb %al, 0xe(%rsp)
jmp 0x118426
movsbl 0xf(%rsp), %eax
cmpl $0x2f, %eax
jne 0x118424
movq (%rsp), %rdi
callq 0x1186a0
andb $0x1, %al
movb %al, 0xe(%rsp)
jmp 0x118426
testb $0x1, 0xe(%rsp)
jne 0x118437
movb $0x0, 0x27(%rsp)
jmp 0x1184be
movq (%rsp), %rax
testb $0x1, 0x10a(%rax)
je 0x1184b9
movq (%rsp), %rax
movl $0x0, 0x8(%rsp)
cmpq $0x0, 0xd8(%rax)
je 0x1184a0
movq (%rsp), %rax
movq 0xd8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x118700
testb $0x1, %al
jne 0x1184a0
movsbl 0xf(%rsp), %eax
cmpl $0x2a, %eax
jne 0x118496
movq (%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0xd0(%rax), %rsi
callq 0x118700
testb $0x1, %al
jne 0x11849e
movl $0x1, 0x8(%rsp)
jmp 0x1184a0
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0xd0(%rdi), %rdx
movl 0x8(%rsp), %ecx
callq 0x118760
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::readNumber()
void 
Reader::readNumber()
{
   while ( current_ != end_ )
   {
      if ( !(*current_ >= '0'  &&  *current_ <= '9')  &&
           !in( *current_, '.', 'e', 'E', '+', '-' ) )
         break;
      ++current_;
   }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0xd0(%rcx), %rax
cmpq 0xc8(%rcx), %rax
je 0x118571
movq 0x8(%rsp), %rax
movq 0xd0(%rax), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x118520
movq 0x8(%rsp), %rax
movq 0xd0(%rax), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x118555
movq 0x8(%rsp), %rax
movq 0xd0(%rax), %rax
movl $0x2e, %esi
movl $0x65, %edx
movl $0x45, %ecx
movl $0x2b, %r8d
movl $0x2d, %r9d
movsbl (%rax), %edi
callq 0x118970
testb $0x1, %al
jne 0x118555
jmp 0x118571
movq 0x8(%rsp), %rax
movq 0xd0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xd0(%rax)
jmp 0x1184e3
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::match(char const*, int)
bool 
Reader::match( Location pattern, 
               int patternLength )
{
   if ( end_ - current_ < patternLength )
      return false;
   int index = patternLength;
   while ( index-- )
      if ( current_[index] != pattern[index] )
         return false;
   current_ += patternLength;
   return true;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movq -0x10(%rsp), %rcx
movq %rcx, -0x28(%rsp)
movq 0xc8(%rcx), %rax
movq 0xd0(%rcx), %rcx
subq %rcx, %rax
movslq -0x1c(%rsp), %rcx
cmpq %rcx, %rax
jge 0x1185ba
movb $0x0, -0x1(%rsp)
jmp 0x118626
movl -0x1c(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rsp)
cmpl $0x0, %eax
je 0x118604
movq -0x28(%rsp), %rax
movq 0xd0(%rax), %rax
movslq -0x20(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rsp), %rcx
movslq -0x20(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x118602
movb $0x0, -0x1(%rsp)
jmp 0x118626
jmp 0x1185c2
movq -0x28(%rsp), %rax
movl -0x1c(%rsp), %edx
movq 0xd0(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0xd0(%rax)
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::readCStyleComment()
bool 
Reader::readCStyleComment()
{
   while ( current_ != end_ )
   {
      Char c = getNextChar();
      if ( c == '*'  &&  *current_ == '/' )
         break;
   }
   return getNextChar() == '/';
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0xd0(%rcx), %rax
cmpq 0xc8(%rcx), %rax
je 0x118684
movq (%rsp), %rdi
callq 0x118300
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0x2a, %eax
jne 0x118682
movq (%rsp), %rax
movq 0xd0(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x118682
jmp 0x118684
jmp 0x118642
movq (%rsp), %rdi
callq 0x118300
movsbl %al, %eax
cmpl $0x2f, %eax
sete %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::readCppStyleComment()
bool 
Reader::readCppStyleComment()
{
   while ( current_ != end_ )
   {
      Char c = getNextChar();
      if (  c == '\r'  ||  c == '\n' )
         break;
   }
   return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0xd0(%rcx), %rax
cmpq 0xc8(%rcx), %rax
je 0x1186eb
movq (%rsp), %rdi
callq 0x118300
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0xd, %eax
je 0x1186e7
movsbl 0xf(%rsp), %eax
cmpl $0xa, %eax
jne 0x1186e9
jmp 0x1186eb
jmp 0x1186b2
movb $0x1, %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::containsNewLine(char const*, char const*)
static bool 
containsNewLine( Reader::Location begin, 
                 Reader::Location end )
{
   for ( ;begin < end; ++begin )
      if ( *begin == '\n'  ||  *begin == '\r' )
         return true;
   return false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
cmpq -0x18(%rsp), %rax
jae 0x118749
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x118730
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0x118737
movb $0x1, -0x1(%rsp)
jmp 0x11874e
jmp 0x118739
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x11870a
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)