LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/cmdline.cpp
// Function: boost::program_options::detail::cmdline::parse_dos_option(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>>>>&)
vector<option> 
    cmdline::parse_dos_option(vector<string>& args)
    {
        vector<option> result;
        const string& tok = args[0];
        if (tok.size() >= 2 && tok[0] == '/')
        {   
            string name = "-" + tok.substr(1,1);
            string adjacent = tok.substr(2);

            option opt;
            opt.string_key = name;
            if (!adjacent.empty())
                opt.value.push_back(adjacent);
            opt.original_tokens.push_back(tok);
            result.push_back(opt);
            args.erase(args.begin());
        }
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq (%rdx), %r15
cmpq $0x2, 0x8(%r15)
jb 0xe11f
movq (%r15), %rax
cmpb $0x2f, (%rax)
jne 0xe11f
movq %rdx, %r14
leaq -0xb8(%rbp), %rdi
pushq $0x1
popq %rcx
movq %r15, %rsi
movq %rcx, %rdx
callq 0xc4f0
leaq 0x1f32c(%rip), %rsi     # 0x2d387
leaq -0x58(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
callq 0xef3a
leaq -0xb8(%rbp), %rdi
callq 0xc9a0
leaq -0x38(%rbp), %rdi
pushq $0x2
popq %rdx
pushq $-0x1
popq %rcx
movq %r15, %rsi
callq 0xc4f0
leaq -0xa8(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
orl $-0x1, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
andw $0x0, 0x48(%rax)
leaq -0xb8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xc2b0
cmpq $0x0, -0x30(%rbp)
je 0xe0db
leaq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xeaf4
leaq -0x78(%rbp), %rdi
movq %r15, %rsi
callq 0xeaf4
leaq -0xb8(%rbp), %rsi
movq %rbx, %rdi
callq 0xea8c
movq (%r14), %rsi
movq %r14, %rdi
callq 0xeb30
leaq -0xb8(%rbp), %rdi
callq 0xeb3a
leaq -0x38(%rbp), %rdi
callq 0xc9a0
leaq -0x58(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe148
movq %rax, %r14
jmp 0xe160
movq %rax, %r14
leaq -0xb8(%rbp), %rdi
jmp 0xe164
movq %rax, %r14
jmp 0xe169
movq %rax, %r14
leaq -0xb8(%rbp), %rdi
callq 0xeb3a
leaq -0x38(%rbp), %rdi
callq 0xc9a0
leaq -0x58(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xeac8
movq %r14, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/cmdline.cpp
// Function: boost::program_options::detail::cmdline::parse_terminator(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>>>>&)
vector<option> 
    cmdline::parse_terminator(vector<string>& args)
    {
        vector<option> result;
        const string& tok = args[0];
        if (tok == "--")
        {
            for(unsigned i = 1; i < args.size(); ++i)
            {
                option opt;
                opt.value.push_back(args[i]);
                opt.original_tokens.push_back(args[i]);
                opt.position_key = INT_MAX;
                result.push_back(opt);
            }
            args.clear();
        }
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
andq $0x0, 0x10(%rdi)
movq (%rdx), %rdi
leaq 0x1f1df(%rip), %rsi     # 0x2d386
callq 0xef68
testb %al, %al
je 0xe254
leaq -0x68(%rbp), %r15
pushq $0x1
popq %rbx
leaq -0x90(%rbp), %r13
movl %ebx, %ebx
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rbx, %rax
jbe 0xe24c
leaq -0x80(%rbp), %rax
movq %rax, -0x90(%rbp)
andq $0x0, -0x88(%rbp)
movb $0x0, -0x80(%rbp)
orl $-0x1, -0x70(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
movups %xmm0, 0x10(%r15)
andw $0x0, 0x30(%r15)
movups %xmm0, (%r15)
movq %rbx, %r12
shlq $0x5, %r12
addq %r12, %rsi
movq %r15, %rdi
callq 0xeaf4
addq (%r14), %r12
leaq -0x50(%rbp), %rdi
movq %r12, %rsi
callq 0xeaf4
movl $0x7fffffff, -0x70(%rbp) # imm = 0x7FFFFFFF
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0xea8c
movq %r13, %rdi
callq 0xeb3a
incl %ebx
jmp 0xe1c2
movq %r14, %rdi
callq 0xef78
movq -0x30(%rbp), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x90(%rbp), %rdi
callq 0xeb3a
movq -0x30(%rbp), %rdi
callq 0xeac8
movq %r14, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./boost/throw_exception.hpp
// Function: void boost::throw_exception<boost::bad_lexical_cast>(boost::bad_lexical_cast const&)
BOOST_NORETURN inline void throw_exception( E const & e )
{
    //All boost exceptions are required to derive from std::exception,
    //to ensure compatibility with BOOST_NO_EXCEPTIONS.
    throw_exception_assert_compatibility(e);

#ifndef BOOST_EXCEPTION_DISABLE
    throw enable_current_exception(enable_error_info(e));
#else
    throw e;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
pushq $0x48
popq %rdi
callq 0xc250
movq %rax, %rbx
movups 0x8(%r14), %xmm0
leaq -0x58(%rbp), %rsi
movups %xmm0, 0x8(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsi)
andq $0x0, 0x30(%rsi)
orl $-0x1, 0x38(%rsi)
leaq 0x2877f(%rip), %rax     # 0x47e70
movq %rax, (%rsi)
leaq 0x2879d(%rip), %rax     # 0x47e98
movq %rax, 0x18(%rsi)
movb $0x1, %r15b
movq %rbx, %rdi
callq 0x1f76e
xorl %r15d, %r15d
leaq 0x2866c(%rip), %rsi     # 0x47d80
leaq 0x29(%rip), %rdx        # 0x1f744
movq %rbx, %rdi
callq 0xc810
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x1f74e
testb %r15b, %r15b
je 0x1f73c
movq %rbx, %rdi
callq 0xc390
movq %r14, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./boost/function/function_template.hpp
// Function: 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>>>::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
result_type operator()(BOOST_FUNCTION_PARMS) const
    {
      if (this->empty())
        boost::throw_exception(bad_function_call());

      return get_vtable()->invoker
               (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq (%rsi), %rax
testq %rax, %rax
je 0x18bd5
movq %rsi, %r14
movq %rdi, %rbx
andq $-0x2, %rax
movq 0x8(%rax), %r12
addq $0x8, %r14
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0xc5f0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *%r12
leaq -0x50(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x1086c
movq %rbx, %rdi
callq 0x107f7
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xc9a0
jmp 0x18c03
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xc540
movq %rbx, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./boost/function/function_template.hpp
// Function: boost::function1<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::operator=(boost::function1<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&> const&)
BOOST_FUNCTION_FUNCTION& operator=(const BOOST_FUNCTION_FUNCTION& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      BOOST_TRY {
        this->assign_to_own(f);
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0xf01d
movq %rsi, %r14
movq %rbx, %rdi
callq 0xf9da
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12304
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0xc1d0
andq $0x0, (%rbx)
callq 0xc700
movq %rax, %rbx
callq 0xc7e0
movq %rbx, %rdi
callq 0xc850
movq %rax, %rdi
callq 0xeb96
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./boost/function/function_template.hpp
// Function: boost::function1<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::clear()
void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0xfa0d
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x1, %al
jne 0xfa03
movq (%rax), %rax
testq %rax, %rax
je 0xfa03
leaq 0x8(%rbx), %rdi
pushq $0x2
popq %rdx
movq %rdi, %rsi
callq *%rax
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./boost/function/function_template.hpp
// Function: boost::function1<std::vector<boost::program_options::basic_option<char>, std::allocator<boost::program_options::basic_option<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>>>>&>::assign_to_own(boost::function1<std::vector<boost::program_options::basic_option<char>, std::allocator<boost::program_options::basic_option<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&)
void assign_to_own(const BOOST_FUNCTION_FUNCTION& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x103dd
movq %rdi, %rax
movq %rcx, (%rdi)
testb $0x1, %cl
jne 0x103cd
movq (%rcx), %rcx
addq $0x8, %rsi
addq $0x8, %rax
movq %rsi, %rdi
movq %rax, %rsi
xorl %edx, %edx
popq %rbp
jmpq *%rcx
movq 0x18(%rsi), %rcx
movq %rcx, 0x18(%rax)
movups 0x8(%rsi), %xmm0
movups %xmm0, 0x8(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./boost/function/function_base.hpp
// Function: boost::detail::function::functor_manager_common<boost::_bi::bind_t<std::vector<boost::program_options::basic_option<char>, std::allocator<boost::program_options::basic_option<char>>>, boost::_mfi::mf1<std::vector<boost::program_options::basic_option<char>, std::allocator<boost::program_options::basic_option<char>>>, boost::program_options::detail::cmdline, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&>, boost::_bi::list2<boost::_bi::value<boost::program_options::detail::cmdline*>, boost::arg<1>>>>::manage_small(boost::detail::function::function_buffer const&, boost::detail::function::function_buffer&, boost::detail::function::functor_manager_operation_type)
static inline void
        manage_small(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op)
        {
          if (op == clone_functor_tag || op == move_functor_tag) {
            const functor_type* in_functor = 
              reinterpret_cast<const functor_type*>(&in_buffer.data);
            new (reinterpret_cast<void*>(&out_buffer.data)) functor_type(*in_functor);

            if (op == move_functor_tag) {
              functor_type* f = reinterpret_cast<functor_type*>(&in_buffer.data);
              (void)f; // suppress warning about the value of f not being used (MSVC)
              f->~Functor();
            }
          } else if (op == destroy_functor_tag) {
            // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
             functor_type* f = reinterpret_cast<functor_type*>(&out_buffer.data);
             (void)f; // suppress warning about the value of f not being used (MSVC)
             f->~Functor();
          } 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.data;
            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 %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, %edx
ja 0x10721
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
jmp 0x10766
cmpl $0x2, %edx
je 0x10766
cmpl $0x3, %edx
jne 0x10757
movq (%rbx), %rax
movq 0x8(%rax), %rax
xorl %edi, %edi
cmpb $0x2a, (%rax)
sete %dil
addq %rax, %rdi
leaq 0x1c22f(%rip), %rsi     # 0x2c974
callq 0xc680
xorl %ecx, %ecx
testl %eax, %eax
cmoveq %r14, %rcx
movq %rcx, (%rbx)
jmp 0x10766
leaq 0x35a72(%rip), %rax     # 0x461d0
movq %rax, (%rbx)
andw $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/config_file.cpp
// Function: boost::program_options::detail::common_config_file_iterator::common_config_file_iterator(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<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)
common_config_file_iterator::common_config_file_iterator(
        const std::set<std::string>& allowed_options,
        bool allow_unregistered)
    : allowed_options(allowed_options),
      m_allow_unregistered(allow_unregistered)
    {
        for(std::set<std::string>::const_iterator i = allowed_options.begin();
            i != allowed_options.end(); 
            ++i)
        {
            add_option(i->c_str());
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movb %al, 0x8(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movb %al, 0x20(%rdi)
orl $-0x1, 0x30(%rdi)
movl %edx, %r12d
movq %rsi, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
andw $0x0, 0x68(%rdi)
movups %xmm0, 0x58(%rdi)
leaq 0x34471(%rip), %rax     # 0x46800
movq %rax, (%rdi)
leaq 0x70(%rdi), %r14
movq %r14, %rdi
callq 0x12d48
leaq 0xa8(%rbx), %rax
andl $0x0, 0xa8(%rbx)
andq $0x0, 0xb0(%rbx)
movq %rax, 0xb8(%rbx)
movq %rax, 0xc0(%rbx)
andq $0x0, 0xc8(%rbx)
leaq 0xa0(%rbx), %rax
movq %rax, -0x30(%rbp)
leaq 0xd0(%rbx), %r13
leaq 0xe0(%rbx), %rax
movq %rax, 0xd0(%rbx)
andq $0x0, 0xd8(%rbx)
movb $0x0, 0xe0(%rbx)
movb %r12b, 0xf0(%rbx)
movq 0x18(%r15), %r12
addq $0x8, %r15
cmpq %r15, %r12
je 0x12427
movq 0x20(%r12), %rsi
movq %rbx, %rdi
callq 0x1246c
movq %r12, %rdi
callq 0xc550
movq %rax, %r12
jmp 0x12408
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x12457
movq %rax, %r15
movq %r13, %rdi
callq 0xc9a0
movq -0x30(%rbp), %rdi
callq 0x13024
movq %r14, %rdi
callq 0x13024
addq $0x10, %rbx
movq %rbx, %rdi
callq 0xeb3a
movq %r15, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/config_file.cpp
// Function: boost::program_options::detail::(anonymous namespace)::trim_ws(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string trim_ws(const string& s)
        {
            string::size_type n, n2;
            n = s.find_first_not_of(" \t\r\n");
            if (n == string::npos)
                return string();
            else {
                n2 = s.find_last_not_of(" \t\r\n");
                return s.substr(n, n2-n+1);
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1a4cb(%rip), %rsi     # 0x2ce7e
movq %r14, %rdi
xorl %edx, %edx
callq 0xc2c0
cmpq $-0x1, %rax
je 0x129ef
movq %rax, %r15
leaq 0x1a4b1(%rip), %rsi     # 0x2ce7e
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0xc880
subq %r15, %rax
leaq 0x1(%rax), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xc4f0
jmp 0x129ff
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/config_file.cpp
// Function: boost::program_options::detail::common_config_file_iterator::allowed_option(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool 
    common_config_file_iterator::allowed_option(const std::string& s) const
    {
        set<string>::const_iterator i = allowed_options.find(s);
        if (i != allowed_options.end())
            return true;        
        // If s is "pa" where "p" is allowed prefix then
        // lower_bound should find the element after "p". 
        // This depends on 'allowed_prefixes' invariant.
        i = allowed_prefixes.lower_bound(s);
        if (i != allowed_prefixes.begin() && s.find(*--i) == 0)
            return true;
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
addq $0x70, %rdi
callq 0x13b3e
leaq 0x78(%r15), %rcx
movb $0x1, %bl
cmpq %rcx, %rax
jne 0x12a67
leaq 0xa0(%r15), %rdi
movq %r14, %rsi
callq 0x13bc8
cmpq 0xb8(%r15), %rax
je 0x12a65
movq %rax, %rdi
callq 0xc2e0
leaq 0x20(%rax), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xc960
testq %rax, %rax
je 0x12a67
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./boost/bind/bind.hpp
// Function: std::codecvt_base::result boost::_bi::bind_t<std::codecvt_base::result, boost::_mfi::cmf7<std::codecvt_base::result, std::__codecvt_abstract_base<wchar_t, char, __mbstate_t>, __mbstate_t&, char const*, char const*, char const*&, wchar_t*, wchar_t*, wchar_t*&>, boost::_bi::list8<boost::_bi::value<std::codecvt<wchar_t, char, __mbstate_t> const*>, boost::arg<1>, boost::arg<2>, boost::arg<3>, boost::arg<4>, boost::arg<5>, boost::arg<6>, boost::arg<7>>>::operator()<__mbstate_t&, char const*&, char const*&, char const*&, wchar_t (&) [32], wchar_t*&, wchar_t*&>(__mbstate_t&, char const*&, char const*&, char const*&, wchar_t (&) [32], wchar_t*&, wchar_t*&)
result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
    {
        list7<
            typename list_add_cref<A1>::type,
            typename list_add_cref<A2>::type,
            typename list_add_cref<A3>::type,
            typename list_add_cref<A4>::type,
            typename list_add_cref<A5>::type,
            typename list_add_cref<A6>::type,
            typename list_add_cref<A7>::type
        > a( a1, a2, a3, a4, a5, a6, a7 );

        return l_( type<result_type>(), f_, a, 0 );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, %rax
movaps 0x10(%rbp), %xmm0
leaq -0x38(%rbp), %r10
movq %rsi, (%r10)
movq %rdx, 0x8(%r10)
movq %rcx, 0x10(%r10)
movq %r8, 0x18(%r10)
movq %r9, 0x20(%r10)
movups %xmm0, 0x28(%r10)
addq $0x10, %rdi
movq %rax, %rsi
movq %r10, %rdx
xorl %ecx, %ecx
callq 0x140c2
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/options_description.cpp
// Function: boost::program_options::option_description::set_name(char const*)
option_description&
    option_description::set_name(const char* _name)
    {
        std::string name(_name);
        string::size_type n = name.find(',');
        if (n != string::npos) {
            assert(n == name.size()-2);
            m_long_name = name.substr(0, n);
            m_short_name = '-' + name.substr(n+1,1);
        } else {
            m_long_name = name;
        }
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %r14
leaq -0x58(%rbp), %rdx
movq %r14, %rdi
callq 0xc1b0
pushq $0x2c
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xc610
cmpq $-0x1, %rax
je 0x14796
movq %rax, %r14
movq -0x30(%rbp), %rax
addq $-0x2, %rax
cmpq %rax, %r14
jne 0x147ba
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0xc4f0
leaq 0x28(%rbx), %rdi
leaq -0x58(%rbp), %r15
movq %r15, %rsi
callq 0xc5a0
movq %r15, %rdi
callq 0xc9a0
incq %r14
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
pushq $0x1
popq %rcx
movq %r14, %rdx
callq 0xc4f0
leaq -0x58(%rbp), %rdi
pushq $0x2d
popq %rsi
leaq -0x78(%rbp), %rdx
callq 0x15dfa
leaq 0x8(%rbx), %rdi
leaq -0x58(%rbp), %r14
movq %r14, %rsi
callq 0xc5a0
movq %r14, %rdi
callq 0xc9a0
leaq -0x78(%rbp), %rdi
callq 0xc9a0
jmp 0x147a3
leaq 0x28(%rbx), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc2b0
leaq -0x38(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18b25(%rip), %rdi     # 0x2d2e6
leaq 0x18b31(%rip), %rsi     # 0x2d2f9
leaq 0x18b5d(%rip), %rcx     # 0x2d32c
movl $0xb1, %edx
callq 0xc350
jmp 0x147eb
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0xc9a0
jmp 0x147ee
jmp 0x147eb
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/options_description.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> boost::program_options::(anonymous namespace)::tolower_<char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::basic_string< charT >  tolower_(const std::basic_string< charT >& str)
       {
           std::basic_string< charT > result;
           for (typename std::basic_string< charT >::size_type i = 0; i < str.size(); ++i)
           {
               result.append(1, static_cast< charT >(std::tolower(str[i])));
           }   
           return result;
       }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
xorl %r12d, %r12d
pushq $0x1
popq %r15
cmpq 0x8(%r14), %r12
jae 0x14b31
movq (%r14), %rax
movsbl (%rax,%r12), %edi
callq 0xc6f0
movsbl %al, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc520
incq %r12
jmp 0x14b0b
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xc9a0
movq %r14, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/options_description.cpp
// Function: boost::program_options::option_description::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const std::string& 
    option_description::key(const std::string& option) const
    {        
        if (!m_long_name.empty()) 
            if (m_long_name.find('*') != string::npos)
                // The '*' character means we're long_name
                // matches only part of the input. So, returning
                // long name will remove some of the information,
                // and we have to return the option as specified
                // in the source.
                return option;
            else
                return m_long_name;
        else
            return m_short_name;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpq $0x0, 0x30(%rdi)
je 0x14b7f
movq %rsi, %rbx
addq $0x28, %r14
pushq $0x2a
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xc610
cmpq $-0x1, %rax
cmoveq %r14, %rbx
jmp 0x14b86
addq $0x8, %r14
movq %r14, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/options_description.cpp
// Function: boost::program_options::option_description::canonical_display_name[abi:cxx11](int) const
std::string 
    option_description::canonical_display_name(int prefix_style) const
    {
        if (!m_long_name.empty()) 
        {
            if (prefix_style == command_line_style::allow_long)
                return "--" + m_long_name;
            if (prefix_style == command_line_style::allow_long_disguise)
                return "-" + m_long_name;
        }
        // sanity check: m_short_name[0] should be '-' or '/'
        if (m_short_name.length() == 2)
        {
            if (prefix_style == command_line_style::allow_slash_for_short)
                return string("/") + m_short_name[1];
            if (prefix_style == command_line_style::allow_dash_for_short)
                return string("-") + m_short_name[1];
        }
        if (!m_long_name.empty()) 
            return m_long_name;
        else
            return m_short_name;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %eax
movq %rdi, %rbx
leaq 0x28(%rsi), %rdx
movq 0x30(%rsi), %rcx
testq %rcx, %rcx
je 0x14bc0
cmpl $0x1000, %eax           # imm = 0x1000
je 0x14c0b
cmpl $0x1, %eax
jne 0x14bc0
leaq 0x187c8(%rip), %rsi     # 0x2d386
jmp 0x14c12
leaq 0x8(%rsi), %r14
cmpq $0x2, 0x10(%rsi)
jne 0x14bfe
cmpl $0x4, %eax
je 0x14c26
cmpl $0x8, %eax
jne 0x14bfe
leaq 0x1a448(%rip), %rsi     # 0x2f024
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0xc1b0
movq (%r14), %rax
movsbl 0x1(%rax), %edx
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0xef0e
jmp 0x14c4d
movq %rbx, %rdi
testq %rcx, %rcx
je 0x14c1c
movq %rdx, %rsi
jmp 0x14c1f
leaq 0x18775(%rip), %rsi     # 0x2d387
movq %rbx, %rdi
callq 0x15d84
jmp 0x14c56
movq %r14, %rsi
callq 0xc660
jmp 0x14c56
leaq 0x1875a(%rip), %rsi     # 0x2d387
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0xc1b0
movq (%r14), %rax
movsbl 0x1(%rax), %edx
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0xef0e
leaq -0x38(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x14c64
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc9a0
jmp 0x14c77
jmp 0x14c74
movq %rax, %rbx
movq %rbx, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/options_description.cpp
// Function: boost::program_options::option_description::format_name[abi:cxx11]() const
std::string 
    option_description::format_name() const
    {
        if (!m_short_name.empty())
        {
            return m_long_name.empty() 
                ? m_short_name 
                : string(m_short_name).append(" [ --").
                  append(m_long_name).append(" ]");
        }
        return string("--").append(m_long_name);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x10(%rsi)
je 0x14d2a
leaq 0x8(%r14), %rsi
movq 0x30(%r14), %r12
testq %r12, %r12
je 0x14d1b
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0xc660
leaq 0x18691(%rip), %rsi     # 0x2d383
movq %r15, %rdi
callq 0xc8e0
addq $0x28, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0xc910
leaq 0x18679(%rip), %rsi     # 0x2d389
movq %rax, %rdi
callq 0xc8e0
movq %rax, %rsi
movq %rbx, %rdi
callq 0xc660
testq %r12, %r12
jne 0x14d59
jmp 0x14d62
leaq 0x18655(%rip), %rsi     # 0x2d386
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0xc1b0
addq $0x28, %r14
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0xc910
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc660
leaq -0x48(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x14d8f
movq %rax, %rbx
testq %r12, %r12
jne 0x14d86
jmp 0x14d8f
jmp 0x14d83
movq %rax, %rbx
leaq -0x48(%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/options_description.cpp
// Function: boost::program_options::options_description::add(boost::program_options::options_description const&)
options_description&
    options_description::add(const options_description& desc)
    {
        shared_ptr<options_description> d(new options_description(desc));
        groups.push_back(d);

        for (size_t i = 0; i < desc.m_options.size(); ++i) {
            add(desc.m_options[i]);
            belong_to_group.back() = true;
        }

        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
movl $0x80, %edi
callq 0xc4e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x15ee6
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x15f6a
leaq 0x68(%rbx), %rdi
movq %r12, %rsi
callq 0x15f9e
leaq 0x40(%rbx), %r12
pushq $0x8
popq %r15
xorl %r13d, %r13d
movq 0x28(%r14), %rax
movq 0x30(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rcx, %r13
jae 0x151ee
movq -0x8(%rax,%r15), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax,%r15), %rax
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x151c5
lock
incl 0x8(%rax)
movq %rbx, %rdi
leaq -0x38(%rbp), %rsi
callq 0x14ed2
leaq -0x30(%rbp), %rdi
callq 0xf63a
movq %r12, %rdi
callq 0x15fda
orq %rdx, (%rax)
incq %r13
addq $0x10, %r15
jmp 0x15197
leaq -0x40(%rbp), %rdi
callq 0xf63a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15218
movq %rax, %rbx
movq %r15, %rdi
callq 0xc4a0
jmp 0x15232
movq %rax, %rbx
jmp 0x15229
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xf63a
leaq -0x40(%rbp), %rdi
callq 0xf63a
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/options_description.cpp
// Function: boost::program_options::options_description::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool, bool) const
const option_description&
    options_description::find(const std::string& name, 
                              bool approx,
                              bool long_ignore_case,
                              bool short_ignore_case) const
    {
        const option_description* d = find_nothrow(name, approx, 
                                       long_ignore_case, short_ignore_case);
        if (!d)
            boost::throw_exception(unknown_option());
        return *d;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xe8, %rsp
callq 0x152bc
testq %rax, %rax
je 0x15264
addq $0xe8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x17c17(%rip), %rsi     # 0x2ce82
leaq -0x30(%rbp), %rbx
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0xc1b0
leaq -0xe8(%rbp), %rdi
movq %rbx, %rsi
callq 0xed54
leaq -0xe8(%rbp), %rdi
callq 0xecd1
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0xee62
jmp 0x152aa
movq %rax, %rbx
leaq -0x30(%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/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
cmpq $0x0, 0x8(%rdi)
je 0x154fe
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc460
leaq 0x17f95(%rip), %rsi     # 0x2d48b
movq %rax, %rdi
callq 0xc4c0
testl %r15d, %r15d
jne 0x1550e
movq %r14, %rdi
callq 0x155ca
movl %eax, %r15d
leaq 0x40(%r14), %r12
xorl %r13d, %r13d
movl %r13d, %r13d
movq 0x30(%r14), %rax
subq 0x28(%r14), %rax
sarq $0x4, %rax
cmpq %r13, %rax
jbe 0x1556e
movq %r12, %rdi
movq %r13, %rsi
callq 0x16264
testb %al, %al
jne 0x15569
movq %r13, %rdi
shlq $0x4, %rdi
addq 0x28(%r14), %rdi
callq 0x1620c
movl 0x20(%r14), %ecx
movq %rbx, %rdi
movq %rax, %rsi
movl %r15d, %edx
callq 0x15774
movq %rbx, %rdi
leaq 0x1791d(%rip), %rsi     # 0x2ce81
callq 0xc4c0
incl %r13d
jmp 0x15515
xorl %eax, %eax
leaq 0x1790a(%rip), %r12     # 0x2ce81
movl %eax, %r13d
movq 0x70(%r14), %rax
subq 0x68(%r14), %rax
sarq $0x4, %rax
cmpq %r13, %rax
jbe 0x155ba
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc4c0
movq %r13, %rdi
shlq $0x4, %rdi
addq 0x68(%r14), %rdi
callq 0x16238
movq %rax, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x154c6
leal 0x1(%r13), %eax
jmp 0x15577
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b041
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 0x1b036
leaq 0x68(%rbx), %rsi
leaq 0x80(%rbx), %rcx
movq %rbx, %rdi
callq 0x1b042
jmp 0x1b038
xorl %eax, %eax
movb %al, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpq $0x0, 0x28(%rdi)
je 0x16c55
pushq %rbp
movq %rsp, %rbp
addq $0x20, %rdi
movsbl %sil, %esi
xorl %edx, %edx
callq 0xc610
cmpq $-0x1, %rax
setne %al
popq %rbp
retq
cmpb $0x1, 0x41(%rdi)
jne 0x16c64
movsbl %sil, %edi
jmp 0x16c9a
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpq $0x0, 0x8(%rdi)
je 0x16c87
pushq %rbp
movq %rsp, %rbp
movsbl %sil, %esi
xorl %edx, %edx
callq 0xc610
cmpq $-0x1, %rax
setne %al
popq %rbp
retq
cmpb $0x1, 0x40(%rdi)
jne 0x16c96
movsbl %sil, %edi
jmp 0x16caa
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, (%rdi)
pushq $0x18
popq %rdi
callq 0xc4e0
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x2fd68(%rip), %rcx     # 0x46d68
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
movq %rax, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0xc1d0
testq %rbx, %rbx
je 0x17025
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
callq 0xc700
movq %rax, %rbx
callq 0xc7e0
movq %rbx, %rdi
callq 0xc850
movq %rax, %rdi
callq 0xeb96
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/parsers.cpp
// Function: boost::program_options::parse_environment(boost::program_options::options_description const&, 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>>> const&)
BOOST_PROGRAM_OPTIONS_DECL parsed_options
    parse_environment(const options_description& desc, 
                      const function1<std::string, std::string>& name_mapper)
    {
        parsed_options result(&desc);
        
        for(environment_iterator i(environ), e; i != e; ++i) {
            string option_name = name_mapper(i->first);

            if (!option_name.empty()) {
                option n;
                n.string_key = option_name;
                n.value.push_back(i->second);
                result.options.push_back(n);
            }                
        }

        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movq %rdi, -0x30(%rbp)
andl $0x0, 0x20(%rdi)
movq %rdx, %r12
movq 0x31135(%rip), %rax     # 0x48fc8
movq (%rax), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x18b28
leaq -0x158(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq -0x138(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
movb $0x1, -0x38(%rax)
leaq -0xd8(%rbp), %r13
leaq -0x120(%rbp), %r15
leaq -0x50(%rbp), %r14
leaq -0x100(%rbp), %rbx
cmpb $0x1, -0xa0(%rbp)
jne 0x17efb
cmpb $0x1, -0x170(%rbp)
je 0x17fa7
movq %r15, %rdi
leaq -0x98(%rbp), %rsi
callq 0xc660
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x18b78
movq %r15, %rdi
callq 0xc9a0
cmpq $0x0, -0x48(%rbp)
je 0x17f8e
leaq -0xf0(%rbp), %rax
movq %rax, -0x100(%rbp)
andq $0x0, -0xf8(%rbp)
movb $0x0, -0xf0(%rbp)
orl $-0x1, -0xe0(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r13)
movups %xmm0, 0x10(%r13)
movups %xmm0, (%r13)
andw $0x0, 0x30(%r13)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc2b0
movq %r13, %rdi
leaq -0x78(%rbp), %rsi
callq 0xeaf4
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0xea8c
movq %rbx, %rdi
callq 0xeb3a
movq %r14, %rdi
callq 0xc9a0
leaq -0xa0(%rbp), %rdi
callq 0x19204
jmp 0x17ee5
leaq -0x168(%rbp), %rdi
callq 0xefd8
leaq -0x98(%rbp), %rdi
callq 0xefd8
movq -0x30(%rbp), %rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1801d
jmp 0x17fdc
movq %rax, %rbx
jmp 0x18005
movq %rax, %rbx
leaq -0x120(%rbp), %rdi
jmp 0x18000
movq %rax, %rbx
leaq -0x100(%rbp), %rdi
callq 0xeb3a
leaq -0x50(%rbp), %rdi
callq 0xc9a0
leaq -0x168(%rbp), %rdi
callq 0xefd8
leaq -0x98(%rbp), %rdi
callq 0xefd8
movq -0x30(%rbp), %rdi
callq 0xeac8
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x8
popq %rdx
movq %r13, %rdi
callq 0xc8a0
movq (%r13), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x220(%rbp,%rax)
jne 0x188e8
movzbl %r15b, %ecx
leaq -0x240(%rbp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x18111
leaq -0x240(%rbp), %rdi
callq 0xc100
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 0x1899a
leaq -0x38(%rbp), %rdi
callq 0x18924
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc860
jmp 0x18910
jmp 0x1890d
movq %rax, %rbx
leaq -0x240(%rbp), %rdi
callq 0xc100
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./boost/program_options/detail/config_file.hpp
// Function: boost::program_options::detail::basic_config_file_iterator<char>::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 %rbx
subq $0x48, %rsp
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %rbx
movb $0x0, (%rax)
addq $0xf8, %rdi
callq 0x18d2e
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0xc0c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %r15d
testb $0x5, %r15b
jne 0x18cfa
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x13d50
leaq -0x58(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc5a0
movq %r14, %rdi
callq 0xc9a0
testb $0x5, %r15b
sete %bl
leaq -0x38(%rbp), %rdi
callq 0xc9a0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18d19
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/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 0x192b2
leaq -0x58(%rbp), %r14
leaq -0x38(%rbp), %rdx
movq %r14, %rdi
callq 0xc1b0
pushq $0x3d
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xc610
cmpq $-0x1, %rax
je 0x192c0
movq %rax, %r14
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0xc4f0
leaq 0x8(%rbx), %rdi
leaq -0x38(%rbp), %r15
movq %r15, %rsi
callq 0xc5a0
movq %r15, %rdi
callq 0xc9a0
incq %r14
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
pushq $-0x1
popq %rcx
movq %r14, %rdx
callq 0xc4f0
leaq 0x28(%rbx), %rdi
leaq -0x38(%rbp), %r14
movq %r14, %rsi
callq 0xc5a0
movq %r14, %rdi
callq 0xc9a0
addq $0x8, 0x48(%rbx)
leaq -0x58(%rbp), %rdi
callq 0xc9a0
jmp 0x192b5
movb $0x1, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14c17(%rip), %rdi     # 0x2dede
leaq 0x14c1c(%rip), %rsi     # 0x2deea
leaq 0x14c46(%rip), %rcx     # 0x2df1b
pushq $0x28
popq %rdx
callq 0xc350
jmp 0x192df
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, (%rdi)
pushq $0x20
popq %rdi
callq 0xc4e0
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x2dab0(%rip), %rcx     # 0x470c0
movq %rcx, (%rax)
movq %r14, 0x10(%rax)
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0xc1d0
callq 0xc700
movq %rax, %rbx
callq 0xc7e0
movq %rbx, %rdi
callq 0xc850
movq %rax, %rdi
callq 0xeb96