// File: 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
subq $0x630, %rsp            # imm = 0x630
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x530(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdab0
testb $0x1, %al
jne 0x11145
jmp 0x1114a
jmp 0x11bd8
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xd230
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x124d0
cmpq $0x0, %rax
je 0x1119c
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12820
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0xd060
jmp 0x11189
jmp 0x1119c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x11be1
movq -0x530(%rbp), %rdi
movq 0x20(%rdi), %rax
movq %rax, -0x548(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x540(%rbp)
movl $0x200, %esi            # imm = 0x200
callq 0xeb90
movq -0x530(%rbp), %rdi
movb %al, -0x54a(%rbp)
movl $0x400, %esi            # imm = 0x400
callq 0xeb90
movq -0x530(%rbp), %rdi
movb %al, -0x549(%rbp)
movl $0x800, %esi            # imm = 0x800
callq 0xeb90
movb -0x54a(%rbp), %dl
movb -0x549(%rbp), %cl
movq -0x548(%rbp), %rdi
movq -0x540(%rbp), %rsi
movzbl %dl, %edx
movzbl %cl, %ecx
movzbl %al, %r8d
callq 0x25300
movq %rax, -0x538(%rbp)
jmp 0x11223
movq -0x538(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x1130e
movq -0x530(%rbp), %rax
testb $0x1, 0x1c(%rax)
je 0x1126b
movq -0x10(%rbp), %rax
movb $0x1, 0x58(%rax)
movl $0x1, -0x5c(%rbp)
jmp 0x11bcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x11b4a
leaq -0x139(%rbp), %rdi
movq %rdi, -0x558(%rbp)
callq 0xdb50
movq -0x558(%rbp), %rdx
leaq 0x4ebd5(%rip), %rsi     # 0x5fe61
leaq -0x138(%rbp), %rdi
callq 0xd8b0
jmp 0x1129a
leaq -0x118(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0x12d50
jmp 0x112af
leaq -0x118(%rbp), %rdi
callq 0x12c70
jmp 0x112bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x112fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x112f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x12e00
leaq -0x138(%rbp), %rdi
callq 0xdca8
leaq -0x139(%rbp), %rdi
callq 0xd6b0
jmp 0x11b4a
movq -0x58(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x148(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x245e0
movq %rax, -0x560(%rbp)
jmp 0x11332
movq -0x560(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0xd060
jmp 0x11344
movq -0x148(%rbp), %rsi
leaq -0x160(%rbp), %rdi
callq 0x248d0
jmp 0x11359
leaq -0x160(%rbp), %rdi
callq 0x129c0
movq %rax, -0x568(%rbp)
jmp 0x1136e
movq -0x568(%rbp), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movl %eax, -0x56c(%rbp)
jmp 0x11386
leaq -0x160(%rbp), %rdi
callq 0x12a10
movl -0x56c(%rbp), %eax
movl %eax, -0x14c(%rbp)
movq -0x148(%rbp), %rsi
leaq -0x178(%rbp), %rdi
callq 0x248d0
jmp 0x113b3
leaq -0x178(%rbp), %rdi
callq 0x129c0
movq %rax, -0x578(%rbp)
jmp 0x113c8
movq -0x578(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movl %eax, -0x57c(%rbp)
jmp 0x113e0
leaq -0x178(%rbp), %rdi
callq 0x12a10
movl -0x57c(%rbp), %eax
movl %eax, -0x164(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x124d0
movq %rax, -0x588(%rbp)
movq -0x18(%rbp), %rdi
callq 0x124d0
movq %rax, %rcx
movq -0x588(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x17c(%rbp)
movl -0x17c(%rbp), %eax
cmpl -0x14c(%rbp), %eax
jb 0x11a48
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x12470
testb $0x1, %al
jne 0x1159d
cmpl $0x0, -0x164(%rbp)
jne 0x1159d
leaq -0x261(%rbp), %rdi
movq %rdi, -0x590(%rbp)
callq 0xdb50
movq -0x590(%rbp), %rdx
leaq 0x4e9e4(%rip), %rsi     # 0x5fe61
leaq -0x260(%rbp), %rdi
callq 0xd8b0
jmp 0x1148b
leaq -0x289(%rbp), %rdi
movq %rdi, -0x598(%rbp)
callq 0xdb50
movq -0x598(%rbp), %rdx
leaq 0x4e9b5(%rip), %rsi     # 0x5fe61
leaq -0x288(%rbp), %rdi
callq 0xd8b0
jmp 0x114ba
leaq -0x240(%rbp), %rdi
movl $0x23, %esi
leaq -0x260(%rbp), %rdx
leaq -0x288(%rbp), %rcx
xorl %r8d, %r8d
callq 0x12f00
jmp 0x114de
leaq -0x240(%rbp), %rdi
callq 0x12e20
jmp 0x114ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x12a10
jmp 0x11b4a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x12a10
jmp 0x11b4a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1158c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x11574
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x11568
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x12f50
leaq -0x288(%rbp), %rdi
callq 0xdca8
leaq -0x289(%rbp), %rdi
callq 0xd6b0
leaq -0x260(%rbp), %rdi
callq 0xdca8
leaq -0x261(%rbp), %rdi
callq 0xd6b0
jmp 0x11b4a
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x124d0
movl -0x14c(%rbp), %ecx
cmpq %rcx, %rax
ja 0x115d4
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x124d0
movl %eax, %ecx
movl -0x14c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14c(%rbp)
jmp 0x115de
movl $0x0, -0x14c(%rbp)
jmp 0x115e0
movq -0x18(%rbp), %rdi
callq 0x12470
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x599(%rbp)
jne 0x11615
movl -0x14c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14c(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0x599(%rbp)
movb -0x599(%rbp), %al
testb $0x1, %al
jne 0x11624
jmp 0x11a43
leaq -0x2a8(%rbp), %rdi
callq 0x12450
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12820
movq %rax, -0x5b0(%rbp)
leaq -0x2c1(%rbp), %rdi
movq %rdi, -0x5a8(%rbp)
callq 0x11e10
movq -0x5b0(%rbp), %rdx
movq -0x5a8(%rbp), %rcx
leaq -0x2c0(%rbp), %rdi
movl $0x1, %esi
callq 0x12f70
jmp 0x11678
leaq -0x2c1(%rbp), %rdi
callq 0x11eb0
movl $0x0, -0x2c8(%rbp)
leaq -0x2a8(%rbp), %rdi
callq 0x125c0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x5b1(%rbp)
jne 0x116ab
jmp 0x116d7
movl -0x2c8(%rbp), %eax
movq %rax, -0x5c0(%rbp)
movq -0x20(%rbp), %rdi
callq 0x124b0
movq %rax, %rcx
movq -0x5c0(%rbp), %rax
cmpq %rcx, %rax
setb %al
movb %al, -0x5b1(%rbp)
movb -0x5b1(%rbp), %al
testb $0x1, %al
jne 0x116e6
jmp 0x11770
movq -0x20(%rbp), %rdi
movl -0x2c8(%rbp), %eax
movl %eax, %esi
callq 0x12ff0
movq %rax, %rsi
leaq -0x2e0(%rbp), %rdi
leaq -0x2c0(%rbp), %rdx
callq 0x12510
jmp 0x1170f
leaq -0x2a8(%rbp), %rdi
leaq -0x2e0(%rbp), %rsi
callq 0x13010
leaq -0x2e0(%rbp), %rdi
callq 0x12700
movl -0x2c8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c8(%rbp)
jmp 0x1168e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x2c1(%rbp), %rdi
callq 0x11eb0
jmp 0x11a32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x11a26
leaq -0x2a8(%rbp), %rdi
callq 0x125c0
testb $0x1, %al
jne 0x1195b
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12820
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0xd060
jmp 0x1179f
movq -0x530(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x5d8(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12820
movq -0x530(%rbp), %rdi
movq %rax, -0x5d0(%rbp)
movl $0x200, %esi            # imm = 0x200
callq 0xeb90
movq -0x530(%rbp), %rdi
movb %al, -0x5da(%rbp)
movl $0x400, %esi            # imm = 0x400
callq 0xeb90
movq -0x530(%rbp), %rdi
movb %al, -0x5d9(%rbp)
movl $0x800, %esi            # imm = 0x800
callq 0xeb90
movb -0x5da(%rbp), %dl
movb -0x5d9(%rbp), %cl
movq -0x5d8(%rbp), %rdi
movq -0x5d0(%rbp), %rsi
movzbl %dl, %edx
movzbl %cl, %ecx
movzbl %al, %r8d
callq 0x25300
movq %rax, -0x5c8(%rbp)
jmp 0x11836
movq -0x5c8(%rbp), %rax
movq %rax, -0x2e8(%rbp)
cmpq $0x0, -0x2e8(%rbp)
je 0x11959
leaq -0x3c9(%rbp), %rdi
movq %rdi, -0x5e8(%rbp)
callq 0xdb50
movq -0x5e8(%rbp), %rdx
leaq 0x4e5ee(%rip), %rsi     # 0x5fe61
leaq -0x3c8(%rbp), %rdi
callq 0xd8b0
jmp 0x11881
leaq -0x3f1(%rbp), %rdi
movq %rdi, -0x5f0(%rbp)
callq 0xdb50
movq -0x5f0(%rbp), %rdx
leaq 0x4e5bf(%rip), %rsi     # 0x5fe61
leaq -0x3f0(%rbp), %rdi
callq 0xd8b0
jmp 0x118b0
leaq -0x3a8(%rbp), %rdi
movl $0x22, %esi
leaq -0x3c8(%rbp), %rdx
leaq -0x3f0(%rbp), %rcx
xorl %r8d, %r8d
callq 0x12f00
jmp 0x118d4
leaq -0x3a8(%rbp), %rdi
callq 0x12e20
jmp 0x118e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x11948
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x11930
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x11924
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x12f50
leaq -0x3f0(%rbp), %rdi
callq 0xdca8
leaq -0x3f1(%rbp), %rdi
callq 0xd6b0
leaq -0x3c8(%rbp), %rdi
callq 0xdca8
leaq -0x3c9(%rbp), %rdi
callq 0xd6b0
jmp 0x11a26
jmp 0x1195b
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x5f8(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12820
movq -0x5f8(%rbp), %rdi
movq %rax, %rsi
callq 0x127b0
jmp 0x11988
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x600(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12820
movq -0x600(%rbp), %rdi
movq %rax, %rsi
callq 0x127b0
jmp 0x119b5
movq -0x18(%rbp), %rdi
movq %rdi, -0x610(%rbp)
callq 0x128b0
movq %rax, -0x408(%rbp)
leaq -0x400(%rbp), %rdi
leaq -0x408(%rbp), %rsi
callq 0x128e0
movq -0x610(%rbp), %rdi
movq -0x400(%rbp), %rsi
callq 0x12840
movq %rax, -0x608(%rbp)
jmp 0x119fb
movq -0x608(%rbp), %rax
movq %rax, -0x410(%rbp)
leaq -0x2c0(%rbp), %rdi
callq 0x11db0
leaq -0x2a8(%rbp), %rdi
callq 0x12700
jmp 0x115e0
leaq -0x2c0(%rbp), %rdi
callq 0x11db0
leaq -0x2a8(%rbp), %rdi
callq 0x12700
jmp 0x11b4a
jmp 0x11bb1
leaq -0x4f1(%rbp), %rdi
movq %rdi, -0x618(%rbp)
callq 0xdb50
movq -0x618(%rbp), %rdx
leaq 0x4e3f8(%rip), %rsi     # 0x5fe61
leaq -0x4f0(%rbp), %rdi
callq 0xd8b0
jmp 0x11a77
leaq -0x519(%rbp), %rdi
movq %rdi, -0x620(%rbp)
callq 0xdb50
movq -0x620(%rbp), %rdx
leaq 0x4e3c9(%rip), %rsi     # 0x5fe61
leaq -0x518(%rbp), %rdi
callq 0xd8b0
jmp 0x11aa6
leaq -0x4d0(%rbp), %rdi
movl $0x22, %esi
leaq -0x4f0(%rbp), %rdx
leaq -0x518(%rbp), %rcx
xorl %r8d, %r8d
callq 0x12f00
jmp 0x11aca
leaq -0x4d0(%rbp), %rdi
callq 0x12e20
jmp 0x11ad8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x11b3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x11b26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x11b1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x4d0(%rbp), %rdi
callq 0x12f50
leaq -0x518(%rbp), %rdi
callq 0xdca8
leaq -0x519(%rbp), %rdi
callq 0xd6b0
leaq -0x4f0(%rbp), %rdi
callq 0xdca8
leaq -0x4f1(%rbp), %rdi
callq 0xd6b0
movl -0x4c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x11be1
movq -0x48(%rbp), %rdi
callq 0xd200
movq -0x530(%rbp), %rdi
movq %rax, -0x528(%rbp)
movq -0x528(%rbp), %rax
movq %rax, -0x630(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x628(%rbp)
callq 0xec00
movq -0x630(%rbp), %rdi
movq -0x628(%rbp), %rsi
movl %eax, %ecx
leaq -0x40(%rbp), %rdx
callq 0x12960
jmp 0x11baa
callq 0xd990
jmp 0x11bfb
jmp 0x11bc8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0xda90
jmp 0x11bc6
jmp 0x11be1
movl $0x0, -0x5c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xdca8
addq $0x630, %rsp            # imm = 0x630
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0xdca8
movq -0x48(%rbp), %rdi
callq 0xdb30
movq %rax, %rdi
callq 0x129b0
nopl (%rax,%rax)