LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/src/memcache/replication.cpp
// Function: yrmcds::memcache::repl_object(std::vector<yrmcds::memcache::repl_socket*, std::allocator<yrmcds::memcache::repl_socket*>> const&, cybozu::hash_key const&, yrmcds::memcache::object const&, bool)
void repl_object(const std::vector<repl_socket*>& slaves,
                 const cybozu::hash_key& key, const object& obj,
                 bool flush) {
    char header[BINARY_HEADER_SIZE];
    fill_header(header, key.length(), 8, obj.size(), binary_command::SetQ);
    char extras[8];
    cybozu::hton(obj.flags(), extras);
    cybozu::hton(obj.exptime(), &extras[4]);
    cybozu::dynbuf buf(0);
    const cybozu::dynbuf& data = obj.data(buf);
    cybozu::tcp_socket::iovec iov[4] = {
        {header, sizeof(header)},
        {extras, sizeof(extras)},
        {key.data(), key.length()},
        {data.data(), data.size()}
    };
    for( cybozu::tcp_socket* s: slaves )
        s->sendv(iov, 4, flush);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %rbx
movq 0x20(%rsi), %rax
movq 0x30(%rdx), %rsi
leaq 0x28(%rdx), %r8
leaq 0x8(%rsi), %r9
testq %rsi, %rsi
cmoveq %r8, %r9
movl (%r9), %esi
xorps %xmm0, %xmm0
movups %xmm0, 0x15(%rsp)
andl $0x0, 0x24(%rsp)
movl %ecx, %ebp
movq %rdi, %r14
movw $0x1180, 0x10(%rsp)     # imm = 0x1180
movzwl %ax, %ecx
rolw $0x8, %ax
movw %ax, 0x12(%rsp)
movb $0x8, 0x14(%rsp)
leal (%rcx,%rsi), %eax
addl $0x8, %eax
bswapl %eax
movl %eax, 0x18(%rsp)
movl 0x38(%rdx), %eax
bswapl %eax
movl %eax, 0x8(%rsp)
movl 0x40(%rdx), %eax
leaq 0x30(%rsp), %rsi
andq $0x0, 0x20(%rsi)
bswapl %eax
movl %eax, 0xc(%rsp)
movaps %xmm0, (%rsi)
movups %xmm0, 0x9(%rsi)
movq %rdx, %rdi
callq 0x1b386
leaq 0x10(%rsp), %rcx
leaq 0x60(%rsp), %r15
movq %rcx, (%r15)
movq $0x18, 0x8(%r15)
leaq 0x8(%rsp), %rcx
movq %rcx, 0x10(%r15)
movq $0x8, 0x18(%r15)
movq 0x18(%rbx), %rcx
movq %rcx, 0x20(%r15)
movq 0x20(%rbx), %rcx
movq %rcx, 0x28(%r15)
movq (%rax), %rcx
movq %rcx, 0x30(%r15)
movq 0x20(%rax), %rax
movq %rax, 0x38(%r15)
movq (%r14), %r12
movq 0x8(%r14), %r14
movzbl %bpl, %ebx
pushq $0x4
popq %rbp
cmpq %r14, %r12
je 0x252a7
movq (%r12), %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x1e020
addq $0x8, %r12
jmp 0x2528c
leaq 0x30(%rsp), %rdi
callq 0x8dac
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x252c3
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8dac
movq %rbx, %rdi
callq 0x7990
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/./cybozu/hash_map.hpp
// Function: cybozu::hash_map<yrmcds::memcache::object>::bucket::remove_nolock(cybozu::hash_key const&, std::function<void (cybozu::hash_key const&)> const&)
bool remove_nolock(const hash_key& key,
                           const std::function<void(const hash_key&)>& callback) {
            for( item** p = &m_objects; *p != nullptr; p = &((*p)->next) ) {
                if( (*p)->key == key ) {
                    item* to_delete = *p;
                    *p = to_delete->next;
                    delete to_delete;
                    if( callback ) callback(key);
                    return true;
                }
            }
            return false;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
addq $0x28, %rdi
movq (%rdi), %r15
testq %r15, %r15
je 0x25ace
movq %rdi, %r13
movq %r15, %rdi
movq %rbx, %rsi
callq 0x13638
movq (%r13), %r12
leaq 0x90(%r12), %rdi
testb %al, %al
je 0x25a75
movq 0x90(%r12), %rax
movq %rax, (%r13)
movq %r12, %rdi
callq 0x160c8
movl $0x98, %esi
movq %r12, %rdi
callq 0x7520
cmpq $0x0, 0x10(%r14)
je 0x25ace
movq %r14, %rdi
movq %rbx, %rsi
callq 0x25ade
testq %r15, %r15
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/./debug_rep.h
// Function: debug_rep(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string debug_rep(const std::string& s)
{
#ifdef DEBUG
	std::cout << "const string &" << "\t";
#endif
	return '"' + s + '"';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x3b38(%rip), %rdi      # 0x5fd0
leaq 0x1b65(%rip), %rsi      # 0x4004
callq 0x2120
leaq 0x1b68(%rip), %rsi      # 0x4013
movq %rax, %rdi
callq 0x2120
leaq -0x40(%rbp), %r15
pushq $0x22
popq %r12
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x2812
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x27e6
leaq -0x40(%rbp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_56.cc
// Function: main
int main(int argc, char const *argv[])
{
	Sales_data item("978-0590353403", 25, 15.99);
	string fcnName("itemProcess");
	ErrorCode code(42);
	string otherData("invalid ISBN");

	errorMsg(cerr, fcnName, code.num(), otherData, "other", item);
	cerr << endl;

	print(cerr, debug_rep(fcnName), debug_rep(code.num()),
				debug_rep(otherData), debug_rep("otherData"),
				debug_rep(item));
	cerr << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
leaq 0x1a73(%rip), %rsi      # 0x402e
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x2080
leaq -0x98(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x21b0
movl $0x19, -0x78(%rbp)
movabsq $0x4078fc0000000000, %rax # imm = 0x4078FC0000000000
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20a0
leaq 0x1a40(%rip), %rsi      # 0x403d
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x2080
leaq 0x1a38(%rip), %rsi      # 0x4049
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x2080
leaq -0x68(%rbp), %rdx
movq $0x2a, (%rdx)
movq 0x39c0(%rip), %rdi      # 0x5ff0
leaq 0x1a1f(%rip), %r8       # 0x4056
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rcx
leaq -0x98(%rbp), %r9
callq 0x291e
movq 0x399e(%rip), %rdi      # 0x5ff0
callq 0x20b0
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x247c
leaq -0x100(%rbp), %rsi
movq $0x2a, (%rsi)
leaq -0x120(%rbp), %rdi
callq 0x2a9e
leaq -0xf8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x247c
leaq 0x19c7(%rip), %rsi      # 0x405c
leaq -0xd8(%rbp), %rdi
callq 0x2556
leaq -0xb8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x2b33
movq 0x3935(%rip), %rdi      # 0x5ff0
leaq -0x68(%rbp), %rsi
leaq -0x120(%rbp), %rdx
leaq -0xf8(%rbp), %rcx
leaq -0xd8(%rbp), %r8
leaq -0xb8(%rbp), %r9
callq 0x2a4b
leaq -0xb8(%rbp), %rdi
callq 0x20a0
leaq -0xd8(%rbp), %rdi
callq 0x20a0
leaq -0xf8(%rbp), %rdi
callq 0x20a0
leaq -0x120(%rbp), %rdi
callq 0x20a0
leaq -0x68(%rbp), %rdi
callq 0x20a0
movq 0x38d0(%rip), %rdi      # 0x5ff0
callq 0x20b0
leaq -0x48(%rbp), %rdi
callq 0x20a0
leaq -0x28(%rbp), %rdi
callq 0x20a0
leaq -0x98(%rbp), %rdi
callq 0x20a0
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x20a0
jmp 0x2763
movq %rax, %rbx
leaq -0xd8(%rbp), %rdi
callq 0x20a0
jmp 0x2774
movq %rax, %rbx
leaq -0xf8(%rbp), %rdi
callq 0x20a0
jmp 0x2785
movq %rax, %rbx
leaq -0x120(%rbp), %rdi
callq 0x20a0
jmp 0x2796
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x20a0
jmp 0x27c0
jmp 0x27bd
jmp 0x27bd
movq %rax, %rbx
jmp 0x27c9
movq %rax, %rbx
jmp 0x27d2
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
jmp 0x27d9
movq %rax, %rbx
jmp 0x27de
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20a0
leaq -0x28(%rbp), %rdi
callq 0x20a0
leaq -0x98(%rbp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/Sales_data.cc
// Function: operator>>(std::istream&, Sales_data&)
istream& operator>>(istream& is, Sales_data& item)
{
	double price;  // no need to initialize; we'll read into price before we use it
	is >> item.bookNo >> item.units_sold >> price;
	if (is)        // check that the inputs succeeded
		item.revenue = item.units_sold * price;
	else
		item = Sales_data(); // input failed: give the object the default state
	return is;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2180
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x2220
leaq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x20c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
je 0x3119
leaq -0x40(%rbp), %rax
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rax)
movupd %xmm0, (%rax)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
andl $0x0, 0x10(%rax)
leaq -0x50(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3424
movq %r15, %rdi
callq 0x20a0
jmp 0x312d
movl 0x20(%r14), %eax
cvtsi2sd %rax, %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x28(%r14)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/Sales_data.cc
// Function: read(std::istream&, Sales_data&)
istream& read(istream &is, Sales_data &item)
{
	double price = 0;
	is >> item.bookNo >> item.units_sold >> price;
	item.revenue = price * item.units_sold;
	return is;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %r15
andq $0x0, (%r15)
callq 0x2180
leaq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0x2220
movq %rax, %rdi
movq %r15, %rsi
callq 0x20c0
movl 0x20(%rbx), %eax
cvtsi2sd %rax, %xmm0
mulsd (%r15), %xmm0
movsd %xmm0, 0x28(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/utility.h
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
vector<string> split(const string &s, char delim, vector<string> &elems) {
    stringstream ss(s);
    string item;
    while (getline(ss, item, delim)) {
        elems.push_back(item);
    }
    return elems;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rcx, %r14
movl %edx, %r12d
movq %rdi, %rbx
leaq -0x1d0(%rbp), %r15
pushq $0x18
popq %rdx
movq %r15, %rdi
callq 0x34e0
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movsbl %r12b, %r12d
leaq -0x48(%rbp), %r13
movq %r15, %rdi
movq %r13, %rsi
movl %r12d, %edx
callq 0x35e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3960
movq %r14, %rdi
movq %r13, %rsi
callq 0x6730
jmp 0x3937
movq %rbx, %rdi
movq %r14, %rsi
callq 0x676c
leaq -0x48(%rbp), %rdi
callq 0x3668
leaq -0x1d0(%rbp), %rdi
callq 0x3260
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3997
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3668
leaq -0x1d0(%rbp), %rdi
callq 0x3260
movq %rbx, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/src/ups_indel.cpp
// Function: isComplexVariant(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isComplexVariant(string r, string a){
    if(r.length() > 1 && a.length() > 1){
        if(r.at(1) != a.at(1)){
            return true;
        }
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x2, 0x8(%rdi)
jb 0x3c99
movq %rsi, %rbx
cmpq $0x2, 0x8(%rsi)
jb 0x3c99
pushq $0x1
popq %r14
movq %r14, %rsi
callq 0x3620
movb (%rax), %r15b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3620
movq %rax, %rcx
movb $0x1, %al
cmpb (%rcx), %r15b
jne 0x3c9b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/src/ups_indel.cpp
// Function: getLeftCircularPermutation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
string getLeftCircularPermutation(string * str) {
    string s = str -> substr(1, str -> length());
    string s2(1, str -> at(0));

    s += s2;

    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
pushq $0x1
popq %rdx
callq 0x3340
movq %r14, %rdi
xorl %esi, %esi
callq 0x3620
movsbl (%rax), %edx
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x30(%rbp), %rdi
pushq $0x1
popq %rsi
callq 0x3380
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x3640
leaq -0x30(%rbp), %rdi
callq 0x3668
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x3668
jmp 0x3d18
jmp 0x3d15
movq %rax, %r14
movq %rbx, %rdi
callq 0x3668
movq %r14, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
decq %rsi
movq %r14, %rdi
callq 0x3620
movsbl (%rax), %edx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3380
movq 0x8(%r14), %rcx
decq %rcx
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3340
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x3640
leaq -0x30(%rbp), %rdi
callq 0x3668
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x3668
jmp 0x3da4
movq %rax, %r14
movq %rbx, %rdi
callq 0x3668
movq %r14, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/src/ups_indel.cpp
// Function: executeUPSIndel(void*)
void * executeUPSIndel(void * threadIndex) {
    long chrNum;
    chrNum = (long) threadIndex;

    int flag = -999;
    string chr = "";

    if (chrNum >= 1 && chrNum <= 22) {
        chr = to_string(chrNum);
    } else if (chrNum == 23) {
        chr = "X";
    } else if (chrNum == 24) {
        chr = "Y";
    } else if (chrNum == 25) {
        chr = "MT";
    }

    string vcfFileName = input_file_base_name + "." + chr + ".vcf";

    if(fileExists(vcfFileName)){
        flag = genenateUPSCoordinate(reference_file_name,
        vcfFileName, output_file_name + "." + chr);

        if (flag) {
            exit(-1);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
leaq 0x7344(%rip), %rsi      # 0xd22c
leaq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x3150
testq %rbx, %rbx
setle %al
cmpq $0x17, %rbx
setge %cl
orb %al, %cl
jne 0x5f2c
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
callq 0x6c2e
leaq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rbx
movq %rbx, %rsi
callq 0x33e0
movq %rbx, %rdi
callq 0x3668
jmp 0x5f4d
addq $-0x17, %rbx
cmpq $0x3, %rbx
jae 0x5f4d
leaq 0x7b3b(%rip), %rax      # 0xda78
movslq (%rax,%rbx,4), %rsi
addq %rax, %rsi
leaq -0x68(%rbp), %rdi
callq 0x3610
leaq 0xe45c(%rip), %rsi      # 0x143b0
leaq 0x71e0(%rip), %rdx      # 0xd13b
leaq -0xe8(%rbp), %rdi
callq 0x6863
leaq -0x28(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x6cb7
leaq 0x7252(%rip), %rdx      # 0xd1d4
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6c8e
leaq -0x28(%rbp), %rdi
callq 0x3668
leaq -0xe8(%rbp), %rdi
callq 0x3668
leaq -0x48(%rbp), %rdi
callq 0x6ce0
leaq 0xe3bc(%rip), %rsi      # 0x14370
leaq -0xc8(%rbp), %rdi
callq 0x3440
leaq -0xa8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3440
leaq 0xe3f9(%rip), %rsi      # 0x143d0
leaq 0x715d(%rip), %rdx      # 0xd13b
leaq -0x28(%rbp), %rdi
callq 0x6863
leaq -0x88(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x6cb7
leaq -0xc8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x49fd
leaq -0x88(%rbp), %rdi
callq 0x3668
leaq -0x28(%rbp), %rdi
callq 0x3668
leaq -0xa8(%rbp), %rdi
callq 0x3668
leaq -0xc8(%rbp), %rdi
callq 0x3668
pushq $-0x1
popq %rdi
callq 0x33c0
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3668
jmp 0x605e
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x3668
jmp 0x606c
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x3668
jmp 0x607d
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x3668
jmp 0x608e
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
jmp 0x60ae
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x3668
jmp 0x60a7
jmp 0x60b7
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0x3668
jmp 0x60ba
jmp 0x60b7
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x3668
movq %rbx, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x68, %rsp
leaq 0x6dcc(%rip), %rsi      # 0xd1ce
leaq 0xdfa7(%rip), %rdx      # 0x143b0
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
callq 0x6bb8
leaq 0x6db6(%rip), %rdx      # 0xd1d2
leaq -0x68(%rbp), %rdi
movq %rbx, %rsi
callq 0x6c8e
leaq -0x28(%rbp), %rdi
callq 0x3668
movq -0x68(%rbp), %rdi
callq 0x32a0
testl %eax, %eax
js 0x648b
leaq 0x6d89(%rip), %rsi      # 0xd1ce
leaq 0xdf84(%rip), %rdx      # 0x143d0
leaq -0x48(%rbp), %rdi
callq 0x6bb8
leaq 0x6d7d(%rip), %rdx      # 0xd1d9
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6c8e
leaq -0x48(%rbp), %rdi
callq 0x3668
movq -0x28(%rbp), %rdi
callq 0x32a0
movl %eax, %ebx
shrl $0x1f, %ebx
leaq -0x28(%rbp), %rdi
callq 0x3668
jmp 0x648e
pushq $0x1
popq %rbx
leaq -0x68(%rbp), %rdi
callq 0x3668
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
jmp 0x64b0
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3668
jmp 0x64bc
jmp 0x64b9
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
jmp 0x64c9
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x3668
movq %rbx, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/src/ups_indel.cpp
// Function: fileExists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool fileExists (const string& fileName) {
    if (FILE *file = fopen(fileName.c_str(), "r")) {
        fclose(file);
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
leaq 0x6a27(%rip), %rsi      # 0xd717
callq 0x33a0
movq %rax, %rbx
testq %rax, %rax
je 0x6d05
movq %rbx, %rdi
callq 0x3320
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %rsi
testb %al, %al
je 0x6d56
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 0xd67f(%rip)            # 0x143f0
movq 0xd278(%rip), %rdi      # 0x13ff0
callq 0x3310
leaq 0x651c(%rip), %rsi      # 0xd2a0
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
movl %r14d, %esi
callq 0x3550
leaq 0x6504(%rip), %rsi      # 0xd2a2
movq %rax, %rdi
callq 0x3310
testq %rbx, %rbx
jne 0x6dc3
movq 0xd23e(%rip), %rdi      # 0x13ff0
callq 0x31a0
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0xd226(%rip), %r14      # 0x13ff0
leaq 0x660c(%rip), %rsi      # 0xd3dd
movq %r14, %rdi
callq 0x3310
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 0xd1cc(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x3430
leaq 0x6780(%rip), %rsi      # 0xd596
movq %r14, %rdi
callq 0x3310
jmp 0x6dab
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/basic/debug_test_system.h
// Function: bool seqan::ClassTest::testLeq<seqan::FaiIndexEntry_*, seqan::FaiIndexEntry_*>(char const*, int, seqan::FaiIndexEntry_* const&, char const*, seqan::FaiIndexEntry_* const&, char const*, char const*, ...)
bool testLeq(const char * file, int line,
             const T1 & value1, const char * expression1,
             const T2 & value2, const char * expression2,
             const char * comment, ...)
{
    if (!(value1 <= value2))
    {
        // Increase global error count.
        StaticData::thisTestOk() = false;
        StaticData::errorCount() += 1;
        // Print assertion failure text, with comment if any is given.
        std::cerr << file << ":" << line << " Assertion failed : "
                  << expression1 << " <= " << expression2 << " was: " << value1
                  << " > " << value2;
        if (comment)
        {
            std::cerr << " (";
            va_list args;
            va_start(args, comment);
            vfprintf(stderr, comment, args);
            va_end(args);
            std::cerr << ")";
        }
        std::cerr << std::endl;
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
testb %al, %al
je 0x726e
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 (%rdx), %rax
movq (%r8), %r12
cmpq %r12, %rax
jbe 0x7347
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %rsi
movq %rax, -0x38(%rbp)
movb $0x0, 0xd15e(%rip)      # 0x143f4
incl 0xd154(%rip)            # 0x143f0
movq 0xcd4d(%rip), %rdi      # 0x13ff0
movq %r9, -0x30(%rbp)
callq 0x3310
leaq 0x5fed(%rip), %rsi      # 0xd2a0
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
movl %ebx, %esi
callq 0x3550
leaq 0x6036(%rip), %rsi      # 0xd302
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
movq %r13, %rsi
callq 0x3310
leaq 0x6031(%rip), %rsi      # 0xd317
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x3310
leaq 0x601b(%rip), %rsi      # 0xd31c
movq %rax, %rdi
callq 0x3310
movq (%r15), %rsi
movq %rax, %rdi
callq 0x3270
leaq 0x6008(%rip), %rsi      # 0xd323
movq %rax, %rdi
callq 0x3310
movq (%r14), %rsi
movq 0x10(%rbp), %r14
movq %rax, %rdi
callq 0x3270
testq %r14, %r14
jne 0x735f
movq 0xccb2(%rip), %rdi      # 0x13ff0
callq 0x31a0
movq -0x38(%rbp), %rax
cmpq %r12, %rax
setbe %al
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xcc8a(%rip), %rbx      # 0x13ff0
leaq 0x6070(%rip), %rsi      # 0xd3dd
movq %rbx, %rdi
callq 0x3310
leaq -0x100(%rbp), %rax
leaq -0x50(%rbp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x18(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000030, %rax     # imm = 0x3000000030
movq %rax, (%rdx)
movq 0xcc30(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
movq %r14, %rsi
callq 0x3430
leaq 0x61e4(%rip), %rsi      # 0xd596
movq %rbx, %rdi
callq 0x3310
jmp 0x7337
nop
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/sequence/string_base.h
// Function: void seqan::AppendValueToString_<seqan::Tag<seqan::TagGenerous_>>::appendValue_<seqan::String<seqan::String<char, seqan::Alloc<void>>, seqan::Alloc<void>>, seqan::String<char, seqan::Alloc<void>> const>(seqan::String<seqan::String<char, seqan::Alloc<void>>, seqan::Alloc<void>>&, seqan::String<char, seqan::Alloc<void>> const&)
static inline void
    appendValue_(T & me,
                TValue & _value)
    {
        SEQAN_CHECKPOINT;
        typename Position<T>::Type me_length = length(me);
        if (capacity(me) <= me_length)
        {
            typename Value<T>::Type temp_copy(_value); //temp copy because resize could invalidate _value
            // TODO(holtgrew): The resize() function will default construct the last element. This is slow. Get rid of this.
            typename Size<T>::Type new_length = reserve(me, me_length + 1, TExpand());
            if (me_length < new_length)
            {
                // *(begin(me) + me_length) = temp_copy;
                valueConstruct(begin(me, Standard()) + me_length, temp_copy); //??? this should be valueMoveConstruct
                _setLength(me, me_length + 1);
            }
        }
        else
        {
            valueConstruct(begin(me, Standard()) + me_length, _value);
            _setLength(me, me_length + 1);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %r14
subq %rdi, %r14
pushq $0x18
popq %rcx
movq %r14, %rax
cqto
idivq %rcx
cmpq %rax, 0x10(%rbx)
jbe 0xaa5f
addq %r14, %rdi
callq 0xaac4
movq (%rbx), %rax
addq %r14, %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
jmp 0xaaa3
movq %rax, %r12
leaq -0x38(%rbp), %rdi
callq 0xaac4
leaq 0x1(%r12), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xab68
cmpq %rax, %r12
jae 0xaa9a
addq (%rbx), %r14
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0xaac4
imulq $0x18, %r15, %rax
addq (%rbx), %rax
movq %rax, 0x8(%rbx)
movq -0x38(%rbp), %rdi
callq 0x32e0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
callq 0x32e0
movq %rbx, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/sequence/string_base.h
// Function: void seqan::_reserveStorage<unsigned long, seqan::Alloc<void>, unsigned long, seqan::TagGenerous_>(seqan::String<unsigned long, seqan::Alloc<void>>&, unsigned long, seqan::Tag<seqan::TagGenerous_>)
inline void
_reserveStorage(
    String<TValue, TSpec> & seq,
    TSize_ new_capacity,
    Tag<TExpand> tag)
{
    typedef typename Size< String<TValue, TSpec> >::Type TSize;

    TSize old_capacity = capacity(seq);

//  if (old_capacity == (TSize)new_capacity) return;
//  if (!IsSameType<TExpand,TagExact_>::VALUE && old_capacity > (TSize)new_capacity) return;
    if (old_capacity >= (TSize)new_capacity) return;

    TSize seq_length = length(seq);
    typename Value< String<TValue, TSpec> >::Type * old_array = _reallocateStorage(seq, new_capacity, tag);
    if (old_array)
    {//buffer was replaced, destruct old buffer
//      arrayConstruct(begin(seq, Standard()), begin(seq, Standard()) + seq_length);
//      arrayMoveForward(old_array, old_array + seq_length, begin(seq, Standard()));
        arrayConstructCopy(old_array, old_array + seq_length, begin(seq, Standard()));
        arrayDestruct(old_array, old_array + seq_length);
        _deallocateStorage(seq, old_array, old_capacity);
    }
    _setLength(seq, seq_length);
}

// Assembly:
cmpq %rsi, 0x10(%rdi)
jae 0x78ba
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
movq 0x8(%rdi), %r13
movq %r13, %r14
subq %r12, %r14
callq 0x78bb
testq %rax, %rax
je 0x78a5
movq %rax, %r15
cmpq %r12, %r13
je 0x789d
movq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3510
movq %r15, %rdi
callq 0x32e0
addq (%rbx), %r14
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/sequence/string_alloc.h
// Function: seqan::Value<seqan::String<char, seqan::Alloc<void>>, 0>::Type* seqan::_allocateStorage<char, void, unsigned long>(seqan::String<char, seqan::Alloc<void>>&, unsigned long)
inline typename Value<String<TValue, Alloc<TSpec> > >::Type *
_allocateStorage(String<TValue, Alloc<TSpec> > & me,
                 TSize new_capacity)
{
    typename Size<String<TValue, Alloc<TSpec> > >::Type size = _computeSizeForCapacity(me, new_capacity);
    typename Value<String<TValue, Alloc<TSpec> > >::Type * _returnValue = me.data_begin;
    allocate(me, me.data_begin, size, TagAllocateStorage());
    me.data_capacity = new_capacity;
    return _returnValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rsi), %rdi
movq (%r14), %r15
callq 0x3330
movq %rax, (%r14)
movq %rbx, 0x10(%r14)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/basic/array_construct_destruct.h
// Function: void seqan::_arrayDestructDefault<seqan::String<char, seqan::Alloc<void>>*, seqan::String<char, seqan::Alloc<void>>*>(seqan::String<char, seqan::Alloc<void>>*, seqan::String<char, seqan::Alloc<void>>*)
inline void 
_arrayDestructDefault(TIterator1 begin_, 
                      TIterator2 end_)
{
    SEQAN_CHECKPOINT;
    while (begin_ != end_)
    {
        valueDestruct(begin_);
        ++begin_;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rbx, %r14
je 0x793f
movq %r14, %rdi
callq 0x7082
addq $0x18, %r14
jmp 0x792c
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/misc/misc_name_store_cache.h
// Function: bool seqan::NameStoreLess_<seqan::StringSet<seqan::String<char, seqan::Alloc<void>>, seqan::Owner<seqan::Tag<seqan::Default_>>>, seqan::String<char, seqan::Alloc<void>>>::operator()<unsigned long>(unsigned long, unsigned long) const
inline bool operator() (TId a, TId b) const
    {
        if (a != maxValue(a))
        {
            if (b != maxValue(b))
                return (*nameStore)[a] < (*nameStore)[b];
            else
                return (*nameStore)[a] < *name;
        } else
        {
            if (b != maxValue(b))
                return *name < (*nameStore)[b];
            else
                return false;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
cmpq $-0x1, %rsi
je 0x7ac9
movq (%r14), %rdi
callq 0x7b8a
movq %rax, %r15
cmpq $-0x1, %rbx
je 0x7ae6
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x7b8a
movq %r15, %rdi
jmp 0x7ae1
cmpq $-0x1, %rbx
je 0x7afc
movq (%r14), %rdi
movq 0x8(%r14), %r14
movq %rbx, %rsi
callq 0x7b8a
movq %r14, %rdi
movq %rax, %rsi
jmp 0x7aed
movq 0x8(%r14), %rsi
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7b09
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/sequence/string_base.h
// Function: seqan::Reference<seqan::String<seqan::String<char, seqan::Alloc<void>>, seqan::Alloc<void>>>::Type seqan::value<seqan::String<char, seqan::Alloc<void>>, seqan::Alloc<void>, unsigned long>(seqan::String<seqan::String<char, seqan::Alloc<void>>, seqan::Alloc<void>>&, unsigned long const&)
SEQAN_HOST_DEVICE inline typename Reference< String<TValue, TSpec> >::Type
value(String<TValue, TSpec> & me,
      TPos const & pos)
{
    SEQAN_CHECKPOINT;
    typedef typename Position< String<TValue, TSpec> >::Type TStringPos SEQAN_TYPEDEF_FOR_DEBUG;
    SEQAN_ASSERT_LT_MSG(static_cast<TStringPos>(pos), static_cast<TStringPos>(length(me)), "Trying to access an element behind the last one!");
    return *(begin(me, Standard()) + pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq -0x20(%rbp), %r10
movq %rax, (%r10)
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
leaq -0x18(%rbp), %r8
movq %rax, (%r8)
leaq 0x57ae(%rip), %rax      # 0xd38d
movq %rax, (%rsp)
leaq 0x573d(%rip), %rdi      # 0xd327
leaq 0x575b(%rip), %rcx      # 0xd34c
leaq 0x5771(%rip), %r9       # 0xd369
movl $0x1f2, %esi            # imm = 0x1F2
movq %r10, %rdx
xorl %eax, %eax
callq 0x7c20
testb %al, %al
je 0x7c1b
imulq $0x18, (%r14), %rax
addq (%rbx), %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x31f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x803e
movl %eax, %edi
callq 0x3650
testl %eax, %eax
sete %r14b
movl 0x8(%rbx), %edi
callq 0x3650
testl %eax, %eax
sete %al
andb %r14b, %al
orq $-0x1, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/system/file_sync.h
// Function: seqan::File<seqan::Sync<void>>::_getOFlag(int) const
inline int _getOFlag(int openMode) const {
			int result = O_LARGEFILE;

			switch (openMode & OPEN_MASK) {
                case OPEN_RDONLY:
                    result |= O_RDONLY;
					break;
                case OPEN_WRONLY:
                    result |= O_WRONLY;
					if (!(openMode & OPEN_APPEND))	result |= O_TRUNC;
					break;
                case OPEN_RDWR:
                    result |= O_RDWR;
					if (!(openMode & OPEN_APPEND))	result |= O_TRUNC;
					break;
			}

			if (openMode & OPEN_CREATE)     result |= O_CREAT;
//			if (openMode & OPEN_TEMPORARY)  result |= O_TEMPORARY;
        #ifdef SEQAN_DIRECTIO
    		if (openMode & OPEN_ASYNC)		result |= O_DIRECT;
        #endif
			return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
movl %esi, %edx
andl $0x3, %edx
xorl %ecx, %ecx
cmpl $0x2, %edx
jb 0x8086
xorl %ecx, %ecx
cmpl $0x3, %edx
jne 0x807c
testb $0x8, %al
sete %cl
shll $0x9, %ecx
orl $0x2, %ecx
jmp 0x8086
testb $0x8, %al
sete %cl
shll $0x9, %ecx
incl %ecx
shll $0x4, %eax
andl $0x40, %eax
orl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/file/string_mmap.h
// Function: bool seqan::_remap<char, seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>, unsigned long>(seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>&, unsigned long)
inline bool 
    _remap(String<TValue, MMap<TConfig> > &me, TCapSize new_capacity) 
	{
		typedef typename Size<String<TValue, MMap<TConfig> > >::Type	TSize;
        typedef typename Size<typename TConfig::TFile>::Type			TFileSize;

        bool result = true;

#ifndef PLATFORM_WINDOWS
        // Windows doesn't allow to resize the file while having a mapped file segment
        // Thus, the following part is only supported on Linux/BSD/Mac OS
        TSize old_capacity = capacity(me);
        if (me.data_begin && new_capacity > 0)
        {
            // if file gets bigger, resize first
            if (old_capacity < new_capacity)
                resize(me.mapping, (TFileSize)new_capacity * (TFileSize)sizeof(TValue));

            me.data_begin = static_cast<TValue*>(remapFileSegment(
                me.mapping,
                me.data_begin,
                0,
                (TFileSize)old_capacity * (TFileSize)sizeof(TValue),
                (TFileSize)new_capacity * (TFileSize)sizeof(TValue)));

            // if file gets smaller, resize at last
            if (old_capacity > new_capacity)
                resize(me.mapping, (TFileSize)new_capacity * (TFileSize)sizeof(TValue));

            if (me.data_begin == NULL)
            {
                me.data_end = NULL;
                return false;
            }
            return true;
        }
#endif
        result &= _unmap(me);
        result &= _map(me, new_capacity);
        return result;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x81f5
leaq 0x10(%rbx), %r15
movq 0x10(%rbx), %r12
cmpq %r14, %r12
jae 0x81bc
movq %r15, %rdi
movq %r14, %rsi
callq 0x8217
movq (%rbx), %rsi
movq %r15, %rdi
xorl %edx, %edx
movq %r12, %rcx
movq %r14, %r8
callq 0x823c
movq %rax, %rcx
movq %rax, (%rbx)
cmpq %r14, %r12
jbe 0x81e5
movq %r15, %rdi
movq %r14, %rsi
callq 0x8217
movq (%rbx), %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x820e
andq $0x0, 0x8(%rbx)
xorl %eax, %eax
jmp 0x820e
movq %rbx, %rdi
callq 0x828f
movl %eax, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x82c1
andb %r15b, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %r8, %rdx
movq %rsi, %rdi
pushq $0x1
popq %rax
movq %rcx, %rsi
movl %eax, %ecx
xorl %eax, %eax
callq 0x3220
leaq 0x1(%rax), %rcx
cmpq $0x1, %rcx
jbe 0x8261
popq %rbp
retq
callq 0x3060
movl (%rax), %edi
callq 0x3130
leaq 0x51fe(%rip), %rdi      # 0xd472
leaq 0x5219(%rip), %rdx      # 0xd494
movl $0x393, %esi            # imm = 0x393
movq %rax, %rcx
xorl %eax, %eax
callq 0x6d12
callq 0x31f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x82b3
leaq 0x10(%rbx), %rdi
movq 0x10(%rbx), %rdx
callq 0x83ad
andq $0x0, (%rbx)
jmp 0x82b5
movb $0x1, %al
andq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x8321
movq %rbx, %rdi
callq 0x8404
leaq 0x10(%rbx), %r12
movq 0x10(%rbx), %rdx
cmpq %r14, %rdx
jae 0x82fb
movq %r12, %rdi
movq %r14, %rsi
callq 0x8217
movq (%r12), %rdx
xorl %r15d, %r15d
movq %r12, %rdi
xorl %esi, %esi
callq 0x843c
movq %rax, (%rbx)
testq %rax, %rax
je 0x8334
movl 0x30(%rbx), %edx
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x33b0
jmp 0x832c
leaq 0x10(%rbx), %rdi
xorl %esi, %esi
callq 0x844b
addq (%rbx), %r14
movb $0x1, %r15b
jmp 0x8337
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/system/file_async.h
// Function: void seqan::resize<void, long>(seqan::File<seqan::Async<void>>&, long)
inline void resize(File<Async<TSpec> > &me, TSize new_length) {
//IOREV _doc_ 
		if (!me.resize(new_length))
            SEQAN_FAIL(
                "resize(%d, %d) failed: \"%s\"",
                me.handle, new_length, strerror(errno));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x839a
testb %al, %al
je 0x8362
popq %rbx
popq %r14
popq %rbp
retq
movl 0x8(%r14), %r14d
callq 0x3060
movl (%rax), %edi
callq 0x3130
leaq 0x50bb(%rip), %rdi      # 0xd434
leaq 0x50d6(%rip), %rdx      # 0xd456
movl $0x440, %esi            # imm = 0x440
movl %r14d, %ecx
movq %rbx, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x6d12
callq 0x31f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3200
testl %eax, %eax
jne 0x83d0
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
callq 0x3060
movl (%rax), %edi
callq 0x3130
leaq 0x508f(%rip), %rdi      # 0xd472
leaq 0x50c8(%rip), %rdx      # 0xd4b2
movl $0x35c, %esi            # imm = 0x35C
movq %r14, %rcx
movq %rbx, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x6d12
callq 0x31f0
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/file/string_mmap.h
// Function: void seqan::_ensureFileIsOpen<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
    _ensureFileIsOpen(String<TValue, MMap<TConfig> > &me)
	{
//IOREV
		if (!me)
		{
			if (!openTemp(me.mapping))
				SEQAN_FAIL("Memory Mapped String couldn't open temporary file");
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, 0x20(%rdi)
jne 0x841b
addq $0x10, %rdi
callq 0x8473
testb %al, %al
je 0x841d
popq %rbp
retq
leaq 0x50b3(%rip), %rdi      # 0xd4d7
leaq 0x50cd(%rip), %rdx      # 0xd4f8
movl $0x295, %esi            # imm = 0x295
xorl %eax, %eax
callq 0x6d12
callq 0x31f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, (%rdi)
pushq $0x3
popq %r14
movl %r14d, 0x18(%rdi)
movw $0x100, 0x1c(%rdi)      # imm = 0x100
addq $0x8, %rdi
callq 0x84a7
movl %r14d, 0x18(%rbx)
movw $0x101, 0x1c(%rbx)      # imm = 0x101
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/sequence/string_base.h
// Function: void seqan::AssignString_<seqan::Tag<seqan::TagGenerous_>>::assign_<seqan::String<char, seqan::Alloc<void>>, 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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x8730
cmpb $0x0, (%rax)
jne 0x873d
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
je 0x87be
movq %r14, %rdi
callq 0x87dd
testq %rax, %rax
je 0x878e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x87f8
testb %al, %al
je 0x878e
cmpq %r14, %rbx
je 0x87be
movq (%r14), %rdi
callq 0x3170
leaq -0x30(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8818
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8a54
movq -0x30(%rbp), %rdi
callq 0x32e0
jmp 0x87be
movq (%r14), %rdi
callq 0x3170
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888a
testq %rax, %rax
je 0x87be
movq (%r14), %rsi
movq (%rbx), %rdi
movq %rax, %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3510
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x32e0
movq %rbx, %rdi
callq 0x3590