// File: demon386[P]git-store/./libs/program_options/src/cmdline.cpp
// Function: boost::program_options::detail::cmdline::run()
vector<option>
    cmdline::run()
    {
        // The parsing is done by having a set of 'style parsers'
        // and trying then in order. Each parser is passed a vector
        // of unparsed tokens and can consume some of them (by
        // removing elements on front) and return a vector of options.
        //
        // We try each style parser in turn, untill some input
        // is consumed. The returned vector of option may contain the
        // result of just syntactic parsing of token, say --foo will
        // be parsed as option with name 'foo', and the style parser
        // is not required to care if that option is defined, and how
        // many tokens the value may take.
        // So, after vector is returned, we validate them.
        assert(m_desc);

        vector<style_parser> style_parsers;      

        if (m_style_parser)
            style_parsers.push_back(m_style_parser);

        if (m_additional_parser)
            style_parsers.push_back(
                boost::bind(&cmdline::handle_additional_parser, this, _1));

        if (m_style & allow_long)
            style_parsers.push_back(
                boost::bind(&cmdline::parse_long_option, this, _1));

        if ((m_style & allow_long_disguise))
            style_parsers.push_back(
                boost::bind(&cmdline::parse_disguised_long_option, this, _1));

        if ((m_style & allow_short) && (m_style & allow_dash_for_short))
            style_parsers.push_back(
                boost::bind(&cmdline::parse_short_option, this, _1));

        if ((m_style & allow_short) && (m_style & allow_slash_for_short))
            style_parsers.push_back(boost::bind(&cmdline::parse_dos_option, this, _1));

        style_parsers.push_back(boost::bind(&cmdline::parse_terminator, this, _1));

        vector<option> result;
        while(!args.empty())
        {
            bool ok = false;
            for(unsigned i = 0; i < style_parsers.size(); ++i)
            {
                unsigned current_size = static_cast<unsigned>(args.size());
                vector<option> next = style_parsers[i](args);

                // Check that option names
                // are valid, and that all values are in place.
                if (!next.empty())
                {
                    vector<string> e;
                    for(unsigned k = 0; k < next.size()-1; ++k) {
                        finish_option(next[k], e, style_parsers);
                    }
                    // For the last option, pass the unparsed tokens
                    // so that they can be added to next.back()'s values
                    // if appropriate.
                    finish_option(next.back(), args, style_parsers);
                    for (unsigned j = 0; j < next.size(); ++j)
                        result.push_back(next[j]);                    
                }
                                
                if (args.size() != current_size) {
                    ok = true;
                    break;                
                } 
            }
            
            if (!ok) {
                option opt;
                opt.value.push_back(args[0]);
                opt.original_tokens.push_back(args[0]);
                result.push_back(opt);
                args.erase(args.begin());
            }
        }

        /* If an key option is followed by a positional option,
           can can consume more tokens (e.g. it's multitoken option),
           give those tokens to it.  */
        vector<option> result2;
        for (unsigned i = 0; i < result.size(); ++i)
        {
            result2.push_back(result[i]);
            option& opt = result2.back();

            if (opt.string_key.empty())
                continue;

            const option_description* xd;
            try
            {
                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));
            } 
            catch(error_with_option_name& e)
            {
                // add context and rethrow
                e.add_context(opt.string_key, opt.original_tokens[0], get_canonical_option_prefix());
                throw;
            }

            if (!xd)
                continue;

            if (xd->semantic()->adjacent_tokens_only())
                continue;

            unsigned min_tokens = xd->semantic()->min_tokens();
            unsigned max_tokens = xd->semantic()->max_tokens();
            if (min_tokens < max_tokens && opt.value.size() < max_tokens)
            {
                // This option may grab some more tokens.
                // We only allow to grab tokens that are not already
                // recognized as key options.

                int can_take_more = max_tokens - static_cast<int>(opt.value.size());
                unsigned j = i+1;
                for (; can_take_more && j < result.size(); --can_take_more, ++j)
                {
                    option& opt2 = result[j];
                    if (!opt2.string_key.empty())
                        break;

                    if (opt2.position_key == INT_MAX)
                    {
                        // We use INT_MAX to mark positional options that
                        // were found after the '--' terminator and therefore
                        // should stay positional forever.
                        break;
                    }

                    assert(opt2.value.size() == 1);
                    
                    opt.value.push_back(opt2.value[0]);

                    assert(opt2.original_tokens.size() == 1);

                    opt.original_tokens.push_back(opt2.original_tokens[0]);
                }
                i = j-1;
            }
        }
        result.swap(result2);
        

        // Assign position keys to positional options.
        int position_key = 0;
        for(unsigned i = 0; i < result.size(); ++i) {
            if (result[i].string_key.empty())
                result[i].position_key = position_key++;
        }

        if (m_positional)
        {
            unsigned position = 0;
            for (unsigned i = 0; i < result.size(); ++i) {
                option& opt = result[i];
                if (opt.position_key != -1) {
                    if (position >= m_positional->max_total_count())
                    {
                        boost::throw_exception(too_many_positional_options_error());
                    }
                    opt.string_key = m_positional->name_for_position(position);
                    ++position;
                }
            }
        }
        
        // set case sensitive flag
        for (unsigned i = 0; i < result.size(); ++i) {
            if (result[i].string_key.size() > 2 ||
                        (result[i].string_key.size() > 1 && result[i].string_key[0] != '-'))
            {
                // it is a long option
                result[i].case_insensitive = is_style_active(long_case_insensitive);
            }
            else
            {
                // it is a short option
                result[i].case_insensitive = is_style_active(short_case_insensitive);
            }
        }

        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp            # imm = 0x4E0
