LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/mshabbirhasan[P]ups-indel/include/seqan/file/string_mmap.h
// Function: bool seqan::_map<char, seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>(seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>&, unsigned long)
inline bool 
    _map(String<TValue, MMap<TConfig> > &me, size_t new_capacity)
	{
        typedef typename Size<typename TConfig::TFile>::Type TFileSize;
		if (new_capacity > 0)
		{
			_ensureFileIsOpen(me);
            if (capacity(me) < new_capacity)
                resize(me.mapping, (TFileSize)new_capacity * (TFileSize)sizeof(TValue));
            me.data_begin = static_cast<TValue*>(mapFileSegment(me.mapping, 0, length(me.mapping)));
            if (me.data_begin == NULL)
            {
                me.data_end = NULL;
                return false;
            }
            adviseFileSegment(me.mapping, me.advise, me.data_begin, 0, length(me.mapping));
		}
        else
			resize(me.mapping, 0);
        _setLength(me, new_capacity);
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0xa861
cmpl $-0x1, 0x20(%r14)
jne 0xa813
movq $0x0, 0x10(%r14)
movl $0x3, %r15d
movl %r15d, 0x28(%r14)
movw $0x100, 0x2c(%r14)      # imm = 0x100
leaq 0x18(%r14), %rdi
movl $0x7, %esi
callq 0xa928
movl %r15d, 0x28(%r14)
movw $0x101, 0x2c(%r14)      # imm = 0x101
testb %al, %al
je 0xa8d1
leaq 0x10(%r14), %r12
cmpq %rbx, 0x10(%r14)
jae 0xa831
movl 0x20(%r14), %edi
movq %rbx, %rsi
callq 0x3460
testl %eax, %eax
jne 0xa899
movq %rbx, (%r12)
movq 0x10(%r14), %rdx
xorl %r15d, %r15d
movq %r12, %rdi
xorl %esi, %esi
movl $0x3, %ecx
callq 0xba95
movq %rax, (%r14)
testq %rax, %rax
je 0xa887
movl 0x30(%r14), %edx
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x33d0
jmp 0xa87f
cmpq $0x0, 0x10(%r14)
je 0xa87f
movl 0x20(%r14), %edi
xorl %esi, %esi
callq 0x3460
testl %eax, %eax
jne 0xa8f0
movq $0x0, 0x10(%r14)
addq (%r14), %rbx
movb $0x1, %r15b
jmp 0xa889
xorl %ebx, %ebx
movq %rbx, 0x8(%r14)
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x20(%r14), %r14d
callq 0x3050
movl (%rax), %edi
callq 0x3130
leaq 0x6b50(%rip), %rdi      # 0x11400
leaq 0x6b6b(%rip), %rdx      # 0x11422
movl $0x440, %esi            # imm = 0x440
movl %r14d, %ecx
movq %rbx, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x8d6f
callq 0x31e0
leaq 0x6bad(%rip), %rdi      # 0x11485
leaq 0x6bc7(%rip), %rdx      # 0x114a6
movl $0x295, %esi            # imm = 0x295
xorl %eax, %eax
callq 0x8d6f
callq 0x31e0
movl 0x20(%r14), %ebx
callq 0x3050
movl (%rax), %edi
callq 0x3130
leaq 0x6af9(%rip), %rdi      # 0x11400
leaq 0x6b14(%rip), %rdx      # 0x11422
movl $0x440, %esi            # imm = 0x440
movl %ebx, %ecx
xorl %r8d, %r8d
movq %rax, %r9
xorl %eax, %eax
callq 0x8d6f
callq 0x31e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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&)
static inline void
    assign_(
        TTarget & target,
        TSource & source)
    {
        if (empty(source) && empty(target))
            return;  // Do nothing if both source and target are empty.
        if (!getObjectId(source) || !shareResources(target, source))
        {
            SEQAN_CHECKPOINT;
            typename Size<TTarget>::Type part_length = _clearSpace(target, length(source), TExpand());
            arrayConstructCopy(begin(source, Standard()), begin(source, Standard()) + part_length, begin(target, Standard()));
        }
        else
        {
            SEQAN_CHECKPOINT;
            if ((void *) &target == (void *) &source) return;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %rbx
testq %rbx, %rbx
jne 0x10655
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x10705
movq (%r15), %rax
addq %rbx, %rax
testq %rbx, %rbx
cmoveq %rbx, %rax
testq %rax, %rax
je 0x1069e
cmpq %rax, 0x8(%r14)
jne 0x1069e
cmpq %r15, %r14
je 0x10705
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x10728
movq %r14, %rdi
movq %r12, %rsi
callq 0xb03c
movq -0x40(%rbp), %rdi
callq 0x32f0
jmp 0x10705
cmpq %rbx, 0x10(%r14)
jae 0x106d0
movq %rbx, %rax
shrq %rax
addq %rbx, %rax
cmpq $0x20, %rbx
movl $0x20, %r13d
cmovaeq %rax, %r13
leaq 0x1(%r13), %rdi
movq (%r14), %r12
callq 0x3340
movq %rax, (%r14)
movq %r13, 0x10(%r14)
jmp 0x106d3
xorl %r12d, %r12d
testq %r12, %r12
je 0x106e0
movq %r12, %rdi
callq 0x32f0
movq (%r14), %rax
leaq (%rax,%rbx), %rcx
movq %rcx, 0x8(%r14)
testq %rbx, %rbx
je 0x10705
movq (%r15), %rcx
xorl %edx, %edx
movb (%rcx,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
cmpq %rdx, %rbx
jne 0x106f5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
callq 0x32f0
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r12
movq (%rsi), %rax
addq %r12, %rax
testq %r12, %r12
cmoveq %r12, %rax
testq %rax, %rax
je 0x10804
cmpq %rax, 0x8(%rbx)
jne 0x10804
cmpq %r14, %rbx
je 0x10879
cmpq %rdx, %r12
cmovbq %r12, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x10728
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb03c
movq -0x40(%rbp), %rdi
callq 0x32f0
jmp 0x10879
cmpq %r12, %rdx
cmovbq %rdx, %r12
cmpq %r12, 0x10(%rbx)
jae 0x10844
movq %r12, %rax
shrq %rax
addq %r12, %rax
cmpq $0x20, %r12
movl $0x20, %r13d
cmovaeq %rax, %r13
cmpq %rdx, %r13
cmovaeq %rdx, %r13
leaq 0x1(%r13), %rdi
movq (%rbx), %r15
callq 0x3340
movq %rax, (%rbx)
movq %r13, 0x10(%rbx)
jmp 0x10847
xorl %r15d, %r15d
testq %r15, %r15
je 0x10854
movq %r15, %rdi
callq 0x32f0
movq (%rbx), %rax
leaq (%rax,%r12), %rcx
movq %rcx, 0x8(%rbx)
testq %r12, %r12
je 0x10879
movq (%r14), %rcx
xorl %edx, %edx
movb (%rcx,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
cmpq %rdx, %r12
jne 0x10869
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
callq 0x32f0
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O1/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), %r15
movq %r15, %rdi
callq 0x3170
testq %r15, %r15
je 0xb5b3
leaq (%r15,%rax), %rcx
cmpq %rcx, 0x8(%rbx)
jne 0xb5b3
movq %r15, %rdi
callq 0x3170
leaq -0x30(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb3d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb772
movq -0x30(%rbp), %rdi
callq 0x32f0
jmp 0xb5eb
movq 0x8(%rbx), %r15
subq (%rbx), %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r15, %rcx
callq 0xb60a
testq %rax, %rax
je 0xb5eb
addq (%rbx), %r15
movq (%r14), %rsi
movq %r15, %rdi
movq %rax, %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3530
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x32f0
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbf5c
movq %rax, %rbx
testl %r15d, %r15d
setne %al
cmpq %r14, %rbx
sete %cl
orb %al, %cl
jne 0xbf4d
movq 0xa139(%rip), %r15      # 0x15ff0
leaq 0x5722(%rip), %rsi      # 0x115e0
movl $0xe, %edx
movq %r15, %rdi
callq 0x33a0
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3300
movq %rax, %r15
leaq 0x56f8(%rip), %rsi      # 0x115ef
movl $0xc, %edx
movq %rax, %rdi
callq 0x33a0
movq %r15, %rdi
movq %r14, %rsi
callq 0x3300
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rcx
movl 0x18(%r14,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%r14,%rcx)
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3310
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3220
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %edi
callq 0x3630
movq %rax, %rbx
testq %rax, %rax
jns 0xc038
movq 0xa06f(%rip), %r14      # 0x15ff0
leaq 0x5657(%rip), %rsi      # 0x115df
movl $0xf, %edx
movq %r14, %rdi
callq 0x33a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3300
movq %rax, %r14
leaq 0x544e(%rip), %rsi      # 0x113f8
movl $0x3, %edx
movq %rax, %rdi
callq 0x33a0
callq 0x3050
movl (%rax), %edi
callq 0x3130
testq %rax, %rax
je 0xbfe3
movq %rax, %r15
movq %rax, %rdi
callq 0x3170
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x33a0
jmp 0xbffd
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x3560
leaq 0x5540(%rip), %rsi      # 0x11544
movl $0x1, %edx
movq %r14, %rdi
callq 0x33a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3310
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3220
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x18(%rdi), %rcx
movq %rax, 0x8(%rdi)
movq %rcx, 0x20(%rdi)
movq 0x30(%rdi), %r14
movq 0x38(%rdi), %r15
cmpq %r15, %r14
je 0xcd44
movq (%r14), %rdi
callq 0x32f0
addq $0x30, %r14
jmp 0xcd31
movq 0x30(%rbx), %rax
movq 0x48(%rbx), %r14
movq %rax, 0x38(%rbx)
movq 0x50(%rbx), %r15
cmpq %r15, %r14
je 0xcd67
movq (%r14), %rdi
callq 0x32f0
addq $0x18, %r14
jmp 0xcd54
movq 0x48(%rbx), %rax
movq 0x60(%rbx), %r15
movq %rax, 0x50(%rbx)
movq 0x68(%rbx), %r12
movq %r12, %r14
subq %r15, %r14
movl $0x1, %eax
cmpq $0x8, %r14
ja 0xcdd7
cmpq $0x0, 0x70(%rbx)
jne 0xcdd7
movl $0x8, %edi
callq 0x3340
movq %rax, 0x60(%rbx)
movq $0x1, 0x70(%rbx)
testq %r15, %r15
je 0xcdc5
cmpq %r15, %r12
je 0xcdbd
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3530
movq %r15, %rdi
callq 0x32f0
addq 0x60(%rbx), %r14
movq %r14, 0x68(%rbx)
xorl %eax, %eax
cmpq $0x0, 0x70(%rbx)
setne %al
shll $0x3, %eax
addq 0x60(%rbx), %rax
movq %rax, 0x68(%rbx)
movb $0x1, 0x78(%rbx)
leaq 0x88(%rbx), %r14
movq %r14, %rdi
callq 0xe328
movq 0xc0(%rbx), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0xce4b
movl $0x1, %r12d
xorl %eax, %eax
leaq -0x30(%rbp), %r15
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
movq %rax, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x9d08
movl %r12d, %eax
movq 0xc0(%rbx), %rcx
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
incl %r12d
cmpq %rax, %rdx
ja 0xce1b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mshabbirhasan[P]ups-indel/include/seqan/file/string_mmap.h
// Function: bool seqan::close<char, seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>(seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>&)
inline bool 
    close(String<TValue, MMap<TConfig> > &me) 
	{
        typedef typename Size<typename TConfig::TFile>::Type TFileSize;

		if (me)
		{
            TFileSize finalLen = (TFileSize)length(me) * (TFileSize)sizeof(TValue);

			// close associated file
			if (me.mapping.temporary)
				cancel(me);

            _unmap(me);
			closeAndResize(me.mapping, finalLen);
		}
		return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $-0x1, 0x20(%rdi)
je 0xcefb
movq %rdi, %rbx
movq (%rdi), %r12
movq 0x8(%rdi), %r14
cmpb $0x1, 0x2d(%rdi)
jne 0xce93
movq 0x10(%rbx), %rsi
movq %r12, %rdi
movl $0x2, %edx
callq 0x3070
movq (%rbx), %r15
testq %r15, %r15
je 0xceb5
movq 0x10(%rbx), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x31f0
testl %eax, %eax
jne 0xcf0c
movq $0x0, (%rbx)
subq %r12, %r14
movq $0x0, 0x8(%rbx)
cmpq %r14, 0x10(%rbx)
je 0xced5
movl 0x20(%rbx), %edi
movq %r14, %rsi
callq 0x3460
testl %eax, %eax
jne 0xcf40
cmpb $0x1, 0x2c(%rbx)
jne 0xcee6
leaq 0x18(%rbx), %rdi
movq 0x18(%rbx), %rax
callq *0x18(%rax)
movq $0x0, 0x10(%rbx)
movl $0x3, 0x28(%rbx)
movw $0x100, 0x2c(%rbx)      # imm = 0x100
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3050
movl (%rax), %edi
callq 0x3130
leaq 0x451f(%rip), %rdi      # 0x1143e
leaq 0x453a(%rip), %rdx      # 0x11460
movl $0x35c, %esi            # imm = 0x35C
movq %r15, %rcx
movq %r13, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x8d6f
callq 0x31e0
movl 0x20(%rbx), %ebx
callq 0x3050
movl (%rax), %edi
callq 0x3130
leaq 0x44aa(%rip), %rdi      # 0x11400
leaq 0x44c5(%rip), %rdx      # 0x11422
movl $0x440, %esi            # imm = 0x440
movl %ebx, %ecx
movq %r14, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x8d6f
callq 0x31e0
// File: /workspace/github_cpp_makefile_star2_O1/mshabbirhasan[P]ups-indel/include/seqan/stream/tokenize.h
// Function: int seqan::skipChar<std::basic_ifstream<char, std::char_traits<char>>, seqan::SinglePass<void>>(seqan::RecordReader<std::basic_ifstream<char, std::char_traits<char>>, seqan::SinglePass<void>>&, char)
inline int
skipChar(RecordReader<TStream, TPass> & reader, char const c)
{
    SEQAN_CHECKPOINT;
    if (atEnd(reader))
        return EOF_BEFORE_SUCCESS;
    if (value(reader) != c)
        return 1;
    goNext(reader);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x30(%rdi), %rax
cmpq %rax, 0x28(%rdi)
je 0xd15b
movq 0x28(%rbx), %rax
cmpq 0x30(%rbx), %rax
leaq -0x21(%rbp), %rdx
setne (%rdx)
leaq 0x44e9(%rip), %rdi      # 0x11603
leaq 0x450e(%rip), %rcx      # 0x1162f
movl $0x108, %esi            # imm = 0x108
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xb89e
testb %al, %al
je 0xd1fc
movq 0x28(%rbx), %rax
movl $0x1, %r15d
cmpb %r14b, (%rax)
jne 0xd1df
movq %rbx, %rdi
callq 0xd56c
xorl %r15d, %r15d
jmp 0xd1df
movq (%rbx), %rdi
movq (%rdi), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rdi,%rcx), %ecx
andl $0x2, %ecx
movl $0x400, %r15d           # imm = 0x400
orl 0x38(%rbx), %ecx
jne 0xd1df
testq %rax, %rax
je 0xd182
cmpb $0x0, 0x3c(%rbx)
jne 0xd1df
movq 0x10(%rbx), %rax
movq %rax, 0x28(%rbx)
callq 0x3580
movq %rax, 0x40(%rbx)
movq %rdx, 0x48(%rbx)
movq 0x28(%rbx), %rsi
movq (%rbx), %r12
movl 0x8(%rbx), %edx
movq %r12, %rdi
callq 0x3410
movq 0x8(%r12), %rax
addq %rax, 0x40(%rbx)
movl 0x8(%rbx), %ecx
cmpq %rcx, %rax
je 0xd1ef
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 0xd1ef
movq 0x28(%rbx), %rax
movq %rax, 0x30(%rbx)
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq 0x28(%rbx), %rax
movq %rax, 0x30(%rbx)
jmp 0xd104
callq 0x31e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0xe021
testl %eax, %eax
jne 0xd2b9
movq 0x30(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0xd239
movq %rbx, %rdi
callq 0xd56c
jmp 0xd2b6
movq (%rbx), %rdi
movq (%rdi), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rdi,%rcx), %ecx
andl $0x2, %ecx
orl 0x38(%rbx), %ecx
jne 0xd2b6
testq %rax, %rax
je 0xd25a
cmpb $0x0, 0x3c(%rbx)
jne 0xd2b6
movq 0x10(%rbx), %rax
movq %rax, 0x28(%rbx)
callq 0x3580
movq %rax, 0x40(%rbx)
movq %rdx, 0x48(%rbx)
movq 0x28(%rbx), %rsi
movq (%rbx), %r14
movl 0x8(%rbx), %edx
movq %r14, %rdi
callq 0x3410
movq 0x8(%r14), %rax
addq %rax, 0x40(%rbx)
movl 0x8(%rbx), %ecx
cmpq %rcx, %rax
je 0xd2c2
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 0xd2c2
movq 0x28(%rbx), %rax
movq %rax, 0x30(%rbx)
movl 0x38(%rbx), %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
addq 0x28(%rbx), %rax
movq %rax, 0x30(%rbx)
jmp 0xd22f
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
leaq -0x11(%rbp), %rdx
setne (%rdx)
leaq 0x4073(%rip), %rdi      # 0x11603
leaq 0x4098(%rip), %rcx      # 0x1162f
movl $0xf5, %esi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xb89e
testb %al, %al
je 0xd655
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
incq %rax
movq %rax, 0x28(%rbx)
cmpq %rcx, %rax
je 0xd5c9
xorl %eax, %eax
jmp 0xd64c
movb $0x1, %al
testq %rcx, %rcx
je 0xd5d6
cmpb $0x0, 0x3c(%rbx)
jne 0xd64c
movq (%rbx), %rdi
movq (%rdi), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%rdi,%rcx)
jne 0xd64c
movq 0x10(%rbx), %rax
movq %rax, 0x28(%rbx)
callq 0x3580
movq %rax, 0x40(%rbx)
movq %rdx, 0x48(%rbx)
movq 0x28(%rbx), %rsi
movq (%rbx), %r14
movl 0x8(%rbx), %edx
movq %r14, %rdi
callq 0x3410
movq 0x8(%r14), %rcx
addq %rcx, 0x40(%rbx)
movl 0x8(%rbx), %eax
cmpq %rax, %rcx
je 0xd642
movq (%rbx), %rax
movq (%rax), %rdx
movq -0x18(%rdx), %rdx
movl 0x20(%rax,%rdx), %eax
xorl %edx, %edx
testb $0x2, %al
cmovel %eax, %edx
movl %edx, 0x38(%rbx)
testl %edx, %edx
je 0xd642
movq 0x28(%rbx), %rcx
movb $0x1, %al
jmp 0xd648
addq 0x28(%rbx), %rcx
xorl %eax, %eax
movq %rcx, 0x30(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x31e0
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
movq 0x10(%rsi), %rcx
movq %rax, %rdx
shrq %rdx
addq %rax, %rdx
cmpq $0x20, %rax
movl $0x20, %r15d
cmovaeq %rdx, %r15
cmpq %rcx, %r15
cmovaeq %rcx, %r15
testq %r15, %r15
je 0xdf28
leaq 0x1(%r15), %rdi
callq 0x3340
movq %rax, (%rbx)
movq %r15, 0x10(%rbx)
movq %rax, 0x8(%rbx)
leaq 0x8(%rbx), %r15
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0xdf40
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb03c
leaq 0x33bb(%rip), %rax      # 0x11302
movq %rax, (%rsp)
leaq 0x3376(%rip), %rdi      # 0x112c8
leaq 0x3395(%rip), %rcx      # 0x112ee
leaq 0x3399(%rip), %r9       # 0x112f9
movl $0x86, %esi
movq %rbx, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x91c5
testb %al, %al
je 0xdf81
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x31e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
leaq 0x35c7(%rip), %r12      # 0x11603
movl %edx, -0x30(%rbp)
movq 0x30(%rbx), %rax
cmpq %rax, 0x28(%rbx)
jne 0xe0ea
movq (%rbx), %rdi
movq (%rdi), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rdi,%rcx), %ecx
andl $0x2, %ecx
movl $0x400, %r15d           # imm = 0x400
orl 0x38(%rbx), %ecx
jne 0xe150
testq %rax, %rax
je 0xe07c
cmpb $0x0, 0x3c(%rbx)
jne 0xe150
movq %r12, %r14
movq 0x10(%rbx), %rax
movq %rax, 0x28(%rbx)
callq 0x3580
movq %rax, 0x40(%rbx)
movq %rdx, 0x48(%rbx)
movq 0x28(%rbx), %rsi
movq (%rbx), %r12
movl 0x8(%rbx), %edx
movq %r12, %rdi
callq 0x3410
movq 0x8(%r12), %rax
addq %rax, 0x40(%rbx)
movl 0x8(%rbx), %ecx
cmpq %rcx, %rax
je 0xe0db
movq (%rbx), %rcx
movq (%rcx), %rdx
movq -0x18(%rdx), %rdx
movl 0x20(%rcx,%rdx), %ecx
testb $0x2, %cl
movl $0x0, %edx
cmovnel %edx, %ecx
movl %ecx, 0x38(%rbx)
testl %ecx, %ecx
jne 0xe162
addq 0x28(%rbx), %rax
movq %rax, 0x30(%rbx)
movq %r14, %r12
movl -0x30(%rbp), %r14d
movq 0x28(%rbx), %rax
cmpq 0x30(%rbx), %rax
setne -0x29(%rbp)
movq %r12, %rdi
movl $0x108, %esi            # imm = 0x108
leaq -0x29(%rbp), %rdx
leaq 0x3526(%rip), %rcx      # 0x1162f
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xb89e
testb %al, %al
je 0xe16c
movq 0x28(%rbx), %rax
cmpb $0xa, (%rax)
setne %al
xorl %r15d, %r15d
xorb %r14b, %al
movl $0x0, %eax
jne 0xe145
movq %rbx, %rdi
callq 0xd56c
movl 0x38(%rbx), %ecx
testl %ecx, %ecx
sete %al
cmovnel %ecx, %r13d
movl %r13d, %r15d
movl %r15d, %r13d
testb %al, %al
jne 0xe03f
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rbx), %rax
movq %rax, 0x30(%rbx)
jmp 0xe150
callq 0x31e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rax
movq %rax, -0x50(%rbp)
subq %rcx, %rax
cmpq $0x2001, %rax           # imm = 0x2001
jl 0xecda
leaq 0x2000(%rcx), %rax
movq %rax, 0x10(%rbx)
movq %rcx, -0x58(%rbp)
movq 0x8(%rbx), %r13
movq 0x10(%rbx), %r15
cmpq %r15, %r13
je 0xedcc
leaq -0x88(%rbp), %rdi
callq 0x8ef8
leaq -0x70(%rbp), %rdi
callq 0x8ef8
leaq -0x48(%rbp), %rdi
callq 0x8ef8
movq -0x88(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x70(%rbp), %rax
movq -0x60(%rbp), %r14
movq %rax, -0x68(%rbp)
movq -0x48(%rbp), %r12
movq -0x38(%rbp), %rax
movq %r12, -0x40(%rbp)
cmpq %r14, %rax
jae 0xed5b
leaq 0x1(%r14), %rdi
callq 0x3340
movq %rax, -0x48(%rbp)
movq %r14, -0x38(%rbp)
testq %r12, %r12
je 0xed53
movq %r12, %rdi
callq 0x32f0
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movq %rbx, %rdx
leaq -0x29(%rbp), %rcx
callq 0xee39
movl %eax, %r12d
testl %eax, %eax
jne 0xeda4
movl -0x68(%rbp), %edx
subl -0x70(%rbp), %edx
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
leaq -0x88(%rbp), %rcx
leaq -0x29(%rbp), %r8
callq 0xef31
movl %eax, %r12d
andl $0xfffffbff, %r12d      # imm = 0xFFFFFBFF
cmovnel %eax, %r12d
movq -0x48(%rbp), %rdi
callq 0x32f0
movq -0x70(%rbp), %rdi
callq 0x32f0
movq -0x88(%rbp), %rdi
callq 0x32f0
cmpl $0x1, %r12d
jne 0xecde
cmpq %r15, %r13
sete %al
movq -0x50(%rbp), %rcx
movq %rcx, 0x10(%rbx)
movq -0x58(%rbp), %rcx
movq %rcx, 0x8(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xee15
movq %rax, %r14
jmp 0xee21
movq %rax, %r14
jmp 0xee0c
movq %rax, %r14
movq -0x48(%rbp), %rdi
callq 0x32f0
movq -0x70(%rbp), %rdi
callq 0x32f0
movq -0x88(%rbp), %rdi
callq 0x32f0
movq -0x50(%rbp), %rax
movq %rax, 0x10(%rbx)
movq -0x58(%rbp), %rax
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdx), %rax
movl $0x1, %r12d
cmpq 0x10(%rdx), %rax
je 0xef1a
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
leaq -0x29(%rbp), %rdx
movb $0x1, (%rdx)
leaq 0x281f(%rip), %rdi      # 0x11694
leaq 0x27b3(%rip), %rcx      # 0x1162f
movl $0xca, %esi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xb89e
testb %al, %al
je 0xef2c
movq 0x8(%r14), %rax
cmpb $0x40, (%rax)
jne 0xef1a
cmpq 0x10(%r14), %rax
leaq -0x2a(%rbp), %rdx
setne (%rdx)
leaq 0x27e6(%rip), %rdi      # 0x11694
leaq 0x277a(%rip), %rcx      # 0x1162f
xorl %r12d, %r12d
movl $0xbd, %esi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xb89e
testb %al, %al
je 0xef2c
movq 0x8(%r14), %rax
incq %rax
movq %rax, 0x8(%r14)
cmpq 0x10(%r14), %rax
je 0xef1a
movq %r13, %rdi
movq %r14, %rsi
callq 0xea54
movl %eax, %r12d
testl %eax, %eax
jne 0xef1a
movq 0x8(%r14), %rax
movl $0x0, %r12d
cmpq 0x10(%r14), %rax
je 0xef1a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf0c3
movl %eax, %r12d
andl $0xfffffbff, %r12d      # imm = 0xFFFFFBFF
cmovnel %eax, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x31e0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x8(%rdi), %rcx
movq %rdi, -0x38(%rbp)
movq 0x10(%rdi), %rax
movq %rax, -0x40(%rbp)
subq %rcx, %rax
cmpq $0x2001, %rax           # imm = 0x2001
jl 0xf638
leaq 0x2000(%rcx), %rax
movq -0x38(%rbp), %rdx
movq %rax, 0x10(%rdx)
movq %rcx, -0x48(%rbp)
leaq -0x78(%rbp), %r13
leaq -0x60(%rbp), %r15
movq -0x38(%rbp), %rax
movq 0x8(%rax), %r12
movq 0x10(%rax), %r14
cmpq %r14, %r12
je 0xf6a9
movq %r13, %rdi
callq 0x8ef8
movq %r15, %rdi
callq 0x8ef8
movq %r15, %rsi
movq -0x78(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %r13, %rbx
movq %r13, %rdi
movq -0x38(%rbp), %rdx
leaq -0x29(%rbp), %rcx
callq 0xf70d
movl %eax, %r13d
movq -0x60(%rbp), %rdi
callq 0x32f0
movq -0x78(%rbp), %rdi
callq 0x32f0
cmpl $0x1, %r13d
movq %rbx, %r13
jne 0xf644
cmpq %r14, %r12
sete %al
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdx
movq %rcx, 0x10(%rdx)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rdx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xf6f1
movq %rax, %r14
movq -0x60(%rbp), %rdi
callq 0x32f0
jmp 0xf6e8
movq %rax, %r14
movq -0x78(%rbp), %rdi
callq 0x32f0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq -0x48(%rbp), %rax
movq %rax, 0x8(%rcx)
movq %r14, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
leaq -0x238(%rbp), %rdi
movl $0x14, %edx
callq 0x3390
movq 0x38(%rbx), %rax
subq 0x30(%rbx), %rax
je 0xfd1d
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
movl $0x1, %r15d
leaq -0x30(%rbp), %r13
leaq -0x238(%rbp), %r12
xorl %r14d, %r14d
movq %r14, -0x30(%rbp)
movq %rax, -0x38(%rbp)
leaq 0x179b(%rip), %rax      # 0x113a9
movq %rax, (%rsp)
leaq 0x172a(%rip), %rdi      # 0x11343
movl $0x1fd, %esi            # imm = 0x1FD
movq %r13, %rdx
leaq 0x1740(%rip), %rcx      # 0x11368
leaq -0x38(%rbp), %r8
leaq 0x1752(%rip), %r9       # 0x11385
xorl %eax, %eax
callq 0xa0ea
testb %al, %al
je 0xfd7c
leaq (%r14,%r14,2), %r14
shlq $0x4, %r14
addq 0x30(%rbx), %r14
movq %r12, %rdi
movq %r14, %rsi
leaq 0x15ed(%rip), %rdx      # 0x11248
callq 0xfd98
movb $0x9, -0x30(%rbp)
movl $0x1, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x33a0
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x3210
movb $0x9, -0x30(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x33a0
movq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x3210
movb $0x9, -0x30(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x33a0
movl 0x28(%r14), %esi
movq %rax, %rdi
callq 0x3210
movb $0x9, -0x30(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x33a0
movl 0x2c(%r14), %esi
movq %rax, %rdi
callq 0x3210
movb $0xa, -0x30(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x33a0
movq 0x38(%rbx), %rax
subq 0x30(%rbx), %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
movl %r15d, %r14d
incl %r15d
cmpq %r14, %rax
ja 0xfbff
leaq -0x230(%rbp), %rdi
movq -0x8(%rdi), %rax
movq -0x18(%rax), %rax
xorl %ebx, %ebx
cmpl $0x0, -0x218(%rbp,%rax)
setne %bl
movq 0x6288(%rip), %rax      # 0x15fc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x238(%rbp,%rcx)
callq 0x32a0
leaq -0x140(%rbp), %rdi
callq 0x3120
movl %ebx, %eax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x31e0
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x34a0
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O1/shisharka[P]interactive_deduction/interactive_deduction.tab.cpp
// Function: yy_stack_print(signed char*, signed char*)
static void
yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
{
  YYFPRINTF (stderr, "Stack now");
  for (; yybottom <= yytop; yybottom++)
    {
      int yybot = *yybottom;
      YYFPRINTF (stderr, " %d", yybot);
    }
  YYFPRINTF (stderr, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xdc7b(%rip), %r12      # 0x10fb0
movq (%r12), %rcx
leaq 0x833a(%rip), %rdi      # 0xb67a
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
callq 0x3300
cmpq %rbx, %r14
ja 0x3371
leaq 0x832d(%rip), %r15      # 0xb684
movsbl (%r14), %edx
movq (%r12), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3210
incq %r14
cmpq %rbx, %r14
jbe 0x3357
movq (%r12), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x31e0
// File: /workspace/github_cpp_makefile_star2_O1/shisharka[P]interactive_deduction/formula.cpp
// Function: Atom::equalTo(std::shared_ptr<BaseFormula> const&) const
bool Atom::equalTo(const Formula & f) const {
  if(f->getType() != T_ATOM)
    return false;

  Atom * a = (Atom *) f.get();
  
  return a->getVariable() == _v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x2, %eax
jne 0x815f
movq (%r14), %rax
movq 0x20(%rax), %rdx
cmpq 0x20(%rbx), %rdx
jne 0x815f
testq %rdx, %rdx
je 0x8169
movq 0x18(%rbx), %rsi
movq 0x18(%rax), %rdi
callq 0x3190
testl %eax, %eax
sete %al
jmp 0x8161
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x1, %al
jmp 0x8161
nop
// File: /workspace/github_cpp_makefile_star2_O1/shisharka[P]interactive_deduction/formula.cpp
// Function: UnaryConnective::equalTo(std::shared_ptr<BaseFormula> const&) const
bool UnaryConnective::equalTo(const Formula & f) const {
  if(f->getType() != getType())
    return false;

  UnaryConnective * uc = (UnaryConnective *) f.get();
  
  return uc->getOperand()->equalTo(_op);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpl %eax, %ebp
jne 0x81a9
movq (%r14), %rax
movq 0x18(%rax), %rdi
addq $0x18, %rbx
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/shisharka[P]interactive_deduction/formula.cpp
// Function: BinaryConnective::equalTo(std::shared_ptr<BaseFormula> const&) const
bool BinaryConnective::equalTo(const Formula & f) const {
  if(f->getType() != getType())
    return false;

  BinaryConnective * bc = (BinaryConnective *) f.get();
  
  return bc->getOperand1()->equalTo(_op1) &&
          bc->getOperand2()->equalTo(_op2);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpl %eax, %ebp
jne 0x81fd
movq (%r14), %r14
movq 0x18(%r14), %rdi
leaq 0x18(%rbx), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x81fd
movq 0x28(%r14), %rdi
addq $0x28, %rbx
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: addAssumption(std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>&, std::shared_ptr<BaseFormula> const&)
void addAssumption(vector<Formula> & assumptions, const Formula & f) {
  bool shouldAdd = true; // indicator for whether or not f should be added to assumptions
  for(unsigned i = 0; i < assumptions.size(); i++)
    if(f->equalTo(assumptions[i]))
      shouldAdd = false;
  if(shouldAdd)
    assumptions.push_back(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x8a26
movb $0x1, %bpl
movl $0x1, %r15d
xorl %r12d, %r12d
xorl %esi, %esi
movq (%rbx), %rdi
shlq $0x4, %rsi
addq %rax, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movzbl %bpl, %ebp
testb %al, %al
cmovnel %r12d, %ebp
movl %r15d, %esi
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
incl %r15d
cmpq %rsi, %rcx
ja 0x89ed
testb $0x1, %bpl
je 0x8a39
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9fca
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyNotI(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyNotI(Goal & g) {
  if(g.second->getType() == T_NOT) {
    Formula notOp = ((Not *)g.second.get())->getOperand();

    addAssumption(g.first, notOp);

    g.second = make_shared<False>();
  }
  else
    cerr << "Failed to apply NotI" << endl;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x8b80
movq 0x18(%rbx), %rdi
callq 0x7eac
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x8bcb
movq 0x842a(%rip), %rcx      # 0x10fa0
cmpb $0x0, (%rcx)
je 0x8bc7
incl 0x8(%rax)
jmp 0x8bcb
movq 0x8461(%rip), %rbx      # 0x10fe8
leaq 0x34b1(%rip), %rsi      # 0xc03f
movl $0x14, %edx
movq %rbx, %rdi
callq 0x31b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x30, %rsp
popq %rbx
jmp 0x3100
lock
incl 0x8(%rax)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x89c8
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rsi
callq 0x6442
movaps 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x20(%rsp)
movq 0x20(%rbx), %rdi
movups %xmm0, 0x18(%rbx)
testq %rdi, %rdi
je 0x8c06
callq 0x59f4
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x8c15
callq 0x59f4
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8c24
callq 0x59f4
addq $0x30, %rsp
popq %rbx
retq
jmp 0x8c2c
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8c3e
callq 0x59f4
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyConjI(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>> const&, std::vector<std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>, std::allocator<std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>>>&)
void applyConjI(const Goal & g, vector<Goal> & subgoals) {
  if(g.second->getType() == T_AND) {
    Goal goal1, goal2;

    goal1.first = g.first;
    goal1.second = ((And *)g.second.get())->getOperand1();

    goal2.first = g.first;
    goal2.second = ((And *)g.second.get())->getOperand2();

    subgoals.push_back(goal1);
    subgoals.push_back(goal2);
  }
  else
    cerr << "Failed to apply ConjI" << endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x4, %eax
jne 0x8d2d
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movq %rax, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %r14, %rsi
callq 0xa00a
movq 0x18(%r14), %rdi
callq 0x7eb2
movq (%rax), %rcx
leaq 0x50(%rsp), %rdi
movq %rcx, -0x8(%rdi)
addq $0x8, %rax
movq %rax, %rsi
callq 0x59a2
movq %rsp, %rdi
movq %r14, %rsi
callq 0xa00a
movq 0x18(%r14), %rdi
callq 0x7eb8
movq (%rax), %rcx
leaq 0x20(%rsp), %rdi
movq %rcx, -0x8(%rdi)
addq $0x8, %rax
movq %rax, %rsi
callq 0x59a2
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xa1b4
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xa1b4
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8d04
callq 0x59f4
movq %rsp, %rdi
callq 0x58e0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x8d1b
callq 0x59f4
leaq 0x30(%rsp), %rdi
callq 0x58e0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq 0x82b4(%rip), %rbx      # 0x10fe8
leaq 0x3319(%rip), %rsi      # 0xc054
movl $0x15, %edx
movq %rbx, %rdi
callq 0x31b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x58, %rsp
popq %rbx
popq %r14
jmp 0x3100
movq %rax, %rbx
movq %rsp, %rdi
callq 0x58c4
leaq 0x30(%rsp), %rdi
callq 0x58c4
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyDisjI1(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyDisjI1(Goal & g) {
  if(g.second->getType() == T_OR)
    g.second = (((Or *)g.second.get())->getOperand1());
  else
    cerr << "Failed to apply DisjI1" << endl;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x5, %eax
jne 0x8dc6
movq 0x18(%rbx), %rdi
callq 0x7eb2
movq (%rax), %rcx
movq %rcx, 0x18(%rbx)
addq $0x20, %rbx
leaq 0x8(%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x59a2
movq 0x821b(%rip), %rbx      # 0x10fe8
leaq 0x3296(%rip), %rsi      # 0xc06a
movl $0x16, %edx
movq %rbx, %rdi
callq 0x31b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
popq %rbx
jmp 0x3100