LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ecx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsi), %rdx
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x15b94
cmpl $0x1000, %ecx           # imm = 0x1000
je 0x15c07
cmpl $0x1, %ecx
jne 0x15b94
leaq 0x1d81c(%rip), %rsi     # 0x333ae
jmp 0x15c0e
movq 0x10(%r14), %r8
cmpq $0x2, %r8
jne 0x15bed
cmpl $0x4, %ecx
je 0x15c32
cmpl $0x8, %ecx
jne 0x15bed
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1f499(%rip), %rsi     # 0x35054
leaq 0x1f493(%rip), %rdx     # 0x35055
leaq -0x38(%rbp), %rdi
callq 0xf97e
movq 0x8(%r14), %rax
movsbl 0x1(%rax), %r8d
leaq -0x38(%rbp), %rdi
movq 0x8(%rdi), %rsi
movl $0x1, %ecx
xorl %edx, %edx
callq 0xb850
jmp 0x15c6e
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testq %rax, %rax
je 0x15c1b
movq (%rdx), %rsi
addq %rsi, %rax
movq %rbx, %rdi
movq %rax, %rdx
jmp 0x15c28
leaq 0x1d7a1(%rip), %rsi     # 0x333af
movq %rbx, %rdi
callq 0x1739d
jmp 0x15cbb
movq 0x8(%r14), %rsi
addq %rsi, %r8
movq %rbx, %rdi
movq %r8, %rdx
callq 0xfa18
jmp 0x15cbb
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1d76e(%rip), %rsi     # 0x333af
leaq 0x1d768(%rip), %rdx     # 0x333b0
leaq -0x38(%rbp), %rdi
callq 0xf97e
movq 0x8(%r14), %rax
movsbl 0x1(%rax), %r8d
leaq -0x38(%rbp), %rdi
movq 0x8(%rdi), %rsi
movl $0x1, %ecx
xorl %edx, %edx
callq 0xb850
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x15c90
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x15c96
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x15cbb
callq 0xb430
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15ccb
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x15ce3
callq 0xb430
jmp 0x15ce3
jmp 0x15ce0
movq %rax, %rbx
movq %rbx, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rdx
testq %rdx, %rdx
je 0x15dec
leaq 0x8(%r14), %rax
movq 0x30(%r14), %r12
testq %r12, %r12
setne %r13b
je 0x15daa
movb %r13b, -0x29(%rbp)
leaq -0x40(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rsi
addq %rsi, %rdx
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0xfa18
movb $0x1, %r13b
leaq 0x1d62c(%rip), %rsi     # 0x333ab
movq %r15, %rdi
callq 0xb880
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
movq %rax, %rdi
callq 0xb160
leaq 0x1d613(%rip), %rsi     # 0x333b1
movq %rax, %rdi
callq 0xb880
movb -0x29(%rbp), %r13b
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xfa18
testq %r12, %r12
je 0x15dda
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15dda
callq 0xb430
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1d5b3(%rip), %rsi     # 0x333ae
leaq 0x1d5ae(%rip), %rdx     # 0x333b0
leaq -0x50(%rbp), %rdi
callq 0xf97e
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
leaq -0x50(%rbp), %rdi
callq 0xb160
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xfa18
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
jne 0x15dd5
jmp 0x15dda
movq %rax, %rbx
jmp 0x15e6d
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
jne 0x15e68
jmp 0x15e6d
movq %rax, %rbx
testb %r13b, %r13b
je 0x15e6d
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15e6d
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/program_options/src/options_description.cpp
// Function: boost::program_options::option_description::format_parameter[abi:cxx11]() const
std::string 
    option_description::format_parameter() const
    {
        if (m_value_semantic->max_tokens() != 0)
            return m_value_semantic->name();
        else
            return "";
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rsi), %rdi
testq %rdi, %rdi
je 0x15eca
movq %rsi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
testl %eax, %eax
je 0x15ea9
movq 0x68(%r14), %rsi
testq %rsi, %rsi
je 0x15eca
movq (%rsi), %rax
movq %rbx, %rdi
callq *(%rax)
jmp 0x15ec2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1cff3(%rip), %rdx     # 0x32eaa
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xf97e
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1c763(%rip), %rdi     # 0x32634
leaq 0x1c764(%rip), %rsi     # 0x3263c
leaq 0x1c77e(%rip), %rcx     # 0x3265d
movl $0x2af, %edx            # imm = 0x2AF
callq 0xb310
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x80, %edi
callq 0xb460
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x1750a
leaq -0x58(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x175b6
leaq 0x68(%rbx), %rdi
movq %r12, %rsi
callq 0x1760e
movq 0x28(%r14), %rax
cmpq %rax, 0x30(%r14)
je 0x163a9
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
leaq 0x28(%rbx), %rdx
movq %rdx, -0x48(%rbp)
leaq 0x40(%rbx), %rdx
movq %rdx, -0x40(%rbp)
movl $0x8, %r15d
xorl %r12d, %r12d
leaq 0x3f(%rcx), %r13
movq -0x8(%rax,%r15), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax,%r15), %rax
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x16325
lock
incl 0x8(%rax)
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x17480
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x174b6
leaq -0x30(%rbp), %rdi
callq 0xf5d6
movl 0x58(%rbx), %eax
leaq -0x1(%rax), %rcx
addq $0x3e, %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
sarq $0x6, %rax
shlq $0x3, %rax
addq 0x50(%rbx), %rax
movq %rcx, %rdx
andq %r13, %rdx
xorl %esi, %esi
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
cmpq %rdi, %rdx
setbe %sil
movl $0x1, %edx
shlq %cl, %rdx
orq %rdx, -0x8(%rax,%rsi,8)
incq %r12
movq 0x28(%r14), %rax
movq 0x30(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
addq $0x10, %r15
cmpq %rcx, %r12
jb 0x1630b
leaq -0x50(%rbp), %rdi
callq 0xf5d6
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x163e2
movq %rax, %rbx
movq %r15, %rdi
callq 0xb430
jmp 0x163eb
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xf5d6
leaq -0x50(%rbp), %rdi
callq 0xf5d6
movq %rbx, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0xe0, %rsp
callq 0x16486
testq %rax, %rax
je 0x16422
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1ca79(%rip), %rdx     # 0x32eaa
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xf97e
leaq -0xe8(%rbp), %rdi
movq %rbx, %rsi
callq 0xec2e
leaq -0xe8(%rbp), %rdi
callq 0xeb41
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0xedb6
jmp 0x1646f
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1647d
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/program_options/src/options_description.cpp
// Function: boost::program_options::options_description::print(std::ostream&, unsigned int) const
void 
    options_description::print(std::ostream& os, unsigned width) const
    {
        if (!m_caption.empty())
            os << m_caption << ":\n";

        if (!width)
            width = get_option_column_width();

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

            const option_description& opt = *m_options[i];

            format_one(os, opt, width, m_line_length);

            os << "\n";
        }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x16761
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xb500
leaq 0x1cd5f(%rip), %rsi     # 0x334b3
movl $0x2, %edx
movq %rax, %rdi
callq 0xb500
testl %r15d, %r15d
jne 0x16771
movq %r14, %rdi
callq 0x16890
movl %eax, %r15d
movq 0x28(%r14), %rax
cmpq %rax, 0x30(%r14)
je 0x167e9
movl $0x1, %r13d
xorl %ecx, %ecx
leaq 0x1c71f(%rip), %r12     # 0x32ea9
movq 0x40(%r14), %rdx
movq %rcx, %rsi
shrq $0x6, %rsi
movq (%rdx,%rsi,8), %rdx
btq %rcx, %rdx
jb 0x167cf
shlq $0x4, %rcx
movq (%rax,%rcx), %rsi
testq %rsi, %rsi
je 0x16871
movl 0x20(%r14), %ecx
movq %rbx, %rdi
movl %r15d, %edx
callq 0x16b04
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb500
movl %r13d, %ecx
movq 0x28(%r14), %rax
movq 0x30(%r14), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
incl %r13d
cmpq %rcx, %rdx
ja 0x1678a
movq 0x70(%r14), %rax
cmpq 0x68(%r14), %rax
je 0x16843
movl $0x1, %r13d
xorl %r12d, %r12d
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x1c69e(%rip), %rsi     # 0x32ea9
callq 0xb500
movq 0x68(%r14), %rax
shlq $0x4, %r12
movq (%rax,%r12), %rdi
testq %rdi, %rdi
je 0x16852
movq %rbx, %rsi
movl %r15d, %edx
callq 0x16722
movq 0x70(%r14), %rax
subq 0x68(%r14), %rax
movl %r13d, %r12d
sarq $0x4, %rax
incl %r13d
cmpq %r12, %rax
ja 0x167fc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bddb(%rip), %rdi     # 0x32634
leaq 0x1bddc(%rip), %rsi     # 0x3263c
leaq 0x1d23f(%rip), %rcx     # 0x33aa6
movl $0x2af, %edx            # imm = 0x2AF
callq 0xb310
leaq 0x1bdbc(%rip), %rdi     # 0x32634
leaq 0x1bdbd(%rip), %rsi     # 0x3263c
leaq 0x1d16e(%rip), %rcx     # 0x339f4
movl $0x2a8, %edx            # imm = 0x2A8
callq 0xb310
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1da3d
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 0x1da32
leaq 0x68(%rbx), %rsi
leaq 0x80(%rbx), %rcx
movq %rbx, %rdi
callq 0x1da3e
jmp 0x1da34
xorl %eax, %eax
movb %al, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./boost/token_functions.hpp
// Function: boost::char_separator<char, std::char_traits<char>>::is_dropped(char) const
bool is_dropped(Char E) const
    {
      if (m_dropped_delims.length())
        return m_dropped_delims.find(E) != string_type::npos;
      else if (m_use_isspace) {
        return Traits::isspace(E) != 0;
      } else
        return false;
    }

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

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

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

#else

        pi_ = new sp_counted_impl_p<Y>( p );

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

#endif
    }

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movl $0x0, (%r15)
movq 0xf8(%rdi), %r14
testq %r14, %r14
je 0x1abc1
movq (%r14), %rax
movq -0x18(%rax), %rax
movq 0xf0(%r14,%rax), %rdi
testq %rdi, %rdi
je 0x1abe0
movq %rsi, %rbx
movq (%rdi), %rax
movl $0xa, %esi
callq *0x50(%rax)
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0xb4c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %r12d
testb $0x5, %r12b
jne 0x1ab9f
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x14b48
leaq -0x60(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb560
movq (%r14), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x1ab9f
callq 0xb430
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x1abad
callq 0xb430
testb $0x5, %r12b
sete %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17a6c(%rip), %rdi     # 0x32634
leaq 0x17a6d(%rip), %rsi     # 0x3263c
leaq 0x19272(%rip), %rcx     # 0x33e48
movl $0x2a8, %edx            # imm = 0x2A8
callq 0xb310
callq 0xb580
jmp 0x1abe7
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x1abf8
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, (%rax)
je 0x1aef6
movq (%rax), %rsi
leaq -0x58(%rbp), %r14
leaq -0x38(%rbp), %rdx
movq %r14, %rdi
callq 0xb1c0
movq %r14, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0xb5c0
cmpq $-0x1, %rax
je 0x1af04
movq %rax, %r14
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0xb490
leaq 0x8(%rbx), %rdi
leaq -0x38(%rbp), %r15
movq %r15, %rsi
callq 0xb560
movq (%r15), %rdi
leaq -0x28(%rbp), %r15
cmpq %r15, %rdi
je 0x1aea6
callq 0xb430
incq %r14
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movq %r14, %rdx
movq $-0x1, %rcx
callq 0xb490
leaq 0x28(%rbx), %rdi
leaq -0x38(%rbp), %r14
movq %r14, %rsi
callq 0xb560
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x1aedd
callq 0xb430
addq $0x8, 0x48(%rbx)
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1aef9
callq 0xb430
jmp 0x1aef9
movb $0x1, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18ffb(%rip), %rdi     # 0x33f06
leaq 0x19000(%rip), %rsi     # 0x33f12
leaq 0x1902a(%rip), %rcx     # 0x33f43
movl $0x28, %edx
callq 0xb310
jmp 0x1af25
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1af3a
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./boost/smart_ptr/detail/shared_count.hpp
// Function: boost::detail::shared_count::shared_count<std::istream*, boost::program_options::detail::null_deleter>(std::istream*, boost::program_options::detail::null_deleter)
id_(shared_count_id)
#endif
    {
#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1200 )
        typedef Y* P;
#endif
#ifndef BOOST_NO_EXCEPTIONS

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

#else

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

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

#endif
    }

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

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0x1c7dc
movl %edx, %r15d
movq 0x8(%rbx), %r13
subq (%rbx), %r13
sarq $0x5, %r13
leaq -0x50(%rbp), %r12
leaq -0x29(%rbp), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0xb1c0
movslq %r15d, %rsi
addq %r13, %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1c8d4
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c804
callq 0xb430
jmp 0x1c804
movq 0x20(%rbx), %r15
testq %r15, %r15
jne 0x1c816
leaq 0x18(%rbx), %r12
movq %r14, %rdi
callq 0xb200
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0xb6f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x179e1(%rip), %rdi     # 0x341fe
leaq 0x17a00(%rip), %rsi     # 0x34224
leaq 0x17a2b(%rip), %rcx     # 0x34256
movl $0x17, %edx
callq 0xb310
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c84a
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/program_options/src/value_semantic.cpp
// Function: boost::program_options::untyped_value::xparse(boost::any&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const
void 
    untyped_value::xparse(boost::any& value_store,
                          const std::vector<std::string>& new_tokens) const
    {
        if (!value_store.empty()) 
            boost::throw_exception(
                multiple_occurrences());
        if (new_tokens.size() > 1)
            boost::throw_exception(multiple_values());
        value_store = new_tokens.empty() ? std::string("") : new_tokens.front();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
cmpq $0x0, (%rsi)
jne 0x1f718
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jae 0x1f72f
movq %rsi, %rbx
leaq -0xb8(%rbp), %r14
movq %r14, -0x10(%r14)
cmpq %rcx, %rax
je 0x1f6d6
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0xc8(%rbp), %rdi
callq 0xfa18
jmp 0x1f6ec
leaq 0x137cd(%rip), %rdx     # 0x32eaa
leaq -0xc8(%rbp), %rdi
movq %rdx, %rsi
callq 0xf97e
leaq -0xc8(%rbp), %rsi
movq %rbx, %rdi
callq 0x213e6
movq -0xc8(%rbp), %rdi
cmpq %r14, %rdi
je 0x1f70c
callq 0xb430
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0xc8(%rbp), %rbx
movq %rbx, %rdi
callq 0x210fa
movq %rbx, %rdi
callq 0x2100d
leaq -0xc8(%rbp), %rbx
movq %rbx, %rdi
callq 0x212e6
movq %rbx, %rdi
callq 0x211f9
movq %rax, %rbx
movq -0xc8(%rbp), %rdi
cmpq %r14, %rdi
je 0x1f772
callq 0xb430
jmp 0x1f772
movq %rax, %rbx
jmp 0x1f772
jmp 0x1f763
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0xedb6
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/program_options/src/value_semantic.cpp
// Function: boost::program_options::bool_switch(bool*)
BOOST_PROGRAM_OPTIONS_DECL typed_value<bool>*
    bool_switch(bool* v)
    {
        typed_value<bool>* r = new typed_value<bool>(v);
        r->default_value(0);
        r->zero_tokens();

        return r;
    }

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1f9f9
movq %r14, %rdi
movl $0x1, %esi
callq 0x2151f
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0xfa18
cmpq $0x0, 0x8(%r14)
je 0x1f968
xorl %r14d, %r14d
movq -0x40(%rbp), %r12
movsbl (%r12,%r14), %edi
callq 0xb670
movb %al, (%r12,%r14)
incq %r14
movq -0x38(%rbp), %rax
cmpq %rax, %r14
jb 0x1f87f
testq %rax, %rax
je 0x1f968
leaq 0x12d84(%rip), %rsi     # 0x32631
leaq -0x40(%rbp), %rdi
callq 0xb110
testl %eax, %eax
je 0x1f968
leaq 0x154d7(%rip), %rsi     # 0x34d9c
leaq -0x40(%rbp), %rdi
callq 0xb110
testl %eax, %eax
je 0x1f968
leaq 0x13b02(%rip), %rsi     # 0x333df
leaq -0x40(%rbp), %rdi
callq 0xb110
testl %eax, %eax
je 0x1f968
leaq 0x154af(%rip), %rsi     # 0x34da0
leaq -0x40(%rbp), %rdi
callq 0xb110
testl %eax, %eax
je 0x1f968
leaq 0x154a0(%rip), %rsi     # 0x34da5
leaq -0x40(%rbp), %rdi
callq 0xb110
testl %eax, %eax
je 0x1f94e
leaq 0x15490(%rip), %rsi     # 0x34da9
leaq -0x40(%rbp), %rdi
callq 0xb110
testl %eax, %eax
je 0x1f94e
leaq 0x16a90(%rip), %rsi     # 0x363bd
leaq -0x40(%rbp), %rdi
callq 0xb110
testl %eax, %eax
je 0x1f94e
leaq 0x1546b(%rip), %rsi     # 0x34dac
leaq -0x40(%rbp), %rdi
callq 0xb110
testl %eax, %eax
jne 0x1f9af
movl $0x10, %edi
callq 0xb460
leaq 0x2b4f9(%rip), %rcx     # 0x4ae58
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
jmp 0x1f980
movl $0x10, %edi
callq 0xb460
leaq 0x2b4df(%rip), %rcx     # 0x4ae58
movq %rcx, (%rax)
movb $0x1, 0x8(%rax)
movq (%rbx), %rdi
movq %rax, (%rbx)
testq %rdi, %rdi
je 0x1f991
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x1f99f
callq 0xb430
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x100(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1ffdc
leaq -0x100(%rbp), %rdi
callq 0x21687
movq %rax, %rbx
leaq -0x100(%rbp), %rdi
callq 0xedb6
jmp 0x1f9e3
jmp 0x1f9e0
jmp 0x1f9e0
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x1f9f1
callq 0xb430
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/program_options/src/value_semantic.cpp
// Function: boost::program_options::(anonymous namespace)::convert_value(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&)
std::string convert_value(const std::wstring& s)
        {
            try {
                return to_local_8_bit(s);
            }
            catch(const std::exception&) {
                return "<unrepresentable unicode string>";
            }
        }

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rsi), %eax
cmpq $0x8, %rax
ja 0x2059f
leaq 0x146e0(%rip), %rcx     # 0x34c60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x12913(%rip), %rdx     # 0x32eaa
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x205ec
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x205f9
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x12dfb(%rip), %rsi     # 0x333af
leaq 0x12df5(%rip), %rdx     # 0x333b0
jmp 0x205e9
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x14a89(%rip), %rsi     # 0x35054
leaq 0x14a83(%rip), %rdx     # 0x35055
jmp 0x205e9
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x12dcc(%rip), %rsi     # 0x333ae
leaq 0x12dc7(%rip), %rdx     # 0x333b0
movq %rbx, %rdi
callq 0xf97e
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0xb250
movq %rax, %rbx
leaq 0x147d8(%rip), %rsi     # 0x34de5
movq %rax, %rdi
callq 0xb650
movq 0x2b9bc(%rip), %rsi     # 0x4bfd8
movq 0x2b98d(%rip), %rdx     # 0x4bfb0
movq %rbx, %rdi
callq 0xb7b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xb360
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./boost/program_options/detail/value_semantic.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const& boost::program_options::validators::get_single_string<char>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, bool)
const std::basic_string<charT>& get_single_string(
            const std::vector<std::basic_string<charT> >& v, 
            bool allow_empty = false)
        {
            static std::basic_string<charT> empty;
            if (v.size() > 1)
                boost::throw_exception(validation_error(validation_error::multiple_values_not_allowed));
            else if (v.size() == 1)
                return v.front();
            else if (!allow_empty)
                boost::throw_exception(validation_error(validation_error::at_least_one_value_required));
            return empty;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %esi, %ebx
movq %rdi, %r14
movb 0x2affe(%rip), %al      # 0x4c538
testb %al, %al
je 0x2157a
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
cmpq $0x21, %rax
jae 0x21581
cmpq $0x20, %rax
sete %dl
orb %bl, %dl
je 0x215df
cmpq $0x20, %rax
leaq 0x2afb0(%rip), %rax     # 0x4c518
cmoveq %rcx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xbaa6
jmp 0x2153e
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1191a(%rip), %rdx     # 0x32eaa
leaq -0x58(%rbp), %rdi
movq %rdx, %rsi
callq 0xf97e
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x118ff(%rip), %rdx     # 0x32eaa
leaq -0x38(%rbp), %rdi
movq %rdx, %rsi
callq 0xf97e
leaq -0x118(%rbp), %rdi
leaq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rcx
movl $0x1e, %esi
xorl %r8d, %r8d
callq 0x236ec
leaq -0x118(%rbp), %rdi
callq 0x235e8
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x118bc(%rip), %rdx     # 0x32eaa
leaq -0x58(%rbp), %rdi
movq %rdx, %rsi
callq 0xf97e
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x118a1(%rip), %rdx     # 0x32eaa
leaq -0x38(%rbp), %rdi
movq %rdx, %rsi
callq 0xf97e
leaq -0x118(%rbp), %rdi
leaq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rcx
movl $0x1f, %esi
xorl %r8d, %r8d
callq 0x236ec
leaq -0x118(%rbp), %rdi
callq 0x235e8
jmp 0x21641
jmp 0x21652
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0xedb6
jmp 0x21655
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x2166a
callq 0xb430
jmp 0x2166a
jmp 0x21667
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x2167f
callq 0xb430
jmp 0x2167f
jmp 0x2167c
movq %rax, %rbx
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./boost/program_options/value_semantic.hpp
// Function: boost::program_options::typed_value<bool, char>::apply_default(boost::any&) const
virtual bool apply_default(boost::any& value_store) const
        {
            if (m_default_value.empty()) {
                return false;
            } else {
                value_store = m_default_value;
                return true;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x38(%rdi), %rbx
testq %rbx, %rbx
je 0x23191
movq %rsi, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%r14), %rdi
movq %rax, (%r14)
testq %rdi, %rdi
je 0x23191
movq (%rdi), %rax
callq *0x8(%rax)
testq %rbx, %rbx
setne %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x234ee
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
je 0x231ba
movb (%rax), %dl
movb %dl, (%rcx)
cmpq $0x0, 0x90(%rbx)
je 0x231dc
addq $0x90, %rbx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x23490
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop