// File: /workspace/github_cpp_makefile_star2_O1/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 $0x178, %rsp            # imm = 0x178
movq %rdx, %r12
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0xe117
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %r13
leaq -0xa0(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rsi
addq %rsi, %rdx
leaq -0xb0(%rbp), %rdi
callq 0xfa18
movq 0x40(%r14), %rsi
cmpq %rsi, 0x48(%r14)
je 0xde22
leaq -0xb0(%rbp), %rdi
callq 0xb290
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 %r14, %rsi
callq 0x16486
movq %rax, %rbx
testq %rax, %rax
je 0xe0ef
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, -0x50(%rbp)
movq %r13, -0x58(%rbp)
callq 0x15b18
movq %r14, %rdi
movq %rax, %rsi
callq 0xb290
leaq -0x1a0(%rbp), %rdi
movq %rbx, %rsi
callq 0x15d00
movq -0x1a0(%rbp), %rdi
testq %rdi, %rdi
je 0xe197
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %r13d
leaq -0x198(%rbp), %rdi
callq 0xf5d6
leaq -0x1a0(%rbp), %rdi
movq %rbx, %rsi
callq 0x15d00
movq -0x1a0(%rbp), %rdi
testq %rdi, %rdi
je 0xe197
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %ebx
leaq -0x198(%rbp), %rdi
callq 0xf5d6
movq 0x28(%r14), %rcx
movq 0x30(%r14), %rdx
movq %rdx, %rax
subq %rcx, %rax
movq 0x8(%r12), %rsi
subq (%r12), %rsi
sarq $0x5, %rax
shrq $0x5, %rsi
addl %eax, %esi
cmpl %esi, %r13d
ja 0xe1b6
cmpq %rdx, %rcx
sete %cl
testl %ebx, %ebx
setne %dl
orb %cl, %dl
je 0xe224
movq (%r12), %rdx
cmpq 0x8(%r12), %rdx
je 0xe0ff
movl %r13d, %ecx
subl %eax, %r13d
xorl %esi, %esi
cmpq %rcx, %rax
cmoval %esi, %r13d
movq -0x50(%rbp), %rax
leaq 0x40(%rax), %rcx
movq %rcx, -0xb8(%rbp)
addq $0x28, %rax
movq %rax, -0xc0(%rbp)
leaq -0x48(%rbp), %r14
subl $0x1, %r13d
jb 0xe0ff
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movq $0x0, -0x60(%rbp)
movl $0x1, %esi
leaq -0xd8(%rbp), %rdi
leaq -0x1a0(%rbp), %rcx
callq 0xee1a
movq -0x70(%rbp), %rax
cmpq -0x68(%rbp), %rax
sete %cl
je 0xe035
movq (%r12), %rsi
leaq -0xb0(%rbp), %rdi
callq 0xb290
movq -0x58(%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 0x16486
testq %rax, %rax
jne 0xe129
movq (%r12), %rsi
movq -0xc0(%rbp), %rdi
callq 0xe916
movq (%r12), %rsi
movq -0xb8(%rbp), %rdi
callq 0xe916
movq (%r12), %rsi
movq %r12, %rdi
callq 0x11450
leaq -0xd8(%rbp), %rdi
callq 0xe51e
leaq -0x70(%rbp), %rdi
callq 0xe8e2
movq (%r12), %rdx
cmpq 0x8(%r12), %rdx
jne 0xdf56
jmp 0xe0ff
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0xe0e2
movl $0x1, %ebx
xorl %esi, %esi
shlq $0x5, %rsi
addq %rax, %rsi
movq %r14, %rdi
leaq -0xd8(%rbp), %rdx
callq 0xe848
xorps %xmm0, %xmm0
movaps %xmm0, -0x1a0(%rbp)
movaps -0x70(%rbp), %xmm0
movq -0x60(%rbp), %rax
movups -0x48(%rbp), %xmm1
movaps %xmm1, -0x70(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movaps -0x1a0(%rbp), %xmm1
movaps %xmm0, -0x1a0(%rbp)
movq %rax, -0x190(%rbp)
movups %xmm1, -0x48(%rbp)
movq $0x0, -0x38(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0xe8e2
movq %r14, %rdi
callq 0xe8e2
movq -0x70(%rbp), %rax
cmpq -0x68(%rbp), %rax
sete %cl
jne 0xdf98
movl %ebx, %esi
movq (%r15), %rax
movq 0x8(%r15), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
incl %ebx
cmpq %rsi, %rdx
ja 0xe049
testb %cl, %cl
je 0xdf98
jmp 0xdfe0
cmpb $0x1, 0x1c(%r13)
jne 0xe292
movb $0x1, 0x58(%r14)
movq -0xb0(%rbp), %rdi
leaq -0xa0(%rbp), %rax
cmpq %rax, %rdi
je 0xe117
callq 0xb430
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x38(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x24d72(%rip), %rdx     # 0x32eaa
leaq -0x48(%rbp), %rdi
movq %rdx, %rsi
callq 0xf97e
leaq -0x80(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x24d57(%rip), %rdx     # 0x32eaa
leaq -0x90(%rbp), %rdi
movq %rdx, %rsi
callq 0xf97e
leaq -0x1a0(%rbp), %rdi
leaq -0x48(%rbp), %rdx
leaq -0x90(%rbp), %rcx
movl $0x22, %esi
xorl %r8d, %r8d
callq 0xf808
leaq 0x3aef0(%rip), %rax     # 0x49078
leaq -0x1a0(%rbp), %rdi
movq %rax, (%rdi)
callq 0xecb2
leaq 0x24496(%rip), %rdi     # 0x32634
leaq 0x24497(%rip), %rsi     # 0x3263c
leaq 0x244b1(%rip), %rcx     # 0x3265d
movl $0x2af, %edx            # imm = 0x2AF
callq 0xb310
leaq -0x38(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x24ce5(%rip), %rdx     # 0x32eaa
leaq -0x48(%rbp), %rdi
movq %rdx, %rsi
callq 0xf97e
leaq -0x80(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x24cca(%rip), %rdx     # 0x32eaa
leaq -0x90(%rbp), %rdi
movq %rdx, %rsi
callq 0xf97e
leaq -0x1a0(%rbp), %rdi
leaq -0x48(%rbp), %rdx
leaq -0x90(%rbp), %rcx
movl $0x22, %esi
xorl %r8d, %r8d
callq 0xf808
leaq 0x3ae63(%rip), %rax     # 0x49078
leaq -0x1a0(%rbp), %rdi
movq %rax, (%rdi)
callq 0xecb2
leaq -0x38(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x24c77(%rip), %rdx     # 0x32eaa
leaq -0x48(%rbp), %rdi
movq %rdx, %rsi
callq 0xf97e
leaq -0x80(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x24c5c(%rip), %rdx     # 0x32eaa
leaq -0x90(%rbp), %rdi
movq %rdx, %rsi
callq 0xf97e
leaq -0x1a0(%rbp), %rdi
leaq -0x48(%rbp), %rdx
leaq -0x90(%rbp), %rcx
movl $0x23, %esi
xorl %r8d, %r8d
callq 0xf808
leaq 0x3adf5(%rip), %rax     # 0x49078
leaq -0x1a0(%rbp), %rdi
movq %rax, (%rdi)
callq 0xecb2
movq %r13, -0x58(%rbp)
movq %r14, -0x50(%rbp)
leaq -0x38(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x24c01(%rip), %rdx     # 0x32eaa
leaq -0x48(%rbp), %rdi
movq %rdx, %rsi
callq 0xf97e
leaq -0x1a0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xec2e
leaq -0x1a0(%rbp), %rdi
callq 0xeb41
jmp 0xe2d5
jmp 0xe2e9
movq %rdx, %r12
movq %rax, %r15
leaq -0x1a0(%rbp), %rdi
callq 0xedb6
jmp 0xe2ef
movq %rdx, %r12
movq %rax, %r15
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0xe320
callq 0xb430
jmp 0xe320
movq %rdx, %r12
movq %rax, %r15
leaq -0x1a0(%rbp), %rdi
callq 0xedb6
jmp 0xe320
jmp 0xe31a
jmp 0xe31a
movq %rdx, %r12
movq %rax, %r15
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0xe3e2
callq 0xb430
jmp 0xe3e2
jmp 0xe399
jmp 0xe399
jmp 0xe399
jmp 0xe341
jmp 0xe399
movq %rdx, %r12
movq %rax, %r15
leaq -0x198(%rbp), %rdi
callq 0xf5d6
jmp 0xe3e2
jmp 0xe399
movq %rax, %r15
jmp 0xe456
movq %rdx, %r12
movq %rax, %r15
leaq -0x1a0(%rbp), %rdi
callq 0xedb6
jmp 0xe37c
movq %rdx, %r12
movq %rax, %r15
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0xe3a7
callq 0xb430
jmp 0xe3a7
movq %r13, -0x58(%rbp)
movq %r14, -0x50(%rbp)
jmp 0xe399
movq %rdx, %r12
movq %rax, %r15
jmp 0xe3e2
movq %rdx, %r12
movq %rax, %r15
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0xe3cd
callq 0xb430
jmp 0xe3cd
jmp 0xe3c7
jmp 0xe3c7
movq %rdx, %r12
movq %rax, %r15
jmp 0xe3d9
jmp 0xe3c7
jmp 0xe3c7
movq %rdx, %r12
movq %rax, %r15
leaq -0xd8(%rbp), %rdi
callq 0xe51e
leaq -0x70(%rbp), %rdi
callq 0xe8e2
cmpl $0x1, %r12d
jne 0xe456
movq %r15, %rdi
callq 0xb1e0
movq %rax, %rbx
movq -0x58(%rbp), %rax
movl 0x18(%rax), %eax
movl $0x1, %r14d
testb $0x1, %al
jne 0xe429
movl $0x1000, %r14d          # imm = 0x1000
btl $0xc, %eax
jb 0xe429
notl %eax
movl $0x4, %r14d
testb $0x6, %al
je 0xe429
xorl %r14d, %r14d
testb $0xa, %al
sete %r14b
shll $0x3, %r14d
movq (%rbx), %rax
movq %rbx, %rdi
movq -0x50(%rbp), %rsi
callq *0x18(%rax)
leaq -0xb0(%rbp), %rsi
movq %rbx, %rdi
callq 0xf106
movl %r14d, 0x10(%rbx)
callq 0xb680
movq %rax, %r15
callq 0xb780
movq -0xb0(%rbp), %rdi
leaq -0xa0(%rbp), %rax
cmpq %rax, %rdi
je 0xe46e
callq 0xb430
movq %r15, %rdi
callq 0xb7f0
movq %rax, %rdi
callq 0xe997