LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
shrq $0x20, %rax
cmpl $0xffff, %eax           # imm = 0xFFFF
setne %al
testb %al, %cl
je 0x28df7
testq %r14, %r14
je 0x28e06
movl $0x0, (%r14)
callq 0x2c80a
movq %rax, 0x8(%r14)
jmp 0x28e06
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26ba2
movq %rax, 0x28(%rbx)
movq 0x28(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x296f7
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 0x296c4
leaq 0xd810(%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 0x296f7
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 0x29726
callq 0xb430
jmp 0x29726
jmp 0x29723
movq %rax, %r14
movq %r14, %rdi
callq 0xb1e0
movq %rbx, %rdi
callq 0xb5f0
movq %rax, %rbx
callq 0xb780
jmp 0x296fa
movq %rax, %rdi
callq 0xb590
// File: /workspace/github_cpp_makefile_star2_O1/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
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 0x21e07(%rip), %rax     # 0x4b5b8
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
addq $0x40, %rbx
movl $0x60, %edi
callq 0xb460
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 %rbx, %rdi
movq %rax, %rsi
callq 0x29ac0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2981e
movq %r14, %rsi
callq 0xb290
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8e0f(%rip), %rdi      # 0x32634
leaq 0x8e10(%rip), %rsi      # 0x3263c
leaq 0xc94e(%rip), %rcx      # 0x36181
movl $0x2af, %edx            # imm = 0x2AF
callq 0xb310
movq %rax, %rdi
callq 0xb1e0
movq %rbx, %rdi
callq 0x29b30
callq 0xb780
jmp 0x29815
movq %rax, %rdi
callq 0xe997
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
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 0x21ced(%rip), %rax     # 0x4b5b8
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
addq $0x40, %rbx
movl $0x60, %edi
callq 0xb460
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 %rbx, %rdi
movq %rax, %rsi
callq 0x29ac0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x29952
movq %r15, %rsi
callq 0xb290
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x29952
addq $0x20, %rdi
movq %r14, %rsi
callq 0xb290
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8cdb(%rip), %rdi      # 0x32634
leaq 0x8cdc(%rip), %rsi      # 0x3263c
leaq 0xc81a(%rip), %rcx      # 0x36181
movl $0x2af, %edx            # imm = 0x2AF
callq 0xb310
movq %rax, %rdi
callq 0xb1e0
movq %rbx, %rdi
callq 0x29b30
callq 0xb780
jmp 0x29943
movq %rax, %rdi
callq 0xe997
// File: /workspace/github_cpp_makefile_star2_O1/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 0x299ef
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0xfa18
movq (%r14), %rcx
testq %rcx, %rcx
je 0x299fd
movq -0x30(%rbp), %r8
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xb4f0
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x299ef
callq 0xb430
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcade(%rip), %rdi      # 0x364e2
leaq 0xcadc(%rip), %rsi      # 0x364e7
leaq 0xcaf8(%rip), %rcx      # 0x3650a
movl $0xc2, %edx
callq 0xb310
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x29a2d
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./boost/filesystem/operations.hpp
// Function: boost::filesystem::filesystem_error::what() const
const char* what() const BOOST_NOEXCEPT_OR_NOTHROW
      {
        if (!m_imp_ptr.get())
        return system::system_error::what();

        try
        {
          if (m_imp_ptr->m_what.empty())
          {
            m_imp_ptr->m_what = system::system_error::what();
            if (!m_imp_ptr->m_path1.empty())
            {
              m_imp_ptr->m_what += ": \"";
              m_imp_ptr->m_what += m_imp_ptr->m_path1.string();
              m_imp_ptr->m_what += "\"";
            }
            if (!m_imp_ptr->m_path2.empty())
            {
              m_imp_ptr->m_what += ", \"";
              m_imp_ptr->m_what += m_imp_ptr->m_path2.string();
              m_imp_ptr->m_what += "\"";
            }
          }
          return m_imp_ptr->m_what.c_str();
        }
        catch (...)
        {
          return system::system_error::what();
        }
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x29ccb
cmpq $0x0, 0x48(%rax)
jne 0x29cb2
movq %rbx, %rdi
callq 0x2966a
movq 0x40(%rbx), %r15
testq %r15, %r15
je 0x29cdb
movq %rax, %r14
movq 0x48(%r15), %r12
addq $0x40, %r15
movq %rax, %rdi
callq 0xb200
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0xb6f0
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x29cdb
cmpq $0x0, 0x8(%rdi)
je 0x29c5f
addq $0x40, %rdi
leaq 0xc616(%rip), %rsi      # 0x36236
callq 0xb880
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x29cdb
leaq 0x40(%rax), %rdi
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0xb160
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x29cdb
addq $0x40, %rdi
leaq 0xc5e2(%rip), %rsi      # 0x3623c
callq 0xb880
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x29cdb
cmpq $0x0, 0x28(%rdi)
je 0x29cb2
addq $0x40, %rdi
leaq 0xc5c0(%rip), %rsi      # 0x3623a
callq 0xb880
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x29cdb
leaq 0x40(%rax), %rdi
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
callq 0xb160
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x29cdb
addq $0x40, %rdi
leaq 0xc58f(%rip), %rsi      # 0x3623c
callq 0xb880
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x29cdb
movq 0x40(%rax), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2966a
leaq 0x8952(%rip), %rdi      # 0x32634
leaq 0x8953(%rip), %rsi      # 0x3263c
leaq 0xc491(%rip), %rcx      # 0x36181
movl $0x2af, %edx            # imm = 0x2AF
callq 0xb310
movq %rax, %rdi
callq 0xb1e0
movq %rbx, %rdi
callq 0x2966a
movq %rax, %rbx
callq 0xb780
jmp 0x29cbf
movq %rax, %rdi
callq 0xe997
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./boost/filesystem/operations.hpp
// Function: boost::filesystem::detail::dir_itr_imp::~dir_itr_imp()
~dir_itr_imp() // never throws
    {
      dir_itr_close(handle
#       if defined(BOOST_POSIX_API)
         , buffer
#       endif
    );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x30, %rdi
leaq 0x38(%rbx), %rsi
callq 0x28e35
movq (%rbx), %rdi
addq $0x10, %rbx
addq $0x8, %rsp
cmpq %rbx, %rdi
je 0x2a131
popq %rbx
popq %rbp
jmp 0xb430
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::operator/=(boost::filesystem::path const&)
path& path::operator/=(const path& p)
  {
    if (p.empty())
      return *this;
    if (this == &p)  // self-append
    {
      path rhs(p);
      if (!is_separator(rhs.m_pathname[0]))
        m_append_separator_if_needed();
      m_pathname += rhs.m_pathname;
    }
    else
    {
      if (!is_separator(*p.m_pathname.begin()))
        m_append_separator_if_needed();
      m_pathname += p.m_pathname;
    }
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x2a1f2
movq %rsi, %r14
cmpq %rsi, %rbx
je 0x2a192
movq (%r14), %rax
cmpb $0x2f, (%rax)
je 0x2a181
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x2a181
movq (%rbx), %rcx
cmpb $0x2f, -0x1(%rcx,%rax)
je 0x2a181
movq %rbx, %rdi
movl $0x2f, %esi
callq 0xb3f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xb160
jmp 0x2a1f2
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
addq %rsi, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0xfa18
movq (%r14), %rax
cmpb $0x2f, (%rax)
je 0x2a1d4
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x2a1d4
movq (%rbx), %rcx
cmpb $0x2f, -0x1(%rcx,%rax)
je 0x2a1d4
movq %rbx, %rdi
movl $0x2f, %esi
callq 0xb3f0
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0xb160
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x2a1f2
callq 0xb430
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x2a211
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::m_append_separator_if_needed()
path::string_type::size_type path::m_append_separator_if_needed()
  {
    if (!m_pathname.empty() &&
#     ifdef BOOST_WINDOWS_API
      *(m_pathname.end()-1) != colon && 
#     endif
      !is_separator(*(m_pathname.end()-1)))
    {
      string_type::size_type tmp(m_pathname.size());
      m_pathname += preferred_separator;
      return tmp;
    }
    return 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x2a233
movq (%rdi), %rax
cmpb $0x2f, -0x1(%rax,%rbx)
jne 0x2a237
xorl %ebx, %ebx
jmp 0x2a241
movl $0x2f, %esi
callq 0xb3f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::operator/=(char const*)
path& path::operator/=(const value_type* ptr)
  {
    if (!*ptr)
      return *this;
    if (ptr >= m_pathname.data()
      && ptr < m_pathname.data() + m_pathname.size())  // overlapping source
    {
      path rhs(ptr);
      if (!is_separator(rhs.m_pathname[0]))
        m_append_separator_if_needed();
      m_pathname += rhs.m_pathname;
    }
    else
    {
      if (!is_separator(*ptr))
        m_append_separator_if_needed();
      m_pathname += ptr;
    }
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0x2a309
movq %rsi, %r14
movq (%rbx), %rax
cmpq %rsi, %rax
ja 0x2a2dc
movq 0x8(%rbx), %rdx
addq %rax, %rdx
cmpq %r14, %rdx
jbe 0x2a2dc
leaq -0x40(%rbp), %r15
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xb1c0
movq (%r15), %rax
cmpb $0x2f, (%rax)
je 0x2a2b8
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x2a2b8
movq (%rbx), %rcx
cmpb $0x2f, -0x1(%rcx,%rax)
je 0x2a2b8
movq %rbx, %rdi
movl $0x2f, %esi
callq 0xb3f0
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0xb160
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a309
callq 0xb430
jmp 0x2a309
cmpb $0x2f, %cl
je 0x2a2fe
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x2a2fe
cmpb $0x2f, -0x1(%rax,%rcx)
je 0x2a2fe
movq %rbx, %rdi
movl $0x2f, %esi
callq 0xb3f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb880
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a32c
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::detail::lex_compare(boost::filesystem::path::iterator, boost::filesystem::path::iterator, boost::filesystem::path::iterator, boost::filesystem::path::iterator)
BOOST_FILESYSTEM_DECL
      int lex_compare(path::iterator first1, path::iterator last1,
        path::iterator first2, path::iterator last2)
    {
      for (; first1 != last1 && first2 != last2;)
      {
        if (first1->native() < first2->native()) return -1;
        if (first2->native() < first1->native()) return 1;
        BOOST_ASSERT(first2->native() == first1->native());
        ++first1;
        ++first2;
      }
      if (first1 == last1 && first2 == last2)
        return 0;
      return first1 == last1 ? -1 : 1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x20(%rdi), %rdx
movq 0x28(%rdi), %rcx
movq 0x20(%rsi), %rdi
movq 0x28(%rsi), %rsi
movq %rdx, %rax
xorq %rdi, %rax
movq %rcx, %r8
xorq %rsi, %r8
orq %rax, %r8
je 0x2a4e0
movq 0x20(%rbx), %rax
cmpq 0x20(%r14), %rax
jne 0x2a473
movq 0x28(%r14), %rax
cmpq %rax, 0x28(%rbx)
je 0x2a4e0
movq %r12, %rdi
movq %rbx, %rsi
callq 0xb050
testl %eax, %eax
js 0x2a512
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb050
testl %eax, %eax
js 0x2a519
movq 0x8(%rbx), %rdx
cmpq 0x8(%r12), %rdx
jne 0x2a520
testq %rdx, %rdx
je 0x2a4b9
movq (%r12), %rsi
movq (%rbx), %rdi
callq 0xb480
testl %eax, %eax
jne 0x2a520
movq %r12, %rdi
callq 0x2b496
movq %rbx, %rdi
callq 0x2b496
movq 0x20(%r12), %rdx
movq 0x28(%r12), %rcx
movq 0x20(%r15), %rdi
movq 0x28(%r15), %rsi
jmp 0x2a44a
movl $0x1, %eax
cmpq %rdi, %rdx
jne 0x2a509
cmpq %rsi, %rcx
jne 0x2a509
movq 0x20(%rbx), %rcx
xorq 0x20(%r14), %rcx
movq 0x28(%r14), %rdx
xorq 0x28(%rbx), %rdx
xorl %eax, %eax
orq %rcx, %rdx
setne %al
negl %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2a509
movl $0x1, %eax
jmp 0x2a509
leaq 0xc116(%rip), %rdi      # 0x3663d
leaq 0xc134(%rip), %rsi      # 0x36662
leaq 0xc14c(%rip), %rcx      # 0x36681
movl $0x291, %edx            # imm = 0x291
callq 0xb310
jmp 0x2a541
movq %rax, %rdi
callq 0xe997
nop
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::begin() const
path::iterator path::begin() const
  {
    iterator itr;
    itr.m_path_ptr = this;
    size_type element_size;
    first_element(m_pathname, itr.m_pos, element_size);
    itr.m_element = m_pathname.substr(itr.m_pos, element_size);
    if (itr.m_element.m_pathname == preferred_separator_string)
      itr.m_element.m_pathname = separator_string;  // needed for Windows, harmless on POSIX
    return itr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
xorl %ecx, %ecx
movq %rcx, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, 0x20(%rdi)
movq 0x8(%rsi), %rax
movq %rcx, 0x28(%rdi)
testq %rax, %rax
je 0x2a5e8
cmpq $0x1, %rax
je 0x2a5a1
movq (%rsi), %rdx
cmpb $0x2f, (%rdx)
jne 0x2a5a1
cmpb $0x2f, 0x1(%rdx)
jne 0x2a5a1
movl $0x2, %ecx
cmpq $0x2, %rax
je 0x2a5cf
cmpb $0x2f, 0x2(%rdx)
jne 0x2a5cf
movq (%rsi), %rdx
cmpb $0x2f, (%rdx)
jne 0x2a5cd
movl $0x1, %ecx
cmpq $0x1, %rax
je 0x2a5e8
movl $0x1, %edi
cmpb $0x2f, (%rdx,%rdi)
jne 0x2a5e8
movq %rdi, 0x28(%rbx)
incq %rdi
cmpq %rdi, %rax
jne 0x2a5b9
jmp 0x2a5e8
xorl %ecx, %ecx
cmpq %rax, %rcx
jae 0x2a5e8
movq (%rsi), %rdx
cmpb $0x2f, (%rdx,%rcx)
je 0x2a5e8
incq %rcx
cmpq %rcx, %rax
jne 0x2a5d7
movq %rax, %rcx
movq 0x28(%rbx), %rdx
leaq -0x38(%rbp), %rdi
callq 0xb490
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0xb290
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a613
callq 0xb430
leaq 0xaa3a(%rip), %rsi      # 0x35054
movq %rbx, %rdi
callq 0xb110
testl %eax, %eax
jne 0x2a641
movq 0x8(%rbx), %rdx
leaq 0xaa23(%rip), %rcx      # 0x35054
movl $0x1, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb6f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a668
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a66b
callq 0xb430
jmp 0x2a66b
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2a678
callq 0xb430
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::end() const
path::iterator path::end() const
  {
    iterator itr;
    itr.m_path_ptr = this;
    itr.m_pos = m_pathname.size();
    return itr;
  }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x2a6cc
cmpq %rsi, 0x8(%rdi)
jbe 0x2a6cc
movq (%rdi), %rax
cmpb $0x2f, 0x1(%rax,%rsi)
jne 0x2a6cc
movl $0x1, %edx
popq %rbp
jmp 0xb0d0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::m_parent_path_end() const
string_type::size_type path::m_parent_path_end() const
  {
    size_type end_pos(filename_pos(m_pathname, m_pathname.size()));

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %rsi
callq 0x2ac0e
movq %rax, %rbx
cmpq $0x0, 0x8(%r14)
je 0x2a73f
movq (%r14), %rax
cmpb $0x2f, (%rax,%rbx)
setne %r15b
jmp 0x2a742
movb $0x1, %r15b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2aafe
movq (%r14), %rdx
leaq 0x1(%rax), %rcx
incq %rbx
movq %rax, %rdi
negq %rdi
cmpq $0x1, %rbx
je 0x2a77d
leaq (%rdi,%rbx), %rsi
cmpq $0x2, %rsi
je 0x2a781
leaq -0x1(%rbx), %rsi
cmpb $0x2f, -0x2(%rdx,%rbx)
movq %rsi, %rbx
je 0x2a75d
jmp 0x2a784
xorl %esi, %esi
jmp 0x2a784
movq %rcx, %rsi
movq %rsi, %rcx
xorq $0x1, %rcx
orq %rcx, %rax
movq $-0x1, %rax
cmovneq %rsi, %rax
testb %r15b, %r15b
cmovneq %rsi, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::replace_extension(boost::filesystem::path const&)
path& path::replace_extension(const path& new_extension)
  {
    // erase existing extension, including the dot, if any
    m_pathname.erase(m_pathname.size()-extension().m_pathname.size());

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

    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2a898
subq 0x8(%r12), %r15
movq 0x8(%rbx), %rcx
cmpq %r15, %rcx
jb 0x2a863
movq %r15, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax,%r15)
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a828
callq 0xb430
cmpq $0x0, 0x8(%r14)
je 0x2a853
movq (%r14), %rax
cmpb $0x2e, (%rax)
je 0x2a844
movq %rbx, %rdi
movl $0x2e, %esi
callq 0xb3f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xb160
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc061(%rip), %rdi      # 0x368cb
leaq 0xc046(%rip), %rsi      # 0x368b7
movq %r15, %rdx
xorl %eax, %eax
callq 0xb6b0
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a890
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::extension() const
path path::extension() const
  {
    path name(filename());
    if (name == detail::dot_path() || name == detail::dot_dot_path()) return path();
    size_type pos(name.m_pathname.rfind(dot));
    return pos == string_type::npos
      ? path()
      : path(name.m_pathname.c_str() + pos);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2acce
callq 0x2ade1
leaq 0x21d47(%rip), %rsi     # 0x4c600
leaq -0x30(%rbp), %rdi
callq 0x2a334
testl %eax, %eax
je 0x2a90f
callq 0x2af5d
leaq 0x21d56(%rip), %rsi     # 0x4c628
leaq -0x30(%rbp), %rdi
callq 0x2a334
testl %eax, %eax
je 0x2a90f
leaq -0x30(%rbp), %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0xb8d0
cmpq $-0x1, %rax
je 0x2a90f
addq -0x30(%rbp), %rax
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb1c0
jmp 0x2a922
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a934
callq 0xb430
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x2a940
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a955
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::root_name() const
path path::root_name() const
  {
    iterator itr(begin());

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x2a54a
movq 0x28(%r15), %rax
cmpq 0x8(%r14), %rax
je 0x2aa5c
movq -0x40(%rbp), %rdx
cmpq $0x2, %rdx
jb 0x2aa5c
movq -0x48(%rbp), %rsi
cmpb $0x2f, (%rsi)
jne 0x2aa5c
cmpb $0x2f, 0x1(%rsi)
jne 0x2aa5c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xfa18
jmp 0x2aa6f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2aa81
callq 0xb430
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2aaa4
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::root_directory() const
path path::root_directory() const
  {
    size_type pos(root_directory_start(m_pathname, m_pathname.size()));

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movq %r14, %rdi
callq 0x2aafe
cmpq $-0x1, %rax
je 0x2aae3
movq (%r14), %rcx
leaq (%rcx,%rax), %rsi
leaq (%rcx,%rax), %rdx
incq %rdx
movq %rbx, %rdi
callq 0x2b99a
jmp 0x2aaf6
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: (anonymous namespace)::root_directory_start(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
size_type root_directory_start(const string_type & path, size_type size)
  // return npos if no root_directory found
  {

#   ifdef BOOST_WINDOWS_API
    // case "c:/"
    if (size > 2
      && path[1] == colon
      && is_separator(path[2])) return 2;
#   endif

    // case "//"
    if (size == 2
      && is_separator(path[0])
      && is_separator(path[1])) return string_type::npos;

#   ifdef BOOST_WINDOWS_API
    // case "\\?\"
    if (size > 4
      && is_separator(path[0])
      && is_separator(path[1])
      && path[2] == questionmark
      && is_separator(path[3]))
    {
      string_type::size_type pos(path.find_first_of(separators, 4));
        return pos < size ? pos : string_type::npos;
    }
#   endif

    // case "//net {/}"
    if (size > 3
      && is_separator(path[0])
      && is_separator(path[1])
      && !is_separator(path[2]))
    {
      string_type::size_type pos(path.find_first_of(separators, 2));
      return pos < size ? pos : string_type::npos;
    }
    
    // case "/"
    if (size > 0 && is_separator(path[0])) return 0;

    return string_type::npos;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq $0x2, %rsi
jne 0x2ab22
movq (%rdi), %rcx
cmpb $0x2f, (%rcx)
jne 0x2ab22
movq $-0x1, %rax
cmpb $0x2f, 0x1(%rcx)
je 0x2ab54
cmpq $0x4, %rbx
jb 0x2ab3c
movq (%rdi), %rax
cmpb $0x2f, (%rax)
jne 0x2ab3c
cmpb $0x2f, 0x1(%rax)
jne 0x2ab3c
cmpb $0x2f, 0x2(%rax)
jne 0x2ab5b
testq %rbx, %rbx
je 0x2ab4d
movq (%rdi), %rax
cmpb $0x2f, (%rax)
jne 0x2ab4d
xorl %eax, %eax
jmp 0x2ab54
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xa4f2(%rip), %rsi      # 0x35054
movl $0x2, %edx
movl $0x1, %ecx
callq 0xb6c0
movq %rax, %rcx
cmpq %rbx, %rax
movq $-0x1, %rax
cmovbq %rcx, %rax
jmp 0x2ab54
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::relative_path() const
path path::relative_path() const
  {
    iterator itr(begin());

    for (; itr.m_pos != m_pathname.size()
      && (is_separator(itr.m_element.m_pathname[0])
#     ifdef BOOST_WINDOWS_API
      || itr.m_element.m_pathname[itr.m_element.m_pathname.size()-1] == colon
#     endif
    ); ++itr) {}

    return path(m_pathname.c_str() + itr.m_pos);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x2a54a
movq -0x28(%rbp), %rsi
cmpq 0x8(%r14), %rsi
je 0x2abc0
movq -0x50(%rbp), %rax
cmpb $0x2f, (%rax)
jne 0x2abc0
movq %r15, %rdi
callq 0x2b496
jmp 0x2aba3
addq (%r14), %rsi
leaq -0x19(%rbp), %rdx
movq %rbx, %rdi
callq 0xb1c0
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2abe1
callq 0xb430
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2abf1
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ac06
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: (anonymous namespace)::filename_pos(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
size_type filename_pos(const string_type & str,
                          size_type end_pos) // end_pos is past-the-end position
    // return 0 if str itself is filename (or empty)
  {
    // case: "//"
    if (end_pos == 2 
      && is_separator(str[0])
      && is_separator(str[1])) return 0;

    // case: ends in "/"
    if (end_pos && is_separator(str[end_pos-1]))
      return end_pos-1;
    
    // set pos to start of last element
    size_type pos(str.find_last_of(separators, end_pos-1));

#   ifdef BOOST_WINDOWS_API
    if (pos == string_type::npos && end_pos > 1)
      pos = str.find_last_of(colon, end_pos-2);
#   endif

    return (pos == string_type::npos // path itself must be a filename (or empty)
      || (pos == 1 && is_separator(str[0]))) // or net
        ? 0 // so filename is entire string
        : pos + 1; // or starts after delimiter
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x2ac47
cmpq $0x2, %rax
jne 0x2ac38
movq (%rbx), %rcx
cmpb $0x2f, (%rcx)
jne 0x2ac33
cmpb $0x2f, 0x1(%rcx)
je 0x2ac75
testq %rax, %rax
je 0x2ac47
movq (%rbx), %rcx
cmpb $0x2f, -0x1(%rcx,%rax)
jne 0x2ac47
decq %rax
jmp 0x2ac7c
decq %rax
leaq 0xa403(%rip), %rsi      # 0x35054
movl $0x1, %ecx
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb900
cmpq $-0x1, %rax
je 0x2ac75
cmpq $0x1, %rax
jne 0x2ac79
movq (%rbx), %rcx
cmpb $0x2f, (%rcx)
jne 0x2ac79
xorl %eax, %eax
jmp 0x2ac7c
incq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::parent_path() const
path path::parent_path() const
  {
   size_type end_pos(m_parent_path_end());
   return end_pos == string_type::npos
     ? path()
     : path(m_pathname.c_str(), m_pathname.c_str() + end_pos);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2a712
cmpq $-0x1, %rax
je 0x2acb2
movq (%r14), %rsi
addq %rsi, %rax
movq %rbx, %rdi
movq %rax, %rdx
callq 0x2b99a
jmp 0x2acc5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::filename() const
path path::filename() const
  {
    size_type pos(filename_pos(m_pathname, m_pathname.size()));
    return (m_pathname.size()
              && pos
              && is_separator(m_pathname[pos])
              && !is_root_separator(m_pathname, pos))
      ? detail::dot_path()
      : path(m_pathname.c_str() + pos);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movq %r14, %rdi
callq 0x2ac0e
movq %rax, %r15
testq %rax, %rax
je 0x2ad12
cmpq $0x0, 0x8(%r14)
je 0x2ad12
movq (%r14), %rax
cmpb $0x2f, (%rax,%r15)
jne 0x2ad12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2ad59
testb %al, %al
je 0x2ad32
movq (%r14), %rsi
addq %r15, %rsi
leaq -0x19(%rbp), %rdx
movq %rbx, %rdi
callq 0xb1c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2ade1
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x218bb(%rip), %rsi     # 0x4c600
movq 0x218bc(%rip), %rdx     # 0x4c608
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xfa18
jmp 0x2ad24
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: (anonymous namespace)::is_root_separator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
bool is_root_separator(const string_type & str, size_type pos)
    // pos is position of the separator
  {
    BOOST_ASSERT_MSG(!str.empty() && is_separator(str[pos]),
      "precondition violation");

    // subsequent logic expects pos to be for leftmost slash of a set
    while (pos > 0 && is_separator(str[pos-1]))
      --pos;

    //  "/" [...]
    if (pos == 0)  
      return true;

# ifdef BOOST_WINDOWS_API
    //  "c:/" [...]
    if (pos == 2 && is_letter(str[0]) && str[1] == colon)  
      return true;
# endif

    //  "//" name "/"
    if (pos < 3 || !is_separator(str[0]) || !is_separator(str[1]))
      return false;

    return str.find_first_of(separators, 2) == pos;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
je 0x2adc2
movq (%rdi), %rax
cmpb $0x2f, (%rax,%rsi)
jne 0x2adc2
incq %rsi
cmpq $0x1, %rsi
je 0x2adb5
leaq -0x1(%rsi), %rbx
cmpb $0x2f, -0x2(%rax,%rsi)
movq %rbx, %rsi
je 0x2ad72
cmpq $0x3, %rbx
jb 0x2adb9
cmpb $0x2f, (%rax)
jne 0x2adb9
cmpb $0x2f, 0x1(%rax)
jne 0x2adb9
leaq 0xa2b6(%rip), %rsi      # 0x35054
movl $0x2, %edx
movl $0x1, %ecx
callq 0xb6c0
cmpq %rbx, %rax
sete %al
jmp 0x2adbb
movb $0x1, %al
jmp 0x2adbb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xba5b(%rip), %rdi      # 0x36824
leaq 0xb892(%rip), %rsi      # 0x36662
leaq 0xba92(%rip), %rcx      # 0x36869
movl $0x1db, %edx            # imm = 0x1DB
callq 0xb310
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::detail::dot_path()
BOOST_FILESYSTEM_DECL
    const path&  dot_path()
    {
#   ifdef BOOST_WINDOWS_API
      static const fs::path dot_pth(L".");
#   else
      static const fs::path dot_pth(".");
#   endif
      return dot_pth;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb 0x21833(%rip), %al      # 0x4c620
testb %al, %al
je 0x2adff
leaq 0x21808(%rip), %rax     # 0x4c600
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2181a(%rip), %rdi     # 0x4c620
callq 0xb820
testl %eax, %eax
je 0x2adf1
leaq 0x217fa(%rip), %rax     # 0x4c610
movq %rax, 0x217e3(%rip)     # 0x4c600
leaq 0x217dc(%rip), %rdi     # 0x4c600
leaq 0xb8c2(%rip), %rsi      # 0x366ed
leaq 0xb8bc(%rip), %rdx      # 0x366ee
callq 0xf97e
leaq -0x16e8(%rip), %rdi     # 0x29756
leaq 0x217bb(%rip), %rsi     # 0x4c600
leaq 0x2164c(%rip), %rdx     # 0x4c498
callq 0xb400
leaq 0x217c8(%rip), %rdi     # 0x4c620
callq 0xb2f0
jmp 0x2adf1
movq %rax, %rbx
leaq 0x217b7(%rip), %rdi     # 0x4c620
callq 0xb2e0
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::stem() const
path path::stem() const
  {
    path name(filename());
    if (name == detail::dot_path() || name == detail::dot_dot_path()) return name;
    size_type pos(name.m_pathname.rfind(dot));
    return pos == string_type::npos
      ? name
      : path(name.m_pathname.c_str(), name.m_pathname.c_str() + pos);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %rdi
callq 0x2acce
callq 0x2ade1
leaq 0x21769(%rip), %rsi     # 0x4c600
leaq -0x28(%rbp), %rdi
callq 0x2a334
testl %eax, %eax
je 0x2aeec
callq 0x2af5d
leaq 0x21778(%rip), %rsi     # 0x4c628
leaq -0x28(%rbp), %rdi
callq 0x2a334
testl %eax, %eax
je 0x2aeec
leaq -0x28(%rbp), %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0xb8d0
cmpq $-0x1, %rax
je 0x2af22
movq -0x28(%rbp), %rsi
addq %rsi, %rax
movq %rbx, %rdi
movq %rax, %rdx
callq 0x2b99a
jmp 0x2af06
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xfa18
leaq -0x18(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2af18
callq 0xb430
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xfa18
jmp 0x2af06
jmp 0x2af40
movq %rax, %rbx
leaq -0x18(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2af55
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::detail::dot_dot_path()
BOOST_FILESYSTEM_DECL
    const path&  dot_dot_path()
    {
#   ifdef BOOST_WINDOWS_API
      static const fs::path dot_dot(L"..");
#   else
      static const fs::path dot_dot("..");
#   endif
      return dot_dot;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb 0x216df(%rip), %al      # 0x4c648
testb %al, %al
je 0x2af7b
leaq 0x216b4(%rip), %rax     # 0x4c628
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x216c6(%rip), %rdi     # 0x4c648
callq 0xb820
testl %eax, %eax
je 0x2af6d
leaq 0x216a6(%rip), %rax     # 0x4c638
movq %rax, 0x2168f(%rip)     # 0x4c628
leaq 0x21688(%rip), %rdi     # 0x4c628
leaq 0xb745(%rip), %rsi      # 0x366ec
leaq 0xb740(%rip), %rdx      # 0x366ee
callq 0xf97e
leaq -0x1864(%rip), %rdi     # 0x29756
leaq 0x21667(%rip), %rsi     # 0x4c628
leaq 0x214d0(%rip), %rdx     # 0x4c498
callq 0xb400
leaq 0x21674(%rip), %rdi     # 0x4c648
callq 0xb2f0
jmp 0x2af6d
movq %rax, %rbx
leaq 0x21663(%rip), %rdi     # 0x4c648
callq 0xb2e0
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::codecvt()
const path::codecvt_type& path::codecvt()
  {
#ifdef BOOST_FILESYSTEM_DEBUG
    std::cout << "***** path::codecvt() called" << std::endl;
#endif
    BOOST_ASSERT_MSG(&path_locale(), "boost::filesystem::path locale initialization error");
    return std::use_facet<std::codecvt<wchar_t, char, std::mbstate_t> >(path_locale());
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb 0x20ea0(%rip), %al      # 0x4c658
testb %al, %al
je 0x2b7d8
movb 0x20e96(%rip), %al      # 0x4c658
testb %al, %al
je 0x2b823
leaq 0x20e83(%rip), %rdi     # 0x4c650
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb630
leaq 0x20e79(%rip), %rdi     # 0x4c658
callq 0xb820
testl %eax, %eax
je 0x2b7bc
leaq 0x20e61(%rip), %rdi     # 0x4c650
leaq 0x76b4(%rip), %rsi      # 0x32eaa
callq 0xb390
movq 0x207be(%rip), %rdi     # 0x4bfc0
leaq 0x20e47(%rip), %rsi     # 0x4c650
leaq 0x20c88(%rip), %rdx     # 0x4c498
callq 0xb400
leaq 0x20e3c(%rip), %rdi     # 0x4c658
callq 0xb2f0
jmp 0x2b7bc
leaq 0x20e2e(%rip), %rdi     # 0x4c658
callq 0xb820
testl %eax, %eax
je 0x2b7c6
leaq 0x20e16(%rip), %rdi     # 0x4c650
leaq 0x7669(%rip), %rsi      # 0x32eaa
callq 0xb390
movq 0x20773(%rip), %rdi     # 0x4bfc0
leaq 0x20dfc(%rip), %rsi     # 0x4c650
leaq 0x20c3d(%rip), %rdx     # 0x4c498
callq 0xb400
leaq 0x20df1(%rip), %rdi     # 0x4c658
callq 0xb2f0
jmp 0x2b7c6
jmp 0x2b873
movq %rax, %rbx
leaq 0x20ddb(%rip), %rdi     # 0x4c658
callq 0xb2e0
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::imbue(std::locale const&)
std::locale path::imbue(const std::locale& loc)
  {
#ifdef BOOST_FILESYSTEM_DEBUG
    std::cout << "***** path::imbue() called" << std::endl;
#endif
    std::locale temp(path_locale());
    path_locale() = loc;
    return temp;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movb 0x20dbb(%rip), %al      # 0x4c658
testb %al, %al
je 0x2b8d1
leaq 0x20da8(%rip), %rsi     # 0x4c650
movq %rbx, %rdi
callq 0xb2d0
movb 0x20da2(%rip), %al      # 0x4c658
testb %al, %al
je 0x2b91c
leaq 0x20d8f(%rip), %rdi     # 0x4c650
movq %r14, %rsi
callq 0xb4d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x20d80(%rip), %rdi     # 0x4c658
callq 0xb820
testl %eax, %eax
je 0x2b8a1
leaq 0x20d68(%rip), %rdi     # 0x4c650
leaq 0x75bb(%rip), %rsi      # 0x32eaa
callq 0xb390
movq 0x206c5(%rip), %rdi     # 0x4bfc0
leaq 0x20d4e(%rip), %rsi     # 0x4c650
leaq 0x20b8f(%rip), %rdx     # 0x4c498
callq 0xb400
leaq 0x20d43(%rip), %rdi     # 0x4c658
callq 0xb2f0
jmp 0x2b8a1
leaq 0x20d35(%rip), %rdi     # 0x4c658
callq 0xb820
testl %eax, %eax
je 0x2b8ba
leaq 0x20d1d(%rip), %rdi     # 0x4c650
leaq 0x7570(%rip), %rsi      # 0x32eaa
callq 0xb390
movq 0x2067a(%rip), %rdi     # 0x4bfc0
leaq 0x20d03(%rip), %rsi     # 0x4c650
leaq 0x20b44(%rip), %rdx     # 0x4c498
callq 0xb400
leaq 0x20cf8(%rip), %rdi     # 0x4c658
callq 0xb2f0
jmp 0x2b8ba
movq %rax, %r14
leaq 0x20ce4(%rip), %rdi     # 0x4c658
callq 0xb2e0
movq %rbx, %rdi
callq 0xb938
jmp 0x2b992
movq %rax, %r14
leaq 0x20ccb(%rip), %rdi     # 0x4c658
callq 0xb2e0
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./boost/filesystem/path.hpp
// Function: boost::filesystem::path::path<char const*>(char const*, char const*)
path(InputIterator begin, InputIterator end)
    { 
      if (begin != end)
      {
        // convert requires contiguous string, so copy
        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);
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq %rdx, %rsi
je 0x2b9ff
movq %rdi, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq -0x40(%rbp), %rdi
callq 0xf97e
movq -0x40(%rbp), %rcx
testq %rcx, %rcx
je 0x2ba0c
movq -0x38(%rbp), %r8
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xb4f0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x2b9ff
callq 0xb430
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xaacf(%rip), %rdi      # 0x364e2
leaq 0xaacd(%rip), %rsi      # 0x364e7
leaq 0xaae9(%rip), %rcx      # 0x3650a
movl $0xc2, %edx
callq 0xb310
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x2ba41
callq 0xb430
jmp 0x2ba41
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2ba4e
callq 0xb430
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path_traits.cpp
// Function: boost::filesystem::path_traits::convert(char const*, char const*, std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>&, std::codecvt<wchar_t, char, __mbstate_t> const&)
BOOST_FILESYSTEM_DECL
  void convert(const char* from,
                const char* from_end,    // 0 for null terminated MBCS
                std::wstring & to,
                const codecvt_type & cvt)
  {
    BOOST_ASSERT(from);

    if (!from_end)  // null terminated
    {
      from_end = from + std::strlen(from);
    }

    if (from == from_end) return;

    std::size_t buf_size = (from_end - from) * 3;  // perhaps too large, but that's OK

    //  dynamically allocate a buffer only if source is unusually large
    if (buf_size > default_codecvt_buf_size)
    {
      boost::scoped_array< wchar_t > buf(new wchar_t [buf_size]);
      convert_aux(from, from_end, buf.get(), buf.get()+buf_size, to, cvt);
    }
    else
    {
      wchar_t buf[default_codecvt_buf_size];
      convert_aux(from, from_end, buf, buf+default_codecvt_buf_size, to, cvt);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
testq %rdi, %rdi
je 0x2bb86
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
testq %rsi, %rsi
jne 0x2baf0
movq %r15, %rdi
callq 0xb200
movq %rax, %r12
addq %r15, %r12
movq %r12, %rax
subq %r15, %rax
je 0x2bb74
leaq (%rax,%rax,2), %rbx
cmpq $0x101, %rbx            # imm = 0x101
jb 0x2bb58
movq %rbx, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
leaq (%rax,%rax,2), %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0xb030
movq %r13, %r9
movq %rax, %r13
leaq (%rax,%rbx,4), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r14, %r8
callq 0x2bbb8
movq %r13, %rdi
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb5a0
leaq -0x30(%rbp), %rcx
leaq -0x430(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %r8
movq %r13, %r9
callq 0x2bbb8
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa955(%rip), %rdi      # 0x364e2
leaq 0xad6e(%rip), %rsi      # 0x36902
leaq 0xad8d(%rip), %rcx      # 0x36928
movl $0x8a, %edx
callq 0xb310
movq %rax, %rbx
movq %r13, %rdi
callq 0xb5a0
movq %rbx, %rdi
callq 0xb7f0