LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mshabbirhasan[P]ups-indel/src/ups_indel.cpp
// Function: getRightCircularPermutation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
string getRightCircularPermutation(string * str) {
    string s(1, str -> at(str -> length() - 1));
    string s2 = str -> substr(0, str -> length() - 1);

    s += s2;

    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq 0x8(%rsi), %rsi
subq $0x1, %rsi
jb 0x3eba
movq %rdi, %rbx
movq (%r14), %rax
movsbl (%rax,%rsi), %edx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movl $0x1, %esi
callq 0x33b0
movq 0x8(%r14), %rcx
decq %rcx
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3360
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x30f0
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3eac
callq 0x32f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd810(%rip), %rdi      # 0x116d1
xorl %edx, %edx
xorl %eax, %eax
callq 0x34b0
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ee4
callq 0x32f0
jmp 0x3ee4
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3ef1
callq 0x32f0
movq %r14, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O3/mshabbirhasan[P]ups-indel/src/ups_indel.cpp
// Function: cleanup()
int cleanup() {
    string remove_temp_vcf_files_command =
        "rm " + input_file_base_name + ".*.vcf";

	if (system(remove_temp_vcf_files_command.c_str()) < 0)
		return 1;

    string remove_temp_uvcf_files_command =
        "rm " + output_file_name + ".*.uvcf";

	if (system(remove_temp_uvcf_files_command.c_str()) < 0)
		return 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
leaq 0x8fd3(%rip), %rsi      # 0x111ea
leaq 0xe1a2(%rip), %rdx      # 0x163c0
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x8ba6
leaq 0x8fbd(%rip), %rsi      # 0x111ee
movq %rbx, %rdi
callq 0x3640
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdi
je 0x825d
movq %rdi, -0x58(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x48(%rbp)
jmp 0x8267
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq %r14, %rdi
movq 0x8(%rax), %rdx
movq %rdx, -0x50(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x28(%rbp), %r15
movq -0x10(%r15), %rax
cmpq %r15, %rax
je 0x8297
movq %rax, %rdi
callq 0x32f0
movq -0x58(%rbp), %rdi
callq 0x32c0
testl %eax, %eax
js 0x82e7
leaq 0x8f43(%rip), %rsi      # 0x111ea
leaq 0xe132(%rip), %rdx      # 0x163e0
leaq -0x78(%rbp), %rdi
callq 0x8ba6
leaq 0x8f37(%rip), %rsi      # 0x111f5
leaq -0x78(%rbp), %rdi
callq 0x3640
movq %r15, -0x38(%rbp)
movq (%rax), %rdi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdi
je 0x82ee
movq %rdi, -0x38(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x28(%rbp)
jmp 0x82f8
movl $0x1, %ebx
jmp 0x8340
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %r15, %rdi
movq 0x8(%rax), %rdx
movq %rdx, -0x30(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x68(%rbp), %rcx
movq -0x10(%rcx), %rax
cmpq %rcx, %rax
je 0x8328
movq %rax, %rdi
callq 0x32f0
movq -0x38(%rbp), %rdi
callq 0x32c0
movl %eax, %ebx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x833d
callq 0x32f0
shrl $0x1f, %ebx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x834e
callq 0x32f0
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
jne 0x8379
jmp 0x8385
movq %rax, %rbx
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8385
callq 0x32f0
jmp 0x8385
jmp 0x8382
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x8393
callq 0x32f0
movq %rbx, %rdi
callq 0x35b0
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x838e
jmp 0x8393
// File: /workspace/github_cpp_makefile_star2_O3/mshabbirhasan[P]ups-indel/include/seqan/basic/debug_test_system.h
// Function: seqan::ClassTest::forceFail(char const*, int, char const*, ...)
inline void forceFail(const char * file, int line,
                      const char * comment, ...)
{
    StaticData::errorCount() += 1;
    std::cerr << file << ":" << line << " FAILED! ";
    if (comment)
    {
        std::cerr << " (";
        va_list args;
        va_start(args, comment);
        vfprintf(stderr, comment, args);
        va_end(args);
        std::cerr << ")";
    }
    std::cerr << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %rbx
movl %esi, %r15d
testb %al, %al
je 0x8cd8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %rcx, -0xc8(%rbp)
movq %r8, -0xc0(%rbp)
movq %r9, -0xb8(%rbp)
incl 0xd70d(%rip)            # 0x16400
testq %rdi, %rdi
je 0x8d14
movq %rdi, %r14
callq 0x3170
movq 0xd2e9(%rip), %rdi      # 0x15ff0
movq %r14, %rsi
movq %rax, %rdx
callq 0x33a0
jmp 0x8d32
movq 0xd2d5(%rip), %rax      # 0x15ff0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x3560
movq 0xd2b7(%rip), %r14      # 0x15ff0
leaq 0x857c(%rip), %rsi      # 0x112bc
movl $0x1, %edx
movq %r14, %rdi
callq 0x33a0
movq %r14, %rdi
movl %r15d, %esi
callq 0x3570
leaq 0x855f(%rip), %rsi      # 0x112be
movl $0x9, %edx
movq %rax, %rdi
callq 0x33a0
testq %rbx, %rbx
jne 0x8da6
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
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xd243(%rip), %r15      # 0x15ff0
leaq 0x8645(%rip), %rsi      # 0x113f9
movl $0x2, %edx
movq %r15, %rdi
callq 0x33a0
leaq -0xe0(%rbp), %rax
leaq -0x30(%rbp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rdx)
movq 0xd1e4(%rip), %rax      # 0x15fd0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x3440
leaq 0x8746(%rip), %rsi      # 0x11544
movl $0x1, %edx
movq %r15, %rdi
callq 0x33a0
jmp 0x8d71
// File: /workspace/github_cpp_makefile_star2_O3/mshabbirhasan[P]ups-indel/include/seqan/system/file_async.h
// Function: seqan::File<seqan::Async<void>>::close()
bool close() {
			bool result = true;
			if (handleAsync != handle && handleAsync != -1)
	            result &= (::close(handleAsync) == 0);
            result &= (::close(handle) == 0);
            handleAsync = -1;
            handle = -1;
			SEQAN_PROSUB(SEQAN_PROOPENFILES, 1);
            return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %edi
movl 0xc(%rbx), %eax
cmpl %edi, %eax
sete %cl
cmpl $-0x1, %eax
sete %dl
orb %cl, %dl
movb $0x1, %r14b
jne 0xa4ba
movl %eax, %edi
callq 0x3660
testl %eax, %eax
sete %r14b
movl 0x8(%rbx), %edi
callq 0x3660
testl %eax, %eax
sete %al
andb %r14b, %al
movq $-0x1, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa57e
cmpl $-0x1, 0x20(%r14)
jne 0xa52f
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 0xa644
movl %r15d, 0x28(%r14)
movw $0x101, 0x2c(%r14)      # imm = 0x101
testb %al, %al
je 0xa5ee
leaq 0x10(%r14), %r15
movq 0x10(%r14), %rdx
cmpq %rbx, %rdx
jae 0xa552
movl 0x20(%r14), %edi
movq %rbx, %rsi
callq 0x3460
testl %eax, %eax
jne 0xa5b6
movq %rbx, (%r15)
movq %rbx, %rdx
xorl %r12d, %r12d
movq %r15, %rdi
xorl %esi, %esi
movl $0x3, %ecx
callq 0xb816
movq %rax, (%r14)
testq %rax, %rax
je 0xa5a4
movl 0x30(%r14), %edx
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x33d0
jmp 0xa59c
cmpq $0x0, 0x10(%r14)
je 0xa59c
movl 0x20(%r14), %edi
xorl %esi, %esi
callq 0x3460
testl %eax, %eax
jne 0xa60d
movq $0x0, 0x10(%r14)
addq (%r14), %rbx
movb $0x1, %r12b
jmp 0xa5a6
xorl %ebx, %ebx
movq %rbx, 0x8(%r14)
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x20(%r14), %r14d
callq 0x3050
movl (%rax), %edi
callq 0x3130
leaq 0x6e33(%rip), %rdi      # 0x11400
leaq 0x6e4e(%rip), %rdx      # 0x11422
movl $0x440, %esi            # imm = 0x440
movl %r14d, %ecx
movq %rbx, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x8c95
callq 0x31e0
leaq 0x6e90(%rip), %rdi      # 0x11485
leaq 0x6eaa(%rip), %rdx      # 0x114a6
movl $0x295, %esi            # imm = 0x295
xorl %eax, %eax
callq 0x8c95
callq 0x31e0
movl 0x20(%r14), %ebx
callq 0x3050
movl (%rax), %edi
callq 0x3130
leaq 0x6ddc(%rip), %rdi      # 0x11400
leaq 0x6df7(%rip), %rdx      # 0x11422
movl $0x440, %esi            # imm = 0x440
movl %ebx, %ecx
xorl %r8d, %r8d
movq %rax, %r9
xorl %eax, %eax
callq 0x8c95
callq 0x31e0
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rdi, %r15
movq 0x8(%rsi), %rbx
movq 0x8(%rdi), %rax
testq %rbx, %rbx
jne 0xff0b
cmpq (%r15), %rax
je 0xffc9
movq (%r14), %rcx
addq %rbx, %rcx
testq %rbx, %rbx
cmoveq %rbx, %rcx
testq %rcx, %rcx
setne %dl
cmpq %rcx, %rax
sete %al
testb %al, %dl
je 0xff59
cmpq %r14, %r15
je 0xffc9
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xffec
movq %r15, %rdi
movq %r12, %rsi
callq 0xad82
movq -0x40(%rbp), %rdi
callq 0x32f0
jmp 0xffc9
movq (%r15), %r12
cmpq %rbx, 0x10(%r15)
jae 0xff9b
movq %rbx, %rax
shrq %rax
addq %rbx, %rax
cmpq $0x20, %rbx
movl $0x20, %r13d
cmovaeq %rax, %r13
leaq 0x1(%r13), %rdi
callq 0x3340
movq %rax, (%r15)
movq %r13, 0x10(%r15)
testq %r12, %r12
je 0xffaa
movq %r12, %rdi
callq 0x32f0
movq (%r15), %r12
jmp 0xffad
leaq (%r12,%rbx), %rax
movq %rax, 0x8(%r15)
testq %rbx, %rbx
jne 0xffb5
jmp 0xffc9
movq %rax, %r12
leaq (%r12,%rbx), %rax
movq %rax, 0x8(%r15)
movq (%r14), %rax
xorl %ecx, %ecx
movb (%rax,%rcx), %dl
movb %dl, (%r12,%rcx)
incq %rcx
cmpq %rcx, %rbx
jne 0xffba
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_O3/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, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %r12
movq (%rsi), %rax
addq %r12, %rax
testq %r12, %r12
cmoveq %r12, %rax
testq %rax, %rax
je 0x100c8
cmpq %rax, 0x8(%r14)
jne 0x100c8
cmpq %rbx, %r14
je 0x10146
cmpq %rdx, %r12
cmovbq %r12, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xffec
movq %r14, %rdi
movq %r15, %rsi
callq 0xad82
movq -0x40(%rbp), %rdi
callq 0x32f0
jmp 0x10146
cmpq %r12, %rdx
cmovbq %rdx, %r12
movq (%r14), %r15
cmpq %r12, 0x10(%r14)
jae 0x10118
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
callq 0x3340
movq %rax, (%r14)
movq %r13, 0x10(%r14)
testq %r15, %r15
je 0x10127
movq %r15, %rdi
callq 0x32f0
movq (%r14), %r15
jmp 0x1012a
leaq (%r15,%r12), %rax
movq %rax, 0x8(%r14)
testq %r12, %r12
jne 0x10132
jmp 0x10146
movq %rax, %r15
leaq (%r15,%r12), %rax
movq %rax, 0x8(%r14)
movq (%rbx), %rax
xorl %ecx, %ecx
movb (%rax,%rcx), %dl
movb %dl, (%r15,%rcx)
incq %rcx
cmpq %rcx, %r12
jne 0x10137
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_O3/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r12
movq %r12, %rdi
callq 0x3170
leaq (%r12,%rax), %rcx
testq %r12, %r12
setne %dl
movq 0x8(%rbx), %r15
cmpq %rcx, %r15
sete %cl
testb %cl, %dl
je 0xb326
movq %r12, %rdi
callq 0x3170
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb12c
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb4e8
movq -0x38(%rbp), %rdi
callq 0x32f0
jmp 0xb35c
subq (%rbx), %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r15, %rcx
callq 0xb37e
testq %rax, %rax
je 0xb35c
addq (%rbx), %r15
movq (%r14), %rsi
movq %r15, %rdi
movq %rax, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3530
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
callq 0x32f0
movq %rbx, %rdi
callq 0x35b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbcd8
movq %rax, %rbx
testl %r15d, %r15d
setne %al
cmpq %r14, %rbx
sete %cl
orb %al, %cl
jne 0xbcca
movq 0xa3bc(%rip), %r15      # 0x15ff0
leaq 0x59a5(%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 0x597b(%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
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbdb4
movq 0xa2f3(%rip), %r14      # 0x15ff0
leaq 0x58db(%rip), %rsi      # 0x115df
movl $0xf, %edx
movq %r14, %rdi
callq 0x33a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3300
movq %rax, %r14
leaq 0x56d2(%rip), %rsi      # 0x113f8
movl $0x3, %edx
movq %rax, %rdi
callq 0x33a0
callq 0x3050
movl (%rax), %edi
callq 0x3130
testq %rax, %rax
je 0xbd5f
movq %rax, %r15
movq %rax, %rdi
callq 0x3170
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x33a0
jmp 0xbd79
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x3560
leaq 0x57c4(%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_O3/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 0xcab3
movq (%r14), %rdi
callq 0x32f0
addq $0x30, %r14
cmpq %r15, %r14
jne 0xca9e
movq 0x30(%rbx), %r14
movq %r14, 0x38(%rbx)
movq 0x48(%rbx), %r14
movq 0x50(%rbx), %r15
cmpq %r15, %r14
je 0xcad9
movq (%r14), %rdi
callq 0x32f0
addq $0x18, %r14
cmpq %r15, %r14
jne 0xcac4
movq 0x48(%rbx), %r14
movq %r14, 0x50(%rbx)
movq 0x60(%rbx), %r14
movq 0x68(%rbx), %r13
movq %r13, %r15
subq %r14, %r15
movl $0x1, %r12d
cmpq $0x8, %r15
ja 0xcb49
cmpq $0x0, 0x70(%rbx)
jne 0xcb49
movl $0x8, %edi
callq 0x3340
movq %rax, 0x60(%rbx)
movq $0x1, 0x70(%rbx)
testq %r14, %r14
je 0xcb46
cmpq %r14, %r13
je 0xcb2c
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3530
movq %r14, %rdi
callq 0x32f0
movq 0x60(%rbx), %r14
xorl %r12d, %r12d
cmpq $0x0, 0x70(%rbx)
setne %r12b
jmp 0xcb49
movq %rax, %r14
leaq (%r14,%r12,8), %rax
movq %rax, 0x68(%rbx)
movb $0x1, 0x78(%rbx)
leaq 0x88(%rbx), %r14
movq %r14, %rdi
callq 0xdb06
movq 0xc0(%rbx), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0xcbba
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 0x9c34
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 0xcb8a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xcc6d
movq %rdi, %rbx
movq (%rdi), %r12
movq 0x8(%rdi), %r14
cmpb $0x1, 0x2d(%rdi)
movq %r12, %r15
jne 0xcc08
movq 0x10(%rbx), %rsi
movq %r12, %rdi
movl $0x2, %edx
callq 0x3070
movq (%rbx), %r15
testq %r15, %r15
je 0xcc27
movq 0x10(%rbx), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x31f0
testl %eax, %eax
jne 0xcc7e
movq $0x0, (%rbx)
subq %r12, %r14
movq $0x0, 0x8(%rbx)
cmpq %r14, 0x10(%rbx)
je 0xcc47
movl 0x20(%rbx), %edi
movq %r14, %rsi
callq 0x3460
testl %eax, %eax
jne 0xccb2
cmpb $0x1, 0x2c(%rbx)
jne 0xcc58
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 0x47ad(%rip), %rdi      # 0x1143e
leaq 0x47c8(%rip), %rdx      # 0x11460
movl $0x35c, %esi            # imm = 0x35C
movq %r15, %rcx
movq %r13, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x8c95
callq 0x31e0
movl 0x20(%rbx), %ebx
callq 0x3050
movl (%rax), %edi
callq 0x3130
leaq 0x4738(%rip), %rdi      # 0x11400
leaq 0x4753(%rip), %rdx      # 0x11422
movl $0x440, %esi            # imm = 0x440
movl %ebx, %ecx
movq %r14, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x8c95
callq 0x31e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x28(%rdi), %rcx
movq 0x30(%rdi), %rax
cmpq %rax, %rcx
je 0xcee2
cmpq %rax, %rcx
leaq -0x21(%rbp), %rdx
setne (%rdx)
leaq 0x4762(%rip), %rdi      # 0x11603
leaq 0x4787(%rip), %rcx      # 0x1162f
movl $0x108, %esi            # imm = 0x108
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xb61f
testb %al, %al
je 0xcf86
movq 0x28(%rbx), %rax
movl $0x1, %r15d
cmpb %r14b, (%rax)
jne 0xcf66
movq %rbx, %rdi
callq 0xd2e4
xorl %r15d, %r15d
jmp 0xcf66
movq (%rbx), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x20(%rdi,%rax), %eax
andl $0x2, %eax
movl $0x400, %r15d           # imm = 0x400
orl 0x38(%rbx), %eax
jne 0xcf66
testq %rcx, %rcx
je 0xcf09
cmpb $0x0, 0x3c(%rbx)
jne 0xcf66
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 0xcf76
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 0xcf76
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
movq 0x28(%rbx), %rcx
addq %rcx, %rax
movq %rax, 0x30(%rbx)
jmp 0xce90
callq 0x31e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd7f8
testl %eax, %eax
jne 0xd049
movq 0x28(%rbx), %rcx
cmpq 0x30(%rbx), %rcx
je 0xcfc9
movq %rbx, %rdi
callq 0xd2e4
movl 0x38(%rbx), %eax
jmp 0xd049
movq (%rbx), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x20(%rdi,%rax), %edx
andl $0x2, %edx
movl 0x38(%rbx), %eax
orl %eax, %edx
jne 0xd049
testq %rcx, %rcx
je 0xcfee
xorl %eax, %eax
cmpb $0x0, 0x3c(%rbx)
jne 0xd049
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 0xd052
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 0xd052
movq 0x28(%rbx), %rcx
movq %rcx, 0x30(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
addq 0x28(%rbx), %rcx
movq %rcx, 0x30(%rbx)
jmp 0xcfb9
// File: /workspace/github_cpp_makefile_star2_O3/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 0x42fb(%rip), %rdi      # 0x11603
leaq 0x4320(%rip), %rcx      # 0x1162f
movl $0xf5, %esi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xb61f
testb %al, %al
je 0xd3c2
movq 0x28(%rbx), %rax
incq %rax
movq %rax, 0x28(%rbx)
cmpq 0x30(%rbx), %rax
je 0xd33b
xorl %eax, %eax
jmp 0xd3b9
movb $0x1, %al
cmpb $0x0, 0x3c(%rbx)
jne 0xd3b9
movq (%rbx), %rdi
movq (%rdi), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%rdi,%rcx)
jne 0xd3b9
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 0xd3af
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 0xd3af
movq 0x28(%rbx), %rcx
movb $0x1, %al
jmp 0xd3b5
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_O3/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 0x10(%rsi), %rdx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, %rsi
subq %rax, %rsi
movq %rsi, %rdi
shrq %rdi
addq %rsi, %rdi
cmpq $0x20, %rsi
movl $0x20, %r15d
cmovaeq %rdi, %r15
cmpq %rdx, %r15
cmovaeq %rdx, %r15
testq %r15, %r15
je 0xd703
leaq 0x1(%r15), %rdi
callq 0x3340
movq %rax, (%rbx)
movq %r15, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x8(%rbx), %r15
cmpq %rax, %rcx
je 0xd717
movq %rbx, %rdi
movq %r14, %rsi
callq 0xad82
leaq 0x3be4(%rip), %rax      # 0x11302
movq %rax, (%rsp)
leaq 0x3b9f(%rip), %rdi      # 0x112c8
leaq 0x3bbe(%rip), %rcx      # 0x112ee
leaq 0x3bc2(%rip), %r9       # 0x112f9
movl $0x86, %esi
movq %rbx, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x90eb
testb %al, %al
je 0xd758
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x31e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3df0(%rip), %r12      # 0x11603
leaq 0x3e15(%rip), %r13      # 0x1162f
movl %edx, -0x30(%rbp)
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rax
cmpq %rax, %rcx
jne 0xd8d0
movq (%rbx), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x20(%rdi,%rax), %eax
andl $0x2, %eax
movl $0x400, %r15d           # imm = 0x400
orl 0x38(%rbx), %eax
jne 0xd91d
testq %rcx, %rcx
je 0xd85d
cmpb $0x0, 0x3c(%rbx)
jne 0xd91d
movq %r13, %r14
movq %r12, %r13
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 0xd8bb
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 0xd92f
movq 0x28(%rbx), %rcx
addq %rcx, %rax
movq %rax, 0x30(%rbx)
movq %r13, %r12
movq %r14, %r13
movl -0x30(%rbp), %r14d
cmpq %rax, %rcx
setne -0x29(%rbp)
movq %r12, %rdi
movl $0x108, %esi            # imm = 0x108
leaq -0x29(%rbp), %rdx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xb61f
testb %al, %al
je 0xd939
movq 0x28(%rbx), %rax
cmpb $0xa, (%rax)
setne %al
xorb %r14b, %al
jne 0xd91a
movq %rbx, %rdi
callq 0xd2e4
movl 0x38(%rbx), %r15d
testl %r15d, %r15d
je 0xd81d
jmp 0xd91d
xorl %r15d, %r15d
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 0xd91d
callq 0x31e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe599
leaq 0x2000(%rcx), %rax
movq %rax, 0x10(%rbx)
movq %rcx, -0x58(%rbp)
movq 0x8(%rbx), %r13
movq 0x10(%rbx), %r15
cmpq %r15, %r13
je 0xe68b
leaq -0x88(%rbp), %rdi
callq 0x8e1e
leaq -0x70(%rbp), %rdi
callq 0x8e1e
leaq -0x48(%rbp), %rdi
callq 0x8e1e
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 0xe61a
leaq 0x1(%r14), %rdi
callq 0x3340
movq %rax, -0x48(%rbp)
movq %r14, -0x38(%rbp)
testq %r12, %r12
je 0xe616
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 0xe6f8
movl %eax, %r12d
testl %eax, %eax
jne 0xe663
movl -0x68(%rbp), %edx
subl -0x70(%rbp), %edx
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
leaq -0x88(%rbp), %rcx
leaq -0x29(%rbp), %r8
callq 0xe7f0
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 0xe59d
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 0xe6d4
movq %rax, %r14
jmp 0xe6e0
movq %rax, %r14
jmp 0xe6cb
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_O3/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 0xe7d9
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
leaq -0x29(%rbp), %rdx
movb $0x1, (%rdx)
leaq 0x2f26(%rip), %rdi      # 0x1165a
leaq 0x2ef4(%rip), %rcx      # 0x1162f
movl $0xca, %esi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xb61f
testb %al, %al
je 0xe7eb
movq 0x8(%r14), %rax
cmpb $0x40, (%rax)
jne 0xe7d9
cmpq 0x10(%r14), %rax
leaq -0x2a(%rbp), %rdx
setne (%rdx)
leaq 0x2eed(%rip), %rdi      # 0x1165a
leaq 0x2ebb(%rip), %rcx      # 0x1162f
xorl %r12d, %r12d
movl $0xbd, %esi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xb61f
testb %al, %al
je 0xe7eb
movq 0x8(%r14), %rax
incq %rax
movq %rax, 0x8(%r14)
cmpq 0x10(%r14), %rax
je 0xe7d9
movq %r13, %rdi
movq %r14, %rsi
callq 0xe2f6
movl %eax, %r12d
testl %eax, %eax
jne 0xe7d9
movq 0x8(%r14), %rax
movl $0x0, %r12d
cmpq 0x10(%r14), %rax
je 0xe7d9
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe982
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_O3/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 0xef14
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 0xef85
movq %r13, %rdi
callq 0x8e1e
movq %r15, %rdi
callq 0x8e1e
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 0xefe9
movl %eax, %r13d
movq -0x60(%rbp), %rdi
callq 0x32f0
movq -0x78(%rbp), %rdi
callq 0x32f0
cmpl $0x1, %r13d
movq %rbx, %r13
jne 0xef20
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 0xefcd
movq %rax, %r14
movq -0x60(%rbp), %rdi
callq 0x32f0
jmp 0xefc4
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_O3/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 0xf5ff
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 0x1eb9(%rip), %rax      # 0x113a9
movq %rax, (%rsp)
leaq 0x1e48(%rip), %rdi      # 0x11343
movl $0x1fd, %esi            # imm = 0x1FD
movq %r13, %rdx
leaq 0x1e5e(%rip), %rcx      # 0x11368
leaq -0x38(%rbp), %r8
leaq 0x1e70(%rip), %r9       # 0x11385
xorl %eax, %eax
callq 0xa00e
testb %al, %al
je 0xf65e
leaq (%r14,%r14,2), %r14
shlq $0x4, %r14
addq 0x30(%rbx), %r14
movq %r12, %rdi
movq %r14, %rsi
leaq 0x1d0b(%rip), %rdx      # 0x11248
callq 0xf67a
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 0xf4e1
leaq -0x230(%rbp), %rdi
movq -0x8(%rdi), %rax
movq -0x18(%rax), %rax
xorl %ebx, %ebx
cmpl $0x0, -0x218(%rbp,%rax)
setne %bl
movq 0x69a6(%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_O3/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 0xdc73(%rip), %r12      # 0x10fa8
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_O3/shisharka[P]interactive_deduction/interactive_deduction.tab.cpp
// Function: yy_symbol_print(_IO_FILE*, yysymbol_kind_t, YYSTYPE const*, std::shared_ptr<BaseFormula>&)
static void
yy_symbol_print (FILE *yyo,
                 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, Formula & formula)
{
  YYFPRINTF (yyo, "%s %s (",
             yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));

  yy_symbol_value_print (yyo, yykind, yyvaluep, formula);
  YYFPRINTF (yyo, ")");
}

// Assembly:
pushq %rbx
cmpl $0xf, %esi
leaq 0x7700(%rip), %rax      # 0xb701
leaq 0x7688(%rip), %rdx      # 0xb690
cmovlq %rax, %rdx
movq %rdi, %rbx
movslq %esi, %rax
leaq 0xc5c7(%rip), %rcx      # 0x105e0
movq (%rcx,%rax,8), %rcx
leaq 0x7664(%rip), %rsi      # 0xb688
xorl %eax, %eax
callq 0x3210
movl $0x29, %edi
movq %rbx, %rsi
popq %rbx
jmp 0x31e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7e9b
movq (%r14), %rax
movq 0x20(%rax), %rdx
cmpq 0x20(%rbx), %rdx
jne 0x7e9b
testq %rdx, %rdx
je 0x7ea5
movq 0x18(%rbx), %rsi
movq 0x18(%rax), %rdi
callq 0x3190
testl %eax, %eax
sete %al
jmp 0x7e9d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x1, %al
jmp 0x7e9d
nop