LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: (anonymous namespace)::remove_all_aux(boost::filesystem::path const&, boost::filesystem::file_type, boost::system::error_code*)
boost::uintmax_t remove_all_aux(const path& p, fs::file_type type,
    error_code* ec)
  {
    boost::uintmax_t count = 1;

    if (type == fs::directory_file)  // but not a directory symlink
    {
      for (fs::directory_iterator itr(p);
            itr != end_dir_itr; ++itr)
      {
        fs::file_type tmp_type = query_file_type(itr->path(), ec);
        if (ec != 0 && *ec)
          return count;
        count += remove_all_aux(itr->path(), tmp_type, ec);
      }
    }
    remove_file_or_directory(p, type, ec);
    return count;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
cmpl $0x3, -0x14(%rbp)
jne 0x4b7cb
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x4ecf0
leaq 0x430cc(%rip), %rsi     # 0x8e798
leaq -0x38(%rbp), %rdi
callq 0x4f1f0
movb %al, -0x4d(%rbp)
jmp 0x4b6da
movb -0x4d(%rbp), %al
testb $0x1, %al
jne 0x4b709
jmp 0x4b6e3
movl $0x2, -0x48(%rbp)
jmp 0x4b7b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4d480
jmp 0x4b7f0
leaq -0x38(%rbp), %rdi
callq 0x4f220
movq %rax, -0x58(%rbp)
jmp 0x4b718
movq -0x58(%rbp), %rdi
callq 0x4e080
movq %rax, -0x60(%rbp)
jmp 0x4b727
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4b2e0
movl %eax, -0x64(%rbp)
jmp 0x4b739
movl -0x64(%rbp), %eax
movl %eax, -0x4c(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4b766
movq -0x20(%rbp), %rdi
callq 0x4d830
cmpq $0x0, %rax
je 0x4b766
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x4b7b6
leaq -0x38(%rbp), %rdi
callq 0x4f220
movq %rax, -0x70(%rbp)
jmp 0x4b775
movq -0x70(%rbp), %rdi
callq 0x4e080
movq %rax, -0x78(%rbp)
jmp 0x4b784
movq -0x78(%rbp), %rdi
movl -0x4c(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x4b690
movq %rax, -0x80(%rbp)
jmp 0x4b79a
movq -0x80(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4f250
jmp 0x4b7b1
jmp 0x4b6c5
leaq -0x38(%rbp), %rdi
callq 0x4d480
movl -0x48(%rbp), %eax
subl $0x1, %eax
je 0x4b7e3
jmp 0x4b7c9
jmp 0x4b7cb
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x4b310
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xdb30
nopl (%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::space(boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  space_info space(const path& p, error_code* ec)
  {
#   ifdef BOOST_POSIX_API
    struct BOOST_STATVFS vfs;
    space_info info;
    if (!error(::BOOST_STATVFS(p.c_str(), &vfs)!= 0,
      p, ec, "boost::filesystem::space"))
    {
      info.capacity 
        = static_cast<boost::uintmax_t>(vfs.f_blocks)* BOOST_STATVFS_F_FRSIZE;
      info.free 
        = static_cast<boost::uintmax_t>(vfs.f_bfree)* BOOST_STATVFS_F_FRSIZE;
      info.available
        = static_cast<boost::uintmax_t>(vfs.f_bavail)* BOOST_STATVFS_F_FRSIZE;
    }

#   else
    ULARGE_INTEGER avail, total, free;
    space_info info;

    if (!error(::GetDiskFreeSpaceExW(p.c_str(), &avail, &total, &free)== 0,
       p, ec, "boost::filesystem::space"))
    {
      info.capacity
        = (static_cast<boost::uintmax_t>(total.HighPart)<< 32)
          + total.LowPart;
      info.free
        = (static_cast<boost::uintmax_t>(free.HighPart)<< 32)
          + free.LowPart;
      info.available
        = (static_cast<boost::uintmax_t>(avail.HighPart)<< 32)
          + avail.LowPart;
    }

#   endif

    else
    {
      info.capacity = info.free = info.available = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xe8(%rbp)
movq %rdi, -0xe0(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4dc70
movq %rax, %rdi
leaq -0x80(%rbp), %rsi
callq 0xd9f0
testl %eax, %eax
setne %al
movzbl %al, %eax
movl %eax, -0xd4(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xdb50
movq -0xc0(%rbp), %rdx
leaq 0x17562(%rip), %rsi     # 0x62fcd
leaq -0xa0(%rbp), %rdi
callq 0xd8b0
jmp 0x4ba79
movq -0xc8(%rbp), %rdx
movq -0xd0(%rbp), %rsi
movl -0xd4(%rbp), %edi
leaq -0xa0(%rbp), %rcx
callq 0x4a0b0
movb %al, -0xe9(%rbp)
jmp 0x4baa1
movb -0xe9(%rbp), %al
xorb $-0x1, %al
movb %al, -0xea(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xdca8
leaq -0xa1(%rbp), %rdi
callq 0xd6b0
movb -0xea(%rbp), %al
testb $0x1, %al
jne 0x4bad3
jmp 0x4bb42
movq -0xe8(%rbp), %rax
movq -0x70(%rbp), %rcx
imulq -0x78(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
imulq -0x78(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x60(%rbp), %rcx
imulq -0x78(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x4bb60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x4bb34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xdca8
leaq -0xa1(%rbp), %rdi
callq 0xd6b0
jmp 0x4bb70
movq -0xe8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq $0x0, 0x8(%rax)
movq $0x0, (%rax)
movq -0xe0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0xdb30
nopl (%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::system_complete(boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  path system_complete(const path& p, system::error_code* ec)
  {
#   ifdef BOOST_POSIX_API
    return (p.empty() || p.is_absolute())
      ? p : current_path()/ p;

#   else
    if (p.empty())
    {
      if (ec != 0) ec->clear();
      return p;
    }
    wchar_t buf[buf_size];
    wchar_t* pfn;
    std::size_t len = get_full_path_name(p, buf_size, buf, &pfn);

    if (error(len == 0 ? BOOST_ERRNO : 0, p, ec, "boost::filesystem::system_complete"))
      return path();

    if (len < buf_size)// len does not include null termination character
      return path(&buf[0]);

    boost::scoped_array<wchar_t> big_buf(new wchar_t[len]);

    return error(get_full_path_name(p, len , big_buf.get(), &pfn)== 0 ? BOOST_ERRNO : 0,
      p, ec, "boost::filesystem::system_complete")
      ? path()
      : path(big_buf.get());
#   endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4d570
movb $0x0, -0x39(%rbp)
testb $0x1, %al
jne 0x4c15f
movq -0x10(%rbp), %rdi
callq 0x4d4d0
testb $0x1, %al
jne 0x4c15f
jmp 0x4c16e
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4d4f0
jmp 0x4c198
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x49d00
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
movb $0x1, -0x39(%rbp)
movq -0x10(%rbp), %rdx
callq 0x4d590
jmp 0x4c196
jmp 0x4c198
testb $0x1, -0x39(%rbp)
jne 0x4c1a0
jmp 0x4c1a9
leaq -0x38(%rbp), %rdi
callq 0x4d550
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x4c1c7
jmp 0x4c1d0
leaq -0x38(%rbp), %rdi
callq 0x4d550
jmp 0x4c1d2
movq -0x48(%rbp), %rdi
callq 0xdb30
nopl (%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::directory_entry::m_get_status(boost::system::error_code*) const
file_status
  directory_entry::m_get_status(system::error_code* ec) const
  {
    if (!status_known(m_status))
    {
      // optimization: if the symlink status is known, and it isn't a symlink,
      // then status and symlink_status are identical so just copy the
      // symlink status to the regular status.
      if (status_known(m_symlink_status)
        && !is_symlink(m_symlink_status))
      { 
        m_status = m_symlink_status;
        if (ec != 0) ec->clear();
      }
      else m_status = detail::status(m_path, ec);
    }
    else if (ec != 0) ec->clear();
    return m_status;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4e030
testb $0x1, %al
jne 0x4c281
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4e030
testb $0x1, %al
jne 0x4c228
jmp 0x4c25f
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4d950
testb $0x1, %al
jne 0x4c25f
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rcx
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x4c25d
movq -0x18(%rbp), %rdi
callq 0x4d9e0
jmp 0x4c27f
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4bb80
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x4c293
cmpq $0x0, -0x18(%rbp)
je 0x4c291
movq -0x18(%rbp), %rdi
callq 0x4d9e0
jmp 0x4c293
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::directory_entry::m_get_symlink_status(boost::system::error_code*) const
file_status
  directory_entry::m_get_symlink_status(system::error_code* ec) const
  {
    if (!status_known(m_symlink_status))
      m_symlink_status = detail::symlink_status(m_path, ec);
    else if (ec != 0) ec->clear();
    return m_symlink_status;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4e030
testb $0x1, %al
jne 0x4c2ff
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x483e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x28(%rax)
jmp 0x4c311
cmpq $0x0, -0x18(%rbp)
je 0x4c30f
movq -0x18(%rbp), %rdi
callq 0x4d9e0
jmp 0x4c311
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: (anonymous namespace)::dir_itr_first(void*&, void*&, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, boost::filesystem::file_status&, boost::filesystem::file_status&)
error_code dir_itr_first(void *& handle, void *& buffer,
    const char* dir, string& target,
    fs::file_status &, fs::file_status &)
  {
    if ((handle = ::opendir(dir))== 0)
      return error_code(errno, system_category());
    target = string(".");  // string was static but caused trouble
                             // when iteration called from dtor, after
                             // static had already been destroyed
    std::size_t path_size (0);  // initialization quiets gcc warning (ticket #3509)
    error_code ec = path_max(path_size);
    if (ec)return ec;
    dirent de;
    buffer = std::malloc((sizeof(dirent) - sizeof(de.d_name))
      +  path_size + 1); // + 1 for "/0"
    return ok;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0xd9c0
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x4c962
callq 0xd070
movl (%rax), %eax
movl %eax, -0x1ac(%rbp)
callq 0x53ec0
movl -0x1ac(%rbp), %esi
movq %rax, %rdx
leaq -0x10(%rbp), %rdi
callq 0x4d680
jmp 0x4ca3a
leaq -0x61(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0xdb50
movq -0x1b8(%rbp), %rdx
leaq 0x16ec6(%rip), %rsi     # 0x63846
leaq -0x60(%rbp), %rdi
callq 0xd8b0
jmp 0x4c98b
movq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xd790
leaq -0x60(%rbp), %rdi
callq 0xdca8
leaq -0x61(%rbp), %rdi
callq 0xd6b0
movq $0x0, -0x80(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x4d1a0
movl %eax, -0x90(%rbp)
movq %rdx, -0x88(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4d830
cmpq $0x0, %rax
je 0x4ca09
movq -0x90(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4ca3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x61(%rbp), %rdi
callq 0xd6b0
jmp 0x4ca4a
movq -0x80(%rbp), %rdi
addq $0x18, %rdi
addq $0x1, %rdi
callq 0xd880
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq 0x41d7d(%rip), %rax     # 0x8e7a8
movq %rax, -0x10(%rbp)
movq 0x41d7a(%rip), %rax     # 0x8e7b0
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: (anonymous namespace)::path_max(unsigned long&)
error_code path_max(std::size_t & result)
  // this code is based on Stevens and Rago, Advanced Programming in the
  // UNIX envirnment, 2nd Ed., ISBN 0-201-43307-9, page 49
  {
#   ifdef PATH_MAX
    static std::size_t max = PATH_MAX;
#   else
    static std::size_t max = 0;
#   endif
    if (max == 0)
    {
      errno = 0;
      long tmp = ::pathconf("/", _PC_NAME_MAX);
      if (tmp < 0)
      {
        if (errno == 0)// indeterminate
          max = 4096; // guess
        else return error_code(errno, system_category());
      }
      else max = static_cast<std::size_t>(tmp + 1); // relative root
    }
    result = max;
    return ok;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
cmpq $0x0, 0x414cc(%rip)     # 0x8e680
jne 0x4d227
callq 0xd070
movl $0x0, (%rax)
leaq 0x14e88(%rip), %rdi     # 0x62050
movl $0x3, %esi
callq 0xda20
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x4d216
callq 0xd070
cmpl $0x0, (%rax)
jne 0x4d1f4
movq $0x1000, 0x4148e(%rip) # imm = 0x1000
jmp 0x4d214
callq 0xd070
movl (%rax), %eax
movl %eax, -0x24(%rbp)
callq 0x53ec0
movl -0x24(%rbp), %esi
movq %rax, %rdx
leaq -0x10(%rbp), %rdi
callq 0x4d680
jmp 0x4d24b
jmp 0x4d225
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, 0x4145b(%rip)     # 0x8e680
jmp 0x4d227
movq 0x41452(%rip), %rcx     # 0x8e680
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq 0x4156c(%rip), %rax     # 0x8e7a8
movq %rax, -0x10(%rbp)
movq 0x41569(%rip), %rax     # 0x8e7b0
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: (anonymous namespace)::readdir_r_simulator(__dirstream*, dirent*, dirent**)
inline int readdir_r_simulator(DIR * dirp, struct dirent * entry,
    struct dirent ** result)// *result set to 0 on end of directory
  {
    errno = 0;

#   if !defined(__CYGWIN__)\
    && defined(_POSIX_THREAD_SAFE_FUNCTIONS)\
    && defined(_SC_THREAD_SAFE_FUNCTIONS)\
    && (_POSIX_THREAD_SAFE_FUNCTIONS+0 >= 0)\
    && (!defined(__hpux) || defined(_REENTRANT)) \
    && (!defined(_AIX) || defined(__THREAD_SAFE))
    if (::sysconf(_SC_THREAD_SAFE_FUNCTIONS)>= 0)
      { return ::readdir_r(dirp, entry, result); }
#   endif

    struct dirent * p;
    *result = 0;
    if ((p = ::readdir(dirp))== 0)
      return errno;
    std::strcpy(entry->d_name, p->d_name);
    *result = entry;
    return 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
callq 0xd070
movl $0x0, (%rax)
movl $0x44, %edi
callq 0xd3f0
cmpq $0x0, %rax
jl 0x4d2a5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xd1b0
movl %eax, -0x4(%rbp)
jmp 0x4d2f6
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0xd360
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x4d2cf
callq 0xd070
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4d2f6
movq -0x18(%rbp), %rdi
addq $0x13, %rdi
movq -0x28(%rbp), %rsi
addq $0x13, %rsi
callq 0xd5b0
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: demon386[P]git-store/./boost/system/system_error.hpp
// Function: boost::system::system_error::what() const
inline const char * system_error::what() const throw()
    // see http://www.boost.org/more/error_handling.html for lazy build rationale
    {
      if ( m_what.empty() )
      {
#ifndef BOOST_NO_EXCEPTIONS
        try
#endif
        {
          m_what = this->std::runtime_error::what();
          if ( !m_what.empty() ) m_what += ": ";
          m_what += m_error_code.message();
        }
#ifndef BOOST_NO_EXCEPTIONS
        catch (...) { return std::runtime_error::what(); }
#endif
      }
      return m_what.c_str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x20, %rdi
callq 0xdab0
testb $0x1, %al
jne 0x4d326
jmp 0x4d3f4
movq -0x48(%rbp), %rdi
callq 0xd8d0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rdi
callq 0xd8a0
jmp 0x4d341
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0xdab0
testb $0x1, %al
jne 0x4d378
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
leaq 0x16de8(%rip), %rsi     # 0x64149
callq 0xd5f0
jmp 0x4d368
jmp 0x4d378
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x4d3be
movq -0x48(%rbp), %rsi
addq $0x10, %rsi
leaq -0x40(%rbp), %rdi
callq 0x4d410
jmp 0x4d38b
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
leaq -0x40(%rbp), %rsi
callq 0xd800
jmp 0x4d39e
leaq -0x40(%rbp), %rdi
callq 0xdca8
jmp 0x4d3f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xdca8
movq -0x18(%rbp), %rdi
callq 0xd200
movq -0x48(%rbp), %rdi
callq 0xd8d0
movq %rax, -0x8(%rbp)
callq 0xda90
jmp 0x4d3db
jmp 0x4d405
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd810
jmp 0x4d3f4
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0xd210
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: demon386[P]git-store/./boost/filesystem/operations.hpp
// Function: boost::filesystem::filesystem_error::filesystem_error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, boost::filesystem::path const&, boost::system::error_code)
filesystem_error(
        const std::string & what_arg, const path& path1_arg,
        system::error_code ec) BOOST_NOEXCEPT
        : system::system_error(ec, what_arg)
      {
        try
        {
          m_imp_ptr.reset(new m_imp);
          m_imp_ptr->m_path1 = path1_arg;
        }
        catch (...) { m_imp_ptr.reset(); }
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %ecx, -0x10(%rbp)
movq %r8, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rcx
movl -0x40(%rbp), %esi
movq -0x38(%rbp), %rdx
callq 0x4e3a0
jmp 0x4d6f0
movq -0x58(%rbp), %rdi
leaq 0x3fead(%rip), %rax     # 0x8d5a8
movq %rax, (%rdi)
addq $0x40, %rdi
movq %rdi, -0x68(%rbp)
callq 0x4e400
movl $0x60, %edi
callq 0xd630
movq %rax, -0x60(%rbp)
jmp 0x4d71b
movq -0x60(%rbp), %rdi
callq 0x4e4c0
jmp 0x4d726
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x4e430
jmp 0x4d735
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x40, %rdi
callq 0x4e520
movq %rax, -0x70(%rbp)
jmp 0x4d750
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x4d9b0
jmp 0x4d75f
jmp 0x4d7a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4d784
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0xd5c0
movq -0x48(%rbp), %rdi
callq 0xd200
movq -0x58(%rbp), %rdi
addq $0x40, %rdi
callq 0x4e570
callq 0xda90
jmp 0x4d7a1
jmp 0x4d7a3
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x129b0
nopw %cs:(%rax,%rax)
nop
// File: demon386[P]git-store/./boost/filesystem/operations.hpp
// Function: boost::filesystem::filesystem_error::filesystem_error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, boost::filesystem::path const&, boost::filesystem::path const&, boost::system::error_code)
filesystem_error(
        const std::string & what_arg, const path& path1_arg,
        const path& path2_arg, system::error_code ec) BOOST_NOEXCEPT
        : system::system_error(ec, what_arg)
      {
        try
        {
          m_imp_ptr.reset(new m_imp);
          m_imp_ptr->m_path1 = path1_arg;
          m_imp_ptr->m_path2 = path2_arg;
        }
        catch (...) { m_imp_ptr.reset(); }
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %r8d, -0x10(%rbp)
movq %r9, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rcx
movl -0x40(%rbp), %esi
movq -0x38(%rbp), %rdx
callq 0x4e3a0
jmp 0x4db85
movq -0x58(%rbp), %rdi
leaq 0x3fa18(%rip), %rax     # 0x8d5a8
movq %rax, (%rdi)
addq $0x40, %rdi
movq %rdi, -0x68(%rbp)
callq 0x4e400
movl $0x60, %edi
callq 0xd630
movq %rax, -0x60(%rbp)
jmp 0x4dbb0
movq -0x60(%rbp), %rdi
callq 0x4e4c0
jmp 0x4dbbb
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x4e430
jmp 0x4dbca
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x40, %rdi
callq 0x4e520
movq -0x70(%rbp), %rsi
movq %rax, %rdi
callq 0x4d9b0
jmp 0x4dbed
movq -0x58(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x40, %rdi
callq 0x4e520
movq -0x78(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rdi
callq 0x4d9b0
jmp 0x4dc14
jmp 0x4dc58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4dc39
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0xd5c0
movq -0x48(%rbp), %rdi
callq 0xd200
movq -0x58(%rbp), %rdi
addq $0x40, %rdi
callq 0x4e570
callq 0xda90
jmp 0x4dc56
jmp 0x4dc58
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x129b0
nopl (%rax)
// File: demon386[P]git-store/./boost/filesystem/path.hpp
// Function: boost::filesystem::path& boost::filesystem::path::assign<char*>(char*, char*)
path& assign(InputIterator begin, InputIterator end)
    {
      m_pathname.clear();
      if (begin != end)
      {
        std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
          seq(begin, end);
        path_traits::convert(seq.c_str(), seq.c_str()+seq.size(), m_pathname);
      }
      return *this;
    }

// 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, -0x58(%rbp)
callq 0xd860
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x4df4e
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xdb50
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0x4f590
jmp 0x4dec6
leaq -0x39(%rbp), %rdi
callq 0xd6b0
leaq -0x38(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xd210
movq -0x88(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0xd210
movq -0x88(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0xd430
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdi
movq -0x58(%rbp), %rdx
addq %rax, %rsi
callq 0x4f600
jmp 0x4df15
leaq -0x38(%rbp), %rdi
callq 0xdca8
jmp 0x4df4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xd6b0
jmp 0x4df5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xdca8
jmp 0x4df5b
movq -0x58(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
nop
// File: demon386[P]git-store/./boost/filesystem/operations.hpp
// Function: boost::filesystem::directory_entry::replace_filename(boost::filesystem::path const&, boost::filesystem::file_status, boost::filesystem::file_status)
void replace_filename(const boost::filesystem::path& p,
    file_status st = file_status(), file_status symlink_st = file_status())
  {
    m_path.remove_filename();
    m_path /= p;
    m_status = st;
    m_symlink_status = symlink_st;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x50140
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4f990
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: demon386[P]git-store/./boost/filesystem/operations.hpp
// Function: boost::filesystem::detail::dir_itr_imp::~dir_itr_imp()
~dir_itr_imp() // never throws
    {
      dir_itr_close(handle
#       if defined(BOOST_POSIX_API)
         , buffer
#       endif
    );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
movq %rsi, %rdi
addq $0x30, %rdi
addq $0x38, %rsi
callq 0x4c3b0
movq %rdx, -0x28(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x4f19d
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movq %rax, -0x10(%rbp)
callq 0x4f1d0
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x129b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::operator/=(boost::filesystem::path const&)
path& path::operator/=(const path& p)
  {
    if (p.empty())
      return *this;
    if (this == &p)  // self-append
    {
      path rhs(p);
      if (!is_separator(rhs.m_pathname[0]))
        m_append_separator_if_needed();
      m_pathname += rhs.m_pathname;
    }
    else
    {
      if (!is_separator(*p.m_pathname.begin()))
        m_append_separator_if_needed();
      m_pathname += p.m_pathname;
    }
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4d570
testb $0x1, %al
jne 0x4f9b7
jmp 0x4f9c4
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4fa8e
movq -0x58(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x4fa4a
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4d4f0
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdc50
movq %rax, -0x60(%rbp)
jmp 0x4f9f2
movq -0x60(%rbp), %rax
movsbl (%rax), %edi
callq 0x4fab0
movb %al, -0x69(%rbp)
jmp 0x4fa03
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x4fa30
jmp 0x4fa0c
movq -0x58(%rbp), %rdi
callq 0x4fad0
jmp 0x4fa17
jmp 0x4fa30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4d550
jmp 0x4fa98
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd800
jmp 0x4fa3f
leaq -0x38(%rbp), %rdi
callq 0x4d550
jmp 0x4fa86
movq -0x18(%rbp), %rdi
callq 0xd5e0
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2a440
movsbl (%rax), %edi
callq 0x4fab0
xorb $-0x1, %al
testb $0x1, %al
jne 0x4fa70
jmp 0x4fa79
movq -0x58(%rbp), %rdi
callq 0x4fad0
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd800
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::m_append_separator_if_needed()
path::string_type::size_type path::m_append_separator_if_needed()
  {
    if (!m_pathname.empty() &&
#     ifdef BOOST_WINDOWS_API
      *(m_pathname.end()-1) != colon && 
#     endif
      !is_separator(*(m_pathname.end()-1)))
    {
      string_type::size_type tmp(m_pathname.size());
      m_pathname += preferred_separator;
      return tmp;
    }
    return 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xdab0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x4fb2a
movq -0x38(%rbp), %rdi
callq 0xd340
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x51fe0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1ead0
movsbl (%rax), %edi
callq 0x4fab0
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x4fb33
jmp 0x4fb58
movq -0x38(%rbp), %rdi
callq 0xd430
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movl $0x2f, %esi
callq 0xd3c0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4fb60
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::operator/=(char const*)
path& path::operator/=(const value_type* ptr)
  {
    if (!*ptr)
      return *this;
    if (ptr >= m_pathname.data()
      && ptr < m_pathname.data() + m_pathname.size())  // overlapping source
    {
      path rhs(ptr);
      if (!is_separator(rhs.m_pathname[0]))
        m_append_separator_if_needed();
      m_pathname += rhs.m_pathname;
    }
    else
    {
      if (!is_separator(*ptr))
        m_append_separator_if_needed();
      m_pathname += ptr;
    }
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x4fba1
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4fc9d
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0xd830
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jb 0x4fc6f
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0xd830
movq -0x50(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0xd430
movq -0x68(%rbp), %rcx
movq %rax, %rdx
movq -0x60(%rbp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x4fc6f
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4df90
movq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdc50
movq %rax, -0x70(%rbp)
jmp 0x4fc17
movq -0x70(%rbp), %rax
movsbl (%rax), %edi
callq 0x4fab0
movb %al, -0x79(%rbp)
jmp 0x4fc28
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x4fc55
jmp 0x4fc31
movq -0x50(%rbp), %rdi
callq 0x4fad0
jmp 0x4fc3c
jmp 0x4fc55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4d550
jmp 0x4fcaa
movq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd800
jmp 0x4fc64
leaq -0x38(%rbp), %rdi
callq 0x4d550
jmp 0x4fc95
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x4fab0
testb $0x1, %al
jne 0x4fc88
movq -0x50(%rbp), %rdi
callq 0x4fad0
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd5f0
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::detail::lex_compare(boost::filesystem::path::iterator, boost::filesystem::path::iterator, boost::filesystem::path::iterator, boost::filesystem::path::iterator)
BOOST_FILESYSTEM_DECL
      int lex_compare(path::iterator first1, path::iterator last1,
        path::iterator first2, path::iterator last2)
    {
      for (; first1 != last1 && first2 != last2;)
      {
        if (first1->native() < first2->native()) return -1;
        if (first2->native() < first1->native()) return 1;
        BOOST_ASSERT(first2->native() == first1->native());
        ++first1;
        ++first2;
      }
      if (first1 == last1 && first2 == last2)
        return 0;
      return first1 == last1 ? -1 : 1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x48(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x4d870
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x49(%rbp)
jne 0x4fdd3
jmp 0x4fde3
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x4d870
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x4fdef
jmp 0x4fee7
movq -0x48(%rbp), %rdi
callq 0x52200
movq %rax, %rdi
callq 0x4e090
movq -0x38(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x52200
movq %rax, %rdi
callq 0x4e090
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x13d20
testb $0x1, %al
jne 0x4fe27
jmp 0x4fe33
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4ff38
movq -0x38(%rbp), %rdi
callq 0x52200
movq %rax, %rdi
callq 0x4e090
movq -0x48(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x52200
movq %rax, %rdi
callq 0x4e090
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x13d20
testb $0x1, %al
jne 0x4fe6b
jmp 0x4fe77
movl $0x1, -0x4(%rbp)
jmp 0x4ff38
movq -0x38(%rbp), %rdi
callq 0x52200
movq %rax, %rdi
callq 0x4e090
movq -0x48(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x52200
movq %rax, %rdi
callq 0x4e090
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x26720
testb $0x1, %al
jne 0x4feaf
jmp 0x4feb1
jmp 0x4fed0
leaq 0x138de(%rip), %rdi     # 0x63796
leaq 0x138fc(%rip), %rsi     # 0x637bb
movl $0x291, %edx            # imm = 0x291
leaq 0x1390f(%rip), %rcx     # 0x637da
callq 0xd400
movq -0x48(%rbp), %rdi
callq 0x4d980
movq -0x38(%rbp), %rdi
callq 0x4d980
jmp 0x4fdb8
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x52230
testb $0x1, %al
jne 0x4fefa
jmp 0x4ff16
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x52230
testb $0x1, %al
jne 0x4ff0d
jmp 0x4ff16
movl $0x0, -0x4(%rbp)
jmp 0x4ff38
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x52230
movb %al, %dl
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::begin() const
path::iterator path::begin() const
  {
    iterator itr;
    itr.m_path_ptr = this;
    size_type element_size;
    first_element(m_pathname, itr.m_pos, element_size);
    itr.m_element = m_pathname.substr(itr.m_pos, element_size);
    if (itr.m_element.m_pathname == preferred_separator_string)
      itr.m_element.m_pathname = separator_string;  // needed for Windows, harmless on POSIX
    return itr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x52260
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdi
movq %rdi, 0x20(%rsi)
addq $0x28, %rsi
leaq -0x20(%rbp), %rdx
movq $-0x1, %rcx
callq 0x51780
jmp 0x4ff9e
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rax
movq 0x28(%rax), %rdx
movq -0x20(%rbp), %rcx
leaq -0x50(%rbp), %rdi
callq 0xd650
jmp 0x4ffb9
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x52280
jmp 0x4ffc8
leaq -0x50(%rbp), %rdi
callq 0xdca8
movq -0x60(%rbp), %rdi
movq 0x3e6ac(%rip), %rsi     # 0x8e688
callq 0x13120
movb %al, -0x69(%rbp)
jmp 0x4ffe6
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x4ffef
jmp 0x50028
movq -0x60(%rbp), %rdi
movq 0x3e696(%rip), %rsi     # 0x8e690
callq 0xd8a0
jmp 0x50001
jmp 0x50028
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x50045
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xdca8
jmp 0x50045
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x5003b
movq -0x60(%rbp), %rdi
callq 0x4d8a0
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x4d8a0
movq -0x28(%rbp), %rdi
callq 0xdb30
nopw (%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::end() const
path::iterator path::end() const
  {
    iterator itr;
    itr.m_path_ptr = this;
    itr.m_pos = m_pathname.size();
    return itr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x52260
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rdi, 0x20(%rax)
callq 0xd430
movq -0x20(%rbp), %rdi
movq %rax, 0x28(%rdi)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x500b8
movq -0x20(%rbp), %rdi
callq 0x4d8a0
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::m_erase_redundant_separator(unsigned long)
void path::m_erase_redundant_separator(string_type::size_type sep_pos)
  {
    if (sep_pos                         // a separator was added
      && sep_pos < m_pathname.size()         // and something was appended
      && (m_pathname[sep_pos+1] == separator // and it was also separator
#      ifdef BOOST_WINDOWS_API
       || m_pathname[sep_pos+1] == preferred_separator  // or preferred_separator
#      endif
)) { m_pathname.erase(sep_pos, 1); } // erase the added separator
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x50137
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xd430
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x50137
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
callq 0xdc50
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x50137
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0xd100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::m_parent_path_end() const
string_type::size_type path::m_parent_path_end() const
  {
    size_type end_pos(filename_pos(m_pathname, m_pathname.size()));

    bool filename_was_separator(m_pathname.size()
      && is_separator(m_pathname[end_pos]));

    // skip separators unless root directory
    size_type root_dir_pos(root_directory_start(m_pathname, end_pos));
    for (; 
      end_pos > 0
      && (end_pos-1) != root_dir_pos
      && is_separator(m_pathname[end_pos-1])
      ;
      --end_pos) {}

   return (end_pos == 1 && root_dir_pos == 0 && filename_was_separator)
     ? string_type::npos
     : end_pos;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xd430
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x509e0
movq -0x30(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0xd430
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x21(%rbp)
je 0x501d8
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd6d0
movsbl (%rax), %edi
callq 0x4fab0
movb %al, -0x21(%rbp)
movq -0x30(%rbp), %rdi
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x507b0
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x31(%rbp)
jbe 0x5022c
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x31(%rbp)
je 0x5022c
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
subq $0x1, %rsi
callq 0xd6d0
movsbl (%rax), %edi
callq 0x4fab0
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x50235
jmp 0x50245
jmp 0x50237
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x501f1
cmpq $0x1, -0x10(%rbp)
jne 0x50266
cmpq $0x0, -0x20(%rbp)
jne 0x50266
testb $0x1, -0x11(%rbp)
je 0x50266
movq $-0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x5026e
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::replace_extension(boost::filesystem::path const&)
path& path::replace_extension(const path& new_extension)
  {
    // erase existing extension, including the dot, if any
    m_pathname.erase(m_pathname.size()-extension().m_pathname.size());

    if (!new_extension.empty())
    {
      // append new_extension, adding the dot if necessary
      if (new_extension.m_pathname[0] != dot)
        m_pathname.push_back(dot);
      m_pathname.append(new_extension.m_pathname);
    }

    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xd430
movq -0x48(%rbp), %rsi
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x503c0
movq -0x58(%rbp), %rdi
callq 0xd430
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
subq %rax, %rsi
movq $-0x1, %rdx
callq 0xd100
jmp 0x50344
leaq -0x30(%rbp), %rdi
callq 0x4d550
movq -0x10(%rbp), %rdi
callq 0x4d570
testb $0x1, %al
jne 0x503a3
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd6d0
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x50396
movq -0x48(%rbp), %rdi
movl $0x2e, %esi
callq 0xd540
jmp 0x50396
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4d550
jmp 0x503ad
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xdc10
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::extension() const
path path::extension() const
  {
    path name(filename());
    if (name == detail::dot_path() || name == detail::dot_dot_path()) return path();
    size_type pos(name.m_pathname.rfind(dot));
    return pos == string_type::npos
      ? path()
      : path(name.m_pathname.c_str() + pos);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x50b60
callq 0x50d50
movq %rax, -0x50(%rbp)
jmp 0x503f6
movq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4d8c0
movb %al, -0x61(%rbp)
jmp 0x50408
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x50437
jmp 0x50411
callq 0x50f20
movq %rax, -0x70(%rbp)
jmp 0x5041c
movq -0x70(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4d8c0
movb %al, -0x71(%rbp)
jmp 0x5042e
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x50437
jmp 0x50462
movq -0x60(%rbp), %rdi
callq 0x4d620
jmp 0x50442
movl $0x1, -0x40(%rbp)
jmp 0x504b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4d550
jmp 0x504cc
leaq -0x30(%rbp), %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0xdc30
movq %rax, -0x48(%rbp)
cmpq $-0x1, -0x48(%rbp)
jne 0x5048f
movq -0x60(%rbp), %rdi
callq 0x4d620
jmp 0x5048d
jmp 0x504af
leaq -0x30(%rbp), %rdi
callq 0xd210
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movq -0x48(%rbp), %rax
addq %rax, %rsi
callq 0x4df90
jmp 0x504ad
jmp 0x504af
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4d550
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::root_name() const
path path::root_name() const
  {
    iterator itr(begin());

    return (itr.m_pos != m_pathname.size()
      && (
          (itr.m_element.m_pathname.size() > 1
            && is_separator(itr.m_element.m_pathname[0])
            && is_separator(itr.m_element.m_pathname[1])
   )
#       ifdef BOOST_WINDOWS_API
        || itr.m_element.m_pathname[itr.m_element.m_pathname.size()-1] == colon
#       endif
  ))
      ? itr.m_element
      : path();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4ff50
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0xd430
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
je 0x506d7
leaq -0x40(%rbp), %rdi
callq 0xd430
cmpq $0x1, %rax
jbe 0x506d7
xorl %eax, %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
callq 0xdc50
movq %rax, -0x78(%rbp)
jmp 0x50672
movq -0x78(%rbp), %rax
movsbl (%rax), %edi
callq 0x4fab0
movb %al, -0x79(%rbp)
jmp 0x50683
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x5068c
jmp 0x506d7
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0xdc50
movq %rax, -0x88(%rbp)
jmp 0x506a3
movq -0x88(%rbp), %rax
movsbl (%rax), %edi
callq 0x4fab0
movb %al, -0x89(%rbp)
jmp 0x506ba
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x506c6
jmp 0x506d7
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4d4f0
jmp 0x506d5
jmp 0x506e4
movq -0x70(%rbp), %rdi
callq 0x4d620
jmp 0x506e2
jmp 0x506e4
leaq -0x40(%rbp), %rdi
callq 0x4d8a0
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4d8a0
movq -0x48(%rbp), %rdi
callq 0xdb30
nopl (%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::root_directory() const
path path::root_directory() const
  {
    size_type pos(root_directory_start(m_pathname, m_pathname.size()));

    return pos == string_type::npos
      ? path()
      : path(m_pathname.c_str() + pos, m_pathname.c_str() + pos + 1);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xd430
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x507b0
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x5076a
movq -0x30(%rbp), %rdi
callq 0x4d620
jmp 0x5079c
movq -0x20(%rbp), %rdi
callq 0xd210
movq -0x20(%rbp), %rdi
addq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xd210
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
addq -0x18(%rbp), %rdx
addq $0x1, %rdx
callq 0x52020
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)