LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./boost/program_options/detail/config_file.hpp
// Function: boost::program_options::detail::common_config_file_iterator::common_config_file_iterator(boost::program_options::detail::common_config_file_iterator const&)
class BOOST_PROGRAM_OPTIONS_DECL common_config_file_iterator
        : public eof_iterator<common_config_file_iterator, option>
    {
    public:
        common_config_file_iterator() { found_eof(); }
        common_config_file_iterator(
            const std::set<std::string>& allowed_options,
            bool allow_unregistered = false);

        virtual ~common_config_file_iterator() {}

    public: // Method required by eof_iterator
        
        void get();
        
#if BOOST_WORKAROUND(_MSC_VER, <= 1900)
        void decrement() {}
        void advance(difference_type) {}
#endif

    protected: // Stubs for derived classes

        // Obtains next line from the config file
        // Note: really, this design is a bit ugly
        // The most clean thing would be to pass 'line_iterator' to
        // constructor of this class, but to avoid templating this class
        // we'd need polymorphic iterator, which does not exist yet.
        virtual bool getline(std::string&) { return false; }
        
    private:
        /** Adds another allowed option. If the 'name' ends with
            '*', then all options with the same prefix are
            allowed. For example, if 'name' is 'foo*', then 'foo1' and
            'foo_bar' are allowed. */
        void add_option(const char* name);

        // Returns true if 's' is a registered option name.
        bool allowed_option(const std::string& s) const; 

        // That's probably too much data for iterator, since
        // it will be copied, but let's not bother for now.
        std::set<std::string> allowed_options;
        // Invariant: no element is prefix of other element.
        std::set<std::string> allowed_prefixes;
        std::string m_prefix;
        bool m_allow_unregistered;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x19b1e
leaq 0x2cd61(%rip), %rax     # 0x46800
movq %rax, (%rbx)
leaq 0x70(%rbx), %r14
leaq 0x70(%r15), %rsi
movq %r14, %rdi
callq 0x12d48
movl $0xa0, %esi
leaq (%rbx,%rsi), %r12
addq %r15, %rsi
movq %r12, %rdi
callq 0x12d48
movl $0xd0, %esi
leaq (%rbx,%rsi), %rdi
addq %r15, %rsi
callq 0xc660
movb 0xf0(%r15), %al
movb %al, 0xf0(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r12, %rdi
callq 0x13024
jmp 0x19afd
movq %rax, %r15
movq %r14, %rdi
callq 0x13024
jmp 0x19b0a
movq %rax, %r15
addq $0x10, %rbx
movq %rbx, %rdi
callq 0xeb3a
movq %r15, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0xc660
leaq 0x8(%rbx), %rdx
leaq 0x2d035(%rip), %r14     # 0x472d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a31a
movl %eax, %r15d
leaq -0x38(%rbp), %rdi
callq 0xc9a0
xorl %eax, %eax
testb %r15b, %r15b
cmovneq %r14, %rax
movq %rax, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./boost/function/function_base.hpp
// Function: boost::detail::function::functor_manager<boost::program_options::detail::prefix_name_mapper>::manager(boost::detail::function::function_buffer const&, boost::detail::function::function_buffer&, boost::detail::function::functor_manager_operation_type, mpl_::bool_<false>)
static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, mpl::false_)
        {
          if (op == clone_functor_tag) {
            // Clone the functor
            // GCC 2.95.3 gets the CV qualifiers wrong here, so we
            // can't do the static_cast that we should do.
            // jewillco: Changing this to static_cast because GCC 2.95.3 is
            // obsolete.
            const functor_type* f =
              static_cast<const functor_type*>(in_buffer.obj_ptr);
            functor_type* new_f = new functor_type(*f);
            out_buffer.obj_ptr = new_f;
          } else if (op == move_functor_tag) {
            out_buffer.obj_ptr = in_buffer.obj_ptr;
            in_buffer.obj_ptr = 0;
          } else if (op == destroy_functor_tag) {
            /* Cast from the void pointer to the functor pointer type */
            functor_type* f =
              static_cast<functor_type*>(out_buffer.obj_ptr);
            delete f;
            out_buffer.obj_ptr = 0;
          } else if (op == check_functor_type_tag) {
            const detail::sp_typeinfo& check_type
              = *out_buffer.type.type;
            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
              out_buffer.obj_ptr = in_buffer.obj_ptr;
            else
              out_buffer.obj_ptr = 0;
          } else /* op == get_functor_type_tag */ {
            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
          }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x3, %edx
ja 0x1a40f
movq %rdi, %r14
movl %edx, %eax
leaq 0x139a2(%rip), %rcx     # 0x2dd38
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r14), %r15
pushq $0x20
popq %rdi
callq 0xc4e0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xc660
movq %r14, (%rbx)
jmp 0x1a425
movq (%rbx), %r14
testq %r14, %r14
je 0x1a3cd
movq %r14, %rdi
callq 0xc9a0
movq %r14, %rdi
callq 0xc4a0
andq $0x0, (%rbx)
jmp 0x1a425
movq (%rbx), %rax
movq 0x8(%rax), %rax
xorl %edi, %edi
cmpb $0x2a, (%rax)
sete %dil
addq %rax, %rdi
leaq 0x13dac(%rip), %rsi     # 0x2e1a1
callq 0xc680
testl %eax, %eax
jne 0x1a420
movq (%r14), %rax
jmp 0x1a422
movq (%r14), %rax
movq %rax, (%rbx)
andq $0x0, (%r14)
jmp 0x1a425
leaq 0x2ceca(%rip), %rax     # 0x472e0
movq %rax, (%rbx)
andw $0x0, 0x8(%rbx)
jmp 0x1a425
xorl %eax, %eax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rdx, %rdi
xorl %edx, %edx
callq 0xc960
testq %rax, %rax
je 0x1a484
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r15), %r15
cmpq 0x8(%r14), %r15
jae 0x1a476
movq (%r14), %rax
movsbl (%rax,%r15), %edi
callq 0xc6f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xc430
incq %r15
jmp 0x1a488
movq %rax, %r14
movq %rbx, %rdi
callq 0xc9a0
movq %r14, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0xc660
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1a516
leaq -0x38(%rbp), %rdi
callq 0xc9a0
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/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 %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0x1a607
movl %edx, %r14d
movq 0x8(%rbx), %r12
subq (%rbx), %r12
sarq $0x5, %r12
leaq -0x48(%rbp), %r15
leaq -0x21(%rbp), %rdx
movq %r15, %rdi
callq 0xc1b0
movslq %r14d, %rsi
addq %r12, %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1a6d8
leaq -0x48(%rbp), %rdi
callq 0xc9a0
jmp 0x1a617
cmpq $0x0, 0x20(%rbx)
jne 0x1a627
leaq 0x18(%rbx), %rdi
callq 0xc8f0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13ba8(%rip), %rdi     # 0x2e1d6
leaq 0x13bc7(%rip), %rsi     # 0x2e1fc
leaq 0x13bf2(%rip), %rcx     # 0x2e22e
pushq $0x17
popq %rdx
callq 0xc350
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./boost/token_functions.hpp
// Function: bool boost::escaped_list_separator<char, std::char_traits<char>>::operator()<__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>>>(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<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>>&)
bool operator()(InputIterator& next,InputIterator end,Token& tok) {
      bool bInQuote = false;
      tok = Token();

      if (next == end) {
        if (last_) {
          last_ = false;
          return true;
        }
        else
          return false;
      }
      last_ = false;
      for (;next != end;++next) {
        if (is_escape(*next)) {
          do_escape(next,end,tok);
        }
        else if (is_c(*next)) {
          if (!bInQuote) {
            // If we are not in quote, then we are done
            ++next;
            // The last character was a c, that means there is
            // 1 more blank field
            last_ = true;
            return true;
          }
          else tok+=*next;
        }
        else if (is_quote(*next)) {
          bInQuote=!bInQuote;
        }
        else {
          tok += *next;
        }
      }
      return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x48(%rbp), %r13
movq %rcx, %rdi
movq %r13, %rsi
callq 0xc5a0
movq %r13, %rdi
callq 0xc9a0
movq (%r14), %rax
cmpq %r12, %rax
je 0x1b120
movb $0x0, 0x60(%rbx)
xorl %r13d, %r13d
cmpq %r12, %rax
je 0x1b135
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x1b146
testb %al, %al
je 0x1b0c4
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x1b174
jmp 0x1b112
movq (%r14), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x1b296
movq (%r14), %rcx
testb %al, %al
je 0x1b0ef
testb $0x1, %r13b
je 0x1b12a
movsbl (%rcx), %esi
movq %r15, %rdi
callq 0xc430
movb $0x1, %r13b
jmp 0x1b112
movsbl (%rcx), %esi
movq %rbx, %rdi
callq 0x1b2c6
testb %al, %al
je 0x1b104
xorb $0x1, %r13b
jmp 0x1b112
movq (%r14), %rax
movsbl (%rax), %esi
movq %r15, %rdi
callq 0xc430
movq (%r14), %rax
incq %rax
movq %rax, (%r14)
jmp 0x1b099
xorl %eax, %eax
cmpb $0x0, 0x60(%rbx)
jne 0x1b132
jmp 0x1b137
incq %rcx
movq %rcx, (%r14)
movb $0x1, %al
movb %al, 0x60(%rbx)
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./boost/token_functions.hpp
// Function: void boost::escaped_list_separator<char, std::char_traits<char>>::do_escape<__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>>>(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<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>>&)
void do_escape(iterator& next,iterator end,Token& tok) {
      if (++next == end)
        BOOST_THROW_EXCEPTION(escaped_list_error(std::string("cannot end with escape")));
      if (Traits::eq(*next,'n')) {
        tok+='\n';
        return;
      }
      else if (is_quote(*next)) {
        tok+=*next;
        return;
      }
      else if (is_c(*next)) {
        tok+=*next;
        return;
      }
      else if (is_escape(*next)) {
        tok+=*next;
        return;
      }
      else
        BOOST_THROW_EXCEPTION(escaped_list_error(std::string("unknown escape sequence")));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq (%rsi), %rax
incq %rax
movq %rax, (%rsi)
cmpq %rdx, %rax
je 0x1b1ee
movq %rcx, %rbx
movb (%rax), %al
movb $0xa, %cl
cmpb $0x6e, %al
je 0x1b1d9
movq %rsi, %r14
movq %rdi, %r15
movsbl %al, %esi
callq 0x1b2c6
movq (%r14), %rcx
movb (%rcx), %cl
testb %al, %al
jne 0x1b1d9
movsbl %cl, %esi
movq %r15, %rdi
callq 0x1b296
movq (%r14), %rcx
movb (%rcx), %cl
testb %al, %al
jne 0x1b1d9
movsbl %cl, %esi
movq %r15, %rdi
callq 0x1b146
testb %al, %al
je 0x1b22b
movq (%r14), %rax
movb (%rax), %cl
movsbl %cl, %esi
movq %rbx, %rdi
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc430
leaq 0x1314d(%rip), %rsi     # 0x2e342
leaq -0x50(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0xc1b0
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1b3ca
leaq 0x13143(%rip), %rsi     # 0x2e359
leaq 0x1322f(%rip), %rdx     # 0x2e44c
leaq -0x30(%rbp), %rdi
movl $0x81, %ecx
callq 0x1b378
leaq 0x13236(%rip), %rsi     # 0x2e468
leaq -0x50(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0xc1b0
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1b3ca
leaq 0x13106(%rip), %rsi     # 0x2e359
leaq 0x131f2(%rip), %rdx     # 0x2e44c
leaq -0x30(%rbp), %rdi
movl $0x93, %ecx
callq 0x1b378
jmp 0x1b26e
jmp 0x1b27c
jmp 0x1b28a
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xc540
jmp 0x1b27f
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xc9a0
jmp 0x1b28d
movq %rax, %rbx
movq %rbx, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
cmpq $0x0, (%rsi)
jne 0x1c5b7
movq (%rdx), %rbx
movq 0x8(%rdx), %r15
movq %r15, %rax
subq %rbx, %rax
cmpq $0x21, %rax
jae 0x1c5ce
movq %rsi, %r14
cmpq %r15, %rbx
je 0x1c574
leaq -0xd8(%rbp), %rdi
movq %rbx, %rsi
callq 0xc660
jmp 0x1c58b
leaq 0x10907(%rip), %rsi     # 0x2ce82
leaq -0xd8(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0xc1b0
leaq -0xd8(%rbp), %rsi
movq %r14, %rdi
callq 0x1db7c
leaq -0xd8(%rbp), %rdi
callq 0xc9a0
cmpq %r15, %rbx
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0xd8(%rbp), %rbx
movq %rbx, %rdi
callq 0x1d982
movq %rbx, %rdi
callq 0x1d8fe
leaq -0xd8(%rbp), %rbx
movq %rbx, %rdi
callq 0x1dac0
movq %rbx, %rdi
callq 0x1da3d
movq %rax, %r14
leaq -0xd8(%rbp), %rdi
callq 0xc9a0
jmp 0x1c5f9
movq %rax, %r14
cmpq %r15, %rbx
jmp 0x1c60f
jmp 0x1c600
movq %rax, %r14
leaq -0xd8(%rbp), %rdi
callq 0xee62
movq %r14, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc4e0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1dbba
leaq -0x11(%rbp), %rsi
movb $0x0, (%rsi)
movq %rbx, %rdi
callq 0x1dc2a
movb $0x1, 0x8b(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xc4a0
movq %r14, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1c816
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1dc9f
leaq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xc660
xorl %r14d, %r14d
movq -0x30(%rbp), %rax
cmpq %rax, %r14
jae 0x1c6d3
movq -0x38(%rbp), %r15
movsbl (%r15,%r14), %edi
callq 0xc6f0
movb %al, (%r15,%r14)
incq %r14
jmp 0x1c6b3
testq %rax, %rax
je 0x1c728
leaq 0xff28(%rip), %rsi      # 0x2c607
leaq -0x38(%rbp), %rdi
callq 0xef68
testb %al, %al
jne 0x1c728
leaq 0x12679(%rip), %rsi     # 0x2ed6c
leaq -0x38(%rbp), %rdi
callq 0xef68
testb %al, %al
jne 0x1c728
leaq 0x10cb0(%rip), %rsi     # 0x2d3b7
leaq -0x38(%rbp), %rdi
callq 0xef68
testb %al, %al
jne 0x1c728
leaq 0x12655(%rip), %rsi     # 0x2ed70
leaq -0x38(%rbp), %rdi
callq 0xef68
testb %al, %al
je 0x1c766
pushq $0x10
popq %rdi
callq 0xc4e0
leaq 0x2b5a1(%rip), %rcx     # 0x47cd8
movq %rcx, (%rax)
movb $0x1, 0x8(%rax)
movq (%rbx), %rdi
movq %rax, (%rbx)
testq %rdi, %rdi
je 0x1c74f
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x38(%rbp), %rdi
callq 0xc9a0
addq $0xe8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12608(%rip), %rsi     # 0x2ed75
leaq -0x38(%rbp), %rdi
callq 0xef68
testb %al, %al
jne 0x1c7b6
leaq 0x125f8(%rip), %rsi     # 0x2ed79
leaq -0x38(%rbp), %rdi
callq 0xef68
testb %al, %al
jne 0x1c7b6
leaq 0x13d02(%rip), %rsi     # 0x30497
leaq -0x38(%rbp), %rdi
callq 0xef68
testb %al, %al
jne 0x1c7b6
leaq 0x125d3(%rip), %rsi     # 0x2ed7c
leaq -0x38(%rbp), %rdi
callq 0xef68
testb %al, %al
je 0x1c7d1
pushq $0x10
popq %rdi
callq 0xc4e0
leaq 0x2b513(%rip), %rcx     # 0x47cd8
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
jmp 0x1c73e
leaq -0xf8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1cd20
leaq -0xf8(%rbp), %rdi
callq 0x1de2e
movq %rax, %rbx
leaq -0xf8(%rbp), %rdi
callq 0xee62
jmp 0x1c805
jmp 0x1c802
jmp 0x1c802
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/value_semantic.cpp
// Function: boost::program_options::validate(boost::any&, std::vector<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>, std::allocator<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>>> const&, bool*, int)
BOOST_PROGRAM_OPTIONS_DECL 
    void validate(any& v, const vector<wstring>& xs, bool*, int)
    {
        check_first_occurrence(v);
        wstring s(get_single_string(xs, true));

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1c816
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1deb1
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xc440
movq (%r14), %r15
movq 0x8(%r14), %r14
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x1c8b8
movl (%r15,%r12,4), %edi
callq 0xc6f0
movl %eax, (%r15,%r12,4)
incq %r12
jmp 0x1c8a1
testq %r14, %r14
je 0x1c90d
leaq 0x127b4(%rip), %rsi     # 0x2f078
leaq -0x40(%rbp), %rdi
callq 0x1e040
testb %al, %al
jne 0x1c90d
leaq 0x127ac(%rip), %rsi     # 0x2f084
leaq -0x40(%rbp), %rdi
callq 0x1e040
testb %al, %al
jne 0x1c90d
leaq 0x127a8(%rip), %rsi     # 0x2f094
leaq -0x40(%rbp), %rdi
callq 0x1e040
testb %al, %al
jne 0x1c90d
leaq 0x1279c(%rip), %rsi     # 0x2f09c
leaq -0x40(%rbp), %rdi
callq 0x1e040
testb %al, %al
je 0x1c94d
pushq $0x10
popq %rdi
callq 0xc4e0
leaq 0x2b3bc(%rip), %rcx     # 0x47cd8
movq %rcx, (%rax)
movb $0x1, 0x8(%rax)
movq (%rbx), %rdi
movq %rax, (%rbx)
testq %rdi, %rdi
je 0x1c934
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x40(%rbp), %rdi
callq 0xc990
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1275c(%rip), %rsi     # 0x2f0b0
leaq -0x40(%rbp), %rdi
callq 0x1e040
testb %al, %al
jne 0x1c99d
leaq 0x12758(%rip), %rsi     # 0x2f0c0
leaq -0x40(%rbp), %rdi
callq 0x1e040
testb %al, %al
jne 0x1c99d
leaq 0x12750(%rip), %rsi     # 0x2f0cc
leaq -0x40(%rbp), %rdi
callq 0x1e040
testb %al, %al
jne 0x1c99d
leaq 0x12744(%rip), %rsi     # 0x2f0d4
leaq -0x40(%rbp), %rdi
callq 0x1e040
testb %al, %al
je 0x1c9b8
pushq $0x10
popq %rdi
callq 0xc4e0
leaq 0x2b32c(%rip), %rcx     # 0x47cd8
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
jmp 0x1c923
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1ca18
leaq -0x120(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1cd20
leaq -0x120(%rbp), %rdi
callq 0x1de2e
movq %rax, %rbx
leaq -0x120(%rbp), %rdi
callq 0xee62
jmp 0x1c9f5
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xc9a0
jmp 0x1ca07
jmp 0x1ca04
jmp 0x1ca04
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xc990
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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 (%r14), %rsi
movq 0x8(%r14), %rcx
movq %r15, %rdi
xorl %edx, %edx
callq 0xc840
cmpq $-0x1, %rax
je 0x1d165
movq 0x8(%r14), %rdx
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0xc190
jmp 0x1d13a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x10(%rsi), %eax
cmpq $0x8, %rax
ja 0x1d1a4
leaq 0x11aa2(%rip), %rcx     # 0x2ec30
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xfce4(%rip), %rsi      # 0x2ce82
leaq -0x11(%rbp), %rdx
jmp 0x1d1dd
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x1d1f1
leaq 0x101d5(%rip), %rsi     # 0x2d387
leaq -0x13(%rbp), %rdx
jmp 0x1d1dd
leaq 0x11e65(%rip), %rsi     # 0x2f024
leaq -0x14(%rbp), %rdx
jmp 0x1d1dd
leaq 0x101bb(%rip), %rsi     # 0x2d387
leaq -0x15(%rbp), %rdx
jmp 0x1d1dd
leaq 0x101ad(%rip), %rsi     # 0x2d386
leaq -0x12(%rbp), %rdx
movq %rbx, %rdi
callq 0xc1b0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xc250
movq %rax, %rbx
leaq 0x11bb2(%rip), %rsi     # 0x2edb5
movq %rax, %rdi
callq 0xc6d0
movq 0x2bdc6(%rip), %rsi     # 0x48fd8
movq 0x2bd97(%rip), %rdx     # 0x48fb0
movq %rbx, %rdi
callq 0xc810
movq %rax, %r14
movq %rbx, %rdi
callq 0xc390
movq %r14, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./boost/program_options/detail/value_semantic.hpp
// Function: std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const& boost::program_options::validators::get_single_string<wchar_t>(std::vector<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>, std::allocator<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>>> 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 %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movl %esi, %ebx
movq %rdi, %r14
movb 0x2b6ce(%rip), %al      # 0x49598
testb %al, %al
je 0x1df0c
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
cmpq $0x21, %rax
jae 0x1df64
cmpq $0x20, %rax
sete %dl
orb %bl, %dl
je 0x1dfb2
cmpq $0x20, %rax
leaq 0x2b67c(%rip), %rax     # 0x49578
cmoveq %rcx, %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2b685(%rip), %rdi     # 0x49598
callq 0xc890
testl %eax, %eax
je 0x1dece
leaq 0x2b665(%rip), %rax     # 0x49588
movq %rax, 0x2b64e(%rip)     # 0x49578
andq $0x0, 0x2b64e(%rip)     # 0x49580
leaq 0x2b63f(%rip), %rsi     # 0x49578
andl $0x0, 0x2b648(%rip)     # 0x49588
movq 0x2b031(%rip), %rdi     # 0x48f78
leaq 0x2b582(%rip), %rdx     # 0x494d0
callq 0xc450
leaq 0x2b63e(%rip), %rdi     # 0x49598
callq 0xc330
jmp 0x1dece
leaq 0xef17(%rip), %rsi      # 0x2ce82
leaq -0x58(%rbp), %rdi
leaq -0x12(%rbp), %rdx
callq 0xc1b0
leaq 0xef03(%rip), %rsi      # 0x2ce82
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0xc1b0
leaq -0x118(%rbp), %rdi
pushq $0x1e
popq %rsi
leaq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rcx
xorl %r8d, %r8d
callq 0x1fac2
leaq -0x118(%rbp), %rdi
callq 0x1fa3e
leaq 0xeec9(%rip), %rsi      # 0x2ce82
leaq -0x58(%rbp), %rdi
leaq -0x12(%rbp), %rdx
callq 0xc1b0
leaq 0xeeb5(%rip), %rsi      # 0x2ce82
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0xc1b0
leaq -0x118(%rbp), %rdi
pushq $0x1f
popq %rsi
leaq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rcx
xorl %r8d, %r8d
callq 0x1fac2
leaq -0x118(%rbp), %rdi
callq 0x1fa3e
jmp 0x1e004
jmp 0x1e015
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0xee62
jmp 0x1e018
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc9a0
jmp 0x1e028
jmp 0x1e025
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xc9a0
jmp 0x1e038
jmp 0x1e035
movq %rax, %rbx
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./boost/program_options/detail/value_semantic.hpp
// Function: boost::program_options::typed_value<bool, char>::name[abi:cxx11]() const
std::string
    typed_value<T, charT>::name() const
    {
        std::string const& var = (m_value_name.empty() ? arg : m_value_name);
        if (!m_implicit_value.empty() && !m_implicit_value_as_text.empty()) {
            std::string msg = "[=" + var + "(=" + m_implicit_value_as_text + ")]";
            if (!m_default_value.empty() && !m_default_value_as_text.empty())
                msg += " (=" + m_default_value_as_text + ")";
            return msg;
        }
        else if (!m_default_value.empty() && !m_default_value_as_text.empty()) {
            return var + " (=" + m_default_value_as_text + ")";
        } else {
            return var;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rcx
cmpq $0x0, 0x20(%rsi)
leaq 0x2a53f(%rip), %rax     # 0x49530
cmovneq %rcx, %rax
cmpq $0x0, 0x60(%rsi)
je 0x1f0c2
cmpq $0x0, 0x70(%r14)
je 0x1f0c2
leaq 0x10014(%rip), %rsi     # 0x2f026
leaq -0x78(%rbp), %r15
movq %r15, %rdi
movq %rax, %rdx
callq 0x15d84
leaq 0x10005(%rip), %rdx     # 0x2f02d
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x12ae9
leaq 0x68(%r14), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x12b12
leaq 0xffdd(%rip), %rdx      # 0x2f029
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x12ae9
leaq -0x38(%rbp), %rdi
callq 0xc9a0
leaq -0x58(%rbp), %rdi
callq 0xc9a0
leaq -0x78(%rbp), %rdi
callq 0xc9a0
cmpq $0x0, 0x38(%r14)
je 0x1f12b
cmpq $0x0, 0x48(%r14)
je 0x1f12b
addq $0x40, %r14
leaq 0xff98(%rip), %rsi      # 0x2f02c
leaq -0x58(%rbp), %rdi
movq %r14, %rdx
callq 0x15d84
leaq 0x11786(%rip), %rdx     # 0x3082d
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x12ae9
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0xc910
jmp 0x1f10c
cmpq $0x0, 0x38(%r14)
je 0x1f120
cmpq $0x0, 0x48(%r14)
je 0x1f120
addq $0x40, %r14
leaq 0xff51(%rip), %rdx      # 0x2f02c
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1f376
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12b12
leaq 0x1172d(%rip), %rdx     # 0x3082d
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x12ae9
leaq -0x38(%rbp), %rdi
callq 0xc9a0
leaq -0x58(%rbp), %rdi
callq 0xc9a0
jmp 0x1f12b
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc660
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0xc9a0
jmp 0x1f14a
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0xc9a0
jmp 0x1f158
movq %rax, %r14
movq %rbx, %rdi
jmp 0x1f197
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0xc9a0
jmp 0x1f16e
movq %rax, %r14
leaq -0x58(%rbp), %rdi
jmp 0x1f197
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0xc9a0
jmp 0x1f185
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0xc9a0
jmp 0x1f193
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0xc9a0
movq %r14, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq 0x38(%rdi), %rbx
testq %rbx, %rbx
je 0x1f227
movq %rdi, %rax
addq $0x38, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1f3ae
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1f431
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
je 0x1f252
movb (%rax), %dl
movb %dl, (%rcx)
cmpq $0x0, 0x90(%rbx)
je 0x1f274
addq $0x90, %rbx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1f3e4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 const char* stl_type_index::raw_name() const BOOST_NOEXCEPT {
#ifdef _MSC_VER
    return data_->raw_name();
#else
    return data_->name();
#endif
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rax), %rax
xorl %edi, %edi
cmpb $0x2a, (%rax)
sete %dil
addq %rax, %rdi
movq (%rsi), %rax
movq 0x8(%rax), %rax
xorl %esi, %esi
cmpb $0x2a, (%rax)
sete %sil
addq %rax, %rsi
cmpq %rsi, %rdi
je 0x1f4dd
pushq %rbp
movq %rsp, %rbp
callq 0xc680
testl %eax, %eax
sete %al
popq %rbp
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq -0x18(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x1f648
testb %al, %al
jne 0x1f588
callq 0x1f602
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0xc660
leaq -0x28(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x30, %rsp
leaq -0x17(%rbp), %rax
movq %rax, 0x7(%rax)
movb (%rdi), %cl
orb $0x30, %cl
movb %cl, (%rax)
leaq -0x16(%rbp), %rcx
movq %rcx, 0xe(%rcx)
leaq -0x28(%rbp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
callq 0x1f67e
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq 0x88(%rdi), %rbx
leaq 0x78(%rdi), %r13
leaq 0x10(%rdi), %r15
leaq 0x18(%rdi), %r12
cmpq %r13, %rbx
je 0x20c4e
leaq 0x20(%rbx), %rsi
movq %r15, %rdi
callq 0x21820
cmpq %r12, %rax
je 0x20c93
cmpq $0x0, 0x40(%rax)
je 0x20c93
movq %rbx, %rdi
callq 0xc550
movq %rax, %rbx
jmp 0x20c24
movq 0x28(%r14), %rbx
cmpq %r12, %rbx
je 0x20c81
cmpq $0x0, 0x50(%rbx)
je 0x20c74
leaq 0x50(%rbx), %rdi
callq 0xeba4
leaq 0x40(%rbx), %rsi
movq (%rax), %rcx
movq %rax, %rdi
callq *0x40(%rcx)
movq %rbx, %rdi
callq 0xc360
movq %rax, %rbx
jmp 0x20c52
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x40, %rbx
leaq -0xe0(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x210c4
movq %r14, %rdi
callq 0x21040
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0xee62
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20d1d
movq 0x8(%r15), %rdi
testq %rdi, %rdi
jne 0x20cff
cmpb $0x1, 0x8(%rbx)
jne 0x20d40
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x20d40
movq %r14, %rsi
callq 0x20cf2
cmpq $0x0, (%rax)
je 0x20d40
cmpb $0x1, 0x8(%rax)
jne 0x20d43
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x28749(%rip), %al      # 0x495c0
testb %al, %al
je 0x20ea2
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x216ee
addq $0x18, %rbx
leaq 0x40(%rax), %rcx
cmpq %rbx, %rax
leaq 0x28707(%rip), %rax     # 0x495a0
cmovneq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28717(%rip), %rdi     # 0x495c0
callq 0xc890
testl %eax, %eax
je 0x20e7b
andq $0x0, 0x286e6(%rip)     # 0x495a0
leaq 0x286df(%rip), %rsi     # 0x495a0
movb $0x0, 0x286e0(%rip)     # 0x495a8
xorps %xmm0, %xmm0
movups %xmm0, 0x286de(%rip)    # 0x495b0
leaq 0xdb(%rip), %rdi        # 0x20fb4
leaq 0x285f0(%rip), %rdx     # 0x494d0
callq 0xc450
leaq 0x286d4(%rip), %rdi     # 0x495c0
callq 0xc330
jmp 0x20e7b
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpl $0x4, %edx
jae 0x21c65
movl %edx, %eax
leaq 0xddc0(%rip), %rcx      # 0x2fa1c
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmp 0x21c6c
leaq 0xd349(%rip), %rsi      # 0x2efb5
movq %rbx, %rdi
callq 0xc8f0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xc9a0
movq %r14, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x224cc
cmpl $0x0, (%rbx)
je 0x227c5
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %eax
je 0x22804
cmpl $0x3, %eax
je 0x227ec
cmpl $0x4, %eax
jne 0x2281e
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22be1
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2282f
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22971
callq 0x2761f
movl $0x26, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x227ba