// File: demon386[P]git-store/./libs/program_options/src/variables_map.cpp
// Function: boost::program_options::store(boost::program_options::basic_parsed_options<char> const&, boost::program_options::variables_map&, bool)
BOOST_PROGRAM_OPTIONS_DECL
    void store(const parsed_options& options, variables_map& xm,
               bool utf8)
    {
        // TODO: what if we have different definition
        // for the same option name during different calls
        // 'store'.
        assert(options.description);
        const options_description& desc = *options.description;

        // We need to access map's operator[], not the overriden version
        // variables_map. Ehmm.. messy.
        std::map<std::string, variable_value>& m = xm;

        std::set<std::string> new_final;

        // Declared once, to please Intel in VC++ mode;
        unsigned i;

        // Declared here so can be used to provide context for exceptions
        string option_name;
        string original_token;

        try
        {

            // First, convert/store all given options
            for (i = 0; i < options.options.size(); ++i) {

                option_name = options.options[i].string_key;
                original_token = options.options[i].original_tokens.size() ?
                                options.options[i].original_tokens[0] :
                                option_name;
                // Skip positional options without name
                if (option_name.empty())
                    continue;

                // Ignore unregistered option. The 'unregistered'
                // field can be true only if user has explicitly asked
                // to allow unregistered options. We can't store them
                // to variables map (lacking any information about paring),
                // so just ignore them.
                if (options.options[i].unregistered)
                    continue;

                // If option has final value, skip this assignment
                if (xm.m_final.count(option_name))
                    continue;

                string original_token = options.options[i].original_tokens.size() ?
                                        options.options[i].original_tokens[0]     : "";
                const option_description& d = desc.find(option_name, false,
                                                        false, false);

                variable_value& v = m[option_name];
                if (v.defaulted()) {
                    // Explicit assignment here erases defaulted value
                    v = variable_value();
                }

                d.semantic()->parse(v.value(), options.options[i].value, utf8);

                v.m_value_semantic = d.semantic();

                // The option is not composing, and the value is explicitly
                // provided. Ignore values of this option for subsequent
                // calls to 'store'. We store this to a temporary set,
                // so that several assignment inside *this* 'store' call
                // are allowed.
                if (!d.semantic()->is_composing())
                    new_final.insert(option_name);
            }
        }
#ifndef BOOST_NO_EXCEPTIONS
        catch(error_with_option_name& e)
        {
            // add context and rethrow
            e.add_context(option_name, original_token, options.m_options_prefix);
            throw;
        }
#endif
        xm.m_final.insert(new_final.begin(), new_final.end());



        // Second, apply default values and store required options.
        const vector<shared_ptr<option_description> >& all = desc.options();
        for(i = 0; i < all.size(); ++i)
        {
            const option_description& d = *all[i];
            string key = d.key("");
            // FIXME: this logic relies on knowledge of option_description
            // internals.
            // The 'key' is empty if options description contains '*'.
            // In that
            // case, default value makes no sense at all.
            if (key.empty())
            {
                continue;
            }
            if (m.count(key) == 0) {

                boost::any def;
                if (d.semantic()->apply_default(def)) {
                    m[key] = variable_value(def, true);
                    m[key].m_value_semantic = d.semantic();
                }
            }

            // add empty value if this is an required option
            if (d.semantic()->is_required()) {

                // For option names specified in multiple ways, e.g. on the command line,
                // config file etc, the following precedence rules apply:
                //  "--"  >  ("-" or "/")  >  ""
                //  Precedence is set conveniently by a single call to length()
                string canonical_name = d.canonical_display_name(options.m_options_prefix);
                if (canonical_name.length() > xm.m_required[key].length())
                    xm.m_required[key] = canonical_name;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x340, %rsp            # imm = 0x340
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x43a17
jmp 0x43a36
leaq 0x1ed41(%rip), %rdi     # 0x6275f
leaq 0x1ed4e(%rip), %rsi     # 0x62773
movl $0x1d, %edx
leaq 0x1ed6f(%rip), %rcx     # 0x627a0
callq 0xd400
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1e720
leaq -0x80(%rbp), %rdi
callq 0xd8f0
leaq -0xa0(%rbp), %rdi
callq 0xd8f0
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movq %rax, -0x238(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12600
movq %rax, %rcx
movq -0x238(%rbp), %rax
cmpq %rcx, %rax
jae 0x43f2f
movq -0x8(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x2fbb0
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0xd060
jmp 0x43ab5
movq -0x8(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x2fbb0
movq %rax, %rdi
addq $0x40, %rdi
callq 0x124d0
cmpq $0x0, %rax
je 0x43afc
movq -0x8(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x2fbb0
movq %rax, %rdi
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34f30
movq %rax, -0x240(%rbp)
jmp 0x43b09
leaq -0x80(%rbp), %rax
movq %rax, -0x240(%rbp)
jmp 0x43b09
movq -0x240(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0xd060
jmp 0x43b1e
leaq -0x80(%rbp), %rdi
callq 0xdab0
testb $0x1, %al
jne 0x43b2d
jmp 0x43b49
jmp 0x43ec5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x43edf
movq -0x8(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x2fbb0
testb $0x1, 0x58(%rax)
je 0x43b62
jmp 0x43ec5
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
leaq -0x80(%rbp), %rsi
callq 0x44ae0
movq %rax, -0x248(%rbp)
jmp 0x43b7c
movq -0x248(%rbp), %rax
cmpq $0x0, %rax
je 0x43b8e
jmp 0x43ec5
movq -0x8(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x2fbb0
movq %rax, %rdi
addq $0x40, %rdi
callq 0x124d0
movb $0x0, -0xd2(%rbp)
cmpq $0x0, %rax
je 0x43be6
movq -0x8(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x2fbb0
movq %rax, %rdi
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34f30
movq %rax, %rsi
leaq -0xd0(%rbp), %rdi
callq 0xd230
jmp 0x43be4
jmp 0x43c1e
leaq -0xd1(%rbp), %rdi
movq %rdi, -0x250(%rbp)
callq 0xdb50
movq -0x250(%rbp), %rdx
movb $0x1, -0xd2(%rbp)
leaq 0x1c253(%rip), %rsi     # 0x5fe61
leaq -0xd0(%rbp), %rdi
callq 0xd8b0
jmp 0x43c1c
jmp 0x43c1e
testb $0x1, -0xd2(%rbp)
jne 0x43c29
jmp 0x43c35
leaq -0xd1(%rbp), %rdi
callq 0xd6b0
movq -0x20(%rbp), %rdi
leaq -0x80(%rbp), %rsi
xorl %r8d, %r8d
movl %r8d, %edx
movl %r8d, %ecx
callq 0x251d0
movq %rax, -0x258(%rbp)
jmp 0x43c54
movq -0x258(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x44b40
movq %rax, -0x260(%rbp)
jmp 0x43c78
movq -0x260(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rdi
callq 0x44c20
movb %al, -0x261(%rbp)
jmp 0x43c9a
movb -0x261(%rbp), %al
testb $0x1, %al
jne 0x43ca6
jmp 0x43d1a
leaq -0x108(%rbp), %rdi
callq 0x44c40
jmp 0x43cb4
movq -0xe8(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x44c70
leaq -0x108(%rbp), %rdi
callq 0x44cc0
jmp 0x43d1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
testb $0x1, -0xd2(%rbp)
jne 0x43cf2
jmp 0x43cfe
leaq -0xd1(%rbp), %rdi
callq 0xd6b0
jmp 0x43edf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x43ed3
movq -0xe0(%rbp), %rsi
leaq -0x118(%rbp), %rdi
callq 0x248d0
jmp 0x43d2f
leaq -0x118(%rbp), %rdi
callq 0x129c0
movq %rax, -0x270(%rbp)
jmp 0x43d44
movq -0xe8(%rbp), %rdi
callq 0x44cf0
movq %rax, -0x278(%rbp)
jmp 0x43d59
movq -0x8(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x2fbb0
movq -0x270(%rbp), %rdi
movq -0x278(%rbp), %rsi
movq %rax, %rdx
addq $0x28, %rdx
movq (%rdi), %rax
movq 0x30(%rax), %rax
movzbl -0x11(%rbp), %ecx
andl $0x1, %ecx
callq *%rax
jmp 0x43d8e
leaq -0x118(%rbp), %rdi
callq 0x12a10
movq -0xe0(%rbp), %rsi
leaq -0x128(%rbp), %rdi
callq 0x248d0
jmp 0x43daf
movq -0xe8(%rbp), %rdi
addq $0x10, %rdi
leaq -0x128(%rbp), %rsi
movq %rsi, -0x280(%rbp)
callq 0x44d00
movq -0x280(%rbp), %rdi
callq 0x12a10
movq -0xe0(%rbp), %rsi
leaq -0x138(%rbp), %rdi
callq 0x248d0
jmp 0x43dee
leaq -0x138(%rbp), %rdi
callq 0x129c0
movq %rax, -0x288(%rbp)
jmp 0x43e03
movq -0x288(%rbp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movb %al, -0x289(%rbp)
jmp 0x43e1b
movb -0x289(%rbp), %al
xorb $-0x1, %al
movb %al, -0x28a(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x12a10
movb -0x28a(%rbp), %al
testb $0x1, %al
jne 0x43e41
jmp 0x43eb9
leaq -0x58(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1ea80
movb %dl, -0x299(%rbp)
movq %rax, -0x298(%rbp)
jmp 0x43e5d
movb -0x299(%rbp), %al
movq -0x298(%rbp), %rcx
movq %rcx, -0x148(%rbp)
movb %al, -0x140(%rbp)
jmp 0x43eb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x12a10
jmp 0x43ed3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x12a10
jmp 0x43ed3
leaq -0xd0(%rbp), %rdi
callq 0xdca8
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x43a73
leaq -0xd0(%rbp), %rdi
callq 0xdca8
movl -0xac(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x444c5
movq -0xa8(%rbp), %rdi
callq 0xd200
movq %rax, -0x150(%rbp)
movq -0x150(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
leaq -0x80(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x12960
jmp 0x43f25
callq 0xd990
jmp 0x444f7
jmp 0x43f4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
callq 0xda90
jmp 0x43f4a
jmp 0x444c5
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x2a8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x2b0(%rbp)
callq 0x1e740
movq -0x2b0(%rbp), %rdi
movq %rax, -0x158(%rbp)
callq 0x1e7a0
movq -0x2a8(%rbp), %rdi
movq %rax, -0x160(%rbp)
movq -0x158(%rbp), %rsi
movq -0x160(%rbp), %rdx
callq 0x44d50
jmp 0x43fa4
movq -0x20(%rbp), %rdi
callq 0x255f0
movq %rax, -0x2b8(%rbp)
jmp 0x43fb6
movq -0x2b8(%rbp), %rax
movq %rax, -0x168(%rbp)
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movq %rax, -0x2c0(%rbp)
movq -0x168(%rbp), %rdi
callq 0x26dd0
movq %rax, %rcx
movq -0x2c0(%rbp), %rax
cmpq %rcx, %rax
jae 0x4449e
movq -0x168(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x26df0
movq %rax, %rdi
callq 0x27240
movq %rax, -0x2c8(%rbp)
jmp 0x44016
movq -0x2c8(%rbp), %rax
movq %rax, -0x170(%rbp)
movq -0x170(%rbp), %rax
movq %rax, -0x2d8(%rbp)
leaq -0x1b1(%rbp), %rdi
movq %rdi, -0x2d0(%rbp)
callq 0xdb50
movq -0x2d0(%rbp), %rdx
leaq 0x1be0e(%rip), %rsi     # 0x5fe61
leaq -0x1b0(%rbp), %rdi
callq 0xd8b0
jmp 0x44061
movq -0x2d8(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x245e0
movq %rax, -0x2e0(%rbp)
jmp 0x4407d
movq -0x2e0(%rbp), %rsi
leaq -0x190(%rbp), %rdi
callq 0xd230
jmp 0x44092
leaq -0x1b0(%rbp), %rdi
callq 0xdca8
leaq -0x1b1(%rbp), %rdi
callq 0xd6b0
leaq -0x190(%rbp), %rdi
callq 0xdab0
testb $0x1, %al
jne 0x440bc
jmp 0x44125
movl $0x7, -0x1b8(%rbp)
jmp 0x44466
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x444c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x44114
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0xdca8
leaq -0x1b1(%rbp), %rdi
callq 0xd6b0
jmp 0x444c5
movq -0x28(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x44d90
movq %rax, -0x2e8(%rbp)
jmp 0x4413e
movq -0x2e8(%rbp), %rax
cmpq $0x0, %rax
jne 0x44318
leaq -0x1c0(%rbp), %rdi
callq 0x3e000
movq -0x170(%rbp), %rsi
leaq -0x1d0(%rbp), %rdi
callq 0x248d0
jmp 0x44170
leaq -0x1d0(%rbp), %rdi
callq 0x129c0
movq %rax, -0x2f0(%rbp)
jmp 0x44185
movq -0x2f0(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
leaq -0x1c0(%rbp), %rsi
callq *%rax
movb %al, -0x2f1(%rbp)
jmp 0x441a4
leaq -0x1d0(%rbp), %rdi
callq 0x12a10
movb -0x2f1(%rbp), %al
testb $0x1, %al
jne 0x441bf
jmp 0x442f9
leaq -0x1f0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
movl $0x1, %edx
callq 0x44df0
jmp 0x441d9
movq -0x28(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x44b40
movq %rax, -0x300(%rbp)
jmp 0x441f2
movq -0x300(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
movq %rsi, -0x308(%rbp)
callq 0x44c70
movq -0x308(%rbp), %rdi
callq 0x44cc0
movq -0x170(%rbp), %rsi
leaq -0x200(%rbp), %rdi
callq 0x248d0
jmp 0x4422d
movq -0x28(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x44b40
movq %rax, -0x310(%rbp)
jmp 0x44246
movq -0x310(%rbp), %rdi
addq $0x10, %rdi
leaq -0x200(%rbp), %rsi
callq 0x44d00
leaq -0x200(%rbp), %rdi
callq 0x12a10
jmp 0x442f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x44490
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x44307
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x12a10
jmp 0x44307
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x44cc0
jmp 0x44307
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x12a10
jmp 0x44307
leaq -0x1c0(%rbp), %rdi
callq 0x3d300
jmp 0x44318
leaq -0x1c0(%rbp), %rdi
callq 0x3d300
jmp 0x44490
movq -0x170(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x248d0
jmp 0x4432d
leaq -0x210(%rbp), %rdi
callq 0x129c0
movq %rax, -0x318(%rbp)
jmp 0x44342
movq -0x318(%rbp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
movb %al, -0x319(%rbp)
jmp 0x4435a
leaq -0x210(%rbp), %rdi
callq 0x12a10
movb -0x319(%rbp), %al
testb $0x1, %al
jne 0x44375
jmp 0x4445c
movq -0x170(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
leaq -0x230(%rbp), %rdi
callq 0x24650
jmp 0x44391
leaq -0x230(%rbp), %rdi
callq 0xd9b0
movq %rax, -0x330(%rbp)
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
leaq -0x190(%rbp), %rsi
callq 0x13730
movq %rax, -0x328(%rbp)
jmp 0x443c1
movq -0x328(%rbp), %rdi
callq 0xd9b0
movq %rax, %rcx
movq -0x330(%rbp), %rax
cmpq %rcx, %rax
jbe 0x44450
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
leaq -0x190(%rbp), %rsi
callq 0x13730
movq %rax, -0x338(%rbp)
jmp 0x443f9
movq -0x338(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0xd060
jmp 0x4440e
jmp 0x44450
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x12a10
jmp 0x44490
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x230(%rbp), %rdi
callq 0xdca8
jmp 0x44490
leaq -0x230(%rbp), %rdi
callq 0xdca8
movl $0x0, -0x1b8(%rbp)
leaq -0x190(%rbp), %rdi
callq 0xdca8
movl -0x1b8(%rbp), %eax
testl %eax, %eax
je 0x44480
jmp 0x4447e
jmp 0x44482
jmp 0x44482
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x43fcb
leaq -0x190(%rbp), %rdi
callq 0xdca8
jmp 0x444c5
leaq -0xa0(%rbp), %rdi
callq 0xdca8
leaq -0x80(%rbp), %rdi
callq 0xdca8
leaq -0x58(%rbp), %rdi
callq 0x1e830
addq $0x340, %rsp            # imm = 0x340
popq %rbp
retq
leaq -0xa0(%rbp), %rdi
callq 0xdca8
leaq -0x80(%rbp), %rdi
callq 0xdca8
leaq -0x58(%rbp), %rdi
callq 0x1e830
movq -0xa8(%rbp), %rdi
callq 0xdb30
movq %rax, %rdi
callq 0x129b0
nopw (%rax,%rax)