movq %rdi, -0x3b0(%rbp)
movq %rdi, %rax
movq %rax, -0x3a8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x3a0(%rbp)
cmpq $0x0, 0x20(%rax)
je 0xecd8
jmp 0xecf7
leaq 0x507a3(%rip), %rdi     # 0x5f482
leaq 0x507a3(%rip), %rsi     # 0x5f489
movl $0xda, %edx
leaq 0x507be(%rip), %rcx     # 0x5f4b0
callq 0xd400
leaq -0x28(%rbp), %rdi
callq 0x12230
movq -0x3a0(%rbp), %rdi
addq $0x50, %rdi
callq 0x12250
movq %rax, -0x3b8(%rbp)
jmp 0xed19
movq -0x3b8(%rbp), %rax
cmpq $0x0, %rax
je 0xed4f
movq -0x3a0(%rbp), %rsi
addq $0x50, %rsi
leaq -0x28(%rbp), %rdi
callq 0x12280
jmp 0xed3c
jmp 0xed4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xfe4f
movq -0x3a0(%rbp), %rdi
addq $0x30, %rdi
callq 0x122f0
movq %rax, -0x3c0(%rbp)
jmp 0xed68
movq -0x3c0(%rbp), %rax
cmpq $0x0, %rax
je 0xedff
movq -0x3a0(%rbp), %rcx
leaq 0x10e9(%rip), %rax      # 0xfe70
movq %rax, -0x88(%rbp)
movq $0x0, -0x80(%rbp)
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x12350
jmp 0xedac
movq -0x60(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x70(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
callq 0x123e0
jmp 0xedcb
leaq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x12320
jmp 0xedda
leaq -0x58(%rbp), %rdi
callq 0x11d50
jmp 0xedff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x11d50
jmp 0xfe4f
movq -0x3a0(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xeeb6
movq -0x3a0(%rbp), %rcx
leaq 0x121d(%rip), %rax      # 0x10040
movq %rax, -0xd8(%rbp)
movq $0x0, -0xd0(%rbp)
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
callq 0x12350
jmp 0xee51
movq -0xb0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0xc0(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
callq 0x123e0
jmp 0xee79
leaq -0x28(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x12320
jmp 0xee8b
leaq -0xa8(%rbp), %rdi
callq 0x11d50
jmp 0xeeb6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x11d50
jmp 0xfe4f
movq -0x3a0(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0xef6f
movq -0x3a0(%rbp), %rcx
leaq 0x14c4(%rip), %rax      # 0x103a0
movq %rax, -0x128(%rbp)
movq $0x0, -0x120(%rbp)
movq -0x128(%rbp), %rsi
movq -0x120(%rbp), %rdx
leaq -0x110(%rbp), %rdi
callq 0x12350
jmp 0xef0a
movq -0x100(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x110(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0xf8(%rbp), %rdi
xorl %esi, %esi
callq 0x123e0
jmp 0xef32
leaq -0x28(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x12320
jmp 0xef44
leaq -0xf8(%rbp), %rdi
callq 0x11d50
jmp 0xef6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x11d50
jmp 0xfe4f
movq -0x3a0(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xf03c
movq -0x3a0(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xf03c
movq -0x3a0(%rbp), %rcx
leaq 0x16d7(%rip), %rax      # 0x10680
movq %rax, -0x178(%rbp)
movq $0x0, -0x170(%rbp)
movq -0x178(%rbp), %rsi
movq -0x170(%rbp), %rdx
leaq -0x160(%rbp), %rdi
callq 0x12350
jmp 0xefd7
movq -0x150(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x160(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x148(%rbp), %rdi
xorl %esi, %esi
callq 0x123e0
jmp 0xefff
leaq -0x28(%rbp), %rdi
leaq -0x148(%rbp), %rsi
callq 0x12320
jmp 0xf011
leaq -0x148(%rbp), %rdi
callq 0x11d50
jmp 0xf03c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x11d50
jmp 0xfe4f
movq -0x3a0(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xf109
movq -0x3a0(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xf109
movq -0x3a0(%rbp), %rcx
leaq 0x1c8a(%rip), %rax      # 0x10d00
movq %rax, -0x1c8(%rbp)
movq $0x0, -0x1c0(%rbp)
movq -0x1c8(%rbp), %rsi
movq -0x1c0(%rbp), %rdx
leaq -0x1b0(%rbp), %rdi
callq 0x12350
jmp 0xf0a4
movq -0x1a0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x1b0(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x198(%rbp), %rdi
xorl %esi, %esi
callq 0x123e0
jmp 0xf0cc
leaq -0x28(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x12320
jmp 0xf0de
leaq -0x198(%rbp), %rdi
callq 0x11d50
jmp 0xf109
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x11d50
jmp 0xfe4f
movq -0x3a0(%rbp), %rcx
leaq 0x1e59(%rip), %rax      # 0x10f70
movq %rax, -0x218(%rbp)
movq $0x0, -0x210(%rbp)
movq -0x218(%rbp), %rsi
movq -0x210(%rbp), %rdx
leaq -0x200(%rbp), %rdi
callq 0x12350
jmp 0xf145
movq -0x1f0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x200(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x1e8(%rbp), %rdi
xorl %esi, %esi
callq 0x123e0
jmp 0xf16d
leaq -0x28(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x12320
jmp 0xf17f
leaq -0x1e8(%rbp), %rdi
callq 0x11d50
movq -0x3b0(%rbp), %rdi
movb $0x0, -0x219(%rbp)
callq 0x12450
movq -0x3a0(%rbp), %rdi
callq 0x12470
xorb $-0x1, %al
testb $0x1, %al
jne 0xf1b5
jmp 0xf52a
movb $0x0, -0x21a(%rbp)
movl $0x0, -0x220(%rbp)
movl -0x220(%rbp), %eax
movq %rax, -0x3c8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x124b0
movq %rax, %rcx
movq -0x3c8(%rbp), %rax
cmpq %rcx, %rax
jae 0xf41c
movq -0x3a0(%rbp), %rdi
callq 0x124d0
movl %eax, -0x224(%rbp)
movl -0x220(%rbp), %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x124f0
movq -0x3a0(%rbp), %rdx
movq %rax, %rsi
leaq -0x240(%rbp), %rdi
callq 0x12510
jmp 0xf22a
leaq -0x240(%rbp), %rdi
callq 0x125c0
testb $0x1, %al
jne 0xf3b8
leaq -0x258(%rbp), %rdi
callq 0x11cf0
movl $0x0, -0x25c(%rbp)
movl -0x25c(%rbp), %eax
movq %rax, -0x3d0(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x12600
movq %rax, %rcx
movq -0x3d0(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0xf31e
movl -0x25c(%rbp), %eax
movl %eax, %esi
leaq -0x240(%rbp), %rdi
callq 0x12630
movq -0x3a0(%rbp), %rdi
movq %rax, %rsi
leaq -0x258(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x11110
jmp 0xf2b4
jmp 0xf2b6
movl -0x25c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x25c(%rbp)
jmp 0xf254
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x11d50
jmp 0xfe4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xfe43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x258(%rbp), %rdi
callq 0x11db0
leaq -0x240(%rbp), %rdi
callq 0x12700
jmp 0xfe43
leaq -0x240(%rbp), %rdi
callq 0x12650
movq -0x3a0(%rbp), %rdx
movq %rax, %rsi
leaq -0x28(%rbp), %rcx
movq %rdx, %rdi
callq 0x11110
jmp 0xf342
movl $0x0, -0x260(%rbp)
movl -0x260(%rbp), %eax
movq %rax, -0x3d8(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x12600
movq %rax, %rcx
movq -0x3d8(%rbp), %rax
cmpq %rcx, %rax
jae 0xf3ac
movl -0x260(%rbp), %eax
movl %eax, %esi
leaq -0x240(%rbp), %rdi
callq 0x12630
movq -0x3b0(%rbp), %rdi
movq %rax, %rsi
callq 0x12690
jmp 0xf399
jmp 0xf39b
movl -0x260(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x260(%rbp)
jmp 0xf34c
leaq -0x258(%rbp), %rdi
callq 0x11db0
movq -0x3a0(%rbp), %rdi
callq 0x124d0
movl -0x224(%rbp), %ecx
cmpq %rcx, %rax
je 0xf3e2
movb $0x1, -0x21a(%rbp)
movl $0x4, -0x264(%rbp)
jmp 0xf3ec
movl $0x0, -0x264(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x12700
movl -0x264(%rbp), %eax
testl %eax, %eax
je 0xf406
jmp 0xf404
jmp 0xf41c
jmp 0xf408
movl -0x220(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x220(%rbp)
jmp 0xf1c6
testb $0x1, -0x21a(%rbp)
jne 0xf525
leaq -0x2c8(%rbp), %rdi
callq 0x12760
jmp 0xf437
movq -0x3a0(%rbp), %rdi
leaq -0x2a0(%rbp), %rax
movq %rax, -0x3e0(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x12820
movq -0x3e0(%rbp), %rdi
movq %rax, %rsi
callq 0x127b0
jmp 0xf466
movq -0x3a0(%rbp), %rdi
leaq -0x288(%rbp), %rax
movq %rax, -0x3e8(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x12820
movq -0x3e8(%rbp), %rdi
movq %rax, %rsi
callq 0x127b0
jmp 0xf495
movq -0x3b0(%rbp), %rdi
leaq -0x2c8(%rbp), %rsi
callq 0x12690
jmp 0xf4aa
movq -0x3a0(%rbp), %rdi
callq 0x128b0
movq %rax, -0x2d8(%rbp)
leaq -0x2d0(%rbp), %rdi
leaq -0x2d8(%rbp), %rsi
callq 0x128e0
movq -0x3a0(%rbp), %rdi
movq -0x2d0(%rbp), %rsi
callq 0x12840
movq %rax, -0x3f0(%rbp)
jmp 0xf4ec
movq -0x3f0(%rbp), %rax
movq %rax, -0x2e0(%rbp)
leaq -0x2c8(%rbp), %rdi
callq 0x12920
jmp 0xf525
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x2c8(%rbp), %rdi
callq 0x12920
jmp 0xfe43
jmp 0xf19e
leaq -0x2f8(%rbp), %rdi
callq 0x12450
movl $0x0, -0x2fc(%rbp)
movq -0x3b0(%rbp), %rdi
movl -0x2fc(%rbp), %eax
movq %rax, -0x3f8(%rbp)
callq 0x12600
movq %rax, %rcx
movq -0x3f8(%rbp), %rax
cmpq %rcx, %rax
jae 0xfab1
movq -0x3b0(%rbp), %rdi
movl -0x2fc(%rbp), %eax
movl %eax, %esi
callq 0x12630
movq %rax, %rsi
leaq -0x2f8(%rbp), %rdi
callq 0x12690
jmp 0xf591
leaq -0x2f8(%rbp), %rdi
callq 0x12650
movq %rax, -0x308(%rbp)
movq -0x308(%rbp), %rdi
callq 0xdab0
testb $0x1, %al
jne 0xf5b6
jmp 0xf5cc
jmp 0xfa9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xfe10
movq -0x3a0(%rbp), %rdi
movq 0x20(%rdi), %rax
movq %rax, -0x410(%rbp)
movq -0x308(%rbp), %rax
movq %rax, -0x408(%rbp)
movl $0x200, %esi            # imm = 0x200
callq 0xeb90
movq -0x3a0(%rbp), %rdi
movb %al, -0x412(%rbp)
movl $0x400, %esi            # imm = 0x400
callq 0xeb90
movq -0x3a0(%rbp), %rdi
movb %al, -0x411(%rbp)
movl $0x800, %esi            # imm = 0x800
callq 0xeb90
movb -0x412(%rbp), %dl
movb -0x411(%rbp), %cl
movq -0x410(%rbp), %rdi
movq -0x408(%rbp), %rsi
movzbl %dl, %edx
movzbl %cl, %ecx
movzbl %al, %r8d
callq 0x25300
movq %rax, -0x400(%rbp)
jmp 0xf656
movq -0x400(%rbp), %rax
movq %rax, -0x310(%rbp)
jmp 0xf711
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xfe10
movq -0x30(%rbp), %rdi
callq 0xd200
movq %rax, -0x318(%rbp)
movq -0x318(%rbp), %rax
movq %rax, -0x430(%rbp)
movq -0x308(%rbp), %rdi
movq %rdi, -0x428(%rbp)
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12820
movq -0x3a0(%rbp), %rdi
movq %rax, -0x420(%rbp)
callq 0xec00
movq -0x430(%rbp), %rdi
movq -0x428(%rbp), %rsi
movq -0x420(%rbp), %rdx
movl %eax, %ecx
callq 0x12960
jmp 0xf6ef
callq 0xd990
jmp 0xfe69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xda90
jmp 0xf70c
jmp 0xfe10
cmpq $0x0, -0x310(%rbp)
jne 0xf720
jmp 0xfa9d
movq -0x310(%rbp), %rsi
leaq -0x328(%rbp), %rdi
callq 0x248d0
jmp 0xf735
leaq -0x328(%rbp), %rdi
callq 0x129c0
movq %rax, -0x438(%rbp)
jmp 0xf74a
movq -0x438(%rbp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movb %al, -0x439(%rbp)
jmp 0xf762
leaq -0x328(%rbp), %rdi
callq 0x12a10
movb -0x439(%rbp), %al
testb $0x1, %al
jne 0xf77a
jmp 0xf79c
jmp 0xfa9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x328(%rbp), %rdi
callq 0x12a10
jmp 0xfe10
movq -0x310(%rbp), %rsi
leaq -0x340(%rbp), %rdi
callq 0x248d0
jmp 0xf7b1
leaq -0x340(%rbp), %rdi
callq 0x129c0
movq %rax, -0x448(%rbp)
jmp 0xf7c6
movq -0x448(%rbp), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movl %eax, -0x44c(%rbp)
jmp 0xf7de
leaq -0x340(%rbp), %rdi
callq 0x12a10
movl -0x44c(%rbp), %eax
movl %eax, -0x32c(%rbp)
movq -0x310(%rbp), %rsi
leaq -0x358(%rbp), %rdi
callq 0x248d0
jmp 0xf80b
leaq -0x358(%rbp), %rdi
callq 0x129c0
movq %rax, -0x458(%rbp)
jmp 0xf820
movq -0x458(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movl %eax, -0x45c(%rbp)
jmp 0xf838
leaq -0x358(%rbp), %rdi
callq 0x12a10
movl -0x45c(%rbp), %eax
movl %eax, -0x344(%rbp)
movl -0x32c(%rbp), %eax
cmpl -0x344(%rbp), %eax
jae 0xfa9b
movq -0x308(%rbp), %rdi
addq $0x28, %rdi
callq 0x124d0
movl -0x344(%rbp), %ecx
cmpq %rcx, %rax
jae 0xfa9b
movl -0x344(%rbp), %eax
movl %eax, -0x460(%rbp)
movq -0x308(%rbp), %rdi
addq $0x28, %rdi
callq 0x124d0
movq %rax, %rcx
movl -0x460(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x35c(%rbp)
movl -0x2fc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x360(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x35c(%rbp)
movb %al, -0x461(%rbp)
je 0xf8fd
movq -0x3b0(%rbp), %rdi
movl -0x360(%rbp), %eax
movq %rax, -0x470(%rbp)
callq 0x12600
movq %rax, %rcx
movq -0x470(%rbp), %rax
cmpq %rcx, %rax
setb %al
movb %al, -0x461(%rbp)
movb -0x461(%rbp), %al
testb $0x1, %al
jne 0xf90c
jmp 0xfa8c
movq -0x3b0(%rbp), %rdi
movl -0x360(%rbp), %eax
movl %eax, %esi
callq 0x12630
movq %rax, -0x368(%rbp)
movq -0x368(%rbp), %rdi
callq 0xdab0
testb $0x1, %al
jne 0xf976
jmp 0xfa8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x340(%rbp), %rdi
callq 0x12a10
jmp 0xfe10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x358(%rbp), %rdi
callq 0x12a10
jmp 0xfe10
movq -0x368(%rbp), %rax
cmpl $0x7fffffff, 0x20(%rax) # imm = 0x7FFFFFFF
jne 0xf98b
jmp 0xfa8c
movq -0x368(%rbp), %rdi
addq $0x28, %rdi
callq 0x124d0
cmpq $0x1, %rax
jne 0xf9a3
jmp 0xf9c2
leaq 0x4fb44(%rip), %rdi     # 0x5f4ee
leaq 0x4fad8(%rip), %rsi     # 0x5f489
movl $0x157, %edx            # imm = 0x157
leaq 0x4faf3(%rip), %rcx     # 0x5f4b0
callq 0xd400
movq -0x308(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x478(%rbp)
movq -0x368(%rbp), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12820
movq -0x478(%rbp), %rdi
movq %rax, %rsi
callq 0x127b0
jmp 0xf9f9
movq -0x368(%rbp), %rdi
addq $0x40, %rdi
callq 0x124d0
cmpq $0x1, %rax
jne 0xfa11
jmp 0xfa30
leaq 0x4faed(%rip), %rdi     # 0x5f505
leaq 0x4fa6a(%rip), %rsi     # 0x5f489
movl $0x15b, %edx            # imm = 0x15B
leaq 0x4fa85(%rip), %rcx     # 0x5f4b0
callq 0xd400
movq -0x308(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x480(%rbp)
movq -0x368(%rbp), %rdi
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12820
movq -0x480(%rbp), %rdi
movq %rax, %rsi
callq 0x127b0
jmp 0xfa67
jmp 0xfa69
movl -0x35c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x35c(%rbp)
movl -0x360(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x360(%rbp)
jmp 0xf8bd
movl -0x360(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2fc(%rbp)
jmp 0xfa9d
movl -0x2fc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2fc(%rbp)
jmp 0xf540
movq -0x3b0(%rbp), %rdi
leaq -0x2f8(%rbp), %rsi
callq 0x12a30
movl $0x0, -0x36c(%rbp)
movl $0x0, -0x370(%rbp)
movq -0x3b0(%rbp), %rdi
movl -0x370(%rbp), %eax
movq %rax, -0x488(%rbp)
callq 0x12600
movq %rax, %rcx
movq -0x488(%rbp), %rax
cmpq %rcx, %rax
jae 0xfb6a
movq -0x3b0(%rbp), %rdi
movl -0x370(%rbp), %eax
movl %eax, %esi
callq 0x12630
movq %rax, %rdi
callq 0xdab0
testb $0x1, %al
jne 0xfb22
jmp 0xfb54
movq -0x3b0(%rbp), %rdi
movl -0x36c(%rbp), %eax
movl %eax, -0x48c(%rbp)
addl $0x1, %eax
movl %eax, -0x36c(%rbp)
movl -0x370(%rbp), %eax
movl %eax, %esi
callq 0x12630
movl -0x48c(%rbp), %ecx
movl %ecx, 0x20(%rax)
jmp 0xfb56
movl -0x370(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x370(%rbp)
jmp 0xfad8
movq -0x3a0(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xfcb0
movl $0x0, -0x374(%rbp)
movl $0x0, -0x378(%rbp)
movq -0x3b0(%rbp), %rdi
movl -0x378(%rbp), %eax
movq %rax, -0x498(%rbp)
callq 0x12600
movq %rax, %rcx
movq -0x498(%rbp), %rax
cmpq %rcx, %rax
jae 0xfcae
movq -0x3b0(%rbp), %rdi
movl -0x378(%rbp), %eax
movl %eax, %esi
callq 0x12630
movq %rax, -0x380(%rbp)
movq -0x380(%rbp), %rax
cmpl $-0x1, 0x20(%rax)
je 0xfc98
movq -0x3a0(%rbp), %rax
movl -0x374(%rbp), %ecx
movl %ecx, -0x4a0(%rbp)
movq 0x28(%rax), %rdi
callq 0x34d80
movl %eax, -0x49c(%rbp)
jmp 0xfc0c
movl -0x4a0(%rbp), %eax
movl -0x49c(%rbp), %ecx
cmpl %ecx, %eax
jb 0xfc55
leaq -0x390(%rbp), %rdi
callq 0x12b40
jmp 0xfc2a
leaq -0x390(%rbp), %rdi
callq 0x12a90
jmp 0xfc38
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x390(%rbp), %rdi
callq 0x12bf0
jmp 0xfe10
movq -0x3a0(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0x374(%rbp), %esi
callq 0x34dd0
movq %rax, -0x4a8(%rbp)
jmp 0xfc74
movq -0x4a8(%rbp), %rsi
movq -0x380(%rbp), %rdi
callq 0xd060
jmp 0xfc89
movl -0x374(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x374(%rbp)
jmp 0xfc9a
movl -0x378(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x378(%rbp)
jmp 0xfb90
jmp 0xfcb0
movl $0x0, -0x394(%rbp)
movq -0x3b0(%rbp), %rdi
movl -0x394(%rbp), %eax
movq %rax, -0x4b0(%rbp)
callq 0x12600
movq %rax, %rcx
movq -0x4b0(%rbp), %rax
cmpq %rcx, %rax
jae 0xfde8
movq -0x3b0(%rbp), %rdi
movl -0x394(%rbp), %eax
movl %eax, %esi
callq 0x12630
movq %rax, %rdi
callq 0xd430
cmpq $0x2, %rax
ja 0xfd62
movq -0x3b0(%rbp), %rdi
movl -0x394(%rbp), %eax
movl %eax, %esi
callq 0x12630
movq %rax, %rdi
callq 0xd430
cmpq $0x1, %rax
jbe 0xfd9b
movq -0x3b0(%rbp), %rdi
movl -0x394(%rbp), %eax
movl %eax, %esi
callq 0x12630
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdc50
movq %rax, -0x4b8(%rbp)
jmp 0xfd53
movq -0x4b8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0xfd9b
movq -0x3a0(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0xeb90
movq -0x3b0(%rbp), %rdi
movb %al, -0x4b9(%rbp)
movl -0x394(%rbp), %eax
movl %eax, %esi
callq 0x12630
movb -0x4b9(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x59(%rax)
jmp 0xfdd2
movq -0x3a0(%rbp), %rdi
movl $0x800, %esi            # imm = 0x800
callq 0xeb90
movq -0x3b0(%rbp), %rdi
movb %al, -0x4ba(%rbp)
movl -0x394(%rbp), %eax
movl %eax, %esi
callq 0x12630
movb -0x4ba(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x59(%rax)
jmp 0xfdd4
movl -0x394(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x394(%rbp)
jmp 0xfcba
movb $0x1, -0x219(%rbp)
movl $0x1, -0x264(%rbp)
leaq -0x2f8(%rbp), %rdi
callq 0x12700
testb $0x1, -0x219(%rbp)
jne 0xfe2a
jmp 0xfe1e
leaq -0x2f8(%rbp), %rdi
callq 0x12700
jmp 0xfe43
movq -0x3b0(%rbp), %rdi
callq 0x12700
leaq -0x28(%rbp), %rdi
callq 0x12c10
movq -0x3a8(%rbp), %rax
addq $0x4e0, %rsp            # imm = 0x4E0
popq %rbp
retq
movq -0x3b0(%rbp), %rdi
callq 0x12700
leaq -0x28(%rbp), %rdi
callq 0x12c10
movq -0x30(%rbp), %rdi
callq 0xdb30
movq %rax, %rdi
callq 0x129b0
nopl (%rax)