LevelStashes *lev = stashes.find_current_level();

        LevelStashes *lev = StashTrack.find_current_level();

            LevelStashes *lev = stashes.find_current_level();

            LevelStashes *lev = StashTrack.find_current_level();

                const LevelStashes *lev = stashes.find_current_level();

                const LevelStashes *lev = StashTrack.find_current_level();

        ls = stashes.find_current_level();

        ls = StashTrack.find_current_level();

            current_level = stashes.find_current_level();

            current_level = StashTrack.find_current_level();

    int   stash_count() const { return stashes.size() + shops.size(); }
    int   visible_stash_count() const { return count_stashes() + shops.size(); }

    int   stash_count() const { return m_stashes.size() + m_shops.size(); }
    int   visible_stash_count() const { return _num_enabled_stashes() + m_shops.size(); }

private:
    // which level
    level_id place;

 private:
    int _num_enabled_stashes() const;

 private:

    stashes_t stashes;
    shops_t   shops;
    int count_stashes() const;

    // which level
    level_id m_place;
    stashes_t m_stashes;
    shops_t m_shops;

extern StashTracker stashes;

extern StashTracker StashTrack;

// Global
StashTracker StashTrack;

    stashes.remove_level( level_id(LEVEL_PANDEMONIUM) );
    stashes.remove_level( level_id(LEVEL_PORTAL_VAULT) );

    StashTrack.remove_level( level_id(LEVEL_PANDEMONIUM) );
    StashTrack.remove_level( level_id(LEVEL_PORTAL_VAULT) );

    LevelStashes *ls = stashes.find_current_level();

    LevelStashes *ls = StashTrack.find_current_level();

    LevelStashes *ls = stashes.find_current_level();

    LevelStashes *ls = StashTrack.find_current_level();

LevelStashes::LevelStashes() : place(level_id::current()), stashes(), shops()

LevelStashes::LevelStashes()
    : m_place(level_id::current()),
      m_stashes(),
      m_shops()

    return (place);

    return m_place;

    stashes_t::const_iterator st = stashes.find(abspos);
    return (st == stashes.end()? NULL : &st->second);

    stashes_t::const_iterator st = m_stashes.find(abspos);
    return (st == m_stashes.end()? NULL : &st->second);

    for (unsigned i = 0; i < shops.size(); ++i)

    for (unsigned i = 0; i < m_shops.size(); ++i)

        if (shops[i].isAt(x, y))
            return (&shops[i]);

        if (m_shops[i].isAt(x, y))
            return (&m_shops[i]);

    for (unsigned i = 0; i < shops.size(); ++i)

    for (unsigned i = 0; i < m_shops.size(); ++i)

        if (shops[i].isAt(x, y))
            return shops[i];

        if (m_shops[i].isAt(x, y))
            return m_shops[i];

    shops.push_back(si);

    m_shops.push_back(si);

    stashes.erase(s.abs_pos());

    m_stashes.erase(s.abs_pos());

        stashes[ newStash.abs_pos() ] = newStash;

        m_stashes[ newStash.abs_pos() ] = newStash;

            stashes[ new_stash.abs_pos() ] = new_stash;

            m_stashes[ new_stash.abs_pos() ] = new_stash;

    return (place == level_id::current());

    return (m_place == level_id::current());

    return place.describe(true, true);

    return m_place.describe(true, true);

    return place.describe();

    return m_place.describe();

int LevelStashes::count_stashes() const

int LevelStashes::_num_enabled_stashes() const

    int rawcount = stashes.size();

    int rawcount = m_stashes.size();

    for (stashes_t::const_iterator iter = stashes.begin(); 
            iter != stashes.end(); iter++)

    for (stashes_t::const_iterator iter = m_stashes.begin(); 
            iter != m_stashes.end(); iter++)

    std::string lplace = "{" + place.describe() + "}";
    for (stashes_t::const_iterator iter = stashes.begin();
            iter != stashes.end(); iter++)

    std::string lplace = "{" + m_place.describe() + "}";
    for (stashes_t::const_iterator iter = m_stashes.begin();
            iter != m_stashes.end(); iter++)

                res.pos.id = place;

                res.pos.id = m_place;

    for (unsigned i = 0; i < shops.size(); ++i)

    for (unsigned i = 0; i < m_shops.size(); ++i)

        if (shops[i].matches_search(lplace, search, res))

        if (m_shops[i].matches_search(lplace, search, res))

            res.pos.id = place;

            res.pos.id = m_place;

    for (unsigned i = 0; i < shops.size(); ++i)

    for (unsigned i = 0; i < m_shops.size(); ++i)

        shops[i].write(os, identify);

        m_shops[i].write(os, identify);

    if (stashes.size())

    if (m_stashes.size())

        const Stash &s = stashes.begin()->second;

        const Stash &s = m_stashes.begin()->second;

        for (stashes_t::const_iterator iter = stashes.begin(); 
                iter != stashes.end(); iter++)

        for (stashes_t::const_iterator iter = m_stashes.begin(); 
                iter != m_stashes.end(); iter++)

    writeShort(file, (short) stashes.size());

    writeShort(file, (short) m_stashes.size());

    place.save(file);

    m_place.save(file);

    for (stashes_t::const_iterator iter = stashes.begin(); 
            iter != stashes.end(); iter++)

    for (stashes_t::const_iterator iter = m_stashes.begin(); 
            iter != m_stashes.end(); iter++)

    writeShort(file, (short) shops.size());
    for (unsigned i = 0; i < shops.size(); ++i)
        shops[i].save(file);

    writeShort(file, (short) m_shops.size());
    for (unsigned i = 0; i < m_shops.size(); ++i)
        m_shops[i].save(file);

    place.load(file);

    m_place.load(file);

    stashes.clear();

    m_stashes.clear();

            stashes[ s.abs_pos() ] = s;

            m_stashes[ s.abs_pos() ] = s;

    shops.clear();

    m_shops.clear();

        shops.push_back(si);

        m_shops.push_back(si);

// Global
StashTracker stashes;

    ShopInfo &si = stashes.get_shop(shop.x, shop.y);

    ShopInfo &si = StashTrack.get_shop(shop.x, shop.y);

        stashes.get_shop(shop.x, shop.y).reset();

        StashTrack.get_shop(shop.x, shop.y).reset();

        stashes.add_stash();

        StashTrack.add_stash();

        stashes.save(stashf);

        StashTrack.save(stashf);

        stashes.load(stashf);

        StashTrack.load(stashf);

        stashes.update_stash(); // Stash-track the generated item(s)

        StashTrack.update_stash(); // Stash-track the generated item(s)

    stashes.dump(stash_file_name.c_str(), par.full_id);

    StashTrack.dump(stash_file_name.c_str(), par.full_id);

            stashes.add_stash();

            StashTrack.add_stash();

        stashes.search_stashes();

        StashTrack.search_stashes();

            stashes.add_stash(-1, -1, true);

            StashTrack.add_stash(-1, -1, true);

            stashes.no_stash();

            StashTrack.no_stash();

        stashes.update_visible_stashes(

        StashTrack.update_visible_stashes(