// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp            # imm = 0x298
movq %rsi, %r15
movq %rdi, %r14
callq 0x2030
movq %rax, 0x98(%rsp)
callq 0x2030
movq %rax, 0x198(%rsp)
movq 0xf79e(%rip), %rbx      # 0x13ff0
movq %rbx, %rdi
callq 0x20a0
leaq 0x8a06(%rip), %rsi      # 0xd267
movq %rbx, %rdi
callq 0x2160
movl (%r15), %esi
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x20a0
leaq 0x89eb(%rip), %rsi      # 0xd26e
movq %rbx, %rdi
callq 0x2160
movq %r15, 0x48(%rsp)
movl 0x4(%r15), %esi
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x20a0
leaq 0x89d4(%rip), %rsi      # 0xd27f
movq %rbx, %rdi
callq 0x2160
movq 0x50(%r14), %rcx
movq %r14, 0x40(%rsp)
cmpq %rcx, 0x48(%r14)
je 0x48c7
movl -0x4(%rcx), %esi
jmp 0x48c9
xorl %esi, %esi
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x20a0
movq 0xf710(%rip), %rbx      # 0x13ff0
leaq 0x89c6(%rip), %rsi      # 0xd2ad
movq %rbx, %rdi
callq 0x2160
movq 0x48(%rsp), %r15
movl 0x8(%r15), %esi
subl 0xac(%r15), %esi
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x20a0
leaq 0x8971(%rip), %rsi      # 0xd287
movq %rbx, %rdi
callq 0x2160
movq %rax, %r14
leaq 0xc(%r15), %r13
movq %r13, %rdi
callq 0x248f
movq %r14, %rdi
movl %eax, %esi
callq 0x2230
movq %rax, %rdi
callq 0x20a0
leaq 0x895a(%rip), %rsi      # 0xd2a0
movq %rbx, %rdi
callq 0x2160
movq %rax, %r14
leaq 0xb0(%r15), %r12
movq %r12, %rdi
callq 0x248f
movq %r14, %rdi
movl %eax, %esi
callq 0x2230
movq %rax, %rdi
callq 0x20a0
leaq 0x8940(%rip), %rsi      # 0xd2b9
movq %rbx, %rdi
callq 0x2160
movq %rax, %r14
movq %r13, 0xa0(%rsp)
movq %r13, %rdi
callq 0x2dfe
shrq $0x20, %rax
movq %r14, %rdi
movl %eax, %esi
callq 0x2230
movq %rax, %rdi
callq 0x20a0
leaq 0x891f(%rip), %rsi      # 0xd2d0
movq %rbx, %rdi
callq 0x2160
movq %rax, %rbx
movq %r12, %rdi
callq 0x2dfe
shrq $0x20, %rax
movq %rbx, %rdi
movl %eax, %esi
callq 0x2230
movq %rax, %rdi
callq 0x20a0
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rbx
cmpq %rbx, 0x18(%rax)
je 0x4aed
movslq -0x150(%rbx), %rax
movq 0x40(%rsp), %r14
movq (%r14), %rcx
leaq (%rax,%rax,8), %rax
movq (%rcx,%rax), %rdi
movl -0x148(%rbx), %edx
movzbl 0x8(%rcx,%rax), %esi
callq 0x2700
leaq 0x70(%rsp), %r8
movq %rax, (%r8)
movb %dl, 0x8(%r8)
addq $-0x144, %rbx           # imm = 0xFEBC
movq 0x38(%r14), %rcx
addq $-0x8, %rcx
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r8, %rdx
callq 0x2966
leaq 0x1a0(%rsp), %rbx
movl $0xa0, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2130
movq %rbx, %rdi
movq 0xa0(%rsp), %rsi
callq 0x7dd5
testb %al, %al
je 0x4aed
movq 0xf578(%rip), %rbx      # 0x13ff0
leaq 0x8868(%rip), %rsi      # 0xd2e7
movq %rbx, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20a0
leaq 0x1a0(%rsp), %rsi
movq %rbx, %rdi
callq 0x6776
movq %rax, %rdi
callq 0x20a0
leaq 0x883d(%rip), %rsi      # 0xd2eb
movq %rbx, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20a0
movq %rbx, %rdi
movq 0xa0(%rsp), %rsi
callq 0x6776
movq %rax, %rdi
callq 0x20a0
leaq 0x8812(%rip), %rsi      # 0xd2ef
movq %rbx, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20a0
movq 0x48(%rsp), %rbp
cmpl $0x0, (%rbp)
jne 0x4b85
movq 0x40(%rsp), %r15
leaq 0x78(%r15), %rbx
movl 0x8(%rbp), %edx
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
movq 0xa0(%rsp), %rcx
callq 0x3067
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7e54
leaq 0xc8(%rsp), %rdi
callq 0x5f78
leaq 0x90(%r15), %rbx
movl (%rbp), %esi
movl 0xac(%rbp), %edx
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %r12, %rcx
callq 0x3067
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7e54
leaq 0xc8(%rsp), %rdi
callq 0x5f78
movl $0x1, 0x148(%r15)
movq 0x48(%rsp), %rbp
movq 0x40(%rsp), %rax
movq 0x80(%rax), %r13
xorpd %xmm0, %xmm0
movapd %xmm0, 0xc0(%rsp)
andq $0x0, 0xd0(%rsp)
movq -0x10(%r13), %rax
addq $-0x10, %r13
movl 0x8(%rbp), %ecx
movl %ecx, %esi
subl 0xac(%rbp), %esi
cmpl %esi, 0x8(%rax)
je 0x4bcd
testl %ecx, %ecx
setle %cl
testl %esi, %esi
setle %dl
testb %dl, %cl
je 0x4bd1
xorl %ebx, %ebx
jmp 0x4bec
leaq 0xc0(%rsp), %rcx
movq %r13, %rdi
movq 0x40(%rsp), %rdx
callq 0x6804
movq (%r13), %rax
movb $0x1, %bl
xorpd %xmm0, %xmm0
movupd %xmm0, 0xc8(%rax)
movq 0x48(%rsp), %rax
movslq (%rax), %rax
leaq (%rax,%rax,8), %rsi
movq 0x40(%rsp), %rax
addq (%rax), %rsi
movq %r13, %rdi
callq 0x3676
movq 0x48(%rsp), %rax
cmpl $0x0, (%rax)
je 0x4ca8
movq %r13, %rdi
callq 0x3a57
testb %al, %al
je 0x4e5c
movq 0x40(%rsp), %r14
leaq 0xa8(%r14), %rbx
movq %rbx, %rdi
callq 0x6a88
leaq 0xf8(%r14), %rdi
callq 0x6a88
leaq -0x1157(%rip), %rsi     # 0x3b02
movq %rbx, %rdi
callq 0x69d0
movq 0x40(%rsp), %rax
incl 0x148(%rax)
movq 0xd8(%rax), %rdi
cmpq 0xe0(%rax), %rdi
jne 0x4c91
movq 0x40(%rsp), %rax
movq 0xf0(%rax), %rax
movl $0x1f8, %edi            # imm = 0x1F8
addq -0x8(%rax), %rdi
addq $-0x38, %rdi
movl $0xc8, %esi
addq (%r13), %rsi
movq %r13, %rdx
callq 0x6a20
jmp 0x4cff
movq 0x40(%rsp), %rax
leaq 0xa8(%rax), %rdi
leaq -0x11b9(%rip), %rsi     # 0x3b02
callq 0x69d0
movq 0x40(%rsp), %rax
movq 0xd8(%rax), %rdi
cmpq 0xe0(%rax), %rdi
jne 0x4cea
movq 0x40(%rsp), %rax
movq 0xf0(%rax), %rax
movl $0x1f8, %edi            # imm = 0x1F8
addq -0x8(%rax), %rdi
addq $-0x38, %rdi
movl $0xc8, %esi
addq (%r13), %rsi
movq %r13, %rdx
callq 0x6a20
movq 0x40(%rsp), %rax
movl 0x148(%rax), %eax
movq (%r13), %rcx
movl %eax, 0x100(%rcx)
leaq 0xc0(%rsp), %rdi
callq 0x60fc
movq 0x48(%rsp), %r13
movslq (%r13), %rax
testq %rax, %rax
je 0x4fd5
pushq $-0x1
popq %rcx
movq %rcx, 0x60(%rsp)
movq 0x40(%rsp), %rdx
movq (%rdx), %rcx
movq 0x98(%rdx), %rbx
addq $-0x10, %rbx
leaq (%rax,%rax,8), %rax
leaq (%rcx,%rax), %rsi
addq $-0x9, %rsi
movq %rbx, %rdi
callq 0x3676
movl $0xdeadbeef, %eax       # imm = 0xDEADBEEF
movq %rax, 0x58(%rsp)
pushq $-0x2
popq %r14
movl $0x138, %ebp            # imm = 0x138
cmpq $0xa, %r14
je 0x4dcd
xorl %r13d, %r13d
cmpq $0x40, %r13
je 0x4dc4
movq (%rbx), %r15
addq %rbp, %r15
movq (%r13,%r15), %rdi
testq %rdi, %rdi
je 0x4da4
addq $0x14, %rdi
movq %r12, %rsi
callq 0x7ddf
testb %al, %al
jne 0x4daa
addq $0x10, %r13
jmp 0x4d7e
movq (%r13,%r15), %rax
movq 0xb4(%rax), %rax
movq %rax, 0x58(%rsp)
shrq $0x20, %rax
movq %rax, 0x60(%rsp)
incq %r14
addq $0x40, %rbp
jmp 0x4d75
movq 0x40(%rsp), %r15
leaq 0x90(%r15), %r14
movq 0x58(%rsp), %rbp
movl %ebp, %eax
xorl $0xdeadbeef, %eax       # imm = 0xDEADBEEF
movq 0x60(%rsp), %r13
movl %r13d, %ecx
notl %ecx
orl %eax, %ecx
jne 0x4f4d
movq 0xf1f2(%rip), %rdi      # 0x13ff0
leaq 0x84fc(%rip), %rsi      # 0xd301
callq 0x2160
movq %rax, %rdi
callq 0x20a0
movq 0x48(%rsp), %rax
movl (%rax), %esi
movl 0xac(%rax), %edx
subl 0x8(%rax), %edx
leaq 0xc0(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
callq 0x3067
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7e54
leaq 0xc8(%rsp), %rdi
callq 0x5f78
movq 0x40(%rsp), %r15
movq 0x48(%rsp), %r13
jmp 0x4fa3
testb %bl, %bl
je 0x5ac0
movq 0xf185(%rip), %rdi      # 0x13ff0
leaq 0x8481(%rip), %rsi      # 0xd2f3
callq 0x2160
movq %rax, %rdi
callq 0x20a0
movq 0x40(%rsp), %r13
incl 0x148(%r13)
leaq 0x1a0(%rsp), %rdi
movq %r13, (%rdi)
leaq 0xa8(%r13), %rbx
movq %rbx, %rsi
callq 0x6ab0
leaq 0xf8(%r13), %rsi
leaq 0x1a0(%rsp), %rdi
callq 0x6ab0
movq 0xc0(%rsp), %r14
movq 0xc8(%rsp), %r15
leaq 0xb8(%r13), %rax
movq %rax, 0x60(%rsp)
leaq -0x13da(%rip), %r13     # 0x3b02
cmpq %r15, %r14
je 0x4d14
movq (%r14), %rax
movslq (%rax), %rbp
movq 0x48(%rsp), %rax
movslq (%rax), %rax
subq %rax, %rbp
movq %rbx, %rdi
callq 0x6cae
cmpq %rbp, %rax
ja 0x4f10
movq %rbx, %rdi
movq %r13, %rsi
callq 0x69d0
jmp 0x4ef6
movq 0x60(%rsp), %rdi
movq %rbp, %rsi
callq 0x8c96
movq (%r14), %rsi
movl $0xc8, %ecx
addq %rcx, %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x6cbe
movq 0x40(%rsp), %rax
movl 0x148(%rax), %eax
movq (%r14), %rcx
movl %eax, 0x100(%rcx)
addq $0x10, %r14
jmp 0x4edc
movq %r13, %rax
shlq $0x20, %rax
movl %ebp, %esi
orq %rax, %rsi
movq %rbx, %rdi
callq 0x39a5
movslq %ebp, %rax
shlq $0x6, %rax
addq (%rbx), %rax
movslq %r13d, %rcx
shlq $0x4, %rcx
leaq (%rcx,%rax), %rbx
addq $0x1b8, %rbx            # imm = 0x1B8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d50
movq 0x48(%rsp), %r13
movl 0xac(%r13), %esi
subl 0x8(%r13), %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x6d7c
movq 0x98(%r15), %rax
movq -0x10(%rax), %rax
xorpd %xmm0, %xmm0
movupd %xmm0, 0xc8(%rax)
movq 0x98(%r15), %rdi
addq $-0x10, %rdi
movslq (%r13), %rax
leaq (%rax,%rax,8), %rsi
addq (%r15), %rsi
callq 0x3676
callq 0x2030
movq %rax, 0x98(%rsp)
movl $0x2bf20, %eax          # imm = 0x2BF20
subl 0x4(%r13), %eax
movl $0xffff8ad0, %ecx       # imm = 0xFFFF8AD0
cltd
idivl %ecx
cmpl $-0x3, %eax
pushq $-0x4
popq %r12
cmovgel %eax, %r12d
addl $0x8, %r12d
xorpd %xmm0, %xmm0
leaq 0x1a0(%rsp), %rdi
movapd %xmm0, 0x10(%rdi)
movapd %xmm0, (%rdi)
andq $0x0, 0x20(%rdi)
movq %r12, %rsi
callq 0x6f2a
movq 0x40(%rsp), %r14
movq 0x98(%r14), %rsi
addq $-0x10, %rsi
leaq 0xc0(%rsp), %rbx
movq %rbx, %rdi
callq 0x605a
pushq $0x3c
popq %rdx
leaq 0x1a0(%rsp), %r9
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %ecx
movq %r13, %r8
callq 0x6f5b
leaq 0xc8(%rsp), %rdi
callq 0x5f78
movq 0x98(%r14), %rax
movq -0x10(%rax), %rax
movl 0xc(%rax), %eax
movl %eax, 0x1c4(%rsp)
movq 0x1a0(%rsp), %rdi
movq 0x1a8(%rsp), %rsi
callq 0x9711
leaq 0x48(%r14), %rcx
movq %rcx, 0x178(%rsp)
leaq 0x18(%r14), %rcx
movq %rcx, 0x180(%rsp)
leaq 0x78(%r14), %rcx
movq %rcx, 0x170(%rsp)
movq (%rax), %rax
movq %rax, 0x1b8(%rsp)
xorl %ebx, %ebx
cmpq %rbx, %r12
je 0x5108
cvtsi2sd %ebx, %xmm1
movsd 0x8107(%rip), %xmm0     # 0xd1e0
callq 0x2240
movq 0x1a0(%rsp), %rax
cvtsi2sdl (%rax,%rbx,8), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
cmpl %eax, 0x1c0(%rsp)
jge 0x5103
movl %eax, 0x1c0(%rsp)
incq %rbx
jmp 0x50c8
xorl %ebx, %ebx
leaq 0x8201(%rip), %r15      # 0xd312
leaq 0x826d(%rip), %rbp      # 0xd385
leaq 0x81f9(%rip), %r13      # 0xd318
leaq 0x81f5(%rip), %r14      # 0xd31b
cmpq %rbx, %r12
je 0x5199
movq 0xeebe(%rip), %rdi      # 0x13ff0
movq %r15, %rsi
callq 0x2160
movq %rax, %rdi
movl %ebx, %esi
callq 0x2230
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2160
movq 0x1a0(%rsp), %rcx
movl 0x4(%rcx,%rbx,8), %esi
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
movq %r13, %rsi
callq 0x2160
movq 0x1a0(%rsp), %rcx
movl (%rcx,%rbx,8), %esi
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
movq %r14, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20a0
incq %rbx
jmp 0x5126
movq 0xee50(%rip), %rdi      # 0x13ff0
leaq 0x8177(%rip), %rsi      # 0xd31e
callq 0x2160
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x71d2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2060
leaq 0x815f(%rip), %rsi      # 0xd32d
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20a0
callq 0x2030
movq %rax, 0x98(%rsp)
movq $-0x21524111, 0x50(%rsp) # imm = 0xDEADBEEF
movq 0x40(%rsp), %r8
movq 0x80(%r8), %rax
movq -0x10(%rax), %rax
movq 0xd8(%rax), %rax
movl 0x4(%rax), %ecx
movq 0x48(%rsp), %rdx
movl (%rdx), %eax
movl 0x4(%rdx), %esi
cmpl $0xe, %eax
pushq $0xe
popq %rdx
cmovll %eax, %edx
pushq $0x16
popq %rdi
subl %edx, %edi
pushq $-0x2
popq %r9
movl %ecx, %eax
cltd
idivl %r9d
movl %eax, %r9d
addl $0x12, %r9d
cmpl %r9d, %edi
cmovgl %edi, %r9d
pushq $0x1e
popq %rdi
movl %esi, %eax
cltd
idivl %edi
movl 0x1bc(%rsp), %edx
cmpl %edx, %ecx
cmovgl %ecx, %edx
imull $0xaa, %edx, %ecx
cmpl $0x8, %edx
movl $0x4b0, %ebp            # imm = 0x4B0
cmovgel %ecx, %ebp
cmpl %eax, %ebp
cmovgel %eax, %ebp
movq %r9, 0xb8(%rsp)
leal 0x1(%r9), %eax
movslq %eax, %r14
leaq 0xa8(%r8), %r13
leaq -0x1783(%rip), %rbx     # 0x3b02
movq %r13, %rdi
callq 0x6cae
cmpq %r14, %rax
ja 0x529f
movq %r13, %rdi
movq %rbx, %rsi
callq 0x69d0
jmp 0x5285
movq 0x40(%rsp), %rax
leaq 0xf8(%rax), %r15
leaq -0x17b0(%rip), %rbx     # 0x3b02
movq %r15, %rdi
callq 0x6cae
movq %rax, %r14
movq %r13, %rdi
callq 0x6cae
cmpq %rax, %r14
jae 0x52d7
movq %r15, %rdi
movq %rbx, %rsi
callq 0x69d0
jmp 0x52b2
movl %ebp, 0xb4(%rsp)
movq %r15, 0xa8(%rsp)
leaq 0x6f(%rsp), %rax
movb $0x0, (%rax)
movabsq $-0x10000000000000, %rcx # imm = 0xFFF0000000000000
leaq 0x278(%rsp), %rdx
movq %rcx, (%rdx)
xorpd %xmm0, %xmm0
leaq 0x70(%rsp), %rcx
movapd %xmm0, (%rcx)
movq 0x48(%rsp), %rsi
movq %rsi, 0xc0(%rsp)
leaq 0x1a0(%rsp), %rsi
movq %rsi, 0xc8(%rsp)
movq %rax, 0xd0(%rsp)
movq %rdx, 0xd8(%rsp)
movq %rcx, 0xe0(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xec97(%rip), %rdi      # 0x13ff0
leaq 0x7fd0(%rip), %rsi      # 0xd330
callq 0x2160
movq %rax, %rdi
callq 0x20a0
movq 0x40(%rsp), %rax
leaq 0x108(%rax), %r15
xorl %ebx, %ebx
leaq 0x88(%rsp), %r14
leaq 0x280(%rsp), %rbp
movq %r15, 0x58(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x6cae
cmpq %rbx, %rax
jbe 0x54e4
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8c96
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x54dc
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8c96
movq (%rax), %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0xcb24
movq 0x88(%rsp), %r12
testq %r12, %r12
je 0x54b3
leaq 0x268(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
movq %r14, %rdx
callq 0x7252
movq %r12, 0x60(%rsp)
movq %r13, %r12
leaq 0x270(%rsp), %rdi
callq 0x5f78
movq 0x40(%rsp), %r15
movq 0x80(%r15), %r13
movq %r14, %rsi
leaq 0x188(%rsp), %rdi
callq 0x605a
movq 0x48(%rsp), %rax
movl (%rax), %edx
movq %rbp, %rdi
leaq 0x188(%rsp), %rsi
callq 0x38ea
addq $-0x10, %r13
movl 0x148(%r15), %r8d
movupd 0xc0(%rsp), %xmm0
movupd 0xd0(%rsp), %xmm1
movups 0xe0(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movupd %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r12, %r13
movq %r12, %rcx
callq 0x748e
movq %rbp, %rdi
callq 0xcb98
leaq 0x190(%rsp), %rdi
callq 0x5f78
movq 0x58(%rsp), %r15
movq 0x60(%rsp), %r12
jmp 0x54c6
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8c96
movq %rax, %rdi
callq 0x71ea
leaq 0x90(%rsp), %rdi
callq 0x5f78
testq %r12, %r12
je 0x53a6
incq %rbx
jmp 0x5390
movq 0xeb05(%rip), %rdi      # 0x13ff0
leaq 0x7e49(%rip), %rsi      # 0xd33b
callq 0x2160
movq %rax, %rdi
callq 0x20a0
movq 0x48(%rsp), %rax
movl (%rax), %edx
movq 0x40(%rsp), %rsi
movl 0x148(%rsi), %r9d
movq 0x80(%rsi), %rax
addq $-0x10, %rax
movslq 0xb4(%rsp), %rcx
movupd 0xc0(%rsp), %xmm0
movupd 0xd0(%rsp), %xmm1
movups 0xe0(%rsp), %xmm2
movups %xmm2, 0x30(%rsp)
movupd %xmm1, 0x20(%rsp)
movupd %xmm0, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rax, (%rsp)
pushq $0x8
popq %rcx
movq %r13, %rdi
movq 0xb8(%rsp), %r8
callq 0x774e
cmpq $0x0, 0x70(%rsp)
je 0x55ce
leaq 0x258(%rsp), %rbx
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0x605a
movq 0x48(%rsp), %rax
movl (%rax), %edx
incl %edx
leaq 0x88(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3870
leaq 0x260(%rsp), %rdi
callq 0x5f78
movq (%r14), %rax
movq 0xb4(%rax), %rax
movq %rax, 0x50(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x5f78
movq 0x40(%rsp), %rax
leaq 0xb8(%rax), %rbx
xorl %r14d, %r14d
movq 0xb8(%rsp), %rbp
testl %ebp, %ebp
cmovlel %r14d, %ebp
pushq $0x18
popq %r12
leaq 0x7d67(%rip), %r15      # 0xd35d
cmpq %r14, %rbp
je 0x5699
movq 0xe9ea(%rip), %rdi      # 0x13ff0
leaq 0x7d3e(%rip), %rsi      # 0xd34b
callq 0x2160
movq %rax, %rdi
movl %r14d, %esi
callq 0x2230
movq %rax, %rdi
leaq 0x7d2e(%rip), %rsi      # 0xd355
callq 0x2160
movq %rax, %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8c96
movq 0x8(%rax), %rcx
subq (%rax), %rcx
movq %rcx, %rax
cqto
idivq %r12
movq %r13, %rdi
movq %rax, %rsi
callq 0x20f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
movq %rax, %r13
movq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x8c96
movq 0x8(%rax), %rcx
subq (%rax), %rcx
movq %rcx, %rax
cqto
idivq %r12
movq %r13, %rdi
movq %rax, %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x20a0
incq %r14
jmp 0x55f6
movq 0xe950(%rip), %rdi      # 0x13ff0
leaq 0x7cbf(%rip), %rsi      # 0xd366
callq 0x2160
movq 0x58(%rsp), %r14
movq %rax, %rdi
callq 0x20a0
xorl %ebp, %ebp
leaq 0x7cc5(%rip), %r12      # 0xd387
movq 0xa8(%rsp), %rdi
callq 0x6cae
cmpq %rbp, %rax
jbe 0x580e
movq %r14, %rdi
movq %rbp, %rsi
callq 0x8c96
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x5806
movq %r14, %rdi
movq %rbp, %rsi
callq 0x8c96
movq (%rax), %rsi
addq $0x8, %rsi
leaq 0x88(%rsp), %rdi
callq 0xcb24
movq 0x88(%rsp), %rax
movl (%rax), %ebx
movl 0x8(%rax), %esi
movq 0x48(%rsp), %rcx
movl (%rcx), %r15d
movl 0xbc(%rax), %r13d
addl $0x14, %esi
movl 0x1c4(%rsp), %ecx
movl %ecx, %eax
cltd
pushq $-0x2
popq %rdi
idivl %edi
addl $0x3c, %eax
cmpl $0x50, %ecx
pushq $0x14
popq %rcx
cmovgel %ecx, %eax
cmpl %eax, %esi
cmovgl %esi, %eax
leal (%rax,%rax,4), %r14d
addl 0x1c0(%rsp), %r14d
movq 0xe88f(%rip), %rdi      # 0x13ff0
leaq 0x7c03(%rip), %rsi      # 0xd36b
callq 0x2160
subl %r15d, %ebx
movq %rax, %rdi
movl %ebx, %esi
callq 0x2230
movq %rax, %rdi
leaq 0x7bce(%rip), %rsi      # 0xd352
callq 0x2160
movq 0x88(%rsp), %rcx
movl 0xc0(%rcx), %esi
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
leaq 0x7b6f(%rip), %rsi      # 0xd318
callq 0x2160
movq 0x88(%rsp), %rcx
movl 0xbc(%rcx), %esi
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
leaq 0x7b4d(%rip), %rsi      # 0xd31b
callq 0x2160
cmpl %r13d, %r14d
movq %r12, %rsi
leaq 0x7b93(%rip), %rcx      # 0xd373
cmovlq %rcx, %rsi
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20a0
leaq 0x90(%rsp), %rdi
callq 0x5f78
movq 0x58(%rsp), %r14
incq %rbp
jmp 0x56c2
leaq 0x78(%rsp), %rdi
callq 0x5f78
movq 0xe7d1(%rip), %rdi      # 0x13ff0
leaq 0x7b53(%rip), %rsi      # 0xd379
callq 0x2160
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x71d2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2060
leaq 0x7ae0(%rip), %rsi      # 0xd32d
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20a0
callq 0x2030
movq %rax, 0x98(%rsp)
movq 0x48(%rsp), %rax
movl 0x4(%rax), %eax
cmpl $0x15f90, %eax          # imm = 0x15F90
jle 0x587d
pushq $0x3
jmp 0x5886
cmpl $0xea60, %eax           # imm = 0xEA60
jle 0x5889
pushq $0x2
popq %rbx
jmp 0x5893
xorl %ebx, %ebx
cmpl $0x7531, %eax           # imm = 0x7531
setge %bl
cmpl $0x4e21, %eax           # imm = 0x4E21
jl 0x5aea
movq 0x48(%rsp), %rax
cmpl $0x5, 0xac(%rax)
movq 0xa8(%rsp), %rdi
jg 0x5aea
leaq 0xc8(%rsp), %r12
xorl %ebp, %ebp
pushq $0x5
popq %r15
cmpq %rbp, %rbx
je 0x5aea
callq 0x6cae
cmpq %rbp, %rax
jbe 0x5a90
movq %r14, %rdi
movq %rbp, %rsi
callq 0x8c96
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x5a90
movq %r14, %rdi
movq %rbp, %rsi
callq 0x8c96
movq (%rax), %rsi
addq $0x8, %rsi
leaq 0xc0(%rsp), %rdi
callq 0xcb24
movq 0xc0(%rsp), %rax
movq 0x50(%rsp), %xmm0
movq 0xb4(%rax), %xmm1
pcmpeqd %xmm0, %xmm1
pshufd $0x50, %xmm1, %xmm0     # xmm0 = xmm1[0,0,1,1]
movmskpd %xmm0, %ecx
cmpl $0x3, %ecx
je 0x5ae2
movl 0x8(%rax), %ecx
movq 0x1a0(%rsp), %rax
movl (%rax), %eax
cltd
idivl %r15d
cmpl $0x15, %eax
pushq $0x14
popq %rdx
cmovll %edx, %eax
cmpl $0x15, %ecx
jl 0x5a88
addl %ecx, %eax
addl $0xa, %eax
testl %eax, %eax
jg 0x5a88
movq 0xe679(%rip), %rdi      # 0x13ff0
leaq 0x7a0a(%rip), %rsi      # 0xd388
callq 0x2160
leal 0x1(%rbp), %esi
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
leaq 0x79ba(%rip), %rsi      # 0xd352
callq 0x2160
movq 0xc0(%rsp), %rcx
movl 0xc0(%rcx), %esi
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
leaq 0x795b(%rip), %rsi      # 0xd318
callq 0x2160
movq 0xc0(%rsp), %rcx
movl 0xbc(%rcx), %esi
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
leaq 0x7939(%rip), %rsi      # 0xd31b
callq 0x2160
movq %rax, %rdi
callq 0x20a0
movq 0x40(%rsp), %rsi
movq 0x98(%rsi), %rdi
addq $-0x10, %rdi
pushq $0x78
popq %rdx
pushq $0xa
popq %rcx
movq 0x48(%rsp), %r8
leaq 0xc0(%rsp), %r9
callq 0x7af7
leaq 0x248(%rsp), %r13
movq %r13, %rdi
leaq 0xc0(%rsp), %rsi
callq 0x605a
movq 0x48(%rsp), %rax
movl (%rax), %edx
incl %edx
leaq 0x70(%rsp), %rdi
movq %r13, %rsi
callq 0x3870
movq 0x70(%rsp), %rax
movq 0xb4(%rax), %rax
movq %rax, 0x50(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x5f78
leaq 0x250(%rsp), %rdi
callq 0x5f78
movq 0xe57c(%rip), %rdi      # 0x13ff0
leaq 0x7921(%rip), %rsi      # 0xd39c
callq 0x2160
movq %rax, %rdi
callq 0x20a0
movq %r12, %rdi
callq 0x5f78
incq %rbp
movq 0xa8(%rsp), %rdi
jmp 0x58c6
movq %rax, %r14
cmpl $0x1, %edx
jne 0x5e0d
movq %r14, %rdi
callq 0x2080
callq 0x2210
movq 0x58(%rsp), %r14
jmp 0x5a88
movq 0x40(%rsp), %rbx
leaq 0xa8(%rbx), %rdi
callq 0x6d26
leaq 0xf8(%rbx), %rdi
callq 0x6d26
jmp 0x4d14
movq %r12, %rdi
callq 0x5f78
movq 0xe4ff(%rip), %rdi      # 0x13ff0
leaq 0x78a9(%rip), %rsi      # 0xd3a1
callq 0x2160
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x71d2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2060
leaq 0x780e(%rip), %rsi      # 0xd32d
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20a0
movq 0x48(%rsp), %rdx
movslq (%rdx), %rax
movq 0x40(%rsp), %rcx
movq (%rcx), %rcx
leaq (%rax,%rax,8), %rax
movq (%rcx,%rax), %rdi
movl 0x8(%rdx), %edx
movzbl 0x8(%rcx,%rax), %esi
callq 0x2700
movq %rax, 0x70(%rsp)
movb %dl, 0x78(%rsp)
cmpl $0xdeadbeef, 0x50(%rsp) # imm = 0xDEADBEEF
jne 0x5c66
cmpl $-0x1, 0x54(%rsp)
jne 0x5c66
movq 0xe473(%rip), %rdi      # 0x13ff0
leaq 0x7833(%rip), %rsi      # 0xd3b7
callq 0x2160
movq %rax, %rdi
callq 0x20a0
pushq $-0x1
popq %rbp
leaq 0x70(%rsp), %r14
leaq 0x88(%rsp), %r15
movabsq $0x100000000, %r13      # imm = 0x100000000
pushq $-0x2
popq %r12
cmpl $0xa, %r12d
je 0x5c3a
movl %r12d, %r12d
movq %r12, 0x60(%rsp)
pushq $0x4
popq %rbx
subq $0x1, %rbx
jb 0x5c2d
movq %r12, 0x88(%rsp)
leaq 0xc0(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x2966
movl 0x164(%rsp), %eax
cmpl %eax, %ebp
jg 0x5bff
movq %r12, 0x50(%rsp)
movl %eax, %ebp
addq %r13, %r12
jmp 0x5bc4
movq %rax, %rdi
cmpl $0x3, %edx
jne 0x5c18
callq 0x2080
callq 0x2210
jmp 0x5bff
cmpl $0x2, %edx
jne 0x5e01
callq 0x2080
callq 0x2210
jmp 0x5bff
movq 0x60(%rsp), %r12
incl %r12d
jmp 0x5baf
cmpl $0xdeadbeef, 0x50(%rsp) # imm = 0xDEADBEEF
jne 0x5c66
cmpl $-0x1, 0x54(%rsp)
jne 0x5c66
movq 0xe39e(%rip), %rdi      # 0x13ff0
leaq 0x776f(%rip), %rsi      # 0xd3c8
callq 0x2160
movq %rax, %rdi
callq 0x20a0
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x2796
testb %al, %al
je 0x5d55
movq 0x180(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x7d9e
movq 0x40(%rsp), %rax
leaq 0x30(%rax), %rdi
leaq 0x50(%rsp), %rsi
callq 0x46f2
leaq 0xc0(%rsp), %rdi
leaq 0x70(%rsp), %rdx
leaq 0x50(%rsp), %rcx
movq 0xa0(%rsp), %rsi
callq 0x2966
movq 0x40(%rsp), %rbx
leaq 0x60(%rbx), %rdi
leaq 0x164(%rsp), %rsi
callq 0xa1f6
movq 0x50(%rbx), %rax
cmpq %rax, 0x48(%rbx)
je 0x5ce6
movl -0x4(%rax), %eax
jmp 0x5ce8
xorl %eax, %eax
movq 0x40(%rsp), %rbx
movq 0x68(%rbx), %rcx
addl -0x8(%rcx), %eax
leaq 0xc0(%rsp), %rsi
movl %eax, (%rsi)
movq 0x178(%rsp), %rdi
callq 0xa2f2
movq 0x80(%rbx), %rdi
addq $-0x10, %rdi
movq 0x50(%rsp), %rsi
callq 0x39a5
movq 0x80(%rbx), %rax
movslq 0x50(%rsp), %rcx
shlq $0x6, %rcx
addq -0x10(%rax), %rcx
movslq 0x54(%rsp), %rax
shlq $0x4, %rax
leaq (%rax,%rcx), %rsi
addq $0x1b8, %rsi            # imm = 0x1B8
movq 0x170(%rsp), %rdi
callq 0x6d50
movq 0xe294(%rip), %rdi      # 0x13ff0
leaq 0x7676(%rip), %rsi      # 0xd3d9
callq 0x2160
movq %rax, %rbx
leaq 0x198(%rsp), %rdi
callq 0x71d2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2060
leaq 0x75a3(%rip), %rsi      # 0xd32d
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20a0
leaq 0x1a0(%rsp), %rdi
callq 0x66ce
movq 0x50(%rsp), %rax
addq $0x298, %rsp            # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5e0a
jmp 0x5dfe
jmp 0x5dfe
jmp 0x5dca
jmp 0x5e16
jmp 0x5dca
movq %rax, %r14
leaq 0xc8(%rsp), %rdi
callq 0x5f78
jmp 0x5e7f
jmp 0x5dfe
jmp 0x5dfe
jmp 0x5dfe
jmp 0x5dfe
jmp 0x5e2f
movq %rax, %r14
leaq 0xc8(%rsp), %rdi
jmp 0x5e6d
jmp 0x5e2f
jmp 0x5e16
jmp 0x5e16
jmp 0x5e2f
movq %rax, %rdi
movq %rdi, %r14
jmp 0x5e72
jmp 0x5e2a
jmp 0x5e2f
movq %rax, %r14
movq %r12, %rdi
jmp 0x5e6d
jmp 0x5e2f
jmp 0x5e2f
movq %rax, %r14
leaq 0xc0(%rsp), %rdi
callq 0x60fc
jmp 0x5e7f
jmp 0x5e58
movq %rax, %r14
jmp 0x5e68
movq %rax, %r14
jmp 0x5e72
movq %rax, %r14
leaq 0x280(%rsp), %rdi
callq 0xcb98
jmp 0x5e49
movq %rax, %r14
leaq 0x190(%rsp), %rdi
callq 0x5f78
jmp 0x5e5b
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0x5f78
leaq 0x78(%rsp), %rdi
callq 0x5f78
leaq 0x1a0(%rsp), %rdi
callq 0x66ce
movq %r14, %rdi
callq 0x2250
nop