// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/cmdline.cpp
// Function: boost::program_options::detail::cmdline::finish_option(boost::program_options::basic_option<char>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<boost::function1<std::vector<boost::program_options::basic_option<char>, std::allocator<boost::program_options::basic_option<char>>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&>, std::allocator<boost::function1<std::vector<boost::program_options::basic_option<char>, std::allocator<boost::program_options::basic_option<char>>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&>>> const&)
void
    cmdline::finish_option(option& opt,
                           vector<string>& other_tokens,
                           const vector<style_parser>& style_parsers)
    {          
        if (opt.string_key.empty())
            return;

        // 
        // Be defensive:
        // will have no original token if option created by handle_additional_parser()
        std::string original_token_for_exceptions = opt.string_key;
        if (opt.original_tokens.size())
            original_token_for_exceptions = opt.original_tokens[0];

        try
        {
            // First check that the option is valid, and get its description.
            const option_description* xd = m_desc->find_nothrow(opt.string_key, 
                    is_style_active(allow_guessing),
                    is_style_active(long_case_insensitive),
                    is_style_active(short_case_insensitive));

            if (!xd)
            {
                if (m_allow_unregistered) {
                    opt.unregistered = true;
                    return;
                } else {
                    boost::throw_exception(unknown_option());
                }                
            }
            const option_description& d = *xd;

            // Canonize the name
            opt.string_key = d.key(opt.string_key);

            // We check that the min/max number of tokens for the option
            // agrees with the number of tokens we have. The 'adjacent_value'
            // (the value in --foo=1) counts as a separate token, and if present
            // must be consumed. The following tokens on the command line may be
            // left unconsumed.

            // We don't check if those tokens look like option, or not!

            unsigned min_tokens = d.semantic()->min_tokens();
            unsigned max_tokens = d.semantic()->max_tokens();
            
            unsigned present_tokens = static_cast<unsigned>(opt.value.size() + other_tokens.size());
            
            if (present_tokens >= min_tokens)
            {
                if (!opt.value.empty() && max_tokens == 0) 
                {
                    boost::throw_exception(
                        invalid_command_line_syntax(invalid_command_line_syntax::extra_parameter));
                }
                
                // If an option wants, at minimum, N tokens, we grab them there,
                // when adding these tokens as values to current option we check
                // if they look like options
                if (opt.value.size() <= min_tokens) 
                {
                    min_tokens -= static_cast<unsigned>(opt.value.size());
                }
                else
                {
                    min_tokens = 0;
                }

                // Everything's OK, move the values to the result.            
                for(;!other_tokens.empty() && min_tokens--; ) 
                {
                    // check if extra parameter looks like a known option
                    // we use style parsers to check if it is syntactically an option, 
                    // additionally we check if an option_description exists
                    vector<option> followed_option;  
                    vector<string> next_token(1, other_tokens[0]);      
                    for (unsigned i = 0; followed_option.empty() && i < style_parsers.size(); ++i)
                    {
                        followed_option = style_parsers[i](next_token);
                    }
                    if (!followed_option.empty()) 
                    {
                        original_token_for_exceptions = other_tokens[0];
                        const option_description* od = m_desc->find_nothrow(other_tokens[0], 
                                  is_style_active(allow_guessing),
                                  is_style_active(long_case_insensitive),
                                  is_style_active(short_case_insensitive));
                        if (od) 
                            boost::throw_exception(
                                invalid_command_line_syntax(invalid_command_line_syntax::missing_parameter));
                    }
                    opt.value.push_back(other_tokens[0]);
                    opt.original_tokens.push_back(other_tokens[0]);
                    other_tokens.erase(other_tokens.begin());
                }
            }
            else
            {
                boost::throw_exception(
                            invalid_command_line_syntax(invalid_command_line_syntax::missing_parameter)); 

            }
        } 
        // use only original token for unknown_option / ambiguous_option since by definition
        //    they are unrecognised / unparsable
        catch(error_with_option_name& e)
        {
            // add context and rethrow
            e.add_context(opt.string_key, original_token_for_exceptions, get_canonical_option_prefix());
            throw;
        }

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, -0x48(%rbp)
cmpq $0x0, 0x8(%rsi)
je 0xe555
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq -0xe0(%rbp), %rdi
callq 0xc660
movq 0x40(%r12), %rsi
cmpq %rsi, 0x48(%r12)
je 0xe2d8
leaq -0xe0(%rbp), %rdi
callq 0xc2b0
movq 0x20(%r13), %rdi
movl 0x18(%r13), %r8d
movl %r8d, %edx
shrl $0x9, %edx
andl $0x1, %edx
movl %r8d, %ecx
shrl $0xa, %ecx
andl $0x1, %ecx
shrl $0xb, %r8d
andl $0x1, %r8d
movq %r12, %rsi
callq 0x152bc
movq %rax, %r14
testq %rax, %rax
je 0xe538
movq %r14, %rdi
movq %r12, %rsi
movq %r12, -0x40(%rbp)
movq %r13, -0x38(%rbp)
callq 0x14b50
movq %r12, %rdi
movq %rax, %rsi
callq 0xc2b0
leaq -0x1b8(%rbp), %rdi
movq %r14, %rsi
callq 0x14c94
leaq -0x1b8(%rbp), %rdi
callq 0xeba4
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movl %eax, %ebx
leaq -0x1b0(%rbp), %rdi
callq 0xf63a
leaq -0x1b8(%rbp), %rdi
movq %r14, %rsi
callq 0x14c94
leaq -0x1b8(%rbp), %rdi
callq 0xeba4
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movl %eax, %r14d
leaq -0x1b0(%rbp), %rdi
callq 0xf63a
movq 0x28(%r12), %rsi
movq 0x30(%r12), %rdi
movq %rdi, %rcx
subq %rsi, %rcx
sarq $0x5, %rcx
movq -0x48(%rbp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rax
movq %rax, %r8
subq %rdx, %r8
shrq $0x5, %r8
addl %ecx, %r8d
cmpl %r8d, %ebx
ja 0xe5bb
cmpq %rdi, %rsi
sete %sil
testl %r14d, %r14d
setne %dil
orb %sil, %dil
je 0xe615
movl %ebx, %esi
subl %ecx, %ebx
xorl %edi, %edi
cmpq %rsi, %rcx
cmovbel %ebx, %edi
leaq 0x40(%r12), %rcx
movq %rcx, -0xb8(%rbp)
leaq 0x28(%r12), %rcx
movq %rcx, -0xc0(%rbp)
leaq -0xf8(%rbp), %r14
leaq -0x1b8(%rbp), %r13
leaq -0x90(%rbp), %rbx
cmpq %rax, %rdx
je 0xe549
subl $0x1, %edi
jb 0xe549
movl %edi, -0x4c(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x90(%rbp)
andq $0x0, -0x80(%rbp)
movq %r14, %rdi
pushq $0x1
popq %rsi
movq %r13, %rcx
callq 0xeeae
xorl %r12d, %r12d
movq -0x90(%rbp), %rax
cmpq -0x88(%rbp), %rax
jne 0xe49b
movl %r12d, %eax
movq (%r15), %rsi
movq 0x8(%r15), %rcx
subq %rsi, %rcx
sarq $0x5, %rcx
cmpq %rax, %rcx
jbe 0xe4e7
shlq $0x5, %rax
addq %rax, %rsi
movq %r13, %rdi
movq %r14, %rdx
callq 0xea3a
movq %rbx, %rdi
movq %r13, %rsi
callq 0x12292
movq %r13, %rdi
callq 0xeac8
incl %r12d
jmp 0xe44b
movq -0x48(%rbp), %r12
movq (%r12), %rsi
leaq -0xe0(%rbp), %rdi
callq 0xc2b0
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rdi
movq (%r12), %rsi
movl 0x18(%rax), %r8d
movl %r8d, %edx
shrl $0x9, %edx
andl $0x1, %edx
movl %r8d, %ecx
shrl $0xa, %ecx
andl $0x1, %ecx
shrl $0xb, %r8d
andl $0x1, %r8d
callq 0x152bc
testq %rax, %rax
jne 0xe567
movq -0x48(%rbp), %r12
movq (%r12), %rsi
movq -0xc0(%rbp), %rdi
callq 0xeaf4
movq (%r12), %rsi
movq -0xb8(%rbp), %rdi
callq 0xeaf4
movq (%r12), %rsi
movq %r12, %rdi
callq 0xeb30
movq %r14, %rdi
callq 0xe840
movq %rbx, %rdi
callq 0xeac8
movq (%r12), %rdx
movq 0x8(%r12), %rax
movl -0x4c(%rbp), %edi
jmp 0xe416
cmpb $0x1, 0x1c(%r13)
jne 0xe66f
movb $0x1, 0x58(%r12)
leaq -0xe0(%rbp), %rdi
callq 0xc9a0
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e914(%rip), %rsi     # 0x2ce82
leaq -0x70(%rbp), %rdi
leaq -0x2a(%rbp), %rdx
callq 0xc1b0
leaq 0x1e900(%rip), %rsi     # 0x2ce82
leaq -0xb0(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0xc1b0
leaq -0x1b8(%rbp), %rdi
pushq $0x22
popq %rsi
leaq -0x70(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
xorl %r8d, %r8d
callq 0xee42
leaq -0x1b8(%rbp), %rdi
callq 0xedbe
leaq 0x1e8c0(%rip), %rsi     # 0x2ce82
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0xc1b0
leaq 0x1e8a9(%rip), %rsi     # 0x2ce82
leaq -0xb0(%rbp), %rdi
leaq -0xf8(%rbp), %rdx
callq 0xc1b0
leaq -0x1b8(%rbp), %rdi
pushq $0x22
popq %rsi
leaq -0x70(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
xorl %r8d, %r8d
callq 0xee42
leaq -0x1b8(%rbp), %rdi
callq 0xedbe
leaq 0x1e866(%rip), %rsi     # 0x2ce82
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0xc1b0
leaq 0x1e84f(%rip), %rsi     # 0x2ce82
leaq -0xb0(%rbp), %rdi
leaq -0xf8(%rbp), %rdx
callq 0xc1b0
leaq -0x1b8(%rbp), %rdi
pushq $0x23
popq %rsi
leaq -0x70(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
xorl %r8d, %r8d
callq 0xee42
leaq -0x1b8(%rbp), %rdi
callq 0xedbe
movq %r13, -0x38(%rbp)
movq %r12, -0x40(%rbp)
leaq 0x1e804(%rip), %rsi     # 0x2ce82
leaq -0x70(%rbp), %rdi
leaq -0xb0(%rbp), %rdx
callq 0xc1b0
leaq -0x1b8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xed54
leaq -0x1b8(%rbp), %rdi
callq 0xecd1
jmp 0xe6ae
jmp 0xe6c2
movq %rdx, %r12
movq %rax, %r15
leaq -0x1b8(%rbp), %rdi
callq 0xee62
jmp 0xe6c8
movq %rdx, %r12
movq %rax, %r15
leaq -0xb0(%rbp), %rdi
callq 0xc9a0
jmp 0xe6f4
movq %rdx, %r12
movq %rax, %r15
leaq -0x1b8(%rbp), %rdi
callq 0xee62
jmp 0xe6f4
jmp 0xe6ee
jmp 0xe6ee
movq %rdx, %r12
movq %rax, %r15
leaq -0x70(%rbp), %rdi
callq 0xc9a0
jmp 0xe7a3
jmp 0xe76d
jmp 0xe76d
jmp 0xe76d
movq %rdx, %r12
movq %rax, %r15
leaq -0x1b8(%rbp), %rdi
callq 0xee62
jmp 0xe722
movq %rdx, %r12
movq %rax, %r15
leaq -0xb0(%rbp), %rdi
callq 0xc9a0
jmp 0xe762
jmp 0xe734
jmp 0xe76d
movq %rdx, %r12
movq %rax, %r15
leaq -0x1b0(%rbp), %rdi
callq 0xf63a
jmp 0xe7a3
jmp 0xe76d
movq %rax, %r15
jmp 0xe7df
movq %r13, -0x38(%rbp)
movq %r12, -0x40(%rbp)
jmp 0xe76d
movq %rdx, %r12
movq %rax, %r15
leaq -0x70(%rbp), %rdi
callq 0xc9a0
jmp 0xe78b
movq %rdx, %r12
movq %rax, %r15
jmp 0xe7a3
jmp 0xe785
jmp 0xe785
jmp 0xe785
movq %rdx, %r12
movq %rax, %r15
jmp 0xe797
jmp 0xe785
movq %rdx, %r12
movq %rax, %r15
leaq -0xf8(%rbp), %rdi
callq 0xe840
leaq -0x90(%rbp), %rdi
callq 0xeac8
cmpl $0x1, %r12d
jne 0xe7df
movq %r15, %rdi
callq 0xc1d0
movq %rax, %rbx
movq -0x38(%rbp), %rdi
callq 0xcf48
leaq -0xe0(%rbp), %rdx
movq %rbx, %rdi
movq -0x40(%rbp), %rsi
movl %eax, %ecx
callq 0xeb64
callq 0xc700
movq %rax, %r15
callq 0xc7e0
leaq -0xe0(%rbp), %rdi
callq 0xc9a0
movq %r15, %rdi
callq 0xc850
movq %rax, %rdi
callq 0xeb96
nop