LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sweeterthancandy[P]linux_event_debugger/linux_events.cpp
// Function: (anonymous namespace)::driver::pretty_print_(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, input_event const&)
void pretty_print_(const std::string& dev, const struct input_event& ev){
                std::stringstream sstr;
                sstr << dev << " - ";
                sstr << input_event_to_string(ev,aux::colour_formatter());
                std::cout << sstr.str() << std::endl;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0xd460
leaq -0x190(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd5b0
movq %rax, -0x200(%rbp)
jmp 0x19b9c
movq -0x200(%rbp), %rdi
leaq 0x4dd78(%rip), %rsi     # 0x67922
callq 0xd650
jmp 0x19bb1
leaq -0x190(%rbp), %rax
movq %rax, -0x208(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x1d0(%rbp), %rdi
leaq -0x1d1(%rbp), %rdx
callq 0x19cd0
jmp 0x19bd8
movq -0x208(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0xd5b0
jmp 0x19bed
leaq -0x1d0(%rbp), %rdi
callq 0xd3b0
leaq -0x1f8(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xd630
jmp 0x19c0e
movq 0x7f393(%rip), %rdi     # 0x98fa8
leaq -0x1f8(%rbp), %rsi
callq 0xd5b0
movq %rax, -0x210(%rbp)
jmp 0x19c2a
movq -0x210(%rbp), %rdi
movq 0x7f310(%rip), %rsi     # 0x98f48
callq 0xd6c0
jmp 0x19c3f
leaq -0x1f8(%rbp), %rdi
callq 0xd3b0
leaq -0x1a0(%rbp), %rdi
callq 0xd4c0
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x19cb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0xd3b0
jmp 0x19cb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0xd3b0
leaq -0x1a0(%rbp), %rdi
callq 0xd4c0
movq -0x1a8(%rbp), %rdi
callq 0xdb80
nopw (%rax,%rax)
// File: sweeterthancandy[P]linux_event_debugger/./event_monitor.h
// Function: event_monitor::event_monitor(boost::asio::io_context&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
explicit event_monitor(boost::asio::io_service& io, const std::string& dev)
                :io_(io)
                ,work_(io) // keep alive
                ,desc_(io)
                ,dev_(dev)
        {
                int fd = open(dev_.c_str(), O_RDONLY);
                if( fd < 0 ) 
                        BOOST_THROW_EXCEPTION(std::domain_error("unable to open file"));
                desc_.assign( fd );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3c1e0
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
movq %rdi, -0x60(%rbp)
movq -0x10(%rbp), %rsi
callq 0x30020
jmp 0x3c053
movq -0x68(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x70(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3c200
jmp 0x3c06e
movq -0x68(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x78(%rbp)
movq -0x18(%rbp), %rsi
callq 0xd280
jmp 0x3c085
movq -0x68(%rbp), %rdi
addq $0xa0, %rdi
movq %rdi, -0x80(%rbp)
leaq -0x25(%rbp), %rsi
leaq -0x26(%rbp), %rdx
callq 0x3c230
jmp 0x3c0a3
movq -0x68(%rbp), %rdi
addq $0x68, %rdi
callq 0xd260
movq %rax, %rdi
xorl %esi, %esi
movb %sil, %al
callq 0xd4b0
movl %eax, -0x84(%rbp)
jmp 0x3c0c5
movl -0x84(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x3c182
leaq 0x27fa2(%rip), %rsi     # 0x64081
leaq -0x40(%rbp), %rdi
callq 0xd3e0
jmp 0x3c0ea
leaq 0x27fa4(%rip), %rsi     # 0x64095
leaq 0x27faf(%rip), %rcx     # 0x640a7
leaq -0x58(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movl $0x19, %edx
xorl %r8d, %r8d
callq 0x3c360
movq -0x90(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x3c2e0
jmp 0x3c122
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3c1c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3c1b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3c1b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3c1a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3c19e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd570
jmp 0x3c19e
movq -0x68(%rbp), %rdi
addq $0x20, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x3c3a0
jmp 0x3c195
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x3c410
movq -0x78(%rbp), %rdi
callq 0xd3b0
movq -0x70(%rbp), %rdi
callq 0x3c450
movq -0x60(%rbp), %rdi
callq 0x300a0
movq -0x68(%rbp), %rdi
callq 0x3c470
movq -0x20(%rbp), %rdi
callq 0xdb80
nopw %cs:(%rax,%rax)
nop
// File: sweeterthancandy[P]linux_event_debugger/./event_monitor.h
// Function: event_monitor::start_read()
void start_read(){
                auto self = shared_from_this();
                boost::asio::async_read( desc_, boost::asio::buffer(ev_buffer_),
                        [this,self](const boost::system::error_code& ec, size_t n){
                                if( ec ){
                                        // must of been cancelled
                                 
                                } else {
                                        assert( n == sizeof(struct input_event) && "unexpected read size");
                                        sig_(dev_, *reinterpret_cast<struct input_event*>(ev_buffer_.data()));
                                        start_read();
                                }
                });
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x60(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x40740
movq -0x60(%rbp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x58(%rbp)
addq $0x88, %rdi
callq 0x407d0
movq -0x68(%rbp), %rsi
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x40820
movq -0x58(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x40770
jmp 0x406f3
leaq -0x40(%rbp), %rdi
callq 0x40850
leaq -0x18(%rbp), %rdi
callq 0x3b670
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x40850
leaq -0x18(%rbp), %rdi
callq 0x3b670
movq -0x48(%rbp), %rdi
callq 0xdb80
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: VanAndelInstitute[P]intent/main.cpp
// Function: usage()
void usage()
{
  std::cout << std::endl << "Usage: intent [options] read1.fastq.gz read2.fastq.gz output" << std::endl <<
      "  read1.fastq.gz     read 1 fastq file (gzipped) from a v2 inDrop sequencing run." << std::endl <<
      "  read2.fastq.gz     read 2 fastq file (gzipped) from a v2 inDrop sequencing run." << std::endl <<
      "" << std::endl << 
      "  Options:" << std::endl <<
      "    -x               expanded barcodes and umi format (20 / 14) " << std::endl <<
      "    -t               Chromium v2 barcode format (16 / 10) " << std::endl <<
      "    -d 2             Maximum W1 alignment distance (default = 2)" << std::endl <<
      "    -h               Print this help" << std::endl << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x59a3d(%rip), %rdi     # 0x8dfb8
movq 0x599f6(%rip), %rsi     # 0x8df78
callq 0x85b0
movq %rax, %rdi
leaq 0x3ac21(%rip), %rsi     # 0x6f1b2
callq 0x8540
movq %rax, %rdi
movq 0x599d8(%rip), %rsi     # 0x8df78
callq 0x85b0
movq %rax, %rdi
leaq 0x3ac40(%rip), %rsi     # 0x6f1ef
callq 0x8540
movq %rax, %rdi
movq 0x599ba(%rip), %rsi     # 0x8df78
callq 0x85b0
movq %rax, %rdi
leaq 0x3ac74(%rip), %rsi     # 0x6f241
callq 0x8540
movq %rax, %rdi
movq 0x5999c(%rip), %rsi     # 0x8df78
callq 0x85b0
movq %rax, %rdi
leaq 0x3aeee(%rip), %rsi     # 0x6f4d9
callq 0x8540
movq %rax, %rdi
movq 0x5997e(%rip), %rsi     # 0x8df78
callq 0x85b0
movq %rax, %rdi
leaq 0x3ac8a(%rip), %rsi     # 0x6f293
callq 0x8540
movq %rax, %rdi
movq 0x59960(%rip), %rsi     # 0x8df78
callq 0x85b0
movq %rax, %rdi
leaq 0x3ac77(%rip), %rsi     # 0x6f29e
callq 0x8540
movq %rax, %rdi
movq 0x59942(%rip), %rsi     # 0x8df78
callq 0x85b0
movq %rax, %rdi
leaq 0x3ac9a(%rip), %rsi     # 0x6f2df
callq 0x8540
movq %rax, %rdi
movq 0x59924(%rip), %rsi     # 0x8df78
callq 0x85b0
movq %rax, %rdi
leaq 0x3acb7(%rip), %rsi     # 0x6f31a
callq 0x8540
movq %rax, %rdi
movq 0x59906(%rip), %rsi     # 0x8df78
callq 0x85b0
movq %rax, %rdi
leaq 0x3acda(%rip), %rsi     # 0x6f35b
callq 0x8540
movq %rax, %rdi
movq 0x598e8(%rip), %rsi     # 0x8df78
callq 0x85b0
movq %rax, %rdi
movq 0x598d9(%rip), %rsi     # 0x8df78
callq 0x85b0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: VanAndelInstitute[P]intent/main.cpp
// Function: readFour[abi:cxx11](zstr::istream&)
std::vector<std::string> readFour(zstr::istream &f)
{
  std::vector<std::string> lines;
  std::string line;
  for(int i = 0; i < 4; i++) {
    if(f.peek() != EOF ) {
      getline(f, line);
      lines.push_back(line);
    } else {
      lines.push_back("");
    }
  }
  return lines;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x36070
leaq -0x38(%rbp), %rdi
callq 0x87c0
movl $0x0, -0x3c(%rbp)
cmpl $0x4, -0x3c(%rbp)
jge 0x347d4
movq -0x10(%rbp), %rdi
callq 0x8220
movl %eax, -0x8c(%rbp)
jmp 0x34705
movl -0x8c(%rbp), %eax
cmpl $-0x1, %eax
je 0x34747
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x80e0
jmp 0x3471f
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x36090
jmp 0x34731
jmp 0x347c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x347e9
leaq -0x71(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x8980
movq -0x98(%rbp), %rdx
leaq 0x3ad74(%rip), %rsi     # 0x6f4d9
leaq -0x70(%rbp), %rdi
callq 0x35e90
jmp 0x34770
movq -0x88(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x36100
jmp 0x34782
leaq -0x70(%rbp), %rdi
callq 0x8a98
leaq -0x71(%rbp), %rdi
callq 0x85e0
jmp 0x347c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x347b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x8a98
leaq -0x71(%rbp), %rdi
callq 0x85e0
jmp 0x347e9
jmp 0x347c6
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x346ea
movb $0x1, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8a98
testb $0x1, -0x11(%rbp)
jne 0x3480c
jmp 0x34800
leaq -0x38(%rbp), %rdi
callq 0x8a98
movq -0x88(%rbp), %rdi
callq 0x36130
jmp 0x34819
movq -0x88(%rbp), %rdi
callq 0x36130
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x8970
nopw %cs:(%rax,%rax)
// File: VanAndelInstitute[P]intent/main.cpp
// Function: update_stats(std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>, int, int, int, int, int, int)
void update_stats(std::chrono::steady_clock::time_point start, int a, int b, int c, int d, int e, int f) {
  auto now = std::chrono::steady_clock::now();
  int secs = std::chrono::duration_cast<std::chrono::seconds>(now - start).count();
  printf("|%11d|%11d|%11d|%11d|%11d|%11d| (in %d secs)\r", a, b, c, d, e, f, secs);
  fflush(stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
callq 0x8760
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x36410
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x363e0
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x36460
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movl 0x10(%rbp), %r10d
movl -0x2c(%rbp), %eax
leaq 0x3a9ec(%rip), %rdi     # 0x6f42e
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x8090
movq 0x59508(%rip), %rax     # 0x8df60
movq (%rax), %rdi
callq 0x8680
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: VanAndelInstitute[P]intent/include/strict_fstream.hpp
// Function: strict_fstream::strerror[abi:cxx11]()
static std::string strerror()
{
    std::string buff(80, '\0');
#ifdef _WIN32
    if (strerror_s(&buff[0], buff.size(), errno) != 0)
    {
        buff = "Unknown error";
    }
#elif (_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && ! _GNU_SOURCE
// XSI-compliant strerror_r()
    if (strerror_r(errno, &buff[0], buff.size()) != 0)
    {
        buff = "Unknown error";
    }
#elif __APPLE__ && __clang__ && ! _GNU_SOURCE
// XSI-compliant strerror_r()
    if (strerror_r(errno, &buff[0], buff.size()) != 0)
    {
        buff = "Unknown error";
    }
#else 
// GNU-specific strerror_r()
    auto p = strerror_r(errno, &buff[0], buff.size());
    std::string tmp(p, std::strlen(p));
    std::swap(buff, tmp);
#endif
    buff.resize(buff.find('\0'));
    return buff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0xa(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x8980
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rcx
movl $0x50, %esi
xorl %edx, %edx
callq 0x38b70
jmp 0x35d41
leaq -0xa(%rbp), %rdi
callq 0x85e0
callq 0x8080
movq -0x60(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x74(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x8a50
movq %rax, -0x70(%rbp)
jmp 0x35d67
movq -0x60(%rbp), %rdi
callq 0x8410
movl -0x74(%rbp), %edi
movq -0x70(%rbp), %rsi
movq %rax, %rdx
callq 0x8150
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x8290
movq %rax, -0x88(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x8980
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0x8630
jmp 0x35dc4
leaq -0x49(%rbp), %rdi
callq 0x85e0
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x38be0
movq -0x60(%rbp), %rdi
xorl %esi, %esi
movl %esi, %edx
callq 0x8730
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x87b0
jmp 0x35df5
movb $0x1, -0x9(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8a98
testb $0x1, -0x9(%rbp)
jne 0x35e66
jmp 0x35e5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xa(%rbp), %rdi
callq 0x85e0
jmp 0x35e7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x35e73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x85e0
jmp 0x35e73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8a98
jmp 0x35e73
movq -0x60(%rbp), %rdi
callq 0x8a98
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x8a98
movq -0x18(%rbp), %rdi
callq 0x8970
nopw %cs:(%rax,%rax)
nop
// File: VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::istreambuf::istreambuf(std::basic_streambuf<char, std::char_traits<char>>*, unsigned long, bool)
istreambuf(std::streambuf * _sbuf_p,
               std::size_t _buff_size = default_buff_size, bool _auto_detect = true)
        : sbuf_p(_sbuf_p),
          zstrm_p(nullptr),
          buff_size(_buff_size),
          auto_detect(_auto_detect),
          auto_detect_run(false),
          is_text(false)
    {
        assert(sbuf_p);
        in_buff = new char [buff_size];
        in_buff_start = in_buff;
        in_buff_end = in_buff;
        out_buff = new char [buff_size];
        setg(out_buff, out_buff, out_buff);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x8160
movq -0x38(%rbp), %rax
leaq 0x56595(%rip), %rcx     # 0x8d698
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq $0x0, 0x68(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x70(%rax)
movb -0x19(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x78(%rax)
movb $0x0, 0x79(%rax)
movb $0x0, 0x7a(%rax)
cmpq $0x0, 0x40(%rax)
je 0x3713c
jmp 0x3715b
leaq 0x384c8(%rip), %rdi     # 0x6f60b
leaq 0x384c8(%rip), %rsi     # 0x6f612
movl $0x74, %edx
leaq 0x384cd(%rip), %rcx     # 0x6f623
callq 0x83e0
movq -0x38(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x8040
movq %rax, -0x40(%rbp)
jmp 0x3716e
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq 0x48(%rax), %rcx
movq %rcx, 0x50(%rax)
movq 0x48(%rax), %rcx
movq %rcx, 0x58(%rax)
movq 0x70(%rax), %rdi
callq 0x8040
movq %rax, -0x48(%rbp)
jmp 0x37199
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, 0x60(%rdi)
movq 0x60(%rdi), %rcx
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x8820
jmp 0x371b6
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8a80
movq -0x28(%rbp), %rdi
callq 0x8970
nopw (%rax,%rax)
// File: VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::detail::z_stream_wrapper::~z_stream_wrapper()
~z_stream_wrapper()
    {
        if (is_input)
        {
            inflateEnd(this);
        }
        else
        {
            deflateEnd(this);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x70(%rax)
je 0x37747
movq -0x10(%rbp), %rdi
callq 0x85d0
jmp 0x37745
jmp 0x37754
movq -0x10(%rbp), %rdi
callq 0x8390
jmp 0x37752
jmp 0x37754
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x36cc0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::detail::z_stream_wrapper::z_stream_wrapper(bool, int)
z_stream_wrapper(bool _is_input = true, int _level = Z_DEFAULT_COMPRESSION)
        : is_input(_is_input)
    {
        this->zalloc = Z_NULL;
        this->zfree = Z_NULL;
        this->opaque = Z_NULL;
        int ret;
        if (is_input)
        {
            this->avail_in = 0;
            this->next_in = Z_NULL;
            ret = inflateInit2(this, 15+32);
        }
        else
        {
            ret = deflateInit2(this, _level, Z_DEFLATED, 15+16, 8, Z_DEFAULT_STRATEGY);
        }
        if (ret != Z_OK) throw Exception(this, ret);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movb -0x9(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x70(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x48(%rax)
movq $0x0, 0x50(%rax)
testb $0x1, 0x70(%rax)
je 0x37823
movq -0x30(%rbp), %rdi
movl $0x0, 0x8(%rdi)
movq $0x0, (%rdi)
movl $0x2f, %esi
leaq 0x37eea(%rip), %rdx     # 0x6f6fe
movl $0x70, %ecx
callq 0x84d0
movl %eax, -0x14(%rbp)
jmp 0x37856
movq -0x30(%rbp), %rdi
movl -0x10(%rbp), %esi
movl $0x8, %r8d
movl $0x1f, %ecx
xorl %r9d, %r9d
leaq 0x37ebf(%rip), %rax     # 0x6f6fe
movl %r8d, %edx
movq %rax, (%rsp)
movl $0x70, 0x8(%rsp)
callq 0x80b0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x378ac
movl $0x28, %edi
callq 0x82f0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %edx
callq 0x378c0
jmp 0x3787e
movq -0x38(%rbp), %rdi
leaq 0x55ea7(%rip), %rsi     # 0x8d730
leaq 0x300(%rip), %rdx       # 0x37b90
callq 0x8920
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x8440
jmp 0x378b2
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x8970
nopl (%rax,%rax)
// File: VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::ostreambuf::ostreambuf(std::basic_streambuf<char, std::char_traits<char>>*, unsigned long, int)
ostreambuf(std::streambuf * _sbuf_p,
               std::size_t _buff_size = default_buff_size, int _level = Z_DEFAULT_COMPRESSION)
        : sbuf_p(_sbuf_p),
          zstrm_p(new detail::z_stream_wrapper(false, _level)),
          buff_size(_buff_size)
    {
        assert(sbuf_p);
        in_buff = new char [buff_size];
        out_buff = new char [buff_size];
        setp(in_buff, in_buff + buff_size);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x8160
movq -0x48(%rbp), %rax
leaq 0x55c71(%rip), %rcx     # 0x8da00
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x40(%rax)
addq $0x58, %rax
movq %rax, -0x40(%rbp)
movl $0x78, %edi
callq 0x8550
movq %rax, -0x38(%rbp)
jmp 0x37db2
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %edx
xorl %esi, %esi
callq 0x377b0
jmp 0x37dc2
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdx
movq %rdx, (%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, 0x60(%rax)
cmpq $0x0, 0x40(%rax)
je 0x37de2
jmp 0x37e2b
leaq 0x37822(%rip), %rdi     # 0x6f60b
leaq 0x37822(%rip), %rsi     # 0x6f612
movl $0xeb, %edx
leaq 0x37a08(%rip), %rcx     # 0x6f804
callq 0x83e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x37e80
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x78, %esi
callq 0x8560
jmp 0x37e80
movq -0x48(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x8040
movq %rax, -0x50(%rbp)
jmp 0x37e3e
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq 0x60(%rax), %rdi
callq 0x8040
movq %rax, -0x58(%rbp)
jmp 0x37e59
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rax
movq %rax, 0x50(%rdi)
movq 0x48(%rdi), %rsi
movq 0x60(%rdi), %rax
movq %rsi, %rdx
addq %rax, %rdx
callq 0x8880
jmp 0x37e7a
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x8a80
movq -0x28(%rbp), %rdi
callq 0x8970
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: VanAndelInstitute[P]intent/include/strict_fstream.hpp
// Function: strict_fstream::ofstream::open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::_Ios_Openmode)
void open(const std::string& filename, std::ios_base::openmode mode = std::ios_base::out)
    {
        mode |= std::ios_base::out;
        exceptions(std::ios_base::badbit);
        detail::static_method_holder::check_mode(filename, mode);
        std::ofstream::open(filename, mode);
        detail::static_method_holder::check_open(this, filename, mode);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x14(%rbp), %rdi
movl $0x10, %esi
callq 0x38110
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x1, %esi
callq 0x81d0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x38140
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x82e0
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x385a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: VanAndelInstitute[P]intent/include/strict_fstream.hpp
// Function: strict_fstream::detail::static_method_holder::mode_to_string[abi:cxx11](std::_Ios_Openmode)
static std::string mode_to_string(std::ios_base::openmode mode)
    {
        static const int n_modes = 6;
        static const std::ios_base::openmode mode_val_v[n_modes] =
            {
                std::ios_base::in,
                std::ios_base::out,
                std::ios_base::app,
                std::ios_base::ate,
                std::ios_base::trunc,
                std::ios_base::binary
            };

        static const char * mode_name_v[n_modes] =
            {
                "in",
                "out",
                "app",
                "ate",
                "trunc",
                "binary"
            };
        std::string res;
        for (int i = 0; i < n_modes; ++i)
        {
            if (mode & mode_val_v[i])
            {
                res += (! res.empty()? "|" : "");
                res += mode_name_v[i];
            }
        }
        if (res.empty()) res = "none";
        return res;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0x87c0
movl $0x0, -0x14(%rbp)
cmpl $0x6, -0x14(%rbp)
jge 0x38b1c
movl -0xc(%rbp), %edi
movslq -0x14(%rbp), %rcx
leaq 0x3773e(%rip), %rax     # 0x701e0
movl (%rax,%rcx,4), %esi
callq 0x38830
cmpl $0x0, %eax
je 0x38b0c
movq -0x38(%rbp), %rdi
callq 0x88f0
movq -0x38(%rbp), %rdi
movb %al, %cl
leaq 0x36a14(%rip), %rax     # 0x6f4d9
leaq 0x36de6(%rip), %rsi     # 0x6f8b2
testb %cl, %cl
cmovneq %rax, %rsi
callq 0x8520
jmp 0x38ad9
movq -0x38(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x55a78(%rip), %rax     # 0x8e560
movq (%rax,%rcx,8), %rsi
callq 0x8520
jmp 0x38af3
jmp 0x38b0c
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x8a98
jmp 0x38b5c
jmp 0x38b0e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x38a8a
movq -0x38(%rbp), %rdi
callq 0x88f0
testb $0x1, %al
jne 0x38b2b
jmp 0x38b3f
movq -0x38(%rbp), %rdi
leaq 0x36cc9(%rip), %rsi     # 0x6f7ff
callq 0x8790
jmp 0x38b3d
jmp 0x38b3f
movb $0x1, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
jne 0x38b52
movq -0x38(%rbp), %rdi
callq 0x8a98
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x8970
nopw %cs:(%rax,%rax)
nop
// File: VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::ostreambuf::~ostreambuf()
virtual ~ostreambuf()
    {
        // flush the zlib stream
        //
        // NOTE: Errors here (sync() return value not 0) are ignored, because we
        // cannot throw in a destructor. This mirrors the behaviour of
        // std::basic_filebuf::~basic_filebuf(). To see an exception on error,
        // close the ofstream with an explicit call to close(), and do not rely
        // on the implicit call in the destructor.
        //
        sync();
        delete [] in_buff;
        delete [] out_buff;
        delete zstrm_p;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0x54d85(%rip), %rax     # 0x8da00
movq %rax, (%rdi)
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
jmp 0x38c89
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x38ca4
movq -0x18(%rbp), %rdi
callq 0x8710
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x38cbf
movq -0x20(%rbp), %rdi
callq 0x8710
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x38ce8
movq -0x28(%rbp), %rdi
callq 0x37720
movq -0x28(%rbp), %rdi
movl $0x78, %esi
callq 0x8560
movq -0x10(%rbp), %rdi
callq 0x8a80
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x36cc0
nop
// File: VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::ostreambuf::sync()
virtual int sync()
    {
        // first, call overflow to clear in_buff
        overflow();
        if (! pptr()) return -1;
        // then, call deflate asking to finish the zlib stream
        zstrm_p->next_in = nullptr;
        zstrm_p->avail_in = 0;
        if (deflate_loop(Z_FINISH) != 0) return -1;
        deflateReset(zstrm_p);
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x37bd0
movq -0x18(%rbp), %rdi
movl %eax, %esi
movq (%rdi), %rax
callq *0x68(%rax)
movq -0x18(%rbp), %rdi
callq 0x8190
cmpq $0x0, %rax
jne 0x38d6d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x38db3
movq -0x18(%rbp), %rdi
movq 0x58(%rdi), %rax
movq $0x0, (%rax)
movq 0x58(%rdi), %rax
movl $0x0, 0x8(%rax)
movl $0x4, %esi
callq 0x38eb0
cmpl $0x0, %eax
je 0x38d9f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x38db3
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x87f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::ostreambuf::overflow(int)
virtual std::streambuf::int_type overflow(std::streambuf::int_type c = traits_type::eof())
    {
        zstrm_p->next_in = reinterpret_cast< decltype(zstrm_p->next_in) >(pbase());
        zstrm_p->avail_in = pptr() - pbase();
        while (zstrm_p->avail_in > 0)
        {
            int r = deflate_loop(Z_NO_FLUSH);
            if (r != 0)
            {
                setp(nullptr, nullptr);
                return traits_type::eof();
            }
        }
        setp(in_buff, in_buff + buff_size);
        return traits_type::eq_int_type(c, traits_type::eof()) ? traits_type::eof() : sputc(c);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x81c0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movq 0x58(%rdi), %rax
movq %rcx, (%rax)
callq 0x8190
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x81c0
movq -0x30(%rbp), %rcx
movq %rax, %rdx
movq -0x28(%rbp), %rax
subq %rdx, %rcx
movq 0x58(%rax), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x0, 0x8(%rax)
jbe 0x38e4f
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x38eb0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x38e4d
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x8880
callq 0x37bd0
movl %eax, -0x4(%rbp)
jmp 0x38ea1
jmp 0x38e11
movq -0x28(%rbp), %rdi
movq 0x48(%rdi), %rsi
movq 0x48(%rdi), %rdx
addq 0x60(%rdi), %rdx
callq 0x8880
callq 0x37bd0
movl %eax, -0x1c(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x38fe0
testb $0x1, %al
jne 0x38e7f
jmp 0x38e89
callq 0x37bd0
movl %eax, -0x34(%rbp)
jmp 0x38e9b
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movsbl %al, %esi
callq 0x8250
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::ostreambuf::deflate_loop(int)
int deflate_loop(int flush)
    {
        while (true)
        {
            zstrm_p->next_out = reinterpret_cast< decltype(zstrm_p->next_out) >(out_buff);
            zstrm_p->avail_out = buff_size;
            int ret = deflate(zstrm_p, flush);
            if (ret != Z_OK && ret != Z_STREAM_END && ret != Z_BUF_ERROR) throw Exception(zstrm_p, ret);
            std::streamsize sz = sbuf_p->sputn(out_buff, reinterpret_cast< decltype(out_buff) >(zstrm_p->next_out) - out_buff);
            if (sz != reinterpret_cast< decltype(out_buff) >(zstrm_p->next_out) - out_buff)
            {
                // there was an error in the sink stream
                return -1;
            }
            if (ret == Z_STREAM_END || ret == Z_BUF_ERROR || sz == 0)
            {
                break;
            }
        }
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rdx
movq 0x58(%rax), %rcx
movq %rdx, 0x18(%rcx)
movq 0x60(%rax), %rcx
movl %ecx, %edx
movq 0x58(%rax), %rcx
movl %edx, 0x20(%rcx)
movq 0x58(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x82d0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x38f59
cmpl $0x1, -0x18(%rbp)
je 0x38f59
cmpl $-0x5, -0x18(%rbp)
je 0x38f59
movl $0x28, %edi
callq 0x82f0
movq %rax, %rdi
movq -0x38(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x40(%rbp)
movq 0x58(%rax), %rsi
movl -0x18(%rbp), %edx
callq 0x378c0
jmp 0x38f2b
movq -0x40(%rbp), %rdi
leaq 0x547fa(%rip), %rsi     # 0x8d730
leaq -0x13ad(%rip), %rdx     # 0x37b90
callq 0x8920
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x8440
jmp 0x38fcc
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rdi
movq 0x50(%rax), %rsi
movq 0x58(%rax), %rcx
movq 0x18(%rcx), %rdx
movq 0x50(%rax), %rax
subq %rax, %rdx
callq 0x8840
movq -0x38(%rbp), %rdx
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x58(%rdx), %rcx
movq 0x18(%rcx), %rcx
movq 0x50(%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
je 0x38fa2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x38fc3
cmpl $0x1, -0x18(%rbp)
je 0x38fb5
cmpl $-0x5, -0x18(%rbp)
je 0x38fb5
cmpq $0x0, -0x30(%rbp)
jne 0x38fb7
jmp 0x38fbc
jmp 0x38ec7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x8970
nopw %cs:(%rax,%rax)
nop
// File: VanAndelInstitute[P]intent/src/edlib.cpp
// Function: createReverseCopy(unsigned char const*, int)
static inline unsigned char* createReverseCopy(const unsigned char* const seq, const int length) {
    unsigned char* rSeq = new unsigned char[length];
    for (int i = 0; i < length; i++) {
        rSeq[i] = seq[length - i - 1];
    }
    return rSeq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
callq 0x8040
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x66ef4
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x66ec3
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: VanAndelInstitute[P]intent/src/edlib.cpp
// Function: edlibNewAlignConfig
EdlibAlignConfig edlibNewAlignConfig(int k, EdlibAlignMode mode, EdlibAlignTask task,
                                                EdlibEqualityPair* additionalEqualities,
                                                int additionalEqualitiesLength) {
    EdlibAlignConfig config;
    config.k = k;
    config.mode = mode;
    config.task = task;
    config.additionalEqualities = additionalEqualities;
    config.additionalEqualitiesLength = additionalEqualitiesLength;
    return config;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movq %r8, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl -0x4(%rbp), %ecx
movl %ecx, (%rdi)
movl -0x8(%rbp), %ecx
movl %ecx, 0x4(%rdi)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rdi)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rdi)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x18(%rdi)
popq %rbp
retq
nopl (%rax)
// File: VanAndelInstitute[P]intent/src/edlib.cpp
// Function: calculateBlock(unsigned long, unsigned long, unsigned long, int, unsigned long&, unsigned long&)
static inline int calculateBlock(Word Pv, Word Mv, Word Eq, const int hin,
                                 Word &PvOut, Word &MvOut) {
    // hin can be 1, -1 or 0.
    // 1  -> 00...01
    // 0  -> 00...00
    // -1 -> 11...11 (2-complement)

    Word hinIsNeg = static_cast<Word>(hin >> 2) & WORD_1; // 00...001 if hin is -1, 00...000 if 0 or 1

    Word Xv = Eq | Mv;
    // This is instruction below written using 'if': if (hin < 0) Eq |= (Word)1;
    Eq |= hinIsNeg;
    Word Xh = (((Eq & Pv) + Pv) ^ Pv) | Eq;

    Word Ph = Mv | ~(Xh | Pv);
    Word Mh = Pv & Xh;

    int hout = 0;
    // This is instruction below written using 'if': if (Ph & HIGH_BIT_MASK) hout = 1;
    hout = (Ph & HIGH_BIT_MASK) >> (WORD_SIZE - 1);
    // This is instruction below written using 'if': if (Mh & HIGH_BIT_MASK) hout = -1;
    hout -= (Mh & HIGH_BIT_MASK) >> (WORD_SIZE - 1);

    Ph <<= 1;
    Mh <<= 1;

    // This is instruction below written using 'if': if (hin < 0) Mh |= (Word)1;
    Mh |= hinIsNeg;
    // This is instruction below written using 'if': if (hin > 0) Ph |= (Word)1;
    Ph |= static_cast<Word>((hin + 1) >> 1);

    PvOut = Mh | ~(Xv | Ph);
    MvOut = Ph & Xv;

    return hout;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x1c(%rbp), %eax
sarl $0x2, %eax
cltq
andq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
orq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq -0x8(%rbp), %rax
addq -0x8(%rbp), %rax
xorq -0x8(%rbp), %rax
orq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
orq -0x8(%rbp), %rcx
xorq $-0x1, %rcx
orq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
andq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq -0x50(%rbp), %rax
shrq $0x3f, %rax
movl %eax, -0x5c(%rbp)
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
andq -0x58(%rbp), %rcx
shrq $0x3f, %rcx
movslq -0x5c(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x5c(%rbp)
movq -0x50(%rbp), %rax
shlq %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
shlq %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
orq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
sarl %eax
cltq
orq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rcx
movq -0x40(%rbp), %rax
orq -0x50(%rbp), %rax
xorq $-0x1, %rax
orq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
andq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0x5c(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: VanAndelInstitute[P]intent/src/edlib.cpp
// Function: allBlockCellsLarger(Block, int)
static inline bool allBlockCellsLarger(const Block block, const int k) {
    vector<int> scores = getBlockCellValues(block);
    for (int i = 0; i < WORD_SIZE; i++) {
        if (scores[i] <= k) return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movl %edi, -0x8(%rbp)
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x67690
movl $0x0, -0x3c(%rbp)
cmpl $0x40, -0x3c(%rbp)
jge 0x67667
movslq -0x3c(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x69140
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jg 0x6765a
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x67672
jmp 0x6765c
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x67633
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x36b20
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: VanAndelInstitute[P]intent/src/edlib.cpp
// Function: getBlockCellValues(Block)
static inline vector<int> getBlockCellValues(const Block block) {
    vector<int> scores(WORD_SIZE);
    int score = block.score;
    Word mask = HIGH_BIT_MASK;
    for (int i = 0; i < WORD_SIZE - 1; i++) {
        scores[i] = score;
        if (block.P & mask) score--;
        if (block.M & mask) score++;
        mask >>= 1;
    }
    scores[WORD_SIZE - 1] = score;
    return scores;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0xa(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x39050
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movl $0x40, %esi
callq 0x69ad0
jmp 0x676d4
leaq -0xa(%rbp), %rdi
callq 0x642f0
movq -0x48(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x20(%rbp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x3f, -0x2c(%rbp)
jge 0x67788
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x54(%rbp)
movslq -0x2c(%rbp), %rsi
callq 0x69140
movl -0x54(%rbp), %edx
movq %rax, %rcx
movq -0x48(%rbp), %rax
movl %edx, (%rcx)
movq (%rax), %rax
andq -0x28(%rbp), %rax
cmpq $0x0, %rax
je 0x67754
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x67754
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xa(%rbp), %rdi
callq 0x642f0
jmp 0x677be
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
andq -0x28(%rbp), %rax
cmpq $0x0, %rax
je 0x6776f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x28(%rbp), %rax
shrq %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x676fc
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x58(%rbp)
movl $0x3f, %esi
callq 0x69140
movl -0x58(%rbp), %ecx
movl %ecx, (%rax)
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x677b4
movq -0x40(%rbp), %rdi
callq 0x36b20
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8970
nopw (%rax,%rax)
// File: VanAndelInstitute[P]intent/src/edlib.cpp
// Function: readBlock(Block, int*)
static inline void readBlock(const Block block, int* const dest) {
    int score = block.score;
    Word mask = HIGH_BIT_MASK;
    for (int i = 0; i < WORD_SIZE - 1; i++) {
        dest[WORD_SIZE - 1 - i] = score;
        if (block.P & mask) score--;
        if (block.M & mask) score++;
        mask >>= 1;
    }
    dest[0] = score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0xc(%rbp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3f, -0x1c(%rbp)
jge 0x68c21
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rcx
movl $0x3f, %edx
subl -0x1c(%rbp), %edx
movslq %edx, %rdx
movl %esi, (%rcx,%rdx,4)
movq (%rax), %rax
andq -0x18(%rbp), %rax
cmpq $0x0, %rax
je 0x68bf0
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
andq -0x18(%rbp), %rax
cmpq $0x0, %rax
je 0x68c0b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
shrq %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x68bbb
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: VanAndelInstitute[P]intent/src/edlib.cpp
// Function: readBlockReverse(Block, int*)
static inline void readBlockReverse(const Block block, int* const dest) {
    int score = block.score;
    Word mask = HIGH_BIT_MASK;
    for (int i = 0; i < WORD_SIZE - 1; i++) {
        dest[i] = score;
        if (block.P & mask) score--;
        if (block.M & mask) score++;
        mask >>= 1;
    }
    dest[WORD_SIZE - 1] = score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0xc(%rbp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3f, -0x1c(%rbp)
jge 0x68cba
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movq (%rax), %rax
andq -0x18(%rbp), %rax
cmpq $0x0, %rax
je 0x68c89
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
andq -0x18(%rbp), %rax
cmpq $0x0, %rax
je 0x68ca4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
shrq %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x68c5b
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xfc(%rax)
popq %rbp
retq
nopl (%rax)
// File: VanAndelInstitute[P]intent/src/edlib.cpp
// Function: EqualityDefinition::EqualityDefinition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, EdlibEqualityPair const*, int)
EqualityDefinition(const string& alphabet,
                       const EdlibEqualityPair* additionalEqualities = NULL,
                       const int additionalEqualitiesLength = 0) {
        for (int i = 0; i < static_cast<int>(alphabet.size()); i++) {
            for (int j = 0; j < static_cast<int>(alphabet.size()); j++) {
                matrix[i][j] = (i == j);
            }
        }
        if (additionalEqualities != NULL) {
            for (int i = 0; i < additionalEqualitiesLength; i++) {
                size_t firstTransformed = alphabet.find(additionalEqualities[i].first);
                size_t secondTransformed = alphabet.find(additionalEqualities[i].second);
                if (firstTransformed != string::npos && secondTransformed != string::npos) {
                    matrix[firstTransformed][secondTransformed] = matrix[secondTransformed][firstTransformed] = true;
                }
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8410
movq %rax, %rcx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jge 0x68da9
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8410
movq %rax, %rcx
movl -0x48(%rbp), %eax
cmpl %ecx, %eax
jge 0x68d9c
movq -0x40(%rbp), %rax
movl -0x20(%rbp), %ecx
cmpl -0x24(%rbp), %ecx
sete %dl
movslq -0x20(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movslq -0x24(%rbp), %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x68d56
jmp 0x68d9e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x68d36
cmpq $0x0, -0x18(%rbp)
je 0x68e4b
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x68e49
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
xorl %edx, %edx
movsbl (%rax,%rcx,2), %esi
callq 0x8730
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
xorl %edx, %edx
movsbl 0x1(%rax,%rcx,2), %esi
callq 0x8730
movq %rax, -0x38(%rbp)
cmpq $-0x1, -0x30(%rbp)
je 0x68e39
cmpq $-0x1, -0x38(%rbp)
je 0x68e39
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdx
shlq $0x8, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq -0x30(%rbp), %rdx
movb $0x1, (%rcx,%rdx)
movq -0x30(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movq -0x38(%rbp), %rcx
movb $0x1, (%rax,%rcx)
jmp 0x68e3b
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x68dbb
jmp 0x68e4b
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: VanAndelInstitute[P]intent/src/edlib.cpp
// Function: AlignmentData::~AlignmentData()
~AlignmentData() {
        delete[] Ps;
        delete[] Ms;
        delete[] scores;
        delete[] firstBlocks;
        delete[] lastBlocks;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x68e8a
movq -0x10(%rbp), %rdi
callq 0x8710
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x68ea5
movq -0x20(%rbp), %rdi
callq 0x8710
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x68ec0
movq -0x28(%rbp), %rdi
callq 0x8710
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x68edb
movq -0x30(%rbp), %rdi
callq 0x8710
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x68ef6
movq -0x38(%rbp), %rdi
callq 0x8710
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)