LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x41907(%rip), %rsi     # 0x5fe5d
xorl %eax, %eax
movl %eax, %edx
callq 0xd330
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x1e575
movq -0x30(%rbp), %rdi
callq 0xd8f0
jmp 0x1e5ad
movq -0x10(%rbp), %rdi
leaq 0x418dd(%rip), %rsi     # 0x5fe5d
movq $-0x1, %rdx
callq 0xdb70
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
subq -0x18(%rbp), %rcx
addq $0x1, %rcx
callq 0xd650
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x70, %rdi
movq -0x18(%rbp), %rsi
callq 0x1ee80
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x70, %rdi
callq 0x1e7a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1e770
testb $0x1, %al
jne 0x1e60d
jmp 0x1e616
movb $0x1, -0x1(%rbp)
jmp 0x1e6ab
movq -0x40(%rbp), %rdi
addq $0xa0, %rdi
movq -0x18(%rbp), %rsi
callq 0x1eeb0
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0xa0, %rdi
callq 0x1e740
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1e770
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0x1e665
jmp 0x1e698
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1e8e0
movq %rax, %rdi
callq 0x1e910
movq -0x50(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xdc70
cmpq $0x0, %rax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x1e6a1
jmp 0x1e6a7
movb $0x1, -0x1(%rbp)
jmp 0x1e6ab
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xdb50
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xd8b0
jmp 0x23f22
leaq -0x31(%rbp), %rdi
callq 0xd6b0
leaq -0x30(%rbp), %rdi
movl $0x2c, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xd850
movq %rax, -0x50(%rbp)
cmpq $-0x1, -0x50(%rbp)
je 0x2407d
movq -0x50(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd430
movq %rax, %rcx
movq -0xd0(%rbp), %rax
subq $0x2, %rcx
cmpq %rcx, %rax
jne 0x23f75
jmp 0x23fae
leaq 0x3c35c(%rip), %rdi     # 0x602d8
leaq 0x3c368(%rip), %rsi     # 0x602eb
movl $0xb1, %edx
leaq 0x3c38f(%rip), %rcx     # 0x6031e
callq 0xd400
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0xd6b0
jmp 0x240b7
movq -0x50(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xd650
jmp 0x23fc5
movq -0xc8(%rbp), %rdi
addq $0x28, %rdi
leaq -0x70(%rbp), %rsi
movq %rsi, -0xd8(%rbp)
callq 0xd790
movq -0xd8(%rbp), %rdi
callq 0xdca8
movq -0x50(%rbp), %rdx
incq %rdx
leaq -0xb0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x1, %ecx
callq 0xd650
jmp 0x2400a
leaq -0x90(%rbp), %rdi
movl $0x2d, %esi
leaq -0xb0(%rbp), %rdx
callq 0x268c0
jmp 0x24024
movq -0xc8(%rbp), %rdi
addq $0x8, %rdi
leaq -0x90(%rbp), %rsi
callq 0xd790
leaq -0x90(%rbp), %rdi
callq 0xdca8
leaq -0xb0(%rbp), %rdi
callq 0xdca8
jmp 0x24095
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x240ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xdca8
jmp 0x240ae
movq -0xc8(%rbp), %rdi
addq $0x28, %rdi
leaq -0x30(%rbp), %rsi
callq 0xd060
jmp 0x24093
jmp 0x24095
leaq -0x30(%rbp), %rdi
callq 0xdca8
movq -0xc8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0xdca8
movq -0x40(%rbp), %rdi
callq 0xdb30
// File: 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
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xd8f0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd430
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x245b8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd6d0
movsbl (%rax), %edi
callq 0xd970
movq -0x40(%rbp), %rdi
movsbl %al, %edx
movl $0x1, %esi
callq 0xd6a0
jmp 0x24591
jmp 0x24593
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2454c
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xdca8
jmp 0x245d5
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x245cb
movq -0x40(%rbp), %rdi
callq 0xdca8
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xdb30
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x28, %rdi
callq 0xdab0
testb $0x1, %al
jne 0x24639
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xd850
cmpq $-0x1, %rax
je 0x2462b
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x24645
movq -0x20(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x8(%rbp)
jmp 0x24645
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x8, %rdi
callq 0xdab0
testb $0x1, %al
jne 0x24a33
movq -0x78(%rbp), %rdi
addq $0x28, %rdi
callq 0xdab0
movb $0x0, -0x31(%rbp)
testb $0x1, %al
jne 0x24951
jmp 0x24965
movq -0x78(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x90(%rbp)
jmp 0x249e6
movq -0x78(%rbp), %rsi
addq $0x8, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xd230
movq -0xa0(%rbp), %rdi
movb $0x1, -0x31(%rbp)
leaq 0x3b9e6(%rip), %rsi     # 0x60375
callq 0xdbf0
movq %rax, -0x98(%rbp)
jmp 0x2499d
movq -0x98(%rbp), %rdi
movq -0x78(%rbp), %rsi
addq $0x28, %rsi
callq 0xdc10
movq %rax, -0xa8(%rbp)
jmp 0x249ba
movq -0xa8(%rbp), %rdi
leaq 0x3b9b3(%rip), %rsi     # 0x6037b
callq 0xdbf0
movq %rax, -0xb0(%rbp)
jmp 0x249d6
movq -0xb0(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x249e6
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0xd230
jmp 0x249fb
testb $0x1, -0x31(%rbp)
jne 0x24a03
jmp 0x24a0c
leaq -0x30(%rbp), %rdi
callq 0xdca8
jmp 0x24acd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x24a25
jmp 0x24a2e
leaq -0x30(%rbp), %rdi
callq 0xdca8
jmp 0x24ada
leaq -0x69(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xdb50
movq -0xb8(%rbp), %rdx
leaq 0x3b927(%rip), %rsi     # 0x60378
leaq -0x68(%rbp), %rdi
callq 0xd8b0
jmp 0x24a5c
movq -0x78(%rbp), %rsi
addq $0x28, %rsi
leaq -0x68(%rbp), %rdi
callq 0xdc10
movq %rax, -0xc0(%rbp)
jmp 0x24a76
movq -0xc0(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0xd230
jmp 0x24a8b
leaq -0x68(%rbp), %rdi
callq 0xdca8
leaq -0x69(%rbp), %rdi
callq 0xd6b0
jmp 0x24acd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x24ac2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xdca8
leaq -0x69(%rbp), %rdi
callq 0xd6b0
jmp 0x24ada
movq -0x80(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x68, %rdi
callq 0x129c0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0x0, %eax
je 0x24b45
movq -0x30(%rbp), %rdi
addq $0x68, %rdi
callq 0x129c0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq (%rsi), %rax
callq *(%rax)
jmp 0x24b8a
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xdb50
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x3b300(%rip), %rsi     # 0x5fe61
callq 0xd8b0
jmp 0x24b68
leaq -0x11(%rbp), %rdi
callq 0xd6b0
jmp 0x24b8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0xd6b0
jmp 0x24b94
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xdb30
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x80, %edi
callq 0xd630
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
callq 0x26c10
jmp 0x2505a
movq -0x60(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x26cf0
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
addq $0x68, %rdi
callq 0x26d60
jmp 0x2507e
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x26dd0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x25172
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movq -0x38(%rbp), %rsi
callq 0x26df0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x26a10
movq -0x68(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x24ce0
jmp 0x250db
leaq -0x48(%rbp), %rdi
callq 0x26a50
movq -0x68(%rbp), %rdi
addq $0x40, %rdi
callq 0x26e10
movq %rdx, -0x90(%rbp)
movq %rax, -0x88(%rbp)
jmp 0x25101
movq -0x90(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x50(%rbp)
leaq -0x58(%rbp), %rdi
movl $0x1, %esi
callq 0x26e80
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x25086
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xd5c0
jmp 0x25191
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x25188
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x26a50
jmp 0x25188
leaq -0x20(%rbp), %rdi
callq 0x26ed0
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x26ed0
movq -0x28(%rbp), %rdi
callq 0xdb30
nopw (%rax,%rax)
// File: 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
subq $0x120, %rsp            # imm = 0x120
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dl
movb %dl, -0x11(%rbp)
andb $0x1, %cl
movb %cl, -0x12(%rbp)
andb $0x1, %al
movb %al, -0x13(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %dl
movb -0x12(%rbp), %cl
movb -0x13(%rbp), %al
andb $0x1, %dl
andb $0x1, %cl
andb $0x1, %al
movzbl %dl, %edx
movzbl %cl, %ecx
movzbl %al, %r8d
callq 0x25300
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x252e0
leaq -0xf9(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0xdb50
movq -0x118(%rbp), %rdx
leaq 0x3ac12(%rip), %rsi     # 0x5fe61
leaq -0xf8(%rbp), %rdi
callq 0xd8b0
jmp 0x2525d
leaq -0xd8(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x12d50
jmp 0x25272
leaq -0xd8(%rbp), %rdi
callq 0x12c70
jmp 0x25280
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x252d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x252c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x12e00
leaq -0xf8(%rbp), %rdi
callq 0xdca8
leaq -0xf9(%rbp), %rdi
callq 0xd6b0
jmp 0x252ed
movq -0x20(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x108(%rbp), %rdi
callq 0xdb30
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xdab0
testb $0x1, %al
jne 0x25680
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0xd570
movq %rax, %rdi
leaq 0x3ae02(%rip), %rsi     # 0x6047d
callq 0xd610
cmpl $0x0, -0x14(%rbp)
jne 0x25692
movq -0x30(%rbp), %rdi
callq 0x257a0
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0x38(%rbp)
addq $0x28, %rdi
callq 0x26dd0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x25729
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x273a0
testb $0x1, %al
jne 0x256d1
jmp 0x256d3
jmp 0x2571b
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x26df0
movq %rax, %rdi
callq 0x27240
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
movl 0x20(%rax), %ecx
callq 0x25aa0
movq -0x10(%rbp), %rdi
leaq 0x3a74a(%rip), %rsi     # 0x5fe60
callq 0xd610
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x25699
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %eax
movq %rax, -0x40(%rbp)
addq $0x68, %rdi
callq 0x272d0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x25794
movq -0x10(%rbp), %rdi
leaq 0x3a705(%rip), %rsi     # 0x5fe60
callq 0xd610
movq -0x30(%rbp), %rdi
addq $0x68, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x272f0
movq %rax, %rdi
callq 0x27310
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x25640
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x25730
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: demon386[P]git-store/./boost/token_iterator.hpp
// Function: boost::token_iterator<boost::char_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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x60(%rax)
je 0x29f3c
jmp 0x29f9b
movq -0x18(%rbp), %rdi
callq 0x29fb0
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x50, %rdi
addq $0x58, %rsi
callq 0x29fc0
testb $0x1, %al
jne 0x29f5f
jmp 0x29f87
movq -0x18(%rbp), %rdi
movq %rdi, %rsi
addq $0x50, %rsi
movq 0x58(%rdi), %rax
movq %rax, -0x10(%rbp)
movq %rdi, %rcx
addq $0x68, %rcx
movq -0x10(%rbp), %rdx
callq 0x2a000
movb %al, -0x19(%rbp)
jmp 0x29f8e
xorl %eax, %eax
movb %al, -0x19(%rbp)
jmp 0x29f8e
movq -0x18(%rbp), %rax
movb -0x19(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x60(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x20, %rdi
callq 0xd9b0
cmpq $0x0, %rax
je 0x2a40c
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0x11(%rbp), %esi
callq 0xd850
cmpq $-0x1, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2a435
movq -0x20(%rbp), %rax
testb $0x1, 0x41(%rax)
je 0x2a431
movsbl -0x11(%rbp), %edi
callq 0x2a590
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2a435
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xd9b0
cmpq $0x0, %rax
je 0x2a504
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0x11(%rbp), %esi
callq 0xd850
cmpq $-0x1, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2a52d
movq -0x20(%rbp), %rax
testb $0x1, 0x40(%rax)
je 0x2a529
movsbl -0x11(%rbp), %edi
callq 0x2a5e0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2a52d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, (%rax)
movl $0x18, %edi
callq 0xd630
movq %rax, -0x28(%rbp)
jmp 0x2b68f
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2b760
jmp 0x2b69e
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x2b6fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2b6ce
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xd5c0
movq -0x18(%rbp), %rdi
callq 0xd200
movq -0x10(%rbp), %rdi
callq 0x2b7a0
jmp 0x2b6e2
callq 0xd990
jmp 0x2b715
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xda90
jmp 0x2b6fc
jmp 0x2b704
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xdb30
movq %rax, %rdi
callq 0x129b0
nopw %cs:(%rax,%rax)
nop
// File: demon386[P]git-store/./libs/program_options/src/parsers.cpp
// Function: boost::program_options::(anonymous namespace)::woption_from_option(boost::program_options::basic_option<char> const&)
woption woption_from_option(const option& opt)
        {
            woption result;
            result.string_key = opt.string_key;
            result.position_key = opt.position_key;
            result.unregistered = opt.unregistered;
            
            std::transform(opt.value.begin(), opt.value.end(),
                           back_inserter(result.value),
                           boost::bind(from_utf8, _1));

            std::transform(opt.original_tokens.begin(), 
                           opt.original_tokens.end(),
                           back_inserter(result.original_tokens),
                           boost::bind(from_utf8, _1));
            return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x307b0
movq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd060
jmp 0x2e53f
movq -0xa0(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movb 0x58(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x58(%rax)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x15e00
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x15e30
movq -0xa0(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x28, %rdi
callq 0x308c0
movq %rax, -0xb0(%rbp)
jmp 0x2e598
movq -0xb0(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0xc97a(%rip), %rdi     # 0x21c30
callq 0x308f0
movq %rax, -0xb8(%rbp)
jmp 0x2e5b8
movq -0xb8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x30800
movq %rax, -0xc0(%rbp)
jmp 0x2e5e1
movq -0xc0(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x15e00
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x15e30
movq -0xa0(%rbp), %rdi
movq %rax, -0x70(%rbp)
addq $0x40, %rdi
callq 0x308c0
movq %rax, -0xc8(%rbp)
jmp 0x2e627
movq -0xc8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0xca09(%rip), %rdi     # 0x21c30
callq 0x308f0
movq %rax, -0xd0(%rbp)
jmp 0x2e647
movq -0xd0(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x88(%rbp), %rcx
callq 0x30800
movq %rax, -0xd8(%rbp)
jmp 0x2e676
movq -0xd8(%rbp), %rax
movq %rax, -0x98(%rbp)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2e6b6
jmp 0x2e6aa
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2fbd0
jmp 0x2e6c6
movq -0xa0(%rbp), %rdi
callq 0x2fbd0
movq -0xa8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xdb30
nop
// File: 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
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x260(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x258(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x228(%rbp), %rdi
movl $0x8, %edx
callq 0xdb90
movq -0x228(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x228(%rbp,%rax), %rdi
callq 0xd260
movb %al, -0x249(%rbp)
jmp 0x2f7d4
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x2f7e0
jmp 0x2f834
movq -0x10(%rbp), %rsi
leaq -0x248(%rbp), %rdi
callq 0x2f940
jmp 0x2f7f2
leaq -0x248(%rbp), %rdi
callq 0x2f890
jmp 0x2f800
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
jmp 0x2f870
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x2fa20
jmp 0x2f870
movq -0x260(%rbp), %rdi
movq -0x18(%rbp), %rdx
movzbl -0x19(%rbp), %ecx
andl $0x1, %ecx
leaq -0x228(%rbp), %rsi
callq 0x2ead0
jmp 0x2f854
leaq -0x228(%rbp), %rdi
callq 0xd120
movq -0x258(%rbp), %rax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
leaq -0x228(%rbp), %rdi
callq 0xd120
movq -0x230(%rbp), %rdi
callq 0xdb30
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xd8f0
movq -0x80(%rbp), %rdi
addq $0xf8, %rdi
callq 0x300f0
movq %rax, -0x78(%rbp)
jmp 0x3003a
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd0e0
movq %rax, -0x88(%rbp)
jmp 0x30050
movq -0x88(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xd7d0
movb %al, -0x89(%rbp)
jmp 0x3006e
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x3007a
jmp 0x300c3
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x21dd0
jmp 0x30089
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xd790
leaq -0x68(%rbp), %rdi
callq 0xdca8
movb $0x1, -0x1(%rbp)
movl $0x1, -0x6c(%rbp)
jmp 0x300ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xdca8
jmp 0x300e5
movb $0x0, -0x1(%rbp)
movl $0x1, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xdca8
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xdb30
nop
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x48(%rax), %rax
cmpq $0x0, (%rax)
jne 0x31705
movq -0x90(%rbp), %rdi
callq 0x31920
jmp 0x318b1
movq -0x90(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xdb50
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0xd8b0
jmp 0x31743
leaq -0x29(%rbp), %rdi
callq 0xd6b0
leaq -0x28(%rbp), %rdi
movl $0x3d, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xd850
movq %rax, -0x48(%rbp)
cmpq $-0x1, -0x48(%rbp)
je 0x3176b
jmp 0x317a4
leaq 0x2f776(%rip), %rdi     # 0x60ee8
leaq 0x2f77b(%rip), %rsi     # 0x60ef4
movl $0x28, %edx
leaq 0x2f7a0(%rip), %rcx     # 0x60f25
callq 0xd400
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0xd6b0
jmp 0x318ba
movq -0x48(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xd650
jmp 0x317bb
movq -0x90(%rbp), %rdi
callq 0x31940
movq %rax, -0xa8(%rbp)
jmp 0x317d0
movq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
callq 0xd790
movq -0xb0(%rbp), %rdi
callq 0xdca8
movq -0x48(%rbp), %rdx
incq %rdx
leaq -0x88(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movq $-0x1, %rcx
callq 0xd650
jmp 0x31813
movq -0x90(%rbp), %rdi
callq 0x31940
movq %rax, -0xb8(%rbp)
jmp 0x31828
movq -0xb8(%rbp), %rdi
addq $0x20, %rdi
leaq -0x88(%rbp), %rsi
callq 0xd790
leaq -0x88(%rbp), %rdi
callq 0xdca8
movq -0x90(%rbp), %rax
movq 0x48(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x48(%rax)
leaq -0x28(%rbp), %rdi
callq 0xdca8
jmp 0x318b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x318a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xdca8
jmp 0x318a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xdca8
leaq -0x28(%rbp), %rdi
callq 0xdca8
jmp 0x318ba
addq $0xc0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, (%rax)
movl $0x20, %edi
callq 0xd630
movq %rax, -0x30(%rbp)
jmp 0x3266f
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x1(%rbp), %rdx
callq 0x32730
jmp 0x32682
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x326e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x326b2
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xd5c0
movq -0x20(%rbp), %rdi
callq 0xd200
movq -0x18(%rbp), %rsi
leaq -0x1(%rbp), %rdi
callq 0x32780
jmp 0x326ca
callq 0xd990
jmp 0x326fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xda90
jmp 0x326e4
jmp 0x326ec
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xdb30
movq %rax, %rdi
callq 0x129b0
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xd8f0
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0xdc70
cmpq $0x0, %rax
jne 0x349ed
movq -0x40(%rbp), %rdi
callq 0xd430
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd430
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x349eb
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xd6d0
movsbl (%rax), %edi
callq 0xd970
movq -0x50(%rbp), %rdi
movsbl %al, %esi
callq 0xd3c0
jmp 0x349c4
jmp 0x349c6
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x34984
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xdca8
jmp 0x34a0a
jmp 0x349ed
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x34a00
movq -0x50(%rbp), %rdi
callq 0xdca8
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x1, %al
cmpl $-0x1, -0x14(%rbp)
movb %al, -0x4d(%rbp)
jne 0x34c89
movq -0x58(%rbp), %rdi
addq $0x18, %rdi
callq 0xdab0
movb %al, -0x4d(%rbp)
movb -0x4d(%rbp), %al
testb $0x1, %al
jne 0x34c92
jmp 0x34c94
jmp 0x34cb3
leaq 0x2c545(%rip), %rdi     # 0x611e0
leaq 0x2c564(%rip), %rsi     # 0x61206
movl $0x17, %edx
leaq 0x2c58a(%rip), %rcx     # 0x61238
callq 0xd400
cmpl $-0x1, -0x14(%rbp)
jne 0x34ccf
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rdi
callq 0xd8a0
jmp 0x34d67
movq -0x58(%rbp), %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x124d0
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xdb50
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xd8b0
jmp 0x34d12
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x34e70
jmp 0x34d25
leaq -0x38(%rbp), %rdi
callq 0xdca8
leaq -0x39(%rbp), %rdi
callq 0xd6b0
jmp 0x34d67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x34d5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xdca8
leaq -0x39(%rbp), %rdi
callq 0xd6b0
jmp 0x34d74
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xdb30
nopl (%rax)
// File: demon386[P]git-store/./libs/program_options/src/positional_options.cpp
// Function: boost::program_options::positional_options_description::name_for_position[abi:cxx11](unsigned int) const
const std::string& 
    positional_options_description::name_for_position(unsigned position) const
    {
        assert(position < max_total_count());

        if (position < m_names.size())
            return m_names[position];
        else
            return m_trailing;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
callq 0x34d80
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jae 0x34dfd
jmp 0x34e1c
leaq 0x2c4a3(%rip), %rdi     # 0x612a7
leaq 0x2c3fb(%rip), %rsi     # 0x61206
movl $0x2b, %edx
leaq 0x2c4ad(%rip), %rcx     # 0x612c4
callq 0xd400
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x124d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x34e4c
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x34f30
movq %rax, -0x8(%rbp)
jmp 0x34e58
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c7b0
testb $0x1, %al
jne 0x39ff8
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x3c8b0
movq -0x1c8(%rbp), %rdi
callq 0x3c7d0
jmp 0x39fd5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x3ca40
jmp 0x3a13e
movq -0x18(%rbp), %rdi
callq 0x124d0
cmpq $0x1, %rax
jbe 0x3a04b
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x3cb40
movq -0x1d0(%rbp), %rdi
callq 0x3ca60
jmp 0x3a028
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3ccd0
jmp 0x3a13e
movq -0x18(%rbp), %rdi
callq 0x12470
movb $0x0, -0x1ba(%rbp)
testb $0x1, %al
jne 0x3a061
jmp 0x3a099
leaq -0x1b9(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0xdb50
movq -0x1d8(%rbp), %rdx
movb $0x1, -0x1ba(%rbp)
leaq 0x25dd8(%rip), %rsi     # 0x5fe61
leaq -0x1b8(%rbp), %rdi
callq 0xd8b0
jmp 0x3a097
jmp 0x3a0b5
movq -0x18(%rbp), %rdi
callq 0x3ccf0
movq %rax, %rsi
leaq -0x1b8(%rbp), %rdi
callq 0xd230
jmp 0x3a0b3
jmp 0x3a0b5
movq -0x10(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x3cd20
jmp 0x3a0c7
leaq -0x1b8(%rbp), %rdi
callq 0xdca8
testb $0x1, -0x1ba(%rbp)
jne 0x3a0de
jmp 0x3a0ea
leaq -0x1b9(%rbp), %rdi
callq 0xd6b0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x3a125
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0xdca8
testb $0x1, -0x1ba(%rbp)
jne 0x3a130
jmp 0x3a13c
leaq -0x1b9(%rbp), %rdi
callq 0xd6b0
jmp 0x3a13e
movq -0xd8(%rbp), %rdi
callq 0xdb30
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0xb0, %edi
callq 0xd630
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rsi
callq 0x3cd70
jmp 0x3a18b
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movb $0x0, -0x1d(%rbp)
leaq -0x1d(%rbp), %rsi
callq 0x3cea0
movq -0x10(%rbp), %rdi
callq 0x3cf10
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xd5c0
movq -0x18(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x98, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd210
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd9b0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0xdb20
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x3b715
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rax
addq $0x98, %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd9b0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
callq 0xd1d0
jmp 0x3b6cc
nopw (%rax,%rax)
// File: demon386[P]git-store/./libs/program_options/src/value_semantic.cpp
// Function: boost::program_options::validation_error::get_template[abi:cxx11](boost::program_options::validation_error::kind_t)
string 
    validation_error::get_template(kind_t kind)
    {
        // Initially, store the message in 'const char*' variable,
        // to avoid conversion to std::string in all cases.
        const char* msg;
        switch(kind)
        {
        case invalid_bool_value:
            msg = "the argument ('%value%') for option '%canonical_option%' is invalid. Valid choices are 'on|off', 'yes|no', '1|0' and 'true|false'";
            break;
        case invalid_option_value:
            msg = "the argument ('%value%') for option '%canonical_option%' is invalid";
            break;
        case multiple_values_not_allowed:
            msg = "option '%canonical_option%' only takes a single argument";
            break;
        case at_least_one_value_required:
            msg = "option '%canonical_option%' requires at least one argument";
            break;
        // currently unused
        case invalid_option:
            msg = "option '%canonical_option%' is not valid";
            break;
        default:
            msg = "unknown error";
        }
        return msg;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1e, %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x4, %eax
ja 0x3c714
movq -0x40(%rbp), %rax
leaq 0x255b6(%rip), %rcx     # 0x61c80
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x257cd(%rip), %rax     # 0x61ea7
movq %rax, -0x20(%rbp)
jmp 0x3c71f
leaq 0x25842(%rip), %rax     # 0x61f29
movq %rax, -0x20(%rbp)
jmp 0x3c71f
leaq 0x25879(%rip), %rax     # 0x61f6d
movq %rax, -0x20(%rbp)
jmp 0x3c71f
leaq 0x258a5(%rip), %rax     # 0x61fa6
movq %rax, -0x20(%rbp)
jmp 0x3c71f
leaq 0x22a0b(%rip), %rax     # 0x5f119
movq %rax, -0x20(%rbp)
jmp 0x3c71f
leaq 0x258c6(%rip), %rax     # 0x61fe1
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xdb50
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0xd8b0
jmp 0x3c747
leaq -0x21(%rbp), %rdi
callq 0xd6b0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0xd6b0
movq -0x30(%rbp), %rdi
callq 0xdb30
nopl (%rax,%rax)