LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/program_options/src/options_description.cpp
// Function: boost::program_options::options_description::print(std::ostream&, unsigned int) const
void 
    options_description::print(std::ostream& os, unsigned width) const
    {
        if (!m_caption.empty())
            os << m_caption << ":\n";

        if (!width)
            width = get_option_column_width();

        /* The options formatting style is stolen from Subversion. */
        for (unsigned i = 0; i < m_options.size(); ++i)
        {
            if (belong_to_group[i])
                continue;

            const option_description& opt = *m_options[i];

            format_one(os, opt, width, m_line_length);

            os << "\n";
        }

        for (unsigned j = 0; j < groups.size(); ++j) {            
            os << "\n";
            groups[j]->print(os, width);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x16659
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xb500
leaq 0x1ce67(%rip), %rsi     # 0x334b3
movl $0x2, %edx
movq %rax, %rdi
callq 0xb500
testl %r15d, %r15d
jne 0x16669
movq %r14, %rdi
callq 0x1678e
movl %eax, %r15d
movq 0x28(%r14), %rax
movq 0x30(%r14), %rcx
cmpq %rax, %rcx
je 0x166e7
movl $0x1, %r13d
xorl %edx, %edx
leaq 0x1c824(%rip), %r12     # 0x32ea9
leal -0x1(%r13), %esi
movq 0x40(%r14), %rdi
shrl $0x6, %esi
movq (%rdi,%rsi,8), %rsi
btq %rdx, %rsi
jb 0x166d2
shlq $0x4, %rdx
movq (%rax,%rdx), %rsi
testq %rsi, %rsi
je 0x1676f
movl 0x20(%r14), %ecx
movq %rbx, %rdi
movl %r15d, %edx
callq 0x16a02
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb500
movq 0x28(%r14), %rax
movq 0x30(%r14), %rcx
movl %r13d, %edx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x4, %rsi
incl %r13d
cmpq %rdx, %rsi
ja 0x16685
movq 0x70(%r14), %rax
cmpq 0x68(%r14), %rax
je 0x16741
movl $0x1, %r13d
xorl %r12d, %r12d
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x1c7a0(%rip), %rsi     # 0x32ea9
callq 0xb500
movq 0x68(%r14), %rax
shlq $0x4, %r12
movq (%rax,%r12), %rdi
testq %rdi, %rdi
je 0x16750
movq %rbx, %rsi
movl %r15d, %edx
callq 0x1661a
movq 0x70(%r14), %rax
subq 0x68(%r14), %rax
movl %r13d, %r12d
sarq $0x4, %rax
incl %r13d
cmpq %r12, %rax
ja 0x166fa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bedd(%rip), %rdi     # 0x32634
leaq 0x1bede(%rip), %rsi     # 0x3263c
leaq 0x1d341(%rip), %rcx     # 0x33aa6
movl $0x2af, %edx            # imm = 0x2AF
callq 0xb310
leaq 0x1bebe(%rip), %rdi     # 0x32634
leaq 0x1bebf(%rip), %rsi     # 0x3263c
leaq 0x1d270(%rip), %rcx     # 0x339f4
movl $0x2a8, %edx            # imm = 0x2A8
callq 0xb310
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/token_iterator.hpp
// Function: boost::token_iterator<boost::escaped_list_separator<char, std::char_traits<char>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::initialize()
void initialize(){
          if(valid_) return;
          f_.reset();
          valid_ = (begin_ != end_)?
              f_(begin_,end_,tok_):false;
      }

// Assembly:
cmpb $0x0, 0x78(%rdi)
jne 0x1d8bd
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0x60(%rdi)
movq 0x70(%rdi), %rdx
cmpq %rdx, 0x68(%rdi)
je 0x1d8b2
leaq 0x68(%rbx), %rsi
leaq 0x80(%rbx), %rcx
movq %rbx, %rdi
callq 0x1d8be
jmp 0x1d8b4
xorl %eax, %eax
movb %al, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/token_functions.hpp
// Function: boost::char_separator<char, std::char_traits<char>>::is_dropped(char) const
bool is_dropped(Char E) const
    {
      if (m_dropped_delims.length())
        return m_dropped_delims.find(E) != string_type::npos;
      else if (m_use_isspace) {
        return Traits::isspace(E) != 0;
      } else
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x28(%rdi)
je 0x18092
addq $0x20, %rdi
movsbl %sil, %esi
xorl %edx, %edx
callq 0xb5c0
cmpq $-0x1, %rax
jmp 0x180a3
cmpb $0x1, 0x41(%rdi)
jne 0x180a8
movsbl %sil, %edi
callq 0xb090
testl %eax, %eax
setne %al
popq %rbp
retq
xorl %eax, %eax
jmp 0x180a6
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/token_functions.hpp
// Function: boost::char_separator<char, std::char_traits<char>>::is_kept(char) const
bool is_kept(Char E) const
    {
      if (m_kept_delims.length())
        return m_kept_delims.find(E) != string_type::npos;
      else if (m_use_ispunct) {
        return Traits::ispunct(E) != 0;
      } else
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x8(%rdi)
je 0x180c8
movsbl %sil, %esi
xorl %edx, %edx
callq 0xb5c0
cmpq $-0x1, %rax
jmp 0x180d9
cmpb $0x1, 0x40(%rdi)
jne 0x180de
movsbl %sil, %edi
callq 0xb890
testl %eax, %eax
setne %al
popq %rbp
retq
xorl %eax, %eax
jmp 0x180dc
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/smart_ptr/detail/shared_count.hpp
// Function: boost::detail::shared_count::shared_count<boost::program_options::value_semantic const>(boost::program_options::value_semantic const*)
explicit shared_count( Y * p ): pi_( 0 )
#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        , id_(shared_count_id)
#endif
    {
#ifndef BOOST_NO_EXCEPTIONS

        try
        {
            pi_ = new sp_counted_impl_p<Y>( p );
        }
        catch(...)
        {
            boost::checked_delete( p );
            throw;
        }

#else

        pi_ = new sp_counted_impl_p<Y>( p );

        if( pi_ == 0 )
        {
            boost::checked_delete( p );
            boost::throw_exception( std::bad_alloc() );
        }

#endif
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, (%rdi)
movl $0x18, %edi
callq 0xb460
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x31ca3(%rip), %rcx     # 0x49ef8
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
movq %rax, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0xb1e0
testq %rbx, %rbx
je 0x1827a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
callq 0xb680
movq %rax, %rbx
callq 0xb780
movq %rbx, %rdi
callq 0xb7f0
movq %rax, %rdi
callq 0xe915
nop
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/core/checked_delete.hpp
// Function: void boost::checked_delete<boost::filesystem::filesystem_error::m_imp>(boost::filesystem::filesystem_error::m_imp*)
inline void checked_delete(T * x)
{
    // intentionally complex - simplification causes regressions
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x29b20
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x29afd
callq 0xb430
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x29b0f
callq 0xb430
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x29b20
callq 0xb430
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb430
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/smart_ptr/detail/sp_counted_impl.hpp
// Function: boost::detail::sp_counted_impl_p<boost::filesystem::filesystem_error::m_imp>::dispose()
virtual void dispose() // nothrow
    {
#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        boost::sp_scalar_destructor_hook( px_, sizeof(X), this );
#endif
        boost::checked_delete( px_ );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rbx
testq %rbx, %rbx
je 0x29b7c
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x29b59
callq 0xb430
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x29b6b
callq 0xb430
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x29b7c
callq 0xb430
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb430
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/program_options/src/parsers.cpp
// Function: boost::program_options::basic_parsed_options<char> boost::program_options::parse_config_file<char>(char const*, boost::program_options::options_description const&, bool)
basic_parsed_options<charT>
    parse_config_file(const char* filename, 
                      const options_description& desc,
                      bool allow_unregistered)
    { 
        // Parser return char strings
        std::basic_ifstream< charT > strm(filename);
        if (!strm) 
        {
            boost::throw_exception(reading_file(filename));
        }
        return parse_config_file(strm, desc, allow_unregistered);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movl %ecx, %r15d
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq -0x240(%rbp), %r13
movq %r13, %rdi
movl $0x8, %edx
callq 0xb830
movq (%r13), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x220(%rbp,%rax)
jne 0x1a1c2
movzbl %r15b, %ecx
leaq -0x240(%rbp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x195f6
leaq -0x240(%rbp), %rdi
callq 0xb0e0
movq %rbx, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x38(%rbp), %rdi
movq %r12, %rsi
callq 0x1a2d2
leaq -0x38(%rbp), %rdi
callq 0x1a1fe
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xb800
jmp 0x1a1ea
jmp 0x1a1e7
movq %rax, %rbx
leaq -0x240(%rbp), %rdi
callq 0xb0e0
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/program_options/detail/config_file.hpp
// Function: boost::program_options::detail::basic_config_file_iterator<wchar_t>::getline(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool
    basic_config_file_iterator<charT>::getline(std::string& s)
    {
        std::basic_string<charT> in;
        if (std::getline(*is, in)) {
            s = to_internal(in);
            return true;
        } else {
            return false;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movl $0x0, (%r15)
movq 0xf8(%rdi), %r14
testq %r14, %r14
je 0x1aa59
movq (%r14), %rax
movq -0x18(%rax), %rax
movq 0xf0(%r14,%rax), %rdi
testq %rdi, %rdi
je 0x1aa78
movq %rsi, %rbx
movq (%rdi), %rax
movl $0xa, %esi
callq *0x50(%rax)
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0xb4c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %r12d
testb $0x5, %r12b
jne 0x1aa37
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x149d0
leaq -0x60(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb560
movq (%r14), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x1aa37
callq 0xb430
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x1aa45
callq 0xb430
testb $0x5, %r12b
sete %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17bd4(%rip), %rdi     # 0x32634
leaq 0x17bd5(%rip), %rsi     # 0x3263c
leaq 0x193da(%rip), %rcx     # 0x33e48
movl $0x2a8, %edx            # imm = 0x2A8
callq 0xb310
callq 0xb580
jmp 0x1aa7f
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x1aa90
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/program_options/environment_iterator.hpp
// Function: boost::environment_iterator::get()
void get()
        {
            if (*m_environment == 0)
                found_eof();
            else {
                std::string s(*m_environment);
                std::string::size_type n = s.find('=');
                assert(n != s.npos);
                value().first = s.substr(0, n);
                value().second = s.substr(n+1);
                
                ++m_environment;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0x1ad97
leaq -0x58(%rbp), %r14
leaq -0x38(%rbp), %rdx
movq %r14, %rdi
callq 0xb1c0
movq %r14, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0xb5c0
cmpq $-0x1, %rax
je 0x1ada5
movq %rax, %r14
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0xb490
leaq 0x8(%rbx), %rdi
leaq -0x38(%rbp), %r15
movq %r15, %rsi
callq 0xb560
movq (%r15), %rdi
leaq -0x28(%rbp), %r15
cmpq %r15, %rdi
je 0x1ad47
callq 0xb430
incq %r14
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movq %r14, %rdx
movq $-0x1, %rcx
callq 0xb490
leaq 0x28(%rbx), %rdi
leaq -0x38(%rbp), %r14
movq %r14, %rsi
callq 0xb560
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x1ad7e
callq 0xb430
addq $0x8, 0x48(%rbx)
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ad9a
callq 0xb430
jmp 0x1ad9a
movb $0x1, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1915a(%rip), %rdi     # 0x33f06
leaq 0x1915f(%rip), %rsi     # 0x33f12
leaq 0x19189(%rip), %rcx     # 0x33f43
movl $0x28, %edx
callq 0xb310
jmp 0x1adc6
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1addb
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/smart_ptr/detail/shared_count.hpp
// Function: boost::detail::shared_count::shared_count<std::istream*, boost::program_options::detail::null_deleter>(std::istream*, boost::program_options::detail::null_deleter)
id_(shared_count_id)
#endif
    {
#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1200 )
        typedef Y* P;
#endif
#ifndef BOOST_NO_EXCEPTIONS

        try
        {
            pi_ = new sp_counted_impl_pd<P, D>(p, d);
        }
        catch(...)
        {
            d(p); // delete p
            throw;
        }

#else

        pi_ = new sp_counted_impl_pd<P, D>(p, d);

        if(pi_ == 0)
        {
            d(p); // delete p
            boost::throw_exception(std::bad_alloc());
        }

#endif
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, (%rdi)
movl $0x20, %edi
callq 0xb460
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x2f0fd(%rip), %rcx     # 0x4a250
movq %rcx, (%rax)
movq %r14, 0x10(%rax)
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0xb1e0
callq 0xb680
movq %rax, %rbx
callq 0xb780
movq %rbx, %rdi
callq 0xb7f0
movq %rax, %rdi
callq 0xe915
nop
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/function/function_template.hpp
// Function: void boost::function1<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::assign_to<boost::program_options::detail::prefix_name_mapper>(boost::program_options::detail::prefix_name_mapper)
void assign_to(Functor f)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R BOOST_FUNCTION_COMMA 
                        BOOST_FUNCTION_TEMPLATE_ARGS>
        handler_type;
      
      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;

      // Note: it is extremely important that this initialization use
      // static initialization. Otherwise, we will have a race
      // condition here in multi-threaded code. See
      // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
      static const vtable_type stored_vtable = 
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        // coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else 
        vtable = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0xf98c
leaq 0x8(%rbx), %rdx
leaq 0x2e1af(%rip), %r14     # 0x4a450
movq %r14, %rdi
movq %r15, %rsi
callq 0x1c32e
movl %eax, %r15d
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1c2bd
callq 0xb430
xorl %eax, %eax
testb %r15b, %r15b
cmovneq %r14, %rax
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1c2e7
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/program_options/src/parsers.cpp
// Function: boost::program_options::detail::prefix_name_mapper::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string operator()(const std::string& s)
            {
                string result;
                if (s.find(prefix) == 0) {
                    for(string::size_type n = prefix.size(); n < s.size(); ++n) 
                    {   
                        // Intel-Win-7.1 does not understand
            // push_back on string.         
                        result += static_cast<char>(tolower(s[n]));
                    }
                }
                return result;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rsi
movq 0x8(%r15), %rcx
movq %rdx, %rdi
xorl %edx, %edx
callq 0xb7e0
testq %rax, %rax
je 0x1c4e5
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r15), %r15
cmpq 0x8(%r14), %r15
jae 0x1c4d9
movq (%r14), %rax
movsbl (%rax,%r15), %edi
callq 0xb670
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb3f0
incq %r15
jmp 0x1c4e9
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1c51c
callq 0xb430
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/function/function_template.hpp
// Function: bool boost::detail::function::basic_vtable1<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::assign_to<boost::program_options::detail::prefix_name_mapper>(boost::program_options::detail::prefix_name_mapper, boost::detail::function::function_buffer&, boost::detail::function::function_obj_tag) const
bool 
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor, 
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0xf98c
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1c5a0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1c577
callq 0xb430
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1c597
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/program_options/src/positional_options.cpp
// Function: boost::program_options::positional_options_description::add(char const*, int)
positional_options_description&
    positional_options_description::add(const char* name, int max_count)
    {
        assert(max_count != -1 || m_trailing.empty());

        if (max_count == -1)
            m_trailing = name;
        else {
            m_names.resize(m_names.size() + max_count, name);
        }
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0x1c67c
movl %edx, %r15d
movq 0x8(%rbx), %r13
subq (%rbx), %r13
sarq $0x5, %r13
leaq -0x50(%rbp), %r12
leaq -0x29(%rbp), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0xb1c0
movslq %r15d, %rsi
addq %r13, %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1c772
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c6a1
callq 0xb430
jmp 0x1c6a1
cmpq $0x0, 0x20(%rbx)
jne 0x1c6b3
leaq 0x18(%rbx), %r15
movq %r14, %rdi
callq 0xb200
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
callq 0xb6f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17b44(%rip), %rdi     # 0x341fe
leaq 0x17b63(%rip), %rsi     # 0x34224
leaq 0x17b8e(%rip), %rcx     # 0x34256
movl $0x17, %edx
callq 0xb310
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c6e7
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/program_options/src/value_semantic.cpp
// Function: boost::program_options::untyped_value::xparse(boost::any&, 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&) const
void 
    untyped_value::xparse(boost::any& value_store,
                          const std::vector<std::string>& new_tokens) const
    {
        if (!value_store.empty()) 
            boost::throw_exception(
                multiple_occurrences());
        if (new_tokens.size() > 1)
            boost::throw_exception(multiple_values());
        value_store = new_tokens.empty() ? std::string("") : new_tokens.front();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
cmpq $0x0, (%rsi)
jne 0x1f594
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jae 0x1f5ab
movq %rsi, %rbx
leaq -0xb8(%rbp), %r14
movq %r14, -0x10(%r14)
cmpq %rcx, %rax
je 0x1f552
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0xc8(%rbp), %rdi
callq 0xf98c
jmp 0x1f568
leaq 0x13951(%rip), %rdx     # 0x32eaa
leaq -0xc8(%rbp), %rdi
movq %rdx, %rsi
callq 0xf8ee
leaq -0xc8(%rbp), %rsi
movq %rbx, %rdi
callq 0x21254
movq -0xc8(%rbp), %rdi
cmpq %r14, %rdi
je 0x1f588
callq 0xb430
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0xc8(%rbp), %rbx
movq %rbx, %rdi
callq 0x20f6a
movq %rbx, %rdi
callq 0x20e7f
leaq -0xc8(%rbp), %rbx
movq %rbx, %rdi
callq 0x21154
movq %rbx, %rdi
callq 0x21069
movq %rax, %rbx
movq -0xc8(%rbp), %rdi
cmpq %r14, %rdi
je 0x1f5ee
callq 0xb430
jmp 0x1f5ee
movq %rax, %rbx
jmp 0x1f5ee
jmp 0x1f5df
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0xed30
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/program_options/src/value_semantic.cpp
// Function: boost::program_options::bool_switch(bool*)
BOOST_PROGRAM_OPTIONS_DECL typed_value<bool>*
    bool_switch(bool* v)
    {
        typed_value<bool>* r = new typed_value<bool>(v);
        r->default_value(0);
        r->zero_tokens();

        return r;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl $0xb0, %edi
callq 0xb460
movq %rax, %rbx
leaq 0x2b74c(%rip), %rax     # 0x4ad70
movq %rax, (%rbx)
leaq 0x2b7ba(%rip), %rax     # 0x4ade8
movq %rax, 0x8(%rbx)
movq %r14, 0x10(%rbx)
leaq 0x28(%rbx), %rax
movq %rax, 0x18(%rbx)
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movb %al, 0x28(%rbx)
movq %rax, 0x38(%rbx)
leaq 0x50(%rbx), %rcx
movq %rcx, 0x40(%rbx)
movq %rax, 0x48(%rbx)
movb %al, 0x50(%rbx)
movq %rax, 0x60(%rbx)
leaq 0x78(%rbx), %rcx
movq %rcx, 0x68(%rbx)
movq %rax, 0x70(%rbx)
movb %al, 0x78(%rbx)
movq %rax, 0x90(%rbx)
movb %al, 0x8c(%rbx)
movl $0x0, 0x88(%rbx)
leaq -0x11(%rbp), %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x21292
movb $0x1, 0x8b(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/program_options/src/value_semantic.cpp
// Function: boost::program_options::validate(boost::any&, 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&, bool*, int)
BOOST_PROGRAM_OPTIONS_DECL void validate(any& v, const vector<string>& xs,
                       bool*, int)
    {
        check_first_occurrence(v);
        string s(get_single_string(xs, true));

        for (size_t i = 0; i < s.size(); ++i)
            s[i] = char(tolower(s[i]));

        if (s.empty() || s == "on" || s == "yes" || s == "1" || s == "true")
            v = any(true);
        else if (s == "off" || s == "no" || s == "0" || s == "false")
            v = any(false);
        else
            boost::throw_exception(invalid_bool_value(s));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1f875
movq %r14, %rdi
movl $0x1, %esi
callq 0x21382
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0xf98c
cmpq $0x0, 0x8(%r14)
je 0x1f7e4
xorl %r14d, %r14d
movq -0x40(%rbp), %r12
movsbl (%r12,%r14), %edi
callq 0xb670
movb %al, (%r12,%r14)
incq %r14
movq -0x38(%rbp), %rax
cmpq %rax, %r14
jb 0x1f6fb
testq %rax, %rax
je 0x1f7e4
leaq 0x12f08(%rip), %rsi     # 0x32631
leaq -0x40(%rbp), %rdi
callq 0xb110
testl %eax, %eax
je 0x1f7e4
leaq 0x1565b(%rip), %rsi     # 0x34d9c
leaq -0x40(%rbp), %rdi
callq 0xb110
testl %eax, %eax
je 0x1f7e4
leaq 0x13c86(%rip), %rsi     # 0x333df
leaq -0x40(%rbp), %rdi
callq 0xb110
testl %eax, %eax
je 0x1f7e4
leaq 0x15633(%rip), %rsi     # 0x34da0
leaq -0x40(%rbp), %rdi
callq 0xb110
testl %eax, %eax
je 0x1f7e4
leaq 0x15624(%rip), %rsi     # 0x34da5
leaq -0x40(%rbp), %rdi
callq 0xb110
testl %eax, %eax
je 0x1f7ca
leaq 0x15614(%rip), %rsi     # 0x34da9
leaq -0x40(%rbp), %rdi
callq 0xb110
testl %eax, %eax
je 0x1f7ca
leaq 0x16c14(%rip), %rsi     # 0x363bd
leaq -0x40(%rbp), %rdi
callq 0xb110
testl %eax, %eax
je 0x1f7ca
leaq 0x155ef(%rip), %rsi     # 0x34dac
leaq -0x40(%rbp), %rdi
callq 0xb110
testl %eax, %eax
jne 0x1f82b
movl $0x10, %edi
callq 0xb460
leaq 0x2b67d(%rip), %rcx     # 0x4ae58
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
jmp 0x1f7fc
movl $0x10, %edi
callq 0xb460
leaq 0x2b663(%rip), %rcx     # 0x4ae58
movq %rcx, (%rax)
movb $0x1, 0x8(%rax)
movq (%rbx), %rdi
movq %rax, (%rbx)
testq %rdi, %rdi
je 0x1f80d
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x1f81b
callq 0xb430
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x100(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1fe50
leaq -0x100(%rbp), %rdi
callq 0x214ea
movq %rax, %rbx
leaq -0x100(%rbp), %rdi
callq 0xed30
jmp 0x1f85f
jmp 0x1f85c
jmp 0x1f85c
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x1f86d
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/program_options/src/value_semantic.cpp
// Function: boost::program_options::(anonymous namespace)::convert_value(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&)
std::string convert_value(const std::wstring& s)
        {
            try {
                return to_local_8_bit(s);
            }
            catch(const std::exception&) {
                return "<unrepresentable unicode string>";
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1491f
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x1fafe
movq %r14, %rdi
callq 0xb1e0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x15554(%rip), %rsi     # 0x35032
leaq 0x1556d(%rip), %rdx     # 0x35052
movq %rbx, %rdi
callq 0xf8ee
popq %rbx
popq %r14
popq %rbp
jmp 0xb780
movq %rax, %r14
callq 0xb780
movq %r14, %rdi
callq 0xb7f0
movq %rax, %rdi
callq 0xe915
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/program_options/src/value_semantic.cpp
// Function: boost::program_options::error_with_option_name::replace_token(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
void error_with_option_name::replace_token(const string& from, const string& to) const
    {
        for (;;)
        {
            std::size_t pos = m_message.find(from.c_str(), 0, from.length());
            // not found: all replaced
            if (pos == std::string::npos)
                return;
            m_message.replace(pos, from.length(), to);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x98, %r15
movq (%rsi), %rsi
movq 0x8(%r14), %rcx
movq %r15, %rdi
xorl %edx, %edx
callq 0xb7e0
cmpq $-0x1, %rax
je 0x203ce
movq 0x8(%r14), %rdx
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
movq %r15, %rdi
movq %rax, %rsi
callq 0xb4f0
movq (%r14), %rsi
jmp 0x2039f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/program_options/src/value_semantic.cpp
// Function: boost::program_options::error_with_option_name::get_canonical_option_prefix[abi:cxx11]() const
string error_with_option_name::get_canonical_option_prefix() const
    {
        switch (m_option_style)
        {
        case command_line_style::allow_dash_for_short:
            return "-";
        case command_line_style::allow_slash_for_short:
            return "/";
        case command_line_style::allow_long_disguise:
            return "-";
        case command_line_style::allow_long:
            return "--";
        case 0:
            return "";
        }
        throw std::logic_error("error_with_option_name::m_option_style can only be "
                               "one of [0, allow_dash_for_short, allow_slash_for_short, "
                               "allow_long_disguise or allow_long]");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rsi), %eax
cmpq $0x8, %rax
ja 0x20413
leaq 0x1486c(%rip), %rcx     # 0x34c60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x12a9f(%rip), %rdx     # 0x32eaa
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x20460
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x2046d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x12f87(%rip), %rsi     # 0x333af
leaq 0x12f81(%rip), %rdx     # 0x333b0
jmp 0x2045d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x14c15(%rip), %rsi     # 0x35054
leaq 0x14c0f(%rip), %rdx     # 0x35055
jmp 0x2045d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x12f58(%rip), %rsi     # 0x333ae
leaq 0x12f53(%rip), %rdx     # 0x333b0
movq %rbx, %rdi
callq 0xf8ee
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0xb250
movq %rax, %rbx
leaq 0x14964(%rip), %rsi     # 0x34de5
movq %rax, %rdi
callq 0xb650
movq 0x2bb48(%rip), %rsi     # 0x4bfd8
movq 0x2bb19(%rip), %rdx     # 0x4bfb0
movq %rbx, %rdi
callq 0xb7b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xb360
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/program_options/detail/value_semantic.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const& boost::program_options::validators::get_single_string<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&, bool)
const std::basic_string<charT>& get_single_string(
            const std::vector<std::basic_string<charT> >& v, 
            bool allow_empty = false)
        {
            static std::basic_string<charT> empty;
            if (v.size() > 1)
                boost::throw_exception(validation_error(validation_error::multiple_values_not_allowed));
            else if (v.size() == 1)
                return v.front();
            else if (!allow_empty)
                boost::throw_exception(validation_error(validation_error::at_least_one_value_required));
            return empty;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %esi, %ebx
movq %rdi, %r14
movb 0x2b19b(%rip), %al      # 0x4c538
testb %al, %al
je 0x213dd
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
cmpq $0x21, %rax
jae 0x213e4
cmpq $0x20, %rax
sete %dl
orb %bl, %dl
je 0x21442
cmpq $0x20, %rax
leaq 0x2b14d(%rip), %rax     # 0x4c518
cmoveq %rcx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xba9a
jmp 0x213a1
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x11ab7(%rip), %rdx     # 0x32eaa
leaq -0x58(%rbp), %rdi
movq %rdx, %rsi
callq 0xf8ee
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x11a9c(%rip), %rdx     # 0x32eaa
leaq -0x38(%rbp), %rdi
movq %rdx, %rsi
callq 0xf8ee
leaq -0x118(%rbp), %rdi
leaq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rcx
movl $0x1e, %esi
xorl %r8d, %r8d
callq 0x2351a
leaq -0x118(%rbp), %rdi
callq 0x23422
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x11a59(%rip), %rdx     # 0x32eaa
leaq -0x58(%rbp), %rdi
movq %rdx, %rsi
callq 0xf8ee
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x11a3e(%rip), %rdx     # 0x32eaa
leaq -0x38(%rbp), %rdi
movq %rdx, %rsi
callq 0xf8ee
leaq -0x118(%rbp), %rdi
leaq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rcx
movl $0x1f, %esi
xorl %r8d, %r8d
callq 0x2351a
leaq -0x118(%rbp), %rdi
callq 0x23422
jmp 0x214a4
jmp 0x214b5
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0xed30
jmp 0x214b8
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x214cd
callq 0xb430
jmp 0x214cd
jmp 0x214ca
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x214e2
callq 0xb430
jmp 0x214e2
jmp 0x214df
movq %rax, %rbx
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq 0x38(%rdi), %rbx
testq %rbx, %rbx
je 0x22fd1
movq %rsi, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%r14), %rdi
movq %rax, (%r14)
testq %rdi, %rdi
je 0x22fd1
movq (%rdi), %rax
callq *0x8(%rax)
testq %rbx, %rbx
setne %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x23328
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
je 0x22ffa
movb (%rax), %dl
movb %dl, (%rcx)
cmpq $0x0, 0x90(%rbx)
je 0x2301c
addq $0x90, %rbx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x232ca
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/program_options/src/variables_map.cpp
// Function: boost::program_options::variables_map::notify()
void
    variables_map::notify()
    {
        // This checks if all required options occur
        for (map<string, string>::const_iterator r = m_required.begin();
             r != m_required.end();
             ++r)
        {
            const string& opt = r->first;
            const string& display_opt = r->second;
            map<string, variable_value>::const_iterator iter = find(opt);
            if (iter == end() || iter->second.empty())
            {
                boost::throw_exception(required_option(display_opt));

            }
        }

        // Lastly, run notify actions.
        for (map<string, variable_value>::iterator k = begin();
             k != end();
             ++k)
        {
            /* Users might wish to use variables_map to store their own values
               that are not parsed, and therefore will not have value_semantics
               defined. Do not crash on such values. In multi-module programs,
               one module might add custom values, and the 'notify' function
               will be called after that, so we check that value_sematics is
               not NULL. See:
                   https://svn.boost.org/trac/boost/ticket/2782
            */
            if (k->second.m_value_semantic)
                k->second.m_value_semantic->notify(k->second.value());
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
movq 0x88(%rdi), %r14
leaq 0x78(%rdi), %r12
cmpq %r12, %r14
je 0x24c79
leaq 0x10(%rbx), %r15
leaq 0x18(%rbx), %r13
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x25782
cmpq %r13, %rax
je 0x24cbb
cmpq $0x0, 0x40(%rax)
je 0x24cbb
movq %r14, %rdi
callq 0xb510
movq %rax, %r14
cmpq %r12, %rax
jne 0x24c51
movq 0x28(%rbx), %r14
addq $0x18, %rbx
cmpq %rbx, %r14
je 0x24ca9
movq 0x50(%r14), %rdi
testq %rdi, %rdi
je 0x24c99
leaq 0x40(%r14), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq %r14, %rdi
callq 0xb330
movq %rax, %r14
cmpq %rbx, %rax
jne 0x24c86
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x40, %r14
leaq -0xe0(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2505e
movq %rbx, %rdi
callq 0x24f73
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0xed30
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
movq %rax, %rbx
cmpq $0x0, (%rax)
jne 0x24d47
movq 0x8(%r15), %rdi
testq %rdi, %rdi
jne 0x24d29
cmpb $0x1, 0x8(%rbx)
jne 0x24d6a
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x24d6a
movq %r14, %rsi
callq 0x24d1c
cmpq $0x0, (%rax)
je 0x24d6a
cmpb $0x1, 0x8(%rax)
jne 0x24d6d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movb 0x276f5(%rip), %al      # 0x4c588
testb %al, %al
je 0x24ebe
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x2563c
addq $0x18, %rbx
leaq 0x40(%rax), %rcx
cmpq %rbx, %rax
leaq 0x276b3(%rip), %rax     # 0x4c568
cmovneq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0xbb7c
jmp 0x24e97
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpl $0x4, %edx
jae 0x25d2c
movl %edx, %eax
leaq 0xfc30(%rip), %rdx      # 0x35948
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
leaq 0xfc92(%rip), %rdx      # 0x359b8
movq (%rdx,%rax,8), %r8
jmp 0x25d39
movl $0xd, %r8d
leaq 0xf2ac(%rip), %rcx      # 0x34fe5
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb6f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x25d63
callq 0xb430
movq %r14, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/filesystem/src/operations.cpp
// Function: boost::filesystem::detail::copy(boost::filesystem::path const&, boost::filesystem::path const&, boost::system::error_code*)
BOOST_FILESYSTEM_DECL
  void copy(const path& from, const path& to, system::error_code* ec)
  {
    file_status s(symlink_status(from, *ec));
    if (ec != 0 && *ec) return;

    if(is_symlink(s))
    {
      copy_symlink(from, to, *ec);
    }
    else if(is_directory(s))
    {
      copy_directory(from, to, *ec);
    }
    else if(is_regular_file(s))
    {
      copy_file(from, to, fs::copy_option::fail_if_exists, *ec);
    }
    else
    {
      if (ec == 0)
        BOOST_FILESYSTEM_THROW(filesystem_error("boost::filesystem::copy",
          from, to, error_code(BOOST_ERROR_NOT_SUPPORTED, system_category())));
      ec->assign(BOOST_ERROR_NOT_SUPPORTED, system_category());
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rsi
callq 0x26910
cmpl $0x0, (%rbx)
je 0x26c64
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %eax
je 0x26ca3
cmpl $0x3, %eax
je 0x26c8b
cmpl $0x4, %eax
jne 0x26cbd
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x270bd
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x26cce
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x26e20
callq 0x2c4e2
movl $0x26, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x26c59
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
leaq -0xe0(%rbp), %rsi
callq 0xb7c0
testl %eax, %eax
jne 0x26d11
movq (%r14), %rdi
movl -0xc8(%rbp), %esi
callq 0xb210
testl %eax, %eax
je 0x26d70
callq 0xb060
movl (%rax), %r12d
leaq -0x40(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0xee32(%rip), %rsi      # 0x35b5a
leaq 0xee4c(%rip), %rdx      # 0x35b7b
leaq -0x50(%rbp), %r13
movq %r13, %rdi
callq 0xf8ee
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movq -0x30(%rbp), %rcx
movq %r13, %r8
callq 0x26d8e
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x26d5e
callq 0xb430
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0x26d19
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x26d86
callq 0xb430
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
testl %edi, %edi
je 0x26db5
movl %edi, %r14d
testq %rbx, %rbx
je 0x26dd8
callq 0x2c4e2
movl %r14d, (%rbx)
jmp 0x26dc5
testq %rbx, %rbx
je 0x26dc9
movl $0x0, (%rbx)
callq 0x2c4e2
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %r12
movq %rdx, %r15
movq %rsi, %r13
movl $0x50, %edi
callq 0xb250
movq %rax, %rbx
callq 0x2c4e2
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
movl %r14d, %r8d
movq %rax, %r9
callq 0x295a0
leaq 0x24757(%rip), %rsi     # 0x4b568
leaq 0x275e(%rip), %rdx      # 0x29576
movq %rbx, %rdi
callq 0xb7b0