LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./boost/filesystem/operations.hpp
// Function: boost::filesystem::filesystem_error::filesystem_error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, boost::filesystem::path const&, boost::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 %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rcx
movq %rdi, %rbx
movl %r8d, %esi
movq %r9, %rdx
callq 0x24e5c
leaq 0x23a61(%rip), %rax     # 0x485d8
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
addq $0x40, %rbx
pushq $0x60
popq %rdi
callq 0xc4e0
movq %rax, %r12
movq %rax, %rdi
callq 0x24f16
movq %rbx, %rdi
movq %r12, %rsi
callq 0x24ea6
movq %rbx, %rdi
callq 0x24f4e
movq %rax, %rdi
movq %r15, %rsi
callq 0xc2b0
movq %rbx, %rdi
callq 0x24f4e
leaq 0x20(%rax), %rdi
movq %r14, %rsi
callq 0xc2b0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r12, %rdi
callq 0xc4a0
jmp 0x24be3
movq %rax, %r14
movq %r14, %rdi
callq 0xc1d0
movq %rbx, %rdi
callq 0x24f7a
callq 0xc7e0
jmp 0x24bca
movq %rax, %rdi
callq 0xeb96
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq (%rdi), %rax
movb $0x0, (%rax)
cmpq %rdx, %rsi
je 0x24c61
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x24dbe
movq (%r14), %rdi
movq 0x8(%r14), %rsi
addq %rdi, %rsi
movq %rbx, %rdx
callq 0x25513
leaq -0x30(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./boost/filesystem/operations.hpp
// Function: boost::filesystem::directory_entry::replace_filename(boost::filesystem::path const&, boost::filesystem::file_status, boost::filesystem::file_status)
void replace_filename(const boost::filesystem::path& p,
    file_status st = file_status(), file_status symlink_st = file_status())
  {
    m_path.remove_filename();
    m_path /= p;
    m_status = st;
    m_symlink_status = symlink_st;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x25a08
movq %r12, %rdi
movq %r15, %rsi
callq 0x2558c
movq %r14, 0x20(%r12)
movq %rbx, 0x28(%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x40(%rdi)
je 0x250e9
leaq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0x24f4e
cmpq $0x0, 0x48(%rax)
jne 0x250cf
movq %rbx, %rdi
callq 0x248f0
movq %rax, %r15
movq %r14, %rdi
callq 0x24f4e
leaq 0x40(%rax), %rdi
movq %r15, %rsi
callq 0xc8f0
movq %r14, %rdi
callq 0x24f4e
cmpq $0x0, 0x8(%rax)
je 0x25070
movq %r14, %rdi
callq 0x24f4e
leaq 0x40(%rax), %rdi
leaq 0xb2dc(%rip), %rsi      # 0x30310
callq 0xc8e0
movq %r14, %rdi
callq 0x24f4e
movq %rax, %r15
movq %r14, %rdi
callq 0x24f4e
leaq 0x40(%rax), %rdi
movq %r15, %rsi
callq 0xc910
movq %r14, %rdi
callq 0x24f4e
leaq 0x40(%rax), %rdi
leaq 0xb2ab(%rip), %rsi      # 0x30316
callq 0xc8e0
movq %r14, %rdi
callq 0x24f4e
cmpq $0x0, 0x28(%rax)
je 0x250cf
movq %r14, %rdi
callq 0x24f4e
leaq 0x40(%rax), %rdi
leaq 0xb282(%rip), %rsi      # 0x30314
callq 0xc8e0
movq %r14, %rdi
callq 0x24f4e
leaq 0x20(%rax), %r15
movq %r14, %rdi
callq 0x24f4e
leaq 0x40(%rax), %rdi
movq %r15, %rsi
callq 0xc910
movq %r14, %rdi
callq 0x24f4e
leaq 0x40(%rax), %rdi
leaq 0xb24c(%rip), %rsi      # 0x30316
callq 0xc8e0
movq %r14, %rdi
callq 0x24f4e
movq 0x40(%rax), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x248f0
movq %rax, %rdi
callq 0xc1d0
movq %rbx, %rdi
callq 0x248f0
movq %rax, %rbx
callq 0xc7e0
jmp 0x250db
movq %rax, %rdi
callq 0xeb96
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x242e4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc9a0
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x0, 0x8(%rsi)
je 0x255fc
movq %rsi, %r14
cmpq %rsi, %rbx
je 0x255c8
movq (%r14), %rax
cmpb $0x2f, (%rax)
je 0x255bb
movq %rbx, %rdi
callq 0x2561e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc910
jmp 0x255fc
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xc660
movq (%r15), %rax
cmpb $0x2f, (%rax)
je 0x255e7
movq %rbx, %rdi
callq 0x2561e
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0xc910
leaq -0x38(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/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 0x25637
movq (%rdi), %rax
cmpb $0x2f, -0x1(%rax,%rbx)
jne 0x2563b
xorl %ebx, %ebx
jmp 0x25643
pushq $0x2f
popq %rsi
callq 0xc430
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/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), %al
testb %al, %al
je 0x256c5
movq %rsi, %r14
movq (%rbx), %rcx
cmpq %rsi, %rcx
ja 0x256ae
addq 0x8(%rbx), %rcx
cmpq %r14, %rcx
jbe 0x256ae
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x24c82
movq (%r15), %rax
cmpb $0x2f, (%rax)
je 0x25697
movq %rbx, %rdi
callq 0x2561e
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0xc910
leaq -0x38(%rbp), %rdi
callq 0xc9a0
jmp 0x256c5
cmpb $0x2f, %al
je 0x256ba
movq %rbx, %rdi
callq 0x2561e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc8e0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
pushq $0x1
popq %rbx
movq 0x20(%r13), %rax
movq 0x28(%r13), %rcx
movq 0x20(%r12), %rdx
movq 0x28(%r12), %rsi
movq %rax, %rdi
xorq %rdx, %rdi
movq %rcx, %r8
xorq %rsi, %r8
orq %rdi, %r8
je 0x25842
movq 0x20(%r14), %rdi
cmpq 0x20(%r15), %rdi
jne 0x25803
movq 0x28(%r15), %rdi
cmpq %rdi, 0x28(%r14)
je 0x25848
movq %r13, %rdi
movq %r14, %rsi
callq 0xf2d6
testb %al, %al
jne 0x2586f
movq %r14, %rdi
movq %r13, %rsi
callq 0xf2d6
testb %al, %al
jne 0x25872
movq %r14, %rdi
movq %r13, %rsi
callq 0x15d61
testb %al, %al
je 0x25883
movq %r13, %rdi
callq 0x2652a
movq %r14, %rdi
callq 0x2652a
jmp 0x257cc
movq %rax, %rdx
movq %rcx, %rsi
xorq %rdx, %rax
xorq %rsi, %rcx
orq %rax, %rcx
jne 0x25872
movq 0x20(%r14), %rax
xorq 0x20(%r15), %rax
movq 0x28(%r15), %rcx
xorq 0x28(%r14), %rcx
xorl %ebx, %ebx
orq %rax, %rcx
setne %bl
negl %ebx
jmp 0x25872
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xae96(%rip), %rdi      # 0x30720
leaq 0xaeb4(%rip), %rsi      # 0x30745
leaq 0xaecc(%rip), %rcx      # 0x30764
movl $0x291, %edx            # imm = 0x291
callq 0xc350
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, 0x20(%rdi)
movq 0x8(%rsi), %rax
andq $0x0, 0x28(%rdi)
testq %rax, %rax
je 0x258e4
movq (%rsi), %rdi
movb (%rdi), %cl
cmpq $0x1, %rax
jne 0x258ea
cmpb $0x2f, %cl
je 0x25905
jmp 0x2591c
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x25947
cmpb $0x2f, %cl
jne 0x2591c
cmpb $0x2f, 0x1(%rdi)
jne 0x25905
pushq $0x2
popq %r8
cmpq $0x2, %rax
je 0x2591f
cmpb $0x2f, 0x2(%rdi)
jne 0x2591f
pushq $0x1
popq %rdx
cmpq %rax, %rdx
jae 0x2593c
cmpb $0x2f, (%rdi,%rdx)
jne 0x2593c
movq %rdx, 0x28(%rbx)
incq %rdx
jmp 0x25908
xorl %r8d, %r8d
cmpq %rax, %r8
movq %rax, %rcx
cmovaq %r8, %rcx
xorl %edx, %edx
cmpq %rax, %r8
jae 0x25947
cmpb $0x2f, (%rdi,%r8)
je 0x25944
incq %r8
jmp 0x2592b
decq %rdx
pushq $0x1
popq %rcx
jmp 0x25947
movq %r8, %rcx
leaq -0x30(%rbp), %rdi
callq 0xc4f0
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0xc2b0
leaq -0x30(%rbp), %rdi
callq 0xc9a0
leaq 0x96b8(%rip), %rsi      # 0x2f024
movq %rbx, %rdi
callq 0xef68
testb %al, %al
je 0x25987
leaq 0x96a5(%rip), %rsi      # 0x2f024
movq %rbx, %rdi
callq 0xc8f0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x259a3
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0xc9a0
jmp 0x259a6
movq %rax, %r14
movq %rbx, %rdi
callq 0xc9a0
movq %r14, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, 0x20(%rdi)
movq 0x8(%rsi), %rcx
movq %rcx, 0x28(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25a05
cmpq %rsi, 0x8(%rdi)
jbe 0x25a05
movq (%rdi), %rax
cmpb $0x2f, 0x1(%rax,%rsi)
jne 0x25a05
movabsq $0x1, %rdx
popq %rbp
jmp 0xc0e0
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25e72
movq %rax, %rbx
cmpq $0x0, 0x8(%r14)
je 0x25a5b
movq (%r14), %rax
cmpb $0x2f, (%rax,%rbx)
setne %r15b
jmp 0x25a5e
movb $0x1, %r15b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x25d8b
movq (%r14), %rdx
leaq 0x1(%rax), %rcx
incq %rbx
movq %rax, %rdi
negq %rdi
cmpq $0x1, %rbx
je 0x25a99
leaq (%rdi,%rbx), %rsi
cmpq $0x2, %rsi
je 0x25a9d
leaq -0x1(%rbx), %rsi
cmpb $0x2f, -0x2(%rdx,%rbx)
movq %rsi, %rbx
je 0x25a79
jmp 0x25aa0
xorl %esi, %esi
jmp 0x25aa0
movq %rcx, %rsi
movq %rsi, %rcx
xorq $0x1, %rcx
orq %rcx, %rax
pushq $-0x1
popq %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_O2/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 0x25b86
subq 0x8(%r12), %r15
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc0e0
leaq -0x40(%rbp), %rdi
callq 0xc9a0
cmpq $0x0, 0x8(%r14)
je 0x25b61
movq (%r14), %rax
cmpb $0x2e, (%rax)
je 0x25b56
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0xc430
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc910
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 -0x28(%rbp), %rdi
callq 0x25f24
callq 0x2601b
leaq 0x23a91(%rip), %rsi     # 0x49638
leaq -0x28(%rbp), %rdi
callq 0x24b12
testb %al, %al
jne 0x25bf3
callq 0x2614f
leaq 0x23aa0(%rip), %rsi     # 0x49660
leaq -0x28(%rbp), %rdi
callq 0x24b12
testb %al, %al
jne 0x25bf3
leaq -0x28(%rbp), %rdi
pushq $0x2e
popq %rsi
pushq $-0x1
popq %rdx
callq 0xc940
cmpq $-0x1, %rax
je 0x25bf3
addq -0x28(%rbp), %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x24c82
jmp 0x25c03
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq -0x28(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x25c18
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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 0x258a2
movq 0x28(%r15), %rax
cmpq 0x8(%r14), %rax
je 0x25d01
cmpq $0x2, -0x40(%rbp)
jb 0x25d01
movq -0x48(%rbp), %rax
cmpb $0x2f, (%rax)
jne 0x25d01
cmpb $0x2f, 0x1(%rax)
jne 0x25d01
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0xc660
jmp 0x25d11
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq -0x48(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/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 0x25d8b
cmpq $-0x1, %rax
je 0x25d73
movq (%r14), %rcx
leaq (%rcx,%rax), %rsi
leaq (%rcx,%rax), %rdx
incq %rdx
movq %rbx, %rdi
callq 0x268b0
jmp 0x25d83
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x2, %rsi
jne 0x25da7
movq (%rdi), %rax
cmpb $0x2f, (%rax)
jne 0x25df3
cmpb $0x2f, 0x1(%rax)
jne 0x25def
jmp 0x25df3
movq %rsi, %rbx
cmpq $0x4, %rsi
jb 0x25de2
movq (%rdi), %rax
cmpb $0x2f, (%rax)
jne 0x25df3
cmpb $0x2f, 0x1(%rax)
jne 0x25def
cmpb $0x2f, 0x2(%rax)
je 0x25def
leaq 0x9259(%rip), %rsi      # 0x2f024
pushq $0x2
popq %rdx
callq 0xc260
movq %rax, %rcx
cmpq %rbx, %rax
pushq $-0x1
popq %rax
cmovbq %rcx, %rax
jmp 0x25df6
testq %rbx, %rbx
je 0x25df3
movq (%rdi), %rax
cmpb $0x2f, (%rax)
jne 0x25df3
xorl %eax, %eax
jmp 0x25df6
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x258a2
movq -0x20(%rbp), %rsi
cmpq 0x8(%r14), %rsi
je 0x25e3a
movq -0x48(%rbp), %rax
cmpb $0x2f, (%rax)
jne 0x25e3a
movq %r15, %rdi
callq 0x2652a
jmp 0x25e1d
addq (%r14), %rsi
movq %rbx, %rdi
callq 0x24c82
leaq -0x48(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25e5e
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/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 %rdi, %rbx
testq %rsi, %rsi
je 0x25e96
cmpq $0x2, %rsi
jne 0x25e9b
movq (%rbx), %rcx
cmpb $0x2f, (%rcx)
jne 0x25e9e
cmpb $0x2f, 0x1(%rcx)
jne 0x25e9e
jmp 0x25ecf
pushq $-0x1
popq %rax
jmp 0x25ea9
movq (%rbx), %rcx
leaq -0x1(%rsi), %rax
cmpb $0x2f, -0x1(%rcx,%rsi)
je 0x25ed6
leaq 0x9174(%rip), %rsi      # 0x2f024
movq %rbx, %rdi
movq %rax, %rdx
callq 0xc4b0
cmpq $-0x1, %rax
je 0x25ecf
cmpq $0x1, %rax
jne 0x25ed3
movq (%rbx), %rcx
cmpb $0x2f, (%rcx)
jne 0x25ed3
xorl %eax, %eax
jmp 0x25ed6
incq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25a2e
cmpq $-0x1, %rax
je 0x25f0c
movq (%r14), %rsi
addq %rsi, %rax
movq %rbx, %rdi
movq %rax, %rdx
callq 0x268b0
jmp 0x25f1c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movq %r15, %rdi
callq 0x25e72
movq %rax, %r14
movq (%r15), %rsi
testq %rax, %rax
je 0x25f6b
cmpq $0x0, 0x8(%r15)
je 0x25f6b
cmpb $0x2f, (%rsi,%r14)
jne 0x25f6b
movq %r15, %rdi
movq %r14, %rsi
callq 0x25f9a
testb %al, %al
je 0x25f84
movq (%r15), %rsi
addq %r14, %rsi
movq %rbx, %rdi
callq 0x24c82
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2601b
leaq 0x236a8(%rip), %rsi     # 0x49638
movq %rbx, %rdi
callq 0xc660
jmp 0x25f76
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25ffc
movq (%rdi), %rax
cmpb $0x2f, (%rax,%rsi)
jne 0x25ffc
incq %rsi
cmpq $0x1, %rsi
je 0x25fef
leaq -0x1(%rsi), %rbx
cmpb $0x2f, -0x2(%rax,%rsi)
movq %rbx, %rsi
je 0x25fb3
cmpq $0x3, %rbx
jb 0x25ff3
cmpb $0x2f, (%rax)
jne 0x25ff3
cmpb $0x2f, 0x1(%rax)
jne 0x25ff3
leaq 0x9045(%rip), %rsi      # 0x2f024
pushq $0x2
popq %rdx
callq 0xc260
cmpq %rbx, %rax
sete %al
jmp 0x25ff5
movb $0x1, %al
jmp 0x25ff5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xa904(%rip), %rdi      # 0x30907
leaq 0xa73b(%rip), %rsi      # 0x30745
leaq 0xa93b(%rip), %rcx      # 0x3094c
movl $0x1db, %edx            # imm = 0x1DB
callq 0xc350
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23631(%rip), %al      # 0x49658
testb %al, %al
je 0x26039
leaq 0x23606(%rip), %rax     # 0x49638
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x23618(%rip), %rdi     # 0x49658
callq 0xc890
testl %eax, %eax
je 0x2602b
leaq 0x235e8(%rip), %rdi     # 0x49638
leaq 0xa779(%rip), %rsi      # 0x307d0
callq 0x24c82
leaq -0x1685(%rip), %rdi     # 0x249de
leaq 0x235ce(%rip), %rsi     # 0x49638
leaq 0x2345f(%rip), %rdx     # 0x494d0
callq 0xc450
leaq 0x235db(%rip), %rdi     # 0x49658
callq 0xc330
jmp 0x2602b
movq %rax, %rbx
leaq 0x235ca(%rip), %rdi     # 0x49658
callq 0xc320
movq %rbx, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25f24
callq 0x2601b
leaq 0x2357b(%rip), %rsi     # 0x49638
leaq -0x28(%rbp), %rdi
callq 0x24b12
testb %al, %al
jne 0x260e3
callq 0x2614f
leaq 0x2358a(%rip), %rsi     # 0x49660
leaq -0x28(%rbp), %rdi
callq 0x24b12
testb %al, %al
je 0x26102
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0xc660
leaq -0x28(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq -0x28(%rbp), %rdi
pushq $0x2e
popq %rsi
pushq $-0x1
popq %rdx
callq 0xc940
cmpq $-0x1, %rax
je 0x2612b
movq -0x28(%rbp), %rsi
addq %rsi, %rax
movq %rbx, %rdi
movq %rax, %rdx
callq 0x268b0
jmp 0x260ef
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0xc660
jmp 0x260ef
jmp 0x2613b
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23525(%rip), %al      # 0x49680
testb %al, %al
je 0x2616d
leaq 0x234fa(%rip), %rax     # 0x49660
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2350c(%rip), %rdi     # 0x49680
callq 0xc890
testl %eax, %eax
je 0x2615f
leaq 0x234dc(%rip), %rdi     # 0x49660
leaq 0xa644(%rip), %rsi      # 0x307cf
callq 0x24c82
leaq -0x17b9(%rip), %rdi     # 0x249de
leaq 0x234c2(%rip), %rsi     # 0x49660
leaq 0x2332b(%rip), %rdx     # 0x494d0
callq 0xc450
leaq 0x234cf(%rip), %rdi     # 0x49680
callq 0xc330
jmp 0x2615f
movq %rax, %rbx
leaq 0x234be(%rip), %rdi     # 0x49680
callq 0xc320
movq %rbx, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: boost::filesystem::path::m_path_iterator_decrement(boost::filesystem::path::iterator&)
void path::m_path_iterator_decrement(path::iterator & it)
  {
    BOOST_ASSERT_MSG(it.m_pos, "path::iterator decrement past begin()");

    size_type end_pos(it.m_pos);

    // if at end and there was a trailing non-root '/', return "."
    if (it.m_pos == it.m_path_ptr->m_pathname.size()
      && it.m_path_ptr->m_pathname.size() > 1
      && is_separator(it.m_path_ptr->m_pathname[it.m_pos-1])
      && !is_root_separator(it.m_path_ptr->m_pathname, it.m_pos-1) 
       )
    {
      --it.m_pos;
      it.m_element = detail::dot_path();
      return;
    }

    size_type root_dir_pos(root_directory_start(it.m_path_ptr->m_pathname, end_pos));

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

    it.m_pos = filename_pos(it.m_path_ptr->m_pathname, end_pos);
    it.m_element = it.m_path_ptr->m_pathname.substr(it.m_pos, end_pos - it.m_pos);
    if (it.m_element.m_pathname == preferred_separator_string) // needed for Windows, harmless on POSIX 
      it.m_element.m_pathname = separator_string;    // generic format; see docs 
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x28(%rdi), %r14
testq %r14, %r14
je 0x26794
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movq 0x8(%rdi), %rax
cmpq %rax, %r14
setne %cl
cmpq $0x2, %rax
setb %al
orb %cl, %al
jne 0x266ca
movq (%rdi), %rax
cmpb $0x2f, -0x1(%rax,%r14)
jne 0x266ca
leaq -0x1(%r14), %rsi
callq 0x25f9a
testb %al, %al
je 0x26772
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x25d8b
movq 0x20(%rbx), %rdi
leaq 0x1(%rax), %rcx
incq %r14
negq %rax
cmpq $0x1, %r14
je 0x26704
leaq (%rax,%r14), %rdx
cmpq $0x2, %rdx
je 0x26709
movq (%rdi), %rdx
leaq -0x1(%r14), %r15
cmpb $0x2f, -0x2(%rdx,%r14)
movq %r15, %r14
je 0x266e0
jmp 0x2670c
xorl %r15d, %r15d
jmp 0x2670c
movq %rcx, %r15
movq %r15, %rsi
callq 0x25e72
movq %rax, 0x28(%rbx)
movq 0x20(%rbx), %rsi
subq %rax, %r15
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xc4f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc2b0
leaq -0x38(%rbp), %rdi
callq 0xc9a0
leaq 0x88d8(%rip), %rsi      # 0x2f024
movq %rbx, %rdi
callq 0xef68
testb %al, %al
je 0x26767
leaq 0x88c5(%rip), %rsi      # 0x2f024
movq %rbx, %rdi
callq 0xc8f0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
decq 0x28(%rbx)
callq 0x2601b
leaq 0x22eb6(%rip), %rsi     # 0x49638
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc2b0
leaq 0xa0e5(%rip), %rdi      # 0x30880
leaq 0x9fa3(%rip), %rsi      # 0x30745
leaq 0xa10d(%rip), %rcx      # 0x308b6
movl $0x308, %edx            # imm = 0x308
callq 0xc350
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/path.cpp
// Function: (anonymous namespace)::path_locale()
inline std::locale& path_locale()
  // std::locale("") construction, needed on non-Apple POSIX systems, can throw
  // (if environmental variables LC_MESSAGES or LANG are wrong, for example), so
  // path_locale() provides lazy initialization via a local static to ensure that any 
  // exceptions occur after main() starts and so can be caught. Furthermore,
  // path_locale() is only called if path::codecvt() or path::imbue() are themselves
  // actually called, ensuring that an exception will only be thrown if std::locale("")
  // is really needed.
  {
    static std::locale loc(default_locale());
#ifdef BOOST_FILESYSTEM_DEBUG
    std::cout << "***** path_locale() called" << std::endl;
#endif
    return loc;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb 0x22ea1(%rip), %al      # 0x49690
testb %al, %al
je 0x267fa
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x22e8f(%rip), %rdi     # 0x49690
callq 0xc890
testl %eax, %eax
je 0x267f3
leaq 0x22e77(%rip), %rdi     # 0x49688
leaq 0x666a(%rip), %rsi      # 0x2ce82
callq 0xc3c0
movq 0x2279c(%rip), %rdi     # 0x48fc0
leaq 0x22e5d(%rip), %rsi     # 0x49688
leaq 0x22c9e(%rip), %rdx     # 0x494d0
callq 0xc450
leaq 0x22e52(%rip), %rdi     # 0x49690
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc330
movq %rax, %rbx
leaq 0x22e3d(%rip), %rdi     # 0x49690
callq 0xc320
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq %rdx, %rsi
je 0x26900
movq %rdi, %rbx
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x30(%rbp), %rdi
callq 0x26980
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq %rdi, %rsi
movq %rbx, %rdx
callq 0x25513
leaq -0x30(%rbp), %rdi
callq 0xc9a0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0xc9a0
jmp 0x2691a
movq %rax, %r14
movq %rbx, %rdi
callq 0xc9a0
movq %r14, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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 0x26aee
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
testq %rsi, %rsi
jne 0x26a5c
movq %r15, %rdi
callq 0xc1f0
movq %rax, %r12
addq %r15, %r12
movq %r12, %rax
subq %r15, %rax
je 0x26adc
leaq (%rax,%rax,2), %rbx
cmpq $0x101, %rbx            # imm = 0x101
jb 0x26ac0
movq %rbx, %rcx
shrq $0x3e, %rcx
imulq $0xc, %rax, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0xc030
movq %r13, %r9
movq %rax, %r13
leaq (%rax,%rbx,4), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r14, %r8
callq 0x26b20
movq %r13, %rdi
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x26db6
leaq -0x30(%rbp), %rcx
leaq -0x430(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %r8
movq %r13, %r9
callq 0x26b20
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9ac7(%rip), %rdi      # 0x305bc
leaq 0x9e9e(%rip), %rsi      # 0x3099a
leaq 0x9ebd(%rip), %rcx      # 0x309c0
movl $0x8a, %edx
callq 0xc350
movq %rax, %rbx
movq %r13, %rdi
callq 0x26db6
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/path_traits.cpp
// Function: (anonymous namespace)::convert_aux(char const*, char const*, wchar_t*, wchar_t*, std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>&, std::codecvt<wchar_t, char, __mbstate_t> const&)
void convert_aux(
                   const char* from,
                   const char* from_end,
                   wchar_t* to, wchar_t* to_end,
                   std::wstring & target,
                   const pt::codecvt_type & cvt)
  {
    //std::cout << std::hex
    //          << " from=" << std::size_t(from)
    //          << " from_end=" << std::size_t(from_end)
    //          << " to=" << std::size_t(to)
    //          << " to_end=" << std::size_t(to_end)
    //          << std::endl;

    std::mbstate_t state  = std::mbstate_t();  // perhaps unneeded, but cuts bug reports
    const char* from_next;
    wchar_t* to_next;

    std::codecvt_base::result res;

    if ((res=cvt.in(state, from, from_end, from_next,
           to, to_end, to_next)) != std::codecvt_base::ok)
    {
      //std::cout << " result is " << static_cast<int>(res) << std::endl;
      BOOST_FILESYSTEM_THROW(bs::system_error(res, fs::codecvt_error_category(),
        "boost::filesystem::path codecvt to wstring"));
    }
    target.append(to, to_next); 
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %rax
movq %rdx, %r14
movq %rsi, %rcx
movq %rdi, %rdx
leaq -0x30(%rbp), %rsi
andq $0x0, (%rsi)
movq (%r9), %r10
leaq -0x20(%rbp), %r11
leaq -0x28(%rbp), %r8
movq %r9, %rdi
movq %r14, %r9
pushq %r11
pushq %rax
callq *0x20(%r10)
addq $0x10, %rsp
testl %eax, %eax
jne 0x26b7e
movq -0x20(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x140a4
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r15d
pushq $0x40
popq %rdi
callq 0xc250
movq %rax, %rbx
callq 0x21bd8
leaq 0x9f0b(%rip), %rcx      # 0x30aa3
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x26d6c
leaq 0x219c3(%rip), %rsi     # 0x48570
leaq -0x1e74(%rip), %rdx     # 0x24d40
movq %rbx, %rdi
callq 0xc810
movq %rax, %r14
movq %rbx, %rdi
callq 0xc390
movq %r14, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/path_traits.cpp
// Function: boost::filesystem::path_traits::convert(wchar_t const*, wchar_t const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::codecvt<wchar_t, char, __mbstate_t> const&)
BOOST_FILESYSTEM_DECL
  void convert(const wchar_t* from,
                const wchar_t* from_end,  // 0 for null terminated MBCS
                std::string & to,
                const codecvt_type & cvt)
  {
    BOOST_ASSERT(from);

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

    if (from == from_end) return;

    //  The codecvt length functions may not be implemented, and I don't really
    //  understand them either. Thus this code is just a guess; if it turns
    //  out the buffer is too small then an error will be reported and the code
    //  will have to be fixed.
    std::size_t buf_size = (from_end - from) * 4;  // perhaps too large, but that's OK
    buf_size += 4;  // encodings like shift-JIS need some prefix space

    //  dynamically allocate a buffer only if source is unusually large
    if (buf_size > default_codecvt_buf_size)
    {
      boost::scoped_array< char > buf(new char [buf_size]);
      convert_aux(from, from_end, buf.get(), buf.get()+buf_size, to, cvt);
    }
    else
    {
      char 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 $0x108, %rsp            # imm = 0x108
testq %rdi, %rdi
je 0x26c8a
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
testq %rsi, %rsi
jne 0x26c09
movq %r15, %rdi
callq 0xc420
leaq (%r15,%rax,4), %r12
movq %r12, %r13
subq %r15, %r13
je 0x26c78
addq $0x4, %r13
cmpq $0x101, %r13            # imm = 0x101
jb 0x26c5c
movq %r13, %rdi
callq 0xc030
movq %rbx, %r9
movq %rax, %rbx
addq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x26cbc
movq %rbx, %rdi
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x25502
leaq -0x30(%rbp), %rcx
leaq -0x130(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %r8
movq %rbx, %r9
callq 0x26cbc
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x992b(%rip), %rdi      # 0x305bc
leaq 0x9d02(%rip), %rsi      # 0x3099a
leaq 0x9d90(%rip), %rcx      # 0x30a2f
movl $0xac, %edx
callq 0xc350
movq %rax, %r14
movq %rbx, %rdi
callq 0x25502
movq %r14, %rdi
callq 0xc850