LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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), %rdi
testq %rdi, %rdi
je 0x299c5
cmpq $0x0, 0x48(%rdi)
jne 0x299b5
movq %rbx, %rdi
callq 0x29364
movq 0x40(%rbx), %r15
testq %r15, %r15
je 0x299d5
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 0x299d5
cmpq $0x0, 0x8(%rdi)
je 0x29962
addq $0x40, %rdi
leaq 0xc91c(%rip), %rsi      # 0x36236
callq 0xb880
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x299d5
leaq 0x40(%rax), %rdi
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0xb160
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x299d5
addq $0x40, %rdi
leaq 0xc8e8(%rip), %rsi      # 0x3623c
callq 0xb880
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x299d5
cmpq $0x0, 0x28(%rdi)
je 0x299b5
addq $0x40, %rdi
leaq 0xc8c6(%rip), %rsi      # 0x3623a
callq 0xb880
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x299d5
leaq 0x40(%rax), %rdi
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
callq 0xb160
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x299d5
addq $0x40, %rdi
leaq 0xc895(%rip), %rsi      # 0x3623c
callq 0xb880
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x299d5
movq 0x40(%rdi), %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 0x29364
leaq 0x8c58(%rip), %rdi      # 0x32634
leaq 0x8c59(%rip), %rsi      # 0x3263c
leaq 0xc797(%rip), %rcx      # 0x36181
movl $0x2af, %edx            # imm = 0x2AF
callq 0xb310
movq %rax, %rdi
callq 0xb1e0
movq %rbx, %rdi
callq 0x29364
movq %rax, %rbx
callq 0xb780
jmp 0x299b9
movq %rax, %rdi
callq 0xe915
// File: /workspace/github_cpp_makefile_star2_O3/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 0x28b5b
movq (%rbx), %rdi
addq $0x10, %rbx
addq $0x8, %rsp
cmpq %rbx, %rdi
je 0x29e33
popq %rbx
popq %rbp
jmp 0xb430
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29ef6
movq %rsi, %r14
cmpq %rsi, %rbx
je 0x29e96
movq (%r14), %rsi
cmpb $0x2f, (%rsi)
je 0x29e8c
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x29e8c
movq (%rbx), %rcx
cmpb $0x2f, -0x1(%rcx,%rax)
je 0x29e8c
movq %rbx, %rdi
movl $0x2f, %esi
callq 0xb3f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xb160
jmp 0x29ef6
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
addq %rsi, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0xf98c
movq (%r14), %rsi
cmpb $0x2f, (%rsi)
je 0x29edc
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x29edc
movq (%rbx), %rcx
cmpb $0x2f, -0x1(%rcx,%rax)
je 0x29edc
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 0x29ef6
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 0x29f15
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29f37
movq (%rdi), %rax
cmpb $0x2f, -0x1(%rax,%rbx)
jne 0x29f3b
xorl %ebx, %ebx
jmp 0x29f45
movl $0x2f, %esi
callq 0xb3f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a00d
movq %rsi, %r14
movq (%rbx), %rax
cmpq %rsi, %rax
ja 0x29fe0
movq 0x8(%rbx), %rdx
addq %rax, %rdx
cmpq %r14, %rdx
jbe 0x29fe0
leaq -0x40(%rbp), %r15
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xb1c0
movq (%r15), %rsi
cmpb $0x2f, (%rsi)
je 0x29fc0
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x29fc0
movq (%rbx), %rcx
cmpb $0x2f, -0x1(%rcx,%rax)
je 0x29fc0
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 0x2a00d
callq 0xb430
jmp 0x2a00d
cmpb $0x2f, %cl
je 0x2a002
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x2a002
cmpb $0x2f, -0x1(%rax,%rcx)
je 0x2a002
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 0x2a030
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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), %rsi
movq 0x28(%r15), %rdi
movq %rdx, %rax
xorq %rsi, %rax
movq %rcx, %r8
xorq %rdi, %r8
orq %rax, %r8
je 0x2a1dc
movq 0x20(%rbx), %rax
cmpq 0x20(%r14), %rax
jne 0x2a173
movq 0x28(%r14), %rax
cmpq %rax, 0x28(%rbx)
je 0x2a1e2
movq %r12, %rdi
movq %rbx, %rsi
callq 0xb050
testl %eax, %eax
js 0x2a214
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb050
testl %eax, %eax
js 0x2a21b
movq 0x8(%rbx), %rdx
cmpq 0x8(%r12), %rdx
jne 0x2a222
testq %rdx, %rdx
je 0x2a1b9
movq (%r12), %rsi
movq (%rbx), %rdi
callq 0xb480
testl %eax, %eax
jne 0x2a222
movq %r12, %rdi
callq 0x2b1ba
movq %rbx, %rdi
callq 0x2b1ba
movq 0x20(%r12), %rdx
movq 0x28(%r12), %rcx
movq 0x20(%r15), %rsi
jmp 0x2a14a
movq %rdx, %rsi
movq %rcx, %rdi
movl $0x1, %eax
cmpq %rsi, %rdx
jne 0x2a20b
cmpq %rdi, %rcx
jne 0x2a20b
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 0x2a20b
movl $0x1, %eax
jmp 0x2a20b
leaq 0xc414(%rip), %rdi      # 0x3663d
leaq 0xc432(%rip), %rsi      # 0x36662
leaq 0xc44a(%rip), %rcx      # 0x36681
movl $0x291, %edx            # imm = 0x291
callq 0xb310
jmp 0x2a243
movq %rax, %rdi
callq 0xe915
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %edx, %edx
movq %rdx, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, 0x20(%rdi)
movq 0x8(%rsi), %rax
movq %rdx, 0x28(%rdi)
movl $0x0, %ecx
testq %rax, %rax
je 0x2a308
movq (%rsi), %rdi
movb (%rdi), %r9b
cmpq $0x1, %rax
jne 0x2a2a8
movl $0x1, %ecx
xorl %r8d, %r8d
movl $0x0, %edx
cmpb $0x2f, %r9b
jne 0x2a2ea
jmp 0x2a308
cmpb $0x2f, %r9b
jne 0x2a2e7
cmpb $0x2f, 0x1(%rdi)
jne 0x2a2c6
movl $0x2, %r8d
cmpq $0x2, %rax
je 0x2a2ea
cmpb $0x2f, 0x2(%rdi)
jne 0x2a2ea
movl $0x1, %edx
cmpb $0x2f, (%rdi,%rdx)
jne 0x2a2dd
movq %rdx, 0x28(%rbx)
incq %rdx
cmpq %rdx, %rax
jne 0x2a2cb
decq %rdx
movl $0x1, %ecx
jmp 0x2a308
xorl %r8d, %r8d
xorl %edx, %edx
cmpq %rax, %r8
jae 0x2a305
cmpb $0x2f, (%rdi,%r8)
je 0x2a305
incq %r8
cmpq %r8, %rax
jne 0x2a2f1
movq %rax, %rcx
jmp 0x2a308
movq %r8, %rcx
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 0x2a32f
callq 0xb430
leaq 0xad1e(%rip), %rsi      # 0x35054
movq %rbx, %rdi
callq 0xb110
testl %eax, %eax
jne 0x2a35d
movq 0x8(%rbx), %rdx
leaq 0xad07(%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 0x2a384
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a387
callq 0xb430
jmp 0x2a387
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2a394
callq 0xb430
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a3e8
cmpq %rsi, 0x8(%rdi)
jbe 0x2a3e8
movq (%rdi), %rax
cmpb $0x2f, 0x1(%rax,%rsi)
jne 0x2a3e8
movl $0x1, %edx
popq %rbp
jmp 0xb0d0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a92e
movq %rax, %rbx
cmpq $0x0, 0x8(%r14)
je 0x2a45b
movq (%r14), %rax
cmpb $0x2f, (%rax,%rbx)
setne %r15b
jmp 0x2a45e
movb $0x1, %r15b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a81c
movq (%r14), %rdx
leaq 0x1(%rax), %rcx
incq %rbx
movq %rax, %rdi
negq %rdi
cmpq $0x1, %rbx
je 0x2a499
leaq (%rdi,%rbx), %rsi
cmpq $0x2, %rsi
je 0x2a49d
leaq -0x1(%rbx), %rsi
cmpb $0x2f, -0x2(%rdx,%rbx)
movq %rsi, %rbx
je 0x2a479
jmp 0x2a4a0
xorl %esi, %esi
jmp 0x2a4a0
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_O3/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 0x2a5b6
subq 0x8(%r12), %r15
movq 0x8(%rbx), %rcx
cmpq %r15, %rcx
jb 0x2a581
movq %r15, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax,%r15)
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a544
callq 0xb430
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x2a571
movq (%r14), %rsi
cmpb $0x2e, (%rsi)
je 0x2a569
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 0xc343(%rip), %rdi      # 0x368cb
leaq 0xc328(%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 0x2a5ae
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a9ec
callq 0x2aaff
leaq 0x22029(%rip), %rsi     # 0x4c600
leaq -0x30(%rbp), %rdi
callq 0x2a038
testl %eax, %eax
je 0x2a62d
callq 0x2ac7b
leaq 0x22038(%rip), %rsi     # 0x4c628
leaq -0x30(%rbp), %rdi
callq 0x2a038
testl %eax, %eax
je 0x2a62d
leaq -0x30(%rbp), %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0xb8d0
cmpq $-0x1, %rax
je 0x2a62d
addq -0x30(%rbp), %rax
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb1c0
jmp 0x2a640
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 0x2a652
callq 0xb430
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x2a65e
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a673
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a24c
movq 0x28(%r15), %rax
cmpq 0x8(%r14), %rax
je 0x2a77a
movq -0x40(%rbp), %rdx
cmpq $0x2, %rdx
jb 0x2a77a
movq -0x48(%rbp), %rsi
cmpb $0x2f, (%rsi)
jne 0x2a77a
cmpb $0x2f, 0x1(%rsi)
jne 0x2a77a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xf98c
jmp 0x2a78d
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 0x2a79f
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 0x2a7c2
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a81c
cmpq $-0x1, %rax
je 0x2a801
movq (%r14), %rcx
leaq (%rcx,%rax), %rsi
leaq (%rcx,%rax), %rdx
incq %rdx
movq %rbx, %rdi
callq 0x2b68c
jmp 0x2a814
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_O3/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 0x2a83f
movq (%rdi), %rcx
cmpb $0x2f, (%rcx)
jne 0x2a896
movq $-0x1, %rax
cmpb $0x2f, 0x1(%rcx)
jne 0x2a892
jmp 0x2a89d
movq %rsi, %rbx
cmpq $0x4, %rsi
jb 0x2a885
movq (%rdi), %rax
cmpb $0x2f, (%rax)
jne 0x2a896
cmpb $0x2f, 0x1(%rax)
jne 0x2a892
cmpb $0x2f, 0x2(%rax)
je 0x2a892
leaq 0xa7f1(%rip), %rsi      # 0x35054
movl $0x2, %edx
movl $0x1, %ecx
callq 0xb6c0
movq %rax, %rcx
cmpq %rbx, %rax
movq $-0x1, %rax
cmovbq %rcx, %rax
jmp 0x2a89d
testq %rbx, %rbx
je 0x2a896
movq (%rdi), %rax
cmpb $0x2f, (%rax)
jne 0x2a896
xorl %eax, %eax
jmp 0x2a89d
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a24c
movq -0x28(%rbp), %rsi
cmpq 0x8(%r14), %rsi
je 0x2a8e0
movq -0x50(%rbp), %rax
cmpb $0x2f, (%rax)
jne 0x2a8e0
movq %r15, %rdi
callq 0x2b1ba
jmp 0x2a8c3
addq (%r14), %rsi
leaq -0x19(%rbp), %rdx
movq %rbx, %rdi
callq 0xb1c0
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a901
callq 0xb430
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a911
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a926
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a952
cmpq $0x2, %rsi
jne 0x2a95b
movq (%rbx), %rcx
cmpb $0x2f, (%rcx)
jne 0x2a95e
cmpb $0x2f, 0x1(%rcx)
jne 0x2a95e
jmp 0x2a994
movq $-0x1, %rax
jmp 0x2a969
movq (%rbx), %rcx
leaq -0x1(%rsi), %rax
cmpb $0x2f, -0x1(%rcx,%rsi)
je 0x2a99b
leaq 0xa6e4(%rip), %rsi      # 0x35054
movl $0x1, %ecx
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb900
cmpq $-0x1, %rax
je 0x2a994
cmpq $0x1, %rax
jne 0x2a998
movq (%rbx), %rcx
cmpb $0x2f, (%rcx)
jne 0x2a998
xorl %eax, %eax
jmp 0x2a99b
incq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a42e
cmpq $-0x1, %rax
je 0x2a9d0
movq (%r14), %rsi
addq %rsi, %rax
movq %rbx, %rdi
movq %rax, %rdx
callq 0x2b68c
jmp 0x2a9e3
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_O3/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 0x2a92e
movq %rax, %r14
movq (%r15), %rsi
testq %rax, %rax
je 0x2aa33
cmpq $0x0, 0x8(%r15)
je 0x2aa33
cmpb $0x2f, (%rsi,%r14)
jne 0x2aa33
movq %r15, %rdi
movq %r14, %rsi
callq 0x2aa77
testb %al, %al
je 0x2aa50
movq (%r15), %rsi
addq %r14, %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 0x2aaff
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x21b9d(%rip), %rsi     # 0x4c600
movq 0x21b9e(%rip), %rdx     # 0x4c608
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xf98c
jmp 0x2aa42
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2aae0
movq (%rdi), %rax
cmpb $0x2f, (%rax,%rsi)
jne 0x2aae0
incq %rsi
cmpq $0x1, %rsi
je 0x2aad3
leaq -0x1(%rsi), %rbx
cmpb $0x2f, -0x2(%rax,%rsi)
movq %rbx, %rsi
je 0x2aa90
cmpq $0x3, %rbx
jb 0x2aad7
cmpb $0x2f, (%rax)
jne 0x2aad7
cmpb $0x2f, 0x1(%rax)
jne 0x2aad7
leaq 0xa598(%rip), %rsi      # 0x35054
movl $0x2, %edx
movl $0x1, %ecx
callq 0xb6c0
cmpq %rbx, %rax
sete %al
jmp 0x2aad9
movb $0x1, %al
jmp 0x2aad9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xbd3d(%rip), %rdi      # 0x36824
leaq 0xbb74(%rip), %rsi      # 0x36662
leaq 0xbd74(%rip), %rcx      # 0x36869
movl $0x1db, %edx            # imm = 0x1DB
callq 0xb310
// File: /workspace/github_cpp_makefile_star2_O3/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 0x21b15(%rip), %al      # 0x4c620
testb %al, %al
je 0x2ab1d
leaq 0x21aea(%rip), %rax     # 0x4c600
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x21afc(%rip), %rdi     # 0x4c620
callq 0xb820
testl %eax, %eax
je 0x2ab0f
leaq 0x21adc(%rip), %rax     # 0x4c610
movq %rax, 0x21ac5(%rip)     # 0x4c600
leaq 0x21abe(%rip), %rdi     # 0x4c600
leaq 0xbba4(%rip), %rsi      # 0x366ed
leaq 0xbb9e(%rip), %rdx      # 0x366ee
callq 0xf8ee
leaq -0x170c(%rip), %rdi     # 0x29450
leaq 0x21a9d(%rip), %rsi     # 0x4c600
leaq 0x2192e(%rip), %rdx     # 0x4c498
callq 0xb400
leaq 0x21aaa(%rip), %rdi     # 0x4c620
callq 0xb2f0
jmp 0x2ab0f
movq %rax, %rbx
leaq 0x21a99(%rip), %rdi     # 0x4c620
callq 0xb2e0
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a9ec
callq 0x2aaff
leaq 0x21a4b(%rip), %rsi     # 0x4c600
leaq -0x28(%rbp), %rdi
callq 0x2a038
testl %eax, %eax
je 0x2ac0a
callq 0x2ac7b
leaq 0x21a5a(%rip), %rsi     # 0x4c628
leaq -0x28(%rbp), %rdi
callq 0x2a038
testl %eax, %eax
je 0x2ac0a
leaq -0x28(%rbp), %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0xb8d0
cmpq $-0x1, %rax
je 0x2ac40
movq -0x28(%rbp), %rsi
addq %rsi, %rax
movq %rbx, %rdi
movq %rax, %rdx
callq 0x2b68c
jmp 0x2ac24
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xf98c
leaq -0x18(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ac36
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 0xf98c
jmp 0x2ac24
jmp 0x2ac5e
movq %rax, %rbx
leaq -0x18(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ac73
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x219c1(%rip), %al      # 0x4c648
testb %al, %al
je 0x2ac99
leaq 0x21996(%rip), %rax     # 0x4c628
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x219a8(%rip), %rdi     # 0x4c648
callq 0xb820
testl %eax, %eax
je 0x2ac8b
leaq 0x21988(%rip), %rax     # 0x4c638
movq %rax, 0x21971(%rip)     # 0x4c628
leaq 0x2196a(%rip), %rdi     # 0x4c628
leaq 0xba27(%rip), %rsi      # 0x366ec
leaq 0xba22(%rip), %rdx      # 0x366ee
callq 0xf8ee
leaq -0x1888(%rip), %rdi     # 0x29450
leaq 0x21949(%rip), %rsi     # 0x4c628
leaq 0x217b2(%rip), %rdx     # 0x4c498
callq 0xb400
leaq 0x21956(%rip), %rdi     # 0x4c648
callq 0xb2f0
jmp 0x2ac8b
movq %rax, %rbx
leaq 0x21945(%rip), %rdi     # 0x4c648
callq 0xb2e0
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2b461
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 0x2b382
movq (%rdi), %rax
cmpb $0x2f, -0x1(%rax,%r14)
jne 0x2b382
leaq -0x1(%r14), %rsi
callq 0x2aa77
testb %al, %al
je 0x2b43f
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x2a81c
movq 0x20(%rbx), %rdi
leaq 0x1(%rax), %rcx
incq %r14
negq %rax
cmpq $0x1, %r14
je 0x2b3bc
leaq (%rax,%r14), %rdx
cmpq $0x2, %rdx
je 0x2b3c1
movq (%rdi), %rdx
leaq -0x1(%r14), %r15
cmpb $0x2f, -0x2(%rdx,%r14)
movq %r15, %r14
je 0x2b398
jmp 0x2b3c4
xorl %r15d, %r15d
jmp 0x2b3c4
movq %rcx, %r15
movq %r15, %rsi
callq 0x2a92e
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 0xb490
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb290
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b406
callq 0xb430
leaq 0x9c47(%rip), %rsi      # 0x35054
movq %rbx, %rdi
callq 0xb110
testl %eax, %eax
jne 0x2b434
movq 0x8(%rbx), %rdx
leaq 0x9c30(%rip), %rcx      # 0x35054
movl $0x1, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb6f0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
decq 0x28(%rbx)
callq 0x2aaff
leaq 0x211b1(%rip), %rsi     # 0x4c600
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb290
leaq 0xb335(%rip), %rdi      # 0x3679d
leaq 0xb1f3(%rip), %rsi      # 0x36662
leaq 0xb35d(%rip), %rcx      # 0x367d3
movl $0x308, %edx            # imm = 0x308
callq 0xb310
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b495
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x211ae(%rip), %al      # 0x4c658
testb %al, %al
je 0x2b4ca
movb 0x211a4(%rip), %al      # 0x4c658
testb %al, %al
je 0x2b515
leaq 0x21191(%rip), %rdi     # 0x4c650
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb630
leaq 0x21187(%rip), %rdi     # 0x4c658
callq 0xb820
testl %eax, %eax
je 0x2b4ae
leaq 0x2116f(%rip), %rdi     # 0x4c650
leaq 0x79c2(%rip), %rsi      # 0x32eaa
callq 0xb390
movq 0x20acc(%rip), %rdi     # 0x4bfc0
leaq 0x21155(%rip), %rsi     # 0x4c650
leaq 0x20f96(%rip), %rdx     # 0x4c498
callq 0xb400
leaq 0x2114a(%rip), %rdi     # 0x4c658
callq 0xb2f0
jmp 0x2b4ae
leaq 0x2113c(%rip), %rdi     # 0x4c658
callq 0xb820
testl %eax, %eax
je 0x2b4b8
leaq 0x21124(%rip), %rdi     # 0x4c650
leaq 0x7977(%rip), %rsi      # 0x32eaa
callq 0xb390
movq 0x20a81(%rip), %rdi     # 0x4bfc0
leaq 0x2110a(%rip), %rsi     # 0x4c650
leaq 0x20f4b(%rip), %rdx     # 0x4c498
callq 0xb400
leaq 0x210ff(%rip), %rdi     # 0x4c658
callq 0xb2f0
jmp 0x2b4b8
jmp 0x2b565
movq %rax, %rbx
leaq 0x210e9(%rip), %rdi     # 0x4c658
callq 0xb2e0
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x210c9(%rip), %al      # 0x4c658
testb %al, %al
je 0x2b5c3
leaq 0x210b6(%rip), %rsi     # 0x4c650
movq %rbx, %rdi
callq 0xb2d0
movb 0x210b0(%rip), %al      # 0x4c658
testb %al, %al
je 0x2b60e
leaq 0x2109d(%rip), %rdi     # 0x4c650
movq %r14, %rsi
callq 0xb4d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2108e(%rip), %rdi     # 0x4c658
callq 0xb820
testl %eax, %eax
je 0x2b593
leaq 0x21076(%rip), %rdi     # 0x4c650
leaq 0x78c9(%rip), %rsi      # 0x32eaa
callq 0xb390
movq 0x209d3(%rip), %rdi     # 0x4bfc0
leaq 0x2105c(%rip), %rsi     # 0x4c650
leaq 0x20e9d(%rip), %rdx     # 0x4c498
callq 0xb400
leaq 0x21051(%rip), %rdi     # 0x4c658
callq 0xb2f0
jmp 0x2b593
leaq 0x21043(%rip), %rdi     # 0x4c658
callq 0xb820
testl %eax, %eax
je 0x2b5ac
leaq 0x2102b(%rip), %rdi     # 0x4c650
leaq 0x787e(%rip), %rsi      # 0x32eaa
callq 0xb390
movq 0x20988(%rip), %rdi     # 0x4bfc0
leaq 0x21011(%rip), %rsi     # 0x4c650
leaq 0x20e52(%rip), %rdx     # 0x4c498
callq 0xb400
leaq 0x21006(%rip), %rdi     # 0x4c658
callq 0xb2f0
jmp 0x2b5ac
movq %rax, %r14
leaq 0x20ff2(%rip), %rdi     # 0x4c658
callq 0xb2e0
movq %rbx, %rdi
callq 0xb938
jmp 0x2b684
movq %rax, %r14
leaq 0x20fd9(%rip), %rdi     # 0x4c658
callq 0xb2e0
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2b6f1
movq %rdi, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq -0x40(%rbp), %rdi
callq 0xf8ee
movq -0x40(%rbp), %rcx
testq %rcx, %rcx
je 0x2b6fe
movq -0x38(%rbp), %r8
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xb4f0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x2b6f1
callq 0xb430
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xaddd(%rip), %rdi      # 0x364e2
leaq 0xaddb(%rip), %rsi      # 0x364e7
leaq 0xadf7(%rip), %rcx      # 0x3650a
movl $0xc2, %edx
callq 0xb310
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x2b733
callq 0xb430
jmp 0x2b733
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2b740
callq 0xb430
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2b87a
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
testq %rsi, %rsi
jne 0x2b7e4
movq %r15, %rdi
callq 0xb200
movq %rax, %r12
addq %r15, %r12
movq %r12, %rax
subq %r15, %rax
je 0x2b868
leaq (%rax,%rax,2), %rbx
cmpq $0x101, %rbx            # imm = 0x101
jb 0x2b84c
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 0x2b8ac
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 0x2b8ac
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xac61(%rip), %rdi      # 0x364e2
leaq 0xb07a(%rip), %rsi      # 0x36902
leaq 0xb099(%rip), %rcx      # 0x36928
movl $0x8a, %edx
callq 0xb310
movq %rax, %rbx
movq %r13, %rdi
callq 0xb5a0
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2ba28
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
testq %rsi, %rsi
jne 0x2b9a7
movq %r15, %rdi
callq 0xb3e0
leaq (%r15,%rax,4), %r12
movq %r12, %r13
subq %r15, %r13
je 0x2ba16
addq $0x4, %r13
cmpq $0x101, %r13            # imm = 0x101
jb 0x2b9fa
movq %r13, %rdi
callq 0xb030
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 0x2ba5a
movq %rbx, %rdi
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb5a0
leaq -0x30(%rbp), %rcx
leaq -0x130(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %r8
movq %rbx, %r9
callq 0x2ba5a
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xaab3(%rip), %rdi      # 0x364e2
leaq 0xaecc(%rip), %rsi      # 0x36902
leaq 0xaf5a(%rip), %rcx      # 0x36997
movl $0xac, %edx
callq 0xb310
movq %rax, %r14
movq %rbx, %rdi
callq 0xb5a0
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/filesystem/src/path_traits.cpp
// Function: (anonymous namespace)::convert_aux(wchar_t const*, wchar_t const*, char*, char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::codecvt<wchar_t, char, __mbstate_t> const&)
void convert_aux(
                   const wchar_t* from,
                   const wchar_t* from_end,
                   char* to, char* to_end,
                   std::string & 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 wchar_t* from_next;
    char* to_next;

    std::codecvt_base::result res;

    if ((res=cvt.out(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 string"));
    }
    target.append(to, to_next); 
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %rax
movq %rdx, %rbx
movq %rsi, %rcx
movq %rdi, %rdx
leaq -0x30(%rbp), %rsi
movq $0x0, (%rsi)
movq (%r9), %r10
leaq -0x20(%rbp), %r11
leaq -0x28(%rbp), %r8
movq %r9, %rdi
movq %rbx, %r9
pushq %r11
pushq %rax
callq *0x10(%r10)
addq $0x10, %rsp
testl %eax, %eax
jne 0x2bac4
movq -0x20(%rbp), %r8
movq 0x8(%r14), %rsi
subq %rbx, %r8
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xb4f0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r15d
movl $0x40, %edi
callq 0xb250
movq %rax, %rbx
callq 0x25cb4
leaq 0xaf56(%rip), %rcx      # 0x36a36
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x2bb18
leaq 0x1fa5b(%rip), %rsi     # 0x4b550
leaq -0x2390(%rip), %rdx     # 0x2976c
movq %rbx, %rdi
callq 0xb7b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xb360
movq %r14, %rdi
callq 0xb7f0
nop