LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::copy_directory(boost::filesystem::path const&, boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  void copy_directory(const path& from, const path& to, system::error_code* ec)
  {
#   ifdef BOOST_POSIX_API
    struct stat from_stat;
#   endif
    error(!BOOST_COPY_DIRECTORY(from.c_str(), to.c_str()) ? BOOST_ERRNO : 0,
      from, to, ec, "boost::filesystem::copy_directory");
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
leaq -0xe0(%rbp), %rsi
callq 0xc820
testl %eax, %eax
jne 0x22871
movq (%r14), %rdi
movl -0xc8(%rbp), %esi
callq 0xc210
testl %eax, %eax
je 0x228bf
callq 0xc060
movl (%rax), %r12d
leaq 0xd38a(%rip), %rsi      # 0x2fc0a
leaq -0x50(%rbp), %r13
leaq -0x29(%rbp), %rdx
movq %r13, %rdi
callq 0xc1b0
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x228d8
leaq -0x50(%rbp), %rdi
callq 0xc9a0
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0x22879
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: (anonymous namespace)::error(int, boost::filesystem::path const&, boost::filesystem::path const&, boost::system::error_code*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool error(err_t error_num, const path& p1, const path& p2, error_code* ec,
    const string& message)
  {
    if (!error_num)
    {
      if (ec != 0) ec->clear();
    }
    else  
    { //  error
      if (ec == 0)
        BOOST_FILESYSTEM_THROW(filesystem_error(message,
          p1, p2, error_code(error_num, system_category())));
      else
        ec->assign(error_num, system_category());
    }
    return error_num != 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
testl %edi, %edi
je 0x22910
movl %edi, %ebx
testq %r13, %r13
je 0x2292b
callq 0x2761f
movl %ebx, (%r13)
movq %rax, 0x8(%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r13, %r13
je 0x22901
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x24b32
movq %r8, %r15
movq %rdx, %r14
movq %rsi, %r12
pushq $0x50
popq %rdi
callq 0xc250
movq %rax, %r13
callq 0x2761f
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
movl %ebx, %r8d
movq %rax, %r9
callq 0x24b4e
leaq 0x25c26(%rip), %rsi     # 0x48588
leaq 0x217f(%rip), %rdx      # 0x24ae8
movq %r13, %rdi
callq 0xc810
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::copy_symlink(boost::filesystem::path const&, boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  void copy_symlink(const path& existing_symlink, const path& new_symlink,
    system::error_code* ec)
  {
# if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0600
    error(BOOST_ERROR_NOT_SUPPORTED, new_symlink, existing_symlink, ec,
      "boost::filesystem::copy_symlink");

# else  // modern Windows or BOOST_POSIX_API 
    path p(read_symlink(existing_symlink, ec));
    if (ec != 0 && *ec) return;
    create_symlink(p, new_symlink, ec);

# endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
leaq -0x30(%rbp), %rdi
callq 0x22654
testq %rbx, %rbx
je 0x22c08
cmpl $0x0, (%rbx)
jne 0x22c17
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x22c3d
leaq -0x30(%rbp), %rdi
callq 0xc9a0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::create_symlink(boost::filesystem::path const&, boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  void create_symlink(const path& to, const path& from, error_code* ec)
  {
#   if defined(BOOST_WINDOWS_API) && _WIN32_WINNT < 0x0600  // SDK earlier than Vista and Server 2008
    error(BOOST_ERROR_NOT_SUPPORTED, to, from, ec,
      "boost::filesystem::create_directory_symlink");
#   else

#     if defined(BOOST_WINDOWS_API) && _WIN32_WINNT >= 0x0600
        // see if actually supported by Windows runtime dll
        if (error(!create_symbolic_link_api ? BOOST_ERROR_NOT_SUPPORTED : 0, to, from, ec,
            "boost::filesystem::create_symlink"))
          return;
#     endif

    error(!BOOST_CREATE_SYMBOLIC_LINK(from.c_str(), to.c_str(), 0) ? BOOST_ERRNO : 0,
      to, from, ec, "boost::filesystem::create_symlink");
#   endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0xc080
testl %eax, %eax
je 0x22c70
callq 0xc060
movl (%rax), %r12d
jmp 0x22c73
xorl %r12d, %r12d
leaq 0xd0f8(%rip), %rsi      # 0x2fd72
leaq -0x50(%rbp), %r13
leaq -0x29(%rbp), %rdx
movq %r13, %rdi
callq 0xc1b0
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x228d8
leaq -0x50(%rbp), %rdi
callq 0xc9a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::create_directories(boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  bool create_directories(const path& p, system::error_code* ec)
  {
    error_code local_ec;
    file_status p_status = status(p, local_ec);

    if (p_status.type() == directory_file)
    {
      if (ec != 0)
        ec->clear();
      return false;
    }

    path parent = p.parent_path();
    BOOST_ASSERT_MSG(parent != p, "internal error: p == p.parent_path()");
    if (!parent.empty())
    {
      // determine if the parent exists
      file_status parent_status = status(parent, local_ec);

      // if the parent does not exist, create the parent
      if (parent_status.type() == file_not_found)
      {
        create_directories(parent, local_ec);
        if (local_ec)
        {
          if (ec == 0)
            BOOST_FILESYSTEM_THROW(filesystem_error(
              "boost::filesystem::create_directories", parent, local_ec));
          else
            *ec = local_ec;
          return false;
        }
      }
    }

    // create the directory
    return create_directory(p, ec);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x30(%rbp), %r15
andl $0x0, (%r15)
callq 0x2761f
movq %rax, 0x8(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x23f1a
cmpl $0x3, %eax
jne 0x22d0f
testq %rbx, %rbx
je 0x22d0b
movq %rbx, %rdi
callq 0x24b32
xorl %ebx, %ebx
jmp 0x22d7f
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x25ede
movq %r15, %rdi
movq %r14, %rsi
callq 0x24b22
testb %al, %al
je 0x22d8c
cmpq $0x0, -0x48(%rbp)
je 0x22d69
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x23f1a
cmpl $0x1, %eax
jne 0x22d69
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x22cca
cmpl $0x0, -0x30(%rbp)
je 0x22d69
testq %rbx, %rbx
je 0x22dab
movups -0x30(%rbp), %xmm0
movups %xmm0, (%rbx)
xorl %ebx, %ebx
jmp 0x22d76
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22e28
movl %eax, %ebx
leaq -0x50(%rbp), %rdi
callq 0xc9a0
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xceb6(%rip), %rdi      # 0x2fc49
leaq 0xcdef(%rip), %rsi      # 0x2fb89
leaq 0xcee0(%rip), %rcx      # 0x2fc81
movl $0x3ad, %edx            # imm = 0x3AD
callq 0xc350
pushq $0x50
popq %rdi
callq 0xc250
movq %rax, %rbx
leaq 0xcf1b(%rip), %rsi      # 0x2fcd8
leaq -0x70(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0xc1b0
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %r8
leaq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
callq 0x24a48
leaq 0x257a0(%rip), %rsi     # 0x48588
leaq 0x1cf9(%rip), %rdx      # 0x24ae8
movq %rbx, %rdi
callq 0xc810
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0xc9a0
jmp 0x22e17
movq %rax, %r14
movq %rbx, %rdi
callq 0xc390
jmp 0x22e17
jmp 0x22e14
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0xc9a0
movq %r14, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::create_directory(boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  bool create_directory(const path& p, error_code* ec)
  {
    if (BOOST_CREATE_DIRECTORY(p.c_str()))
    {
      if (ec != 0)
        ec->clear();
      return true;
    }

    //  attempt to create directory failed
    int errval(BOOST_ERRNO);  // save reason for failure
    error_code dummy;
    if (errval == BOOST_ERROR_ALREADY_EXISTS && is_directory(p, dummy))
    {
      if (ec != 0)
        ec->clear();
      return false;
    }

    //  attempt to create directory failed && it doesn't already exist
    if (ec == 0)
      BOOST_FILESYSTEM_THROW(filesystem_error("boost::filesystem::create_directory",
        p, error_code(errval, system_category())));
    else
      ec->assign(errval, system_category());
    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0xc210
movl %eax, %r14d
testl %eax, %eax
je 0x22e7c
callq 0xc060
movl (%rax), %r12d
andl $0x0, -0x38(%rbp)
callq 0x2761f
movq %rax, -0x30(%rbp)
cmpl $0x11, %r12d
jne 0x22e8b
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x24c02
testb %al, %al
je 0x22e8b
testq %r15, %r15
je 0x22e9c
movq %r15, %rdi
callq 0x24b32
jmp 0x22e9c
testq %r15, %r15
je 0x22eaf
callq 0x2761f
movl %r12d, (%r15)
movq %rax, 0x8(%r15)
testl %r14d, %r14d
sete %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x50
popq %rdi
callq 0xc250
movq %rax, %r14
leaq 0xce3d(%rip), %rsi      # 0x2fcfe
leaq -0x58(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0xc1b0
callq 0x2761f
leaq -0x58(%rbp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
movl %r12d, %ecx
movq %rax, %r8
callq 0x24a48
leaq 0x25699(%rip), %rsi     # 0x48588
leaq 0x1bf2(%rip), %rdx      # 0x24ae8
movq %r14, %rdi
callq 0xc810
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xc9a0
jmp 0x22f17
movq %rax, %rbx
movq %r14, %rdi
callq 0xc390
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::create_directory_symlink(boost::filesystem::path const&, boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  void create_directory_symlink(const path& to, const path& from,
                                 system::error_code* ec)
  {
#   if defined(BOOST_WINDOWS_API) && _WIN32_WINNT < 0x0600  // SDK earlier than Vista and Server 2008

    error(BOOST_ERROR_NOT_SUPPORTED, to, from, ec,
      "boost::filesystem::create_directory_symlink");
#   else

#     if defined(BOOST_WINDOWS_API) && _WIN32_WINNT >= 0x0600
        // see if actually supported by Windows runtime dll
        if (error(!create_symbolic_link_api ? BOOST_ERROR_NOT_SUPPORTED : 0, to, from, ec,
            "boost::filesystem::create_directory_symlink"))
          return;
#     endif

    error(!BOOST_CREATE_SYMBOLIC_LINK(from.c_str(), to.c_str(),
      SYMBOLIC_LINK_FLAG_DIRECTORY) ? BOOST_ERRNO : 0,
      to, from, ec, "boost::filesystem::create_directory_symlink");
#   endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0xc080
testl %eax, %eax
je 0x22f52
callq 0xc060
movl (%rax), %r12d
jmp 0x22f55
xorl %r12d, %r12d
leaq 0xcdc6(%rip), %rsi      # 0x2fd22
leaq -0x50(%rbp), %r13
leaq -0x29(%rbp), %rdx
movq %r13, %rdi
callq 0xc1b0
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x228d8
leaq -0x50(%rbp), %rdi
callq 0xc9a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::create_hard_link(boost::filesystem::path const&, boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  void create_hard_link(const path& to, const path& from, error_code* ec)
  {

#   if defined(BOOST_WINDOWS_API) && _WIN32_WINNT < 0x0500  // SDK earlier than Win 2K

    error(BOOST_ERROR_NOT_SUPPORTED, to, from, ec,
      "boost::filesystem::create_hard_link");
#   else

#     if defined(BOOST_WINDOWS_API) && _WIN32_WINNT >= 0x0500
        // see if actually supported by Windows runtime dll
        if (error(!create_hard_link_api ? BOOST_ERROR_NOT_SUPPORTED : 0, to, from, ec,
            "boost::filesystem::create_hard_link"))
          return;
#     endif

    error(!BOOST_CREATE_HARD_LINK(from.c_str(), to.c_str()) ? BOOST_ERRNO : 0, to, from, ec,
      "boost::filesystem::create_hard_link");
#   endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0xc140
testl %eax, %eax
je 0x22fdf
callq 0xc060
movl (%rax), %r12d
jmp 0x22fe2
xorl %r12d, %r12d
leaq 0xcd65(%rip), %rsi      # 0x2fd4e
leaq -0x50(%rbp), %r13
leaq -0x29(%rbp), %rdx
movq %r13, %rdi
callq 0xc1b0
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x228d8
leaq -0x50(%rbp), %rdi
callq 0xc9a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::current_path(boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  path current_path(error_code* ec)
  {
#   ifdef BOOST_POSIX_API
    path cur;
    for (long path_max = 128;; path_max *=2)// loop 'til buffer large enough
    {
      boost::scoped_array<char>
        buf(new char[static_cast<std::size_t>(path_max)]);
      if (::getcwd(buf.get(), static_cast<std::size_t>(path_max))== 0)
      {
        if (error(errno != ERANGE ? errno : 0
      // bug in some versions of the Metrowerks C lib on the Mac: wrong errno set 
#         if defined(__MSL__) && (defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__))
          && errno != 0
#         endif
          , ec, "boost::filesystem::current_path"))
        {
          break;
        }
      }
      else
      {
        cur = buf.get();
        if (ec != 0) ec->clear();
        break;
      }
    }
    return cur;

#   else
    DWORD sz;
    if ((sz = ::GetCurrentDirectoryW(0, NULL)) == 0)sz = 1;
    boost::scoped_array<path::value_type> buf(new path::value_type[sz]);
    error(::GetCurrentDirectoryW(sz, buf.get()) == 0 ? BOOST_ERRNO : 0, ec,
      "boost::filesystem::current_path");
    return path(buf.get());
#   endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movq %rdi, -0x38(%rbp)
movb $0x0, 0x10(%rdi)
movl $0x80, %r12d
leaq -0x58(%rbp), %rbx
movq %r12, %rdi
callq 0xc030
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
callq 0xc280
testq %rax, %rax
jne 0x230ed
callq 0xc060
movl (%rax), %r13d
cmpl $0x22, %r13d
movl $0x0, %eax
cmovel %eax, %r13d
movq %rbx, %rdi
leaq 0xccef(%rip), %rsi      # 0x2fd94
leaq -0x29(%rbp), %rdx
callq 0xc1b0
testl %r13d, %r13d
je 0x230c6
testq %r15, %r15
je 0x23121
callq 0x2761f
movl %r13d, (%r15)
movq %rax, 0x8(%r15)
jmp 0x230d3
testq %r15, %r15
je 0x230d3
movq %r15, %rdi
callq 0x24b32
movq %rbx, %rdi
callq 0xc9a0
movq %r14, %rdi
callq 0x25502
addq %r12, %r12
testl %r13d, %r13d
je 0x2306b
jmp 0x2310e
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0xc8f0
testq %r15, %r15
je 0x23106
movq %r15, %rdi
callq 0x24b32
movq %r14, %rdi
callq 0x25502
movq -0x38(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x50
popq %rdi
callq 0xc250
movq %rax, %rbx
callq 0x2761f
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
movl %r13d, %edx
movq %rax, %rcx
callq 0x25268
leaq 0x2543e(%rip), %rsi     # 0x48588
leaq 0x1997(%rip), %rdx      # 0x24ae8
movq %rbx, %rdi
callq 0xc810
jmp 0x23169
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xc9a0
jmp 0x2316c
movq %rax, %rbx
movq %r14, %rdi
callq 0x25502
jmp 0x23179
movq %rax, %rbx
movq -0x38(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: (anonymous namespace)::error(int, boost::filesystem::path const&, boost::system::error_code*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool error(err_t error_num, const path& p, error_code* ec, const string& message)
  {
    if (!error_num)
    {
      if (ec != 0) ec->clear();
    }
    else  
    { //  error
      if (ec == 0)
        BOOST_FILESYSTEM_THROW(filesystem_error(message,
          p, error_code(error_num, system_category())));
      else
        ec->assign(error_num, system_category());
    }
    return error_num != 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movl %edi, %ebx
testl %edi, %edi
je 0x23233
testq %r12, %r12
je 0x2324e
callq 0x2761f
movl %ebx, (%r12)
movq %rax, 0x8(%r12)
jmp 0x23240
testq %r12, %r12
je 0x23240
movq %r12, %rdi
callq 0x24b32
testl %ebx, %ebx
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %r14
movq %rsi, %r15
pushq $0x50
popq %rdi
callq 0xc250
movq %rax, %r12
callq 0x2761f
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebx, %ecx
movq %rax, %r8
callq 0x24a48
leaq 0x2530a(%rip), %rsi     # 0x48588
leaq 0x1863(%rip), %rdx      # 0x24ae8
movq %r12, %rdi
callq 0xc810
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::file_size(boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  boost::uintmax_t file_size(const path& p, error_code* ec)
  {
#   ifdef BOOST_POSIX_API

    struct stat path_stat;
    if (error(::stat(p.c_str(), &path_stat)!= 0 ? BOOST_ERRNO : 0,
        p, ec, "boost::filesystem::file_size"))
      return static_cast<boost::uintmax_t>(-1);
   if (error(!S_ISREG(path_stat.st_mode) ? EPERM : 0,
        p, ec, "boost::filesystem::file_size"))
      return static_cast<boost::uintmax_t>(-1);

    return static_cast<boost::uintmax_t>(path_stat.st_size);

#   else  // Windows

    // assume uintmax_t is 64-bits on all Windows compilers

    WIN32_FILE_ATTRIBUTE_DATA fad;

    if (error(::GetFileAttributesExW(p.c_str(), ::GetFileExInfoStandard, &fad)== 0
      ? BOOST_ERRNO : 0, p, ec, "boost::filesystem::file_size"))
          return static_cast<boost::uintmax_t>(-1);

    if (error((fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)!= 0
      ? ERROR_NOT_SUPPORTED : 0, p, ec, "boost::filesystem::file_size"))
      return static_cast<boost::uintmax_t>(-1);

    return (static_cast<boost::uintmax_t>(fad.nFileSizeHigh)
              << (sizeof(fad.nFileSizeLow)*8)) + fad.nFileSizeLow;
#   endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq -0xd8(%rbp), %rsi
callq 0xc820
testl %eax, %eax
je 0x233b5
callq 0xc060
movl (%rax), %r15d
jmp 0x233b8
xorl %r15d, %r15d
leaq 0xca13(%rip), %rsi      # 0x2fdd2
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0xc1b0
leaq -0x48(%rbp), %rcx
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2320a
movl %eax, %r12d
leaq -0x48(%rbp), %rdi
callq 0xc9a0
pushq $-0x1
popq %r15
testb %r12b, %r12b
jne 0x23447
movl -0xc0(%rbp), %r12d
leaq 0xc9d1(%rip), %rsi      # 0x2fdd2
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0xc1b0
andl $0xf000, %r12d          # imm = 0xF000
xorl %edi, %edi
cmpl $0x8000, %r12d          # imm = 0x8000
setne %dil
leaq -0x48(%rbp), %rcx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2320a
movl %eax, %ebx
leaq -0x48(%rbp), %rdi
callq 0xc9a0
testb %bl, %bl
jne 0x23447
movq -0xa8(%rbp), %r15
movq %r15, %rax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2345e
jmp 0x2346c
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xc9a0
jmp 0x2346f
movq %rax, %rbx
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::hard_link_count(boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  boost::uintmax_t hard_link_count(const path& p, system::error_code* ec)
  {
#   ifdef BOOST_POSIX_API

    struct stat path_stat;
    return error(::stat(p.c_str(), &path_stat)!= 0 ? BOOST_ERRNO : 0,
                  p, ec, "boost::filesystem::hard_link_count")
           ? 0
           : static_cast<boost::uintmax_t>(path_stat.st_nlink);

#   else // Windows

    // Link count info is only available through GetFileInformationByHandle
    BY_HANDLE_FILE_INFORMATION info;
    handle_wrapper h(
      create_file_handle(p.c_str(), 0,
          FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
          OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0));
    return
      !error(h.handle == INVALID_HANDLE_VALUE ? BOOST_ERRNO : 0,
              p, ec, "boost::filesystem::hard_link_count")
      && !error(::GetFileInformationByHandle(h.handle, &info)== 0 ? BOOST_ERRNO : 0,
                 p, ec, "boost::filesystem::hard_link_count")
           ? info.nNumberOfLinks
           : 0;
#   endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq -0xd8(%rbp), %rsi
callq 0xc820
testl %eax, %eax
je 0x234ac
callq 0xc060
movl (%rax), %r15d
jmp 0x234af
xorl %r15d, %r15d
leaq 0xc939(%rip), %rsi      # 0x2fdef
leaq -0x48(%rbp), %r12
leaq -0x21(%rbp), %rdx
movq %r12, %rdi
callq 0xc1b0
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x2320a
testb %al, %al
jne 0x234e4
movq -0xc8(%rbp), %rbx
jmp 0x234e6
xorl %ebx, %ebx
leaq -0x48(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::initial_path(boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  path initial_path(error_code* ec)
  {
      static path init_path;
      if (init_path.empty())
        init_path = current_path(ec);
      else if (ec != 0) ec->clear();
      return init_path;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb 0x260e9(%rip), %al      # 0x49618
testb %al, %al
je 0x23590
cmpq $0x0, 0x260c5(%rip)     # 0x49600
je 0x2354c
testq %r14, %r14
je 0x23573
movq %r14, %rdi
callq 0x24b32
jmp 0x23573
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x23039
leaq 0x26096(%rip), %rdi     # 0x495f8
movq %r15, %rsi
callq 0xc2b0
leaq -0x38(%rbp), %rdi
callq 0xc9a0
leaq 0x2607e(%rip), %rsi     # 0x495f8
movq %rbx, %rdi
callq 0xc660
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x26081(%rip), %rdi     # 0x49618
callq 0xc890
testl %eax, %eax
je 0x23533
leaq 0x26061(%rip), %rax     # 0x49608
movq %rax, 0x2604a(%rip)     # 0x495f8
leaq 0x26043(%rip), %rsi     # 0x495f8
andq $0x0, 0x26043(%rip)     # 0x49600
movb $0x0, 0x26044(%rip)     # 0x49608
leaq 0x1413(%rip), %rdi      # 0x249de
leaq 0x25efe(%rip), %rdx     # 0x494d0
callq 0xc450
leaq 0x2603a(%rip), %rdi     # 0x49618
callq 0xc330
jmp 0x23533
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::is_empty(boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  bool is_empty(const path& p, system::error_code* ec)
  {
#   ifdef BOOST_POSIX_API

    struct stat path_stat;
    if (error(::stat(p.c_str(), &path_stat)!= 0,
        p, ec, "boost::filesystem::is_empty"))
      return false;        
    return S_ISDIR(path_stat.st_mode)
      ? is_empty_directory(p)
      : path_stat.st_size == 0;
#   else

    WIN32_FILE_ATTRIBUTE_DATA fad;
    if (error(::GetFileAttributesExW(p.c_str(), ::GetFileExInfoStandard, &fad)== 0
      ? BOOST_ERRNO : 0, p, ec, "boost::filesystem::is_empty"))
        return false;

    if (ec != 0) ec->clear();
    return 
      (fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        ? is_empty_directory(p)
        : (!fad.nFileSizeHigh && !fad.nFileSizeLow);
#   endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
leaq -0xd8(%rbp), %rsi
callq 0xc820
movl %eax, %r15d
leaq 0xc7e5(%rip), %rsi      # 0x2fe12
leaq -0x48(%rbp), %r12
leaq -0x21(%rbp), %rdx
movq %r12, %rdi
callq 0xc1b0
xorl %edi, %edi
testl %r15d, %r15d
setne %dil
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x2320a
movl %eax, %r14d
leaq -0x48(%rbp), %rdi
callq 0xc9a0
testb %r14b, %r14b
je 0x23669
xorl %ebx, %ebx
jmp 0x236ad
movl $0xf000, %eax           # imm = 0xF000
andl -0xc0(%rbp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x236a2
leaq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x252f2
movq (%r14), %rax
cmpq 0x25f44(%rip), %rax     # 0x495d8
sete %bl
leaq -0x40(%rbp), %rdi
callq 0xf63a
jmp 0x236ad
cmpq $0x0, -0xa8(%rbp)
sete %bl
movl %ebx, %eax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::last_write_time(boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  std::time_t last_write_time(const path& p, system::error_code* ec)
  {
#   ifdef BOOST_POSIX_API

    struct stat path_stat;
    if (error(::stat(p.c_str(), &path_stat)!= 0 ? BOOST_ERRNO : 0,
      p, ec, "boost::filesystem::last_write_time"))
        return std::time_t(-1);
    return path_stat.st_mtime;

#   else

    handle_wrapper hw(
      create_file_handle(p.c_str(), 0,
        FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
        OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0));

    if (error(hw.handle == INVALID_HANDLE_VALUE ? BOOST_ERRNO : 0,
      p, ec, "boost::filesystem::last_write_time"))
        return std::time_t(-1);

    FILETIME lwt;

    if (error(::GetFileTime(hw.handle, 0, 0, &lwt)== 0 ? BOOST_ERRNO : 0,
      p, ec, "boost::filesystem::last_write_time"))
        return std::time_t(-1);

    return to_time_t(lwt);
#   endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq -0xd8(%rbp), %rsi
callq 0xc820
testl %eax, %eax
je 0x23708
callq 0xc060
movl (%rax), %r15d
jmp 0x2370b
xorl %r15d, %r15d
leaq 0xc71c(%rip), %rsi      # 0x2fe2e
leaq -0x48(%rbp), %r12
leaq -0x21(%rbp), %rdx
movq %r12, %rdi
callq 0xc1b0
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x2320a
movl %eax, %ebx
leaq -0x48(%rbp), %rdi
callq 0xc9a0
testb %bl, %bl
jne 0x23748
movq -0x80(%rbp), %rax
jmp 0x2374b
pushq $-0x1
popq %rax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::last_write_time(boost::filesystem::path const&, long, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  void last_write_time(const path& p, const std::time_t new_time,
                        system::error_code* ec)
  {
#   ifdef BOOST_POSIX_API

    struct stat path_stat;
    if (error(::stat(p.c_str(), &path_stat)!= 0,
      p, ec, "boost::filesystem::last_write_time"))
        return;
    ::utimbuf buf;
    buf.actime = path_stat.st_atime; // utime()updates access time too:-(
    buf.modtime = new_time;
    error(::utime(p.c_str(), &buf)!= 0 ? BOOST_ERRNO : 0,
      p, ec, "boost::filesystem::last_write_time");

#   else

    handle_wrapper hw(
      create_file_handle(p.c_str(), FILE_WRITE_ATTRIBUTES,
        FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
        OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0));

    if (error(hw.handle == INVALID_HANDLE_VALUE ? BOOST_ERRNO : 0,
      p, ec, "boost::filesystem::last_write_time"))
        return;

    FILETIME lwt;
    to_FILETIME(new_time, lwt);

    error(::SetFileTime(hw.handle, 0, 0, &lwt)== 0 ? BOOST_ERRNO : 0,
      p, ec, "boost::filesystem::last_write_time");
#   endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
leaq -0xe8(%rbp), %rsi
callq 0xc820
movl %eax, %r12d
leaq 0xc68b(%rip), %rsi      # 0x2fe2e
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0xc1b0
xorl %edi, %edi
testl %r12d, %r12d
setne %dil
leaq -0x48(%rbp), %rcx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2320a
movl %eax, %r12d
leaq -0x48(%rbp), %rdi
callq 0xc9a0
testb %r12b, %r12b
jne 0x23833
movq -0xa0(%rbp), %rax
leaq -0x58(%rbp), %rsi
movq %rax, (%rsi)
movq %r15, 0x8(%rsi)
movq (%r14), %rdi
callq 0xc2a0
testl %eax, %eax
je 0x23801
callq 0xc060
movl (%rax), %r15d
jmp 0x23804
xorl %r15d, %r15d
leaq 0xc623(%rip), %rsi      # 0x2fe2e
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0xc1b0
leaq -0x48(%rbp), %rcx
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2320a
leaq -0x48(%rbp), %rdi
callq 0xc9a0
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x23847
jmp 0x23855
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xc9a0
jmp 0x23858
movq %rax, %rbx
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::remove(boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  bool remove(const path& p, error_code* ec)
  {
    error_code tmp_ec;
    file_type type = query_file_type(p, &tmp_ec);
    if (error(type == status_error ? tmp_ec.value() : 0, p, ec,
        "boost::filesystem::remove"))
      return false;

    // Since POSIX remove() is specified to work with either files or directories, in a
    // perfect world it could just be called. But some important real-world operating
    // systems (Windows, Mac OS X, for example) don't implement the POSIX spec. So
    // remove_file_or_directory() is always called to kep it simple.
    return remove_file_or_directory(p, type, ec);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x40(%rbp), %r15
andl $0x0, (%r15)
callq 0x2761f
movq %rax, 0x8(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x224cc
movq %rax, %r15
xorl %r12d, %r12d
testl %r15d, %r15d
jne 0x23a50
movl -0x40(%rbp), %r12d
leaq 0xc4f8(%rip), %rsi      # 0x2ff4f
leaq -0x60(%rbp), %r13
leaq -0x29(%rbp), %rdx
movq %r13, %rdi
callq 0xc1b0
movl %r12d, %edi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x2320a
movl %eax, %r12d
leaq -0x60(%rbp), %rdi
callq 0xc9a0
testb %r12b, %r12b
je 0x23a8d
xorl %eax, %eax
jmp 0x23a9b
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x23abe
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: (anonymous namespace)::remove_file_or_directory(boost::filesystem::path const&, boost::filesystem::file_type, boost::system::error_code*)
bool remove_file_or_directory(const path& p, fs::file_type type, error_code* ec)
    // return true if file removed, false if not removed
  {
    if (type == fs::file_not_found)
    {
      if (ec != 0) ec->clear();
      return false;
    }

    if (type == fs::directory_file
#     ifdef BOOST_WINDOWS_API
        || type == fs::_detail_directory_symlink
#     endif
      )
    {
      if (error(!remove_directory(p) ? BOOST_ERRNO : 0, p, ec,
        "boost::filesystem::remove"))
          return false;
    }
    else
    {
      if (error(!remove_file(p) ? BOOST_ERRNO : 0, p, ec,
        "boost::filesystem::remove"))
          return false;
    }
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x3, %esi
je 0x23af1
cmpl $0x1, %esi
jne 0x23b07
testq %rbx, %rbx
je 0x23b80
movq %rbx, %rdi
callq 0x24b32
jmp 0x23b80
movq (%r14), %rdi
callq 0xc1e0
testl %eax, %eax
je 0x23b1d
callq 0xc060
movl (%rax), %r15d
jmp 0x23b20
movq (%r14), %rdi
callq 0xc220
testl %eax, %eax
je 0x23b48
callq 0xc060
movl (%rax), %r15d
jmp 0x23b4b
xorl %r15d, %r15d
leaq 0xc428(%rip), %rsi      # 0x2ff4f
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0xc1b0
leaq -0x40(%rbp), %rcx
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2320a
jmp 0x23b71
xorl %r15d, %r15d
leaq 0xc3fd(%rip), %rsi      # 0x2ff4f
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0xc1b0
leaq -0x40(%rbp), %rcx
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2320a
movl %eax, %ebx
leaq -0x40(%rbp), %rdi
callq 0xc9a0
testb %bl, %bl
je 0x23b84
xorl %eax, %eax
jmp 0x23b86
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x23b93
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xc9a0
jmp 0x23ba6
jmp 0x23ba3
movq %rax, %rbx
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::remove_all(boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  boost::uintmax_t remove_all(const path& p, error_code* ec)
  {
    error_code tmp_ec;
    file_type type = query_file_type(p, &tmp_ec);
    if (error(type == status_error ? tmp_ec.value() : 0, p, ec,
      "boost::filesystem::remove_all"))
      return 0;

    return (type != status_error && type != file_not_found) // exists
      ? remove_all_aux(p, type, ec)
      : 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x40(%rbp), %r15
andl $0x0, (%r15)
callq 0x2761f
movq %rax, 0x8(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x224cc
movq %rax, %r15
xorl %r12d, %r12d
testl %r15d, %r15d
jne 0x23bf0
movl -0x40(%rbp), %r12d
leaq 0xc372(%rip), %rsi      # 0x2ff69
leaq -0x60(%rbp), %r13
leaq -0x29(%rbp), %rdx
movq %r13, %rdi
callq 0xc1b0
movl %r12d, %edi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x2320a
movl %eax, %r12d
leaq -0x60(%rbp), %rdi
callq 0xc9a0
cmpl $0x2, %r15d
setb %al
orb %r12b, %al
je 0x23c34
xorl %eax, %eax
jmp 0x23c42
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x23c65
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rax
cmpl $0x3, %esi
jne 0x23ceb
leaq -0x38(%rbp), %r13
movq %r13, %rdi
movq %rax, -0x40(%rbp)
movq %rax, %rsi
callq 0x252f2
pushq $0x1
popq %rbx
movq -0x38(%rbp), %rax
cmpq 0x25933(%rip), %rax     # 0x495d8
je 0x23cf0
movq %r13, %rdi
callq 0x254c8
movq %rax, %rdi
movq %r14, %rsi
callq 0x224cc
movq %rax, %r12
testq %r14, %r14
je 0x23cc8
cmpl $0x0, (%r14)
jne 0x23d1d
movq %r13, %rdi
callq 0x254c8
movq %rax, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x23c65
addq %rax, %rbx
movq %r13, %rdi
callq 0x254f6
jmp 0x23c9a
pushq $0x1
popq %rbx
jmp 0x23cfd
leaq -0x30(%rbp), %rdi
callq 0xf63a
movq -0x40(%rbp), %rax
movq %rax, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x23abe
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0xf63a
jmp 0x23d0b
jmp 0x23d2a
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xf63a
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
leaq -0xc0(%rbp), %rsi
callq 0xc740
movl %eax, %r12d
leaq 0xc13f(%rip), %rsi      # 0x2ffc0
leaq -0x50(%rbp), %r13
leaq -0x29(%rbp), %rdx
movq %r13, %rdi
callq 0xc1b0
xorl %edi, %edi
testl %r12d, %r12d
setne %dil
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x2320a
movl %eax, %r14d
leaq -0x50(%rbp), %rdi
callq 0xc9a0
testb %r14b, %r14b
je 0x23ec1
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x23ee6
movq -0xb8(%rbp), %rax
movq -0xb0(%rbp), %rcx
imulq %rax, %rcx
movq -0xa8(%rbp), %rdx
imulq %rax, %rdx
imulq -0xa0(%rbp), %rax
movq %rax, 0x10(%rbx)
movq %rdx, 0x8(%rbx)
movq %rcx, (%rbx)
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x241a4
movq %r14, %rdi
callq 0x24d86
testb %al, %al
je 0x241b1
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc660
jmp 0x241d6
leaq -0x38(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x23039
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x249e8
leaq -0x38(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rax
testl %eax, %eax
setne %cl
shrq $0x20, %rax
cmpl $0xffff, %eax           # imm = 0xFFFF
setne %al
testb %al, %cl
jne 0x24259
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
movabsq $0xffff00000000, %rdx   # imm = 0xFFFF00000000
movq 0x28(%rbx), %rax
andq %rax, %rcx
cmpq %rdx, %rcx
sete %cl
testl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
sete %dl
orb %cl, %dl
je 0x24255
movq %rbx, %rdi
callq 0x23f1a
movq %rax, 0x20(%rbx)
jmp 0x24266
movq %rax, 0x20(%rbx)
testq %rsi, %rsi
je 0x24266
movq %rsi, %rdi
callq 0x24b32
movq 0x20(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rax
testl %eax, %eax
setne %cl
movq %rax, %rdx
shrq $0x20, %rdx
cmpl $0xffff, %edx           # imm = 0xFFFF
setne %dl
testb %dl, %cl
je 0x242ab
testq %rsi, %rsi
je 0x242b7
movq %rsi, %rdi
callq 0x24b32
movq 0x28(%rbx), %rax
jmp 0x242b7
movq %rbx, %rdi
callq 0x224cc
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x20(%rdi), %r14
cmpq $0x0, 0x28(%rdi)
jne 0x24955
movq %rdi, %rbx
callq 0xc650
movq %r14, %rdi
movq %rax, %rsi
callq 0xc8f0
cmpq $0x0, 0x28(%rbx)
je 0x2492f
leaq 0xc645(%rip), %rsi      # 0x30f6c
movq %r14, %rdi
callq 0xc8e0
movq 0x18(%rbx), %rsi
movl 0x10(%rbx), %edx
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x18(%rax)
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0xc910
leaq -0x30(%rbp), %rdi
callq 0xc9a0
movq (%r14), %rbx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0xc9a0
jmp 0x24977
jmp 0x24974
movq %rax, %r14
movq %r14, %rdi
callq 0xc1d0
movq %rbx, %rdi
callq 0xc650
movq %rax, %rbx
callq 0xc7e0
jmp 0x24958
movq %rax, %rdi
callq 0xc5d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
movl %ecx, %esi
movq %r8, %rdx
movq %rax, %rcx
callq 0x24e5c
leaq 0x23b69(%rip), %rax     # 0x485d8
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
addq $0x40, %rbx
pushq $0x60
popq %rdi
callq 0xc4e0
movq %rax, %r15
movq %rax, %rdi
callq 0x24f16
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24ea6
movq %rbx, %rdi
callq 0x24f4e
movq %rax, %rdi
movq %r14, %rsi
callq 0xc2b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rdi
callq 0xc4a0
jmp 0x24ac9
movq %rax, %r14
movq %r14, %rdi
callq 0xc1d0
movq %rbx, %rdi
callq 0x24f7a
callq 0xc7e0
jmp 0x24aae
movq %rax, %rdi
callq 0xeb96