LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mshabbirhasan[P]ups-indel/include/seqan/stream/tokenize.h
// Function: int seqan::_readHelper<seqan::TabOrLineBreak__, seqan::RecordReader<std::basic_ifstream<char, std::char_traits<char>>, seqan::SinglePass<void>>, seqan::String<char, seqan::Alloc<void>>>(seqan::String<char, seqan::Alloc<void>>&, seqan::RecordReader<std::basic_ifstream<char, std::char_traits<char>>, seqan::SinglePass<void>>&, seqan::Tag<seqan::TabOrLineBreak__> const&, bool)
inline int
_readHelper(TBuffer & buffer,
            TRecordReader & reader,
            Tag<TTagSpec> const & tag,
            bool const desiredOutcomeOfComparison) 
/*   desired behaviour of loop -> "readUntil()" or "readwhile()"  */
{
    typedef char TChar;

    while (!atEnd(reader))
    {
        TChar c = value(reader);
        if (bool( _charCompare(c, tag)) == desiredOutcomeOfComparison)
            return 0;
        appendValue(buffer, c, Generous());
        goNext(reader);
        if (resultCode(reader) != 0)
            return resultCode(reader);
    }
    return EOF_BEFORE_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rdi
callq 0x134a0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1451c
jmp 0x1458a
movq -0x18(%rbp), %rdi
callq 0x135b0
movb %al, -0x22(%rbp)
movsbl -0x22(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x145a0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movb -0x21(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x14556
movl $0x0, -0x4(%rbp)
jmp 0x14591
movq -0x10(%rbp), %rdi
leaq -0x22(%rbp), %rsi
callq 0x145e0
movq -0x18(%rbp), %rdi
callq 0x14610
movq -0x18(%rbp), %rdi
callq 0x146b0
cmpl $0x0, %eax
je 0x14588
movq -0x18(%rbp), %rdi
callq 0x146b0
movl %eax, -0x4(%rbp)
jmp 0x14591
jmp 0x1450b
movl $0x400, -0x4(%rbp)      # imm = 0x400
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/stream/record_reader_single.h
// Function: bool seqan::goNext<std::basic_ifstream<char, std::char_traits<char>>>(seqan::RecordReader<std::basic_ifstream<char, std::char_traits<char>>, seqan::SinglePass<void>>&)
inline bool
goNext(RecordReader<TFile, SinglePass<void> > & recordReader)
{
    SEQAN_ASSERT(recordReader._current != recordReader._end);

    recordReader._current += 1;
    // If there is more data in the buffer then we're done.
    if (recordReader._current != recordReader._end)
        return false;  // Has more data.

    // Otherwise, try to load some data.
    return !_refillBuffer(recordReader);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq 0x1430e(%rip), %rdi     # 0x28949
movl $0xf5, %esi
leaq -0x11(%rbp), %rdx
leaq 0x1432a(%rip), %rcx     # 0x28975
callq 0x11cb0
xorb $-0x1, %al
testb $0x1, %al
jne 0x14658
jmp 0x1465d
callq 0xb2a0
jmp 0x1465f
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
je 0x14687
movb $0x0, -0x1(%rbp)
jmp 0x14697
movq -0x10(%rbp), %rdi
callq 0x14110
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/sequence/string_set_base.h
// Function: void seqan::_refreshStringSetLimits<seqan::String<char, seqan::Alloc<void>>, seqan::Owner<seqan::Tag<seqan::Default_>>>(seqan::StringSet<seqan::String<char, seqan::Alloc<void>>, seqan::Owner<seqan::Tag<seqan::Default_>>>&)
void _refreshStringSetLimits(StringSet< TString, TSpec > & me)
{
    typedef StringSet< TString, TSpec >                 TStringSet;
    typedef typename StringSetLimits<TStringSet>::Type  TLimits;

    typename Value<TLimits>::Type   sum = 0;
    typename Size<TStringSet>::Type len = length(me);
    typename Size<TStringSet>::Type i = 0;

//      SEQAN_ASSERT_EQ(length(me.limits), len + 1);
    resize(me.limits, len + 1, Generous());
    for(; i < len; ++i)
    {
        me.limits[i] = sum;
        sum += length(me[i]);
        SEQAN_ASSERT_LEQ(me.limits[i], sum);
    }
    me.limits[i] = sum;
    me.limitsValid = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcc10
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x14b50
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x14aae
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
callq 0x14b80
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd6a0
movq %rax, %rdi
callq 0xd920
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
callq 0x14b80
movq %rax, %rdx
leaq 0x13f2c(%rip), %rdi     # 0x289a0
movl $0x51d, %esi            # imm = 0x51D
leaq 0x13f49(%rip), %rcx     # 0x289c9
leaq -0x10(%rbp), %r8
leaq 0x13f4b(%rip), %r9      # 0x289d6
callq 0x14bb0
testb $0x1, %al
jne 0x14a99
callq 0xb2a0
jmp 0x14a9b
jmp 0x14a9d
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x14a0e
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
callq 0x14b80
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x30(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/sequence/string_alloc.h
// Function: seqan::String<char, seqan::Alloc<void>>::String(seqan::String<char, seqan::Alloc<void>> const&)
String(String const & source)
        : data_begin(0),
          data_end(0),
          data_capacity(0)
    {
        reserve(*this, std::min(capacity(source), computeGenerousCapacity(source, length(source))), Exact());
        if (length(source) > 0u)
            assign(*this, source);
        SEQAN_ASSERT_LEQ_MSG(data_begin, data_end, "String end is before begin!");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0xfe90
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd920
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xff90
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x15210
movq -0x30(%rbp), %rdi
movq (%rax), %rsi
callq 0x151e0
movq -0x10(%rbp), %rdi
callq 0xd920
cmpq $0x0, %rax
jbe 0x15102
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15250
jmp 0x15104
movq -0x30(%rbp), %rdx
movq %rdx, %r8
addq $0x8, %r8
leaq 0x1348a(%rip), %rdi     # 0x285a0
movl $0x86, %esi
leaq 0x134a4(%rip), %rcx     # 0x285c6
leaq 0x134a8(%rip), %r9      # 0x285d1
leaq 0x134aa(%rip), %rax     # 0x285da
movq %rax, (%rsp)
movb $0x0, %al
callq 0xb800
testb $0x1, %al
jne 0x15144
callq 0xb2a0
jmp 0x15146
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/basic/array_construct_destruct.h
// Function: void seqan::_arrayConstructCopyDefault<seqan::String<char, seqan::Alloc<void>>*, seqan::String<char, seqan::Alloc<void>>*, seqan::String<char, seqan::Alloc<void>>*>(seqan::String<char, seqan::Alloc<void>>*, seqan::String<char, seqan::Alloc<void>>*, seqan::String<char, seqan::Alloc<void>>*)
inline void 
_arrayConstructCopyDefault(TSource1 source_begin, 
                           TSource2 source_end, 
                           TTarget target_begin)
{
    SEQAN_CHECKPOINT;
    while (source_begin != source_end)
    {
        // NOTE(holtgrew): getValue() is used here since value() could return
        // a proxy!
        valueConstruct(target_begin, getValue(source_begin));
        ++source_begin;
        ++target_begin;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x156d5
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x156e0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x15180
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x15694
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/stream/tokenize.h
// Function: int seqan::_skipHelper<seqan::UnixEOL__, seqan::RecordReader<std::basic_ifstream<char, std::char_traits<char>>, seqan::SinglePass<void>>>(seqan::RecordReader<std::basic_ifstream<char, std::char_traits<char>>, seqan::SinglePass<void>>&, seqan::Tag<seqan::UnixEOL__> const&, bool)
inline int
_skipHelper(TRecordReader & reader,
            Tag<TTagSpec> const & tag,
            bool const desiredOutcomeOfComparison)
{
    typedef char TChar;

    while (!atEnd(reader))
    {
        TChar c = value(reader);
        if (bool(_charCompare(c, tag)) == desiredOutcomeOfComparison)
            return 0;
        goNext(reader);
        if (resultCode(reader) != 0)
            return resultCode(reader);
    }
    return EOF_BEFORE_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
callq 0x134a0
xorb $-0x1, %al
testb $0x1, %al
jne 0x15a98
jmp 0x15af9
movq -0x10(%rbp), %rdi
callq 0x135b0
movb %al, -0x1a(%rbp)
movsbl -0x1a(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x15b10
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movb -0x19(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x15ad2
movl $0x0, -0x4(%rbp)
jmp 0x15b00
movq -0x10(%rbp), %rdi
callq 0x14610
movq -0x10(%rbp), %rdi
callq 0x146b0
cmpl $0x0, %eax
je 0x15af7
movq -0x10(%rbp), %rdi
callq 0x146b0
movl %eax, -0x4(%rbp)
jmp 0x15b00
jmp 0x15a87
movl $0x400, -0x4(%rbp)      # imm = 0x400
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/seq_io/guess_stream_format.h
// Function: bool seqan::guessStreamFormat<seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>, seqan::TagList<seqan::Tag<seqan::TagFastq_>, seqan::TagList<seqan::Tag<seqan::TagFasta_>, void>>>(seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>&, seqan::TagSelector<seqan::TagList<seqan::Tag<seqan::TagFastq_>, seqan::TagList<seqan::Tag<seqan::TagFasta_>, void>>>&)
inline bool
guessStreamFormat(TRecordReader & reader, TagSelector<TTagList> & format)
{
    // (weese:) compare with guessFormat in file_format_mmap.h
    typedef typename TTagList::Type TFormatTag;

    if (value(format) == -1 || value(format) == Find<TTagList, TFormatTag>::VALUE)
    {
        // if tagId is set to -1 (auto-detect) or the current format (TFormatTag) then test for TFormatTag format
        if (guessStreamFormat(reader, TFormatTag()))
        {
            value(format) = Find<TTagList, TFormatTag>::VALUE;
            return true;
        }
    }
    return guessStreamFormat(reader, static_cast<typename TagSelector<TTagList>::Base &>(format));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16de0
cmpl $-0x1, (%rax)
je 0x1682c
movq -0x18(%rbp), %rdi
callq 0x16de0
cmpl $0x1, (%rax)
jne 0x16856
movq -0x10(%rbp), %rdi
leaq -0x19(%rbp), %rsi
callq 0x16df0
testb $0x1, %al
jne 0x1683f
jmp 0x16854
movq -0x18(%rbp), %rdi
callq 0x16de0
movl $0x1, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x16868
jmp 0x16856
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16f70
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/stream/tokenize.h
// Function: int seqan::readLine<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>, seqan::String<char, seqan::Alloc<void>>>(seqan::String<char, seqan::Alloc<void>>&, seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>&)
inline int
readLine(TBuffer & buffer, RecordReader<TStream, TPass> & reader)
{
    int r = 0;

    // Loop over characters from stream, taking early exits on line breaks and errors.
    while (!atEnd(reader))
    {
        char c = value(reader);

        // Unix EOL is the simplest case.
        if (c == '\n')
        {
            if (!atEnd(reader))
                goNext(reader);
            return resultCode(reader);
        }

        // If the current character is '\r' then this can be an ANSI or a Mac line ending.
        if (c == '\r')
        {
            goNext(reader);
            if ((r = resultCode(reader)) != 0)
                return r;
            if (atEnd(reader))
                return 0;  // Assume Mac EOL at end of file.
            if (value(reader) == '\n')
            {
                // Assume Windows EOL.
                if (!atEnd(reader))
                    goNext(reader);
                return resultCode(reader);
            }
            return 0;  // Was Mac EOL, not at end of file.
        }

        appendValue(buffer, c);
        goNext(reader);
    }

    return EOF_BEFORE_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x168a0
xorb $-0x1, %al
testb $0x1, %al
jne 0x16a4b
jmp 0x16b23
movq -0x18(%rbp), %rdi
callq 0x168c0
movb %al, -0x1d(%rbp)
movsbl -0x1d(%rbp), %eax
cmpl $0xa, %eax
jne 0x16a87
movq -0x18(%rbp), %rdi
callq 0x168a0
testb $0x1, %al
jne 0x16a76
movq -0x18(%rbp), %rdi
callq 0x16920
movq -0x18(%rbp), %rdi
callq 0x17570
movl %eax, -0x4(%rbp)
jmp 0x16b2a
movsbl -0x1d(%rbp), %eax
cmpl $0xd, %eax
jne 0x16b08
movq -0x18(%rbp), %rdi
callq 0x16920
movq -0x18(%rbp), %rdi
callq 0x17570
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x16ab2
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x16b2a
movq -0x18(%rbp), %rdi
callq 0x168a0
testb $0x1, %al
jne 0x16ac1
jmp 0x16aca
movl $0x0, -0x4(%rbp)
jmp 0x16b2a
movq -0x18(%rbp), %rdi
callq 0x168c0
movsbl %al, %eax
cmpl $0xa, %eax
jne 0x16aff
movq -0x18(%rbp), %rdi
callq 0x168a0
testb $0x1, %al
jne 0x16af1
movq -0x18(%rbp), %rdi
callq 0x16920
movq -0x18(%rbp), %rdi
callq 0x17570
movl %eax, -0x4(%rbp)
jmp 0x16b2a
movl $0x0, -0x4(%rbp)
jmp 0x16b2a
movq -0x10(%rbp), %rdi
leaq -0x1d(%rbp), %rsi
callq 0x176a0
movq -0x18(%rbp), %rdi
callq 0x16920
jmp 0x16a37
movl $0x400, -0x4(%rbp)      # imm = 0x400
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/seq_io/read_fasta_fastq.h
// Function: bool seqan::guessStreamFormat<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>(seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>&, seqan::Tag<seqan::TagFastq_> const&)
inline bool
guessStreamFormat(RecordReader<TStream, TPass> & reader, Fastq const & /*tag*/)
{
    LimitRecordReaderInScope<TStream, TPass> limiter(reader);
    while (!atEnd(reader))
    {
        CharString meta;
        CharString seq;
        CharString qual;
        int r = readRecord(meta, seq, qual, reader, Fastq());
        if (r == RecordReader<TStream, TPass>::INVALID_FORMAT)
            return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x16ff0
movq -0x10(%rbp), %rdi
callq 0x168a0
movb %al, -0x95(%rbp)
jmp 0x16e21
movb -0x95(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x16e32
jmp 0x16f36
leaq -0x58(%rbp), %rdi
callq 0xb3a0
jmp 0x16e3d
leaq -0x70(%rbp), %rdi
callq 0xb3a0
jmp 0x16e48
leaq -0x88(%rbp), %rdi
callq 0xb3a0
jmp 0x16e56
movq -0x10(%rbp), %rcx
leaq -0x58(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x88(%rbp), %rdx
leaq -0x8d(%rbp), %r8
callq 0x17040
movl %eax, -0x9c(%rbp)
jmp 0x16e7d
movl -0x9c(%rbp), %eax
movl %eax, -0x8c(%rbp)
cmpl $0x1, -0x8c(%rbp)
jne 0x16ee9
movb $0x0, -0x1(%rbp)
movl $0x1, -0x94(%rbp)
jmp 0x16ef3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x16f5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x16f2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x16f22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xb7b0
jmp 0x16f22
movl $0x0, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xb7b0
leaq -0x70(%rbp), %rdi
callq 0xb7b0
leaq -0x58(%rbp), %rdi
callq 0xb7b0
movl -0x94(%rbp), %eax
testl %eax, %eax
jne 0x16f44
jmp 0x16f1d
jmp 0x16e10
leaq -0x70(%rbp), %rdi
callq 0xb7b0
leaq -0x58(%rbp), %rdi
callq 0xb7b0
jmp 0x16f5b
movb $0x1, -0x1(%rbp)
movl $0x1, -0x94(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x17110
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x17110
movq -0x38(%rbp), %rdi
callq 0x4770
nopl (%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/seq_io/read_fasta_fastq.h
// Function: int seqan::readRecord<seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>(seqan::String<char, seqan::Alloc<void>>&, seqan::String<char, seqan::Alloc<void>>&, seqan::String<char, seqan::Alloc<void>>&, seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>&, seqan::Tag<seqan::TagFastq_> const&)
inline int
readRecord(TIdString & meta,
           TSeqString & seq,
           TQualString & qual,
           RecordReader<TFile, TPass > & reader,
           Fastq const & /*tag*/)
{
    int res = _clearAndReserveMemory(meta, seq, qual, reader, Fastq());
    if (res)
        return res;

    res = _readMetaAndSequence(meta, seq, reader, Fastq());
    if (res)
        return res;

    res = _readQualityBlock(qual, reader, length(seq), meta, Fastq());
    if (res == 0 || res == EOF_BEFORE_SUCCESS)
        return 0;
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x35(%rbp), %r8
callq 0x17190
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x17086
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x170fd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x36(%rbp), %rcx
callq 0x17200
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x170ac
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x170fd
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd920
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl %eax, %edx
movq -0x10(%rbp), %rcx
leaq -0x37(%rbp), %r8
callq 0x17310
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x170ee
cmpl $0x400, -0x34(%rbp)     # imm = 0x400
jne 0x170f7
movl $0x0, -0x4(%rbp)
jmp 0x170fd
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/seq_io/read_fasta_fastq.h
// Function: int seqan::_clearAndReserveMemory<seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>, seqan::Tag<seqan::TagFastq_>>(seqan::String<char, seqan::Alloc<void>>&, seqan::String<char, seqan::Alloc<void>>&, seqan::String<char, seqan::Alloc<void>>&, seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>&, seqan::Tag<seqan::TagFastq_> const&)
inline int
_clearAndReserveMemory(TIdString & meta, TSeqString & seq, TQualString & qual,
                       RecordReader<TFile, TSpec> & reader,
                       TTag const & tag)
{
    int res = _clearAndReserveMemory(meta, seq, reader, tag);
    clear(qual);
    reserve(qual, capacity(seq), Exact());
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x17530
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13670
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfe90
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x151e0
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/seq_io/read_fasta_fastq.h
// Function: int seqan::_readMetaAndSequence<seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>, seqan::Tag<seqan::TagFastq_>>(seqan::String<char, seqan::Alloc<void>>&, seqan::String<char, seqan::Alloc<void>>&, seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>&, seqan::Tag<seqan::TagFastq_> const&)
inline int
_readMetaAndSequence(TIdString & meta, TSeqString & seq,
                     RecordReader<TFile, TPass > & reader,
                     TTag const & formatTag)
{
    // READ META
    if (atEnd(reader) || value(reader) != MetaFirstChar_<TTag>::VALUE)
        return RecordReader<TFile, TPass>::INVALID_FORMAT;
    goNext(reader);
    if (resultCode(reader))
        return resultCode(reader);
    if (atEnd(reader)) // empty ID, no sequence, this is legal
        return 0;

    int res = readLine(meta, reader);
    if (res == EOF_BEFORE_SUCCESS)
        return EOF_BEFORE_SUCCESS;
    else if (res)
        return res;

    if (atEnd(reader)) // no sequence
        return 0;

    // READ SEQUENCE
    res = _readSequenceFastAQ(seq, reader, formatTag);
    if (res && res != EOF_BEFORE_SUCCESS)
        return res;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x168a0
testb $0x1, %al
jne 0x17236
movq -0x20(%rbp), %rdi
callq 0x168c0
movsbl %al, %eax
cmpl $0x40, %eax
je 0x17242
movl $0x1, -0x4(%rbp)
jmp 0x172fe
movq -0x20(%rbp), %rdi
callq 0x16920
movq -0x20(%rbp), %rdi
callq 0x17570
cmpl $0x0, %eax
je 0x1726a
movq -0x20(%rbp), %rdi
callq 0x17570
movl %eax, -0x4(%rbp)
jmp 0x172fe
movq -0x20(%rbp), %rdi
callq 0x168a0
testb $0x1, %al
jne 0x17279
jmp 0x17282
movl $0x0, -0x4(%rbp)
jmp 0x172fe
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x16a20
movl %eax, -0x2c(%rbp)
cmpl $0x400, -0x2c(%rbp)     # imm = 0x400
jne 0x172a4
movl $0x400, -0x4(%rbp)      # imm = 0x400
jmp 0x172fe
cmpl $0x0, -0x2c(%rbp)
je 0x172b2
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x172fe
jmp 0x172b4
movq -0x20(%rbp), %rdi
callq 0x168a0
testb $0x1, %al
jne 0x172c3
jmp 0x172cc
movl $0x0, -0x4(%rbp)
jmp 0x172fe
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x17580
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x172f7
cmpl $0x400, -0x2c(%rbp)     # imm = 0x400
je 0x172f7
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x172fe
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/seq_io/read_fasta_fastq.h
// Function: int seqan::_readSequenceFastAQCharImpl<seqan::String<char, seqan::Alloc<void>>, seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>, seqan::Tag<seqan::TagFastq_>>(seqan::String<char, seqan::Alloc<void>>&, seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>&, seqan::Tag<seqan::TagFastq_> const&)
inline int
_readSequenceFastAQCharImpl(TString & string,
                            TRecordReader & reader,
                            TFormatTag const & /*formatTag*/)
{
    // The variable afterEol is true if we are after an EOL char and we are not at the beginning of the sequence
    // record.  Empty sequence lines are fine, non-existent ones are not.
    bool afterEol = false;

    while (!atEnd(reader))
    {
        char c = value(reader);
        if (c == '\r' || c == '\n')
        {
            afterEol = true;
            goNext(reader);
            if (resultCode(reader) != 0)
                return resultCode(reader);
            continue;
        }

        if (afterEol && c == AfterSeqFirstChar_<TFormatTag>::VALUE)
        {
            return 0;  // Done, at stop char.
        }

        if (!isspace(c))
            appendValue(string, c);
        afterEol = false;
        goNext(reader);
        if (resultCode(reader) != 0)
            return resultCode(reader);
    }

    return EOF_BEFORE_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rdi
callq 0x168a0
xorb $-0x1, %al
testb $0x1, %al
jne 0x175dc
jmp 0x17686
movq -0x18(%rbp), %rdi
callq 0x168c0
movb %al, -0x22(%rbp)
movsbl -0x22(%rbp), %eax
cmpl $0xd, %eax
je 0x175fa
movsbl -0x22(%rbp), %eax
cmpl $0xa, %eax
jne 0x17625
movb $0x1, -0x21(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16920
movq -0x18(%rbp), %rdi
callq 0x17570
cmpl $0x0, %eax
je 0x17623
movq -0x18(%rbp), %rdi
callq 0x17570
movl %eax, -0x4(%rbp)
jmp 0x1768d
jmp 0x175c8
testb $0x1, -0x21(%rbp)
je 0x1763d
movsbl -0x22(%rbp), %eax
cmpl $0x2b, %eax
jne 0x1763d
movl $0x0, -0x4(%rbp)
jmp 0x1768d
movsbl -0x22(%rbp), %edi
callq 0x40a0
cmpl $0x0, %eax
jne 0x17658
movq -0x10(%rbp), %rdi
leaq -0x22(%rbp), %rsi
callq 0x176a0
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16920
movq -0x18(%rbp), %rdi
callq 0x17570
cmpl $0x0, %eax
je 0x17681
movq -0x18(%rbp), %rdi
callq 0x17570
movl %eax, -0x4(%rbp)
jmp 0x1768d
jmp 0x175c8
movl $0x400, -0x4(%rbp)      # imm = 0x400
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/stream/tokenize.h
// Function: int seqan::_readNCharsIgnoringType<seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>, seqan::Tag<seqan::Whitespace__>>(seqan::String<char, seqan::Alloc<void>>&, seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>&, unsigned int, seqan::Tag<seqan::Whitespace__>)
inline int
_readNCharsIgnoringType(TBuffer & buffer,
                         RecordReader<TStream, TPass> & reader,
                         unsigned const n,
                         TIgnoredType /* tag */)
{
    SEQAN_CHECKPOINT


    reserve(buffer, n, Exact());

    for (unsigned i = 0; i < n; ++i)
    {
        if (atEnd(reader))
            return EOF_BEFORE_SUCCESS;

        if (_charCompare(value(reader), TIgnoredType()))
            --i;
        else
            appendValue(buffer, value(reader));

        goNext(reader);
        if (resultCode(reader) != 0)
            return resultCode(reader);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x17970
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x17c78
movq -0x18(%rbp), %rdi
callq 0x168a0
testb $0x1, %al
jne 0x17bf1
jmp 0x17bfd
movl $0x400, -0x4(%rbp)      # imm = 0x400
jmp 0x17c7f
movq -0x18(%rbp), %rdi
callq 0x168c0
movsbl %al, %edi
leaq -0x25(%rbp), %rsi
callq 0x17c90
cmpl $0x0, %eax
je 0x17c22
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x17c43
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x168c0
movq -0x30(%rbp), %rdi
movb %al, -0x26(%rbp)
leaq -0x26(%rbp), %rsi
callq 0x176a0
movq -0x18(%rbp), %rdi
callq 0x16920
movq -0x18(%rbp), %rdi
callq 0x17570
cmpl $0x0, %eax
je 0x17c68
movq -0x18(%rbp), %rdi
callq 0x17570
movl %eax, -0x4(%rbp)
jmp 0x17c7f
jmp 0x17c6a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x17bd6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/seq_io/read_fasta_fastq.h
// Function: bool seqan::guessStreamFormat<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>(seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>&, seqan::Tag<seqan::TagFasta_> const&)
inline bool
guessStreamFormat(RecordReader<TStream, TPass> & reader, Fasta const & /*tag*/)
{
    LimitRecordReaderInScope<TStream, TPass> limiter(reader);
    while (!atEnd(reader))
    {
        CharString meta;
        CharString seq;
        int r = readRecord(meta, seq, reader, Fasta());
//         std::cout << "Meta: " << toCString(meta) << "\nSeq: " << toCString(seq) << "\n";
        if (r == RecordReader<TStream, TPass>::INVALID_FORMAT)
            return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x16ff0
movq -0x10(%rbp), %rdi
callq 0x168a0
movb %al, -0x7d(%rbp)
jmp 0x17d1e
movb -0x7d(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x17d2c
jmp 0x17de0
leaq -0x58(%rbp), %rdi
callq 0xb3a0
jmp 0x17d37
leaq -0x70(%rbp), %rdi
callq 0xb3a0
jmp 0x17d42
movq -0x10(%rbp), %rdx
leaq -0x58(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x75(%rbp), %rcx
callq 0x17e40
movl %eax, -0x84(%rbp)
jmp 0x17d5f
movl -0x84(%rbp), %eax
movl %eax, -0x74(%rbp)
cmpl $0x1, -0x74(%rbp)
jne 0x17dae
movb $0x0, -0x1(%rbp)
movl $0x1, -0x7c(%rbp)
jmp 0x17db5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x17e02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x17dd5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xb7b0
jmp 0x17dd5
movl $0x0, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xb7b0
leaq -0x58(%rbp), %rdi
callq 0xb7b0
movl -0x7c(%rbp), %eax
testl %eax, %eax
jne 0x17deb
jmp 0x17dd0
jmp 0x17d10
leaq -0x58(%rbp), %rdi
callq 0xb7b0
jmp 0x17e02
movb $0x1, -0x1(%rbp)
movl $0x1, -0x7c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x17110
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x17110
movq -0x38(%rbp), %rdi
callq 0x4770
nopw %cs:(%rax,%rax)
nop
// File: mshabbirhasan[P]ups-indel/include/seqan/seq_io/read_fasta_fastq.h
// Function: int seqan::readRecord<seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>(seqan::String<char, seqan::Alloc<void>>&, seqan::String<char, seqan::Alloc<void>>&, seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>&, seqan::Tag<seqan::TagFasta_> const&)
inline int
readRecord(TIdString & meta,
           TSeqString & seq,
           RecordReader<TFile, TPass > & reader,
           Fasta const & /*tag*/)
{
    int res = _clearAndReserveMemory(meta, seq, reader, Fasta());
    if (res)
        return res;

    res = _readMetaAndSequence(meta, seq, reader, Fasta());
    if (res)
        return res;

    return _skipQualityBlock(reader, length(seq), Fasta());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x2d(%rbp), %rcx
callq 0x17ed0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x17e7e
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x17ec7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x2e(%rbp), %rcx
callq 0x17f10
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x17ea4
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x17ec7
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd920
movq -0x38(%rbp), %rdi
movl %eax, %esi
leaq -0x2f(%rbp), %rdx
callq 0x18020
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: mshabbirhasan[P]ups-indel/include/seqan/seq_io/fai_index.h
// Function: seqan::write(seqan::FaiIndex const&, char const*)
inline int write(FaiIndex const & index, char const * faiFilename)
{
    // Open index files.
    std::ofstream indexOut(faiFilename, std::ios::binary | std::ios::out);

    for (unsigned i = 0; i < length(index.indexEntryStore); ++i)
    {
        FaiIndexEntry_ const & entry = index.indexEntryStore[i];
        indexOut << entry.name << '\t' << entry.sequenceLength << '\t' << entry.offset << '\t'
                 << entry.lineLength << '\t' << entry.overallLineLength << '\n';
    }

    return !indexOut.good();  // 1 on errors, 0 on success.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x238(%rbp)
movl $0x4, %edi
movl $0x10, %esi
callq 0x9ee0
movq -0x238(%rbp), %rsi
movl %eax, %edx
leaq -0x210(%rbp), %rdi
callq 0x44b0
movl $0x0, -0x214(%rbp)
movl -0x214(%rbp), %eax
movq %rax, -0x248(%rbp)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x15c60
movq %rax, -0x240(%rbp)
jmp 0x1840f
movq -0x248(%rbp), %rax
movq -0x240(%rbp), %rcx
cmpq %rcx, %rax
jae 0x1859b
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movl -0x214(%rbp), %esi
callq 0x18600
movq %rax, -0x250(%rbp)
jmp 0x18442
movq -0x250(%rbp), %rax
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x18630
movq %rax, -0x258(%rbp)
jmp 0x1846c
movq -0x258(%rbp), %rdi
movl $0x9, %esi
callq 0x44c0
movq %rax, -0x260(%rbp)
jmp 0x18486
movq -0x260(%rbp), %rdi
movq -0x230(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x4130
movq %rax, -0x268(%rbp)
jmp 0x184a6
movq -0x268(%rbp), %rdi
movl $0x9, %esi
callq 0x44c0
movq %rax, -0x270(%rbp)
jmp 0x184c0
movq -0x270(%rbp), %rdi
movq -0x230(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x4130
movq %rax, -0x278(%rbp)
jmp 0x184e0
movq -0x278(%rbp), %rdi
movl $0x9, %esi
callq 0x44c0
movq %rax, -0x280(%rbp)
jmp 0x184fa
movq -0x280(%rbp), %rdi
movq -0x230(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x45a0
movq %rax, -0x288(%rbp)
jmp 0x18519
movq -0x288(%rbp), %rdi
movl $0x9, %esi
callq 0x44c0
movq %rax, -0x290(%rbp)
jmp 0x18533
movq -0x290(%rbp), %rdi
movq -0x230(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x45a0
movq %rax, -0x298(%rbp)
jmp 0x18552
movq -0x298(%rbp), %rdi
movl $0xa, %esi
callq 0x44c0
jmp 0x18565
jmp 0x18567
movl -0x214(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x214(%rbp)
jmp 0x183ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x4640
jmp 0x185e9
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x4720
movb %al, -0x299(%rbp)
jmp 0x185bb
movb -0x299(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2a0(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x4640
movl -0x2a0(%rbp), %eax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x4770
nopw %cs:(%rax,%rax)
nop
// File: mshabbirhasan[P]ups-indel/include/seqan/misc/misc_name_store_cache.h
// Function: bool seqan::getIdByName<seqan::StringSet<seqan::String<char, seqan::Alloc<void>>, seqan::Owner<seqan::Tag<seqan::Default_>>>, seqan::String<char, seqan::Alloc<void>>, unsigned int, seqan::StringSet<seqan::String<char, seqan::Alloc<void>>, seqan::Owner<seqan::Tag<seqan::Default_>>>, seqan::String<char, seqan::Alloc<void>>>(seqan::StringSet<seqan::String<char, seqan::Alloc<void>>, seqan::Owner<seqan::Tag<seqan::Default_>>> const&, seqan::String<char, seqan::Alloc<void>> const&, unsigned int&, seqan::NameStoreCache<seqan::StringSet<seqan::String<char, seqan::Alloc<void>>, seqan::Owner<seqan::Tag<seqan::Default_>>>, seqan::String<char, seqan::Alloc<void>>> const&)
inline bool
getIdByName(TNameStore const & /*nameStore*/, TName const & name, TPos & pos, NameStoreCache<TCNameStore, TCName> const & context)
{
    typedef typename Position<TNameStore const>::Type TId;
    typedef NameStoreCache<TCNameStore, TCName> const TNameStoreCache;
    typedef typename TNameStoreCache::TSet TSet;

    TSet const &set = context.nameSet;
    typename TSet::const_iterator it;

    // (weese:)
    // To avoid local variables to copy the name into we use a member in context.
    // However, changing the NameStoreCache per query is not thread-safe and the user might not notice it.
    // To avoid pitfalls, we should introduce a critical section.
    //SEQAN_OMP_PRAGMA(critical (nameStoreFind))
    {

        context.name = name;
        it = set.find(maxValue<TId>());
    }
    
    if (it != set.end())
    {
        pos = *it;
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1c520
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
callq 0x16b40
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x1c570
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x1c540
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1c5c0
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1c590
testb $0x1, %al
jne 0x19eff
jmp 0x19f19
leaq -0x38(%rbp), %rdi
callq 0x1c5f0
movq (%rax), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x19f1d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/stream/tokenize.h
// Function: int seqan::readUntilChar<seqan::String<char, seqan::Alloc<void>>, std::istream, seqan::SinglePass<void>, char>(seqan::String<char, seqan::Alloc<void>>&, seqan::RecordReader<std::istream, seqan::SinglePass<void>>&, char const&)
inline int
readUntilChar(TBuffer & buffer,
              RecordReader<TStream, TPass> & reader,
              TCharX const & x)
{
    SEQAN_CHECKPOINT
    typedef char TChar;

    while (!atEnd(reader))
    {
        TChar c = value(reader);
        if (c == x)
            return 0;
        appendValue(buffer, c, Generous());
        goNext(reader);
        if (resultCode(reader) != 0)
            return resultCode(reader);
    }
    return EOF_BEFORE_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x18f10
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a935
jmp 0x1a98d
movq -0x18(%rbp), %rdi
callq 0x1a3f0
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x1a959
movl $0x0, -0x4(%rbp)
jmp 0x1a994
movq -0x10(%rbp), %rdi
leaq -0x21(%rbp), %rsi
callq 0x145e0
movq -0x18(%rbp), %rdi
callq 0x1a660
movq -0x18(%rbp), %rdi
callq 0x1aab0
cmpl $0x0, %eax
je 0x1a98b
movq -0x18(%rbp), %rdi
callq 0x1aab0
movl %eax, -0x4(%rbp)
jmp 0x1a994
jmp 0x1a924
movl $0x400, -0x4(%rbp)      # imm = 0x400
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/stream/tokenize.h
// Function: int seqan::readUntilOneOf<seqan::String<char, seqan::Alloc<void>>, std::istream, seqan::SinglePass<void>>(seqan::String<char, seqan::Alloc<void>>&, seqan::RecordReader<std::istream, seqan::SinglePass<void>>&, char, char, char)
inline int
readUntilOneOf(TBuffer & buffer, RecordReader<TStream, TPass> & reader, char c1, char c2, char c3)
{
    while (!atEnd(reader))
    {
        char c = value(reader);
        if (c == c1 || c == c2 || c == c3)
            return 0;
        appendValue(buffer, c, Generous());
        goNext(reader);
        if (resultCode(reader) != 0)
            return resultCode(reader);
    }
    return EOF_BEFORE_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %dl, -0x19(%rbp)
movb %cl, -0x1a(%rbp)
movb %al, -0x1b(%rbp)
movq -0x18(%rbp), %rdi
callq 0x18f10
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a9cd
jmp 0x1aa3a
movq -0x18(%rbp), %rdi
callq 0x1a3f0
movb %al, -0x1c(%rbp)
movsbl -0x1c(%rbp), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
je 0x1a9fd
movsbl -0x1c(%rbp), %eax
movsbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
je 0x1a9fd
movsbl -0x1c(%rbp), %eax
movsbl -0x1b(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1aa06
movl $0x0, -0x4(%rbp)
jmp 0x1aa41
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x145e0
movq -0x18(%rbp), %rdi
callq 0x1a660
movq -0x18(%rbp), %rdi
callq 0x1aab0
cmpl $0x0, %eax
je 0x1aa38
movq -0x18(%rbp), %rdi
callq 0x1aab0
movl %eax, -0x4(%rbp)
jmp 0x1aa41
jmp 0x1a9bc
movl $0x400, -0x4(%rbp)      # imm = 0x400
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/basic/array_construct_destruct.h
// Function: void seqan::_arrayConstructDefault<seqan::Pair<seqan::String<char, seqan::Alloc<void>>, int, void>*, seqan::Pair<seqan::String<char, seqan::Alloc<void>>, int, void>*>(seqan::Pair<seqan::String<char, seqan::Alloc<void>>, int, void>*, seqan::Pair<seqan::String<char, seqan::Alloc<void>>, int, void>*)
inline void 
_arrayConstructDefault(TIterator1 begin_, 
                       TIterator2 end_)
{
    SEQAN_CHECKPOINT;
    while (begin_ != end_)
    {
        valueConstruct(begin_);
        ++begin_;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x1d091
movq -0x8(%rbp), %rdi
callq 0x1d0a0
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x8(%rbp)
jmp 0x1d070
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/bam_io/bam_alignment_record.h
// Function: seqan::clear(seqan::BamAlignmentRecord&)
inline void
clear(BamAlignmentRecord & record)
{
    clear(record.qName);
    record._qID = MaxValue<__uint32>::VALUE;
    record.rID = BamAlignmentRecord::INVALID_REFID;
    record.beginPos = BamAlignmentRecord::INVALID_POS;
    record.mapQ = 255;
    record.bin = 0;
    clear(record.cigar);
    record.rNextId = BamAlignmentRecord::INVALID_REFID;
    record.pNext = BamAlignmentRecord::INVALID_POS;
    record.tLen = BamAlignmentRecord::INVALID_LEN;
    clear(record.seq);
    clear(record.qual);
    clear(record.tags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x13670
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x24(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movb $-0x1, 0x2c(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x2e(%rax)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x1def0
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x48(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x4c(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, 0x50(%rax)
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
callq 0x13670
movq -0x8(%rbp), %rdi
addq $0x70, %rdi
callq 0x13670
movq -0x8(%rbp), %rdi
addq $0x88, %rdi
callq 0x13670
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/bam_io/bam_sam_conversion.h
// Function: void seqan::assignTagsSamToBam<seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::Alloc<void>>>(seqan::String<char, seqan::Alloc<void>>&, seqan::String<char, seqan::Alloc<void>>&)
void assignTagsSamToBam(TTarget & target, TSource & source)
{
    // Handle case of empty source sequence.
    if (empty(source))
        clear(target);

    typedef typename Iterator<TSource, Standard>::Type TSourceIter;
    TSourceIter it = begin(source, Standard());
    TSourceIter itEnd = end(source, Standard());

    typedef Stream<CharArray<char const *> > TStream;
    typedef RecordReader<TStream, SinglePass<> > TRecordReader;

    TStream stream(it, itEnd);
    TRecordReader reader(stream);

    CharString buffer;

    while (!atEnd(reader))
    {
        if (value(reader) == '\t')
            goNext(reader);
        SEQAN_ASSERT_NOT(atEnd(reader));

        _assignTagsSamToBamOneTag(target, reader, buffer);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf8e0
testb $0x1, %al
jne 0x1dd32
jmp 0x1dd3b
movq -0x8(%rbp), %rdi
callq 0x13670
movq -0x10(%rbp), %rdi
callq 0xfc90
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x29(%rbp), %rsi
callq 0xfe70
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x50(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x1ea80
movq -0xc8(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x1eac0
leaq -0xb0(%rbp), %rdi
callq 0xb3a0
jmp 0x1dd92
jmp 0x1dd94
leaq -0x98(%rbp), %rdi
callq 0x1eb60
movb %al, -0xc9(%rbp)
jmp 0x1dda8
movb -0xc9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1ddb9
jmp 0x1dea9
leaq -0x98(%rbp), %rdi
callq 0x1ebc0
movb %al, -0xca(%rbp)
jmp 0x1ddcd
movb -0xca(%rbp), %al
movsbl %al, %eax
cmpl $0x9, %eax
jne 0x1de25
leaq -0x98(%rbp), %rdi
callq 0x1ec20
jmp 0x1dde9
jmp 0x1de25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x1deca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xb7b0
jmp 0x1deca
jmp 0x1de27
leaq -0x98(%rbp), %rdi
callq 0x1eb60
movb %al, -0xcb(%rbp)
jmp 0x1de3b
movb -0xcb(%rbp), %al
andb $0x1, %al
movb %al, -0xbd(%rbp)
leaq 0xac50(%rip), %rdi      # 0x28aa0
leaq 0xac73(%rip), %rcx      # 0x28aca
movl $0x161, %esi            # imm = 0x161
leaq -0xbd(%rbp), %rdx
callq 0x1ecc0
movb %al, -0xcc(%rbp)
jmp 0x1de70
movb -0xcc(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1de7e
jmp 0x1de87
callq 0xb2a0
jmp 0x1de85
jmp 0x1de87
jmp 0x1de89
jmp 0x1de8b
movq -0x8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x1ed00
jmp 0x1dea4
jmp 0x1dd94
leaq -0xb0(%rbp), %rdi
callq 0xb7b0
leaq -0x98(%rbp), %rdi
callq 0x20750
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x98(%rbp), %rdi
callq 0x20750
movq -0xb8(%rbp), %rdi
callq 0x4770
nopw %cs:(%rax,%rax)
nopl (%rax)