LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: demon386[P]git-store/./boost/program_options/value_semantic.hpp
// Function: boost::program_options::typed_value<bool, char>::min_tokens() const
unsigned min_tokens() const
        {
            if (m_zero_tokens || !m_implicit_value.empty()) {
                return 0;
            } else {
                return 1;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x8b(%rax)
jne 0x4044e
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
callq 0x3c7b0
testb $0x1, %al
jne 0x40457
movl $0x0, -0x4(%rbp)
jmp 0x4045e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: demon386[P]git-store/./boost/program_options/value_semantic.hpp
// Function: boost::program_options::typed_value<bool, char>::max_tokens() const
unsigned max_tokens() const {
            if (m_multitoken) {
                return std::numeric_limits<unsigned>::max BOOST_PREVENT_MACRO_SUBSTITUTION();
            } else if (m_zero_tokens) {
                return 0;
            } else {
                return 1;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x8a(%rax)
je 0x40497
callq 0x34f20
movl %eax, -0x4(%rbp)
jmp 0x404b4
movq -0x18(%rbp), %rax
testb $0x1, 0x8b(%rax)
je 0x404ad
movl $0x0, -0x4(%rbp)
jmp 0x404b4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: demon386[P]git-store/./boost/program_options/value_semantic.hpp
// Function: boost::program_options::typed_value<bool, char>::apply_default(boost::any&) const
virtual bool apply_default(boost::any& value_store) const
        {
            if (m_default_value.empty()) {
                return false;
            } else {
                value_store = m_default_value;
                return true;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x38, %rdi
callq 0x3c7b0
testb $0x1, %al
jne 0x40557
jmp 0x4055d
movb $0x0, -0x1(%rbp)
jmp 0x40572
movq -0x20(%rbp), %rsi
addq $0x38, %rsi
movq -0x18(%rbp), %rdi
callq 0x40860
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: demon386[P]git-store/./boost/program_options/detail/value_semantic.hpp
// Function: boost::program_options::typed_value<bool, char>::notify(boost::any const&) const
void 
    typed_value<T, charT>::notify(const boost::any& value_store) const
    {
        const T* value = boost::any_cast<T>(&value_store);
        if (m_store_to) {
            *m_store_to = *value;
        }
        if (m_notifier) {
            m_notifier(*value);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40900
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x405c6
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb (%rcx), %cl
movq 0x10(%rax), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq -0x20(%rbp), %rdi
addq $0x90, %rdi
callq 0x40920
cmpq $0x0, %rax
je 0x405f0
movq -0x20(%rbp), %rdi
addq $0x90, %rdi
movq -0x18(%rbp), %rsi
callq 0x40950
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./boost/type_index/stl_type_index.hpp
// Function: boost::typeindex::stl_type_index::equal(boost::typeindex::stl_type_index const&) const
inline bool stl_type_index::equal(const stl_type_index& rhs) const BOOST_NOEXCEPT {
#ifdef BOOST_CLASSINFO_COMPARE_BY_NAMES
    return raw_name() == rhs.raw_name() || !std::strcmp(raw_name(), rhs.raw_name());
#else
    return *data_ == *rhs.data_;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x40bd0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40bd0
movq -0x20(%rbp), %rcx
movq %rax, %rdx
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x11(%rbp)
je 0x40bb8
movq -0x28(%rbp), %rdi
callq 0x40bd0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40bd0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xd900
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: demon386[P]git-store/./boost/lexical_cast.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> boost::lexical_cast<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool>(bool const&)
inline Target lexical_cast(const Source &arg)
    {
        boost::value_initialized<Target> result;

        if (!boost::conversion::detail::try_lexical_convert(arg, get(result))) {
            boost::conversion::detail::throw_bad_cast<Source, Target>();
        }

        return get(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)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x41040
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x41090
movq %rax, -0x48(%rbp)
jmp 0x40e52
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x41060
movb %al, -0x69(%rbp)
jmp 0x40e64
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x40e8d
jmp 0x40e6d
callq 0x410b0
jmp 0x40e74
jmp 0x40e8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x41100
jmp 0x40ec1
leaq -0x30(%rbp), %rdi
callq 0x41090
movq %rax, -0x78(%rbp)
jmp 0x40e9c
movq -0x78(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0xd230
jmp 0x40eab
leaq -0x30(%rbp), %rdi
callq 0x41100
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xdb30
nopw (%rax,%rax)
// File: demon386[P]git-store/./boost/lexical_cast/detail/converter_lexical.hpp
// Function: boost::detail::lexical_converter_impl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool>::try_convert(bool const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
static inline bool try_convert(const Source& arg, Target& result) {
                i_interpreter_type i_interpreter;

                // Disabling ADL, by directly specifying operators.
                if (!(i_interpreter.operator <<(arg)))
                    return false;

                o_interpreter_type out(i_interpreter.cbegin(), i_interpreter.cend());

                // Disabling ADL, by directly specifying operators.
                if(!(out.operator >>(result)))
                    return false;

                return true;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x41210
movq -0x10(%rbp), %rax
movb (%rax), %al
leaq -0x30(%rbp), %rdi
andb $0x1, %al
movzbl %al, %esi
callq 0x41240
testb $0x1, %al
jne 0x411b7
movb $0x0, -0x1(%rbp)
jmp 0x411f8
leaq -0x30(%rbp), %rdi
callq 0x412b0
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x412d0
movq -0x48(%rbp), %rsi
movq %rax, %rdx
leaq -0x40(%rbp), %rdi
callq 0x412f0
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x41320
testb $0x1, %al
jne 0x411f4
movb $0x0, -0x1(%rbp)
jmp 0x411f8
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: demon386[P]git-store/./boost/lexical_cast/detail/converter_lexical_streams.hpp
// Function: boost::detail::lexical_istream_limited_src<char, std::char_traits<char>, false, 2ul>::operator<<(bool)
bool operator<<(bool value) BOOST_NOEXCEPT {
                CharT const czero = lcast_char_constants<CharT>::zero;
                Traits::assign(buffer[0], Traits::to_char_type(czero + value));
                finish = start + 1;
                return true;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x30, -0xa(%rbp)
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addl $0x30, %eax
movl %eax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x41370
movq -0x20(%rbp), %rdi
movb %al, -0xb(%rbp)
leaq -0xb(%rbp), %rsi
callq 0x41350
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: demon386[P]git-store/./libs/program_options/src/variables_map.cpp
// Function: boost::program_options::abstract_variables_map::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const variable_value&
    abstract_variables_map::operator[](const std::string& name) const
    {
        const variable_value& v = get(name);
        if (v.empty() && m_next)
            return (*m_next)[name];
        else if (v.defaulted() && m_next) {
            const variable_value& v2 = (*m_next)[name];
            if (!v2.empty() && !v2.defaulted())
                return v2;
            else return v;
        } else {
            return v;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x44e40
testb $0x1, %al
jne 0x44835
jmp 0x44857
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x44857
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x44800
movq %rax, -0x8(%rbp)
jmp 0x448bc
movq -0x20(%rbp), %rdi
callq 0x44c20
testb $0x1, %al
jne 0x44866
jmp 0x448b4
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x448b4
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x44800
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x44e40
testb $0x1, %al
jne 0x448aa
movq -0x28(%rbp), %rdi
callq 0x44c20
testb $0x1, %al
jne 0x448aa
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x448bc
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x448bc
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/program_options/src/variables_map.cpp
// Function: boost::program_options::variables_map::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const variable_value&
    variables_map::get(const std::string& name) const
    {
        static variable_value empty;
        const_iterator i = this->find(name);
        if (i == this->end())
            return empty;
        else
            return i->second;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpb $0x0, 0x49d71(%rip)     # 0x8e780
jne 0x44a56
leaq 0x49d68(%rip), %rdi     # 0x8e780
callq 0xdb80
cmpl $0x0, %eax
je 0x44a56
leaq 0x49d37(%rip), %rdi     # 0x8e760
callq 0x44c40
jmp 0x44a30
leaq 0x289(%rip), %rdi       # 0x44cc0
leaq 0x49d22(%rip), %rsi     # 0x8e760
leaq 0x49c13(%rip), %rdx     # 0x8e658
callq 0xd560
leaq 0x49d2f(%rip), %rdi     # 0x8e780
callq 0xd3e0
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x44ee0
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x10, %rdi
callq 0x44f40
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x44f10
testb $0x1, %al
jne 0x44a8f
jmp 0x44ab6
leaq 0x49cca(%rip), %rax     # 0x8e760
movq %rax, -0x8(%rbp)
jmp 0x44ac7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq 0x49cd1(%rip), %rdi     # 0x8e780
callq 0xd3d0
jmp 0x44ad1
leaq -0x30(%rbp), %rdi
callq 0x44f70
addq $0x20, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xdb30
nopw (%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/codecvt_error_category.cpp
// Function: (anonymous namespace)::codecvt_error_cat::message[abi:cxx11](int) const
std::string codecvt_error_cat::message(int ev) const
  {
    std::string str;
    switch (ev)
    {
    case std::codecvt_base::ok:
      str = "ok";
      break;
    case std::codecvt_base::partial:
      str = "partial";
      break;
    case std::codecvt_base::error:
      str = "error";
      break;
    case std::codecvt_base::noconv:
      str = "noconv";
      break;
    default:
      str = "unknown error";
    }
    return str;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0xd8f0
movl -0x14(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x3, %rax
ja 0x473bf
movq -0x30(%rbp), %rax
leaq 0x1b6ad(%rip), %rcx     # 0x629fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x40(%rbp), %rdi
leaq 0x1b719(%rip), %rsi     # 0x62a7c
callq 0xd8a0
jmp 0x4736a
jmp 0x473d3
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xdca8
jmp 0x473f0
movq -0x40(%rbp), %rdi
leaq 0x1b6f1(%rip), %rsi     # 0x62a7f
callq 0xd8a0
jmp 0x47395
jmp 0x473d3
movq -0x40(%rbp), %rdi
leaq 0x1bda7(%rip), %rsi     # 0x63149
callq 0xd8a0
jmp 0x473a9
jmp 0x473d3
movq -0x40(%rbp), %rdi
leaq 0x1b6d1(%rip), %rsi     # 0x62a87
callq 0xd8a0
jmp 0x473bd
jmp 0x473d3
movq -0x40(%rbp), %rdi
leaq 0x1ac17(%rip), %rsi     # 0x61fe1
callq 0xd8a0
jmp 0x473d1
jmp 0x473d3
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x473e6
movq -0x40(%rbp), %rdi
callq 0xdca8
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xdb30
nopl (%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::copy_directory(boost::filesystem::path const&, boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  void copy_directory(const path& from, const path& to, system::error_code* ec)
  {
#   ifdef BOOST_POSIX_API
    struct stat from_stat;
#   endif
    error(!BOOST_COPY_DIRECTORY(from.c_str(), to.c_str()) ? BOOST_ERRNO : 0,
      from, to, ec, "boost::filesystem::copy_directory");
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4dc70
movq %rax, %rdi
leaq -0xa8(%rbp), %rsi
callq 0xdae0
cmpl $0x0, %eax
jne 0x48cc0
movq -0x10(%rbp), %rdi
callq 0x4dc70
movq %rax, %rdi
movl -0x90(%rbp), %esi
callq 0xd270
cmpl $0x0, %eax
je 0x48ccf
callq 0xd070
movl (%rax), %eax
movl %eax, -0xe0(%rbp)
jmp 0x48cd9
xorl %eax, %eax
movl %eax, -0xe0(%rbp)
jmp 0x48cd9
movl -0xe0(%rbp), %eax
movl %eax, -0x104(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0xc9(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0xdb50
movq -0xe8(%rbp), %rdx
leaq 0x19e99(%rip), %rsi     # 0x62bc0
leaq -0xc8(%rbp), %rdi
callq 0xd8b0
jmp 0x48d35
movq -0xf0(%rbp), %rcx
movq -0xf8(%rbp), %rdx
movq -0x100(%rbp), %rsi
movl -0x104(%rbp), %edi
leaq -0xc8(%rbp), %r8
callq 0x48dd0
jmp 0x48d5e
leaq -0xc8(%rbp), %rdi
callq 0xdca8
leaq -0xc9(%rbp), %rdi
callq 0xd6b0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x48db1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0xdca8
leaq -0xc9(%rbp), %rdi
callq 0xd6b0
movq -0xd8(%rbp), %rdi
callq 0xdb30
nopl (%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: (anonymous namespace)::error(int, boost::filesystem::path const&, boost::filesystem::path const&, boost::system::error_code*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool error(err_t error_num, const path& p1, const path& p2, error_code* ec,
    const string& message)
  {
    if (!error_num)
    {
      if (ec != 0) ec->clear();
    }
    else  
    { //  error
      if (ec == 0)
        BOOST_FILESYSTEM_THROW(filesystem_error(message,
          p1, p2, error_code(error_num, system_category())));
      else
        ec->assign(error_num, system_category());
    }
    return error_num != 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x48e06
cmpq $0x0, -0x20(%rbp)
je 0x48e01
movq -0x20(%rbp), %rdi
callq 0x4d9e0
jmp 0x48ea5
cmpq $0x0, -0x20(%rbp)
jne 0x48e81
movl $0x50, %edi
callq 0xd2b0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x5c(%rbp)
callq 0x53ec0
movl -0x5c(%rbp), %esi
movq %rax, %rdx
leaq -0x38(%rbp), %rdi
callq 0x4d680
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rdi
movl -0x38(%rbp), %r8d
movq -0x30(%rbp), %r9
callq 0x4db40
movq -0x40(%rbp), %rdi
leaq 0x446e3(%rip), %rsi     # 0x8d558
leaq 0x4944(%rip), %rdx      # 0x4d7c0
callq 0xdad0
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x60(%rbp)
callq 0x53ec0
movq -0x68(%rbp), %rdi
movl -0x60(%rbp), %esi
movq %rax, %rdx
callq 0x4d800
jmp 0x48ea5
cmpl $0x0, -0x4(%rbp)
setne %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::copy_symlink(boost::filesystem::path const&, boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  void copy_symlink(const path& existing_symlink, const path& new_symlink,
    system::error_code* ec)
  {
# if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0600
    error(BOOST_ERROR_NOT_SUPPORTED, new_symlink, existing_symlink, ec,
      "boost::filesystem::copy_symlink");

# else  // modern Windows or BOOST_POSIX_API 
    path p(read_symlink(existing_symlink, ec));
    if (ec != 0 && *ec) return;
    create_symlink(p, new_symlink, ec);

# endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x48770
cmpq $0x0, -0x18(%rbp)
je 0x494d4
movq -0x18(%rbp), %rdi
callq 0x4d830
cmpq $0x0, %rax
je 0x494d4
movl $0x1, -0x3c(%rbp)
jmp 0x494ee
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x49520
jmp 0x494e7
movl $0x0, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4d550
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4d550
movq -0x48(%rbp), %rdi
callq 0xdb30
nopl (%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::create_symlink(boost::filesystem::path const&, boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  void create_symlink(const path& to, const path& from, error_code* ec)
  {
#   if defined(BOOST_WINDOWS_API) && _WIN32_WINNT < 0x0600  // SDK earlier than Vista and Server 2008
    error(BOOST_ERROR_NOT_SUPPORTED, to, from, ec,
      "boost::filesystem::create_directory_symlink");
#   else

#     if defined(BOOST_WINDOWS_API) && _WIN32_WINNT >= 0x0600
        // see if actually supported by Windows runtime dll
        if (error(!create_symbolic_link_api ? BOOST_ERROR_NOT_SUPPORTED : 0, to, from, ec,
            "boost::filesystem::create_symlink"))
          return;
#     endif

    error(!BOOST_CREATE_SYMBOLIC_LINK(from.c_str(), to.c_str(), 0) ? BOOST_ERRNO : 0,
      to, from, ec, "boost::filesystem::create_symlink");
#   endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4dc70
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4dc70
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xd090
cmpl $0x0, %eax
je 0x4956a
callq 0xd070
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
jmp 0x49571
xorl %eax, %eax
movl %eax, -0x5c(%rbp)
jmp 0x49571
movl -0x5c(%rbp), %eax
movl %eax, -0x84(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xdb50
movq -0x68(%rbp), %rdx
leaq 0x197a3(%rip), %rsi     # 0x62d4d
leaq -0x38(%rbp), %rdi
callq 0xd8b0
jmp 0x495b5
movq -0x70(%rbp), %rcx
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rsi
movl -0x84(%rbp), %edi
leaq -0x38(%rbp), %r8
callq 0x48dd0
jmp 0x495d2
leaq -0x38(%rbp), %rdi
callq 0xdca8
leaq -0x39(%rbp), %rdi
callq 0xd6b0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x49610
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xdca8
leaq -0x39(%rbp), %rdi
callq 0xd6b0
movq -0x48(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::create_directory(boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  bool create_directory(const path& p, error_code* ec)
  {
    if (BOOST_CREATE_DIRECTORY(p.c_str()))
    {
      if (ec != 0)
        ec->clear();
      return true;
    }

    //  attempt to create directory failed
    int errval(BOOST_ERRNO);  // save reason for failure
    error_code dummy;
    if (errval == BOOST_ERROR_ALREADY_EXISTS && is_directory(p, dummy))
    {
      if (ec != 0)
        ec->clear();
      return false;
    }

    //  attempt to create directory failed && it doesn't already exist
    if (ec == 0)
      BOOST_FILESYSTEM_THROW(filesystem_error("boost::filesystem::create_directory",
        p, error_code(errval, system_category())));
    else
      ec->assign(errval, system_category());
    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4dc70
movq %rax, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0xd270
cmpl $0x0, %eax
jne 0x49957
cmpq $0x0, -0x18(%rbp)
je 0x4994e
movq -0x18(%rbp), %rdi
callq 0x4d9e0
movb $0x1, -0x1(%rbp)
jmp 0x49ac5
callq 0xd070
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4d4a0
cmpl $0x11, -0x1c(%rbp)
jne 0x4999c
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4dcc0
testb $0x1, %al
jne 0x49983
jmp 0x4999c
cmpq $0x0, -0x18(%rbp)
je 0x49993
movq -0x18(%rbp), %rdi
callq 0x4d9e0
movb $0x0, -0x1(%rbp)
jmp 0x49ac5
cmpq $0x0, -0x18(%rbp)
jne 0x49a93
movb $0x1, -0x79(%rbp)
movl $0x50, %edi
callq 0xd2b0
movq %rax, -0x90(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xdb50
movq -0x88(%rbp), %rdx
leaq 0x192ff(%rip), %rsi     # 0x62cd9
leaq -0x50(%rbp), %rdi
callq 0xd8b0
jmp 0x499e5
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x9c(%rbp)
callq 0x53ec0
movl -0x9c(%rbp), %esi
movq %rax, %rdx
leaq -0x78(%rbp), %rdi
callq 0x4d680
movq -0x98(%rbp), %rdx
movq -0x90(%rbp), %rdi
movl -0x78(%rbp), %ecx
movq -0x70(%rbp), %r8
leaq -0x50(%rbp), %rsi
callq 0x4d6b0
movq -0x90(%rbp), %rdi
movb $0x0, -0x79(%rbp)
leaq 0x43b18(%rip), %rsi     # 0x8d558
leaq 0x3d79(%rip), %rdx      # 0x4d7c0
callq 0xdad0
jmp 0x49adc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x49a74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xdca8
leaq -0x51(%rbp), %rdi
callq 0xd6b0
testb $0x1, -0x79(%rbp)
jne 0x49a85
jmp 0x49a91
movq -0x90(%rbp), %rdi
callq 0xd460
jmp 0x49ad3
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xa0(%rbp)
callq 0x53ec0
movq -0xa8(%rbp), %rdi
movl -0xa0(%rbp), %esi
movq %rax, %rdx
callq 0x4d800
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xdb30
nopl (%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::create_directory_symlink(boost::filesystem::path const&, boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  void create_directory_symlink(const path& to, const path& from,
                                 system::error_code* ec)
  {
#   if defined(BOOST_WINDOWS_API) && _WIN32_WINNT < 0x0600  // SDK earlier than Vista and Server 2008

    error(BOOST_ERROR_NOT_SUPPORTED, to, from, ec,
      "boost::filesystem::create_directory_symlink");
#   else

#     if defined(BOOST_WINDOWS_API) && _WIN32_WINNT >= 0x0600
        // see if actually supported by Windows runtime dll
        if (error(!create_symbolic_link_api ? BOOST_ERROR_NOT_SUPPORTED : 0, to, from, ec,
            "boost::filesystem::create_directory_symlink"))
          return;
#     endif

    error(!BOOST_CREATE_SYMBOLIC_LINK(from.c_str(), to.c_str(),
      SYMBOLIC_LINK_FLAG_DIRECTORY) ? BOOST_ERRNO : 0,
      to, from, ec, "boost::filesystem::create_directory_symlink");
#   endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4dc70
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4dc70
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xd090
cmpl $0x0, %eax
je 0x49b2a
callq 0xd070
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
jmp 0x49b31
xorl %eax, %eax
movl %eax, -0x5c(%rbp)
jmp 0x49b31
movl -0x5c(%rbp), %eax
movl %eax, -0x84(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xdb50
movq -0x68(%rbp), %rdx
leaq 0x19193(%rip), %rsi     # 0x62cfd
leaq -0x38(%rbp), %rdi
callq 0xd8b0
jmp 0x49b75
movq -0x70(%rbp), %rcx
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rsi
movl -0x84(%rbp), %edi
leaq -0x38(%rbp), %r8
callq 0x48dd0
jmp 0x49b92
leaq -0x38(%rbp), %rdi
callq 0xdca8
leaq -0x39(%rbp), %rdi
callq 0xd6b0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x49bd0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xdca8
leaq -0x39(%rbp), %rdi
callq 0xd6b0
movq -0x48(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::create_hard_link(boost::filesystem::path const&, boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  void create_hard_link(const path& to, const path& from, error_code* ec)
  {

#   if defined(BOOST_WINDOWS_API) && _WIN32_WINNT < 0x0500  // SDK earlier than Win 2K

    error(BOOST_ERROR_NOT_SUPPORTED, to, from, ec,
      "boost::filesystem::create_hard_link");
#   else

#     if defined(BOOST_WINDOWS_API) && _WIN32_WINNT >= 0x0500
        // see if actually supported by Windows runtime dll
        if (error(!create_hard_link_api ? BOOST_ERROR_NOT_SUPPORTED : 0, to, from, ec,
            "boost::filesystem::create_hard_link"))
          return;
#     endif

    error(!BOOST_CREATE_HARD_LINK(from.c_str(), to.c_str()) ? BOOST_ERRNO : 0, to, from, ec,
      "boost::filesystem::create_hard_link");
#   endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4dc70
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4dc70
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xd160
cmpl $0x0, %eax
je 0x49c3a
callq 0xd070
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
jmp 0x49c41
xorl %eax, %eax
movl %eax, -0x5c(%rbp)
jmp 0x49c41
movl -0x5c(%rbp), %eax
movl %eax, -0x84(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xdb50
movq -0x68(%rbp), %rdx
leaq 0x190af(%rip), %rsi     # 0x62d29
leaq -0x38(%rbp), %rdi
callq 0xd8b0
jmp 0x49c85
movq -0x70(%rbp), %rcx
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rsi
movl -0x84(%rbp), %edi
leaq -0x38(%rbp), %r8
callq 0x48dd0
jmp 0x49ca2
leaq -0x38(%rbp), %rdi
callq 0xdca8
leaq -0x39(%rbp), %rdi
callq 0xd6b0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x49ce0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xdca8
leaq -0x39(%rbp), %rdi
callq 0xd6b0
movq -0x48(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: (anonymous namespace)::error(int, boost::system::error_code*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool error(err_t error_num, error_code* ec, const string& message)
  {
    if (!error_num)
    {
      if (ec != 0) ec->clear();
    }
    else  
    { //  error
      if (ec == 0)
        BOOST_FILESYSTEM_THROW(filesystem_error(message,
          error_code(error_num, system_category())));
      else
        ec->assign(error_num, system_category());
    }
    return error_num != 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x49f2e
cmpq $0x0, -0x10(%rbp)
je 0x49f29
movq -0x10(%rbp), %rdi
callq 0x4d9e0
jmp 0x49fb4
cmpq $0x0, -0x10(%rbp)
jne 0x49f90
movl $0x50, %edi
callq 0xd2b0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x53ec0
movl -0x3c(%rbp), %esi
movq %rax, %rdx
leaq -0x28(%rbp), %rdi
callq 0x4d680
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
movl -0x28(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x4ebf0
movq -0x30(%rbp), %rdi
leaq 0x435d4(%rip), %rsi     # 0x8d558
leaq 0x3835(%rip), %rdx      # 0x4d7c0
callq 0xdad0
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x40(%rbp)
callq 0x53ec0
movq -0x48(%rbp), %rdi
movl -0x40(%rbp), %esi
movq %rax, %rdx
callq 0x4d800
jmp 0x49fb4
cmpl $0x0, -0x4(%rbp)
setne %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: (anonymous namespace)::error(int, boost::filesystem::path const&, boost::system::error_code*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool error(err_t error_num, const path& p, error_code* ec, const string& message)
  {
    if (!error_num)
    {
      if (ec != 0) ec->clear();
    }
    else  
    { //  error
      if (ec == 0)
        BOOST_FILESYSTEM_THROW(filesystem_error(message,
          p, error_code(error_num, system_category())));
      else
        ec->assign(error_num, system_category());
    }
    return error_num != 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x4a0e2
cmpq $0x0, -0x18(%rbp)
je 0x4a0dd
movq -0x18(%rbp), %rdi
callq 0x4d9e0
jmp 0x4a174
cmpq $0x0, -0x18(%rbp)
jne 0x4a150
movl $0x50, %edi
callq 0xd2b0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x4c(%rbp)
callq 0x53ec0
movl -0x4c(%rbp), %esi
movq %rax, %rdx
leaq -0x30(%rbp), %rdi
callq 0x4d680
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rdi
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %r8
callq 0x4d6b0
movq -0x38(%rbp), %rdi
leaq 0x43414(%rip), %rsi     # 0x8d558
leaq 0x3675(%rip), %rdx      # 0x4d7c0
callq 0xdad0
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x50(%rbp)
callq 0x53ec0
movq -0x58(%rbp), %rdi
movl -0x50(%rbp), %esi
movq %rax, %rdx
callq 0x4d800
jmp 0x4a174
cmpl $0x0, -0x4(%rbp)
setne %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::hard_link_count(boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  boost::uintmax_t hard_link_count(const path& p, system::error_code* ec)
  {
#   ifdef BOOST_POSIX_API

    struct stat path_stat;
    return error(::stat(p.c_str(), &path_stat)!= 0 ? BOOST_ERRNO : 0,
                  p, ec, "boost::filesystem::hard_link_count")
           ? 0
           : static_cast<boost::uintmax_t>(path_stat.st_nlink);

#   else // Windows

    // Link count info is only available through GetFileInformationByHandle
    BY_HANDLE_FILE_INFORMATION info;
    handle_wrapper h(
      create_file_handle(p.c_str(), 0,
          FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
          OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0));
    return
      !error(h.handle == INVALID_HANDLE_VALUE ? BOOST_ERRNO : 0,
              p, ec, "boost::filesystem::hard_link_count")
      && !error(::GetFileInformationByHandle(h.handle, &info)== 0 ? BOOST_ERRNO : 0,
                 p, ec, "boost::filesystem::hard_link_count")
           ? info.nNumberOfLinks
           : 0;
#   endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4dc70
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0xdae0
cmpl $0x0, %eax
je 0x4a61f
callq 0xd070
movl (%rax), %eax
movl %eax, -0xd8(%rbp)
jmp 0x4a629
xorl %eax, %eax
movl %eax, -0xd8(%rbp)
jmp 0x4a629
movl -0xd8(%rbp), %eax
movl %eax, -0xf4(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0xc1(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xdb50
movq -0xe0(%rbp), %rdx
leaq 0x1875e(%rip), %rsi     # 0x62dca
leaq -0xc0(%rbp), %rdi
callq 0xd8b0
jmp 0x4a67a
movq -0xe8(%rbp), %rdx
movq -0xf0(%rbp), %rsi
movl -0xf4(%rbp), %edi
leaq -0xc0(%rbp), %rcx
callq 0x4a0b0
movb %al, -0xf5(%rbp)
jmp 0x4a6a2
movb -0xf5(%rbp), %al
testb $0x1, %al
jne 0x4a6ae
jmp 0x4a6b9
xorl %eax, %eax
movq %rax, -0x100(%rbp)
jmp 0x4a6c7
movq -0x90(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x100(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0xdca8
leaq -0xc1(%rbp), %rdi
callq 0xd6b0
movq -0x108(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x4a72f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0xdca8
leaq -0xc1(%rbp), %rdi
callq 0xd6b0
movq -0xd0(%rbp), %rdi
callq 0xdb30
nopw (%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::initial_path(boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  path initial_path(error_code* ec)
  {
      static path init_path;
      if (init_path.empty())
        init_path = current_path(ec);
      else if (ec != 0) ec->clear();
      return init_path;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpb $0x0, 0x44066(%rip)     # 0x8e7d8
jne 0x4a7b9
leaq 0x4405d(%rip), %rdi     # 0x8e7d8
callq 0xdb80
cmpl $0x0, %eax
je 0x4a7b9
leaq 0x4402c(%rip), %rdi     # 0x8e7b8
callq 0x4d620
jmp 0x4a793
leaq 0x2db6(%rip), %rdi      # 0x4d550
leaq 0x44017(%rip), %rsi     # 0x8e7b8
leaq 0x43eb0(%rip), %rdx     # 0x8e658
callq 0xd560
leaq 0x44024(%rip), %rdi     # 0x8e7d8
callq 0xd3e0
leaq 0x43ff8(%rip), %rdi     # 0x8e7b8
callq 0x4d570
testb $0x1, %al
jne 0x4a7cb
jmp 0x4a82a
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x49d00
movq -0x58(%rbp), %rsi
leaq 0x43fd1(%rip), %rdi     # 0x8e7b8
callq 0x4d9b0
jmp 0x4a7ee
leaq -0x40(%rbp), %rdi
callq 0x4d550
jmp 0x4a83c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq 0x43fcc(%rip), %rdi     # 0x8e7d8
callq 0xd3d0
jmp 0x4a856
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4d550
jmp 0x4a856
cmpq $0x0, -0x10(%rbp)
je 0x4a83a
movq -0x10(%rbp), %rdi
callq 0x4d9e0
jmp 0x4a83c
movq -0x50(%rbp), %rdi
leaq 0x43f71(%rip), %rsi     # 0x8e7b8
callq 0x4d4f0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xdb30
nop
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::is_empty(boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  bool is_empty(const path& p, system::error_code* ec)
  {
#   ifdef BOOST_POSIX_API

    struct stat path_stat;
    if (error(::stat(p.c_str(), &path_stat)!= 0,
        p, ec, "boost::filesystem::is_empty"))
      return false;        
    return S_ISDIR(path_stat.st_mode)
      ? is_empty_directory(p)
      : path_stat.st_size == 0;
#   else

    WIN32_FILE_ATTRIBUTE_DATA fad;
    if (error(::GetFileAttributesExW(p.c_str(), ::GetFileExInfoStandard, &fad)== 0
      ? BOOST_ERRNO : 0, p, ec, "boost::filesystem::is_empty"))
        return false;

    if (ec != 0) ec->clear();
    return 
      (fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        ? is_empty_directory(p)
        : (!fad.nFileSizeHigh && !fad.nFileSizeLow);
#   endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4dc70
movq %rax, %rdi
leaq -0xa8(%rbp), %rsi
callq 0xdae0
testl %eax, %eax
setne %al
movzbl %al, %eax
movl %eax, -0xfc(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0xc9(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0xdb50
movq -0xe8(%rbp), %rdx
leaq 0x1851d(%rip), %rsi     # 0x62ded
leaq -0xc8(%rbp), %rdi
callq 0xd8b0
jmp 0x4a8de
movq -0xf0(%rbp), %rdx
movq -0xf8(%rbp), %rsi
movl -0xfc(%rbp), %edi
leaq -0xc8(%rbp), %rcx
callq 0x4a0b0
movb %al, -0xfd(%rbp)
jmp 0x4a906
leaq -0xc8(%rbp), %rdi
callq 0xdca8
leaq -0xc9(%rbp), %rdi
callq 0xd6b0
movb -0xfd(%rbp), %al
testb $0x1, %al
jne 0x4a92a
jmp 0x4a970
movb $0x0, -0x1(%rbp)
jmp 0x4a9ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4a962
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0xdca8
leaq -0xc9(%rbp), %rdi
callq 0xd6b0
jmp 0x4a9ba
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x4a993
movq -0x10(%rbp), %rdi
callq 0x4a9d0
movb %al, -0xfe(%rbp)
jmp 0x4a9a1
cmpq $0x0, -0x78(%rbp)
sete %al
movb %al, -0xfe(%rbp)
movb -0xfe(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::last_write_time(boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  std::time_t last_write_time(const path& p, system::error_code* ec)
  {
#   ifdef BOOST_POSIX_API

    struct stat path_stat;
    if (error(::stat(p.c_str(), &path_stat)!= 0 ? BOOST_ERRNO : 0,
      p, ec, "boost::filesystem::last_write_time"))
        return std::time_t(-1);
    return path_stat.st_mtime;

#   else

    handle_wrapper hw(
      create_file_handle(p.c_str(), 0,
        FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
        OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0));

    if (error(hw.handle == INVALID_HANDLE_VALUE ? BOOST_ERRNO : 0,
      p, ec, "boost::filesystem::last_write_time"))
        return std::time_t(-1);

    FILETIME lwt;

    if (error(::GetFileTime(hw.handle, 0, 0, &lwt)== 0 ? BOOST_ERRNO : 0,
      p, ec, "boost::filesystem::last_write_time"))
        return std::time_t(-1);

    return to_time_t(lwt);
#   endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4dc70
movq %rax, %rdi
leaq -0xa8(%rbp), %rsi
callq 0xdae0
cmpl $0x0, %eax
je 0x4aa7f
callq 0xd070
movl (%rax), %eax
movl %eax, -0xe0(%rbp)
jmp 0x4aa89
xorl %eax, %eax
movl %eax, -0xe0(%rbp)
jmp 0x4aa89
movl -0xe0(%rbp), %eax
movl %eax, -0xfc(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0xc9(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0xdb50
movq -0xe8(%rbp), %rdx
leaq 0x1833d(%rip), %rsi     # 0x62e09
leaq -0xc8(%rbp), %rdi
callq 0xd8b0
jmp 0x4aada
movq -0xf0(%rbp), %rdx
movq -0xf8(%rbp), %rsi
movl -0xfc(%rbp), %edi
leaq -0xc8(%rbp), %rcx
callq 0x4a0b0
movb %al, -0xfd(%rbp)
jmp 0x4ab02
leaq -0xc8(%rbp), %rdi
callq 0xdca8
leaq -0xc9(%rbp), %rdi
callq 0xd6b0
movb -0xfd(%rbp), %al
testb $0x1, %al
jne 0x4ab26
jmp 0x4ab70
movq $-0x1, -0x8(%rbp)
jmp 0x4ab78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4ab62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0xdca8
leaq -0xc9(%rbp), %rdi
callq 0xd6b0
jmp 0x4ab85
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::remove(boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  bool remove(const path& p, error_code* ec)
  {
    error_code tmp_ec;
    file_type type = query_file_type(p, &tmp_ec);
    if (error(type == status_error ? tmp_ec.value() : 0, p, ec,
        "boost::filesystem::remove"))
      return false;

    // Since POSIX remove() is specified to work with either files or directories, in a
    // perfect world it could just be called. But some important real-world operating
    // systems (Windows, Mac OS X, for example) don't implement the POSIX spec. So
    // remove_file_or_directory() is always called to kep it simple.
    return remove_file_or_directory(p, type, ec);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4d4a0
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4b2e0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x4b200
leaq -0x28(%rbp), %rdi
callq 0x475c0
movl %eax, -0x68(%rbp)
jmp 0x4b207
xorl %eax, %eax
movl %eax, -0x68(%rbp)
jmp 0x4b207
movl -0x68(%rbp), %eax
movl %eax, -0x84(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xdb50
movq -0x70(%rbp), %rdx
leaq 0x17d24(%rip), %rsi     # 0x62f5c
leaq -0x50(%rbp), %rdi
callq 0xd8b0
jmp 0x4b243
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rsi
movl -0x84(%rbp), %edi
leaq -0x50(%rbp), %rcx
callq 0x4a0b0
movb %al, -0x85(%rbp)
jmp 0x4b262
leaq -0x50(%rbp), %rdi
callq 0xdca8
leaq -0x51(%rbp), %rdi
callq 0xd6b0
movb -0x85(%rbp), %al
testb $0x1, %al
jne 0x4b280
jmp 0x4b2b4
movb $0x0, -0x1(%rbp)
jmp 0x4b2c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x4b2a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xdca8
leaq -0x51(%rbp), %rdi
callq 0xd6b0
jmp 0x4b2d7
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x4b310
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xdb30
// File: demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::remove_all(boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  boost::uintmax_t remove_all(const path& p, error_code* ec)
  {
    error_code tmp_ec;
    file_type type = query_file_type(p, &tmp_ec);
    if (error(type == status_error ? tmp_ec.value() : 0, p, ec,
      "boost::filesystem::remove_all"))
      return 0;

    return (type != status_error && type != file_not_found) // exists
      ? remove_all_aux(p, type, ec)
      : 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4d4a0
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4b2e0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x4b580
leaq -0x28(%rbp), %rdi
callq 0x475c0
movl %eax, -0x68(%rbp)
jmp 0x4b587
xorl %eax, %eax
movl %eax, -0x68(%rbp)
jmp 0x4b587
movl -0x68(%rbp), %eax
movl %eax, -0x84(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xdb50
movq -0x70(%rbp), %rdx
leaq 0x179be(%rip), %rsi     # 0x62f76
leaq -0x50(%rbp), %rdi
callq 0xd8b0
jmp 0x4b5c3
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rsi
movl -0x84(%rbp), %edi
leaq -0x50(%rbp), %rcx
callq 0x4a0b0
movb %al, -0x85(%rbp)
jmp 0x4b5e2
leaq -0x50(%rbp), %rdi
callq 0xdca8
leaq -0x51(%rbp), %rdi
callq 0xd6b0
movb -0x85(%rbp), %al
testb $0x1, %al
jne 0x4b600
jmp 0x4b638
movq $0x0, -0x8(%rbp)
jmp 0x4b673
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x4b62d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xdca8
leaq -0x51(%rbp), %rdi
callq 0xd6b0
jmp 0x4b680
cmpl $0x0, -0x2c(%rbp)
je 0x4b65d
cmpl $0x1, -0x2c(%rbp)
je 0x4b65d
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x4b690
movq %rax, -0x90(%rbp)
jmp 0x4b668
xorl %eax, %eax
movq %rax, -0x90(%rbp)
jmp 0x4b668
movq -0x90(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xdb30
nopl (%rax)