// File: kmyk[P]codevs-for-student-2016/Main.cpp
// Function: AI::think(primitive::input_t const&)
output_t think(input_t const & input) {
#ifndef RELEASE
        stopwatch watch, total_watch;
#endif

#ifndef RELEASE
        // logging
        cerr << endl;
        cerr << "turn: " << input.turn << endl;
        cerr << "remaining time: " << input.remaining_time << endl;
        cerr << "score: " << (scores.empty() ? 0 : scores.back()) << endl;
        cerr << "obstacles: " << input.self_obstacles - input.opponent_obstacles << endl;
        cerr << "self dropped obstacles: " << count_obstacle_blocks(input.self_field) << endl;
        cerr << "opp. dropped obstacles: " << count_obstacle_blocks(input.opponent_field) << endl;
        cerr << "self estimated chain: " << estimate_with_erasing(input.self_field).chain << endl;
        cerr << "opp. estimated chain: " << estimate_with_erasing(input.opponent_field).chain << endl;

        // check
        if (not inputs.empty()) {
            field_t const & field = input.self_field;
            auto & last = inputs.back();
            pack_t const & last_filled_pack = fill_obstacles(config.packs[last.turn], last.self_obstacles);
            result_t result; int result_erased; field_t nfield; tie(result, result_erased, nfield) = simulate_with_output(last.self_field, last_filled_pack, outputs.back());
            if (nfield != field) {
                cerr << "<<<" << endl;
                cerr << nfield << endl;
                cerr << "===" << endl;
                cerr << field << endl;
                cerr << ">>>" << endl;
            }
            assert (nfield == field);
        }
#endif

        // prepare
        if (input.turn == 0) { // 初期化
            self_history.push_back(initial_photon(input.turn, input.self_obstacles,     input.self_field));
            oppo_history.push_back(initial_photon(input.turn, input.opponent_obstacles, input.opponent_field));
            beam_generation = 1;
        }
        { // 自分のビーム準備
            shared_ptr<photon_t> const & pho = self_history.back();
            vector<shared_ptr<photon_t> > updateds;
            bool updated = (pho->obstacles != input.self_obstacles - input.opponent_obstacles);
            if (updated) {
                if (input.self_obstacles <= 0 and input.self_obstacles - input.opponent_obstacles <= 0) {
                    updated = false; // 勝ってるときは時間節約のため無視
                } else {
                    update_photon_obstacles(pho, input.self_obstacles - input.opponent_obstacles, config.packs, [&](shared_ptr<photon_t> const & pho) {
                        updateds.push_back(pho);
                    });
                }
            }
            evaluate_photon_init(pho);
            step_photon_all(pho, config.packs[input.turn]);
            // ビームのcacheの更新
            if (input.turn == 0) {
                que.emplace_back(compare_photon_with_first);
                que.back().emplace(pho->evaluation.score, pho);
                pho->beam_generation = beam_generation;
            } else {
                if (is_rejected(pho)) {
                    que.clear();
                    fired.clear();
                    que.emplace_back(compare_photon_with_first);
                    beam_generation += 1;
                    que.back().emplace(pho->evaluation.score, pho);
                    pho->beam_generation = beam_generation;
                } else if (updated) {
#ifndef RELEASE
                    cerr << "queue shifted" << endl;
#endif
                    beam_generation += 1;
                    auto shift = [&](deque<functional_priority_queue<pair<double, weak_ptr<photon_t> > > > & que) {
                        que[0] = functional_priority_queue<pair<double, weak_ptr<photon_t> > >(compare_photon_with_first);
                        repeat (i, que.size() - 1) {
                            while (not que[i+1].empty()) {
                                shared_ptr<photon_t> npho = que[i+1].top().second.lock(); que[i+1].pop();
                                if (not npho) continue;
                                que[i].emplace(npho->evaluation.score, npho);
                                npho->beam_generation = beam_generation;
                            }
                            que[i+1] = functional_priority_queue<pair<double, weak_ptr<photon_t> > >(compare_photon_with_first);
                        }
                    };
                    shift(que);
                    shift(fired);
                    for (auto & pho : updateds) {
                        int i = pho->turn - input.turn;
                        while (i >= que.size()) que.emplace_back(compare_photon_with_first);
                        assert (pho->beam_generation != beam_generation);
                        que[i].emplace(pho->evaluation.score, pho);
                        pho->beam_generation = beam_generation;
                    }
                } else {
                    que.pop_front();
                    fired.pop_front();
                }
            }
        }
        if (input.turn != 0) { // 相手の準備
            shared_ptr<photon_t> const & pho = oppo_history.back();
            step_photon_all(pho, config.packs[input.turn-1]);
            output_t output = invalid_output; // 相手の出力は直接は見えない
            repeat_from (x, - pack_size + 1, width) repeat (r, 4) {
                shared_ptr<photon_t> const & npho = pho->next[x+pack_size-1][r];
                if (not npho) continue;
                if (npho->field == input.opponent_field) {
                    output = npho->output;
                    break;
                }
            }
            if (output == invalid_output) {
#ifndef RELEASE
                cerr << "oppo reset cache" << endl;
#endif
                oppo_history.push_back(initial_photon(input.turn, input.opponent_obstacles - input.self_obstacles, input.opponent_field));
            } else {
                prune_photon(pho, output);
                shared_ptr<photon_t> const & npho = pho->next[output.x+pack_size-1][output.rotate];
                oppo_history.push_back(npho);
                update_photon_obstacles(npho, input.opponent_obstacles - input.self_obstacles, config.packs, [](shared_ptr<photon_t> const & pho){}); // ここでお邪魔を更新
            }
            evaluate_photon_init(oppo_history.back());
            step_photon_all(oppo_history.back(), config.packs[input.turn]);
        }

        // 相手側の探索
#ifndef RELEASE
        watch = stopwatch();
#endif
        const int oppo_depth = max<int>(4, 8 - (180 * 1000 - input.remaining_time) / (30 * 1000));
        opponent_info_t oppo = {}; {
            const int beam_width = 60;
            const int beam_depth = oppo_depth;
            oppo.result.resize(oppo_depth);
            auto cont = [&](shared_ptr<photon_t> const & pho) {
                int age = pho->turn - input.turn;
                assert (age >= 1);
                setmax(oppo.result[age-1], pho->result);
                return is_rejected(pho) ? nullptr : pho; // 打ち切るか否か
            };
            shared_ptr<photon_t> initial = oppo_history.back();
            beam_search(initial, config, beam_width, beam_depth, cont);
        }
        oppo.dropped_obstacles = oppo_history.back()->dropped_obstacles;
        oppo.best = *whole(max_element, oppo.result);
        repeat (i, oppo_depth) setmax<int>(oppo.score, pow(0.8, i) * oppo.result[i].score); // ここけっこう重要
#ifndef RELEASE
        repeat (i, oppo_depth) {
            cerr << "oppo " << i << ": " << oppo.result[i].chain << "c " << oppo.result[i].score << "pt" << endl;
        }
        cerr << "oppo elapsed: " << watch() << "ms" << endl;
#endif

        // メインの探索 chokudai search
#ifndef RELEASE
        watch = stopwatch();
#endif
        output_t output = invalid_output; {
            const int estimated_chain = self_history.back()->evaluation.estimateds.front().first.chain;
            const int beam_width = 8; // TODO: この値がどういう意味を持つか理解する
            const int beam_depth = max(22 - min(14, input.turn), 18 - estimated_chain/2); // いい感じに減少させる
            const int time_limit = min(input.remaining_time / 30, max(1200, 170 * max(estimated_chain, oppo.best.chain))); // msec // 毎ターン数秒ずつ
            while (beam_depth+1 >= que.size()) que.emplace_back(compare_photon_with_first);
            while (fired.size() < que.size()) fired.emplace_back(compare_photon_with_first);
            bool is_fired = false;
            double best_score = - INFINITY;
            shared_ptr<photon_t> result = nullptr;
            auto cont = [&](shared_ptr<photon_t> const & pho) {
                int age = pho->turn - input.turn;
                assert (age >= 1);
                bool cur_is_fired = is_effective_firing(pho->result.score, pho->obstacles, age, oppo);
                double cur_score = evaluate_photon_for_output(pho, input.turn, oppo);
                if (make_pair(is_fired, best_score) < make_pair(cur_is_fired, cur_score)) {
                    is_fired = cur_is_fired;
                    best_score = cur_score;
                    result = pho;
#ifndef RELEASE
                    cerr << "result: +" << age << "t " << cur_score << "pt";
                    if (pho->result.chain >= chain_of_fire) {
                        bool is_eff = is_effective_firing(pho->result.score, pho->obstacles, age, oppo);
                        cerr << " (fire " << pho->result.chain << "c " << pho->result.score << "pt" << (is_eff ? " eff." : "") << ")";
                    } else {
                        cerr << " (" << pho->evaluation.estimateds.front().first.chain << "c " << pho->evaluation.estimateds.front().first.score << "pt)";
                    }
                    cerr << endl;
#endif
                }
                if (is_rejected(pho)) {
                    fired[age-1].emplace(pho->result.score, pho); // ここで葉の控えに追加
                    return shared_ptr<photon_t>(nullptr);
                } else {
                    return pho;
                }
            };
#ifndef RELEASE
            cerr << "load cache" << endl;
#endif
            repeat (i, fired.size()) { // 古い葉は覚えておいて直接見る
                while (not fired[i].empty()) {
                    shared_ptr<photon_t> const & pho = fired[i].top().second.lock();
                    if (not pho) { fired[i].pop(); continue; } // だめなのを削る
                    cont(pho);
                    anneal_photon(self_history.back(), outputs_photon_from(pho, input.turn), config, que, beam_generation, cont); // 近傍見ておく
                    break;
                }
            }
#ifndef RELEASE
            cerr << "chokudai search" << endl;
#endif
            chokudai_search(que, config, input.turn, beam_width, beam_depth, beam_generation, self_history.back(), time_limit, cont);
            if (result) {
                shared_ptr<photon_t> pho = parent_photon_at(result, input.turn + 1);
                assert (pho);
                output = pho->output;
            }
#ifndef RELEASE
            repeat (i, beam_depth) cerr << "width at " << i << ": beam " << que[i].size() << " / fire " << fired[i].size()<< endl;
            cerr << "done" << endl;
            repeat (i, fired.size()) {
                if (not fired[i].empty()) {
                    shared_ptr<photon_t> const & pho = fired[i].top().second.lock();
                    int age = pho->turn - input.turn;
                    bool is_eff = is_effective_firing(pho->result.score, pho->obstacles, age, oppo);
                    cerr << "fire: +" << age << "t " << pho->result.chain << "c " << pho->result.score << "pt" << (is_eff ? " eff." : "") << endl;
                }
            }
#endif
        }
#ifndef RELEASE
        cerr << "self elapsed: " << watch() << "ms" << endl;
#endif

        // 相手を刺せるなら強制発火
#ifndef RELEASE
        watch = stopwatch();
#endif
        const int fire_depth =
            input.remaining_time > 90 * 1000 ? 3 :
            input.remaining_time > 60 * 1000 ? 2 :
            input.remaining_time > 30 * 1000 ? 1 :
            0;
        if (input.remaining_time > 20 * 1000) {
            if (input.opponent_obstacles <= 5) { // 既に送れてるならしない
                repeat (i, fire_depth) if (i < fired.size() and not fired[i].empty()) {
                    shared_ptr<photon_t> const & best = fired[i].top().second.lock();
                    assert (best);
                    if (output == best->output) break; // もう発火することにしてあるなら見ない
                    if (best->obstacles + max(30, oppo.result[0].score/5 + 10) > 0) continue; // 明らかにだめな場合はしない
                    if (best->obstacles <= 20) continue; // 勝ってるからといって遊ばない
#ifndef RELEASE
                    cerr << "firing check for: +" << 1+i << "t " << best->result.chain << "c " << best->result.score << "pt" << endl;
#endif
                    const int beam_width = 120;
                    const int beam_depth = 10;
                    auto cont = [&](shared_ptr<photon_t> pho) {
                        int age = pho->turn - input.turn;
                        assert (age >= 1);
                        if (age == 1) {
                            pho = make_shared<photon_t>(*pho);
                            repeat_from (x, - pack_size + 1, width) repeat (r, 4) {
                                pho->cached[x+pack_size-1][r] = false;
                                pho->next[x+pack_size-1][r] = nullptr;
                            }
                            pho->obstacles += best->result.score/5; // ここで足す
                        }
                        if (- pho->obstacles >= 20) {
#ifndef RELEASE
                            cerr << "counter found: +" << age << "t " << pho->result.chain << "c " << pho->result.score << "pt" << endl;
#endif
                            throw counter_exception();
                        }
                        return is_rejected(pho) ? nullptr : pho;
                    };
                    shared_ptr<photon_t> const & initial = oppo_history.back();
                    try {
                        beam_search(initial, config, beam_width, beam_depth, cont);
                        output = parent_photon_at(best, input.turn + 1)->output;
#ifndef RELEASE
                        cerr << "fire" << endl;
#endif
                    } catch (counter_exception e) {
                        // nop
                    }
                }
            }
        }
#ifndef RELEASE
        cerr << "firing beam elapsed: " << watch() << "ms" << endl;
#endif

        // finalize
        const pack_t filled_pack = fill_obstacles(config.packs[input.turn], input.self_obstacles);
        if (output == invalid_output) { // もうだめなら悪あがきの貪欲
#ifndef RELEASE
            cerr << "search failed..." << endl;
#endif
            int score = -1;
            repeat_from (x, - pack_size + 1, width) repeat (r, 4) {
                try {
                    result_t result = get<0>(simulate_with_output(input.self_field, filled_pack, make_output(x, r)));
                    if (score <= result.score) {
                        score = result.score;
                        output = make_output(x, r);
                    }
                } catch (simulate_invalid_output_exception e) {
                    // nop
                } catch (simulate_gameover_exception e) {
                    // nop
                }
            }
#ifndef RELEASE
            if (output == invalid_output) {
                cerr << "greedy failed..." << endl; // ここに来たら終了
            }
#endif
        }
        if (is_valid_output(input.self_field, filled_pack, output)) {
            inputs.push_back(input);
            outputs.push_back(output);
            results.push_back(get<0>(simulate_with_output(input.self_field, filled_pack, output)));
            int last_score = scores.empty() ? 0 : scores.back();
            scores.push_back(last_score + results.back().score);
            prune_photon(self_history.back(), output);
            self_history.push_back(self_history.back()->next[output.x+pack_size-1][output.rotate]);
        }
#ifndef RELEASE
        cerr << "total elapsed: " << total_watch() << "ms" << endl;
#endif
        return output;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb40, %rsp            # imm = 0xB40
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x760(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xe8c0
leaq -0x28(%rbp), %rdi
callq 0xe8c0
movq 0x2fe79(%rip), %rdi     # 0x37ff0
movq 0x2fe2a(%rip), %rsi     # 0x37fa8
callq 0x21e0
movq 0x2fe66(%rip), %rdi     # 0x37ff0
leaq 0x1e0ce(%rip), %rsi     # 0x2625f
callq 0x21b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x22d0
movq %rax, %rdi
movq 0x2fdfa(%rip), %rsi     # 0x37fa8
callq 0x21e0
movq 0x2fe36(%rip), %rdi     # 0x37ff0
leaq 0x1e0a5(%rip), %rsi     # 0x26266
callq 0x21b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x22d0
movq %rax, %rdi
movq 0x2fdc9(%rip), %rsi     # 0x37fa8
callq 0x21e0
movq 0x2fe05(%rip), %rdi     # 0x37ff0
leaq 0x1e085(%rip), %rsi     # 0x26277
callq 0x21b0
movq -0x760(%rbp), %rdi
movq %rax, -0x758(%rbp)
addq $0x48, %rdi
callq 0xe900
testb $0x1, %al
jne 0x8214
jmp 0x821e
xorl %eax, %eax
movl %eax, -0x764(%rbp)
jmp 0x8236
movq -0x760(%rbp), %rdi
addq $0x48, %rdi
callq 0xe940
movl (%rax), %eax
movl %eax, -0x764(%rbp)
movq -0x758(%rbp), %rdi
movl -0x764(%rbp), %esi
callq 0x22d0
movq %rax, %rdi
movq 0x2fd56(%rip), %rsi     # 0x37fa8
callq 0x21e0
movq 0x2fd92(%rip), %rdi     # 0x37ff0
leaq 0x1e040(%rip), %rsi     # 0x262a5
callq 0x21b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rax
subl 0xac(%rax), %esi
callq 0x22d0
movq %rax, %rdi
movq 0x2fd1b(%rip), %rsi     # 0x37fa8
callq 0x21e0
movq 0x2fd57(%rip), %rdi     # 0x37ff0
leaq 0x1dfdf(%rip), %rsi     # 0x2627f
callq 0x21b0
movq %rax, -0x788(%rbp)
movq -0x18(%rbp), %rdi
addq $0xc, %rdi
callq 0x27a0
movq -0x788(%rbp), %rdi
movl %eax, %esi
callq 0x22d0
movq %rax, %rdi
movq 0x2fcd7(%rip), %rsi     # 0x37fa8
callq 0x21e0
movq 0x2fd13(%rip), %rdi     # 0x37ff0
leaq 0x1dfb4(%rip), %rsi     # 0x26298
callq 0x21b0
movq %rax, -0x780(%rbp)
movq -0x18(%rbp), %rdi
addq $0xb0, %rdi
callq 0x27a0
movq -0x780(%rbp), %rdi
movl %eax, %esi
callq 0x22d0
movq %rax, %rdi
movq 0x2fc90(%rip), %rsi     # 0x37fa8
callq 0x21e0
movq 0x2fccc(%rip), %rdi     # 0x37ff0
leaq 0x1df86(%rip), %rsi     # 0x262b1
callq 0x21b0
movq %rax, -0x778(%rbp)
movq -0x18(%rbp), %rdi
addq $0xc, %rdi
callq 0x3b90
movq -0x778(%rbp), %rdi
movq %rax, -0x30(%rbp)
movl -0x2c(%rbp), %esi
callq 0x22d0
movq %rax, %rdi
movq 0x2fc47(%rip), %rsi     # 0x37fa8
callq 0x21e0
movq 0x2fc83(%rip), %rdi     # 0x37ff0
leaq 0x1df54(%rip), %rsi     # 0x262c8
callq 0x21b0
movq %rax, -0x770(%rbp)
movq -0x18(%rbp), %rdi
addq $0xb0, %rdi
callq 0x3b90
movq -0x770(%rbp), %rdi
movq %rax, -0x38(%rbp)
movl -0x34(%rbp), %esi
callq 0x22d0
movq %rax, %rdi
movq 0x2fbfb(%rip), %rsi     # 0x37fa8
callq 0x21e0
movq -0x760(%rbp), %rdi
addq $0x18, %rdi
callq 0xe980
testb $0x1, %al
jne 0x858c
movq -0x760(%rbp), %rdi
movq -0x18(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x40(%rbp)
addq $0x18, %rdi
callq 0xe9c0
movq -0x760(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movslq (%rax), %rsi
callq 0x64e0
movb 0x8(%rax), %cl
movb %cl, -0x60(%rbp)
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x48(%rbp), %rax
movl 0x8(%rax), %edx
movb -0x60(%rbp), %al
movb %al, -0x70(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
movzbl -0x70(%rbp), %esi
callq 0x2c50
movq -0x760(%rbp), %rdi
movb %dl, -0x80(%rbp)
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x59(%rbp)
movb -0x80(%rbp), %al
movb %al, -0x51(%rbp)
leaq -0x59(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x798(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x790(%rbp)
addq $0x30, %rdi
callq 0xea00
movq -0x798(%rbp), %rsi
movq -0x790(%rbp), %rdx
movq %rax, %rcx
leaq -0x1e0(%rbp), %rdi
callq 0x3290
leaq -0x1f8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x94(%rbp), %rdx
leaq -0x134(%rbp), %rcx
callq 0x7a80
leaq -0x1f8(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x7ac0
movq -0x40(%rbp), %rsi
leaq -0x134(%rbp), %rdi
callq 0xea40
testb $0x1, %al
jne 0x84e3
jmp 0x858a
movq 0x2fb06(%rip), %rdi     # 0x37ff0
leaq 0x1ddee(%rip), %rsi     # 0x262df
callq 0x21b0
movq %rax, %rdi
movq 0x2faa8(%rip), %rsi     # 0x37fa8
callq 0x21e0
movq 0x2fae4(%rip), %rdi     # 0x37ff0
leaq -0x134(%rbp), %rsi
callq 0xea70
movq %rax, %rdi
movq 0x2fa86(%rip), %rsi     # 0x37fa8
callq 0x21e0
movq 0x2fac2(%rip), %rdi     # 0x37ff0
leaq 0x1ddae(%rip), %rsi     # 0x262e3
callq 0x21b0
movq %rax, %rdi
movq 0x2fa64(%rip), %rsi     # 0x37fa8
callq 0x21e0
movq -0x40(%rbp), %rsi
movq 0x2fa9c(%rip), %rdi     # 0x37ff0
callq 0xea70
movq %rax, %rdi
movq 0x2fa45(%rip), %rsi     # 0x37fa8
callq 0x21e0
movq 0x2fa81(%rip), %rdi     # 0x37ff0
leaq 0x1dd71(%rip), %rsi     # 0x262e7
callq 0x21b0
movq %rax, %rdi
movq 0x2fa23(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0x858c
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x86a0
movq -0x760(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x7a8(%rbp)
movq -0x18(%rbp), %rcx
movl (%rcx), %esi
movl 0x8(%rcx), %edx
addq $0xc, %rcx
leaq -0x208(%rbp), %rdi
movq %rdi, -0x7a0(%rbp)
callq 0x3f90
movq -0x7a8(%rbp), %rdi
movq -0x7a0(%rbp), %rsi
callq 0xeb70
jmp 0x85e0
leaq -0x208(%rbp), %rdi
callq 0x78c0
movq -0x760(%rbp), %rax
addq $0x90, %rax
movq %rax, -0x7b8(%rbp)
movq -0x18(%rbp), %rcx
movl (%rcx), %esi
movl 0xac(%rcx), %edx
addq $0xb0, %rcx
leaq -0x228(%rbp), %rdi
movq %rdi, -0x7b0(%rbp)
callq 0x3f90
movq -0x7b8(%rbp), %rdi
movq -0x7b0(%rbp), %rsi
callq 0xeb70
jmp 0x863b
leaq -0x228(%rbp), %rdi
callq 0x78c0
movq -0x760(%rbp), %rax
movl $0x1, 0x148(%rax)
jmp 0x86a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x78c0
jmp 0xa8d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x78c0
jmp 0xa8d3
movq -0x760(%rbp), %rdi
addq $0x78, %rdi
callq 0xeba0
movq %rax, -0x230(%rbp)
leaq -0x248(%rbp), %rdi
callq 0xbec0
movq -0x230(%rbp), %rdi
callq 0x76d0
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %ecx
movq -0x18(%rbp), %rdx
subl 0xac(%rdx), %ecx
cmpl %ecx, %eax
setne %al
andb $0x1, %al
movb %al, -0x249(%rbp)
testb $0x1, -0x249(%rbp)
je 0x8786
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jg 0x8726
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
subl 0xac(%rcx), %eax
cmpl $0x0, %eax
jg 0x8726
movb $0x0, -0x249(%rbp)
jmp 0x8784
movq -0x760(%rbp), %rdx
movq -0x230(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movl 0xac(%rax), %eax
subl %eax, %esi
leaq -0x248(%rbp), %rax
movq %rax, -0x258(%rbp)
movq -0x258(%rbp), %rcx
callq 0xebe0
jmp 0x875f
jmp 0x8784
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x248(%rbp), %rdi
callq 0xbfa0
jmp 0xa8d3
jmp 0x8786
movq -0x230(%rbp), %rdi
callq 0x4d80
movq -0x760(%rbp), %rdi
movq -0x230(%rbp), %rax
movq %rax, -0x7c0(%rbp)
movq -0x18(%rbp), %rax
movslq (%rax), %rsi
callq 0x64e0
movq -0x7c0(%rbp), %rdi
movq %rax, %rsi
callq 0x4c20
jmp 0x87c4
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x8862
movq -0x760(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x32b6(%rip), %rsi     # 0x5530
callq 0xef10
jmp 0x87ed
movq -0x760(%rbp), %rdi
addq $0xa8, %rdi
callq 0xef80
movq %rax, -0x7c8(%rbp)
movq -0x230(%rbp), %rdi
callq 0x76d0
movq -0x7c8(%rbp), %rdi
movq %rax, %rsi
addq $0xc8, %rsi
movq -0x230(%rbp), %rdx
callq 0xefc0
jmp 0x8832
movq -0x760(%rbp), %rax
movl 0x148(%rax), %eax
movl %eax, -0x7cc(%rbp)
movq -0x230(%rbp), %rdi
callq 0x76d0
movl -0x7cc(%rbp), %ecx
movl %ecx, 0x100(%rax)
jmp 0x8b46
movq -0x230(%rbp), %rdi
callq 0x5370
testb $0x1, %al
jne 0x8877
jmp 0x893c
movq -0x760(%rbp), %rdi
addq $0xa8, %rdi
movq %rdi, -0x7d8(%rbp)
callq 0xf060
movq -0x760(%rbp), %rdi
addq $0xf8, %rdi
callq 0xf060
movq -0x7d8(%rbp), %rdi
leaq -0x3382(%rip), %rsi     # 0x5530
callq 0xef10
jmp 0x88b9
movq -0x760(%rbp), %rdi
movl 0x148(%rdi), %eax
incl %eax
movl %eax, 0x148(%rdi)
addq $0xa8, %rdi
callq 0xef80
movq %rax, -0x7e0(%rbp)
movq -0x230(%rbp), %rdi
callq 0x76d0
movq -0x7e0(%rbp), %rdi
movq %rax, %rsi
addq $0xc8, %rsi
movq -0x230(%rbp), %rdx
callq 0xefc0
jmp 0x890c
movq -0x760(%rbp), %rax
movl 0x148(%rax), %eax
movl %eax, -0x7e4(%rbp)
movq -0x230(%rbp), %rdi
callq 0x76d0
movl -0x7e4(%rbp), %ecx
movl %ecx, 0x100(%rax)
jmp 0x8b44
testb $0x1, -0x249(%rbp)
je 0x8b1c
movq 0x2f6a0(%rip), %rdi     # 0x37ff0
leaq 0x1d994(%rip), %rsi     # 0x262eb
callq 0x21b0
movq %rax, -0x7f0(%rbp)
jmp 0x8965
movq -0x7f0(%rbp), %rdi
movq 0x2f635(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0x897a
movq -0x760(%rbp), %rsi
movl 0x148(%rsi), %eax
incl %eax
movl %eax, 0x148(%rsi)
movq %rsi, -0x260(%rbp)
addq $0xa8, %rsi
leaq -0x260(%rbp), %rdi
callq 0xf0a0
jmp 0x89ab
movq -0x760(%rbp), %rsi
addq $0xf8, %rsi
leaq -0x260(%rbp), %rdi
callq 0xf0a0
jmp 0x89c7
leaq -0x248(%rbp), %rax
movq %rax, -0x268(%rbp)
movq -0x268(%rbp), %rdi
callq 0xf400
movq %rax, -0x270(%rbp)
movq -0x268(%rbp), %rdi
callq 0xf430
movq %rax, -0x278(%rbp)
leaq -0x270(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0xf460
testb $0x1, %al
jne 0x8a17
jmp 0x8b1a
leaq -0x270(%rbp), %rdi
callq 0xf4a0
movq %rax, -0x280(%rbp)
movq -0x280(%rbp), %rdi
callq 0x76d0
movl (%rax), %eax
movq -0x18(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x284(%rbp)
movq -0x760(%rbp), %rdi
movslq -0x284(%rbp), %rax
movq %rax, -0x7f8(%rbp)
addq $0xa8, %rdi
callq 0xf4c0
movq %rax, %rcx
movq -0x7f8(%rbp), %rax
cmpq %rcx, %rax
jb 0x8a92
movq -0x760(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x3559(%rip), %rsi     # 0x5530
callq 0xef10
jmp 0x8a90
jmp 0x8a44
movq -0x760(%rbp), %rdi
addq $0xa8, %rdi
movslq -0x284(%rbp), %rsi
callq 0xf4f0
movq %rax, -0x800(%rbp)
movq -0x280(%rbp), %rdi
callq 0x76d0
movq -0x800(%rbp), %rdi
movq %rax, %rsi
addq $0xc8, %rsi
movq -0x280(%rbp), %rdx
callq 0xf520
jmp 0x8ade
movq -0x760(%rbp), %rax
movl 0x148(%rax), %eax
movl %eax, -0x804(%rbp)
movq -0x280(%rbp), %rdi
callq 0x76d0
movl -0x804(%rbp), %ecx
movl %ecx, 0x100(%rax)
leaq -0x270(%rbp), %rdi
callq 0xf5c0
jmp 0x89fb
jmp 0x8b42
movq -0x760(%rbp), %rdi
addq $0xa8, %rdi
callq 0xf5e0
movq -0x760(%rbp), %rdi
addq $0xf8, %rdi
callq 0xf5e0
jmp 0x8b44
jmp 0x8b46
leaq -0x248(%rbp), %rdi
callq 0xbfa0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x8e69
movq -0x760(%rbp), %rdi
addq $0x90, %rdi
callq 0xeba0
movq -0x760(%rbp), %rdi
movq %rax, -0x290(%rbp)
movq -0x290(%rbp), %rax
movq %rax, -0x810(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x64e0
movq -0x810(%rbp), %rdi
movq %rax, %rsi
callq 0x4c20
movq 0x1d613(%rip), %rax     # 0x261c8
movq %rax, -0x298(%rbp)
movl $0xfffffffe, -0x29c(%rbp) # imm = 0xFFFFFFFE
cmpl $0xa, -0x29c(%rbp)
jge 0x8cad
movl $0x0, -0x2a0(%rbp)
cmpl $0x4, -0x2a0(%rbp)
jge 0x8c97
movq -0x290(%rbp), %rdi
callq 0x76d0
movq %rax, %rdi
addq $0x138, %rdi            # imm = 0x138
movl -0x29c(%rbp), %eax
addl $0x3, %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x7b30
movq %rax, %rdi
movslq -0x2a0(%rbp), %rsi
callq 0x7b60
movq %rax, -0x2a8(%rbp)
movq -0x2a8(%rbp), %rdi
callq 0x7d10
testb $0x1, %al
jne 0x8c3c
jmp 0x8c83
movq -0x2a8(%rbp), %rdi
callq 0x76d0
movq %rax, %rdi
addq $0x14, %rdi
movq -0x18(%rbp), %rsi
addq $0xb0, %rsi
callq 0xf650
testb $0x1, %al
jne 0x8c65
jmp 0x8c81
movq -0x2a8(%rbp), %rdi
callq 0x76d0
movq 0xb4(%rax), %rax
movq %rax, -0x298(%rbp)
jmp 0x8c97
jmp 0x8c83
movl -0x2a0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2a0(%rbp)
jmp 0x8bdd
jmp 0x8c99
movl -0x29c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x29c(%rbp)
jmp 0x8bc6
leaq -0x298(%rbp), %rdi
leaq 0x1d4ad(%rip), %rsi     # 0x26168
callq 0x29a0
testb $0x1, %al
jne 0x8cc9
jmp 0x8d73
movq 0x2f320(%rip), %rdi     # 0x37ff0
leaq 0x1d622(%rip), %rsi     # 0x262f9
callq 0x21b0
movq %rax, %rdi
movq 0x2f2c2(%rip), %rsi     # 0x37fa8
callq 0x21e0
movq -0x760(%rbp), %rax
addq $0x90, %rax
movq %rax, -0x820(%rbp)
movq -0x18(%rbp), %rcx
movl 0xac(%rcx), %edx
movl (%rcx), %esi
movl 0x8(%rcx), %eax
subl %eax, %edx
addq $0xb0, %rcx
leaq -0x2b8(%rbp), %rdi
movq %rdi, -0x818(%rbp)
callq 0x3f90
movq -0x820(%rbp), %rdi
movq -0x818(%rbp), %rsi
callq 0xeb70
jmp 0x8d3f
leaq -0x2b8(%rbp), %rdi
callq 0x78c0
jmp 0x8e12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x2b8(%rbp), %rdi
callq 0x78c0
jmp 0xa8d3
movq -0x290(%rbp), %rdi
movq -0x298(%rbp), %rax
movq %rax, -0x2c0(%rbp)
movq -0x2c0(%rbp), %rsi
callq 0x5280
movq -0x290(%rbp), %rdi
callq 0x76d0
movq %rax, %rdi
addq $0x138, %rdi            # imm = 0x138
movl -0x298(%rbp), %eax
addl $0x3, %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x7b30
movq %rax, %rdi
movslq -0x294(%rbp), %rsi
callq 0x7b60
movq -0x760(%rbp), %rdi
movq %rax, -0x2c8(%rbp)
addq $0x90, %rdi
movq -0x2c8(%rbp), %rsi
callq 0xf680
movq -0x760(%rbp), %rdx
movq -0x2c8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0xac(%rax), %esi
movq -0x18(%rbp), %rax
subl 0x8(%rax), %esi
callq 0xf6f0
movq -0x760(%rbp), %rdi
addq $0x90, %rdi
callq 0xeba0
movq %rax, %rdi
callq 0x4d80
movq -0x760(%rbp), %rdi
addq $0x90, %rdi
callq 0xeba0
movq -0x760(%rbp), %rdi
movq %rax, -0x828(%rbp)
movq -0x18(%rbp), %rax
movslq (%rax), %rsi
callq 0x64e0
movq -0x828(%rbp), %rdi
movq %rax, %rsi
callq 0x4c20
leaq -0x2d8(%rbp), %rdi
callq 0xe8c0
movq -0x2d8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x4, -0x2e0(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movl $0x2bf20, %eax          # imm = 0x2BF20
subl %ecx, %eax
cltq
imulq $0x45e7b273, %rax, %rcx # imm = 0x45E7B273
movq %rcx, %rax
shrq $0x3f, %rax
sarq $0x2d, %rcx
addl %eax, %ecx
movl $0x8, %eax
subl %ecx, %eax
movl %eax, -0x2e4(%rbp)
leaq -0x2e0(%rbp), %rdi
leaq -0x2e4(%rbp), %rsi
callq 0x66f0
movl (%rax), %eax
movl %eax, -0x2dc(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x310(%rbp)
movq $0x0, -0x300(%rbp)
leaq -0x310(%rbp), %rdi
movq %rdi, -0x830(%rbp)
callq 0xbea0
movq -0x830(%rbp), %rdi
movl $0x0, -0x2f8(%rbp)
movl $0x0, -0x2f4(%rbp)
movl $0x0, -0x2f0(%rbp)
movl $0x0, -0x2ec(%rbp)
movl $0x3c, -0x314(%rbp)
movl -0x2dc(%rbp), %eax
movl %eax, -0x318(%rbp)
movslq -0x2dc(%rbp), %rsi
callq 0xfa10
jmp 0x8f51
movq -0x760(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x328(%rbp)
leaq -0x310(%rbp), %rax
movq %rax, -0x320(%rbp)
addq $0x90, %rdi
callq 0xeba0
movq %rax, %rsi
leaq -0x338(%rbp), %rdi
movq %rdi, -0x838(%rbp)
callq 0x7c70
movq -0x838(%rbp), %rdi
movq -0x760(%rbp), %rsi
movl -0x318(%rbp), %ecx
movups -0x328(%rbp), %xmm0
movaps %xmm0, -0x350(%rbp)
movq -0x350(%rbp), %r8
movq -0x348(%rbp), %r9
movl $0x3c, %edx
callq 0xfaa0
jmp 0x8fcf
leaq -0x338(%rbp), %rdi
callq 0x78c0
movq -0x760(%rbp), %rdi
addq $0x90, %rdi
callq 0xeba0
movq %rax, %rdi
callq 0x76d0
movl 0xc(%rax), %eax
movl %eax, -0x2ec(%rbp)
leaq -0x359(%rbp), %rdi
leaq -0x310(%rbp), %rsi
callq 0xfe70
movq %rax, -0x840(%rbp)
jmp 0x901b
movq -0x840(%rbp), %rax
movq %rax, -0x358(%rbp)
leaq -0x358(%rbp), %rdi
callq 0xfec0
movq (%rax), %rax
movq %rax, -0x2f8(%rbp)
movl $0x0, -0x360(%rbp)
movl -0x360(%rbp), %eax
cmpl -0x2dc(%rbp), %eax
jge 0x9116
leaq -0x2f0(%rbp), %rax
movq %rax, -0x848(%rbp)
movl -0x360(%rbp), %edi
movsd 0x1d141(%rip), %xmm0    # 0x261b8
callq 0x7ca0
movsd %xmm0, -0x850(%rbp)
movslq -0x360(%rbp), %rsi
leaq -0x310(%rbp), %rdi
callq 0xff10
movsd -0x850(%rbp), %xmm0
movq -0x848(%rbp), %rdi
cvtsi2sdl (%rax), %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x364(%rbp)
leaq -0x364(%rbp), %rsi
callq 0xfee0
jmp 0x90c6
jmp 0x90c8
movl -0x360(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x360(%rbp)
jmp 0x9049
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0xa8c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x338(%rbp), %rdi
callq 0x78c0
jmp 0xa8c7
movl $0x0, -0x368(%rbp)
movl -0x368(%rbp), %eax
cmpl -0x2dc(%rbp), %eax
jge 0x923d
movq 0x2eeb7(%rip), %rdi     # 0x37ff0
leaq 0x1d1ca(%rip), %rsi     # 0x2630a
callq 0x21b0
movq %rax, -0x858(%rbp)
jmp 0x914e
movq -0x858(%rbp), %rdi
movl -0x368(%rbp), %esi
callq 0x22d0
movq %rax, -0x860(%rbp)
jmp 0x9169
movq -0x860(%rbp), %rdi
leaq 0x1d206(%rip), %rsi     # 0x2637d
callq 0x21b0
movq %rax, -0x868(%rbp)
jmp 0x9185
movslq -0x368(%rbp), %rsi
leaq -0x310(%rbp), %rdi
callq 0xff10
movq -0x868(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x22d0
movq %rax, -0x870(%rbp)
jmp 0x91b0
movq -0x870(%rbp), %rdi
leaq 0x1d152(%rip), %rsi     # 0x26310
callq 0x21b0
movq %rax, -0x878(%rbp)
jmp 0x91cc
movslq -0x368(%rbp), %rsi
leaq -0x310(%rbp), %rdi
callq 0xff10
movq -0x878(%rbp), %rdi
movl (%rax), %esi
callq 0x22d0
movq %rax, -0x880(%rbp)
jmp 0x91f6
movq -0x880(%rbp), %rdi
leaq 0x1d10f(%rip), %rsi     # 0x26313
callq 0x21b0
movq %rax, -0x888(%rbp)
jmp 0x9212
movq -0x888(%rbp), %rdi
movq 0x2ed88(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0x9227
jmp 0x9229
movl -0x368(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x368(%rbp)
jmp 0x9120
movq 0x2edac(%rip), %rdi     # 0x37ff0
leaq 0x1d0cb(%rip), %rsi     # 0x26316
callq 0x21b0
movq %rax, -0x890(%rbp)
jmp 0x9259
leaq -0x20(%rbp), %rdi
callq 0xff30
movq %rax, -0x898(%rbp)
jmp 0x926b
movq -0x898(%rbp), %rsi
movq -0x890(%rbp), %rdi
callq 0x20f0
movq %rax, -0x8a0(%rbp)
jmp 0x9287
movq -0x8a0(%rbp), %rdi
leaq 0x1d090(%rip), %rsi     # 0x26325
callq 0x21b0
movq %rax, -0x8a8(%rbp)
jmp 0x92a3
movq -0x8a8(%rbp), %rdi
movq 0x2ecf7(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0x92b8
leaq -0x370(%rbp), %rdi
callq 0xe8c0
jmp 0x92c6
movq -0x760(%rbp), %rdi
movq -0x370(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x1cee9(%rip), %rax     # 0x261c8
movq %rax, -0x8(%rbp)
addq $0x78, %rdi
callq 0xeba0
movq %rax, %rdi
callq 0x76d0
movq %rax, %rdi
addq $0xc8, %rdi
addq $0x10, %rdi
callq 0xff80
movl 0x4(%rax), %eax
movl %eax, -0x374(%rbp)
movl $0x8, -0x378(%rbp)
movl $0xe, -0x384(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x384(%rbp), %rdi
callq 0x6730
movq %rax, %rcx
movl $0x16, %eax
subl (%rcx), %eax
movl %eax, -0x380(%rbp)
movl -0x374(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl $0x12, %eax
subl %ecx, %eax
movl %eax, -0x388(%rbp)
leaq -0x380(%rbp), %rdi
leaq -0x388(%rbp), %rsi
callq 0x66f0
movl (%rax), %eax
movl %eax, -0x37c(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl $0x1e, %ecx
cltd
idivl %ecx
movl %eax, -0x390(%rbp)
movl $0x4b0, -0x394(%rbp)    # imm = 0x4B0
leaq -0x310(%rbp), %rsi
addq $0x18, %rsi
addq $0x4, %rsi
leaq -0x374(%rbp), %rdi
callq 0x66f0
imull $0xaa, (%rax), %eax
movl %eax, -0x398(%rbp)
leaq -0x394(%rbp), %rdi
leaq -0x398(%rbp), %rsi
callq 0x66f0
movq %rax, %rsi
leaq -0x390(%rbp), %rdi
callq 0x6730
movl (%rax), %eax
movl %eax, -0x38c(%rbp)
movq -0x760(%rbp), %rdi
movl -0x37c(%rbp), %eax
addl $0x1, %eax
cltq
movq %rax, -0x8b0(%rbp)
addq $0xa8, %rdi
callq 0xf4c0
movq %rax, %rcx
movq -0x8b0(%rbp), %rax
cmpq %rcx, %rax
jb 0x943e
movq -0x760(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x3f05(%rip), %rsi     # 0x5530
callq 0xef10
jmp 0x943c
jmp 0x93ec
jmp 0x9440
movq -0x760(%rbp), %rdi
addq $0xf8, %rdi
callq 0xf4c0
movq -0x760(%rbp), %rdi
movq %rax, -0x8b8(%rbp)
addq $0xa8, %rdi
callq 0xf4c0
movq %rax, %rcx
movq -0x8b8(%rbp), %rax
cmpq %rcx, %rax
jae 0x949a
movq -0x760(%rbp), %rdi
addq $0xf8, %rdi
leaq -0x3f61(%rip), %rsi     # 0x5530
callq 0xef10
jmp 0x9498
jmp 0x9440
movb $0x0, -0x399(%rbp)
movabsq $-0x10000000000000, %rax # imm = 0xFFF0000000000000
movq %rax, -0x3a8(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x3b8(%rbp), %rdi
movq %rdi, -0x8c8(%rbp)
callq 0x7d90
movq -0x8c8(%rbp), %rcx
movq -0x760(%rbp), %rax
movq -0x18(%rbp), %rdx
movq %rdx, -0x3e8(%rbp)
leaq -0x310(%rbp), %rdx
movq %rdx, -0x3e0(%rbp)
leaq -0x399(%rbp), %rdx
movq %rdx, -0x3d8(%rbp)
leaq -0x3a8(%rbp), %rdx
movq %rdx, -0x3d0(%rbp)
movq %rcx, -0x3c8(%rbp)
movq %rax, -0x3c0(%rbp)
movq 0x2eacf(%rip), %rdi     # 0x37ff0
leaq 0x1ce00(%rip), %rsi     # 0x26328
callq 0x21b0
movq %rax, -0x8c0(%rbp)
jmp 0x9536
movq -0x8c0(%rbp), %rdi
movq 0x2ea64(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0x954b
movl $0x0, -0x3ec(%rbp)
movq -0x760(%rbp), %rdi
movslq -0x3ec(%rbp), %rax
movq %rax, -0x8d0(%rbp)
addq $0xf8, %rdi
callq 0xf4c0
movq %rax, %rcx
movq -0x8d0(%rbp), %rax
cmpq %rcx, %rax
jae 0x981f
jmp 0x958b
movq -0x760(%rbp), %rdi
addq $0xf8, %rdi
movslq -0x3ec(%rbp), %rsi
callq 0xf4f0
movq %rax, %rdi
callq 0xffb0
movb %al, -0x8d1(%rbp)
jmp 0x95b5
movb -0x8d1(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x95c6
jmp 0x9809
movq -0x760(%rbp), %rdi
addq $0xf8, %rdi
movslq -0x3ec(%rbp), %rsi
callq 0xf4f0
movq %rax, %rdi
callq 0xffd0
movq %rax, -0x8e0(%rbp)
jmp 0x95f1
movq -0x8e0(%rbp), %rsi
addq $0x8, %rsi
leaq -0x408(%rbp), %rdi
callq 0x7d30
leaq -0x408(%rbp), %rax
movq %rax, -0x3f8(%rbp)
movq -0x3f8(%rbp), %rdi
callq 0x7d10
testb $0x1, %al
jne 0x9687
movq -0x760(%rbp), %rdi
addq $0xf8, %rdi
movslq -0x3ec(%rbp), %rsi
callq 0xf4f0
movq %rax, %rdi
callq 0xfff0
jmp 0x964a
movl $0x19, -0x40c(%rbp)
jmp 0x97d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x9ff9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x97f8
movq -0x3f8(%rbp), %rdx
leaq -0x420(%rbp), %rdi
leaq -0x3e8(%rbp), %rsi
callq 0x10080
jmp 0x96a3
leaq -0x420(%rbp), %rdi
callq 0x78c0
movq -0x760(%rbp), %rdi
addq $0x78, %rdi
callq 0xeba0
movq %rax, -0x8f0(%rbp)
movq -0x3f8(%rbp), %rsi
leaq -0x448(%rbp), %rdi
movq %rdi, -0x8e8(%rbp)
callq 0x7c70
movq -0x8e8(%rbp), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %edx
leaq -0x438(%rbp), %rdi
callq 0x5110
jmp 0x96fb
movq -0x760(%rbp), %rdx
movq -0x8f0(%rbp), %rdi
movq %rdx, %rcx
addq $0xa8, %rcx
movl 0x148(%rdx), %r8d
movups -0x3e8(%rbp), %xmm0
movups -0x3d8(%rbp), %xmm1
movups -0x3c8(%rbp), %xmm2
movaps %xmm2, -0x460(%rbp)
movaps %xmm1, -0x470(%rbp)
movaps %xmm0, -0x480(%rbp)
movaps -0x480(%rbp), %xmm0
movaps -0x470(%rbp), %xmm1
movaps -0x460(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x438(%rbp), %rsi
callq 0x10400
jmp 0x9775
leaq -0x438(%rbp), %rdi
callq 0x7e90
leaq -0x448(%rbp), %rdi
callq 0x78c0
movl $0x1a, -0x40c(%rbp)
jmp 0x97d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x97cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x438(%rbp), %rdi
callq 0x7e90
leaq -0x448(%rbp), %rdi
callq 0x78c0
jmp 0x97f8
leaq -0x408(%rbp), %rdi
callq 0x78c0
movl -0x40c(%rbp), %eax
subl $0x19, %eax
je 0x958b
jmp 0x97f6
jmp 0x9809
leaq -0x408(%rbp), %rdi
callq 0x78c0
jmp 0x9ff9
jmp 0x980b
movl -0x3ec(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3ec(%rbp)
jmp 0x9555
movq 0x2e7ca(%rip), %rdi     # 0x37ff0
leaq 0x1cb06(%rip), %rsi     # 0x26333
callq 0x21b0
movq %rax, -0x8f8(%rbp)
jmp 0x983b
movq -0x8f8(%rbp), %rdi
movq 0x2e75f(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0x9850
movq -0x760(%rbp), %rdi
movq %rdi, %rax
addq $0xa8, %rax
movq %rax, -0x910(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x904(%rbp)
movl -0x37c(%rbp), %eax
movl %eax, -0x900(%rbp)
movl 0x148(%rdi), %eax
movl %eax, -0x8fc(%rbp)
addq $0x78, %rdi
callq 0xeba0
movq -0x910(%rbp), %rdi
movq -0x760(%rbp), %rsi
movl -0x904(%rbp), %edx
movl -0x900(%rbp), %r8d
movl -0x8fc(%rbp), %r9d
movq %rax, %rcx
movslq -0x38c(%rbp), %r10
movups -0x3e8(%rbp), %xmm0
movups -0x3d8(%rbp), %xmm1
movups -0x3c8(%rbp), %xmm2
movaps %xmm2, -0x490(%rbp)
movaps %xmm1, -0x4a0(%rbp)
movaps %xmm0, -0x4b0(%rbp)
movaps -0x4b0(%rbp), %xmm0
movaps -0x4a0(%rbp), %xmm1
movaps -0x490(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x30(%rax)
movups %xmm1, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movq %r10, 0x8(%rax)
movq %rcx, (%rax)
movl $0x8, %ecx
callq 0x108b0
jmp 0x9921
leaq -0x3b8(%rbp), %rdi
callq 0x7d10
testb $0x1, %al
jne 0x9933
jmp 0x9991
leaq -0x4d0(%rbp), %rdi
leaq -0x3b8(%rbp), %rsi
callq 0x7c70
movq -0x18(%rbp), %rax
movl (%rax), %edx
addl $0x1, %edx
leaq -0x4c0(%rbp), %rdi
leaq -0x4d0(%rbp), %rsi
callq 0x5040
leaq -0x4d0(%rbp), %rdi
callq 0x78c0
leaq -0x4c0(%rbp), %rdi
callq 0x76d0
movq 0xb4(%rax), %rax
movq %rax, -0x8(%rbp)
leaq -0x4c0(%rbp), %rdi
callq 0x78c0
movl $0x0, -0x4d4(%rbp)
movl -0x4d4(%rbp), %eax
cmpl -0x37c(%rbp), %eax
jge 0x9ad5
movq 0x2e63c(%rip), %rdi     # 0x37ff0
leaq 0x1c988(%rip), %rsi     # 0x26343
callq 0x21b0
movq %rax, -0x918(%rbp)
jmp 0x99c9
movq -0x918(%rbp), %rdi
movl -0x4d4(%rbp), %esi
callq 0x22d0
movq %rax, -0x920(%rbp)
jmp 0x99e4
movq -0x920(%rbp), %rdi
leaq 0x1c95b(%rip), %rsi     # 0x2634d
callq 0x21b0
movq %rax, -0x928(%rbp)
jmp 0x9a00
movq -0x760(%rbp), %rdi
addq $0xa8, %rdi
movslq -0x4d4(%rbp), %rsi
callq 0xf4f0
movq %rax, %rdi
callq 0x10d30
movq %rax, -0x930(%rbp)
jmp 0x9a2b
movq -0x930(%rbp), %rsi
movq -0x928(%rbp), %rdi
callq 0x2050
movq %rax, -0x938(%rbp)
jmp 0x9a47
movq -0x938(%rbp), %rdi
leaq 0x1c900(%rip), %rsi     # 0x26355
callq 0x21b0
movq %rax, -0x940(%rbp)
jmp 0x9a63
movq -0x760(%rbp), %rdi
addq $0xf8, %rdi
movslq -0x4d4(%rbp), %rsi
callq 0xf4f0
movq %rax, %rdi
callq 0x10d30
movq %rax, -0x948(%rbp)
jmp 0x9a8e
movq -0x948(%rbp), %rsi
movq -0x940(%rbp), %rdi
callq 0x2050
movq %rax, -0x950(%rbp)
jmp 0x9aaa
movq -0x950(%rbp), %rdi
movq 0x2e4f0(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0x9abf
jmp 0x9ac1
movl -0x4d4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4d4(%rbp)
jmp 0x999b
movq 0x2e514(%rip), %rdi     # 0x37ff0
leaq 0x1c87b(%rip), %rsi     # 0x2635e
callq 0x21b0
movq %rax, -0x958(%rbp)
jmp 0x9af1
movq -0x958(%rbp), %rdi
movq 0x2e4a9(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0x9b06
movl $0x0, -0x4d8(%rbp)
movq -0x760(%rbp), %rdi
movslq -0x4d8(%rbp), %rax
movq %rax, -0x960(%rbp)
addq $0xf8, %rdi
callq 0xf4c0
movq %rax, %rcx
movq -0x960(%rbp), %rax
cmpq %rcx, %rax
jae 0x9dab
movq -0x760(%rbp), %rdi
addq $0xf8, %rdi
movslq -0x4d8(%rbp), %rsi
callq 0xf4f0
movq %rax, %rdi
callq 0xffb0
movb %al, -0x961(%rbp)
jmp 0x9b6e
movb -0x961(%rbp), %al
testb $0x1, %al
jne 0x9d95
jmp 0x9b7e
movq -0x760(%rbp), %rdi
addq $0xf8, %rdi
movslq -0x4d8(%rbp), %rsi
callq 0xf4f0
movq %rax, %rdi
callq 0xffd0
movq %rax, -0x970(%rbp)
jmp 0x9ba9
movq -0x970(%rbp), %rsi
addq $0x8, %rsi
leaq -0x4f0(%rbp), %rdi
movq %rdi, -0x980(%rbp)
callq 0x7d30
movq -0x980(%rbp), %rax
movq %rax, -0x4e0(%rbp)
movq -0x4e0(%rbp), %rdi
callq 0x76d0
movl (%rax), %eax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x4f4(%rbp)
movq -0x4e0(%rbp), %rdi
callq 0x76d0
movl 0xbc(%rax), %eax
movl %eax, -0x978(%rbp)
movq -0x4e0(%rbp), %rdi
callq 0x76d0
movl -0x978(%rbp), %edi
movl 0x8(%rax), %esi
movl -0x4f4(%rbp), %edx
leaq -0x310(%rbp), %rcx
callq 0x4d00
movb %al, -0x971(%rbp)
jmp 0x9c38
movb -0x971(%rbp), %al
andb $0x1, %al
movb %al, -0x4f5(%rbp)
movq 0x2e3a3(%rip), %rdi     # 0x37ff0
leaq 0x1c70f(%rip), %rsi     # 0x26363
callq 0x21b0
movq %rax, -0x988(%rbp)
jmp 0x9c62
movq -0x988(%rbp), %rdi
movl -0x4f4(%rbp), %esi
callq 0x22d0
movq %rax, -0x990(%rbp)
jmp 0x9c7d
movq -0x990(%rbp), %rdi
leaq 0x1c6bf(%rip), %rsi     # 0x2634a
callq 0x21b0
movq %rax, -0x998(%rbp)
jmp 0x9c99
movq -0x4e0(%rbp), %rdi
callq 0x76d0
movq -0x998(%rbp), %rdi
movl 0xc0(%rax), %esi
callq 0x22d0
movq %rax, -0x9a0(%rbp)
jmp 0x9cc0
movq -0x9a0(%rbp), %rdi
leaq 0x1c642(%rip), %rsi     # 0x26310
callq 0x21b0
movq %rax, -0x9a8(%rbp)
jmp 0x9cdc
movq -0x4e0(%rbp), %rdi
callq 0x76d0
movq -0x9a8(%rbp), %rdi
movl 0xbc(%rax), %esi
callq 0x22d0
movq %rax, -0x9b0(%rbp)
jmp 0x9d03
movq -0x9b0(%rbp), %rdi
leaq 0x1c602(%rip), %rsi     # 0x26313
callq 0x21b0
movq %rax, -0x9b8(%rbp)
jmp 0x9d1f
movq -0x9b8(%rbp), %rdi
movb -0x4f5(%rbp), %cl
leaq 0x1c638(%rip), %rax     # 0x2636b
leaq 0x1c645(%rip), %rsi     # 0x2637f
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x21b0
movq %rax, -0x9c0(%rbp)
jmp 0x9d4f
movq -0x9c0(%rbp), %rdi
movq 0x2e24b(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0x9d64
leaq -0x4f0(%rbp), %rdi
callq 0x78c0
jmp 0x9d95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x4f0(%rbp), %rdi
callq 0x78c0
jmp 0x9ff9
jmp 0x9d97
movl -0x4d8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4d8(%rbp)
jmp 0x9b10
leaq -0x3b8(%rbp), %rdi
callq 0x78c0
movq 0x2e232(%rip), %rdi     # 0x37ff0
leaq 0x1c5ac(%rip), %rsi     # 0x26371
callq 0x21b0
movq %rax, -0x9c8(%rbp)
jmp 0x9dd3
leaq -0x20(%rbp), %rdi
callq 0xff30
movq %rax, -0x9d0(%rbp)
jmp 0x9de5
movq -0x9d0(%rbp), %rsi
movq -0x9c8(%rbp), %rdi
callq 0x20f0
movq %rax, -0x9d8(%rbp)
jmp 0x9e01
movq -0x9d8(%rbp), %rdi
leaq 0x1c516(%rip), %rsi     # 0x26325
callq 0x21b0
movq %rax, -0x9e0(%rbp)
jmp 0x9e1d
movq -0x9e0(%rbp), %rdi
movq 0x2e17d(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0x9e32
leaq -0x500(%rbp), %rdi
callq 0xe8c0
jmp 0x9e40
movq -0x500(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x15f90, 0x4(%rax)     # imm = 0x15F90
jle 0x9e65
movl $0x3, %eax
movl %eax, -0x9e4(%rbp)
jmp 0x9ea8
movq -0x18(%rbp), %rax
cmpl $0xea60, 0x4(%rax)      # imm = 0xEA60
jle 0x9e7f
movl $0x2, %eax
movl %eax, -0x9e8(%rbp)
jmp 0x9e9c
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x7530, %edx           # imm = 0x7530
cmovgl %ecx, %eax
movl %eax, -0x9e8(%rbp)
movl -0x9e8(%rbp), %eax
movl %eax, -0x9e4(%rbp)
movl -0x9e4(%rbp), %eax
movl %eax, -0x504(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x4e20, 0x4(%rax)      # imm = 0x4E20
jle 0xa360
movq -0x18(%rbp), %rax
cmpl $0x5, 0xac(%rax)
jg 0xa35e
movl $0x0, -0x508(%rbp)
movl -0x508(%rbp), %eax
cmpl -0x504(%rbp), %eax
jge 0xa35c
movq -0x760(%rbp), %rdi
movslq -0x508(%rbp), %rax
movq %rax, -0x9f0(%rbp)
addq $0xf8, %rdi
callq 0xf4c0
movq %rax, %rcx
movq -0x9f0(%rbp), %rax
cmpq %rcx, %rax
jae 0xa346
movq -0x760(%rbp), %rdi
addq $0xf8, %rdi
movslq -0x508(%rbp), %rsi
callq 0xf4f0
movq %rax, %rdi
callq 0xffb0
movb %al, -0x9f1(%rbp)
jmp 0x9f50
movb -0x9f1(%rbp), %al
testb $0x1, %al
jne 0xa346
jmp 0x9f60
movq -0x760(%rbp), %rdi
addq $0xf8, %rdi
movslq -0x508(%rbp), %rsi
callq 0xf4f0
movq %rax, %rdi
callq 0xffd0
movq %rax, -0xa00(%rbp)
jmp 0x9f8b
movq -0xa00(%rbp), %rsi
addq $0x8, %rsi
leaq -0x520(%rbp), %rdi
movq %rdi, -0xa10(%rbp)
callq 0x7d30
movq -0xa10(%rbp), %rax
movq %rax, -0x510(%rbp)
movq -0x510(%rbp), %rdi
callq 0x76d0
movq %rax, %rsi
addq $0xb4, %rsi
leaq -0x8(%rbp), %rdi
callq 0x29a0
movb %al, -0xa01(%rbp)
jmp 0x9fde
movb -0xa01(%rbp), %al
testb $0x1, %al
jne 0x9fea
jmp 0xa021
movl $0x21, -0x40c(%rbp)
jmp 0xa306
leaq -0x3b8(%rbp), %rdi
callq 0x78c0
jmp 0xa8c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0xa335
movq -0x510(%rbp), %rdi
callq 0x76d0
movl 0x8(%rax), %eax
movl %eax, -0xa14(%rbp)
movl $0x1e, -0x524(%rbp)
leaq -0x310(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xff10
movl (%rax), %eax
movl $0x5, %ecx
cltd
idivl %ecx
addl $0xa, %eax
movl %eax, -0x528(%rbp)
leaq -0x524(%rbp), %rdi
leaq -0x528(%rbp), %rsi
callq 0x66f0
movq %rax, %rcx
movl -0xa14(%rbp), %eax
addl (%rcx), %eax
cmpl $0x0, %eax
jle 0xa095
movl $0x23, -0x40c(%rbp)
jmp 0xa306
movq -0x510(%rbp), %rdi
callq 0x76d0
cmpl $0x14, 0x8(%rax)
jg 0xa0b6
movl $0x23, -0x40c(%rbp)
jmp 0xa306
movq 0x2df33(%rip), %rdi     # 0x37ff0
leaq 0x1c2bc(%rip), %rsi     # 0x26380
callq 0x21b0
movq %rax, -0xa20(%rbp)
jmp 0xa0d2
movq -0xa20(%rbp), %rdi
movl -0x508(%rbp), %esi
incl %esi
callq 0x22d0
movq %rax, -0xa28(%rbp)
jmp 0xa0ef
movq -0xa28(%rbp), %rdi
leaq 0x1c24d(%rip), %rsi     # 0x2634a
callq 0x21b0
movq %rax, -0xa30(%rbp)
jmp 0xa10b
movq -0x510(%rbp), %rdi
callq 0x76d0
movq -0xa30(%rbp), %rdi
movl 0xc0(%rax), %esi
callq 0x22d0
movq %rax, -0xa38(%rbp)
jmp 0xa132
movq -0xa38(%rbp), %rdi
leaq 0x1c1d0(%rip), %rsi     # 0x26310
callq 0x21b0
movq %rax, -0xa40(%rbp)
jmp 0xa14e
movq -0x510(%rbp), %rdi
callq 0x76d0
movq -0xa40(%rbp), %rdi
movl 0xbc(%rax), %esi
callq 0x22d0
movq %rax, -0xa48(%rbp)
jmp 0xa175
movq -0xa48(%rbp), %rdi
leaq 0x1c190(%rip), %rsi     # 0x26313
callq 0x21b0
movq %rax, -0xa50(%rbp)
jmp 0xa191
movq -0xa50(%rbp), %rdi
movq 0x2de09(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0xa1a6
movq -0x760(%rbp), %rdi
movl $0x78, -0x52c(%rbp)
movl $0xa, -0x530(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x540(%rbp)
movq -0x510(%rbp), %rax
movq %rax, -0x538(%rbp)
addq $0x90, %rdi
callq 0xeba0
movq -0x760(%rbp), %rsi
movq %rax, -0x548(%rbp)
movq -0x548(%rbp), %rdi
movups -0x540(%rbp), %xmm0
movaps %xmm0, -0x560(%rbp)
movq -0x560(%rbp), %r8
movq -0x558(%rbp), %r9
movl $0x78, %edx
movl $0xa, %ecx
callq 0x10d50
jmp 0xa228
movq -0x510(%rbp), %rsi
leaq -0x580(%rbp), %rdi
movq %rdi, -0xa60(%rbp)
callq 0x7c70
movq -0xa60(%rbp), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %edx
incl %edx
leaq -0x570(%rbp), %rdi
movq %rdi, -0xa68(%rbp)
callq 0x5040
movq -0xa68(%rbp), %rdi
callq 0x76d0
movq -0xa68(%rbp), %rdi
movq 0xb4(%rax), %rax
movq %rax, -0x8(%rbp)
callq 0x78c0
movq -0xa60(%rbp), %rdi
callq 0x78c0
movq 0x2dd56(%rip), %rdi     # 0x37ff0
leaq 0x1c0f3(%rip), %rsi     # 0x26394
callq 0x21b0
movq %rax, -0xa58(%rbp)
jmp 0xa2af
movq -0xa58(%rbp), %rdi
movq 0x2dceb(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0xa2c4
jmp 0xa2fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
movl -0x214(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xa335
movq -0x210(%rbp), %rdi
callq 0x2090
callq 0x22b0
jmp 0xa2fa
jmp 0xa2fc
movl $0x0, -0x40c(%rbp)
leaq -0x520(%rbp), %rdi
callq 0x78c0
movl -0x40c(%rbp), %eax
movl %eax, -0xa6c(%rbp)
testl %eax, %eax
je 0xa333
jmp 0xa324
movl -0xa6c(%rbp), %eax
subl $0x21, %eax
je 0xa35c
jmp 0xa331
jmp 0xa348
jmp 0xa346
leaq -0x520(%rbp), %rdi
callq 0x78c0
jmp 0xa8c7
jmp 0xa348
movl -0x508(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x508(%rbp)
jmp 0x9ee0
jmp 0xa35e
jmp 0xa360
movq 0x2dc89(%rip), %rdi     # 0x37ff0
leaq 0x1c02b(%rip), %rsi     # 0x26399
callq 0x21b0
movq %rax, -0xa78(%rbp)
jmp 0xa37c
leaq -0x20(%rbp), %rdi
callq 0xff30
movq %rax, -0xa80(%rbp)
jmp 0xa38e
movq -0xa80(%rbp), %rsi
movq -0xa78(%rbp), %rdi
callq 0x20f0
movq %rax, -0xa88(%rbp)
jmp 0xa3aa
movq -0xa88(%rbp), %rdi
leaq 0x1bf6d(%rip), %rsi     # 0x26325
callq 0x21b0
movq %rax, -0xa90(%rbp)
jmp 0xa3c6
movq -0xa90(%rbp), %rdi
movq 0x2dbd4(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0xa3db
movq -0x760(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rsi
callq 0x64e0
movb 0x8(%rax), %cl
movb %cl, -0x598(%rbp)
movq (%rax), %rax
movq %rax, -0x5a0(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movb -0x598(%rbp), %al
movb %al, -0x5a8(%rbp)
movq -0x5a0(%rbp), %rax
movq %rax, -0x5b0(%rbp)
movq -0x5b0(%rbp), %rdi
movzbl -0x5a8(%rbp), %esi
callq 0x2c50
movb %dl, -0x5b8(%rbp)
movq %rax, -0x5c0(%rbp)
movb -0x5b8(%rbp), %al
movb %al, -0x588(%rbp)
movq -0x5c0(%rbp), %rax
movq %rax, -0x590(%rbp)
leaq 0x1bd05(%rip), %rsi     # 0x26168
leaq -0x8(%rbp), %rdi
callq 0x29a0
movb %al, -0xa91(%rbp)
jmp 0xa474
movb -0xa91(%rbp), %al
testb $0x1, %al
jne 0xa483
jmp 0xa67a
movq 0x2db66(%rip), %rdi     # 0x37ff0
leaq 0x1bf1e(%rip), %rsi     # 0x263af
callq 0x21b0
movq %rax, -0xaa0(%rbp)
jmp 0xa49f
movq -0xaa0(%rbp), %rdi
movq 0x2dafb(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0xa4b4
movl $0xffffffff, -0x5c4(%rbp) # imm = 0xFFFFFFFF
movl $0xfffffffe, -0x5c8(%rbp) # imm = 0xFFFFFFFE
cmpl $0xa, -0x5c8(%rbp)
jge 0xa621
movl $0x0, -0x5cc(%rbp)
cmpl $0x4, -0x5cc(%rbp)
jge 0xa60b
movq -0x18(%rbp), %rax
addq $0xc, %rax
movq %rax, -0xaa8(%rbp)
movl -0x5c8(%rbp), %edi
movl -0x5cc(%rbp), %esi
callq 0x2930
movq -0xaa8(%rbp), %rsi
movq %rax, -0x688(%rbp)
leaq -0x680(%rbp), %rdi
leaq -0x590(%rbp), %rdx
leaq -0x688(%rbp), %rcx
callq 0x3290
jmp 0xa536
leaq -0x680(%rbp), %rdi
callq 0x11160
movq (%rax), %rax
movq %rax, -0x5d4(%rbp)
movl -0x5c4(%rbp), %eax
cmpl -0x5d4(%rbp), %eax
jg 0xa609
movl -0x5d4(%rbp), %eax
movl %eax, -0x5c4(%rbp)
movl -0x5c8(%rbp), %edi
movl -0x5cc(%rbp), %esi
callq 0x2930
movq %rax, -0x690(%rbp)
movq -0x690(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa609
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
movl -0x214(%rbp), %eax
movl %eax, -0xaac(%rbp)
movl $0x3, %ecx
cmpl %ecx, %eax
jne 0xa5e1
movq -0x210(%rbp), %rdi
callq 0x2090
callq 0x22b0
jmp 0xa5c9
jmp 0xa5cb
jmp 0xa5cd
movl -0x5cc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5cc(%rbp)
jmp 0xa4df
movl -0xaac(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0xa8c7
movq -0x210(%rbp), %rdi
callq 0x2090
callq 0x22b0
jmp 0xa607
jmp 0xa5cb
jmp 0xa5cb
jmp 0xa60d
movl -0x5c8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c8(%rbp)
jmp 0xa4c8
leaq 0x1bb40(%rip), %rsi     # 0x26168
leaq -0x8(%rbp), %rdi
callq 0x29a0
movb %al, -0xaad(%rbp)
jmp 0xa639
movb -0xaad(%rbp), %al
testb $0x1, %al
jne 0xa645
jmp 0xa678
movq 0x2d9a4(%rip), %rdi     # 0x37ff0
leaq 0x1bd6d(%rip), %rsi     # 0x263c0
callq 0x21b0
movq %rax, -0xab8(%rbp)
jmp 0xa661
movq -0xab8(%rbp), %rdi
movq 0x2d939(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0xa676
jmp 0xa678
jmp 0xa67a
movq -0x18(%rbp), %rdi
addq $0xc, %rdi
leaq -0x590(%rbp), %rsi
leaq -0x8(%rbp), %rdx
callq 0x2df0
testb $0x1, %al
jne 0xa69b
jmp 0xa829
movq -0x760(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x11180
jmp 0xa6b1
movq -0x760(%rbp), %rdi
addq $0x30, %rdi
leaq -0x8(%rbp), %rsi
callq 0x7e00
jmp 0xa6c7
movq -0x760(%rbp), %rax
addq $0x60, %rax
movq %rax, -0xac0(%rbp)
movq -0x18(%rbp), %rsi
addq $0xc, %rsi
leaq -0x740(%rbp), %rdi
leaq -0x590(%rbp), %rdx
leaq -0x8(%rbp), %rcx
callq 0x3290
jmp 0xa6fa
leaq -0x740(%rbp), %rdi
callq 0x11160
movq -0xac0(%rbp), %rdi
movq %rax, %rsi
callq 0x111f0
jmp 0xa717
movq -0x760(%rbp), %rdi
addq $0x48, %rdi
callq 0xe900
testb $0x1, %al
jne 0xa72d
jmp 0xa737
xorl %eax, %eax
movl %eax, -0xac4(%rbp)
jmp 0xa74f
movq -0x760(%rbp), %rdi
addq $0x48, %rdi
callq 0xe940
movl (%rax), %eax
movl %eax, -0xac4(%rbp)
movq -0x760(%rbp), %rdi
movl -0xac4(%rbp), %eax
movl %eax, -0x744(%rbp)
movq %rdi, %rax
addq $0x48, %rax
movq %rax, -0xad0(%rbp)
movl -0x744(%rbp), %eax
movl %eax, -0xac8(%rbp)
addq $0x60, %rdi
callq 0x11250
movq -0xad0(%rbp), %rdi
movq %rax, %rcx
movl -0xac8(%rbp), %eax
movl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x748(%rbp)
leaq -0x748(%rbp), %rsi
callq 0x11220
jmp 0xa7ad
movq -0x760(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0xad8(%rbp)
callq 0xeba0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x750(%rbp)
movq -0x750(%rbp), %rsi
callq 0x5280
movq -0xad8(%rbp), %rdi
callq 0xeba0
movq %rax, %rdi
callq 0x76d0
movq %rax, %rdi
addq $0x138, %rdi            # imm = 0x138
movl -0x8(%rbp), %eax
addl $0x2, %eax
movslq %eax, %rsi
callq 0x7b30
movq %rax, %rdi
movslq -0x4(%rbp), %rsi
callq 0x7b60
movq -0xad8(%rbp), %rdi
movq %rax, %rsi
callq 0xf680
jmp 0xa827
jmp 0xa829
movq 0x2d7c0(%rip), %rdi     # 0x37ff0
leaq 0x1bb9a(%rip), %rsi     # 0x263d1
callq 0x21b0
movq %rax, -0xae0(%rbp)
jmp 0xa845
leaq -0x28(%rbp), %rdi
callq 0xff30
movq %rax, -0xae8(%rbp)
jmp 0xa857
movq -0xae8(%rbp), %rsi
movq -0xae0(%rbp), %rdi
callq 0x20f0
movq %rax, -0xaf0(%rbp)
jmp 0xa873
movq -0xaf0(%rbp), %rdi
leaq 0x1baa4(%rip), %rsi     # 0x26325
callq 0x21b0
movq %rax, -0xaf8(%rbp)
jmp 0xa88f
movq -0xaf8(%rbp), %rdi
movq 0x2d70b(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0xa8a4
movl $0x1, -0x40c(%rbp)
leaq -0x310(%rbp), %rdi
callq 0x11290
movq -0x8(%rbp), %rax
addq $0xb40, %rsp            # imm = 0xB40
popq %rbp
retq
leaq -0x310(%rbp), %rdi
callq 0x11290
movq -0x210(%rbp), %rdi
callq 0x22f0
nop