str = strtok_r(NULL, "|", &saveptr);

     if(!str) return score;

     str = strtok_r(NULL, "|", &saveptr);

     if(!str) return score;

     // Set username for given user id, since we now know both

     auto user = get_user_info(score.player_id);

     // Mark as a player. Setting this also makes the has_user_info check pass,

     // which unlocks context menu actions such as sending private messages.

         if(result->url == url) {

             *progress = result->progress;

             *response_code = result->response_code;

                 out = result->data;

                 delete matching_thread->downloads[i];

                 matching_thread->downloads.erase(matching_thread->downloads.begin() + i);

         m_backgroundImageHandler->scheduleFreezeCache();

         // scrubbing/seeking

             if(!bancho.is_playing_a_multi_map()) {

                 m_bSeeking = true;

                 const float mousePosX = (int)engine->getMouse()->getPos().x;

                         // special case: keep player invulnerable even if scrubbing position does not change

                         getSelectedBeatmap()->resetScore();

                     }

                     m_fPrevSeekMousePosX = -1.0f;

                     m_fQuickSaveTime = clamp<float>((float)((getSelectedBeatmap()->getStartTimePlayable() +

                                                              getSelectedBeatmap()->getLengthPlayable()) *

                                                             percent) /

                                                         (float)getSelectedBeatmap()->getLength(),

                                                     0.0f, 1.0f);

             }

         }

 void Osu::onFocusLost() {

     if(isInPlayMode() && !getSelectedBeatmap()->isPaused() && osu_pause_on_focus_loss.getBool()) {

             getSelectedBeatmap()->pause(false);

             m_pauseMenu->setVisible(true);

             m_modSelector->setVisible(false);

     if((osu_confine_cursor_fullscreen.getBool() && env->isFullscreen()) ||

        (osu_confine_cursor_windowed.getBool() && !env->isFullscreen()) ||

         env->setCursorClip(true, McRect());

     else

         env->setCursorClip(false, McRect());

     m_bClick1Held = true;

     if((!m_osu->getModAuto() && !m_osu->getModRelax()) || !osu_auto_and_relax_block_user_input.getBool())

     if(mouse) {

         current_keys = current_keys | OsuReplay::M1;

     m_bClick2Held = true;

     if((!m_osu->getModAuto() && !m_osu->getModRelax()) || !osu_auto_and_relax_block_user_input.getBool())

     if(mouse) {

         current_keys = current_keys | OsuReplay::M2;

     m_hitobjectsSortedByEndTime = std::vector<OsuHitObject *>();

     m_misaimObjects = std::vector<OsuHitObject *>();

     m_breaks = std::vector<OsuDatabaseBeatmap::BREAK>();

 }

 void OsuBeatmap::resetHitObjects(long curPos) {

             next_frame = spectated_replay[current_frame_idx + 1];

             current_keys = current_frame.key_flags;

             // Flag fix to simplify logic (stable sets both K1 and M1 when K1 is pressed)

             if(current_keys & OsuReplay::K1) current_keys &= ~OsuReplay::M1;

             if(current_keys & OsuReplay::K2) current_keys &= ~OsuReplay::M2;

             // Pressed key 1

             if(!(last_keys & OsuReplay::K1) && current_keys & OsuReplay::K1) {

                 m_osu->getHUD()->animateInputoverlay(1, true);

                 if(!m_bInBreak && !m_bIsInSkippableSection) m_osu->getScore()->addKeyCount(1);

             }

             if(!(last_keys & OsuReplay::M1) && current_keys & OsuReplay::M1) {

                 m_osu->getHUD()->animateInputoverlay(3, true);

                 if(!m_bInBreak && !m_bIsInSkippableSection) m_osu->getScore()->addKeyCount(3);

             }

             // Pressed key 2

             if(!(last_keys & OsuReplay::K2) && current_keys & OsuReplay::K2) {

                 m_osu->getHUD()->animateInputoverlay(2, true);

                 if(!m_bInBreak && !m_bIsInSkippableSection) m_osu->getScore()->addKeyCount(2);

             }

             if(!(last_keys & OsuReplay::M2) && current_keys & OsuReplay::M2) {

                 m_osu->getHUD()->animateInputoverlay(4, true);

                 if(!m_bInBreak && !m_bIsInSkippableSection) m_osu->getScore()->addKeyCount(4);

             }

         }

                         continue;

                     m_misaimObjects[i]->misAimed();

                     m_osu->getHUD()->addHitError(delta, false, true);

                     break;  // the current click has been dealt with (and the hitobject has been misaimed)

     if(bancho.is_online()) {

         score.player_id = bancho.user_id;

     } else {

     }

     score.passed = isComplete && !isZero && !m_osu->getScore()->hasDied();

     score.grade = score.passed ? m_osu->getScore()->getGrade() : Score::Grade::F;

 class OsuBackgroundStarCacheLoader;

 class OsuBackgroundStarCalcHandler;

 class OsuBeatmap {

    public:

     friend class OsuBackgroundStarCacheLoader;

     bool m_bClickedContinue;

     bool m_bPrevKeyWasKey1;

     int m_iAllowAnyNextKeyForFullAlternateUntilHitObjectIndex;

     // hitobjects

     std::vector<OsuHitObject *> m_hitobjects;

     onHit(OsuScore::HIT::HIT_MISS, delta);

 }

     if(m_bFinished) return;

     const Vector2 pos = m_beatmap->osuCoords2Pixels(m_vRawPos);

     const float cursorDelta = (cursorPos - pos).length();

             return;  // ignore click event completely

         }

         OsuScore::HIT result = OsuGameRules::getHitResult(delta, m_beatmap);

         if(result != OsuScore::HIT::HIT_NULL) {

     Vector2 getOriginalRawPosAt(long pos) { return m_vOriginalRawPos; }

     Vector2 getAutoCursorPos(long curPos);

     virtual void onReset(long curPos);

    private:

         keys.push_back(kv.first);

     }

     for(auto &key : keys) {

         for(Score &score : m_scores[key]) {

         }

     }

     // always add local user, even if there were no scores

     std::vector<UString> names;

     names.reserve(tempNames.size());

     for(auto k : tempNames) {

     }

     return names;

 std::vector<UString> OsuDatabase::getPlayerNamesWithScoresForUserSwitcher() {

     const bool includeLegacyNames = osu_user_switcher_include_legacy_scores_for_names.getBool();

     for(auto kv : m_scores) {

         const MD5Hash &key = kv.first;

         for(Score &score : m_scores[key]) {

         }

     }

     // always add local user, even if there were no scores

     std::vector<UString> names;

     names.reserve(tempNames.size());

     for(auto k : tempNames) {

     }

     return names;

             bool foundValidScore = false;

             float prevPP = -1.0f;

             for(Score &score : m_scores[key]) {

                 if(!score.isLegacyScore &&

                    (osu_user_include_relax_and_autopilot_for_stats.getBool()

                         ? true

                         : !((score.modsLegacy & ModFlags::Relax) || (score.modsLegacy & ModFlags::Autopilot))) &&

                     foundValidScore = true;

                     totalScore += score.score;

                         sc.unixTimestamp = read_int64(&db);

                         // default

                         sc.num300s = read_short(&db);

                         sc.num100s = read_short(&db);

                     sc.version = read_int32(&db);

                     skip_string(&db);  // beatmap hash (already have it)

                     skip_string(&db);  // replay hash (don't use it)

                     sc.num300s = read_short(&db);

             write_int64(&db, score.unixTimestamp);

             // default

             write_short(&db, score.num300s);

             write_short(&db, score.num100s);

         for(size_t i = 0; i < kv.second.size(); i++) {

             Score &score = kv.second[i];

                 numRenamedScores++;

             }

         }

     }

                 out << score.unixTimestamp;

                 out << ",";

                 out << ",";

                 out << score.num300s;

             SCORE_ENTRY scoreEntry;

             scoreEntry.entry_id = -(nb_slots + 1);

             scoreEntry.player_id = score.player_id;

             scoreEntry.combo = score.comboMax;

             scoreEntry.score = score.score;

             scoreEntry.accuracy =

 void OsuHUD::drawScrubbingTimeline(Graphics *g, unsigned long beatmapTime, unsigned long beatmapLength,

                                    unsigned long beatmapLengthPlayable, unsigned long beatmapStartTimePlayable,

                                    float beatmapPercentFinishedPlayable, const std::vector<BREAK> &breaks) {

     const float dpiScale = Osu::getUIScale(m_osu);

     const Color grey = 0xffbbbbbb;

     const Color greyTransparent = 0xbbbbbbbb;

                 const float offsetX =

                     ((float)startTimeMS / (float)strainStepMS) * strainWidth;  // compensate for startTimeMS

                 const Color aimStrainColor =

                     COLORf(alpha, osu_hud_scrubbing_timeline_strains_aim_color_r.getInt() / 255.0f,

                            osu_hud_scrubbing_timeline_strains_aim_color_g.getInt() / 255.0f,

     // breaks

     g->setColor(greyTransparent);

     for(int i = 0; i < breaks.size(); i++) {

         const int width = std::max(

             (int)(m_osu->getScreenWidth() * clamp<float>(breaks[i].endPercent - breaks[i].startPercent, 0.0f, 1.0f)),

     // line

     g->setColor(0xff000000);

     g->drawLine(0, cursorPos.y + 1, m_osu->getScreenWidth(), cursorPos.y + 1);

     g->setColor(grey);

     g->drawLine(0, cursorPos.y, m_osu->getScreenWidth(), cursorPos.y);

     // current time triangle

     {

         g->translate(triangleTip.x + 1, triangleTip.y - m_osu->getSkin()->getSeekTriangle()->getHeight() / 2.0f + 1);

         g->setColor(0xff000000);

         g->drawImage(m_osu->getSkin()->getSeekTriangle());

         g->translate(-1, -1);

         g->setColor(green);

         g->drawImage(m_osu->getSkin()->getSeekTriangle());

     }

     g->popTransform();

                 1,

             triangleTip.y - m_osu->getSkin()->getSeekTriangle()->getHeight() - currentTimeTopTextOffset + 1);

         g->setColor(0xff000000);

         g->drawString(timeFont, currentTimeText);

         g->translate(-1, -1);

         g->setColor(green);

         g->drawString(timeFont, currentTimeText);

     }

     g->popTransform();

         g->translate((int)(startAndEndTimeTextOffset + 1),

                      (int)(triangleTip.y + startAndEndTimeTextOffset + timeFont->getHeight() + 1));

         g->setColor(0xff000000);

         g->drawString(timeFont, startTimeText);

         g->translate(-1, -1);

         g->setColor(greyDark);

         g->drawString(timeFont, startTimeText);

     }

     g->popTransform();

             (int)(m_osu->getScreenWidth() - timeFont->getStringWidth(endTimeText) - startAndEndTimeTextOffset + 1),

             (int)(triangleTip.y + startAndEndTimeTextOffset + timeFont->getHeight() + 1));

         g->setColor(0xff000000);

         g->drawString(timeFont, endTimeText);

         g->translate(-1, -1);

         g->setColor(greyDark);

         g->drawString(timeFont, endTimeText);

     }

     g->popTransform();

             g->translate(triangleTip.x + 1,

                          triangleTip.y + m_osu->getSkin()->getSeekTriangle()->getHeight() / 2.0f + 1);

             g->setColor(0xff000000);

             g->drawImage(m_osu->getSkin()->getSeekTriangle());

             g->translate(-1, -1);

             g->setColor(grey);

             g->drawImage(m_osu->getSkin()->getSeekTriangle());

         }

         g->popTransform();

                       currentTimeTopTextOffset * std::max(1.0f, getCursorScaleFactor() * osu_cursor_scale.getFloat()) *

                           osu_hud_scrubbing_timeline_hover_tooltip_offset_multiplier.getFloat()));

             g->setColor(0xff000000);

             g->drawString(timeFont, endTimeText);

             g->translate(-1, -1);

             g->setColor(grey);

             g->drawString(timeFont, endTimeText);

         }

         g->popTransform();

                       osu_hud_scrubbing_timeline_hover_tooltip_offset_multiplier.getFloat() * 2.0f -

                   1));

         g->setColor(0xff000000);

         g->drawString(timeFont, hoverTimeText);

         g->translate(-1, -1);

         g->setColor(0xff666666);

         g->drawString(timeFont, hoverTimeText);

     }

     g->popTransform();

     inline bool isBlocked() const { return m_bBlocked; }

     inline bool hasMisAimed() const { return m_bMisAim; }

     virtual void onReset(long curPos);

    protected:

     m_bIsUnranked = false;

     m_songInfo->setDate(dateTime);

     m_rankingPanel->setScore(score);

     setGrade(OsuScore::calculateGrade(score.num300s, score.num100s, score.num50s, score.numMisses,

                 bancho.osu->m_notificationOverlay->addNotification(msg);

             }

             *score_cpy = score;

             APIRequest request;

     bancho.osu->replay_info.diff2_md5 = score.md5hash.hash;

     bancho.osu->replay_info.mod_flags = score.modsLegacy;

     bancho.osu->replay_info.player_id = score.player_id;

     auto beatmap = bancho.osu->getSongBrowser()->getDatabase()->getBeatmapDifficulty(score.md5hash.hash);

     }

 }

     if(m_points.size() == 0 || m_bBlocked)

         return;  // also handle note blocking here (doesn't need fancy shake logic, since sliders don't shake in

                  // osu!stable)

     if(!m_bStartFinished) {

         const Vector2 pos = m_beatmap->osuCoords2Pixels(m_curve->pointAt(0.0f));

         const float cursorDelta = (cursorPos - pos).length();

         if(cursorDelta < m_beatmap->getHitcircleDiameter() / 2.0f) {

             OsuScore::HIT result = OsuGameRules::getHitResult(delta, m_beatmap);

             if(result != OsuScore::HIT::HIT_NULL) {

     Vector2 getOriginalRawPosAt(long pos);

     inline Vector2 getAutoCursorPos(long curPos) { return m_vCurPoint; }

     virtual void onReset(long curPos);

     void rebuildVertexBuffer(bool useRawCoords = false);

             angleDiff = engine->getFrameTime() * 1000.0f * AUTO_MULTIPLIER * m_beatmap->getOsu()->getSpeedMultiplier();

         else  // user spin

         {

             const float currentMouseAngle = (float)std::atan2(mouseDelta.y, mouseDelta.x);

             angleDiff = (currentMouseAngle - m_fLastMouseAngle);

     }

 }

     if(m_bFinished) return;

     // needed for nightmare mod

     Vector2 getOriginalRawPosAt(long pos) { return m_vOriginalRawPos; }

     Vector2 getAutoCursorPos(long curPos);

     virtual void onReset(long curPos);

    private:

     // display

     m_scoreGrade =

         OsuScore::calculateGrade(score.num300s, score.num100s, score.num50s, score.numMisses, modHidden, modFlashlight);

     m_sScoreScore = UString::format(

         (score.perfect ? "Score: %llu (%ix PFC)" : (fullCombo ? "Score: %llu (%ix FC)" : "Score: %llu (%ix)")),

         score.score, score.comboMax);

         std::unordered_map<MD5Hash, std::vector<Score>> *scores = m_osu->getSongBrowser()->getDatabase()->getScores();

         // count number of scores to recalculate for UI

         size_t numScoresToRecalculate = 0;

         for(const auto &kv : *scores) {

             for(size_t i = 0; i < kv.second.size(); i++) {

                 const Score &score = kv.second[i];

                     numScoresToRecalculate++;

             }

         }

             for(size_t i = 0; i < kv.second.size(); i++) {

                 Score &score = kv.second[i];

                     if(m_bInterrupted.load()) break;

                     if(score.md5hash.hash[0] == 0) continue;

     if(m_sCopyAllScoresFromUser.length() < 1) return;

     const UString &playerNameToCopyInto = m_name_ref->getString();

     if(playerNameToCopyInto.length() < 1 || m_sCopyAllScoresFromUser == playerNameToCopyInto) return;

     debugLog("Copying all scores from \"%s\" into \"%s\"\n", m_sCopyAllScoresFromUser.toUtf8(),

              playerNameToCopyInto.toUtf8());

             // NOTE: only ever copy McOsu scores

             if(!existingScore.isLegacyScore) {

                     // check if this user already has this exact same score (copied previously) and don't copy if that

                     // is the case

                     bool alreadyCopied = false;

                         if(j == i) continue;

                         if(!alreadyCopiedScore.isLegacyScore) {

                                 if(existingScore.isScoreEqualToCopiedScoreIgnoringPlayerName(alreadyCopiedScore)) {

                                     alreadyCopied = true;

                                     break;

             if(Osu::debug->getBool()) debugLog("Copying %i for %s\n", (int)tempScoresToCopy.size(), kv.first.toUtf8());

             for(size_t i = 0; i < tempScoresToCopy.size(); i++) {

                 tempScoresToCopy[i].sortHack =

                     m_osu->getSongBrowser()->getDatabase()->getAndIncrementScoreSortHackCounter();

     if(id != 1) return;

     const UString &playerName = m_name_ref->getString();

     debugLog("Deleting all scores for \"%s\"\n", playerName.toUtf8());

             // NOTE: only ever delete McOsu scores

             if(!score.isLegacyScore) {

                     kv.second.erase(kv.second.begin() + i);

                     i--;

                 }

     uint64_t unixTimestamp;

     uint32_t player_id = 0;

     bool passed = false;

     bool ragequit = false;

     Grade grade = Grade::N;