if (mons_is_mimic(monster->type) && !mons_is_known_mimic(monster))

    if (mons_is_unknown_mimic(monster))

            if (player_monster_visible(monster)
                && (!mons_is_mimic(monster->type)
                    || mons_is_known_mimic(monster)))

            if (mons_is_unknown_mimic(monster))
            {
                // For unknown mimics, don't mark as seen,
                // but do mark it as in view for later messaging.
                // FIXME: is this correct?
                monster->flags |= MF_WAS_IN_VIEW;
            }
            else if (player_monster_visible(monster))

            && (!mons_is_mimic(mons->type) || mons_is_known_mimic(mons)));

            && !mons_is_unknown_mimic(mons));

            if (mons_is_mimic(mons->type) && !mons_is_known_mimic(mons))

            if (mons_is_unknown_mimic(mons))

        if (mons_is_mimic(mons->type)
            && mons_was_seen(mons)
            && !mons_is_known_mimic(mons))

        if (mons_is_unknown_mimic(mons) && mons_was_seen(mons))

            if (igrd[gx][gy] != NON_ITEM)

            if (igrd(gc) != NON_ITEM)

                    env.tile_bk_bg[gx][gy] |= TILE_FLAG_CURSOR3;

                    env.tile_bk_bg(gc) |= TILE_FLAG_CURSOR3;

        if (igrd[gx][gy] != NON_ITEM)

        if (igrd(gc) != NON_ITEM)

            || (mons_is_mimic(mon->type) && !mons_is_known_mimic(mon))

            || mons_is_unknown_mimic(mon)

        env.tile_bk_fg[gc.x][gc.y] = t0;

        env.tile_bk_fg(gc) = t0;

                wall_flv    = env.tile_flv[gc.x][gc.y].wall;
                floor_flv   = env.tile_flv[gc.x][gc.y].floor;
                special_flv = env.tile_flv[gc.x][gc.y].special;

                wall_flv    = env.tile_flv(gc).wall;
                floor_flv   = env.tile_flv(gc).floor;
                special_flv = env.tile_flv(gc).special;

#include "monstuff.h"

}
static bool _grid_has_mimic_item(const coord_def& pos)
{
    const monsters *mon = monster_at(pos);
    return (mon && mons_is_unknown_mimic(mon));
}
static bool _grid_has_perceived_item(const coord_def& pos)
{
    return (igrd(pos) != NON_ITEM || _grid_has_mimic_item(pos));
}
static bool _grid_has_perceived_multiple_items(const coord_def& pos)
{
    int count = 0;
    if (_grid_has_mimic_item(pos))
        ++count;
    for (stack_iterator si(pos); si && count < 2; ++si)
        ++count;
    return (count > 1);

    int objl = igrd[x][y];

        while (objl != NON_ITEM)
        {
            if (!is_filtered(mitm[objl]))
                add_item(mitm[objl]);
            objl = mitm[objl].link;
        }

        for (stack_iterator si(p); si; ++si)
            if (!is_filtered(*si))
                add_item(*si);

        if (objl == NON_ITEM)

        if (!_grid_has_perceived_item(p))

            return ;

            return;

        const item_def &item = mitm[objl];

        const item_def *pitem;
        item_def mimic_item;
        if (_grid_has_mimic_item(p))
        {
            get_mimic_item(monster_at(p), mimic_item);
            pitem = &mimic_item;
        }
        else
        {
            pitem = &mitm[igrd(p)];
        }

        const item_def& item = *pitem;

        if (item.link == NON_ITEM)

        if (!_grid_has_perceived_multiple_items(p))

            verified = (item.link == NON_ITEM);
            return ;

            // Note that we could be lying here, since we can have
            // a verified falsehood (if there's a mimic.)
            verified = !_grid_has_perceived_multiple_items(p);
            return;

        if (is_filtered(item)) return;

        if (is_filtered(item))
            return;

                        item_def temp   = items[i];
                        items[i]        = items[0];
                        items[0]        = temp;

                        std::swap(items[i], items[0]);

    return const_cast<Stash *>(
        const_cast<const LevelStashes *>(this)->find_stash(x, y) );

    if (x == -1 || y == -1)
    {
        x = you.pos().x;
        y = you.pos().y;
    }
    const int abspos = (GXM * y) + x;
    stashes_t::iterator st = m_stashes.find(abspos);
    return (st == m_stashes.end()? NULL : &st->second);

                && (igrd[cx][cy] != NON_ITEM

                && (_grid_has_perceived_item(coord_def(cx,cy))

bool mons_is_unknown_mimic(const monsters *m);

bool mons_is_unknown_mimic(const monsters *m)
{
    return mons_is_mimic(m->type) && !mons_is_known_mimic(m);
}

                && (!mons_is_mimic(mon->type) || mons_is_known_mimic(mon))

                && !mons_is_unknown_mimic(mon)

        const bool unknown_mimic =
            (mon && mons_is_mimic(mon->type) && !mons_is_known_mimic(mon));

        const bool unknown_mimic = (mon && mons_is_unknown_mimic(mon));