// File: /workspace/github_cpp_makefile_star2_O3/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 $0x188, %rsp            # imm = 0x188
movq %rdx, %r12
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0xe062
movq %rcx, %r15
movq %rsi, %r13
movq %rdi, %rbx
leaq -0xb0(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rsi
addq %rsi, %rdx
leaq -0xc0(%rbp), %rdi
callq 0xf98c
movq 0x40(%r13), %rsi
cmpq %rsi, 0x48(%r13)
je 0xdd9a
leaq -0xc0(%rbp), %rdi
callq 0xb290
movq 0x20(%rbx), %rdi
movl 0x18(%rbx), %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 %r13, %rsi
callq 0x16318
movq %rax, %r14
testq %rax, %rax
je 0xe03b
movq %r14, %rdi
movq %r13, %rsi
movq %r13, -0x58(%rbp)
movq %rbx, -0x60(%rbp)
callq 0x159b8
movq %r13, %rdi
movq %rax, %rsi
callq 0xb290
leaq -0x1a8(%rbp), %rdi
movq %r14, %rsi
callq 0x15ba0
movq -0x1a8(%rbp), %rdi
testq %rdi, %rdi
je 0xe0e5
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %ebx
leaq -0x1a0(%rbp), %rdi
callq 0xf546
leaq -0x1a8(%rbp), %rdi
movq %r14, %rsi
callq 0x15ba0
movq -0x1a8(%rbp), %rdi
testq %rdi, %rdi
je 0xe0e5
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %r14d
leaq -0x1a0(%rbp), %rdi
callq 0xf546
movq 0x28(%r13), %rsi
movq 0x30(%r13), %rdi
movq %rdi, %rax
subq %rsi, %rax
sarq $0x5, %rax
movq (%r12), %rdx
movq 0x8(%r12), %rcx
movq %rcx, %r8
subq %rdx, %r8
shrq $0x5, %r8
addl %eax, %r8d
cmpl %r8d, %ebx
ja 0xe104
cmpq %rdi, %rsi
sete %sil
testl %r14d, %r14d
setne %dil
orb %sil, %dil
je 0xe175
cmpq %rcx, %rdx
je 0xe04a
movl %ebx, %ecx
subl %eax, %ebx
xorl %r13d, %r13d
cmpq %rcx, %rax
cmovbel %ebx, %r13d
movq -0x58(%rbp), %rax
leaq 0x40(%rax), %rcx
movq %rcx, -0xc8(%rbp)
addq $0x28, %rax
movq %rax, -0xd0(%rbp)
leaq -0x50(%rbp), %rbx
subl $0x1, %r13d
jb 0xe04a
xorps %xmm0, %xmm0
movaps %xmm0, -0x80(%rbp)
movq $0x0, -0x70(%rbp)
movl $0x1, %esi
leaq -0xe8(%rbp), %rdi
leaq -0x1a8(%rbp), %rcx
callq 0xed94
movq -0x80(%rbp), %rax
cmpq -0x78(%rbp), %rax
jne 0xdfa1
xorl %r14d, %r14d
movl %r14d, %r14d
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r14, %rax
jbe 0xdfe9
movq %r14, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %rbx, %rdi
leaq -0xe8(%rbp), %rdx
callq 0xe7c6
movaps -0x80(%rbp), %xmm0
movq -0x70(%rbp), %rax
movaps -0x50(%rbp), %xmm1
movaps %xmm1, -0x80(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movups %xmm0, -0x1a8(%rbp)
movq %rax, -0x198(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0xe860
movq %rbx, %rdi
callq 0xe860
incl %r14d
movq -0x80(%rbp), %rax
cmpq -0x78(%rbp), %rax
je 0xdf14
movq (%r12), %rsi
leaq -0xc0(%rbp), %rdi
callq 0xb290
movq -0x60(%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 0x16318
testq %rax, %rax
jne 0xe074
movq (%r12), %rsi
movq -0xd0(%rbp), %rdi
callq 0xe894
movq (%r12), %rsi
movq -0xc8(%rbp), %rdi
callq 0xe894
movq (%r12), %rsi
movq %r12, %rdi
callq 0x11356
leaq -0xe8(%rbp), %rdi
callq 0xe470
leaq -0x80(%rbp), %rdi
callq 0xe860
movq (%r12), %rdx
cmpq 0x8(%r12), %rdx
jne 0xded2
jmp 0xe04a
cmpb $0x1, 0x1c(%rbx)
jne 0xe1e6
movb $0x1, 0x58(%r13)
movq -0xc0(%rbp), %rdi
leaq -0xb0(%rbp), %rax
cmpq %rax, %rdi
je 0xe062
callq 0xb430
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x40(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x24e27(%rip), %rdx     # 0x32eaa
leaq -0x50(%rbp), %rdi
movq %rdx, %rsi
callq 0xf8ee
leaq -0x90(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x24e09(%rip), %rdx     # 0x32eaa
leaq -0xa0(%rbp), %rdi
movq %rdx, %rsi
callq 0xf8ee
leaq -0x1a8(%rbp), %rdi
leaq -0x50(%rbp), %rdx
leaq -0xa0(%rbp), %rcx
movl $0x22, %esi
xorl %r8d, %r8d
callq 0xf778
leaq 0x3b00a(%rip), %rax     # 0x490e0
leaq -0x1a8(%rbp), %rdi
movq %rax, (%rdi)
callq 0xec38
leaq 0x24548(%rip), %rdi     # 0x32634
leaq 0x24549(%rip), %rsi     # 0x3263c
leaq 0x24563(%rip), %rcx     # 0x3265d
movl $0x2af, %edx            # imm = 0x2AF
callq 0xb310
leaq -0x40(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x24d97(%rip), %rdx     # 0x32eaa
leaq -0x50(%rbp), %rdi
movq %rdx, %rsi
callq 0xf8ee
leaq -0x90(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x24d79(%rip), %rdx     # 0x32eaa
leaq -0xa0(%rbp), %rdi
movq %rdx, %rsi
callq 0xf8ee
leaq -0x1a8(%rbp), %rdi
leaq -0x50(%rbp), %rdx
leaq -0xa0(%rbp), %rcx
movl $0x22, %esi
xorl %r8d, %r8d
callq 0xf778
leaq 0x3af7a(%rip), %rax     # 0x490e0
leaq -0x1a8(%rbp), %rdi
movq %rax, (%rdi)
callq 0xec38
leaq -0x40(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x24d26(%rip), %rdx     # 0x32eaa
leaq -0x50(%rbp), %rdi
movq %rdx, %rsi
callq 0xf8ee
leaq -0x90(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x24d08(%rip), %rdx     # 0x32eaa
leaq -0xa0(%rbp), %rdi
movq %rdx, %rsi
callq 0xf8ee
leaq -0x1a8(%rbp), %rdi
leaq -0x50(%rbp), %rdx
leaq -0xa0(%rbp), %rcx
movl $0x23, %esi
xorl %r8d, %r8d
callq 0xf778
leaq 0x3af09(%rip), %rax     # 0x490e0
leaq -0x1a8(%rbp), %rdi
movq %rax, (%rdi)
callq 0xec38
movq %rbx, -0x60(%rbp)
movq %r13, -0x58(%rbp)
leaq -0x40(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x24cad(%rip), %rdx     # 0x32eaa
leaq -0x50(%rbp), %rdi
movq %rdx, %rsi
callq 0xf8ee
leaq -0x1a8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xebb4
leaq -0x1a8(%rbp), %rdi
callq 0xeac9
jmp 0xe229
jmp 0xe23d
movq %rdx, %r12
movq %rax, %r15
leaq -0x1a8(%rbp), %rdi
callq 0xed30
jmp 0xe243
movq %rdx, %r12
movq %rax, %r15
movq -0xa0(%rbp), %rdi
cmpq %r14, %rdi
je 0xe274
callq 0xb430
jmp 0xe274
movq %rdx, %r12
movq %rax, %r15
leaq -0x1a8(%rbp), %rdi
callq 0xed30
jmp 0xe274
jmp 0xe26e
jmp 0xe26e
movq %rdx, %r12
movq %rax, %r15
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0xe333
callq 0xb430
jmp 0xe333
jmp 0xe300
jmp 0xe300
jmp 0xe300
movq %rdx, %r12
movq %rax, %r15
leaq -0x1a8(%rbp), %rdi
callq 0xed30
jmp 0xe2ab
movq %rdx, %r12
movq %rax, %r15
movq -0xa0(%rbp), %rdi
cmpq %r14, %rdi
je 0xe2f0
callq 0xb430
jmp 0xe2f0
jmp 0xe2c2
jmp 0xe300
movq %rdx, %r12
movq %rax, %r15
leaq -0x1a0(%rbp), %rdi
callq 0xf546
jmp 0xe333
jmp 0xe300
movq %rax, %r15
jmp 0xe3a7
movq %rbx, -0x60(%rbp)
movq %r13, -0x58(%rbp)
jmp 0xe300
movq %rdx, %r12
movq %rax, %r15
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0xe31e
callq 0xb430
jmp 0xe31e
movq %rdx, %r12
movq %rax, %r15
jmp 0xe333
jmp 0xe318
jmp 0xe318
movq %rdx, %r12
movq %rax, %r15
jmp 0xe32a
jmp 0xe318
jmp 0xe318
movq %rdx, %r12
movq %rax, %r15
leaq -0xe8(%rbp), %rdi
callq 0xe470
leaq -0x80(%rbp), %rdi
callq 0xe860
cmpl $0x1, %r12d
jne 0xe3a7
movq %r15, %rdi
callq 0xb1e0
movq %rax, %rbx
movq -0x60(%rbp), %rax
movl 0x18(%rax), %eax
movl $0x1, %r14d
testb $0x1, %al
jne 0xe37a
movl $0x1000, %r14d          # imm = 0x1000
btl $0xc, %eax
jb 0xe37a
notl %eax
movl $0x4, %r14d
testb $0x6, %al
je 0xe37a
xorl %r14d, %r14d
testb $0xa, %al
sete %r14b
shll $0x3, %r14d
movq (%rbx), %rax
movq %rbx, %rdi
movq -0x58(%rbp), %rsi
callq *0x18(%rax)
leaq -0xc0(%rbp), %rsi
movq %rbx, %rdi
callq 0xf080
movl %r14d, 0x10(%rbx)
callq 0xb680
movq %rax, %r15
callq 0xb780
movq -0xc0(%rbp), %rdi
leaq -0xb0(%rbp), %rax
cmpq %rax, %rdi
je 0xe3bf
callq 0xb430
movq %r15, %rdi
callq 0xb7f0
movq %rax, %rdi
callq 0xe915
nop