char *saveptr = NULL;

     char *str = strtok_r(score_line, "|", &saveptr);

     if(!str) return score;

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

     if(!str) return score;

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

     if(!str) return score;

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

     if(!str) return score;

     // XXX: We should also separately display either the "personal best" the server sent us,

     //      or the local best, depending on which score is better.

     debugLog("Received online leaderbord for Beatmap ID %d\n", info.beatmap_id);

     bancho.osu->getSongBrowser()->rebuildScoreButtons();

 }

         McFont *debugFont = engine->getResourceManager()->getFont("FONT_DEFAULT");

         g->setColor(0xffffffff);

         g->pushTransform();

         {

             for(const OsuDatabaseBeatmap::TIMINGPOINT &t : m_selectedDifficulty2->getTimingpoints()) {

                 g->drawString(debugFont, UString::format("%li,%f,%i,%i,%i", t.offset, t.msPerBeat, t.sampleType,

 }

 void OsuBeatmap::keyPressed1(bool mouse) {

     if(m_bContinueScheduled) m_bClickedContinue = !m_osu->getModSelector()->isMouseInside();

     if(osu_mod_fullalternate.getBool() && m_bPrevKeyWasKey1) {

     m_bPrevKeyWasKey1 = true;

     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;

 }

 void OsuBeatmap::keyPressed2(bool mouse) {

     if(m_bContinueScheduled) m_bClickedContinue = !m_osu->getModSelector()->isMouseInside();

     if(osu_mod_fullalternate.getBool() && !m_bPrevKeyWasKey1) {

     m_bPrevKeyWasKey1 = false;

     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;

 }

 void OsuBeatmap::keyReleased1(bool mouse) {

     // key overlay

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

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

 }

 void OsuBeatmap::keyReleased2(bool mouse) {

     // key overlay

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

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

     unloadObjects();

 }

 bool OsuBeatmap::play() {

     if(m_selectedDifficulty2 == NULL) return false;

     m_bIsWaiting = true;

     m_fWaitTime = engine->getTimeReal();

     m_bIsPlaying = true;

 }

 void OsuBeatmap::restart(bool quick) {

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

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

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

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

 }

 void OsuBeatmap::resetHitObjects(long curPos) {

 void OsuBeatmap::resetScore() {

     vanilla = convar->isVanilla();

         .cur_music_pos = -1,

         .milliseconds_since_last_frame = 0,

         .x = 256,

         .y = -500,

         .key_flags = 0,

     });

         .cur_music_pos = -1,

         .milliseconds_since_last_frame = -1,

         .x = 256,

                                   // we are continuing we can assume that everything works

             // for nightmare mod, to avoid a miss because of the continue click

         }

     }

                                 (m_selectedDifficulty2->getVersion() < 5 ? osu_old_beatmap_offset.getInt() : 0);

     updateTimingPoints(m_iCurMusicPosWithOffsets);

     // for performance reasons, a lot of operations are crammed into 1 loop over all hitobjects:

     // update all hitobjects,

     // handle click events,

             const bool isCurrentHitObjectFinishedBeforeClickEvents = m_hitobjects[i]->isFinished();

             {

                 if(m_clicks.size() > 0) m_hitobjects[i]->onClickEvent(m_clicks);

             }

             const bool isCurrentHitObjectFinishedAfterClickEvents = m_hitobjects[i]->isFinished();

             const bool isCurrentHitObjectASliderAndHasItsStartCircleFinishedAfterClickEvents =

                         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)

             m_clicks.clear();

         }

     }

     // empty section detection & skipping

     if(osu_playfield_mirror_horizontal.getBool()) pos.y = OsuGameRules::OSU_COORD_HEIGHT - pos.y;

     if(osu_playfield_mirror_vertical.getBool()) pos.x = OsuGameRules::OSU_COORD_WIDTH - pos.x;

         .cur_music_pos = m_iCurMusicPosWithOffsets,

         .milliseconds_since_last_frame = delta,

         .x = pos.x,

     return coords;

 }

 Vector2 OsuBeatmap::getCursorPos() const {

     if(OsuGameRules::osu_mod_fps.getBool() && !m_bIsPaused) {

         if(m_osu->getModAuto() || m_osu->getModAutopilot())

     } else if(m_osu->getModAuto() || m_osu->getModAutopilot())

         return m_vAutoCursorPos;

     else {

         if(osu_mod_shirone.getBool() && m_osu->getScore()->getCombo() > 0)  // <3

             return pos + Vector2(std::sin((m_iCurMusicPos / 20.0f) * 1.15f) *

                                      ((float)m_osu->getScore()->getCombo() / osu_mod_shirone_combo.getFloat()),

 }

 Vector2 OsuBeatmap::getFirstPersonCursorDelta() const {

 }

 float OsuBeatmap::getHitcircleDiameter() const { return m_fHitcircleDiameter; }

     // save local score, but only under certain conditions

     const bool isComplete = (num300s + num100s + num50s + numMisses >= numHitObjects);

     const bool isZero = (m_osu->getScore()->getScore() < 1);

     OsuDatabase::Score score;

     score.isLegacyScore = false;

         OsuRichPresence::onPlayEnd(m_osu, quit);

         if(bancho.submit_scores() && !isZero && vanilla) {

             submit_score(score);

         }

     debugLog("OsuBeatmap::onPaused()\n");

     if(first) {

         if(OsuGameRules::osu_mod_fps.getBool()) m_vContinueCursorPoint = OsuGameRules::getPlayfieldCenter(m_osu);

     }

     friend class OsuBackgroundStarCacheLoader;

     friend class OsuBackgroundStarCalcHandler;

     OsuBeatmap(Osu *osu);

     ~OsuBeatmap();

                                 // the static slider mesh) centered at (0, 0, 0)

     // cursor

     Vector2 getCursorPos() const;

     Vector2 getFirstPersonCursorDelta() const;

     inline Vector2 getContinueCursorPoint() const { return m_vContinueCursorPoint; }

                     // clicking on a beatmap)

     void selectDifficulty2(OsuDatabaseBeatmap *difficulty2);

     void deselect();  // stops + unloads the currently loaded music and deletes all hitobjects

     bool play();

     void restart(bool quick = false);

     void pause(bool quitIfWaiting = true);

     // set to false when using non-vanilla mods (disables score submission)

     bool vanilla = true;

     void write_frame();

     double last_event_time = 0.0;

     long last_event_ms = 0;

     uint8_t current_keys = 0;

     uint8_t last_keys = 0;

     // used by OsuHitObject children and OsuModSelector

     inline Osu *getOsu() const { return m_osu; }

     OsuSkin *getSkin() const;  // maybe use this for beatmap skins, maybe

     Osu *m_osu;

     // beatmap state

     bool m_bIsPlaying;

     bool m_bIsPaused;

     bool m_bIsWaiting;

     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 cursorPos = m_beatmap->getCursorPos();

             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:

         uint64_t play_time_ms = 0;

         std::vector<OsuReplay::Frame> replay;

         int num300s;

         int num100s;

         int num50s;

     inline bool isBlocked() const { return m_bBlocked; }

     inline bool hasMisAimed() const { return m_bMisAim; }

     virtual void onReset(long curPos);

    protected:

     }

 }

     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)

         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);

     }

 }

     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:

         m_contextMenu->begin(0, true);

         {

             m_contextMenu->addButton("Use Mods", 1);  // for scores without mods this will just nomod

             CBaseUIButton *spacer = m_contextMenu->addButton("---");

             spacer->setEnabled(false);

             spacer->setTextColor(0xff888888);

             spacer->setTextDarkColor(0xff000000);

             if(m_score.isLegacyScore) {

                 deleteButton->setEnabled(false);

                 deleteButton->setTextColor(0xff888888);

 }

 void OsuUISongBrowserScoreButton::onContextMenu(UString text, int id) {

     if(id == 2) {

         if(engine->getKeyboard()->isShiftDown())

             onDeleteScoreConfirmed(text, 1);

         else

             onDeleteScoreClicked();

     }

 }