// File: /workspace/github_cpp_makefile_star2_O3/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 $0x288, %rsp            # imm = 0x288
movq %rsi, %r12
movq %rdi, %r14
callq 0x2040
callq 0x2040
movq %rax, 0x190(%rsp)
movq 0xff38(%rip), %rbx      # 0x14ff0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xa1b9(%rip), %rsi      # 0xf29f
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2180
movl (%r12), %esi
movq %rbx, %rdi
callq 0x2210
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xa176(%rip), %rsi      # 0xf2a6
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2180
movq %r12, 0x50(%rsp)
movl 0x4(%r12), %esi
movq %rbx, %rdi
callq 0x2210
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xa137(%rip), %rsi      # 0xf2b7
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2180
movq 0x50(%r14), %rax
xorl %ebx, %ebx
movl $0x0, %esi
movq %r14, 0x48(%rsp)
cmpq %rax, 0x48(%r14)
je 0x51a6
movl -0x4(%rax), %esi
movq 0x48(%rsp), %rax
addq $0x48, %rax
movq %rax, 0x178(%rsp)
movq 0xfe32(%rip), %r15      # 0x14ff0
movq %r15, %rdi
callq 0x2210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xa0ee(%rip), %rsi      # 0xf2e5
movl $0xb, %edx
movq %r15, %rdi
callq 0x2180
movq 0x50(%rsp), %r14
movl 0x8(%r14), %esi
subl 0xac(%r14), %esi
movq %r15, %rdi
callq 0x2210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xa072(%rip), %rsi      # 0xf2bf
movl $0x18, %edx
movq %r15, %rdi
callq 0x2180
leaq 0xc(%r14), %rax
movq %rax, 0x98(%rsp)
xorl %ecx, %ecx
movd %ebx, %xmm0
xorl %edx, %edx
movd (%rax,%rdx), %xmm1
pcmpeqb 0x9d95(%rip), %xmm1     # 0xf010
punpcklbw %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
punpcklwd %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3]
pand 0x9d95(%rip), %xmm1     # 0xf020
paddd %xmm1, %xmm0
addq $0x4, %rdx
cmpq $0x10, %rdx
jne 0x526e
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddd %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0     # xmm0 = xmm1[1,1,1,1]
paddd %xmm1, %xmm0
movd %xmm0, %ebx
incq %rcx
addq $0x10, %rax
cmpq $0xa, %rcx
jne 0x5268
movq 0xfd2d(%rip), %r15      # 0x14ff0
movq %r15, %rdi
movl %ebx, %esi
callq 0x2210
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x9fda(%rip), %rsi      # 0xf2d8
movl $0x18, %edx
movq %r15, %rdi
callq 0x2180
movdqa 0x9d0d(%rip), %xmm3     # 0xf020
movdqa 0x9cf5(%rip), %xmm2     # 0xf010
movq 0x50(%rsp), %rax
leaq 0xb0(%rax), %rbx
xorl %eax, %eax
movq %rbx, %rcx
xorl %esi, %esi
movd %esi, %xmm0
xorl %edx, %edx
movd (%rcx,%rdx), %xmm1
pcmpeqb %xmm2, %xmm1
punpcklbw %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
punpcklwd %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3]
pand %xmm3, %xmm1
paddd %xmm1, %xmm0
addq $0x4, %rdx
cmpq $0x10, %rdx
jne 0x5334
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddd %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0     # xmm0 = xmm1[1,1,1,1]
paddd %xmm1, %xmm0
movd %xmm0, %esi
incq %rax
addq $0x10, %rcx
cmpq $0xa, %rax
jne 0x532e
movq 0xfc6f(%rip), %r13      # 0x14ff0
movq %r13, %rdi
callq 0x2210
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x9f37(%rip), %rsi      # 0xf2f1
movl $0x16, %edx
movq %r13, %rdi
callq 0x2180
movq 0x98(%rsp), %rdi
callq 0x312b
shrq $0x20, %rax
movq %r13, %rdi
movl %eax, %esi
callq 0x2210
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x9ef5(%rip), %rsi      # 0xf308
movl $0x16, %edx
movq %r13, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x312b
shrq $0x20, %rax
movq %r13, %rdi
movl %eax, %esi
callq 0x2210
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x48(%rsp), %rax
movq 0x20(%rax), %r15
cmpq %r15, 0x18(%rax)
je 0x5652
movslq -0x150(%r15), %rax
movq 0x48(%rsp), %r14
movq (%r14), %rcx
leaq (%rax,%rax,8), %rax
movq (%rcx,%rax), %rdi
movl -0x148(%r15), %edx
movzbl 0x8(%rcx,%rax), %esi
callq 0x289d
leaq 0x80(%rsp), %r8
movq %rax, (%r8)
movb %dl, 0x8(%r8)
addq $-0x144, %r15           # imm = 0xFEBC
movq 0x38(%r14), %rcx
addq $-0x8, %rcx
leaq 0xc0(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r8, %rdx
callq 0x2b7b
leaq 0x1d0(%rsp), %rdi
movl $0xa0, %edx
movq %r12, %rsi
callq 0x2120
xorl %eax, %eax
movdqu 0x1d0(%rsp,%rax), %xmm0
movq 0x98(%rsp), %rcx
movdqu (%rcx,%rax), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %edx
xorl %ecx, %ecx
cmpl $0xffff, %edx           # imm = 0xFFFF
setne %dl
jne 0x5520
leaq 0x10(%rax), %rsi
cmpq $0x90, %rax
movq %rsi, %rax
jne 0x54e6
movb %dl, %cl
testl %ecx, %ecx
je 0x5652
leaq 0x9dee(%rip), %rsi      # 0xf31f
movl $0x3, %edx
movq %r13, %rdi
callq 0x2180
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x1d0(%rsp), %rsi
movq %r13, %rdi
callq 0x7891
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x9d7c(%rip), %rsi      # 0xf323
movl $0x3, %edx
movq %r13, %rdi
callq 0x2180
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %r13, %rdi
movq 0x98(%rsp), %rsi
callq 0x7891
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x9d0a(%rip), %rsi      # 0xf327
movl $0x3, %edx
movq %r13, %rdi
callq 0x2180
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x50(%rsp), %rdx
cmpl $0x0, (%rdx)
jne 0x5700
movq 0x48(%rsp), %rax
leaq 0x78(%rax), %r15
movl 0x8(%rdx), %edx
leaq 0xc0(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
movq 0x98(%rsp), %rcx
callq 0x33e5
movq %r15, %rdi
movq %r12, %rsi
callq 0x9650
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0x56a3
callq 0x730e
movq 0x48(%rsp), %rax
leaq 0x90(%rax), %r15
movq 0x50(%rsp), %rax
movl (%rax), %esi
movl 0xac(%rax), %edx
leaq 0xc0(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rcx
callq 0x33e5
movq %r15, %rdi
movq %r12, %rsi
callq 0x9650
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0x56ec
callq 0x730e
movq 0x48(%rsp), %rax
movl $0x1, 0x148(%rax)
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rax
movq 0x80(%rax), %r15
pxor %xmm0, %xmm0
movdqa %xmm0, 0xc0(%rsp)
movq $0x0, 0xd0(%rsp)
movq -0x10(%r15), %rax
addq $-0x10, %r15
movl 0x8(%rdx), %ecx
movl %ecx, %esi
subl 0xac(%rdx), %esi
cmpl %esi, 0x8(%rax)
je 0x574b
testl %ecx, %ecx
setle %cl
testl %esi, %esi
setle %dl
testb %dl, %cl
je 0x574f
xorl %ebp, %ebp
jmp 0x576a
leaq 0xc0(%rsp), %rcx
movq %r15, %rdi
movq 0x48(%rsp), %rdx
callq 0x7952
movq (%r15), %rax
movb $0x1, %bpl
pxor %xmm0, %xmm0
movdqu %xmm0, 0xc8(%rax)
movq 0x50(%rsp), %rax
movslq (%rax), %rax
leaq (%rax,%rax,8), %rsi
movq 0x48(%rsp), %rax
addq (%rax), %rsi
movq %r15, %rdi
callq 0x3cbe
movq 0x50(%rsp), %rax
cmpl $0x0, (%rax)
je 0x5825
movq %r15, %rdi
callq 0x418f
testb %al, %al
je 0x5a2a
movq 0x48(%rsp), %r14
leaq 0xa8(%r14), %r12
movq %r12, %rdi
callq 0x7c7e
leaq 0xf8(%r14), %rdi
callq 0x7c7e
leaq -0x1589(%rip), %rsi     # 0x424e
movq %r12, %rdi
callq 0x7b9e
movq 0x48(%rsp), %rax
incl 0x148(%rax)
movq 0xd8(%rax), %rdi
cmpq 0xe0(%rax), %rdi
jne 0x580f
movq 0x48(%rsp), %rax
movq 0xf0(%rax), %rax
movl $0x1f8, %edi            # imm = 0x1F8
addq -0x8(%rax), %rdi
addq $-0x38, %rdi
movl $0xc8, %esi
addq (%r15), %rsi
movq %r15, %rdx
callq 0x7bee
jmp 0x587b
movq 0x48(%rsp), %rax
leaq 0xa8(%rax), %rdi
leaq -0x15ea(%rip), %rsi     # 0x424e
callq 0x7b9e
movq 0x48(%rsp), %rax
movq 0xd8(%rax), %rdi
cmpq 0xe0(%rax), %rdi
jne 0x5867
movq 0x48(%rsp), %rax
movq 0xf0(%rax), %rax
movl $0x1f8, %edi            # imm = 0x1F8
addq -0x8(%rax), %rdi
addq $-0x38, %rdi
movl $0xc8, %esi
addq (%r15), %rsi
movq %r15, %rdx
callq 0x7bee
movq 0x48(%rsp), %rax
movl 0x148(%rax), %eax
movq (%r15), %rcx
movl %eax, 0x100(%rcx)
leaq 0xc0(%rsp), %rdi
callq 0x7412
movq 0x50(%rsp), %r15
movslq (%r15), %rax
testq %rax, %rax
je 0x5c3b
movq 0x48(%rsp), %rdx
movq (%rdx), %rcx
movq 0x98(%rdx), %r14
leaq -0x10(%r14), %r15
leaq (%rax,%rax,8), %rax
leaq (%rcx,%rax), %rsi
addq $-0x9, %rsi
movq %r15, %rdi
callq 0x3cbe
movl $0x138, %eax            # imm = 0x138
addq -0x10(%r14), %rax
movl $0xdeadbeef, %ebp       # imm = 0xDEADBEEF
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq $-0x2, %rcx
movq %rcx, %rdx
shlq $0x6, %rdx
addq %rax, %rdx
addq $0x80, %rdx
xorl %esi, %esi
movq %rsi, %rdi
shlq $0x4, %rdi
movq (%rdx,%rdi), %rdi
testq %rdi, %rdi
je 0x5953
xorl %r8d, %r8d
movdqu 0x14(%rdi,%r8), %xmm0
movdqu (%rbx,%r8), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %r10d
xorl %r9d, %r9d
cmpl $0xffff, %r10d          # imm = 0xFFFF
setne %r10b
jne 0x594b
leaq 0x10(%r8), %r11
cmpq $0x90, %r8
movq %r11, %r8
jne 0x5915
movb %r10b, %r9b
testl %r9d, %r9d
je 0x595e
incq %rsi
cmpq $0x4, %rsi
jne 0x5902
jmp 0x596c
movq 0xb4(%rdi), %rbp
movq %rbp, %r13
shrq $0x20, %r13
incq %rcx
cmpq $0xa, %rcx
jne 0x58ef
movq 0x48(%rsp), %r14
leaq 0x90(%r14), %r12
movl %ebp, %eax
xorl $0xdeadbeef, %eax       # imm = 0xDEADBEEF
movl %r13d, %ecx
notl %ecx
orl %eax, %ecx
jne 0x5bb4
leaq 0x9999(%rip), %rsi      # 0xf339
movl $0x10, %edx
movq 0xf644(%rip), %r14      # 0x14ff0
movq %r14, %rdi
callq 0x2180
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x50(%rsp), %rax
movl (%rax), %esi
movl 0xac(%rax), %edx
subl 0x8(%rax), %edx
leaq 0xc0(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rcx
callq 0x33e5
movq %r12, %rdi
movq %r15, %rsi
callq 0x9650
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0x5a1b
callq 0x730e
movq 0x48(%rsp), %r14
movq 0x50(%rsp), %r15
jmp 0x5c0a
testb %bpl, %bpl
je 0x6548
movq 0xf5b6(%rip), %r15      # 0x14ff0
leaq 0x98ea(%rip), %rsi      # 0xf32b
movl $0xd, %edx
movq %r15, %rdi
callq 0x2180
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq 0xf584(%rip), %rdi      # 0x14ff0
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x48(%rsp), %r14
incl 0x148(%r14)
leaq 0x1d0(%rsp), %rdi
movq %r14, (%rdi)
leaq 0xa8(%r14), %r15
movq %r15, %rsi
callq 0x7ca6
leaq 0xf8(%r14), %rsi
leaq 0x1d0(%rsp), %rdi
callq 0x7ca6
movq 0xc0(%rsp), %rbp
movq 0xc8(%rsp), %r14
cmpq %r14, %rbp
je 0x588f
movq 0x48(%rsp), %rax
addq $0xb8, %rax
movq %rax, 0x60(%rsp)
leaq -0x1895(%rip), %r12     # 0x424e
movq (%rbp), %rax
movslq (%rax), %r13
movq 0x50(%rsp), %rax
movslq (%rax), %rax
subq %rax, %r13
movq 0x48(%rsp), %rsi
movq 0xf0(%rsi), %rax
movq %rax, %rcx
subq 0xd0(%rsi), %rcx
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
leaq (%rcx,%rcx,8), %rax
movq 0xc8(%rsi), %rcx
movq 0xd8(%rsi), %rdx
subq 0xe0(%rsi), %rdx
sarq $0x3, %rdx
movabsq $0x6db6db6db6db6db7, %rdi # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdi, %rdx
addq %rax, %rdx
subq 0xb8(%rsi), %rcx
sarq $0x3, %rcx
imulq %rdi, %rcx
addq %rdx, %rcx
cmpq %r13, %rcx
ja 0x5b69
movq %r15, %rdi
movq %r12, %rsi
callq 0x7b9e
jmp 0x5af5
movq 0x60(%rsp), %rdi
movq %r13, %rsi
callq 0xa59e
movq (%rbp), %rsi
movl $0xc8, %ecx
addq %rcx, %rsi
movq %rax, %rdi
movq %rbp, %rdx
callq 0x80c2
movq 0x48(%rsp), %rax
movl 0x148(%rax), %eax
movq (%rbp), %rcx
movl %eax, 0x100(%rcx)
addq $0x10, %rbp
cmpq %r14, %rbp
jne 0x5ae3
jmp 0x588f
movq %r13, %rax
shlq $0x20, %rax
movl %ebp, %esi
orq %rax, %rsi
movq %r15, %rdi
callq 0x40e9
movslq %ebp, %rax
shlq $0x6, %rax
addq (%r15), %rax
movslq %r13d, %rcx
shlq $0x4, %rcx
leaq (%rcx,%rax), %rbx
addq $0x1b8, %rbx            # imm = 0x1B8
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8180
movq 0x50(%rsp), %r15
movl 0xac(%r15), %esi
subl 0x8(%r15), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x81c6
movq 0x98(%r14), %rax
movq -0x10(%rax), %rax
pxor %xmm0, %xmm0
movdqu %xmm0, 0xc8(%rax)
movq 0x98(%r14), %rdi
addq $-0x10, %rdi
movslq (%r15), %rax
leaq (%rax,%rax,8), %rsi
addq (%r14), %rsi
callq 0x3cbe
callq 0x2040
movq %rax, %r14
movl $0x2bf20, %eax          # imm = 0x2BF20
subl 0x4(%r15), %eax
cltq
imulq $-0x45e7b273, %rax, %rax # imm = 0xBA184D8D
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x2d, %rax
addl %ecx, %eax
cmpl $-0x3, %eax
movl $0xfffffffc, %r12d      # imm = 0xFFFFFFFC
cmovgel %eax, %r12d
addl $0x8, %r12d
pxor %xmm0, %xmm0
leaq 0x1d0(%rsp), %rdi
movdqa %xmm0, 0x10(%rdi)
movdqa %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
movq %r12, %rsi
callq 0x83f4
movq 0x48(%rsp), %rax
movq 0x98(%rax), %rax
movq -0x10(%rax), %rcx
movq %rcx, 0xc0(%rsp)
movq -0x8(%rax), %rax
movq %rax, 0xc8(%rsp)
testq %rax, %rax
je 0x5cd6
movq 0xf2f8(%rip), %rcx      # 0x14fc0
cmpb $0x0, (%rcx)
je 0x5cd2
incl 0x8(%rax)
jmp 0x5cd6
lock
incl 0x8(%rax)
leaq 0xc0(%rsp), %rdi
leaq 0x1d0(%rsp), %r9
movq 0x48(%rsp), %rsi
movl $0x3c, %edx
movl %r12d, %ecx
movq 0x50(%rsp), %r8
callq 0x8425
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0x5d0f
callq 0x730e
movq 0x48(%rsp), %rax
movq 0x98(%rax), %rax
movq -0x10(%rax), %rax
movl 0xc(%rax), %eax
movl %eax, 0x1f4(%rsp)
movq 0x1d0(%rsp), %rax
movq 0x1d8(%rsp), %rcx
cmpq %rcx, %rax
sete %sil
movq %rax, %rdx
addq $0x8, %rdx
cmpq %rcx, %rdx
sete %dil
orb %sil, %dil
jne 0x5d7e
movl (%rax), %esi
movl (%rdx), %edi
cmpl %edi, %esi
jl 0x5d72
movl 0x4(%rdx), %esi
setle %dil
cmpl %esi, 0x4(%rax)
setl %sil
andb %dil, %sil
cmpb $0x1, %sil
jne 0x5d75
movq %rdx, %rax
addq $0x8, %rdx
cmpq %rcx, %rdx
jne 0x5d53
movq 0x48(%rsp), %rcx
leaq 0x18(%rcx), %rdx
movq %rdx, 0x170(%rsp)
addq $0x78, %rcx
movq %rcx, 0x180(%rsp)
movq (%rax), %rax
movq %rax, 0x1e8(%rsp)
xorl %ebx, %ebx
xorps %xmm1, %xmm1
cvtsi2sd %ebx, %xmm1
movsd 0x9461(%rip), %xmm0     # 0xf218
callq 0x2220
movq 0x1d0(%rsp), %rax
xorps %xmm1, %xmm1
cvtsi2sdl (%rax,%rbx,8), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
cmpl %eax, 0x1f0(%rsp)
jge 0x5de4
movl %eax, 0x1f0(%rsp)
incq %rbx
cmpq %rbx, %r12
jne 0x5da8
xorl %r15d, %r15d
movq 0xf1fa(%rip), %rbp      # 0x14ff0
leaq 0x9556(%rip), %rbx      # 0xf353
movl $0x5, %edx
movq %rbp, %rdi
leaq 0x953e(%rip), %rsi      # 0xf34a
callq 0x2180
movq %rbp, %rdi
movl %r15d, %esi
callq 0x2210
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
leaq 0x958f(%rip), %rsi      # 0xf3bd
callq 0x2180
movq 0x1d0(%rsp), %rax
movl 0x4(%rax,%r15,8), %esi
movq %r13, %rdi
callq 0x2210
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
leaq 0x94f6(%rip), %rsi      # 0xf350
callq 0x2180
movq 0x1d0(%rsp), %rax
movl (%rax,%r15,8), %esi
movq %r13, %rdi
callq 0x2210
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2180
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
incq %r15
cmpq %r15, %r12
jne 0x5dfd
movq 0xf12f(%rip), %rdi      # 0x14ff0
leaq 0x948e(%rip), %rsi      # 0xf356
movl $0xe, %edx
callq 0x2180
callq 0x2040
subq %r14, %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x12, %rdx
addq %rdx, %rsi
movq 0xf0f4(%rip), %rdi      # 0x14ff0
callq 0x2070
movq %rax, %rbx
leaq 0x945a(%rip), %rsi      # 0xf365
movl $0x2, %edx
movq %rax, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
callq 0x2040
movq %rax, 0x188(%rsp)
movq $-0x21524111, 0x58(%rsp) # imm = 0xDEADBEEF
movq 0x48(%rsp), %rsi
movq 0x80(%rsi), %rax
movq -0x10(%rax), %rax
movq 0xd8(%rax), %rax
movl 0x4(%rax), %eax
movq 0x50(%rsp), %rdi
movl (%rdi), %ecx
cmpl $0xe, %ecx
movl $0xe, %edx
cmovll %ecx, %edx
movl $0x16, %ecx
subl %edx, %ecx
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
movl $0x12, %r8d
subl %edx, %r8d
cmpl %r8d, %ecx
cmovgl %ecx, %r8d
movslq 0x4(%rdi), %rcx
imulq $-0x77777777, %rcx, %rdx # imm = 0x88888889
shrq $0x20, %rdx
addl %ecx, %edx
movl %edx, %ecx
shrl $0x1f, %ecx
sarl $0x4, %edx
addl %ecx, %edx
movl 0x1ec(%rsp), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
imull $0xaa, %ecx, %eax
cmpl $0x8, %ecx
movl $0x4b0, %ecx            # imm = 0x4B0
cmovgel %eax, %ecx
cmpl %edx, %ecx
cmovgel %edx, %ecx
movl %ecx, 0xac(%rsp)
movq %r8, 0xa0(%rsp)
leal 0x1(%r8), %eax
movslq %eax, %r14
leaq 0xa8(%rsi), %r12
leaq 0xb8(%rsi), %rax
movq %rax, 0x60(%rsp)
leaq -0x1dc0(%rip), %rbx     # 0x424e
movq 0x48(%rsp), %rsi
movq 0xf0(%rsi), %rax
movq %rax, %rcx
subq 0xd0(%rsi), %rcx
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
leaq (%rcx,%rcx,8), %rax
movq 0xc8(%rsi), %rcx
movq 0xd8(%rsi), %rdx
subq 0xe0(%rsi), %rdx
sarq $0x3, %rdx
movabsq $0x6db6db6db6db6db7, %rdi # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdi, %rdx
addq %rax, %rdx
subq 0xb8(%rsi), %rcx
sarq $0x3, %rcx
imulq %rdi, %rcx
addq %rdx, %rcx
cmpq %r14, %rcx
ja 0x6082
movq %r12, %rdi
movq %rbx, %rsi
callq 0x7b9e
jmp 0x600e
movq 0x48(%rsp), %rax
leaq 0x108(%rax), %rbx
leaq 0xf8(%rax), %r15
leaq -0x1e4e(%rip), %rbp     # 0x424e
movq 0x48(%rsp), %rdi
movq 0x140(%rdi), %rax
movq %rax, %rcx
subq 0x120(%rdi), %rcx
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
movq 0x128(%rdi), %rdx
subq 0x130(%rdi), %rdx
leaq (%rcx,%rcx,8), %rax
sarq $0x3, %rdx
movabsq $0x6db6db6db6db6db7, %r8 # imm = 0x6DB6DB6DB6DB6DB7
imulq %r8, %rdx
addq %rax, %rdx
movq 0x118(%rdi), %rax
subq 0x108(%rdi), %rax
sarq $0x3, %rax
imulq %r8, %rax
addq %rdx, %rax
movq 0xf0(%rdi), %rcx
movq %rcx, %rdx
subq 0xd0(%rdi), %rdx
sarq $0x3, %rdx
cmpq $0x1, %rcx
adcq $-0x1, %rdx
leaq (%rdx,%rdx,8), %rcx
movq 0xc8(%rdi), %rdx
movq 0xd8(%rdi), %rsi
subq 0xe0(%rdi), %rsi
sarq $0x3, %rsi
imulq %r8, %rsi
addq %rcx, %rsi
subq 0xb8(%rdi), %rdx
sarq $0x3, %rdx
imulq %r8, %rdx
addq %rsi, %rdx
cmpq %rdx, %rax
jae 0x6166
movq %r15, %rdi
movq %rbp, %rsi
callq 0x7b9e
jmp 0x609c
leaq 0x6f(%rsp), %rax
movb $0x0, (%rax)
movabsq $-0x10000000000000, %rcx # imm = 0xFFF0000000000000
leaq 0x280(%rsp), %rdx
movq %rcx, (%rdx)
pxor %xmm0, %xmm0
leaq 0x80(%rsp), %rcx
movdqa %xmm0, (%rcx)
movq 0x50(%rsp), %rsi
movq %rsi, 0xc0(%rsp)
leaq 0x1d0(%rsp), %rsi
movq %rsi, 0xc8(%rsp)
movq %rax, 0xd0(%rsp)
movq %rdx, 0xd8(%rsp)
movq %rcx, 0xe0(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xee14(%rip), %r15      # 0x14ff0
leaq 0x9185(%rip), %rsi      # 0xf368
movl $0xa, %edx
movq %r15, %rdi
callq 0x2180
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq 0xede2(%rip), %rdi      # 0x14ff0
callq 0x2030
movq %rax, %rdi
callq 0x2100
xorl %r15d, %r15d
leaq 0x1a8(%rsp), %rbp
movq 0x48(%rsp), %rsi
movq 0x140(%rsi), %rax
movq %rax, %rcx
subq 0x120(%rsi), %rcx
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
leaq (%rcx,%rcx,8), %rax
movq 0x118(%rsi), %rcx
movq 0x128(%rsi), %rdx
subq 0x130(%rsi), %rdx
sarq $0x3, %rdx
movabsq $0x6db6db6db6db6db7, %rdi # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdi, %rdx
addq %rax, %rdx
subq 0x108(%rsi), %rcx
sarq $0x3, %rcx
imulq %rdi, %rcx
addq %rdx, %rcx
cmpq %r15, %rcx
jbe 0x6452
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa59e
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x644a
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa59e
movq (%rax), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x78(%rsp)
testq %rdx, %rdx
je 0x6372
movl 0x8(%rdx), %eax
testl %eax, %eax
je 0x6369
leal 0x1(%rax), %esi
lock
cmpxchgl %esi, 0x8(%rdx)
jne 0x62cc
movq 0x78(%rsp), %rax
testq %rax, %rax
je 0x6372
movl 0x8(%rax), %eax
testl %eax, %eax
je 0x6372
movq 0x8(%rcx), %rax
movq %rax, 0x70(%rsp)
testq %rax, %rax
je 0x637b
leaq 0x270(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x8838
movq 0x278(%rsp), %rdi
testq %rdi, %rdi
je 0x632d
callq 0x730e
movq 0x48(%rsp), %rax
movq 0x80(%rax), %r13
movq 0x70(%rsp), %rcx
movq 0x78(%rsp), %rax
movq %rcx, 0xb0(%rsp)
movq %rax, 0xb8(%rsp)
testq %rax, %rax
je 0x63b2
movq 0xec61(%rip), %rcx      # 0x14fc0
cmpb $0x0, (%rcx)
je 0x63ae
incl 0x8(%rax)
jmp 0x63b2
movq $0x0, 0x78(%rsp)
movq $0x0, 0x70(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa59e
movb $0x1, %r14b
movq %rax, %rdi
callq 0x872e
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x63a0
callq 0x730e
testb %r14b, %r14b
jne 0x6291
jmp 0x644a
lock
incl 0x8(%rax)
movq 0x50(%rsp), %rax
movl (%rax), %edx
movq %rbp, %rdi
leaq 0xb0(%rsp), %rsi
callq 0x3fbe
addq $-0x10, %r13
movq 0x48(%rsp), %rdx
movl 0x148(%rdx), %r8d
movdqu 0xc0(%rsp), %xmm0
movdqu 0xd0(%rsp), %xmm1
movdqu 0xe0(%rsp), %xmm2
movdqu %xmm2, 0x20(%rsp)
movdqu %xmm1, 0x10(%rsp)
movdqu %xmm0, (%rsp)
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rcx
callq 0x8b65
movq 0x1a8(%rsp), %rdi
testq %rdi, %rdi
je 0x6430
movq 0x1b8(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0xb8(%rsp), %rdi
testq %rdi, %rdi
je 0x6442
callq 0x730e
xorl %r14d, %r14d
jmp 0x6391
incq %r15
jmp 0x6226
movq 0xeb97(%rip), %r15      # 0x14ff0
leaq 0x8f13(%rip), %rsi      # 0xf373
movl $0xf, %edx
movq %r15, %rdi
callq 0x2180
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq 0xeb65(%rip), %rdi      # 0x14ff0
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x50(%rsp), %rax
movl (%rax), %edx
movq 0x48(%rsp), %rsi
movl 0x148(%rsi), %r9d
movq 0x80(%rsi), %rax
addq $-0x10, %rax
movslq 0xac(%rsp), %rcx
movdqu 0xc0(%rsp), %xmm0
movdqu 0xd0(%rsp), %xmm1
movdqu 0xe0(%rsp), %xmm2
movdqu %xmm2, 0x30(%rsp)
movdqu %xmm1, 0x20(%rsp)
movdqu %xmm0, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rax, (%rsp)
movq %r12, %rdi
movl $0x8, %ecx
movq 0xa0(%rsp), %r8
callq 0x8ec5
movq 0x80(%rsp), %rax
testq %rax, %rax
je 0x65ba
movq %rax, 0x1c0(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x1c8(%rsp)
testq %rax, %rax
je 0x656e
movq 0xea82(%rip), %rcx      # 0x14fc0
cmpb $0x0, (%rcx)
je 0x656a
incl 0x8(%rax)
jmp 0x656e
movq 0x48(%rsp), %r14
leaq 0xa8(%r14), %rdi
callq 0x8152
leaq 0xf8(%r14), %rdi
callq 0x8152
jmp 0x588f
lock
incl 0x8(%rax)
movq 0x50(%rsp), %rax
movl (%rax), %edx
incl %edx
leaq 0x70(%rsp), %rdi
leaq 0x1c0(%rsp), %r15
movq %r15, %rsi
callq 0x3f30
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x659a
callq 0x730e
movq 0x70(%rsp), %rax
movq 0x78(%rsp), %rdi
movq 0xb4(%rax), %rax
movq %rax, 0x58(%rsp)
testq %rdi, %rdi
je 0x65ba
callq 0x730e
movq 0xa0(%rsp), %rax
testl %eax, %eax
jle 0x66aa
movl %eax, %r14d
xorl %r15d, %r15d
movq 0xea19(%rip), %r12      # 0x14ff0
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
movl $0x9, %edx
movq %r12, %rdi
leaq 0x8d93(%rip), %rsi      # 0xf383
callq 0x2180
movq %r12, %rdi
movl %r15d, %esi
callq 0x2210
movq %rax, %r13
movl $0x7, %edx
movq %rax, %rdi
leaq 0x8d7b(%rip), %rsi      # 0xf38d
callq 0x2180
movq 0x60(%rsp), %rdi
movq %r15, %rsi
callq 0xa59e
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x3, %rsi
imulq %rbp, %rsi
movq %r13, %rdi
callq 0x20f0
movq %rax, %r13
movl $0x8, %edx
movq %rax, %rdi
leaq 0x8d48(%rip), %rsi      # 0xf395
callq 0x2180
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa59e
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x3, %rsi
imulq %rbp, %rsi
movq %r13, %rdi
callq 0x20f0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
incq %r15
cmpq %r15, %r14
jne 0x65e1
movq 0xe93f(%rip), %r15      # 0x14ff0
leaq 0x8ce6(%rip), %rsi      # 0xf39e
movl $0x4, %edx
movq %r15, %rdi
callq 0x2180
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq 0xe90d(%rip), %rdi      # 0x14ff0
callq 0x2030
movq %rax, %rdi
callq 0x2100
xorl %r14d, %r14d
movq 0x48(%rsp), %rsi
movq 0x140(%rsi), %rax
movq %rax, %rcx
subq 0x120(%rsi), %rcx
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
leaq (%rcx,%rcx,8), %rax
movq 0x118(%rsi), %rcx
movq 0x128(%rsi), %rdx
subq 0x130(%rsi), %rdx
sarq $0x3, %rdx
movabsq $0x6db6db6db6db6db7, %rdi # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdi, %rdx
addq %rax, %rdx
subq 0x108(%rsi), %rcx
sarq $0x3, %rcx
imulq %rdi, %rcx
addq %rdx, %rcx
cmpq %r14, %rcx
jbe 0x68f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa59e
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x68e8
movq %rbx, %rdi
movq %r14, 0xa0(%rsp)
movq %r14, %rsi
callq 0xa59e
movq (%rax), %rcx
movq 0x10(%rcx), %r15
movl 0x8(%r15), %eax
leal 0x1(%rax), %edx
lock
cmpxchgl %edx, 0x8(%r15)
jne 0x6794
movl 0x8(%r15), %eax
movq 0x8(%rcx), %r12
movl (%r12), %ebp
movl 0x8(%r12), %eax
addl $0x14, %eax
movl 0x1f4(%rsp), %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
movl $0x3c, %esi
subl %edx, %esi
cmpl $0x50, %ecx
movl $0x14, %ecx
cmovgel %ecx, %esi
movq 0x50(%rsp), %rcx
movl (%rcx), %r13d
cmpl %esi, %eax
cmovgl %eax, %esi
movl 0xbc(%r12), %eax
movl %eax, 0x60(%rsp)
leal (%rsi,%rsi,4), %r14d
addl 0x1f0(%rsp), %r14d
movl $0x7, %edx
movq 0xe7ea(%rip), %rdi      # 0x14ff0
leaq 0x8b96(%rip), %rsi      # 0xf3a3
callq 0x2180
subl %r13d, %ebp
movq 0xe7d4(%rip), %rdi      # 0x14ff0
movl %ebp, %esi
callq 0x2210
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
leaq 0x8b55(%rip), %rsi      # 0xf38a
callq 0x2180
movl 0xc0(%r12), %esi
movq %r13, %rdi
callq 0x2210
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
leaq 0x8af4(%rip), %rsi      # 0xf350
callq 0x2180
movl 0xbc(%r12), %esi
movq %r13, %rdi
callq 0x2210
movq %rax, %rbp
movl $0x2, %edx
movq %rax, %rdi
leaq 0x8ad0(%rip), %rsi      # 0xf353
callq 0x2180
xorl %eax, %eax
cmpl 0x60(%rsp), %r14d
setl %al
leaq 0x8b26(%rip), %rsi      # 0xf3bf
leaq 0x8b0b(%rip), %rcx      # 0xf3ab
cmovlq %rcx, %rsi
leaq (%rax,%rax,4), %rdx
movq %rbp, %rdi
callq 0x2180
movq (%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbp, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %r15, %rdi
callq 0x730e
movq 0xa0(%rsp), %r14
incq %r14
jmp 0x66f3
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x6902
callq 0x730e
movq 0xe6e7(%rip), %rdi      # 0x14ff0
leaq 0x8aa1(%rip), %rsi      # 0xf3b1
movl $0xe, %edx
callq 0x2180
callq 0x2040
subq 0x188(%rsp), %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x12, %rdx
addq %rdx, %rsi
movq 0xe6a7(%rip), %r12      # 0x14ff0
movq %r12, %rdi
callq 0x2070
movq %rax, %r15
leaq 0x8a0a(%rip), %rsi      # 0xf365
movl $0x2, %edx
movq %rax, %rdi
callq 0x2180
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
callq 0x2040
movq %rax, 0x60(%rsp)
movq 0x50(%rsp), %rax
movl 0x4(%rax), %ecx
movl $0x3, %eax
cmpl $0x15f90, %ecx          # imm = 0x15F90
jg 0x69c6
movl $0x2, %eax
cmpl $0xea60, %ecx           # imm = 0xEA60
jg 0x69c6
xorl %eax, %eax
cmpl $0x7531, %ecx           # imm = 0x7531
setge %al
cmpl $0x4e21, %ecx           # imm = 0x4E21
setl %cl
movq 0x50(%rsp), %rdx
cmpl $0x6, 0xac(%rdx)
setge %dl
orb %cl, %dl
testl %eax, %eax
sete %cl
orb %dl, %cl
jne 0x6d1e
movl %eax, %r13d
xorl %ebp, %ebp
movq 0x48(%rsp), %rsi
movq 0x140(%rsi), %rax
movq %rax, %rcx
subq 0x120(%rsi), %rcx
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
leaq (%rcx,%rcx,8), %rax
movq 0x118(%rsi), %rcx
movq 0x128(%rsi), %rdx
subq 0x130(%rsi), %rdx
sarq $0x3, %rdx
movabsq $0x6db6db6db6db6db7, %rdi # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdi, %rdx
addq %rax, %rdx
subq 0x108(%rsi), %rcx
sarq $0x3, %rcx
imulq %rdi, %rcx
addq %rdx, %rcx
cmpq %rbp, %rcx
jbe 0x6cf5
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xa59e
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x6cf5
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xa59e
movq (%rax), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0xc8(%rsp)
movl 0x8(%rdx), %eax
leal 0x1(%rax), %esi
lock
cmpxchgl %esi, 0x8(%rdx)
jne 0x6a92
movq 0xc8(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x8(%rcx), %rax
movq %rax, 0xc0(%rsp)
movq 0x58(%rsp), %xmm0
movq 0xb4(%rax), %xmm1
pcmpeqd %xmm0, %xmm1
pshufd $0x50, %xmm1, %xmm0     # xmm0 = xmm1[0,0,1,1]
movmskpd %xmm0, %ecx
movl $0x21, %r14d
cmpl $0x3, %ecx
je 0x6cd8
movl 0x8(%rax), %eax
movq 0x1d0(%rsp), %rcx
movslq (%rcx), %rcx
imulq $0x66666667, %rcx, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
cmpl $0x15, %ecx
movl $0x14, %edx
cmovll %edx, %ecx
movl $0x23, %r14d
cmpl $0x15, %eax
jl 0x6cd8
addl %ecx, %eax
addl $0xa, %eax
testl %eax, %eax
jg 0x6cd8
movl $0x13, %edx
movq %r12, %rdi
leaq 0x888b(%rip), %rsi      # 0xf3c0
callq 0x2180
leal 0x1(%rbp), %esi
movq %r12, %rdi
callq 0x2210
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
leaq 0x8833(%rip), %rsi      # 0xf38a
callq 0x2180
movq 0xc0(%rsp), %rax
movl 0xc0(%rax), %esi
movq %r15, %rdi
callq 0x2210
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
leaq 0x87cc(%rip), %rsi      # 0xf350
callq 0x2180
movq 0xc0(%rsp), %rax
movl 0xbc(%rax), %esi
movq %r15, %rdi
callq 0x2210
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
leaq 0x87a2(%rip), %rsi      # 0xf353
callq 0x2180
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x48(%rsp), %rsi
movq 0x98(%rsi), %rdi
addq $-0x10, %rdi
movl $0x78, %edx
movl $0xa, %ecx
movq 0x50(%rsp), %r8
leaq 0xc0(%rsp), %r9
callq 0x932e
movq 0xc0(%rsp), %rcx
movq 0xc8(%rsp), %rax
movq %rcx, 0x198(%rsp)
movq %rax, 0x1a0(%rsp)
testq %rax, %rax
je 0x6c43
movq 0xe38b(%rip), %rcx      # 0x14fc0
cmpb $0x0, (%rcx)
je 0x6c3f
incl 0x8(%rax)
jmp 0x6c43
lock
incl 0x8(%rax)
movq 0x50(%rsp), %rax
movl (%rax), %edx
incl %edx
leaq 0x80(%rsp), %rdi
leaq 0x198(%rsp), %rsi
callq 0x3f30
movq 0x80(%rsp), %rax
movq 0x88(%rsp), %rdi
movq 0xb4(%rax), %rax
movq %rax, 0x58(%rsp)
testq %rdi, %rdi
je 0x6c87
callq 0x730e
movq 0x1a0(%rsp), %rdi
testq %rdi, %rdi
je 0x6c99
callq 0x730e
movl $0x4, %edx
movq %r12, %rdi
leaq 0x872c(%rip), %rsi      # 0xf3d4
callq 0x2180
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
xorl %r14d, %r14d
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0x6cea
callq 0x730e
testl %r14d, %r14d
je 0x6cf5
cmpl $0x23, %r14d
jne 0x6d1e
incq %rbp
cmpq %r13, %rbp
jne 0x69f2
jmp 0x6d1e
movq %rax, %r14
cmpl $0x1, %edx
jne 0x719d
movq %r14, %rdi
callq 0x2090
callq 0x21f0
jmp 0x6cd5
movq 0xe2cb(%rip), %rdi      # 0x14ff0
leaq 0x86ad(%rip), %rsi      # 0xf3d9
movl $0x15, %edx
callq 0x2180
callq 0x2040
subq 0x60(%rsp), %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x12, %rdx
addq %rdx, %rsi
movq 0xe28e(%rip), %rdi      # 0x14ff0
callq 0x2070
movq %rax, %rbx
leaq 0x85f4(%rip), %rsi      # 0xf365
movl $0x2, %edx
movq %rax, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x50(%rsp), %rdx
movslq (%rdx), %rax
movq 0x48(%rsp), %rcx
movq (%rcx), %rcx
leaq (%rax,%rax,8), %rax
movq (%rcx,%rax), %rdi
movl 0x8(%rdx), %edx
movzbl 0x8(%rcx,%rax), %esi
callq 0x289d
movq %rax, 0x80(%rsp)
movb %dl, 0x88(%rsp)
cmpl $0xdeadbeef, 0x58(%rsp) # imm = 0xDEADBEEF
jne 0x6f2e
cmpl $-0x1, 0x5c(%rsp)
jne 0x6f2e
movq 0xe1f7(%rip), %rbx      # 0x14ff0
leaq 0x85ef(%rip), %rsi      # 0xf3ef
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq 0xe1c5(%rip), %rdi      # 0x14ff0
callq 0x2030
movq %rax, %rdi
callq 0x2100
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
leaq 0x80(%rsp), %r15
leaq 0x70(%rsp), %r12
movabsq $0x100000000, %r14      # imm = 0x100000000
movl %ebx, %ebx
movl $0x4, %r13d
movq %rbx, 0x60(%rsp)
movq %rbx, 0x70(%rsp)
leaq 0xc0(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x2b7b
movl 0x164(%rsp), %eax
cmpl %eax, %ebp
jg 0x6e98
movq %rbx, 0x58(%rsp)
movl %eax, %ebp
addq %r14, %rbx
decq %r13
jne 0x6e66
jmp 0x6ecb
movq %rax, %rdi
cmpl $0x3, %edx
jne 0x6eb6
callq 0x2090
callq 0x21f0
jmp 0x6e98
cmpl $0x2, %edx
jne 0x7192
callq 0x2090
callq 0x21f0
jmp 0x6e98
movq 0x60(%rsp), %rbx
incl %ebx
cmpl $0xa, %ebx
jne 0x6e59
cmpl $0xdeadbeef, 0x58(%rsp) # imm = 0xDEADBEEF
jne 0x6f2e
cmpl $-0x1, 0x5c(%rsp)
jne 0x6f2e
movq 0xe101(%rip), %rbx      # 0x14ff0
leaq 0x850a(%rip), %rsi      # 0xf400
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq 0xe0cf(%rip), %rdi      # 0x14ff0
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x80(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x2981
testb %al, %al
je 0x707e
movq 0x48(%rsp), %rbx
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x6f73
movl $0x150, %edx            # imm = 0x150
movq %rsi, %rdi
movq 0x50(%rsp), %rsi
callq 0x2120
addq $0x150, 0x20(%rbx)      # imm = 0x150
jmp 0x6f85
movq 0x170(%rsp), %rdi
movq 0x50(%rsp), %rdx
callq 0xbb40
movq 0x48(%rsp), %rcx
movq 0x38(%rcx), %rsi
cmpq 0x40(%rcx), %rsi
je 0x6fa3
movq 0x58(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x38(%rcx)
jmp 0x6fb1
leaq 0x30(%rcx), %rdi
leaq 0x58(%rsp), %rdx
callq 0xe5c2
leaq 0xc0(%rsp), %rdi
leaq 0x80(%rsp), %rdx
leaq 0x58(%rsp), %rcx
movq 0x98(%rsp), %rsi
callq 0x2b7b
movq 0x48(%rsp), %rbx
leaq 0x60(%rbx), %rdi
leaq 0x164(%rsp), %rsi
callq 0xbcac
movq 0x50(%rbx), %rsi
cmpq %rsi, 0x48(%rbx)
je 0x6ff8
movl -0x4(%rsi), %eax
jmp 0x6ffa
xorl %eax, %eax
movq 0x48(%rsp), %rbx
movq 0x68(%rbx), %rcx
addl -0x8(%rcx), %eax
movl %eax, 0xc0(%rsp)
cmpq 0x58(%rbx), %rsi
je 0x701f
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x50(%rbx)
jmp 0x7034
leaq 0xc0(%rsp), %rdx
movq 0x178(%rsp), %rdi
callq 0xbdc0
movq 0x80(%rbx), %rdi
addq $-0x10, %rdi
movq 0x58(%rsp), %rsi
callq 0x40e9
movq 0x80(%rbx), %rax
movslq 0x58(%rsp), %rcx
shlq $0x6, %rcx
addq -0x10(%rax), %rcx
movslq 0x5c(%rsp), %rax
shlq $0x4, %rax
leaq (%rax,%rcx), %rsi
addq $0x1b8, %rsi            # imm = 0x1B8
movq 0x180(%rsp), %rdi
callq 0x8180
movq 0xdf6b(%rip), %rdi      # 0x14ff0
leaq 0x8385(%rip), %rsi      # 0xf411
movl $0xf, %edx
callq 0x2180
callq 0x2040
subq 0x190(%rsp), %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x12, %rdx
addq %rdx, %rsi
movq 0xdf2b(%rip), %rdi      # 0x14ff0
callq 0x2070
movq %rax, %rbx
leaq 0x8291(%rip), %rsi      # 0xf365
movl $0x2, %edx
movq %rax, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x1d0(%rsp), %rdi
testq %rdi, %rdi
je 0x7125
movq 0x1e0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x58(%rsp), %rax
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x719a
jmp 0x718f
jmp 0x718f
jmp 0x718f
jmp 0x714d
jmp 0x71f8
jmp 0x714d
movq %rax, %rbx
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0x725d
callq 0x730e
jmp 0x725d
jmp 0x718f
jmp 0x718f
jmp 0x718f
movq %rax, %rbx
movq 0xc8(%rsp), %rdi
jmp 0x7236
jmp 0x7217
jmp 0x71f8
jmp 0x71f8
jmp 0x7217
movq %rax, %rdi
movq %rdi, %rbx
jmp 0x7240
movq %rax, %r14
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0x71af
callq 0x730e
movq %r14, %rbx
jmp 0x7240
jmp 0x7217
jmp 0x720a
jmp 0x7217
jmp 0x7217
movq %rax, %rbx
movq 0x1a8(%rsp), %rdi
testq %rdi, %rdi
je 0x71e4
movq 0x1b8(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
jmp 0x71e4
movq %rax, %rbx
movq 0xb8(%rsp), %rdi
testq %rdi, %rdi
je 0x721f
callq 0x730e
jmp 0x721f
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x7412
jmp 0x725d
movq %rax, %rbx
jmp 0x722e
movq %rax, %rbx
movq %r15, %rdi
jmp 0x7229
movq %rax, %rbx
jmp 0x7240
movq %rax, %rbx
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x722e
callq 0x730e
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x7240
callq 0x730e
movq 0x1d0(%rsp), %rdi
testq %rdi, %rdi
je 0x725d
movq 0x1e0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2230
nop