LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26acb
testq %rbx, %rbx
je 0x270e4
cmpl $0x0, (%rbx)
jne 0x270f3
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2712b
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27105
callq 0xb430
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27123
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb080
testl %eax, %eax
je 0x2715e
callq 0xb060
movl (%rax), %r12d
jmp 0x27161
xorl %r12d, %r12d
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xeb52(%rip), %rsi      # 0x35cc2
leaq 0xeb6c(%rip), %rdx      # 0x35ce3
leaq -0x48(%rbp), %r13
movq %r13, %rdi
callq 0xf8ee
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x26d8e
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x271a9
callq 0xb430
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x271cd
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0xb210
movl %eax, %r14d
testl %eax, %eax
je 0x273bb
callq 0xb060
movl (%rax), %r12d
movl $0x0, -0x38(%rbp)
callq 0x2c4e2
movq %rax, -0x30(%rbp)
cmpl $0x11, %r12d
jne 0x273cd
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x2869d
cmpl $0x3, %eax
jne 0x273cd
testq %rbx, %rbx
je 0x273de
movl $0x0, (%rbx)
callq 0x2c4e2
jmp 0x273da
testq %rbx, %rbx
je 0x273f3
callq 0x2c4e2
movl %r12d, (%rbx)
movq %rax, 0x8(%rbx)
testl %r14d, %r14d
sete %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x50, %edi
callq 0xb250
movq %rax, %rbx
leaq -0x48(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0xe83f(%rip), %rsi      # 0x35c4e
leaq 0xe85b(%rip), %rdx      # 0x35c71
leaq -0x58(%rbp), %rdi
callq 0xf8ee
callq 0x2c4e2
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movl %r12d, %ecx
movq %rax, %r8
callq 0x2946c
leaq 0x24128(%rip), %rsi     # 0x4b568
leaq 0x212f(%rip), %rdx      # 0x29576
movq %rbx, %rdi
callq 0xb7b0
movq %rax, %r14
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x2746d
callq 0xb430
jmp 0x2746d
movq %rax, %r14
movq %rbx, %rdi
callq 0xb360
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb080
testl %eax, %eax
je 0x274a8
callq 0xb060
movl (%rax), %r12d
jmp 0x274ab
xorl %r12d, %r12d
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xe7b8(%rip), %rsi      # 0x35c72
leaq 0xe7dc(%rip), %rdx      # 0x35c9d
leaq -0x48(%rbp), %r13
movq %r13, %rdi
callq 0xf8ee
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x26d8e
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x274f3
callq 0xb430
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x27517
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb120
testl %eax, %eax
je 0x27552
callq 0xb060
movl (%rax), %r12d
jmp 0x27555
xorl %r12d, %r12d
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xe73a(%rip), %rsi      # 0x35c9e
leaq 0xe756(%rip), %rdx      # 0x35cc1
leaq -0x48(%rbp), %r13
movq %r13, %rdi
callq 0xf8ee
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x26d8e
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2759d
callq 0xb430
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x275c1
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movl %edi, %ebx
testl %edi, %edi
je 0x27821
testq %r14, %r14
je 0x27844
callq 0x2c4e2
movl %ebx, (%r14)
jmp 0x27832
testq %r14, %r14
je 0x27836
movl $0x0, (%r14)
callq 0x2c4e2
movq %rax, 0x8(%r14)
testl %ebx, %ebx
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %r15
movq %rsi, %r12
movl $0x50, %edi
callq 0xb250
movq %rax, %r14
callq 0x2c4e2
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebx, %ecx
movq %rax, %r8
callq 0x2946c
leaq 0x23cf2(%rip), %rsi     # 0x4b568
leaq 0x1cf9(%rip), %rdx      # 0x29576
movq %r14, %rdi
callq 0xb7b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq -0xd8(%rbp), %rsi
callq 0xb7c0
testl %eax, %eax
je 0x279c9
callq 0xb060
movl (%rax), %r15d
jmp 0x279cc
xorl %r15d, %r15d
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0xe347(%rip), %rsi      # 0x35d22
leaq 0xe35c(%rip), %rdx      # 0x35d3e
leaq -0x48(%rbp), %rdi
callq 0xf8ee
leaq -0x48(%rbp), %rcx
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x277fe
movl %eax, %r12d
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x27a0e
callq 0xb430
movq $-0x1, %r15
testb %r12b, %r12b
jne 0x27a79
movl -0xc0(%rbp), %r12d
leaq -0x48(%rbp), %rdi
movq %r13, (%rdi)
leaq 0xe2f3(%rip), %rsi      # 0x35d22
leaq 0xe308(%rip), %rdx      # 0x35d3e
callq 0xf8ee
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 0x277fe
movl %eax, %ebx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x27a6e
callq 0xb430
testb %bl, %bl
jne 0x27a79
movq -0xa8(%rbp), %r15
movq %r15, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27a92
jmp 0x27aa5
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x27aa8
callq 0xb430
jmp 0x27aa8
movq %rax, %rbx
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq -0xd8(%rbp), %rsi
callq 0xb7c0
testl %eax, %eax
je 0x27ae7
callq 0xb060
movl (%rax), %r15d
jmp 0x27aea
xorl %r15d, %r15d
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0xe246(%rip), %rsi      # 0x35d3f
leaq 0xe261(%rip), %rdx      # 0x35d61
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0xf8ee
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x277fe
movl %eax, %ebx
movq -0xc8(%rbp), %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x27b34
callq 0xb430
xorl %eax, %eax
testb %bl, %bl
cmovneq %rax, %r14
movq %r14, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x27b62
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24a5d(%rip), %al      # 0x4c5e0
testb %al, %al
je 0x27c06
cmpq $0x0, 0x24a39(%rip)     # 0x4c5c8
je 0x27ba8
testq %r14, %r14
je 0x27bd8
movl $0x0, (%r14)
callq 0x2c4e2
movq %rax, 0x8(%r14)
jmp 0x27bd8
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x275c9
leaq 0x24a02(%rip), %rdi     # 0x4c5c0
movq %r15, %rsi
callq 0xb290
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27bd8
callq 0xb430
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x249da(%rip), %rsi     # 0x4c5c0
movq 0x249db(%rip), %rdx     # 0x4c5c8
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xf98c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xbc03
jmp 0x27b87
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27c25
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
leaq -0xd8(%rbp), %rsi
callq 0xb7c0
movl %eax, %r15d
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0xe0fa(%rip), %rsi      # 0x35d62
leaq 0xe10e(%rip), %rdx      # 0x35d7d
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0xf8ee
xorl %edi, %edi
testl %r15d, %r15d
setne %dil
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x277fe
movl %eax, %r14d
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x27ca3
callq 0xb430
testb %r14b, %r14b
je 0x27cac
xorl %ebx, %ebx
jmp 0x27cf0
movl $0xf000, %eax           # imm = 0xF000
andl -0xc0(%rbp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x27ce5
leaq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29c6a
movq (%r14), %rax
cmpq 0x248c9(%rip), %rax     # 0x4c5a0
sete %bl
leaq -0x40(%rbp), %rdi
callq 0xf546
jmp 0x27cf0
cmpq $0x0, -0xa8(%rbp)
sete %bl
movl %ebx, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x27d15
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq -0xd8(%rbp), %rsi
callq 0xb7c0
testl %eax, %eax
je 0x27d54
callq 0xb060
movl (%rax), %r15d
jmp 0x27d57
xorl %r15d, %r15d
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0xe018(%rip), %rsi      # 0x35d7e
leaq 0xe033(%rip), %rdx      # 0x35da0
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0xf8ee
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x277fe
movl %eax, %ebx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x27d9a
callq 0xb430
movq $-0x1, %rax
testb %bl, %bl
jne 0x27da9
movq -0x80(%rbp), %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x27dcc
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
leaq -0xe8(%rbp), %rsi
callq 0xb7c0
movl %eax, %r12d
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0xdf6c(%rip), %rsi      # 0x35d7e
leaq 0xdf87(%rip), %rdx      # 0x35da0
leaq -0x48(%rbp), %rdi
callq 0xf8ee
xorl %edi, %edi
testl %r12d, %r12d
setne %dil
leaq -0x48(%rbp), %rcx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x277fe
movl %eax, %r12d
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x27e4b
callq 0xb430
testb %r12b, %r12b
jne 0x27eb5
movq -0xa0(%rbp), %rax
leaq -0x58(%rbp), %rsi
movq %rax, (%rsi)
movq %r15, 0x8(%rsi)
movq (%r14), %rdi
callq 0xb280
testl %eax, %eax
je 0x27e78
callq 0xb060
movl (%rax), %r15d
jmp 0x27e7b
xorl %r15d, %r15d
leaq -0x48(%rbp), %rdi
movq %r13, (%rdi)
leaq 0xdef5(%rip), %rsi      # 0x35d7e
leaq 0xdf10(%rip), %rdx      # 0x35da0
callq 0xf8ee
leaq -0x48(%rbp), %rcx
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x277fe
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x27eb5
callq 0xb430
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27ecb
jmp 0x27ede
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x27ee1
callq 0xb430
jmp 0x27ee1
movq %rax, %rbx
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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
xorl %r12d, %r12d
leaq -0x58(%rbp), %r15
movl %r12d, (%r15)
callq 0x2c4e2
movq %rax, 0x8(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x26910
movq %rax, %r15
testl %r15d, %r15d
jne 0x28108
movl -0x58(%rbp), %r12d
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xdd88(%rip), %rsi      # 0x35e9f
leaq 0xdd9a(%rip), %rdx      # 0x35eb8
leaq -0x48(%rbp), %r13
movq %r13, %rdi
callq 0xf8ee
movl %r12d, %edi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x277fe
movl %eax, %r12d
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x28150
callq 0xb430
testb %r12b, %r12b
je 0x28159
xorl %eax, %eax
jmp 0x28167
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x28193
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2818b
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x3, %esi
je 0x281cf
cmpl $0x1, %esi
jne 0x281e5
testq %rbx, %rbx
je 0x2827b
movl $0x0, (%rbx)
callq 0x2c4e2
movq %rax, 0x8(%rbx)
jmp 0x2827b
movq (%r14), %rdi
callq 0xb1f0
testl %eax, %eax
je 0x281fb
callq 0xb060
movl (%rax), %r15d
jmp 0x281fe
movq (%r14), %rdi
callq 0xb220
testl %eax, %eax
je 0x28232
callq 0xb060
movl (%rax), %r15d
jmp 0x28235
xorl %r15d, %r15d
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xdc91(%rip), %rsi      # 0x35e9f
leaq 0xdca3(%rip), %rdx      # 0x35eb8
leaq -0x40(%rbp), %rdi
callq 0xf8ee
leaq -0x40(%rbp), %rcx
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x277fe
jmp 0x28267
xorl %r15d, %r15d
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xdc5a(%rip), %rsi      # 0x35e9f
leaq 0xdc6c(%rip), %rdx      # 0x35eb8
leaq -0x40(%rbp), %rdi
callq 0xf8ee
leaq -0x40(%rbp), %rcx
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x277fe
movl %eax, %ebx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x28277
callq 0xb430
testb %bl, %bl
je 0x2827f
xorl %eax, %eax
jmp 0x28281
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28290
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x282a8
callq 0xb430
jmp 0x282a8
jmp 0x282a5
movq %rax, %rbx
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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, -0x30(%rbp)
movq %rdi, %r14
xorl %r12d, %r12d
leaq -0x60(%rbp), %r15
movl %r12d, (%r15)
callq 0x2c4e2
movq %rax, 0x8(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x26910
movq %rax, %r15
testl %r15d, %r15d
jne 0x282f2
movl -0x60(%rbp), %r12d
leaq -0x40(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0xdbb8(%rip), %rsi      # 0x35eb9
leaq 0xdbce(%rip), %rdx      # 0x35ed6
leaq -0x50(%rbp), %r13
movq %r13, %rdi
callq 0xf8ee
movl %r12d, %edi
movq %r14, %rsi
movq -0x30(%rbp), %rdx
movq %r13, %rcx
callq 0x277fe
movl %eax, %r12d
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x28337
callq 0xb430
cmpl $0x2, %r15d
setb %al
orb %r12b, %al
je 0x28347
xorl %eax, %eax
jmp 0x28356
movq %r14, %rdi
movl %r15d, %esi
movq -0x30(%rbp), %rdx
callq 0x2837e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x28376
callq 0xb430
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %r15
cmpl $0x3, %esi
jne 0x283f3
leaq -0x30(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x29c6a
movl $0x1, %ebx
movq -0x30(%rbp), %rdi
cmpq 0x241e9(%rip), %rdi     # 0x4c5a0
je 0x28405
testq %rdi, %rdi
je 0x28439
movq %r14, %rsi
callq 0x26910
testq %r14, %r14
je 0x283d1
cmpl $0x0, (%r14)
jne 0x28420
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x28439
movl %eax, %esi
movq %r14, %rdx
callq 0x2837e
addq %rax, %rbx
movq %r12, %rdi
xorl %esi, %esi
callq 0x28f27
jmp 0x283ac
movq %r15, %rdi
movq %r14, %rdx
callq 0x28193
movl $0x1, %ebx
jmp 0x28429
leaq -0x28(%rbp), %rdi
callq 0xf546
movq %r15, %rdi
movl $0x3, %esi
movq %r14, %rdx
callq 0x28193
jmp 0x28429
leaq -0x28(%rbp), %rdi
callq 0xf546
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xde76(%rip), %rdi      # 0x362b6
leaq 0xdea6(%rip), %rsi      # 0x362ed
leaq 0xdec1(%rip), %rcx      # 0x3630f
movl $0x346, %edx            # imm = 0x346
callq 0xb310
jmp 0x2845a
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xf546
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 -0xb8(%rbp), %rsi
callq 0xb6d0
movl %eax, %r12d
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xd921(%rip), %rsi      # 0x35f10
leaq 0xd932(%rip), %rdx      # 0x35f28
leaq -0x48(%rbp), %r13
movq %r13, %rdi
callq 0xf8ee
xorl %edi, %edi
testl %r12d, %r12d
setne %dil
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x277fe
movl %eax, %r14d
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2862e
callq 0xb430
testb %r14b, %r14b
je 0x2863b
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x28660
movq -0xb0(%rbp), %rax
movq -0xa8(%rbp), %rcx
imulq %rax, %rcx
movq -0xa0(%rbp), %rdx
imulq %rax, %rdx
imulq -0x98(%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
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x28695
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x2898d
movq %r14, %rdi
callq 0x297bc
testb %al, %al
je 0x289a6
movq 0x8(%r14), %rdx
jmp 0x2898f
xorl %edx, %edx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xf98c
jmp 0x28a15
leaq -0x60(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x275c9
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0xf98c
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x29e38
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xf98c
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x28a03
callq 0xb430
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x28a15
callq 0xb430
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x28a3b
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x28a3b
callq 0xb430
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x28a4d
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rsi, %r14
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 0x28abe
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 0x28aba
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2869d
movq %rax, 0x20(%rbx)
jmp 0x28ad3
movq %rax, 0x20(%rbx)
testq %r14, %r14
je 0x28ad3
movl $0x0, (%r14)
callq 0x2c4e2
movq %rax, 0x8(%r14)
movq 0x20(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rsi, %r14
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 0x28b21
testq %r14, %r14
je 0x28b30
movl $0x0, (%r14)
callq 0x2c4e2
movq %rax, 0x8(%r14)
movq 0x28(%rbx), %rax
jmp 0x28b30
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26910
movq %rax, 0x28(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x20(%rdi), %r14
cmpq $0x0, 0x28(%rdi)
jne 0x293f1
movq %rdi, %rbx
callq 0xb5f0
movq %rax, %r15
movq 0x28(%rbx), %r12
movq %rax, %rdi
callq 0xb200
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0xb6f0
cmpq $0x0, 0x28(%rbx)
je 0x293be
leaq 0xdb16(%rip), %rsi      # 0x36ecc
movq %r14, %rdi
callq 0xb880
movq 0x18(%rbx), %rsi
movl 0x10(%rbx), %edx
movq (%rsi), %rax
leaq -0x40(%rbp), %rdi
callq *0x18(%rax)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %r14, %rdi
callq 0xb160
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x293f1
callq 0xb430
movq (%r14), %rbx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29420
callq 0xb430
jmp 0x29420
jmp 0x2941d
movq %rax, %r14
movq %r14, %rdi
callq 0xb1e0
movq %rbx, %rdi
callq 0xb5f0
movq %rax, %rbx
callq 0xb780
jmp 0x293f4
movq %rax, %rdi
callq 0xb590
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r15
movl %ecx, %r12d
movq %rdx, %r14
movq %rdi, %rbx
callq 0xb570
movl %r12d, 0x10(%rbx)
movq %r15, 0x18(%rbx)
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
movb $0x0, 0x30(%rbx)
leaq 0x22109(%rip), %rax     # 0x4b5b8
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movl $0x60, %edi
callq 0xb460
leaq 0x40(%rbx), %r15
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movb %cl, 0x10(%rax)
leaq 0x30(%rax), %rdx
movq %rdx, 0x20(%rax)
movq %rcx, 0x28(%rax)
movb %cl, 0x30(%rax)
movq %rax, %rdx
addq $0x50, %rdx
movq %rdx, 0x40(%rax)
movq %rcx, 0x48(%rax)
movb %cl, 0x50(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x297f6
movq (%r15), %rdi
testq %rdi, %rdi
je 0x29520
movq %r14, %rsi
callq 0xb290
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x910d(%rip), %rdi      # 0x32634
leaq 0x910e(%rip), %rsi      # 0x3263c
leaq 0xcc4c(%rip), %rcx      # 0x36181
movl $0x2af, %edx            # imm = 0x2AF
callq 0xb310
movq %rax, %rdi
callq 0xb1e0
movq 0x40(%rbx), %rax
leaq -0x28(%rbp), %rdi
movq %rax, -0x8(%rdi)
movq 0x48(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movq %rax, (%rdi)
callq 0xf546
callq 0xb780
jmp 0x29513
movq %rax, %rdi
callq 0xe915
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movl %r8d, %r13d
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
callq 0xb570
movl %r13d, 0x10(%rbx)
movq %r12, 0x18(%rbx)
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
movb $0x0, 0x30(%rbx)
leaq 0x21fd0(%rip), %rax     # 0x4b5b8
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movl $0x60, %edi
callq 0xb460
leaq 0x40(%rbx), %r12
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movb %cl, 0x10(%rax)
leaq 0x30(%rax), %rdx
movq %rdx, 0x20(%rax)
movq %rcx, 0x28(%rax)
movb %cl, 0x30(%rax)
movq %rax, %rdx
addq $0x50, %rdx
movq %rdx, 0x40(%rax)
movq %rcx, 0x48(%rax)
movb %cl, 0x50(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0x297f6
movq (%r12), %rdi
testq %rdi, %rdi
je 0x29671
movq %r15, %rsi
callq 0xb290
movq (%r12), %rdi
testq %rdi, %rdi
je 0x29671
addq $0x20, %rdi
movq %r14, %rsi
callq 0xb290
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8fbc(%rip), %rdi      # 0x32634
leaq 0x8fbd(%rip), %rsi      # 0x3263c
leaq 0xcafb(%rip), %rcx      # 0x36181
movl $0x2af, %edx            # imm = 0x2AF
callq 0xb310
movq %rax, %rdi
callq 0xb1e0
movq 0x40(%rbx), %rax
leaq -0x30(%rbp), %rdi
movq %rax, -0x8(%rdi)
movq 0x48(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movq %rax, (%rdi)
callq 0xf546
callq 0xb780
jmp 0x29662
movq %rax, %rdi
callq 0xe915
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
movq (%rdi), %rax
movb $0x0, (%rax)
cmpq %rdx, %rsi
je 0x29725
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0xf98c
movq (%r14), %rcx
testq %rcx, %rcx
je 0x29733
movq -0x30(%rbp), %r8
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xb4f0
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x29725
callq 0xb430
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcda8(%rip), %rdi      # 0x364e2
leaq 0xcda6(%rip), %rsi      # 0x364e7
leaq 0xcdc2(%rip), %rcx      # 0x3650a
movl $0xc2, %edx
callq 0xb310
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x29763
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
nop