LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x2, -0x18(%rbp)
jne 0x5080b
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd6d0
movsbl (%rax), %edi
callq 0x4fab0
testb $0x1, %al
jne 0x507e2
jmp 0x5080b
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xd6d0
movsbl (%rax), %edi
callq 0x4fab0
testb $0x1, %al
jne 0x507fe
jmp 0x5080b
movq $-0x1, -0x8(%rbp)
jmp 0x508df
cmpq $0x3, -0x18(%rbp)
jbe 0x508ab
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd6d0
movsbl (%rax), %edi
callq 0x4fab0
testb $0x1, %al
jne 0x50831
jmp 0x508ab
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xd6d0
movsbl (%rax), %edi
callq 0x4fab0
testb $0x1, %al
jne 0x5084d
jmp 0x508ab
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xd6d0
movsbl (%rax), %edi
callq 0x4fab0
testb $0x1, %al
jne 0x508ab
movq -0x10(%rbp), %rdi
leaq 0x117de(%rip), %rsi     # 0x62050
movl $0x2, %edx
callq 0xd2c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x50894
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x508a1
movq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x508a1
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x508df
cmpq $0x0, -0x18(%rbp)
jbe 0x508d7
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd6d0
movsbl (%rax), %edi
callq 0x4fab0
testb $0x1, %al
jne 0x508cd
jmp 0x508d7
movq $0x0, -0x8(%rbp)
jmp 0x508df
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4ff50
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0xd430
movq -0x78(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x69(%rbp)
je 0x50973
xorl %eax, %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
callq 0xdc50
movq %rax, -0x80(%rbp)
jmp 0x50954
movq -0x80(%rbp), %rax
movsbl (%rax), %edi
callq 0x4fab0
movb %al, -0x81(%rbp)
jmp 0x50968
movb -0x81(%rbp), %al
movb %al, -0x69(%rbp)
jmp 0x50973
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x5097c
jmp 0x509a2
jmp 0x5097e
leaq -0x40(%rbp), %rdi
callq 0x4d980
jmp 0x50989
jmp 0x5091f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4d8a0
jmp 0x509d6
movq -0x58(%rbp), %rdi
callq 0xd210
movq -0x68(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rax
addq %rax, %rsi
callq 0x4df90
jmp 0x509c0
leaq -0x40(%rbp), %rdi
callq 0x4d8a0
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xdb30
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x2, -0x18(%rbp)
jne 0x50a3b
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd6d0
movsbl (%rax), %edi
callq 0x4fab0
testb $0x1, %al
jne 0x50a12
jmp 0x50a3b
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xd6d0
movsbl (%rax), %edi
callq 0x4fab0
testb $0x1, %al
jne 0x50a2e
jmp 0x50a3b
movq $0x0, -0x8(%rbp)
jmp 0x50ad0
cmpq $0x0, -0x18(%rbp)
je 0x50a6f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
subq $0x1, %rsi
callq 0xd6d0
movsbl (%rax), %edi
callq 0x4fab0
testb $0x1, %al
jne 0x50a61
jmp 0x50a6f
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x50ad0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
leaq 0x115ce(%rip), %rsi     # 0x62050
callq 0xd5d0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x50ab4
cmpq $0x1, -0x20(%rbp)
jne 0x50abc
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd6d0
movsbl (%rax), %edi
callq 0x4fab0
testb $0x1, %al
jne 0x50ab4
jmp 0x50abc
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x50ac8
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x50180
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x50b1e
movq -0x30(%rbp), %rdi
callq 0x4d620
jmp 0x50b48
movq -0x20(%rbp), %rdi
callq 0xd210
movq -0x20(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0xd210
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
addq -0x18(%rbp), %rdx
callq 0x52020
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xd430
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x509e0
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0xd430
cmpq $0x0, %rax
je 0x50bed
cmpq $0x0, -0x18(%rbp)
je 0x50bed
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd6d0
movsbl (%rax), %edi
callq 0x4fab0
testb $0x1, %al
jne 0x50bc9
jmp 0x50bed
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x50c10
testb $0x1, %al
jne 0x50bed
callq 0x50d50
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x4d4f0
jmp 0x50c06
movq -0x20(%rbp), %rdi
callq 0xd210
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq -0x18(%rbp), %rsi
callq 0x4df90
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdab0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0x50c5f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd6d0
movsbl (%rax), %edi
callq 0x4fab0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0x50c58
jmp 0x50c5f
movb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x50c5f
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x50c68
jmp 0x50c6a
jmp 0x50c89
leaq 0x12e35(%rip), %rdi     # 0x63aa6
leaq 0x12b43(%rip), %rsi     # 0x637bb
movl $0x1db, %edx            # imm = 0x1DB
leaq 0x12e67(%rip), %rcx     # 0x63aeb
callq 0xd400
jmp 0x50c8b
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1a(%rbp)
jbe 0x50cb3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
subq $0x1, %rsi
callq 0xd6d0
movsbl (%rax), %edi
callq 0x4fab0
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x50cbc
jmp 0x50cca
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x50c8b
cmpq $0x0, -0x18(%rbp)
jne 0x50cd7
movb $0x1, -0x1(%rbp)
jmp 0x50d3a
cmpq $0x3, -0x18(%rbp)
jb 0x50d13
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd6d0
movsbl (%rax), %edi
callq 0x4fab0
testb $0x1, %al
jne 0x50cf9
jmp 0x50d13
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xd6d0
movsbl (%rax), %edi
callq 0x4fab0
testb $0x1, %al
jne 0x50d19
movb $0x0, -0x1(%rbp)
jmp 0x50d3a
movq -0x10(%rbp), %rdi
leaq 0x1132c(%rip), %rsi     # 0x62050
movl $0x2, %edx
callq 0xd2c0
cmpq -0x18(%rbp), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x50b60
callq 0x50d50
movq %rax, -0x50(%rbp)
jmp 0x50e16
movq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4d8c0
movb %al, -0x61(%rbp)
jmp 0x50e28
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x50e57
jmp 0x50e31
callq 0x50f20
movq %rax, -0x70(%rbp)
jmp 0x50e3c
movq -0x70(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4d8c0
movb %al, -0x71(%rbp)
jmp 0x50e4e
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x50e57
jmp 0x50e8c
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4d4f0
jmp 0x50e66
movl $0x1, -0x40(%rbp)
jmp 0x50eff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4d550
jmp 0x50f15
leaq -0x30(%rbp), %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0xdc30
movq %rax, -0x48(%rbp)
cmpq $-0x1, -0x48(%rbp)
jne 0x50ebd
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4d4f0
jmp 0x50ebb
jmp 0x50ef8
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xd210
movq -0x88(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0xd210
movq -0x60(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq %rax, %rdx
movq -0x48(%rbp), %rax
addq %rax, %rdx
callq 0x52020
jmp 0x50ef6
jmp 0x50ef8
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4d550
movq -0x58(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xdb30
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x51e90
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xd3b0
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x51e90
movq %rax, -0x30(%rbp)
jmp 0x51f63
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0xd6e0
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x51f9c
jmp 0x51f93
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xdcb8
jmp 0x51fa6
movq -0x40(%rbp), %rdi
callq 0xdcb8
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xdb30
nop
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xd8f0
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x5210e
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xdb50
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0x522d0
jmp 0x52086
leaq -0x39(%rbp), %rdi
callq 0xd6b0
leaq -0x38(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xd210
movq -0x88(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0xd210
movq -0x88(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0xd430
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdi
movq -0x58(%rbp), %rdx
addq %rax, %rsi
callq 0x4f600
jmp 0x520d5
leaq -0x38(%rbp), %rdi
callq 0xdca8
jmp 0x5210e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xd6b0
jmp 0x52117
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xdca8
jmp 0x52117
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xdca8
movq -0x48(%rbp), %rdi
callq 0xdb30
nopl (%rax)
// File: 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
subq $0x470, %rsp            # imm = 0x470
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x52624
jmp 0x52643
leaq 0x11007(%rip), %rdi     # 0x63632
leaq 0x11507(%rip), %rsi     # 0x63b39
movl $0x8a, %edx
leaq 0x11521(%rip), %rcx     # 0x63b5f
callq 0xd400
cmpq $0x0, -0x10(%rbp)
jne 0x5266f
movq -0x8(%rbp), %rax
movq %rax, -0x448(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd240
movq %rax, %rcx
movq -0x448(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x5267e
jmp 0x5277e
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
imulq $0x3, %rax, %rax
movq %rax, -0x28(%rbp)
cmpq $0x100, -0x28(%rbp)     # imm = 0x100
jbe 0x52754
movq -0x28(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0xd030
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x468(%rbp)
callq 0x52b20
movq -0x468(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x460(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x458(%rbp)
callq 0x52b40
movq -0x468(%rbp), %rdi
movq %rax, -0x450(%rbp)
callq 0x52b40
movq -0x460(%rbp), %rdi
movq -0x458(%rbp), %rsi
movq -0x450(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq (%rax,%rcx,4), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
callq 0x52790
jmp 0x52732
leaq -0x30(%rbp), %rdi
callq 0x52b60
jmp 0x5277e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52b60
jmp 0x52787
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x440(%rbp), %rdx
leaq -0x440(%rbp), %rcx
addq $0x400, %rcx            # imm = 0x400
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
callq 0x52790
addq $0x470, %rsp            # imm = 0x470
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xdb30
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0xd310
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r9
movq -0x20(%rbp), %r10
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %r8
leaq -0x48(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x220d0
movl %eax, -0x4c(%rbp)
cmpl $0x0, %eax
je 0x5285f
movl $0x40, %edi
callq 0xd2b0
movq %rax, -0x78(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x6c(%rbp)
callq 0x471d0
movq %rax, -0x68(%rbp)
jmp 0x52818
movq -0x68(%rbp), %rdx
movl -0x6c(%rbp), %esi
movq -0x78(%rbp), %rdi
leaq 0x11418(%rip), %rcx     # 0x63c42
callq 0x52b90
jmp 0x52831
movq -0x78(%rbp), %rdi
leaq 0x3ad04(%rip), %rsi     # 0x8d540
leaq -0x45d3(%rip), %rdx     # 0x4e270
callq 0xdad0
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0xd460
jmp 0x52879
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x227e0
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0xd310
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r9
movq -0x20(%rbp), %r10
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %r8
leaq -0x48(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x223a0
movl %eax, -0x4c(%rbp)
cmpl $0x0, %eax
je 0x52aef
movl $0x40, %edi
callq 0xd2b0
movq %rax, -0x78(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x6c(%rbp)
callq 0x471d0
movq %rax, -0x68(%rbp)
jmp 0x52aa8
movq -0x68(%rbp), %rdx
movl -0x6c(%rbp), %esi
movq -0x78(%rbp), %rdi
leaq 0x111b3(%rip), %rcx     # 0x63c6d
callq 0x52b90
jmp 0x52ac1
movq -0x78(%rbp), %rdi
leaq 0x3aa74(%rip), %rsi     # 0x8d540
leaq -0x4863(%rip), %rdx     # 0x4e270
callq 0xdad0
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0xd460
jmp 0x52b09
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x23750
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: demon386[P]git-store/./libs/filesystem/src/portability.cpp
// Function: boost::filesystem::windows_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
BOOST_FILESYSTEM_DECL bool windows_name(const std::string & name)
    {
      return name.size() != 0
        && name[0] != ' '
        && name.find_first_of(windows_invalid_chars) == std::string::npos
        && *(name.end()-1) != ' '
        && (*(name.end()-1) != '.'
          || name.length() == 1 || name == "..");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd430
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x29(%rbp)
je 0x52de5
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd6d0
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x20, %ecx
movb %al, -0x29(%rbp)
je 0x52de5
movq -0x8(%rbp), %rdi
leaq 0x3bb28(%rip), %rsi     # 0x8e858
xorl %eax, %eax
movl %eax, %edx
callq 0xd590
movq %rax, %rcx
xorl %eax, %eax
cmpq $-0x1, %rcx
movb %al, -0x29(%rbp)
jne 0x52de5
movq -0x8(%rbp), %rdi
callq 0xdbb0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x2a8b0
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2a440
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x20, %ecx
movb %al, -0x29(%rbp)
je 0x52de5
movq -0x8(%rbp), %rdi
callq 0xdbb0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x2a8b0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2a440
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2e, %ecx
movb %al, -0x2a(%rbp)
jne 0x52ddf
movq -0x8(%rbp), %rdi
callq 0xd9b0
movq %rax, %rcx
movb $0x1, %al
cmpq $0x1, %rcx
movb %al, -0x2a(%rbp)
je 0x52ddf
movq -0x8(%rbp), %rdi
leaq 0x10a6e(%rip), %rsi     # 0x63845
callq 0x13120
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: demon386[P]git-store/./libs/filesystem/src/portability.cpp
// Function: boost::filesystem::portable_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
BOOST_FILESYSTEM_DECL bool portable_name(const std::string & name)
    {
      return
        name.size() != 0
        && (name == "."
          || name == ".."
          || (windows_name(name)
            && portable_posix_name(name)
            && name[0] != '.' && name[0] != '-'));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd430
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x9(%rbp)
je 0x52ec0
movq -0x8(%rbp), %rdi
leaq 0x10a24(%rip), %rsi     # 0x63846
callq 0x13120
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xa(%rbp)
jne 0x52eba
movq -0x8(%rbp), %rdi
leaq 0x10a03(%rip), %rsi     # 0x63845
callq 0x13120
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xa(%rbp)
jne 0x52eba
movq -0x8(%rbp), %rdi
callq 0x52ce0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xb(%rbp)
jne 0x52e6a
jmp 0x52eb4
movq -0x8(%rbp), %rdi
callq 0x52c90
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xb(%rbp)
jne 0x52e81
jmp 0x52eb4
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd6d0
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
movb %al, -0xb(%rbp)
je 0x52eb4
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd6d0
movsbl (%rax), %eax
cmpl $0x2d, %eax
setne %al
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/portability.cpp
// Function: boost::filesystem::portable_directory_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
BOOST_FILESYSTEM_DECL bool portable_directory_name(const std::string & name)
    {
      return
        name == "."
        || name == ".."
        || (portable_name(name)
          && name.find('.') == std::string::npos);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1095f(%rip), %rsi     # 0x63846
callq 0x13120
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x52f4d
movq -0x8(%rbp), %rdi
leaq 0x10942(%rip), %rsi     # 0x63845
callq 0x13120
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x52f4d
movq -0x8(%rbp), %rdi
callq 0x52df0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xa(%rbp)
jne 0x52f2b
jmp 0x52f47
movq -0x8(%rbp), %rdi
movl $0x2e, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xd850
cmpq $-0x1, %rax
sete %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/portability.cpp
// Function: boost::filesystem::portable_file_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
BOOST_FILESYSTEM_DECL bool portable_file_name(const std::string & name)
    {
      std::string::size_type pos;
      return
         portable_name(name)
         && name != "."
         && name != ".."
         && ((pos = name.find('.')) == std::string::npos
             || (name.find('.', pos+1) == std::string::npos
               && (pos + 5) > name.length()))
        ;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x52df0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x52f86
jmp 0x5303e
movq -0x8(%rbp), %rdi
leaq 0x108b5(%rip), %rsi     # 0x63846
callq 0x53050
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x52fa7
jmp 0x5303e
movq -0x8(%rbp), %rdi
leaq 0x10893(%rip), %rsi     # 0x63845
callq 0x53050
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x52fc5
jmp 0x5303e
movq -0x8(%rbp), %rdi
movl $0x2e, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xd850
movq %rax, %rcx
movq %rcx, -0x10(%rbp)
movb $0x1, %al
cmpq $-0x1, %rcx
movb %al, -0x12(%rbp)
je 0x53038
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x1, %rdx
movl $0x2e, %esi
callq 0xd850
movq %rax, %rcx
xorl %eax, %eax
cmpq $-0x1, %rcx
movb %al, -0x13(%rbp)
jne 0x53032
movq -0x10(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd9b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
seta %al
movb %al, -0x13(%rbp)
movb -0x13(%rbp), %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: demon386[P]git-store/./libs/filesystem/src/unique_path.cpp
// Function: (anonymous namespace)::fail(int, boost::system::error_code*)
void fail(int err, boost::system::error_code* ec)
{
  if (ec == 0)
    BOOST_FILESYSTEM_THROW( boost::system::system_error(err,
      boost::system::system_category(),
      "boost::filesystem::unique_path"));

  ec->assign(err, boost::system::system_category());
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x53419
movl $0x40, %edi
callq 0xd2b0
movq %rax, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
callq 0x53ec0
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
movq %rax, %rdx
leaq 0x1093c(%rip), %rcx     # 0x63d20
callq 0x52b90
jmp 0x533eb
movq -0x30(%rbp), %rdi
leaq 0x3a14a(%rip), %rsi     # 0x8d540
leaq -0x518d(%rip), %rdx     # 0x4e270
callq 0xdad0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xd460
jmp 0x53441
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x53ec0
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %esi
movq %rax, %rdx
callq 0x4d800
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xdb30
nopw (%rax,%rax)
// File: demon386[P]git-store/./boost/filesystem/path.hpp
// Function: boost::filesystem::path::wstring[abi:cxx11]() const
const std::wstring  wstring() const
    {
      std::wstring tmp;
      if (!m_pathname.empty())
        path_traits::convert(&*m_pathname.begin(), &*m_pathname.begin()+m_pathname.size(),
          tmp);
      return tmp;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xd2a0
movq -0x40(%rbp), %rdi
callq 0xdab0
testb $0x1, %al
jne 0x534f5
movq -0x40(%rbp), %rdi
callq 0xd5e0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2a440
movq -0x40(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0xd5e0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2a440
movq -0x40(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0xd430
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
addq %rax, %rsi
callq 0x53580
jmp 0x534dc
jmp 0x534f5
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xdcc0
jmp 0x53512
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x53508
movq -0x50(%rbp), %rdi
callq 0xdcc0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xdb30
nopl (%rax,%rax)
// File: demon386[P]git-store/./command.hpp
// Function: command::add_subcommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::function<void (boost::program_options::options_description&)>)
void add_subcommand(CommandNameT command_name,
        CommandDescT command_desc,
        CommandCallbackT callback) {
    auto& callback_map = global_command_map();
    callback_map[std::move(command_name)] = std::make_tuple(
            std::move(command_desc),
            std::move(callback));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rsi, -0x90(%rbp)
movq %rdx, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x56fa0
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq %rax, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x57000
movq -0x80(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x57040
movq %rax, -0x78(%rbp)
jmp 0x54a1c
movq -0x78(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x57120
leaq -0x60(%rbp), %rdi
callq 0x57160
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x57160
movq -0x68(%rbp), %rdi
callq 0xdb30
nopl (%rax)
// File: demon386[P]git-store/./subprocess.hpp
// Function: subprocess::run_cmd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
ExitStatusT run_cmd(const std::string& cmd, bool require_stdout=true) {
    FILE* pipe = popen(cmd.c_str(), "r");
    if (!pipe) {
        return -1;
    }
    constexpr int buffer_size = 128;
    char buffer[buffer_size];
    while (!feof(pipe)) {
        if (fgets(buffer, buffer_size, pipe) != nullptr) {
            if (require_stdout) {
                printf("%s", buffer);
            }
        }
    }
    return pclose(pipe);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd210
movq %rax, %rdi
leaq 0xeb4e(%rip), %rsi      # 0x641c8
callq 0xd180
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x55693
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x556f7
movl $0x80, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0xda10
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x556b1
jmp 0x556eb
leaq -0xb0(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x80, %esi
callq 0xda40
cmpq $0x0, %rax
je 0x556e9
testb $0x1, -0x11(%rbp)
je 0x556e7
leaq -0xb0(%rbp), %rsi
leaq 0xea94(%rip), %rdi      # 0x64174
movb $0x0, %al
callq 0xd080
jmp 0x556e9
jmp 0x5569a
movq -0x20(%rbp), %rdi
callq 0xd920
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./boost/program_options/detail/parsers.hpp
// Function: boost::program_options::basic_command_line_parser<char>::run()
basic_parsed_options<charT>
    basic_command_line_parser<charT>::run()
    {
        // save the canonical prefixes which were used by this cmdline parser
        //    eventually inside the parsed results
        //    This will be handy to format recognisable options
        //    for diagnostic messages if everything blows up much later on
        parsed_options result(m_desc, detail::cmdline::get_canonical_option_prefix());
        result.options = detail::cmdline::run();

        // Presense of parsed_options -> wparsed_options conversion
        // does the trick.
        return basic_parsed_options<charT>(result);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq 0x70(%rdi), %rax
movq %rax, -0x70(%rbp)
callq 0xec00
movq -0x70(%rbp), %rsi
movl %eax, %edx
leaq -0x38(%rbp), %rdi
callq 0x2edf0
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xeca0
jmp 0x57401
leaq -0x38(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x50(%rbp), %rsi
movq %rsi, -0x90(%rbp)
callq 0x13010
movq -0x90(%rbp), %rdi
callq 0x12700
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x2f140
jmp 0x5743a
leaq -0x38(%rbp), %rdi
callq 0x2f180
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2f180
movq -0x58(%rbp), %rdi
callq 0xdb30
nop
// File: demon386[P]git-store/./boost/program_options/detail/parsers.hpp
// Function: std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> boost::program_options::collect_unrecognized<char>(std::vector<boost::program_options::basic_option<char>, std::allocator<boost::program_options::basic_option<char>>> const&, boost::program_options::collect_unrecognized_mode)
std::vector< std::basic_string<charT> > 
    collect_unrecognized(const std::vector< basic_option<charT> >& options,
                         enum collect_unrecognized_mode mode)
    {
        std::vector< std::basic_string<charT> >  result;
        for(unsigned i = 0; i < options.size(); ++i)
        {
            if (options[i].unregistered ||
                (mode == include_positional && options[i].position_key != -1))
            {
                copy(options[i].original_tokens.begin(),
                     options[i].original_tokens.end(),
                     back_inserter(result));
            }
        }
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x11cf0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12600
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x57762
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x2fbb0
testb $0x1, 0x58(%rax)
jne 0x576c7
cmpl $0x0, -0x14(%rbp)
jne 0x57752
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x2fbb0
cmpl $-0x1, 0x20(%rax)
je 0x57752
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x2fbb0
movq %rax, %rdi
addq $0x40, %rdi
callq 0x15e00
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x2fbb0
movq %rax, %rdi
addq $0x40, %rdi
callq 0x15e30
movq -0x60(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x5cf00
movq %rax, -0x70(%rbp)
jmp 0x57712
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x5ce90
movq %rax, -0x78(%rbp)
jmp 0x57731
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x57752
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x11db0
jmp 0x57782
jmp 0x57754
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x57671
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x57775
movq -0x60(%rbp), %rdi
callq 0x11db0
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xdb30
nopl (%rax,%rax)
// File: demon386[P]git-store/./boost/any.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> boost::any_cast<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(boost::any&)
ValueType any_cast(any & operand)
    {
        typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref;


        nonref * result = any_cast<nonref>(&operand);
        if(!result)
            boost::throw_exception(bad_any_cast());

        // Attempt to avoid construction of a temporary object in cases when 
        // `ValueType` is not a reference. Example:
        // `static_cast<std::string>(*result);` 
        // which is equal to `std::string(*result);`
        typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
            boost::is_reference<ValueType>,
            ValueType,
            BOOST_DEDUCED_TYPENAME boost::add_reference<ValueType>::type
        >::type ref_type;

        return static_cast<ref_type>(*result);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5a6b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5b716
movq $0x0, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x5ba80
movq -0x48(%rbp), %rdi
callq 0x5b9d0
jmp 0x5b6ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5bac0
jmp 0x5b72d
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd230
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./boost/program_options/detail/convert.hpp
// Function: std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> boost::program_options::to_internal<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
std::vector<std::string> to_internal(const std::vector<T>& s)
        {
            std::vector<std::string> result;
            for (unsigned i = 0; i < s.size(); ++i)
                result.push_back(to_internal(s[i]));            
            return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x11cf0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x124d0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x5c9db
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x34f30
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x21dd0
jmp 0x5c993
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3c780
jmp 0x5c9a2
leaq -0x38(%rbp), %rdi
callq 0xdca8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5c95b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5c9f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xdca8
jmp 0x5c9f8
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x5c9ee
movq -0x58(%rbp), %rdi
callq 0x11db0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x11db0
movq -0x40(%rbp), %rdi
callq 0xdb30
nopw (%rax,%rax)
// File: demon386[P]git-store/./boost/program_options/detail/parsers.hpp
// Function: std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> boost::program_options::detail::make_vector<char, char const* const*>(char const* const*, char const* const*)
std::vector<std::basic_string<charT> > 
        make_vector(Iterator i, Iterator e)
        {
            std::vector<std::basic_string<charT> > result;
            // Some compilers don't have templated constructor for 
            // vector, so we can't create vector from (argv+1, argv+argc) range
            for(; i != e; ++i)
                result.push_back(*i);
            return result;            
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x11cf0
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x5cada
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xdb50
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0xd8b0
jmp 0x5ca74
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3c780
jmp 0x5ca83
leaq -0x40(%rbp), %rdi
callq 0xdca8
leaq -0x41(%rbp), %rdi
callq 0xd6b0
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x5ca3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x5cac6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xdca8
leaq -0x41(%rbp), %rdi
callq 0xd6b0
movq -0x68(%rbp), %rdi
callq 0x11db0
jmp 0x5cafa
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x5caed
movq -0x68(%rbp), %rdi
callq 0x11db0
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_11.cc
// Function: main
int main(int argc, char const *argv[])
{
	shared_ptr<int> p(new int(42));

	cout << p.use_count() << endl;
	process(shared_ptr<int>(p.get()));
	cout << p.use_count() << endl;


	// cout << *p << endl; //undefined,  the memory to which p points was freed

	// why execute p.reset() won't corrupt.
	// p.reset(); // double freed or corruption was generated.

	// delete p.get(); // double freed or corruption was generated.

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x4, %edi
callq 0x1070
movq %rax, %rsi
movl $0x2a, (%rsi)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x13c0
movq -0x50(%rbp), %rdi
callq 0x13a0
movq %rax, %rsi
movq 0x2cff(%rip), %rdi      # 0x3fd8
callq 0x10e0
movq %rax, -0x48(%rbp)
jmp 0x12e4
movq -0x48(%rbp), %rdi
movq 0x2cd1(%rip), %rsi      # 0x3fc0
callq 0x1090
jmp 0x12f6
leaq -0x20(%rbp), %rdi
callq 0x13f0
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x13c0
jmp 0x130d
leaq -0x40(%rbp), %rdi
callq 0x1230
jmp 0x1318
leaq -0x40(%rbp), %rdi
callq 0x1410
leaq -0x20(%rbp), %rdi
callq 0x13a0
movq %rax, %rsi
movq 0x2ca4(%rip), %rdi      # 0x3fd8
callq 0x10e0
movq %rax, -0x58(%rbp)
jmp 0x133f
movq -0x58(%rbp), %rdi
movq 0x2c76(%rip), %rsi      # 0x3fc0
callq 0x1090
jmp 0x1351
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1410
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x138d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1410
leaq -0x20(%rbp), %rdi
callq 0x1410
movq -0x28(%rbp), %rdi
callq 0x10d0
nop