LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mshabbirhasan[P]ups-indel/include/seqan/file/file_mapping.h
// Function: void* seqan::remapFileSegment<void, int, long>(seqan::FileMapping<void>&, void*, int, long, long)
inline void *
remapFileSegment(FileMapping<TSpec> &mapping, void *oldAddr, TPos oldFileOfs, TSize oldSize, TSize newSize)
{
    void *addr;
#if !defined(PLATFORM_WINDOWS) && defined(MREMAP_MAYMOVE)
    ignoreUnusedVariableWarning(mapping);
    ignoreUnusedVariableWarning(oldFileOfs);
    addr = mremap(oldAddr, oldSize, newSize, MREMAP_MAYMOVE);
//    std::cerr << "mremap("<<oldAddr<<','<<oldSize<<','<<newSize<<','<<MREMAP_MAYMOVE<<")="<<addr<<std::endl;
    if (addr == MAP_FAILED)
        addr = NULL;
#else
    // for BSD systems without mremap(..) like Mac OS X ...
    unmapFileSegment(mapping, oldAddr, oldSize);
    addr = mapFileSegment(mapping, oldFileOfs, newSize);
#endif
    if (addr == NULL)
        SEQAN_FAIL("remapFileSegment failed: \"%s\"", strerror(errno));
    return addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf230
leaq -0x14(%rbp), %rdi
callq 0xf280
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl $0x1, %ecx
movb $0x0, %al
callq 0x42c0
movq %rax, -0x30(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x30(%rbp)
jne 0xef5e
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xef97
jmp 0xef67
callq 0x4080
movl (%rax), %edi
callq 0x4190
movq %rax, %rcx
leaq 0x197e9(%rip), %rdi     # 0x28766
movl $0x393, %esi            # imm = 0x393
leaq 0x197ff(%rip), %rdx     # 0x28788
movb $0x0, %al
callq 0xb130
callq 0xb2a0
jmp 0xef97
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/file/string_mmap.h
// Function: bool seqan::_unmap<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 
    _unmap(String<TValue, MMap<TConfig> > &me) 
	{
		bool result = true;
		if (me.data_begin != NULL)
		{
            result = unmapFileSegment(me.mapping, me.data_begin, length(me.mapping));
			me.data_begin = NULL;
		}
        me.data_end = NULL;
		return result;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x1, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xf00e
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0xf320
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0xf290
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0xf10a
movq -0x10(%rbp), %rdi
callq 0xf340
movq -0x10(%rbp), %rdi
callq 0xe9d0
cmpq -0x18(%rbp), %rax
jae 0xf078
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
shlq $0x0, %rsi
callq 0xee70
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0xf320
movq -0x20(%rbp), %rdi
movq %rax, %rdx
xorl %esi, %esi
callq 0xf3a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xf0c5
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xf12a
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0xf320
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x28(%rbp), %rdx
movq %rax, %r8
xorl %ecx, %ecx
callq 0xf3d0
jmp 0xf119
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
callq 0xf410
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xea60
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: mshabbirhasan[P]ups-indel/include/seqan/file/file_mapping.h
// Function: bool seqan::unmapFileSegment<void, long>(seqan::FileMapping<void>&, void*, long)
inline bool
unmapFileSegment(FileMapping<TSpec> &, void *addr, TSize size)
{
    bool result;
#ifdef PLATFORM_WINDOWS
    ignoreUnusedVariableWarning(size);
    result = (UnmapViewOfFile(addr) != 0);
#else
    result = (munmap(addr, size) == 0);
//    std::cerr << "munmap("<<addr<<','<<size<<")="<<result<<std::endl;

#endif
    if (!result)
        SEQAN_FAIL("unmapFileSegment(%x,%i) failed: \"%s\"", (unsigned long)addr, size, strerror(errno));
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4270
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xf30c
jmp 0xf2c4
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x4080
movl (%rax), %edi
callq 0x4190
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %r8
movq %rax, %r9
leaq 0x19474(%rip), %rdi     # 0x28766
movl $0x35c, %esi            # imm = 0x35C
leaq 0x194a8(%rip), %rdx     # 0x287a6
movb $0x0, %al
callq 0xb130
callq 0xb2a0
jmp 0xf30c
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/file/file_mapping.h
// Function: bool seqan::openTemp<void>(seqan::FileMapping<void>&)
inline bool
openTemp(FileMapping<TSpec> &mapping)
{
    _initialize(mapping);
    bool result = openTemp(mapping.file);
    mapping.openMode = OPEN_RDWR;
    mapping.ownFile = true;
    mapping.temporary = true;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe290
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0xf570
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl $0x3, 0x18(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x1c(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x1d(%rax)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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>>, char* const>(seqan::String<char, seqan::Alloc<void>>&, 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xfba0
testb $0x1, %al
jne 0xfa95
jmp 0xfaa9
movq -0x8(%rbp), %rdi
callq 0xf8e0
testb $0x1, %al
jne 0xfaa4
jmp 0xfaa9
jmp 0xfb8d
movq -0x10(%rbp), %rdi
callq 0xfbd0
cmpq $0x0, %rax
je 0xfac9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfbf0
testb $0x1, %al
jne 0xfb2c
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xfc60
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0xfc30
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xfc80
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xfc80
addq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
callq 0xfc90
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
callq 0xec50
jmp 0xfb8d
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xfb38
jmp 0xfb8d
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq (%rax), %rdi
callq 0xfc60
movq -0x78(%rbp), %rsi
movq %rax, %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xfcb0
movq -0x70(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0xfd50
jmp 0xfb6b
leaq -0x38(%rbp), %rdi
callq 0xb7b0
jmp 0xfb8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xb7b0
jmp 0xfb96
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4770
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xfc90
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x12(%rbp), %rsi
callq 0xfe70
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xe980
movq -0x8(%rbp), %rdi
callq 0xfe90
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfeb0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xfe4c
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xff20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xff60
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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>>, char* const>(seqan::String<char, seqan::Alloc<void>>&, 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfbd0
cmpq $0x0, %rax
je 0x10187
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfbf0
testb $0x1, %al
jne 0x101ee
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xfc60
movq -0x78(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x10280
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xfc80
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xfc80
addq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0xfc90
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
callq 0xec50
jmp 0x10262
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x101fa
jmp 0x10262
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xfc60
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x1021c
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xfcb0
movq -0x80(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0xfd50
jmp 0x10240
leaq -0x48(%rbp), %rdi
callq 0xb7b0
jmp 0x10262
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xb7b0
jmp 0x1026b
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x4770
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xfc90
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x1a(%rbp), %rsi
callq 0xfe70
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xe980
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x102fc
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xfe90
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10350
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x10336
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xff20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xff60
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xfe90
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
ja 0x1038b
movq $0x0, -0x8(%rbp)
jmp 0x103bf
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xff90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x103ae
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xffd0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10b70
movq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x75(%rbp)
je 0x10f27
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10b90
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x75(%rbp)
jne 0x10ee5
jmp 0x10f27
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x10bf0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x29(%rbp), %rsi
callq 0xfe70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x10bd0
movq %rax, %rdx
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x11030
xorb $-0x1, %al
movb %al, -0x75(%rbp)
movb -0x75(%rbp), %al
testb $0x1, %al
jne 0x10f33
jmp 0x10fbb
movq -0x8(%rbp), %rdi
callq 0xd920
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x10bd0
movq -0x90(%rbp), %rdi
movq %rax, %rsi
movq -0x38(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x11050
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x10bf0
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x10bf0
addq -0x40(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rdi
callq 0xfc90
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq %rax, %rdx
addq -0x38(%rbp), %rdx
callq 0x10530
jmp 0x1101c
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq (%rax), %rdi
callq 0x10bd0
movq -0xa0(%rbp), %rsi
movq %rax, %rdx
leaq -0x60(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x10c00
movq -0x98(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x11090
jmp 0x10ffa
leaq -0x60(%rbp), %rdi
callq 0xb7b0
jmp 0x1101c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xb7b0
jmp 0x11025
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x4770
nop
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd920
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0xfe90
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xfeb0
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x111c0
leaq -0x68(%rbp), %rdi
callq 0x111f0
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x11189
movq -0x48(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq -0x18(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x11210
movq -0x48(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq -0x28(%rbp), %rsi
movq -0x58(%rbp), %rdx
addq -0x18(%rbp), %rdx
addq -0x10(%rbp), %rdx
callq 0x11210
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xff20
jmp 0x111a6
movq -0x58(%rbp), %rdi
addq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
subq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x11240
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xff60
movq -0x10(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/basic/array_construct_destruct.h
// Function: void seqan::_arrayMoveForwardDefault<char*, char*, char*>(char*, char*, char*)
inline void 
_arrayMoveForwardDefault(TSource1 source_begin, 
                          TSource2 source_end, 
                          TTarget target_begin)
{
    SEQAN_CHECKPOINT;
    while (source_begin != source_end)
    {
        move(*target_begin, *source_begin);
        ++source_begin;
        ++target_begin;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x113f5
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x11400
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x113c4
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x11578
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11400
jmp 0x11547
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd920
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfe90
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jb 0x1174f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x117a0
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x117d0
leaq -0x30(%rbp), %rdi
callq 0x111f0
cmpq $0x0, %rax
je 0x11784
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x117d0
leaq -0x40(%rbp), %rdi
callq 0x11800
movb $0x0, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x111c0
leaq -0x50(%rbp), %rdi
callq 0x111f0
addq $0x60, %rsp
popq %rbp
retq
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd900
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0xd960
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x11b00
movq -0x20(%rbp), %rdi
callq 0x11b10
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x11b30
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x11ace
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x4050
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x47c0
testb $0x1, %al
jne 0x11c3c
movl $0x0, -0x4(%rbp)
jmp 0x11ca4
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x4800
testb $0x1, %al
jne 0x11c52
jmp 0x11c5b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11ca4
jmp 0x11c5d
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x4030
andb $0x1, %al
movb %al, -0x12(%rbp)
leaq 0x16be0(%rip), %rdi     # 0x28859
movl $0x19f, %esi            # imm = 0x19F
leaq -0x12(%rbp), %rdx
leaq 0x16bf5(%rip), %rcx     # 0x2887e
callq 0x11cb0
xorb $-0x1, %al
testb $0x1, %al
jne 0x11c96
jmp 0x11c9b
callq 0xb2a0
jmp 0x11c9d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x11d2e
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)
movq %r9, -0xd8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, (%rax)
jne 0x11e55
callq 0xb9c0
movb $0x0, (%rax)
callq 0xb2d0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rsi
movq 0x2627c(%rip), %rdi     # 0x37ff0
callq 0x4430
movq %rax, %rdi
leaq 0x16df4(%rip), %rsi     # 0x28b77
callq 0x4430
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x4740
movq %rax, %rdi
leaq 0x16859(%rip), %rsi     # 0x285f6
callq 0x4430
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x4430
movq %rax, %rdi
leaq 0x16ad4(%rip), %rsi     # 0x2888c
callq 0x4430
movq %rax, %rdi
movq -0x20(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x47b0
cmpq $0x0, -0x30(%rbp)
je 0x11e3c
movq 0x26212(%rip), %rdi     # 0x37ff0
leaq 0x168ec(%rip), %rsi     # 0x286d1
callq 0x4430
leaq -0x50(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x28, (%rax)
movq 0x261b3(%rip), %rax     # 0x37fc8
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x4590
leaq -0x50(%rbp), %rax
movq 0x261c0(%rip), %rdi     # 0x37ff0
leaq 0x16a53(%rip), %rsi     # 0x2888a
callq 0x4430
movq 0x261ad(%rip), %rdi     # 0x37ff0
movq 0x26156(%rip), %rsi     # 0x37fa0
callq 0x4480
movb $0x0, -0x1(%rbp)
jmp 0x11e59
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x122a0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x122c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x12370
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/file/file_base.h
// Function: seqan::Position<seqan::File<seqan::Async<void>>>::Type seqan::seek<seqan::Async<void>, int>(seqan::File<seqan::Async<void>>&, int, 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
movl -0x10(%rbp), %edx
callq 0x12450
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x1235f
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
je 0x1235f
movq 0x25cf0(%rip), %rdi     # 0x37ff0
leaq 0x1661f(%rip), %rsi     # 0x28926
callq 0x4430
movq %rax, %rdi
leaq 0x1ea(%rip), %rsi       # 0x12500
callq 0x41a0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x47e0
movq %rax, %rdi
leaq 0x16604(%rip), %rsi     # 0x28935
callq 0x4430
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x4740
movq %rax, %rdi
leaq 0x1e5(%rip), %rsi       # 0x12530
callq 0x41a0
movq %rax, %rdi
movq 0x25c46(%rip), %rsi     # 0x37fa0
callq 0x4480
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x4820
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x124e9
movq 0x25b68(%rip), %rdi     # 0x37ff0
leaq 0x16496(%rip), %rsi     # 0x28925
callq 0x4430
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x47e0
movq %rax, %rdi
leaq 0x16226(%rip), %rsi     # 0x286d0
callq 0x4430
movq %rax, -0x28(%rbp)
callq 0x4080
movl (%rax), %edi
callq 0x4190
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x4430
movq %rax, %rdi
leaq 0x163b5(%rip), %rsi     # 0x2888a
callq 0x4430
movq %rax, %rdi
movq 0x25abc(%rip), %rsi     # 0x37fa0
callq 0x4480
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13670
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x13670
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x139c0
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x13a10
movq -0x8(%rbp), %rdi
addq $0x88, %rdi
callq 0x13930
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf4a0
testb $0x1, %al
jne 0x1332b
jmp 0x13369
movq -0x8(%rbp), %rdi
callq 0xe940
shlq $0x0, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x2d(%rax)
je 0x1334f
movq -0x8(%rbp), %rdi
callq 0x13e80
movq -0x8(%rbp), %rdi
callq 0xefb0
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x13ed0
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13310
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x13fc0
testb $0x1, %al
jne 0x133b6
jmp 0x133da
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe9d0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xf030
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x133de
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
je 0x134c4
movb $0x0, -0x1(%rbp)
jmp 0x134f4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x14350
testb $0x1, %al
jne 0x134de
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x134e4
movb $0x1, -0x1(%rbp)
jmp 0x134f4
movq -0x10(%rbp), %rdi
callq 0x14110
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x134a0
testb $0x1, %al
jne 0x13631
jmp 0x1363a
movl $0x400, -0x4(%rbp)      # imm = 0x400
jmp 0x13667
movq -0x10(%rbp), %rdi
callq 0x135b0
movsbl %al, %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x13657
movl $0x1, -0x4(%rbp)
jmp 0x13667
movq -0x10(%rbp), %rdi
callq 0x14610
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x4310
movq -0x1c0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15760
jmp 0x136f8
xorl %eax, %eax
movl %eax, %esi
leaq -0x1b8(%rbp), %rdi
callq 0x140a0
jmp 0x1370a
movq -0x1b8(%rbp), %rsi
movq -0x1b0(%rbp), %rdx
leaq -0x198(%rbp), %rdi
callq 0x4540
jmp 0x13726
movq -0x8(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0x4600
movq %rax, -0x1c8(%rbp)
jmp 0x1373f
movq -0x1c8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4520
movb %al, -0x1c9(%rbp)
jmp 0x1375d
leaq -0x198(%rbp), %rdi
callq 0x4330
movb -0x1c9(%rbp), %al
andb $0x1, %al
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x4330
movq -0x1a0(%rbp), %rdi
callq 0x4770
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x15(%rbp), %rsi
callq 0x15a40
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x138ca
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x138ec
movq -0x10(%rbp), %rdi
callq 0x134a0
testb $0x1, %al
jne 0x138e0
movq -0x10(%rbp), %rdi
callq 0x14610
movq -0x10(%rbp), %rdi
callq 0x146b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: mshabbirhasan[P]ups-indel/include/seqan/file/string_mmap.h
// Function: void seqan::cancel<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 void 
	cancel(String<TValue, MMap<TConfig> > &me)
	{
        typedef typename Size<typename TConfig::TFile>::Type TFileSize;
        cancelFileSegment(
            me.mapping,
            me.data_begin,
            0,
            (TFileSize)capacity(me) * (TFileSize)sizeof(TValue));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe9d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, %rcx
shlq $0x0, %rcx
xorl %edx, %edx
callq 0x13f60
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf140
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
je 0x13f0c
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0xf170
movq -0x8(%rbp), %rax
testb $0x1, 0x1c(%rax)
je 0x13f3d
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x13fa0
andb $0x1, %al
movzbl %al, %ecx
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe290
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe290
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x14070
andb $0x1, %al
movb %al, -0x15(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x1c(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x1d(%rax)
testb $0x1, -0x15(%rbp)
je 0x14028
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x120a0
movq %rax, -0x20(%rbp)
jmp 0x14030
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x14030
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0xf1f0
andb $0x1, %al
movzbl %al, %ecx
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq