+    u32 nb_peppy = 0;

+    u32 nb_neosu = 0;

+    u32 nb_total = 0;

+    for(auto collection : collections) {

+        nb_peppy += collection->peppy_maps.size();

+        nb_neosu += collection->neosu_maps.size();

+        nb_total += collection->maps.size();

+    }

+

+    debugLog("peppy+neosu collections: loading took %f seconds (%d peppy, %d neosu, %d maps total)\n",

+             (engine->getTimeReal() - startTime), nb_peppy, nb_neosu, nb_total);

+        std::vector<DatabaseBeatmap *> *diffs2 = nullptr;

+        auto md5hash = read_hash(db);

+        if(mode != 0) continue;

+

+        DatabaseBeatmap *diff2 = new DatabaseBeatmap(m_osu, fullFilePath, beatmapPath);

+        {

+            diff2->m_sTitle = songTitle;

+            diff2->m_sAudioFileName = audioFileName;

+            diff2->m_iLengthMS = duration;

+

+            diff2->m_fStackLeniency = stackLeniency;

+

+            diff2->m_sArtist = artistName;

+            diff2->m_sCreator = creatorName;

+            diff2->m_sDifficultyName = difficultyName;

+            diff2->m_sSource = songSource;

+            diff2->m_sTags = songTags;

+            diff2->m_sMD5Hash = md5hash;

+            diff2->m_iID = beatmapID;

+            diff2->m_iSetID = beatmapSetID;

+

+            diff2->m_fAR = AR;

+            diff2->m_fCS = CS;

+            diff2->m_fHP = HP;

+            diff2->m_fOD = OD;

+            diff2->m_fSliderMultiplier = sliderMultiplier;

+

+            // diff2->m_sBackgroundImageFileName = "";

+

+            diff2->m_iPreviewTime = previewTime;

+            diff2->last_modification_time = lastModificationTime;

+

+            diff2->m_sFullSoundFilePath = beatmapPath;

+            diff2->m_sFullSoundFilePath.append(diff2->m_sAudioFileName);

+            diff2->m_iLocalOffset = localOffset;

+            diff2->m_iOnlineOffset = (long)onlineOffset;

+            diff2->m_iNumObjects = numCircles + numSliders + numSpinners;

+            diff2->m_iNumCircles = numCircles;

+            diff2->m_iNumSliders = numSliders;

+            diff2->m_iNumSpinners = numSpinners;

+

+            // NOTE: if we have our own stars/bpm cached then use that

+            bool bpm_was_cached = false;

+            diff2->m_fStarsNomod = numOsuStandardStars;

+

+            const auto result = m_starsCache.find(md5hash);

+            if(result != m_starsCache.end()) {

+                if(result->second.starsNomod >= 0.f) {

+                    diff2->m_fStarsNomod = result->second.starsNomod;

+                }

+                if(result->second.min_bpm >= 0) {

+                    diff2->m_iMinBPM = result->second.min_bpm;

+                    diff2->m_iMaxBPM = result->second.max_bpm;

+                    diff2->m_iMostCommonBPM = result->second.common_bpm;

+                    bpm_was_cached = true;

+                }

+            }

+

+            if(!bpm_was_cached) {

+                auto bpm = getBPM(timingPoints);

+            }

+            // build temp partial timingpoints, only used for menu animations

+            // a bit hacky to avoid slow ass allocations

+            diff2->m_timingpoints.resize(numTimingPoints);

+            memset(diff2->m_timingpoints.data(), 0, numTimingPoints * sizeof(DatabaseBeatmap::TIMINGPOINT));

+            for(int t = 0; t < numTimingPoints; t++) {

+                diff2->m_timingpoints[t].offset = (long)timingPoints[t].offset;

+                diff2->m_timingpoints[t].msPerBeat = (float)timingPoints[t].msPerBeat;

+                diff2->m_timingpoints[t].timingChange = timingPoints[t].timingChange;

+        }

+        // special case: legacy fallback behavior for invalid beatmapSetID, try to parse the ID from the path

+        if(beatmapSetID < 1 && path.length() > 0) {

+            auto upath = UString(path.c_str());

+            const std::vector<UString> pathTokens =

+                upath.split("\\");  // NOTE: this is hardcoded to backslash since osu is windows only

+            if(pathTokens.size() > 0 && pathTokens[0].length() > 0) {

+                const std::vector<UString> spaceTokens = pathTokens[0].split(" ");

+                if(spaceTokens.size() > 0 && spaceTokens[0].length() > 0) {

+                    try {

+                        beatmapSetID = spaceTokens[0].toInt();

+                    } catch(...) {

+                        beatmapSetID = -1;

+        }

+        // (the diff is now fully built)

+

+        // now, search if the current set (to which this diff would belong) already exists and add it there, or if

+        // it doesn't exist then create the set

+        const auto result = setIDToIndex.find(beatmapSetID);

+        const bool beatmapSetExists = (result != setIDToIndex.end());

+        if(beatmapSetExists) {

+            beatmapSets[result->second].diffs2->push_back(diff2);

+        } else {

+            setIDToIndex[beatmapSetID] = beatmapSets.size();

+

+            BeatmapSet s;

+            s.setID = beatmapSetID;

+            s.path = beatmapPath;

+            s.diffs2 = new std::vector<DatabaseBeatmap *>();

+            s.diffs2->push_back(diff2);

+            beatmapSets.push_back(s);

+        if(!beatmapSets[i].diffs2->empty())  // sanity check

+                DatabaseBeatmap *bm = new DatabaseBeatmap(m_osu, beatmapSets[i].diffs2);

+        if(!beatmapSets[i].diffs2->empty())  // sanity check

+                for(int b = 0; b < beatmapSets[i].diffs2->size(); b++) {

+                    DatabaseBeatmap *diff2 = (*beatmapSets[i].diffs2)[b];

+                        auto diffs2 = new std::vector<DatabaseBeatmap *>();

+                        diffs2->push_back((*beatmapSets[i].diffs2)[b]);

+                        DatabaseBeatmap *bm = new DatabaseBeatmap(m_osu, diffs2);

+    load_collections();

+

+    Packet cache = load_db("stars.cache");

+    if(cache.size <= 0) return;

+

+    m_starsCache.clear();

+    const int cacheVersion = read<u32>(&cache);

+    if(cacheVersion > STARS_CACHE_VERSION) {

+        debugLog("Invalid stars cache version, ignoring.\n");

+        free(cache.memory);

+        return;

+    }

+    skip_string(&cache);  // ignore md5

+    const i64 numStarsCacheEntries = read<u64>(&cache);

+    debugLog("Stars cache: version = %i, numStarsCacheEntries = %i\n", cacheVersion, numStarsCacheEntries);

+    for(i64 i = 0; i < numStarsCacheEntries; i++) {

+        auto beatmapMD5Hash = read_hash(&cache);

+        STARS_CACHE_ENTRY entry;

+        entry.starsNomod = read<f32>(&cache);

+        if(cacheVersion >= 20240430) {

+            entry.min_bpm = read<i32>(&cache);

+            entry.max_bpm = read<i32>(&cache);

+            entry.common_bpm = read<i32>(&cache);

+        }

+        m_starsCache[beatmapMD5Hash] = entry;

+    }

+    free(cache.memory);

+        numStarsCacheEntries += beatmap->getDifficulties().size();

+    // 100 instead of 1 because player can idle in main menu while shuffling without loading database

+    // If the player *did* load the database and actually has less than 100 beatmaps, then it doesn't matter

+    // since getting the stars/bpm/etc would be fast enough anyway.

+    if(numStarsCacheEntries < 100) {

+        debugLog("No beatmaps loaded, nothing to write.\n");

+    write_u32(&cache, STARS_CACHE_VERSION);

+            write_string(&cache, diff2->getMD5Hash().hash);

+            write_f32(&cache, diff2->getStarsNomod());

+            write<i32>(&cache, diff2->getMinBPM());

+            write<i32>(&cache, diff2->getMaxBPM());

+            write<i32>(&cache, diff2->getMostCommonBPM());

+

+    free(cache.memory);

+                    auto md5hash = read_hash(&db);

+                        debugLog("Beatmap[%i]: md5hash = %s, numScores = %i\n", b, md5hash.hash, numScores);

+                auto md5hash = read_hash(&db);

+    std::vector<DatabaseBeatmap *> *diffs2 = new std::vector<DatabaseBeatmap *>();

+                if(DatabaseBeatmap::loadMetadata(diff2)) {

+                    // (metadata loaded successfully)

+                    diffs2->push_back(diff2);

+                } else {

+    if(diffs2->empty()) {

+        delete diffs2;

+    } else {

+        beatmap = new DatabaseBeatmap(m_osu, diffs2);

+#define STARS_CACHE_VERSION 20240430

+

+    // stars.cache

+    struct STARS_CACHE_ENTRY {

+        float starsNomod = -1;

+        i32 min_bpm = -1;

+        i32 max_bpm = -1;

+        i32 common_bpm = -1;

+    };

+    std::unordered_map<MD5Hash, STARS_CACHE_ENTRY> m_starsCache;

+

+#include "Database.h"

+#include "SongBrowser.h"

+    m_difficulties = new std::vector<DatabaseBeatmap *>();

+DatabaseBeatmap::DatabaseBeatmap(Osu *osu, std::vector<DatabaseBeatmap *> *difficulties)

+    setDifficulties(difficulties);

+    for(size_t i = 0; i < m_difficulties->size(); i++) {

+        delete(*m_difficulties)[i];

+    SAFE_DELETE(m_difficulties);

+    if(!databaseBeatmap->m_difficulties->empty()) return false;  // we are just a container

+        // NOTE: if we have our own stars/bpm cached then use that

+        bool bpm_was_cached = false;

+        auto db = bancho.osu->getSongBrowser()->getDatabase();

+        const auto result = db->m_starsCache.find(databaseBeatmap->getMD5Hash());

+        if(result != db->m_starsCache.end()) {

+            if(result->second.starsNomod >= 0.f) {

+                databaseBeatmap->m_fStarsNomod = result->second.starsNomod;

+            }

+            if(result->second.min_bpm >= 0) {

+                databaseBeatmap->m_iMinBPM = result->second.min_bpm;

+                databaseBeatmap->m_iMaxBPM = result->second.max_bpm;

+                databaseBeatmap->m_iMostCommonBPM = result->second.common_bpm;

+                bpm_was_cached = true;

+            }

+        }

+

+        if(!bpm_was_cached) {

+            auto bpm = getBPM(databaseBeatmap->m_timingpoints);

+            databaseBeatmap->m_iMinBPM = bpm.min;

+            databaseBeatmap->m_iMaxBPM = bpm.max;

+            databaseBeatmap->m_iMostCommonBPM = bpm.most_common;

+        }

+void DatabaseBeatmap::setDifficulties(std::vector<DatabaseBeatmap *> *difficulties) {

+    if(m_difficulties != difficulties) {

+        delete m_difficulties;

+        m_difficulties = difficulties;

+    }

+

+    if(m_difficulties->empty()) return;

+    m_sTitle = (*m_difficulties)[0]->m_sTitle;

+    m_sArtist = (*m_difficulties)[0]->m_sArtist;

+    m_sCreator = (*m_difficulties)[0]->m_sCreator;

+    m_sBackgroundImageFileName = (*m_difficulties)[0]->m_sBackgroundImageFileName;

+    for(auto diff : (*m_difficulties)) {

+    DatabaseBeatmap(Osu *osu, std::vector<DatabaseBeatmap *> *difficulties);

+    void setDifficulties(std::vector<DatabaseBeatmap *> *difficulties);

+    inline const std::vector<DatabaseBeatmap *> &getDifficulties() const { return *m_difficulties; }

+    int m_iMinBPM = 0;

+    int m_iMaxBPM = 0;

+    int m_iMostCommonBPM = 0;

+    std::vector<DatabaseBeatmap *> *m_difficulties = nullptr;

+    i32 min;

+    i32 max;

+    i32 most_common;

+struct BPMInfo getBPM(const zarray<T> &timing_points) {

+    if(timing_points.empty()) {

+        i32 bpm;

+        i32 duration;

+    long lastTime = timing_points[timing_points.size() - 1].offset;

+        if(t.offset > lastTime) continue;

+        const long nextTime = (i == timing_points.size() - 1 ? lastTime : timing_points[i + 1].offset);

+        i32 bpm = t.msPerBeat / 60000;

+        i32 duration = std::max(nextTime - currentTime, (long)0);

+    i32 min = 9001;

+    i32 max = 0;

+    i32 mostCommonBPM = 0;

+    i32 longestDuration = 0;

+    bool empty() const { return nb == 0; }