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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rdi
callq 0x355c0
movq -0x98(%rbp), %rdi
movl $0x4, %edx
xorl %ecx, %ecx
movl $0x1c, %r8d
movzwl %ax, %esi
callq 0x77360
movq -0x18(%rbp), %rdi
callq 0x78e60
movl %eax, %edi
leaq -0x34(%rbp), %rsi
callq 0x5d470
leaq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movq $0x18, -0x68(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0x4, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x355a0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x355c0
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x3b1f0
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x3b220
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x3b250
testb $0x1, %al
jne 0x774c0
jmp 0x774f8
leaq -0x80(%rbp), %rdi
callq 0x3b290
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x3, %edx
movl $0x1, %ecx
callq 0x5d4a0
leaq -0x80(%rbp), %rdi
callq 0x3b340
jmp 0x774aa
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/replication.cpp
// Function: yrmcds::memcache::repl_delete(std::vector<yrmcds::memcache::repl_socket*, std::allocator<yrmcds::memcache::repl_socket*>> const&, cybozu::hash_key const&)
void repl_delete(const std::vector<repl_socket*>& slaves,
                 const cybozu::hash_key& key) {
    char header[BINARY_HEADER_SIZE];
    fill_header(header, key.length(), 0, 0, binary_command::DeleteQ);
    cybozu::tcp_socket::iovec iov[2] = {
        {header, sizeof(header)},
        {key.data(), key.length()}
    };
    for( cybozu::tcp_socket* s: slaves )
        s->sendv(iov, 2, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x355c0
movq -0x78(%rbp), %rdi
xorl %ecx, %ecx
movl $0x14, %r8d
movzwl %ax, %esi
movl %ecx, %edx
callq 0x77360
leaq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x18, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x355a0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x355c0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x3b1f0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x3b220
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3b250
testb $0x1, %al
jne 0x775a9
jmp 0x775d8
leaq -0x60(%rbp), %rdi
callq 0x3b290
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x5d4a0
leaq -0x60(%rbp), %rdi
callq 0x3b340
jmp 0x77596
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x79150
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x348b0
testb $0x1, %al
jne 0x790d4
jmp 0x79138
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x90(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x79116
movq -0x38(%rbp), %rdi
callq 0x3f120
movq -0x38(%rbp), %rdi
movl $0x98, %esi
callq 0x8650
movq -0x20(%rbp), %rdi
callq 0x79160
testb $0x1, %al
jne 0x79125
jmp 0x79132
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x79180
movb $0x1, -0x1(%rbp)
jmp 0x79154
jmp 0x7913a
movq -0x28(%rbp), %rax
movq (%rax), %rax
addq $0x90, %rax
movq %rax, -0x28(%rbp)
jmp 0x790b0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2210
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x2030
movq %rax, %rdi
leaq -0x18(%rbp), %rsi
callq 0x2140
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x2200
testb $0x1, %al
jne 0x492f
jmp 0x494b
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
cvtsi2sd %rax, %xmm0
mulsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x28(%rax)
jmp 0x497a
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x20d0
leaq -0x48(%rbp), %rdi
callq 0x4e50
movq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4e90
leaq -0x48(%rbp), %rdi
callq 0x33f0
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2210
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x2030
movq %rax, %rdi
leaq -0x18(%rbp), %rsi
callq 0x2140
movsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
cvtsi2sd %rax, %xmm1
mulsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x28(%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1f0(%rbp)
movb %dl, %al
movq %rdi, %rdx
movq %rdx, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x9ee0
movq -0x1e0(%rbp), %rsi
movl %eax, %edx
leaq -0x1a8(%rbp), %rdi
callq 0x4690
leaq -0x1c8(%rbp), %rdi
callq 0x45f0
movsbl -0x11(%rbp), %edx
leaq -0x1a8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x4810
movq %rax, -0x1f8(%rbp)
jmp 0x4c38
movq -0x1f8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4520
movb %al, -0x1f9(%rbp)
jmp 0x4c56
movb -0x1f9(%rbp), %al
testb $0x1, %al
jne 0x4c62
jmp 0x4ca2
movq -0x20(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0xa0c0
jmp 0x4c74
jmp 0x4c18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x48b8
leaq -0x1a8(%rbp), %rdi
callq 0x4330
jmp 0x4cdc
movq -0x1f0(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa130
jmp 0x4cb4
leaq -0x1c8(%rbp), %rdi
callq 0x48b8
leaq -0x1a8(%rbp), %rdi
callq 0x4330
movq -0x1e8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1d0(%rbp), %rdi
callq 0x4770
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x4650
cmpq $0x1, %rax
jbe 0x52e9
movq -0x20(%rbp), %rdi
callq 0x4650
cmpq $0x1, %rax
jbe 0x52e9
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x4850
movq -0x20(%rbp), %rdi
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x1, %esi
callq 0x4850
movq %rax, %rcx
movl -0x2c(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x52e7
movb $0x1, -0x1(%rbp)
jmp 0x52ed
jmp 0x52e9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x4650
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rcx
movl $0x1, %edx
callq 0x4460
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4850
movq %rax, -0x50(%rbp)
jmp 0x5357
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x74(%rbp)
leaq -0x45(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x4780
movl -0x74(%rbp), %edx
movq -0x70(%rbp), %rcx
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x42f0
jmp 0x5385
leaq -0x45(%rbp), %rdi
callq 0x44a0
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4550
jmp 0x539d
movb $0x1, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x48b8
testb $0x1, -0x11(%rbp)
jne 0x53f7
jmp 0x53ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5404
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x45(%rbp), %rdi
callq 0x44a0
jmp 0x5404
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x48b8
jmp 0x5404
movq -0x60(%rbp), %rdi
callq 0x48b8
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x48b8
movq -0x40(%rbp), %rdi
callq 0x4770
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4650
movq -0x68(%rbp), %rdi
movq %rax, %rsi
decq %rsi
callq 0x4850
movsbl (%rax), %eax
movl %eax, -0x54(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4780
movq -0x60(%rbp), %rdi
movl -0x54(%rbp), %edx
movq -0x50(%rbp), %rcx
movl $0x1, %esi
callq 0x42f0
jmp 0x5488
leaq -0x12(%rbp), %rdi
callq 0x44a0
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4650
movq -0x78(%rbp), %rsi
movq %rax, %rcx
decq %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x48(%rbp), %rdi
callq 0x4460
jmp 0x54b7
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4550
jmp 0x54c6
movb $0x1, -0x11(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x48b8
testb $0x1, -0x11(%rbp)
jne 0x5520
jmp 0x5517
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x44a0
jmp 0x5536
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x552d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x48b8
jmp 0x552d
movq -0x60(%rbp), %rdi
callq 0x48b8
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x48b8
movq -0x20(%rbp), %rdi
callq 0x4770
nop
// File: 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
subq $0xb0, %rsp
leaq 0x1ed82(%rip), %rsi     # 0x284c4
leaq 0x2ed8f(%rip), %rdx     # 0x384d8
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xaa90
movq -0xa0(%rbp), %rsi
leaq 0x1ed61(%rip), %rdx     # 0x284c8
leaq -0x28(%rbp), %rdi
callq 0xacd0
jmp 0x9772
leaq -0x48(%rbp), %rdi
callq 0x48b8
leaq -0x28(%rbp), %rdi
callq 0x41e0
movq %rax, %rdi
callq 0x4390
movl %eax, -0xa4(%rbp)
jmp 0x9794
movl -0xa4(%rbp), %eax
cmpl $0x0, %eax
jge 0x97dd
movl $0x1, -0x4(%rbp)
movl $0x1, -0x58(%rbp)
jmp 0x989a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x48b8
jmp 0x98b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x98af
leaq 0x1ece0(%rip), %rsi     # 0x284c4
leaq 0x2ed0d(%rip), %rdx     # 0x384f8
leaq -0x98(%rbp), %rdi
callq 0xaa90
jmp 0x97f9
leaq 0x1eccf(%rip), %rdx     # 0x284cf
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xacd0
jmp 0x9812
leaq -0x98(%rbp), %rdi
callq 0x48b8
leaq -0x78(%rbp), %rdi
callq 0x41e0
movq %rax, %rdi
callq 0x4390
movl %eax, -0xa8(%rbp)
jmp 0x9837
movl -0xa8(%rbp), %eax
cmpl $0x0, %eax
jge 0x9883
movl $0x1, -0x4(%rbp)
movl $0x1, -0x58(%rbp)
jmp 0x9891
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x48b8
jmp 0x98af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x48b8
jmp 0x98af
movl $0x0, -0x4(%rbp)
movl $0x1, -0x58(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x48b8
leaq -0x28(%rbp), %rdi
callq 0x48b8
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x48b8
movq -0x50(%rbp), %rdi
callq 0x4770
nopw %cs:(%rax,%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/bam_io/sam_reader.h
// Function: seqan::SamReader_::open(seqan::String<char, seqan::Alloc<void>> const&)
inline int SamReader_::open(CharString const & filename)
{
    // Open file.
    if (filename == "-")
    {
        this->_stream = &std::cin;
    }
    else
    {
        this->_stream = &this->_fstream;
        this->_fstream.open(toCString(filename), std::ios::binary | std::ios::in);
        if (!this->_fstream.good())
            return 1;

        // Determine file size.
        this->_stream->seekg(0, std::ios::end);
        this->_fileSize = this->_stream->tellg();
        this->_stream->seekg(0, std::ios::beg);
    }
    this->_reader.reset(new RecordReader<std::istream, SinglePass<> >(*this->_stream));

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1e5e9(%rip), %rsi     # 0x282fc
callq 0x9e70
testb $0x1, %al
jne 0x9d1e
jmp 0x9d35
movq -0x40(%rbp), %rax
movq 0x2e2af(%rip), %rcx     # 0x37fd8
movq %rcx, 0x230(%rax)
jmp 0x9df9
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x28, %rcx
movq %rcx, 0x230(%rax)
addq $0x28, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9ec0
movq %rax, -0x48(%rbp)
movl $0x4, %edi
movl $0x8, %esi
callq 0x9ee0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl %eax, %edx
callq 0x42e0
movq -0x40(%rbp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movq 0x28(%rax), %rax
addq -0x18(%rax), %rdi
callq 0x4720
testb $0x1, %al
jne 0x9da2
movl $0x1, -0x4(%rbp)
jmp 0x9e5a
movq -0x40(%rbp), %rax
movq 0x230(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x45b0
movq -0x40(%rbp), %rax
movq 0x230(%rax), %rdi
callq 0x4750
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9f00
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
movq 0x230(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x45b0
movq -0x40(%rbp), %rax
addq $0x238, %rax            # imm = 0x238
movq %rax, -0x60(%rbp)
movl $0x50, %edi
callq 0x4450
movq %rax, %rdi
movq -0x40(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x58(%rbp)
movq 0x230(%rax), %rsi
callq 0x9f50
jmp 0x9e2d
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x9f20
movl $0x0, -0x4(%rbp)
jmp 0x9e5a
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x43f0
jmp 0x9e63
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x4770
nopl (%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/bam_io/sam_writer.h
// Function: seqan::SamWriter_::open(seqan::String<char, seqan::Alloc<void>> const&)
inline int SamWriter_::open(CharString const & filename)
{
    if (filename == "-")
    {
        this->_stream = &std::cout;
    }
    else
    {
        this->_stream = &this->_fstream;
        this->_fstream.open(toCString(filename), std::ios::binary | std::ios::out);
        if (!this->_fstream.good())
            return 1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1e2d9(%rip), %rsi     # 0x282fc
callq 0x9e70
testb $0x1, %al
jne 0xa02e
jmp 0xa03f
movq -0x20(%rbp), %rax
movq 0x2df7f(%rip), %rcx     # 0x37fb8
movq %rcx, 0x20(%rax)
jmp 0xa0a8
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x28, %rcx
movq %rcx, 0x20(%rax)
addq $0x28, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9ec0
movq %rax, -0x28(%rbp)
movl $0x4, %edi
movl $0x10, %esi
callq 0x9ee0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl %eax, %edx
callq 0x4090
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movq 0x28(%rax), %rax
addq -0x18(%rax), %rdi
callq 0x4720
testb $0x1, %al
jne 0xa0a6
movl $0x1, -0x4(%rbp)
jmp 0xa0af
jmp 0xa0a8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41e0
movq %rax, %rdi
leaq 0x1dc7c(%rip), %rsi     # 0x28a0b
callq 0x44d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xadae
movq -0x18(%rbp), %rdi
callq 0x4440
movb $0x1, -0x1(%rbp)
jmp 0xadb2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0xe0, %rsp
testb %al, %al
je 0xb168
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 %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
callq 0xb2d0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rsi
movq 0x2ce51(%rip), %rdi     # 0x37ff0
callq 0x4430
movq %rax, %rdi
leaq 0x1d9c9(%rip), %rsi     # 0x28b77
callq 0x4430
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x4740
movq %rax, %rdi
leaq 0x1d3ce(%rip), %rsi     # 0x28596
callq 0x4430
cmpq $0x0, -0x18(%rbp)
je 0xb239
movq 0x2ce15(%rip), %rdi     # 0x37ff0
leaq 0x1d4ef(%rip), %rsi     # 0x286d1
callq 0x4430
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq 0x2cdb6(%rip), %rax     # 0x37fc8
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4590
leaq -0x30(%rbp), %rax
movq 0x2cdc3(%rip), %rdi     # 0x37ff0
leaq 0x1d656(%rip), %rsi     # 0x2888a
callq 0x4430
movq 0x2cdb0(%rip), %rdi     # 0x37ff0
movq 0x2cd59(%rip), %rsi     # 0x37fa0
callq 0x4480
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: mshabbirhasan[P]ups-indel/include/seqan/sequence/string_base.h
// Function: void seqan::AppendValueToString_<seqan::Tag<seqan::TagGenerous_>>::appendValue_<seqan::String<seqan::BamHeaderRecord, seqan::Alloc<void>>, seqan::BamHeaderRecord const>(seqan::String<seqan::BamHeaderRecord, seqan::Alloc<void>>&, seqan::BamHeaderRecord 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b320
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b360
cmpq -0x18(%rbp), %rax
ja 0x1b2d4
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1b380
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
incq %rsi
callq 0x1b3c0
movq %rax, -0x60(%rbp)
jmp 0x1b263
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x1b2c9
movq -0x8(%rbp), %rdi
callq 0x1b420
movq %rax, -0x68(%rbp)
jmp 0x1b284
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
leaq -0x38(%rbp), %rsi
callq 0x1b3f0
jmp 0x1b29e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
incq %rsi
callq 0x1b440
jmp 0x1b2b0
jmp 0x1b2c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1a190
jmp 0x1b30b
leaq -0x38(%rbp), %rdi
callq 0x1a190
jmp 0x1b305
movq -0x8(%rbp), %rdi
callq 0x1b420
movq %rax, %rdi
movq -0x18(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1b3f0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x1b440
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4770
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc220
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0xc38c
jmp 0xc41b
movq -0x10(%rbp), %rdi
callq 0xc1e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc450
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xc40e
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc2a0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0xc4c0
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0xc4f0
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xc520
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xc2c0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/sequence/string_base.h
// Function: seqan::Value<seqan::String<unsigned long, seqan::Alloc<void>>, 0>::Type* seqan::_reallocateStorage<unsigned long, seqan::Alloc<void>, unsigned long>(seqan::String<unsigned long, seqan::Alloc<void>>&, unsigned long, seqan::Tag<seqan::TagGenerous_>)
inline typename Value<String<TValue, TSpec> >::Type *
_reallocateStorage(
    String<TValue, TSpec> & me,
    TSize new_capacity,
    Generous)
{
    typedef typename Size<String<TValue, TSpec> >::Type TStringSize;
    if (static_cast<TStringSize>(new_capacity) <= capacity(me))
        return 0;

    new_capacity = computeGenerousCapacity(me, new_capacity);
    return _reallocateStorage(me, new_capacity);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc220
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
ja 0xc487
movq $0x0, -0x8(%rbp)
jmp 0xc4a9
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xc560
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xc5a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/sequence/string_alloc.h
// Function: seqan::Value<seqan::String<unsigned long, seqan::Alloc<void>>, 0>::Type* seqan::_allocateStorage<unsigned long, void, unsigned long>(seqan::String<unsigned long, 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc630
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x21(%rbp), %rcx
callq 0xc650
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0xca41
movq -0x8(%rbp), %rdi
callq 0xca50
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
jmp 0xca20
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd640
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq (%rcx), %rax
je 0xd447
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd640
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq (%rcx), %rax
je 0xd420
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xd6a0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xd6a0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xd670
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xd493
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xd6a0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xd670
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xd493
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd640
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq (%rcx), %rax
je 0xd48f
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x50(%rbp)
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xd6a0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xd670
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xd493
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: mshabbirhasan[P]ups-indel/include/seqan/sequence/sequence_lexical.h
// Function: void seqan::compare_<unsigned long, seqan::String<char, seqan::Alloc<void>> const, seqan::String<char, seqan::Alloc<void>> const>(seqan::Lexical<unsigned long>&, seqan::String<char, seqan::Alloc<void>> const&, seqan::String<char, seqan::Alloc<void>> const&)
inline void
compare_(Lexical<TSpec> & lexical,
		 TLeft & left,
		 TRight & right)
{
	typename Iterator<TLeft, Standard>::Type left_it = begin(left, Standard());
	typename Size<TLeft>::Type left_length = length(left);
	typename Iterator<TRight, Standard>::Type right_it = begin(right, Standard());
	typename Size<TRight>::Type right_length = length(right);

	if (left_length == right_length) lexical.data_compare = Lexical<TSpec>::EQUAL;
	else if (left_length < right_length) lexical.data_compare = Lexical<TSpec>::LEFT_IS_PREFIX;
	else
	{
		lexical.data_compare = Lexical<TSpec>::RIGHT_IS_PREFIX;
		left_length = right_length;
	}

	lexical.data_lcp = 0;
	for (lexical.data_lcp = 0; lexical.data_lcp < left_length; ++lexical.data_lcp)
	{
		if (*left_it < *right_it)
		{
			lexical.data_compare = Lexical<TSpec>::LESS;
			break;
		}
		if (*left_it > *right_it)
		{
			lexical.data_compare = Lexical<TSpec>::GREATER;
			break;
		}
		++left_it;
		++right_it;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd900
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd920
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd900
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd920
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x48(%rbp), %rax
jne 0xd84c
movq -0x8(%rbp), %rax
movb $0x1, 0x8(%rax)
jmp 0xd872
movq -0x30(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0xd860
movq -0x8(%rbp), %rax
movb $0x8, 0x8(%rax)
jmp 0xd870
movq -0x8(%rbp), %rax
movb $0x10, 0x8(%rax)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xd872
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x30(%rbp), %rax
jae 0xd8f5
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movq -0x38(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0xd8b1
movq -0x8(%rbp), %rax
movb $0x2, 0x8(%rax)
jmp 0xd8f5
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movq -0x38(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jle 0xd8cd
movq -0x8(%rbp), %rax
movb $0x4, 0x8(%rax)
jmp 0xd8f5
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xd888
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/file/file_mapping.h
// Function: void seqan::_initialize<void>(seqan::FileMapping<void>&)
inline void
_initialize(FileMapping<TSpec> &mapping)
{
#ifdef PLATFORM_WINDOWS
    mapping.handle = NULL;
#endif
    mapping.fileSize = 0;
    mapping.openMode = OPEN_RDWR;
    mapping.ownFile = false;
    mapping.temporary = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0x18(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x1d(%rax)
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movb $0x1, -0x9(%rbp)
movl 0xc(%rcx), %eax
cmpl 0x8(%rcx), %eax
je 0xe586
movq -0x18(%rbp), %rax
cmpl $-0x1, 0xc(%rax)
je 0xe586
movq -0x18(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x4880
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %ecx
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x4880
movl %eax, %ecx
movq -0x18(%rbp), %rax
cmpl $0x0, %ecx
sete %cl
andb $0x1, %cl
movzbl %cl, %edx
movb -0x9(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %edx, %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movb %cl, -0x9(%rbp)
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
jmp 0xe5cb
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/system/file_sync.h
// Function: seqan::File<seqan::Sync<void>>::open(char const*, int)
virtual bool open(char const *fileName, int openMode = DefaultOpenMode<File>::VALUE) {
            handle = ::open(fileName, _getOFlag(openMode), S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
			if (handle == -1 && errno == EINVAL) {	// fall back to cached access
	            #ifdef SEQAN_DEBUG_OR_TEST_
					if (!(openMode & OPEN_QUIET))
						::std::cerr << "Warning: Direct access openening failed: " << fileName << "." << ::std::endl;
				#endif			
          	    handle = ::open(fileName, _getOFlag(openMode & ~OPEN_ASYNC), S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
			}
			
			if (handle == -1) {
				if (!(openMode & OPEN_QUIET))
					::std::cerr << "Open failed on file " << fileName << ". (" << ::strerror(errno) << ")" << ::std::endl;
				return false;
			}

			if (sizeof(FilePtr) < 8 && !(openMode & OPEN_QUIET))
				// To remove this warning, you have to options:
				// 1. include the following line before including anything in your application
				//    #define _FILE_OFFSET_BITS 64
				// 2. include <seqan/platform.h> or <seqan/sequence.h> before any other include
				::std::cerr << "WARNING: FilePtr is not 64bit wide" << ::std::endl;

			SEQAN_PROADD(SEQAN_PROOPENFILES, 1);
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %esi
callq 0xe790
movq -0x30(%rbp), %rdi
movl %eax, %esi
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x4320
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
cmpl $-0x1, 0x8(%rax)
jne 0xe6a8
callq 0x4080
cmpl $0x16, (%rax)
jne 0xe6a8
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %esi
andl $-0x11, %esi
callq 0xe790
movq -0x38(%rbp), %rdi
movl %eax, %esi
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x4320
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
jne 0xe72d
movl -0x1c(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xe727
movq 0x2992a(%rip), %rdi     # 0x37ff0
leaq 0x19fee(%rip), %rsi     # 0x286bb
callq 0x4430
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x4430
movq %rax, %rdi
leaq 0x19fe8(%rip), %rsi     # 0x286d0
callq 0x4430
movq %rax, -0x40(%rbp)
callq 0x4080
movl (%rax), %edi
callq 0x4190
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x4430
movq %rax, %rdi
leaq 0x1a177(%rip), %rsi     # 0x2888a
callq 0x4430
movq %rax, %rdi
movq 0x2987e(%rip), %rsi     # 0x37fa0
callq 0x4480
movb $0x0, -0x1(%rbp)
jmp 0xe735
jmp 0xe72f
jmp 0xe731
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: mshabbirhasan[P]ups-indel/include/seqan/system/file_sync.h
// Function: seqan::File<seqan::Sync<void>>::close()
virtual bool close() {
            if (::close(this->handle) == -1) return false;
            handle = -1;
			SEQAN_PROSUB(SEQAN_PROOPENFILES, 1);
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x8(%rax), %edi
callq 0x4880
cmpl $-0x1, %eax
jne 0xe767
movb $0x0, -0x1(%rbp)
jmp 0xe778
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
jmp 0xe774
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0xe7c6
jmp 0xe7b2
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0xe7d1
jmp 0xe7bc
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0xe7f2
jmp 0xe813
movl -0x10(%rbp), %eax
orl $0x0, %eax
movl %eax, -0x10(%rbp)
jmp 0xe813
movl -0x10(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0xe7f0
movl -0x10(%rbp), %eax
orl $0x200, %eax            # imm = 0x200
movl %eax, -0x10(%rbp)
jmp 0xe813
movl -0x10(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0xe811
movl -0x10(%rbp), %eax
orl $0x200, %eax            # imm = 0x200
movl %eax, -0x10(%rbp)
jmp 0xe813
movl -0xc(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xe827
movl -0x10(%rbp), %eax
orl $0x40, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/sequence/string_base.h
// Function: seqan::Size<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>>::Type seqan::_Resize_String<seqan::Tag<seqan::TagGenerous_>>::resize_<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>>(seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>&, seqan::Size<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>>::Type)
static inline typename Size<T>::Type
    resize_(
        T & me,
        typename Size<T>::Type new_length)
    {
        typedef typename Size<T>::Type TSize;
        TSize me_length = length(me);
        if (new_length < me_length)
        {
            SEQAN_CHECKPOINT;
            arrayDestruct(begin(me, Standard()) + new_length, begin(me, Standard()) + me_length);
        }
        else
        {
            typename Size<T>::Type me_capacity = capacity(me);
            if (new_length > me_capacity)
            {
                SEQAN_CHECKPOINT;
                TSize new_capacity = reserve(me, new_length, TExpand());
                if (new_capacity < new_length)
                {
                    new_length = new_capacity;
                }
            }
            if (new_length > me_length)
            {
                SEQAN_CHECKPOINT;
                arrayConstruct(begin(me, Standard()) + me_length, begin(me, Standard()) + new_length);
            }
        }

        _setLength(me, new_length);
        return new_length;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe940
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xe8b3
movq -0x8(%rbp), %rdi
callq 0xe9b0
addq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe9b0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
addq -0x18(%rbp), %rsi
callq 0xe980
jmp 0xe925
movq -0x8(%rbp), %rdi
callq 0xe9d0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0xe8ef
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xe8ed
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xe8ef
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0xe923
movq -0x8(%rbp), %rdi
callq 0xe9b0
addq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe9b0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
addq -0x10(%rbp), %rsi
callq 0xea30
jmp 0xe925
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xea60
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/file/file_mapping.h
// Function: bool seqan::resize<void, long>(seqan::FileMapping<void>&, long)
inline bool
resize(FileMapping<TSpec> &mapping, TSize newFileSize)
{
    typedef typename Size<FileMapping<TSpec> >::Type TFileSize;
    if ((TFileSize)newFileSize == mapping.fileSize)
        return true;

    bool result = _unmapFile(mapping);
    resize(mapping.file, newFileSize);
    mapping.fileSize = newFileSize;
    result &= _mapFile(mapping, newFileSize);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xee93
movb $0x1, -0x1(%rbp)
jmp 0xeeec
movq -0x10(%rbp), %rdi
callq 0xf140
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0xf170
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf1f0
andb $0x1, %al
movzbl %al, %ecx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)