private:
    void _update_corpses(long rot_time);
    void add_item(const item_def &item, bool add_to_front = false);

    friend class LevelStashes;

    void _update_corpses(long rot_time);

    friend class StashTracker;

    StashTracker() : levels()

    StashTracker() : levels(), last_corpse_update(0.0)

    void update_corpses();

    double last_corpse_update;

#include "mon-util.h"

#define ST_MINOR_VER ((unsigned char) 7)

#define ST_MINOR_VER ((unsigned char) 8)

                items.push_back(mitm[objl]);

                add_item(mitm[objl]);

                items.push_back(item);

                add_item(item);

            items.insert(items.begin(), item);

            add_item(item, true);

static bool _is_rottable(const item_def &item)
{
    return (item.base_type == OBJ_CORPSES
            || (item.base_type == OBJ_FOOD && item.sub_type == FOOD_CHUNK));
}
static short _min_rot(const item_def &item)
{
    if (item.base_type == OBJ_FOOD)
        return 0;
    if (item.base_type == OBJ_CORPSES && item.sub_type == CORPSE_SKELETON)
        return 0;
    if (!mons_skeleton(item.plus))
        return 0;
    else
        return -200;
}

    return item.name(DESC_NOCAP_A);

    std::string name = item.name(DESC_NOCAP_A);
    if (!Options.stash_track_decay || !_is_rottable(item))
        return name;
    if (item.plus2 <= _min_rot(item))
    {
        name += " (gone by now)";
        return name;
    }
    // Skeletons show no signs of rotting before they're gone
    if (item.base_type == OBJ_CORPSES && item.sub_type == CORPSE_SKELETON)
        return name;
    // Item was already seen to be rotten
    if (item.special < 100)
        return name;
    if (item.plus2 <= 0)
        name += " (skeletalised by now)";
    else if (item.plus2 < 100)
        name += " (rotten by now)";
    return name;

}
void Stash::_update_corpses(long rot_time)
{
    for (int i = items.size() - 1; i >= 0; i--)
    {
        item_def &item = items[i];
        if (!_is_rottable(item))
            continue;
        long new_rot = static_cast<long>(item.plus2) - rot_time;
        if (new_rot <= _min_rot(item))
        {
            if (Options.stash_remove_decay)
            {
                items.erase(items.begin() + i);
                continue;
            }
            new_rot = _min_rot(item);
        }
        item.plus2 = static_cast<short>(new_rot);
    }

void Stash::add_item(const item_def &item, bool add_to_front)
{
    if (add_to_front)
        items.insert(items.begin(), item);
    else
        items.push_back(item);
    if (!_is_rottable(item))
        return;
    // item.special remains unchanged in the stash, to show how fresh it
    // was when last seen.  It's plus2 that's decayed over time.
    if (add_to_front)
    {
        item_def &it = items.front();
        it.plus2     = it.special;
    }
    else
    {
        item_def &it = items.back();
        it.plus2     = it.special;
    }
}

void LevelStashes::_update_corpses(long rot_time)
{
    for (stashes_t::iterator iter = m_stashes.begin();
            iter != m_stashes.end(); iter++)
    {
        iter->second._update_corpses(rot_time);
    }
}

    // Time of last corpse update.
    marshallFloat(outf, (float) last_corpse_update);

    // Time of last corpse update.
    last_corpse_update = (double) unmarshallFloat(inf);

}
void StashTracker::update_corpses()
{
    if (!Options.stash_track_decay)
        return;
    if (you.elapsed_time - last_corpse_update < 20.0)
        return;
    const long rot_time = static_cast<long>((you.elapsed_time -
                                             last_corpse_update) / 20.0);
    last_corpse_update = you.elapsed_time;
    for (stash_levels_t::iterator iter = levels.begin();
            iter != levels.end(); iter++)
    {
        iter->second._update_corpses(rot_time);
    }

    stash_track_decay      = false;
    stash_remove_decay     = false;

    else BOOL_OPTION(stash_track_decay);
    else BOOL_OPTION(stash_remove_decay);

    bool        stash_track_decay;  // Keep track of how decayed corpses are
    bool        stash_remove_decay; // Remove corpses that have most probably
                                    // completely rotted away

    }
    else
    {
        // Don't do this while delayed, so as to not slow down resting
        // and travel by iterating over all stahses once per player turn.
        StashTrack.update_corpses();

# stash_track_decay = true
# stash_remove_decay = true

                annoate_item_dropped

                annoate_item_dropped, stash_track_decay,
                stash_remove_decay

stash_track_decay = false
        If set to true then the stash tracker will remember how long its
        been since you've seen chunks of meat or a corpse or skeleton and
        tell you what state its in by adding "rotten by now",
        "skeletalised by now" or "gone by now" to its name.

stash_remove_decay = false
        If both this and stash_track_decay are set to true, anything that
        would have been reported as "gone by now" will instead be
        removed from the stash tracker's memory.