LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/sequence/string_base.h
// Function: seqan::Size<seqan::String<char, seqan::Alloc<void>>>::Type seqan::ClearSpaceExpandStringBase_<seqan::Tag<seqan::TagGenerous_>>::_clearSpace_<seqan::String<char, seqan::Alloc<void>>>(seqan::String<char, seqan::Alloc<void>>&, seqan::Size<seqan::String<char, seqan::Alloc<void>>>::Type)
static inline typename Size<T>::Type
    _clearSpace_(
        T & seq,
        typename Size<T>::Type size)
    {
        arrayDestruct(begin(seq, Standard()), end(seq, Standard()));
        typename Size<T>::Type old_capacity = capacity(seq);
        typename Value<T>::Type * old_array = _reallocateStorage(seq, size, TExpand());
        if (old_array)
        {
            SEQAN_CHECKPOINT;
            _deallocateStorage(seq, old_array, old_capacity);
        }
        _setLength(seq, size);
        return size;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x88bb
testq %rax, %rax
je 0x88a9
movq %rax, %rdi
callq 0x32e0
movq (%r14), %rax
addq %rbx, %rax
movq %rax, 0x8(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/sequence/string_base.h
// Function: void seqan::AssignString_<seqan::Tag<seqan::TagGenerous_>>::assign_<seqan::String<char, seqan::Alloc<void>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const>(seqan::String<char, seqan::Alloc<void>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, seqan::Size<seqan::String<char, seqan::Alloc<void>>>::Type)
static inline void
    assign_(
        TTarget & target,
        TSource & source,
        typename Size<TTarget>::Type limit)
    {
        if (!getObjectId(source) || !shareResources(target, source))
        {
            SEQAN_CHECKPOINT;
            typename Size<TTarget>::Type part_length = _clearSpace(target, typename Size<TTarget>::Type(length(source)), limit, TExpand());
            arrayConstructCopy(begin(source, Standard()), begin(source, Standard()) + part_length, begin(target, Standard()));
        }
        else
        {
            SEQAN_CHECKPOINT;
            if ((void *) &target == (void *) &source) return;

            typename Size<TTarget>::Type source_length = length(source);
            if (source_length > limit) source_length = limit;

            typename TempCopy_<TSource>::Type temp(source, source_length);
            assign(target, temp, TExpand());
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movq (%r14), %rax
addq %rsi, %rax
testq %rsi, %rsi
cmoveq %rsi, %rax
testq %rax, %rax
je 0xca67
cmpq %rax, 0x8(%rbx)
jne 0xca67
cmpq %r14, %rbx
je 0xca5c
cmpq %rdx, %rsi
cmovbq %rsi, %rdx
leaq -0x30(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xc98e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8a54
movq -0x30(%rbp), %rdi
callq 0x32e0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x89e2
movq (%r14), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
cmpq %rsi, %rax
je 0xca5c
movb (%rcx,%rsi), %dil
movb %dil, (%rdx,%rsi)
incq %rsi
jmp 0xca77
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x32e0
movq %rbx, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/sequence/string_base.h
// Function: seqan::Size<seqan::String<char, seqan::Alloc<void>>>::Type seqan::ClearSpaceExpandStringBase_<seqan::Tag<seqan::TagGenerous_>>::_clearSpace_<seqan::String<char, seqan::Alloc<void>>>(seqan::String<char, seqan::Alloc<void>>&, seqan::Size<seqan::String<char, seqan::Alloc<void>>>::Type, seqan::Size<seqan::String<char, seqan::Alloc<void>>>::Type)
static inline typename Size<T>::Type
    _clearSpace_(
        T & seq,
        typename Size<T>::Type size,
        typename Size<T>::Type limit)
    {
        arrayDestruct(begin(seq, Standard()), end(seq, Standard()));
        if (limit < size)
        {
            SEQAN_CHECKPOINT;
            size = limit;
        }
        typename Size<T>::Type old_capacity = capacity(seq);
        typename Value<T>::Type * old_array = _reallocateStorage(seq, size, limit, TExpand());
        if (old_array)
        {
            _deallocateStorage(seq, old_array, old_capacity);
        }
        _setLength(seq, size);
        return size;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, %rdx
cmovbq %rdx, %rbx
movq %rbx, %rsi
callq 0x8a1d
testq %rax, %rax
je 0x8a0b
movq %rax, %rdi
callq 0x32e0
movq (%r14), %rax
addq %rbx, %rax
movq %rax, 0x8(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/sequence/string_base.h
// Function: seqan::Value<seqan::String<char, seqan::Alloc<void>>, 0>::Type* seqan::_reallocateStorage<char, seqan::Alloc<void>, unsigned long, unsigned long>(seqan::String<char, seqan::Alloc<void>>&, unsigned long, unsigned long, seqan::Tag<seqan::TagGenerous_>)
inline typename Value<String<TValue, TSpec> >::Type *
_reallocateStorage(
    String<TValue, TSpec> & me,
    TSize new_capacity,
    TSize2 limit,
    Generous)
{
    typedef typename Size<String<TValue, TSpec> >::Type TStringSize;
    if (static_cast<TStringSize>(new_capacity) <= capacity(me))
        return 0;

    new_capacity = computeGenerousCapacity(me, new_capacity);
    if (new_capacity > limit) new_capacity = limit;
    return _reallocateStorage(me, new_capacity);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq %rsi, 0x10(%rdi)
jae 0x8a4f
movq %rsi, %rax
shrq %rax
addq %rsi, %rax
cmpq $0x20, %rsi
movabsq $0x20, %rsi
cmovaeq %rax, %rsi
cmpq %rdx, %rsi
cmovaeq %rdx, %rsi
popq %rbp
jmp 0x88ea
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/sequence/string_base.h
// Function: void seqan::AppendString_<seqan::Tag<seqan::TagGenerous_>>::append_<seqan::String<char, seqan::Alloc<void>>, char const*>(seqan::String<char, seqan::Alloc<void>>&, char const*&)
static inline void
    append_(TTarget & target,
            TSource & source)
    {
        if (!getObjectId(source) || !shareResources(target, source) ||
            !_stringCheckForPossibleOverlap(begin(source, Standard()), end(target, Standard()), length(source)))
        {
            SEQAN_CHECKPOINT;
            typename Size<TTarget>::Type target_length = length(target);
            typename Size<TTarget>::Type part_length = _clearSpace(target, length(source), target_length, target_length, TExpand());
            arrayConstructCopy(begin(source, Standard()), begin(source, Standard()) + part_length, begin(target, Standard()) + target_length);
        }
        else
        {
            SEQAN_CHECKPOINT;
            typename TempCopy_<TSource>::Type temp(source, length(source));
            append(target, temp, TExpand());
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x8cff
testq %rax, %rax
je 0x8f19
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8d1a
testb %al, %al
je 0x8f19
movq (%r14), %rdi
callq 0x3170
leaq -0x30(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8d3a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x90b8
movq -0x30(%rbp), %rdi
callq 0x32e0
jmp 0x8f59
movq 0x8(%rbx), %r15
subq (%rbx), %r15
movq (%r14), %rdi
callq 0x3170
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r15, %rcx
callq 0x8f78
testq %rax, %rax
je 0x8f59
addq (%rbx), %r15
movq (%r14), %rsi
movq %r15, %rdi
movq %rax, %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3510
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x32e0
movq %rbx, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/sequence/string_base.h
// Function: seqan::Size<seqan::String<char, seqan::Alloc<void>>>::Type seqan::ClearSpaceExpandStringBase_<seqan::Tag<seqan::TagGenerous_>>::_clearSpace_<seqan::String<char, seqan::Alloc<void>>>(seqan::String<char, seqan::Alloc<void>>&, seqan::Size<seqan::String<char, seqan::Alloc<void>>>::Type, seqan::Size<seqan::String<char, seqan::Alloc<void>>>::Type, seqan::Size<seqan::String<char, seqan::Alloc<void>>>::Type)
static typename Size<T>::Type
    _clearSpace_(
        T & seq,
        typename Size<T>::Type size,
        typename Size<T>::Type start,
        typename Size<T>::Type end)
    {
        typename Size<T>::Type old_length = length(seq);
        typename Size<T>::Type removed_size = end - start;
        typename Size<T>::Type new_length = old_length - removed_size + size;

        typename Size<T>::Type old_capacity = capacity(seq);
        typename Value<T>::Type * old_array = _reallocateStorage(seq, new_length, TExpand());
        typename Value<T>::Type * seq_array = begin(seq);

        if (old_array)
        {
            SEQAN_CHECKPOINT;
            arrayConstructMove(old_array, old_array + start, seq_array);
            arrayConstructMove(old_array + end, old_array + old_length, seq_array + start + size);
            _deallocateStorage(seq, old_array, old_capacity);
        }
        else
        {
            SEQAN_CHECKPOINT;
            arrayClearSpace(seq_array + start, old_length - start, removed_size, size);
        }

        _setLength(seq, new_length);

        return size;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rdx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %r15
movq %r15, %rbx
movq %rax, -0x38(%rbp)
subq %rax, %rbx
movq %rcx, -0x40(%rbp)
subq %r13, %r12
movq %rbx, %rsi
subq %r12, %rsi
movq %rdx, -0x30(%rbp)
addq %rdx, %rsi
movq %rsi, -0x48(%rbp)
callq 0x88bb
movq %r14, -0x50(%rbp)
movq (%r14), %rdi
testq %rax, %rax
je 0x901a
xorl %ecx, %ecx
movq -0x30(%rbp), %rbx
cmpq %rcx, %r13
je 0x8fe5
movb (%rax,%rcx), %dl
movb %dl, (%rdi,%rcx)
incq %rcx
jmp 0x8fd5
movq %rax, %rcx
movq -0x40(%rbp), %rdx
addq %rdx, %rcx
addq %r13, %rdi
addq %rbx, %rdi
subq %rdx, %r15
subq -0x38(%rbp), %r15
xorl %edx, %edx
cmpq %rdx, %r15
je 0x9010
movb (%rcx,%rdx), %sil
movb %sil, (%rdi,%rdx)
incq %rdx
jmp 0x8ffe
movq %rax, %rdi
callq 0x32e0
jmp 0x9032
addq %r13, %rdi
subq %r13, %rbx
movq %rbx, %rsi
movq %r12, %rdx
movq -0x30(%rbp), %rbx
movq %rbx, %rcx
callq 0x9053
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
addq (%rax), %rcx
movq %rcx, 0x8(%rax)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/basic/array_construct_destruct.h
// Function: void seqan::arrayMove<char*, char*, char*>(char*, char*, char*)
inline void 
arrayMove(TSource1 source_begin, 
          TSource2 source_end,
          TTarget target_begin)
{
    if (target_begin <= source_begin)
        arrayMoveForward(source_begin, source_end, target_begin);
    else
        arrayMoveBackward(source_begin, source_end, target_begin);
}

// Assembly:
cmpq %rdi, %rdx
ja 0x9093
pushq %rbp
movq %rsp, %rbp
cmpq %rsi, %rdi
je 0x9091
movb (%rdi), %al
movb %al, (%rdx)
incq %rdi
incq %rdx
jmp 0x9080
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/basic/array_construct_destruct.h
// Function: void seqan::_arrayMoveBackwardDefault<char*, char*, char*>(char*, char*, char*)
inline void 
_arrayMoveBackwardDefault(TSource1 source_begin, 
                          TSource2 source_end, 
                          TTarget target_begin)
{
    SEQAN_CHECKPOINT;
    target_begin += (source_end - source_begin);
    while (source_end != source_begin) {
        --source_end;
        --target_begin;
        move(*target_begin, *source_end);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
notq %rax
addq %rsi, %rdx
addq %rax, %rdx
cmpq %rdi, %rsi
je 0x90b5
movb -0x1(%rsi), %al
decq %rsi
movb %al, (%rdx)
decq %rdx
jmp 0x90a3
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/sequence/string_cstyle.h
// Function: char* seqan::_toCStringImpl<char, seqan::Alloc<void>>(seqan::String<char, seqan::Alloc<void>>&, seqan::True)
inline TValue *
_toCStringImpl(String<TValue, TSpec> & me, True)
{
    SEQAN_CHECKPOINT;
    typename Size< String<TValue, TSpec> >::Type len = length(me);
    if (len >= capacity(me))
        reserve(me, len + 1);
    if (end(me) != NULL)
        *end(me) = TValue();
    return begin(me);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq %rax, %rsi
subq (%rdi), %rsi
cmpq 0x10(%rdi), %rsi
jb 0x918f
incq %rsi
movq %rbx, %rdi
callq 0x91a1
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x9197
movb $0x0, (%rax)
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/file/stream_algorithms.h
// Function: void seqan::_streamWriteSeq<std::ostream, seqan::String<char, seqan::Alloc<void>>>(std::ostream&, seqan::String<char, seqan::Alloc<void>> const&, seqan::True)
inline void
_streamWriteSeq(TTarget & target,
				TSource const & source,
				True const)
{
//IOREV _nodoc_
SEQAN_CHECKPOINT
	typename Iterator<TSource const, Standard>::Type it = begin(source, Standard());
	typename Iterator<TSource const, Standard>::Type it_end = end(source, Standard());

	for (; it != it_end; ++it)
	{
		typename GetValue<TSource const>::Type val_ = getValue(it);
		_streamWrite(target, val_);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %r15
cmpq %r15, %r14
je 0x9245
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9250
incq %r14
jmp 0x9230
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/stream/adapt_fstream.h
// Function: int seqan::_streamWriteCharImplIOStream<std::ostream>(std::ostream&, char)
inline int
_streamWriteCharImplIOStream(TStream & stream, char const c)
{
    stream.put(c);
    if (!stream.bad())
        return 0;
    if (stream.eof())
        return EOF;
    SEQAN_ASSERT(stream.fail());
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3040
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x20(%rbx,%rax), %ecx
xorl %eax, %eax
testb $0x1, %cl
je 0x92ac
testb $0x2, %cl
jne 0x92a9
leaq -0x9(%rbp), %rdx
movb $0x1, (%rdx)
leaq 0x42d5(%rip), %rdi      # 0xd565
leaq 0x42f3(%rip), %rcx      # 0xd58a
movl $0x19f, %esi            # imm = 0x19F
callq 0x92b8
testb %al, %al
je 0x92b3
pushq $0x1
jmp 0x92ab
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x31f0
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/basic/debug_test_system.h
// Function: bool seqan::ClassTest::testTrue<bool>(char const*, int, bool const&, char const*, char const*, ...)
bool testTrue(const char * file, int line,
              const T & value_, const char * expression_,
              const char * comment, ...)
{
    if (!(value_))
    {
        // Increase global error count.
        StaticData::thisTestOk() = false;
        StaticData::errorCount() += 1;
        // Print assertion failure text, with comment if any is given.
        std::cerr << file << ":" << line << " Assertion failed : "
                  << expression_ << " should be true but was " << (value_);
        if (comment)
        {
            std::cerr << " (";
            va_list args;
            va_start(args, comment);
            vfprintf(stderr, comment, args);
            va_end(args);
            std::cerr << ")";
        }
        std::cerr << std::endl;
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r9, -0xc8(%rbp)
testb %al, %al
je 0x9312
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movb (%rdx), %bl
testb %bl, %bl
jne 0x93a4
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r15
movl %esi, %r13d
movq %rdi, %rsi
movb $0x0, 0xb0c2(%rip)      # 0x143f4
incl 0xb0b8(%rip)            # 0x143f0
movq 0xacb1(%rip), %rdi      # 0x13ff0
callq 0x3310
leaq 0x3f55(%rip), %rsi      # 0xd2a0
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
movl %r13d, %esi
callq 0x3550
leaq 0x3f9d(%rip), %rsi      # 0xd302
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
movq %r12, %rsi
callq 0x3310
leaq 0x4219(%rip), %rsi      # 0xd598
movq %rax, %rdi
callq 0x3310
movzbl (%r15), %esi
movq %rax, %rdi
callq 0x3530
testq %r14, %r14
jne 0x93b8
movq 0xac51(%rip), %rdi      # 0x13ff0
callq 0x31a0
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xac31(%rip), %r15      # 0x13ff0
leaq 0x4017(%rip), %rsi      # 0xd3dd
movq %r15, %rdi
callq 0x3310
leaq -0xf0(%rbp), %rax
leaq -0x40(%rbp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000028, %rax     # imm = 0x3000000028
movq %rax, (%rdx)
movq 0xabd7(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
movq %r14, %rsi
callq 0x3430
leaq 0x418b(%rip), %rsi      # 0xd596
movq %r15, %rdi
callq 0x3310
jmp 0x9398
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/file/file_base.h
// Function: seqan::Size<seqan::File<seqan::Async<void>>>::Type seqan::size<seqan::Async<void>>(seqan::File<seqan::Async<void>>&)
inline typename Size<File<TSpec> >::Type size(File<TSpec> &me) 
	{
//IOREV
        typename Size<File<TSpec> >::Type old_pos = tell(me);
        typename Size<File<TSpec> >::Type result = seek(me, 0, SEEK_END);
        seek(me, old_pos, SEEK_BEGIN);
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x987a
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x9734
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x97d9
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/basic/debug_test_system.h
// Function: bool seqan::ClassTest::testEqual<int, int>(char const*, int, int const&, char const*, int const&, char const*, char const*, ...)
bool testEqual(char const * file, int line,
               T1 const & value1, char const * expression1,
               T2 const & value2, char const * expression2,
               char const * comment, ...)
{
    if (!(value1 == value2))
    {
        // Increase global error count.
        StaticData::thisTestOk() = false;
        StaticData::errorCount() += 1;
        // Print assertion failure text, with comment if any is given.
        std::cerr << file << ":" << line << " Assertion failed : "
                  << expression1 << " == " << expression2 << " was: " << value1
                  << " != " << value2;
        if (comment)
        {
            std::cerr << " (";
            va_list args;
            va_start(args, comment);
            vfprintf(stderr, comment, args);
            va_end(args);
            std::cerr << ")";
        }
        std::cerr << std::endl;
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
testb %al, %al
je 0x95e6
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movl (%rdx), %eax
movl (%r8), %r12d
cmpl %r12d, %eax
je 0x96bc
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %rsi
movl %eax, -0x2c(%rbp)
movb $0x0, 0xade8(%rip)      # 0x143f4
incl 0xadde(%rip)            # 0x143f0
movq 0xa9d7(%rip), %rdi      # 0x13ff0
movq %r9, -0x38(%rbp)
callq 0x3310
leaq 0x3c77(%rip), %rsi      # 0xd2a0
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
movl %ebx, %esi
callq 0x3550
leaq 0x3cc0(%rip), %rsi      # 0xd302
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
movq %r13, %rsi
callq 0x3310
leaq 0x3fcb(%rip), %rsi      # 0xd627
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x3310
leaq 0x3ca5(%rip), %rsi      # 0xd31c
movq %rax, %rdi
callq 0x3310
movl (%r15), %esi
movq %rax, %rdi
callq 0x3550
leaq 0x3f9b(%rip), %rsi      # 0xd62c
movq %rax, %rdi
callq 0x3310
movl (%r14), %esi
movq 0x10(%rbp), %r14
movq %rax, %rdi
callq 0x3550
testq %r14, %r14
jne 0x96d4
movq 0xa93c(%rip), %rdi      # 0x13ff0
callq 0x31a0
movl -0x2c(%rbp), %eax
cmpl %r12d, %eax
sete %al
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa915(%rip), %rbx      # 0x13ff0
leaq 0x3cfb(%rip), %rsi      # 0xd3dd
movq %rbx, %rdi
callq 0x3310
leaq -0x100(%rbp), %rax
leaq -0x50(%rbp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x18(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000030, %rax     # imm = 0x3000000030
movq %rax, (%rdx)
movq 0xa8bb(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
movq %r14, %rsi
callq 0x3430
leaq 0x3e6f(%rip), %rsi      # 0xd596
movq %rbx, %rdi
callq 0x3310
jmp 0x96ad
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/file/file_base.h
// Function: seqan::Position<seqan::File<seqan::Async<void>>>::Type seqan::seek<seqan::Async<void>, long>(seqan::File<seqan::Async<void>>&, long, int)
inline typename Position< File<TSpec> >::Type seek(File<TSpec> &me, TPos const fileOfs, int origin) 
	{
//IOREV
		typedef typename Position< File<TSpec> >::Type TFilePos;
		TFilePos newOfs = me.seek(fileOfs, origin);
        #if SEQAN_ENABLE_DEBUG || SEQAN_ENABLE_TESTING
			if (origin == SEEK_BEGIN && newOfs != (TFilePos)fileOfs) {
				::std::cerr << "seek returned " << ::std::hex << newOfs << " instead of " << fileOfs << ::std::dec << ::std::endl;
			}
        #endif
        return newOfs;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
callq 0x988c
movq %rax, %rbx
testl %r15d, %r15d
setne %al
cmpq %r14, %rbx
sete %cl
orb %al, %cl
jne 0x986b
movq 0xa7e8(%rip), %rdi      # 0x13ff0
leaq 0x3e23(%rip), %rsi      # 0xd632
callq 0x3310
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3300
leaq 0x3e06(%rip), %rsi      # 0xd641
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
movq %r14, %rsi
callq 0x3300
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
callq 0x31a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/system/file_sync.h
// Function: seqan::File<seqan::Sync<void>>::seek(long, int) const
inline FilePtr seek(FilePtr pos, int origin = SEEK_SET) const {
            FilePtr result = ::lseek(handle, pos, origin);
//			#ifdef SEQAN_DEBUG
				if (result < 0)
					::std::cerr << "lseek returned " << result << ". (" << ::strerror(errno) << ")" << ::std::endl;
//			#endif
			return result;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x8(%rdi), %edi
callq 0x35f0
movq %rax, %rbx
testq %rax, %rax
jns 0x9901
movq 0xa746(%rip), %rdi      # 0x13ff0
leaq 0x3d80(%rip), %rsi      # 0xd631
callq 0x3310
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3300
leaq 0x3b14(%rip), %rsi      # 0xd3dc
movq %rax, %rdi
callq 0x3310
movq %rax, %r14
callq 0x3060
movl (%rax), %edi
callq 0x3130
movq %r14, %rdi
movq %rax, %rsi
callq 0x3310
leaq 0x3ca5(%rip), %rsi      # 0xd596
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
callq 0x31a0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/seq_io/fai_index.h
// Function: seqan::clear(seqan::FaiIndex&)
inline void clear(FaiIndex & index)
{
    clear(index.fastaFilename);
    clear(index.faiFilename);
    clear(index.indexEntryStore);
    clear(index.refNameStore);
    refresh(index.refNameStoreCache);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x18(%rdi), %rcx
movq %rax, 0x8(%rdi)
movq %rcx, 0x20(%rdi)
addq $0x30, %rdi
callq 0xa13c
leaq 0x48(%rbx), %rdi
callq 0xa15f
addq $0x88, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa0e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/file/string_mmap.h
// Function: bool seqan::open<char, seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>(seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>&, char const*, int)
inline bool 
    open(String<TValue, MMap<TConfig> > &me, const char *fileName, int openMode) 
	{
//IOREV
		close(me);
		if (open(me.mapping, fileName, openMode))
			return _map(me, capacity(me));
		return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
callq 0x9da4
leaq 0x10(%rbx), %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0xa2ea
testb %al, %al
je 0x9e31
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x82c1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/stream/record_reader_single.h
// Function: bool seqan::atEnd<std::basic_ifstream<char, std::char_traits<char>>>(seqan::RecordReader<std::basic_ifstream<char, std::char_traits<char>>, seqan::SinglePass<void>>&)
inline bool
atEnd(RecordReader<TFile, SinglePass<void> > & recordReader)
{
    // There is more data if the buffer is not exhausted.
    if (recordReader._current != recordReader._end)
        return false;
    // There is no more data if the buffer is exhausted and there the stream
    // is at the end of the file or there previously was an error reading the
    // file.
    
    if (streamEof(recordReader._file) || recordReader._resultCode != 0)
        return true;

    // std::cerr << "refilling in atEnd()" << std::endl;

    // Otherwise, we can try to load some data.  This case only happens if
    // atEnd is called at the beginning of the file; Otherwise, goNext()
    // will load data.
    return !_refillBuffer(recordReader);
}

// Assembly:
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
je 0x9ea9
xorl %eax, %eax
retq
movq (%rdi), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %ecx
andl $0x2, %ecx
movb $0x1, %al
orl 0x38(%rdi), %ecx
jne 0x9ea8
pushq %rbp
movq %rsp, %rbp
callq 0xa346
xorb $0x1, %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/stream/lexical_cast.h
// Function: bool seqan::lexicalCast2<unsigned long, seqan::String<char, seqan::Alloc<void>>>(unsigned long&, seqan::String<char, seqan::Alloc<void>> const&)
inline bool
lexicalCast2(TTarget & target, TSource const & source)
{
    std::stringstream str;
    str << source;
    str.seekg(0);
    return bool(str >> target);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1a0(%rbp), %r15
movq %r15, %rdi
callq 0x3240
movq %r15, %rdi
movq %r14, %rsi
callq 0xad07
leaq -0x1a0(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3400
leaq -0x1a0(%rbp), %rdi
movq %rbx, %rsi
callq 0x31e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
sete %bl
leaq -0x1a0(%rbp), %rdi
callq 0x3260
movl %ebx, %eax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x3260
movq %rbx, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/stream/tokenize.h
// Function: int seqan::skipLine<std::basic_ifstream<char, std::char_traits<char>>, seqan::SinglePass<void>>(seqan::RecordReader<std::basic_ifstream<char, std::char_traits<char>>, seqan::SinglePass<void>>&)
inline int
skipLine(RecordReader<TStream, TPass> & reader)
{
    int r = _skipHelper(reader, UnixEOL_());

    if (r != 0)
        return r;

    if (!atEnd(reader))
        goNext(reader); // go to beginning of next line

    return resultCode(reader);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x9(%rbp), %rsi
callq 0xadd5
testl %eax, %eax
jne 0xa0d9
movq %rbx, %rdi
callq 0x9e9c
testb %al, %al
jne 0xa0d6
movq %rbx, %rdi
callq 0xa4c9
movl 0x38(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/sequence/string_set_owner.h
// Function: void seqan::clear<seqan::String<char, seqan::Alloc<void>>>(seqan::StringSet<seqan::String<char, seqan::Alloc<void>>, seqan::Owner<seqan::Tag<seqan::Default_>>>&)
inline void clear(StringSet<TString, Owner<Default> > & me)
{
    SEQAN_CHECKPOINT;
    clear(me.strings);
    resize(me.limits, 1, Exact());
    me.limitsValid = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xa184
leaq 0x18(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0xa1a8
movb $0x1, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/file/file_mapping.h
// Function: bool seqan::closeAndResize<void, long>(seqan::FileMapping<void>&, long)
inline bool
closeAndResize(FileMapping<TSpec> &mapping, TSize newFileSize)
{
    bool result = _unmapFile(mapping);
    if (newFileSize != mapping.fileSize)
        resize(mapping.file, newFileSize);
    if (mapping.ownFile)
        result &= close(mapping.file);
    _initialize(mapping);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, (%rdi)
je 0xa2bf
leaq 0x8(%rbx), %rdi
callq 0x8347
movb $0x1, %al
cmpb $0x1, 0x1c(%rbx)
jne 0xa2d2
leaq 0x8(%rbx), %rdi
movq 0x8(%rbx), %rax
callq *0x18(%rax)
andq $0x0, (%rbx)
movl $0x3, 0x18(%rbx)
movw $0x100, 0x1c(%rbx)      # imm = 0x100
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/file/file_mapping.h
// Function: bool seqan::open<void>(seqan::FileMapping<void>&, char const*, int)
inline bool
open(FileMapping<TSpec> &mapping, const char *filename, int openMode)
{
    _initialize(mapping);
    bool result = open(mapping.file, filename, openMode);
    mapping.openMode = openMode;
    mapping.ownFile = true;
    mapping.temporary = false;
    mapping.fileSize = (result)? size(mapping.file) : 0ul;
    result &= _mapFile(mapping, mapping.fileSize);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rdi, %rbx
andq $0x0, (%rdi)
movl $0x3, 0x18(%rdi)
movw $0x100, 0x1c(%rdi)      # imm = 0x100
leaq 0x8(%rdi), %r15
movq 0x8(%rdi), %rax
movq %r15, %rdi
callq *0x10(%rax)
movl %eax, %r14d
movl %r12d, 0x18(%rbx)
movw $0x1, 0x1c(%rbx)
testb %al, %al
je 0xa335
movq %r15, %rdi
callq 0x955f
jmp 0xa337
xorl %eax, %eax
movq %rax, (%rbx)
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/stream/record_reader_single.h
// Function: bool seqan::_refillBuffer<std::basic_ifstream<char, std::char_traits<char>>>(seqan::RecordReader<std::basic_ifstream<char, std::char_traits<char>>, seqan::SinglePass<void>>&)
inline bool
_refillBuffer(RecordReader<TFile, SinglePass<void> > & recordReader)
{
    if (recordReader._stayInOneBuffer && recordReader._end != 0)
        // e.g. file format detection; if end==0 there hasnt yet been a buffer
        return false;
    // std::cerr << "REFILLING BUFFER" << std::endl;
    if (streamEof(recordReader._file))
        return false;
    recordReader._current = begin(recordReader._buffer, Standard());
    recordReader._position = streamTell(recordReader._file);
    size_t bytesRead = streamReadBlock(recordReader._current, recordReader._file, recordReader._bufferSize);
    recordReader._position += bytesRead;
    if (bytesRead != recordReader._bufferSize) {
        // If we read fewer characters and the stream is not at its end then
        // there was an error reading the file.
        recordReader._resultCode = streamError(recordReader._file);
        if (recordReader._resultCode) {
            // std::cerr << "RESULT IS " << recordReader._resultCode << std::endl;
            recordReader._end = recordReader._current;
            return false;
        }
    }
    recordReader._end = recordReader._current + bytesRead;
    // std::cerr << "read " << bytesRead << " bytes" << std::endl;
    // std::cerr << "ERROR? " << streamError(recordReader._file) << std::endl;
    // std::cerr << "EOF? " << streamEof(recordReader._file) << std::endl;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x3c(%rdi)
jne 0xa35c
cmpq $0x0, 0x30(%rbx)
jne 0xa3c2
movq (%rbx), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rdi,%rax)
jne 0xa3c2
movq 0x10(%rbx), %rax
movq %rax, 0x28(%rbx)
callq 0x3560
movq %rax, 0x40(%rbx)
movq %rdx, 0x48(%rbx)
movq 0x28(%rbx), %rdi
movq (%rbx), %rsi
movl 0x8(%rbx), %edx
callq 0xa420
addq %rax, 0x40(%rbx)
movl 0x8(%rbx), %ecx
cmpq %rcx, %rax
je 0xa3c6
movq (%rbx), %rcx
movq (%rcx), %rdx
movq -0x18(%rdx), %rdx
movl 0x20(%rcx,%rdx), %ecx
xorl %edx, %edx
testb $0x2, %cl
cmovel %ecx, %edx
movl %edx, 0x38(%rbx)
testl %edx, %edx
je 0xa3c6
movq 0x28(%rbx), %rax
xorl %ecx, %ecx
jmp 0xa3cc
xorl %ecx, %ecx
jmp 0xa3d0
addq 0x28(%rbx), %rax
movb $0x1, %cl
movq %rax, 0x30(%rbx)
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x21(%rbp), %r12
movq %r14, %rdi
callq 0x9e9c
testb %al, %al
jne 0xa4b3
movq %r14, %rdi
callq 0x9f06
movb %al, -0x21(%rbp)
movl %eax, %ecx
andb $-0x5, %cl
cmpb $0x9, %cl
setne %cl
cmpb $0xa, %al
setne %al
andb %cl, %al
cmpb %bl, %al
jne 0xa4ba
movq %r15, %rdi
movq %r12, %rsi
callq 0xa528
movq %r14, %rdi
callq 0xa4c9
movl 0x38(%r14), %eax
testl %eax, %eax
je 0xa469
jmp 0xa4bc
movl $0x400, %eax            # imm = 0x400
jmp 0xa4bc
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
leaq -0x9(%rbp), %rdx
setne (%rdx)
leaq 0x316d(%rip), %rdi      # 0xd655
leaq 0x3192(%rip), %rcx      # 0xd681
movl $0xf5, %esi
callq 0x92b8
testb %al, %al
je 0xa523
movq 0x28(%rbx), %rax
incq %rax
movq %rax, 0x28(%rbx)
cmpq 0x30(%rbx), %rax
je 0xa512
xorl %eax, %eax
jmp 0xa51c
movq %rbx, %rdi
callq 0xa346
xorb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x31f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq -0x30(%rbp), %rax
andq $0x0, (%rax)
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rax, %r15
leaq 0x18(%rdi), %r12
leaq 0x1(%rax), %rsi
movq %r12, %rdi
callq 0xa7c2
xorl %r13d, %r13d
movq -0x30(%rbp), %r14
cmpq %r13, %r15
je 0xa71c
movq %r12, %rdi
movq %r13, %rsi
callq 0xa78a
movq %r14, (%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x7b8a
movq 0x8(%rax), %rcx
subq (%rax), %rcx
addq %rcx, -0x30(%rbp)
movq %r12, %rdi
movq %r13, %rsi
callq 0xa78a
leaq 0x2fbb(%rip), %rdi      # 0xd6ac
movl $0x51d, %esi            # imm = 0x51D
movq %rax, %rdx
leaq 0x2fd5(%rip), %rcx      # 0xd6d5
leaq -0x30(%rbp), %r8
leaq 0x2fd7(%rip), %r9       # 0xd6e2
callq 0xa7a7
incq %r13
testb %al, %al
jne 0xa6b2
callq 0x31f0
movq %r12, %rdi
movq %r15, %rsi
callq 0xa78a
movq %r14, (%rax)
movb $0x1, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
leaq 0x8(%rdi), %r14
movq %rax, %rcx
shrq %rcx
addq %rax, %rcx
cmpq $0x20, %rax
pushq $0x20
popq %rsi
cmovaeq %rcx, %rsi
movq 0x10(%r15), %rax
cmpq %rax, %rsi
cmovaeq %rax, %rsi
callq 0xab81
movq 0x8(%r15), %rax
cmpq (%r15), %rax
je 0xab22
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8a54
leaq 0x27bd(%rip), %rax      # 0xd2e6
movq %rax, (%rsp)
leaq 0x2778(%rip), %rdi      # 0xd2ac
leaq 0x2797(%rip), %rcx      # 0xd2d2
leaq 0x279b(%rip), %r9       # 0xd2dd
movl $0x86, %esi
movq %rbx, %rdx
movq %r14, %r8
xorl %eax, %eax
callq 0x708f
testb %al, %al
je 0xab63
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x31f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq %r14, %r15
je 0xacfc
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaac4
addq $0x18, %r15
addq $0x18, %rbx
jmp 0xace2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
movq %r14, %rdi
callq 0x9e9c
testb %al, %al
jne 0xae1f
movq %r14, %rdi
callq 0x9f06
cmpb $0xa, %al
setne %al
xorb %bl, %al
jne 0xae26
movq %r14, %rdi
callq 0xa4c9
movl 0x38(%r14), %eax
testl %eax, %eax
je 0xadf0
jmp 0xae28
movl $0x400, %eax            # imm = 0x400
jmp 0xae28
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
cmpl $0x1, %eax
je 0xb3a9
cmpl $-0x1, %eax
jne 0xb3c3
leaq -0x11(%rbp), %rsi
movq %r14, %rdi
callq 0xb598
testb %al, %al
je 0xb3c3
movl $0x1, (%rbx)
movb $0x1, %al
jmp 0xb3ce
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb6c8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x19(%rbp), %r15
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0xb500
movq %rbx, %rdi
callq 0xb3d7
movb %al, -0x19(%rbp)
cmpb $0xd, %al
je 0xb507
movzbl %al, %eax
cmpl $0xa, %eax
je 0xb525
movq %r14, %rdi
movq %r15, %rsi
callq 0xa528
movq %rbx, %rdi
callq 0xb41d
jmp 0xb4ca
movl $0x400, %eax            # imm = 0x400
jmp 0xb539
movq %rbx, %rdi
callq 0xb41d
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0xb537
movq %rbx, %rdi
callq 0xb3d7
cmpb $0xa, %al
jne 0xb537
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0xb537
movq %rbx, %rdi
callq 0xb41d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq