LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/program_options/src/variables_map.cpp
// Function: boost::program_options::variables_map::notify()
void
    variables_map::notify()
    {
        // This checks if all required options occur
        for (map<string, string>::const_iterator r = m_required.begin();
             r != m_required.end();
             ++r)
        {
            const string& opt = r->first;
            const string& display_opt = r->second;
            map<string, variable_value>::const_iterator iter = find(opt);
            if (iter == end() || iter->second.empty())
            {
                boost::throw_exception(required_option(display_opt));

            }
        }

        // Lastly, run notify actions.
        for (map<string, variable_value>::iterator k = begin();
             k != end();
             ++k)
        {
            /* Users might wish to use variables_map to store their own values
               that are not parsed, and therefore will not have value_semantics
               defined. Do not crash on such values. In multi-module programs,
               one module might add custom values, and the 'notify' function
               will be called after that, so we check that value_sematics is
               not NULL. See:
                   https://svn.boost.org/trac/boost/ticket/2782
            */
            if (k->second.m_value_semantic)
                k->second.m_value_semantic->notify(k->second.value());
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
movq 0x88(%rdi), %r14
leaq 0x78(%rdi), %r12
cmpq %r12, %r14
je 0x24e9b
leaq 0x10(%rbx), %r15
leaq 0x18(%rbx), %r13
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x259b0
cmpq %r13, %rax
je 0x24edd
cmpq $0x0, 0x40(%rax)
je 0x24edd
movq %r14, %rdi
callq 0xb510
movq %rax, %r14
cmpq %r12, %rax
jne 0x24e73
movq 0x28(%rbx), %r14
addq $0x18, %rbx
cmpq %rbx, %r14
je 0x24ecb
movq 0x50(%r14), %rdi
testq %rdi, %rdi
je 0x24ebb
leaq 0x40(%r14), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq %r14, %rdi
callq 0xb330
movq %rax, %r14
cmpq %rbx, %rax
jne 0x24ea8
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x40, %r14
leaq -0xe0(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25282
movq %rbx, %rdi
callq 0x25195
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0xedb6
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/program_options/src/variables_map.cpp
// Function: boost::program_options::abstract_variables_map::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const variable_value&
    abstract_variables_map::operator[](const std::string& name) const
    {
        const variable_value& v = get(name);
        if (v.empty() && m_next)
            return (*m_next)[name];
        else if (v.defaulted() && m_next) {
            const variable_value& v2 = (*m_next)[name];
            if (!v2.empty() && !v2.defaulted())
                return v2;
            else return v;
        } else {
            return v;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
movq %rax, %rbx
cmpq $0x0, (%rax)
jne 0x24f69
movq 0x8(%r15), %rdi
testq %rdi, %rdi
jne 0x24f4b
cmpb $0x1, 0x8(%rbx)
jne 0x24f8c
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x24f8c
movq %r14, %rsi
callq 0x24f3e
cmpq $0x0, (%rax)
je 0x24f8c
cmpb $0x1, 0x8(%rax)
jne 0x24f8f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/program_options/src/variables_map.cpp
// Function: boost::program_options::variables_map::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const variable_value&
    variables_map::get(const std::string& name) const
    {
        static variable_value empty;
        const_iterator i = this->find(name);
        if (i == this->end())
            return empty;
        else
            return i->second;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movb 0x274d3(%rip), %al      # 0x4c588
testb %al, %al
je 0x250e0
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x2586a
addq $0x18, %rbx
leaq 0x40(%rax), %rcx
cmpq %rbx, %rax
leaq 0x27491(%rip), %rax     # 0x4c568
cmovneq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0xbb88
jmp 0x250b9
nop
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/codecvt_error_category.cpp
// Function: (anonymous namespace)::codecvt_error_cat::message[abi:cxx11](int) const
std::string codecvt_error_cat::message(int ev) const
  {
    std::string str;
    switch (ev)
    {
    case std::codecvt_base::ok:
      str = "ok";
      break;
    case std::codecvt_base::partial:
      str = "partial";
      break;
    case std::codecvt_base::error:
      str = "error";
      break;
    case std::codecvt_base::noconv:
      str = "noconv";
      break;
    default:
      str = "unknown error";
    }
    return str;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpl $0x4, %edx
jae 0x25f58
movl %edx, %eax
leaq 0xfa04(%rip), %rdx      # 0x35948
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
leaq 0xfa66(%rip), %rdx      # 0x359b8
movq (%rdx,%rax,8), %r8
jmp 0x25f65
movl $0xd, %r8d
leaq 0xf080(%rip), %rcx      # 0x34fe5
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb6f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x25f8f
callq 0xb430
movq %r14, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::copy(boost::filesystem::path const&, boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  void copy(const path& from, const path& to, system::error_code* ec)
  {
    file_status s(symlink_status(from, *ec));
    if (ec != 0 && *ec) return;

    if(is_symlink(s))
    {
      copy_symlink(from, to, *ec);
    }
    else if(is_directory(s))
    {
      copy_directory(from, to, *ec);
    }
    else if(is_regular_file(s))
    {
      copy_file(from, to, fs::copy_option::fail_if_exists, *ec);
    }
    else
    {
      if (ec == 0)
        BOOST_FILESYSTEM_THROW(filesystem_error("boost::filesystem::copy",
          from, to, error_code(BOOST_ERROR_NOT_SUPPORTED, system_category())));
      ec->assign(BOOST_ERROR_NOT_SUPPORTED, system_category());
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rsi
callq 0x26ba2
cmpl $0x0, (%rbx)
je 0x26f09
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %eax
je 0x26f48
cmpl $0x3, %eax
je 0x26f30
cmpl $0x4, %eax
jne 0x26f62
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x27362
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x26f73
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x270c5
callq 0x2c80a
movl $0x26, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x26efe
// File: /workspace/github_cpp_makefile_star2_O1/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, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
leaq -0xe0(%rbp), %rsi
callq 0xb7c0
testl %eax, %eax
jne 0x26fb6
movq (%r14), %rdi
movl -0xc8(%rbp), %esi
callq 0xb210
testl %eax, %eax
je 0x27015
callq 0xb060
movl (%rax), %r12d
leaq -0x40(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0xeb8d(%rip), %rsi      # 0x35b5a
leaq 0xeba7(%rip), %rdx      # 0x35b7b
leaq -0x50(%rbp), %r13
movq %r13, %rdi
callq 0xf97e
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movq -0x30(%rbp), %rcx
movq %r13, %r8
callq 0x27033
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x27003
callq 0xb430
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0x26fbe
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x2702b
callq 0xb430
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
testl %edi, %edi
je 0x2705a
movl %edi, %r14d
testq %rbx, %rbx
je 0x2707d
callq 0x2c80a
movl %r14d, (%rbx)
jmp 0x2706a
testq %rbx, %rbx
je 0x2706e
movl $0x0, (%rbx)
callq 0x2c80a
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %r12
movq %rdx, %r15
movq %rsi, %r13
movl $0x50, %edi
callq 0xb250
movq %rax, %rbx
callq 0x2c80a
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
movl %r14d, %r8d
movq %rax, %r9
callq 0x29886
leaq 0x244b2(%rip), %rsi     # 0x4b568
leaq 0x279f(%rip), %rdx      # 0x2985c
movq %rbx, %rdi
callq 0xb7b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26d68
testq %rbx, %rbx
je 0x27389
cmpl $0x0, (%rbx)
jne 0x27398
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x273d0
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x273aa
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 0x273c8
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x27403
callq 0xb060
movl (%rax), %r12d
jmp 0x27406
xorl %r12d, %r12d
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xe8ad(%rip), %rsi      # 0x35cc2
leaq 0xe8c7(%rip), %rdx      # 0x35ce3
leaq -0x48(%rbp), %r13
movq %r13, %rdi
callq 0xf97e
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x27033
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2744e
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 0x27472
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x27668
callq 0xb060
movl (%rax), %r12d
movl $0x0, -0x38(%rbp)
callq 0x2c80a
movq %rax, -0x30(%rbp)
cmpl $0x11, %r12d
jne 0x2767a
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x28975
cmpl $0x3, %eax
jne 0x2767a
testq %rbx, %rbx
je 0x2768b
movl $0x0, (%rbx)
callq 0x2c80a
jmp 0x27687
testq %rbx, %rbx
je 0x276a0
callq 0x2c80a
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 0xe592(%rip), %rsi      # 0x35c4e
leaq 0xe5ae(%rip), %rdx      # 0x35c71
leaq -0x58(%rbp), %rdi
callq 0xf97e
callq 0x2c80a
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movl %r12d, %ecx
movq %rax, %r8
callq 0x29772
leaq 0x23e7b(%rip), %rsi     # 0x4b568
leaq 0x2168(%rip), %rdx      # 0x2985c
movq %rbx, %rdi
callq 0xb7b0
movq %rax, %r14
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x2770d
callq 0xb430
xorl %eax, %eax
jmp 0x27716
movq %rax, %r14
movb $0x1, %al
testb %al, %al
je 0x27722
movq %rbx, %rdi
callq 0xb360
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2775d
callq 0xb060
movl (%rax), %r12d
jmp 0x27760
xorl %r12d, %r12d
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xe503(%rip), %rsi      # 0x35c72
leaq 0xe527(%rip), %rdx      # 0x35c9d
leaq -0x48(%rbp), %r13
movq %r13, %rdi
callq 0xf97e
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x27033
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x277a8
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 0x277cc
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x27807
callq 0xb060
movl (%rax), %r12d
jmp 0x2780a
xorl %r12d, %r12d
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xe485(%rip), %rsi      # 0x35c9e
leaq 0xe4a1(%rip), %rdx      # 0x35cc1
leaq -0x48(%rbp), %r13
movq %r13, %rdi
callq 0xf97e
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x27033
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x27852
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 0x27876
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x27ad6
testq %r14, %r14
je 0x27af9
callq 0x2c80a
movl %ebx, (%r14)
jmp 0x27ae7
testq %r14, %r14
je 0x27aeb
movl $0x0, (%r14)
callq 0x2c80a
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 0x2c80a
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebx, %ecx
movq %rax, %r8
callq 0x29772
leaq 0x23a3d(%rip), %rsi     # 0x4b568
leaq 0x1d2a(%rip), %rdx      # 0x2985c
movq %r14, %rdi
callq 0xb7b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x27c7e
callq 0xb060
movl (%rax), %r15d
jmp 0x27c81
xorl %r15d, %r15d
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0xe092(%rip), %rsi      # 0x35d22
leaq 0xe0a7(%rip), %rdx      # 0x35d3e
leaq -0x48(%rbp), %rdi
callq 0xf97e
leaq -0x48(%rbp), %rcx
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x27ab3
movl %eax, %r12d
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x27cc3
callq 0xb430
movq $-0x1, %r15
testb %r12b, %r12b
jne 0x27d2e
movl -0xc0(%rbp), %r12d
leaq -0x48(%rbp), %rdi
movq %r13, (%rdi)
leaq 0xe03e(%rip), %rsi      # 0x35d22
leaq 0xe053(%rip), %rdx      # 0x35d3e
callq 0xf97e
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 0x27ab3
movl %eax, %ebx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x27d23
callq 0xb430
testb %bl, %bl
jne 0x27d2e
movq -0xa8(%rbp), %r15
movq %r15, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27d47
jmp 0x27d5a
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x27d5d
callq 0xb430
jmp 0x27d5d
movq %rax, %rbx
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x27d9c
callq 0xb060
movl (%rax), %r15d
jmp 0x27d9f
xorl %r15d, %r15d
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0xdf91(%rip), %rsi      # 0x35d3f
leaq 0xdfac(%rip), %rdx      # 0x35d61
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0xf97e
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x27ab3
movl %eax, %ebx
movq -0xc8(%rbp), %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x27de9
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 0x27e17
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x247a8(%rip), %al      # 0x4c5e0
testb %al, %al
je 0x27ebb
cmpq $0x0, 0x24784(%rip)     # 0x4c5c8
je 0x27e5d
testq %r14, %r14
je 0x27e8d
movl $0x0, (%r14)
callq 0x2c80a
movq %rax, 0x8(%r14)
jmp 0x27e8d
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2787e
leaq 0x2474d(%rip), %rdi     # 0x4c5c0
movq %r15, %rsi
callq 0xb290
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27e8d
callq 0xb430
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x24725(%rip), %rsi     # 0x4c5c0
movq 0x24726(%rip), %rdx     # 0x4c5c8
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xfa18
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xbc0f
jmp 0x27e3c
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27eda
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xde45(%rip), %rsi      # 0x35d62
leaq 0xde59(%rip), %rdx      # 0x35d7d
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0xf97e
xorl %edi, %edi
testl %r15d, %r15d
setne %dil
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x27ab3
movl %eax, %r14d
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x27f58
callq 0xb430
testb %r14b, %r14b
je 0x27f61
xorl %ebx, %ebx
jmp 0x27fa5
movl $0xf000, %eax           # imm = 0xF000
andl -0xc0(%rbp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x27f9a
leaq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29f64
movq (%r14), %rax
cmpq 0x24614(%rip), %rax     # 0x4c5a0
sete %bl
leaq -0x40(%rbp), %rdi
callq 0xf5d6
jmp 0x27fa5
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 0x27fca
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28009
callq 0xb060
movl (%rax), %r15d
jmp 0x2800c
xorl %r15d, %r15d
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0xdd63(%rip), %rsi      # 0x35d7e
leaq 0xdd7e(%rip), %rdx      # 0x35da0
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0xf97e
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x27ab3
movl %eax, %ebx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x2804f
callq 0xb430
movq $-0x1, %rax
testb %bl, %bl
jne 0x2805e
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 0x28081
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xdcb7(%rip), %rsi      # 0x35d7e
leaq 0xdcd2(%rip), %rdx      # 0x35da0
leaq -0x48(%rbp), %rdi
callq 0xf97e
xorl %edi, %edi
testl %r12d, %r12d
setne %dil
leaq -0x48(%rbp), %rcx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x27ab3
movl %eax, %r12d
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x28100
callq 0xb430
testb %r12b, %r12b
jne 0x2816a
movq -0xa0(%rbp), %rax
leaq -0x58(%rbp), %rsi
movq %rax, (%rsi)
movq %r15, 0x8(%rsi)
movq (%r14), %rdi
callq 0xb280
testl %eax, %eax
je 0x2812d
callq 0xb060
movl (%rax), %r15d
jmp 0x28130
xorl %r15d, %r15d
leaq -0x48(%rbp), %rdi
movq %r13, (%rdi)
leaq 0xdc40(%rip), %rsi      # 0x35d7e
leaq 0xdc5b(%rip), %rdx      # 0x35da0
callq 0xf97e
leaq -0x48(%rbp), %rcx
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x27ab3
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x2816a
callq 0xb430
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28180
jmp 0x28193
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x28196
callq 0xb430
jmp 0x28196
movq %rax, %rbx
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c80a
movq %rax, 0x8(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x26ba2
movq %rax, %r15
testl %r15d, %r15d
jne 0x283cb
movl -0x58(%rbp), %r12d
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xdac5(%rip), %rsi      # 0x35e9f
leaq 0xdad7(%rip), %rdx      # 0x35eb8
leaq -0x48(%rbp), %r13
movq %r13, %rdi
callq 0xf97e
movl %r12d, %edi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x27ab3
movl %eax, %r12d
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x28413
callq 0xb430
testb %r12b, %r12b
je 0x2841c
xorl %eax, %eax
jmp 0x2842a
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x28456
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 0x2844e
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28492
cmpl $0x1, %esi
jne 0x284a8
testq %rbx, %rbx
je 0x2853e
movl $0x0, (%rbx)
callq 0x2c80a
movq %rax, 0x8(%rbx)
jmp 0x2853e
movq (%r14), %rdi
callq 0xb1f0
testl %eax, %eax
je 0x284be
callq 0xb060
movl (%rax), %r15d
jmp 0x284c1
movq (%r14), %rdi
callq 0xb220
testl %eax, %eax
je 0x284f5
callq 0xb060
movl (%rax), %r15d
jmp 0x284f8
xorl %r15d, %r15d
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xd9ce(%rip), %rsi      # 0x35e9f
leaq 0xd9e0(%rip), %rdx      # 0x35eb8
leaq -0x40(%rbp), %rdi
callq 0xf97e
leaq -0x40(%rbp), %rcx
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x27ab3
jmp 0x2852a
xorl %r15d, %r15d
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xd997(%rip), %rsi      # 0x35e9f
leaq 0xd9a9(%rip), %rdx      # 0x35eb8
leaq -0x40(%rbp), %rdi
callq 0xf97e
leaq -0x40(%rbp), %rcx
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x27ab3
movl %eax, %ebx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x2853a
callq 0xb430
testb %bl, %bl
je 0x28542
xorl %eax, %eax
jmp 0x28544
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28553
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x2856b
callq 0xb430
jmp 0x2856b
jmp 0x28568
movq %rax, %rbx
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c80a
movq %rax, 0x8(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x26ba2
movq %rax, %r15
testl %r15d, %r15d
jne 0x285b5
movl -0x60(%rbp), %r12d
leaq -0x40(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0xd8f5(%rip), %rsi      # 0x35eb9
leaq 0xd90b(%rip), %rdx      # 0x35ed6
leaq -0x50(%rbp), %r13
movq %r13, %rdi
callq 0xf97e
movl %r12d, %edi
movq %r14, %rsi
movq -0x30(%rbp), %rdx
movq %r13, %rcx
callq 0x27ab3
movl %eax, %r12d
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x285fa
callq 0xb430
cmpl $0x2, %r15d
setb %al
orb %r12b, %al
je 0x2860a
xorl %eax, %eax
jmp 0x28619
movq %r14, %rdi
movl %r15d, %esi
movq -0x30(%rbp), %rdx
callq 0x28641
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 0x28639
callq 0xb430
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %rax
movl $0x1, %r12d
cmpl $0x3, %esi
jne 0x286e9
movl %esi, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq %rax, %rsi
callq 0x29f64
movq -0x40(%rbp), %r15
movq 0x23f1b(%rip), %r13     # 0x4c5a0
cmpq %r13, %r15
je 0x286d4
testq %r15, %r15
je 0x28709
movq %r15, %rdi
movq %rbx, %rsi
callq 0x26ba2
testq %rbx, %rbx
je 0x286ab
cmpl $0x0, (%rbx)
je 0x286ab
xorl %eax, %eax
movq %r12, %r14
jmp 0x286c3
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x28709
movl %eax, %esi
movq %rbx, %rdx
callq 0x28641
addq %rax, %r12
movb $0x1, %al
testb %al, %al
je 0x286d4
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x2921f
jmp 0x2867a
leaq -0x38(%rbp), %rdi
callq 0xf5d6
cmpq %r13, %r15
movl -0x2c(%rbp), %esi
movq -0x48(%rbp), %rax
jne 0x286f7
movq %rax, %rdi
movq %rbx, %rdx
callq 0x28456
movq %r12, %r14
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xdba6(%rip), %rdi      # 0x362b6
leaq 0xdbd6(%rip), %rsi      # 0x362ed
leaq 0xdbf1(%rip), %rcx      # 0x3630f
movl $0x346, %edx            # imm = 0x346
callq 0xb310
jmp 0x2872a
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xf5d6
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd651(%rip), %rsi      # 0x35f10
leaq 0xd662(%rip), %rdx      # 0x35f28
leaq -0x48(%rbp), %r13
movq %r13, %rdi
callq 0xf97e
xorl %edi, %edi
testl %r12d, %r12d
setne %dil
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x27ab3
movl %eax, %r14d
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x288fe
callq 0xb430
testb %r14b, %r14b
je 0x28913
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
jmp 0x28943
movq -0xb0(%rbp), %rax
movq -0xa8(%rbp), %rcx
imulq %rax, %rcx
movq %rcx, (%rbx)
movq -0xa0(%rbp), %rcx
imulq %rax, %rcx
movq %rcx, 0x8(%rbx)
imulq -0x98(%rbp), %rax
movq %rax, 0x10(%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 0x2896d
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28c6a
movq %r14, %rdi
callq 0x29a86
testb %al, %al
je 0x28c85
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xfa18
jmp 0x28cf4
leaq -0x60(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x2787e
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0xfa18
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x2a134
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xfa18
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x28ce2
callq 0xb430
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x28cf4
callq 0xb430
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x28d1a
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x28d1a
callq 0xb430
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x28d2c
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28d9c
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 0x28d98
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28975
movq %rax, 0x20(%rbx)
jmp 0x28db1
movq %rax, 0x20(%rbx)
testq %r14, %r14
je 0x28db1
movl $0x0, (%r14)
callq 0x2c80a
movq %rax, 0x8(%r14)
movq 0x20(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq