// returns index of corpse tiles
// parameter mon already holds the corpse type (monster species)

// Returns index of corpse tiles.
// Parameter mon already holds the corpse type (monster species).

    // case MONS_PROGRAM_BUG:

    // case MONS_FUNGUS:
    // case MONS_WANDERING_MUSHROOM:

    // case MONS_BOGGART:

    // case MONS_HELL_HOUND:
    // case MONS_HELL_HOG:

    // case MONS_ROTTING_HULK:

    // case MONS_PHANTOM:
    // case MONS_HUNGRY_GHOST:
    // case MONS_FLAYED_GHOST:
    // case MONS_PLAYER_GHOST:
    // case MONS_INSUBSTANTIAL_WISP:

    // case MONS_FIRE_VORTEX:
    // case MONS_SPATIAL_VORTEX:
    // case MONS_AIR_ELEMENTAL:
    // case MONS_EARTH_ELEMENTAL:
    // case MONS_FIRE_ELEMENTAL:
    // case MONS_WATER_ELEMENTAL:

    // case MONS_UNSEEN_HORROR:
    // case MONS_ABOMINATION_SMALL:

    // case MONS_MOTH_OF_WRATH:
    // case MONS_ZOMBIE_SMALL:
    // case MONS_SKELETON_SMALL:
    // case MONS_SIMULACRUM_SMALL:
    // case MONS_SKELETAL_WARRIOR:
    // case MONS_FLYING_SKULL:
    // case MONS_CURSE_SKULL:
    // case MONS_CURSE_TOE:
    // case MONS_ANGEL:
    // case MONS_DAEVA:

    // case MONS_QUICKSILVER_DRAGON:
    // case MONS_IRON_DRAGON:

    // case MONS_SKELETAL_DRAGON:
    // case MONS_SERPENT_OF_HELL:
    // case MONS_EFREET:

    // case MONS_GIANT_SPORE:

    // case MONS_SHINING_EYE:
    // case MONS_EYE_OF_DEVASTATION:

    // case MONS_SPHINX:
    // case MONS_ICE_BEAST:
    // case MONS_OOZE:
    // case MONS_JELLY:
    // case MONS_SLIME_CREATURE:
    // case MONS_PULSATING_LUMP:

    // case MONS_BROWN_OOZE:
    // case MONS_AZURE_JELLY:
    // case MONS_DEATH_OOZE:
    // case MONS_ACID_BLOB:
    // case MONS_ROYAL_JELLY:

    // case MONS_LICH:
    // case MONS_ANCIENT_LICH:
    // case MONS_MUMMY:
    // case MONS_GUARDIAN_MUMMY:
    // case MONS_GREATER_MUMMY:
    // case MONS_MUMMY_PRIEST:

    // case MONS_OGRE_MAGE:
    // case MONS_PLANT:
    // case MONS_OKLOB_PLANT:

    // case MONS_RAKSHASA:
    // case MONS_RAKSHASA_FAKE:

    // case MONS_VAMPIRE:
    // case MONS_VAMPIRE_KNIGHT:
    // case MONS_VAMPIRE_MAGE:
    // case MONS_WIGHT:
    // case MONS_WRAITH:
    // case MONS_SHADOW_WRAITH:
    // case MONS_FREEZING_WRAITH:
    // case MONS_SPECTRAL_WARRIOR:
    // case MONS_SPECTRAL_THING:
    // case MONS_ABOMINATION_LARGE:
    // case MONS_TENTACLED_MONSTROSITY:
    // case MONS_ORB_GUARDIAN:

    // case MONS_ZOMBIE_LARGE:
    // case MONS_SKELETON_LARGE:
    // case MONS_SIMULACRUM_LARGE:
    // case MONS_BIG_FISH:
    // case MONS_GIANT_GOLDFISH:
    // case MONS_ELECTRICAL_EEL:
    // case MONS_JELLYFISH:
    // case MONS_SWAMP_WORM:
    // case MONS_LAVA_WORM:
    // case MONS_LAVA_FISH:
    // case MONS_LAVA_SNAKE:
    // case MONS_SALAMANDER:
    // case MONS_ROCK_WORM:

    // case MONS_VAULT_GUARD:

    // case MONS_KILLER_KLOWN:
    // case MONS_GOLD_MIMIC:
    // case MONS_WEAPON_MIMIC:
    // case MONS_ARMOUR_MIMIC:
    // case MONS_SCROLL_MIMIC:
    // case MONS_POTION_MIMIC:
    // case MONS_DANCING_WEAPON:
    // case MONS_IMP:
    // case MONS_QUASIT:
    // case MONS_WHITE_IMP:
    // case MONS_LEMURE:
    // case MONS_UFETUBUS:
    // case MONS_MANES:
    // case MONS_MIDGE:
    // case MONS_SHADOW_IMP:
    // case MONS_RED_DEVIL:
    // case MONS_ROTTING_DEVIL:
    // case MONS_HAIRY_DEVIL:
    // case MONS_BEAST:
    // case MONS_SMOKE_DEMON:
    // case MONS_HELLION:
    // case MONS_TORMENTOR:
    // case MONS_BLUE_DEVIL:
    // case MONS_IRON_DEVIL:
    // case MONS_NEQOXEC:
    // case MONS_ORANGE_DEMON:
    // case MONS_HELLWING:
    // case MONS_YNOXINUL:
    // case MONS_DEMONIC_CRAWLER:
    // case MONS_SHADOW_DEMON:
    // case MONS_SUN_DEMON:
    // case MONS_REAPER:
    // case MONS_SOUL_EATER:
    // case MONS_ICE_DEVIL:
    // case MONS_LOROCYPROCA:
    // case MONS_FIEND:
    // case MONS_ICE_FIEND:
    // case MONS_SHADOW_FIEND:
    // case MONS_PIT_FIEND:
    // case MONS_EXECUTIONER:
    // case MONS_GREEN_DEATH:
    // case MONS_BLUE_DEATH:
    // case MONS_BALRUG:
    // case MONS_CACODEMON:
    // case MONS_CLAY_GOLEM:
    // case MONS_WOOD_GOLEM:
    // case MONS_STONE_GOLEM:
    // case MONS_IRON_GOLEM:
    // case MONS_CRYSTAL_GOLEM:
    // case MONS_TOENAIL_GOLEM:
    // case MONS_ELECTRIC_GOLEM:
    // case MONS_ICE_STATUE:
    // case MONS_SILVER_STATUE:
    // case MONS_ORANGE_STATUE:
    // case MONS_GARGOYLE:
    // case MONS_METAL_GARGOYLE:
    // case MONS_MOLTEN_GARGOYLE:
    // case MONS_PANDEMONIUM_DEMON:
    // case MONS_BALL_LIGHTNING:
    // case MONS_ORB_OF_FIRE:
    // case MONS_VAPOUR:
    // case MONS_SHADOW:
    // case MONS_DEATH_COB:
    // case MONS_IJYB:
    // case MONS_BLORK_THE_ORC:
    // case MONS_URUG:
    // case MONS_EROLCHA:
    // case MONS_SNORG:

    // case MONS_ANTAEUS:
    // case MONS_XTAHUA:
    // case MONS_TIAMAT:
    // case MONS_BORIS:
    // case MONS_MURRAY:
    // case MONS_TERENCE:
    // case MONS_JESSICA:
    // case MONS_SIGMUND:
    // case MONS_EDMUND:
    // case MONS_PSYCHE:
    // case MONS_DONALD:
    // case MONS_MICHAEL:
    // case MONS_JOSEPH:
    // case MONS_ERICA:
    // case MONS_JOSEPHINE:
    // case MONS_HAROLD:
    // case MONS_NORBERT:
    // case MONS_JOZEF:
    // case MONS_AGNES:
    // case MONS_MAUD:
    // case MONS_LOUISE:
    // case MONS_FRANCIS:
    // case MONS_FRANCES:
    // case MONS_RUPERT:
    // case MONS_WAYNE:
    // case MONS_DUANE:
    // case MONS_NORRIS:
    // case MONS_FREDERICK:
    // case MONS_MARGERY:
    // case MONS_MNOLEG:
    // case MONS_LOM_LOBON:
    // case MONS_CEREBOV:
    // case MONS_GLOORX_VLOQ:
    // case MONS_GERYON:
    // case MONS_DISPATER:
    // case MONS_ASMODEUS:
    // case MONS_ERESHKIGAL:

            {
                mitm[obj].sub_type = CORPSE_SKELETON;
                mitm[obj].special = 200;
                mitm[obj].colour = LIGHTGREY;
            }

                turn_corpse_into_skeleton(mitm[obj]);

                        {
                            mitm[objl].sub_type = CORPSE_SKELETON;
                            mitm[objl].special  = 200;
                            mitm[objl].colour   = LIGHTGREY;
                        }

                            turn_corpse_into_skeleton(mitm[objl]);

    // should make zombies decay into skeletons

    // Should make zombies decay into skeletons?

        if (is_animatable_corpse(item) &&
            (class_allowed == CORPSE_BODY || item.sub_type == CORPSE_SKELETON))

        if (is_animatable_corpse(item)
            && (class_allowed == CORPSE_BODY
                || item.sub_type == CORPSE_SKELETON))

        // one glyph for each monster

        // One glyph for each monster.

            cprintf( stringize_glyph(glyph).c_str() );

            // XXX: Hack to make the death cob (%) show up correctly.
            if (glyph == '%')
                cprintf("%%");
            else
                cprintf( stringize_glyph(glyph).c_str() );

                // NOTE: in os x, light versions of foreground colors are OK,
                // but not background colors.  So stick wth standards.

            // NOTE: In os x, light versions of foreground colors are OK,
            //       but not background colors.  So stick wth standards.

        // potentially nasty surprise, but very rare

        // Potentially nasty surprise, but very rare.

        // slightly out of depth monsters are more common:

        // Slightly out of depth monsters are more common:

        {

        }

        // we'll try 1000 times for a good spot

        // We'll try 1000 times for a good spot.

            // occupied?

            // Occupied?

            // don't generate monsters on top of teleport traps
            // (how do they get there?)

            // Don't generate monsters on top of teleport traps.
            // (How do they get there?)

    // now, actually create the monster (wheeee!)

    // Now, actually create the monster. (Wheeee!)

    // link monster into monster grid

    // Link monster into monster grid.

    // generate a brand shiny new monster, or zombie

    // Generate a brand shiny new monster, or zombie.

    int zombie_size = 0;
    bool ignore_rarity = false;
    monster_type cls  = MONS_PROGRAM_BUG;

    int zombie_size        = 0;
    bool ignore_rarity     = false;
    monster_type cls       = MONS_PROGRAM_BUG;

    // set size based on zombie class (cs)

    // Set size based on zombie class (cs).

            // this should NEVER happen.

            // This should NEVER happen.

    // that is, random creature from which to fashion undead

    // That is, random creature from which to fashion undead.

        // how OOD this zombie can be.

        // How OOD this zombie can be.

        // pick an appropriate creature to make a zombie out of,

        // Pick an appropriate creature to make a zombie out of,

            // on certain branches, zombie creation will fail if we use

            // On certain branches, zombie creation will fail if we use

            // don't make out-of-rarity zombies when we don't have to

            // Don't make out-of-rarity zombies when we don't have to.

            // if skeleton, monster must have a skeleton

            // If skeleton, monster must have a skeleton.

            // size must match, but you can make a spectral thing out

            // Size must match, but you can make a spectral thing out

            // hack -- non-dungeon zombies are always made out of nastier
            // monsters

            // Skeletal or icy draconians shouldn't be coloured.
            // How could you tell?
            if ((cs == MONS_SKELETON_SMALL || cs == MONS_SIMULACRUM_SMALL)
                && mons_genus(cls) == MONS_DRACONIAN
                && cls != MONS_DRACONIAN)
            {
                cls = MONS_DRACONIAN;
            }
            // Hack -- non-dungeon zombies are always made out of nastier
            // monsters.

            // check for rarity.. and OOD - identical to mons_place()

            // Check for rarity.. and OOD - identical to mons_place()

            // every so often, we'll relax the OOD restrictions.  Avoids

            // Every so often, we'll relax the OOD restrictions.  Avoids

/*
 * Finds a square for a monster of the given class, pathfinding
 * through only contiguous squares of habitable terrain.
 */

// Finds a square for a monster of the given class, pathfinding
// through only contiguous squares of habitable terrain.

    // get the drawbacks, not the benefits...
    // (to prevent e.g. demon-scumming)

    // Get the drawbacks, not the benefits... (to prevent e.g. demon-scumming).

    // assume all player summoning originates from player x,y

    // Assume all player summoning originates from player x,y.

    {

                // add point to list of good points

                // Add point to list of good points.

        }                       // end "for count_y"
    }                           // end "for count_x"

        }

}                               // end empty_surrounds()

}

        return false;

        return (false);

    return true;

    return (true);

            : (_scan_mon_inv_randarts(mon, RAP_LEVITATE) > 0) ? FL_LEVITATE
                                                              : FL_NONE);

                : (_scan_mon_inv_randarts(mon, RAP_LEVITATE) > 0) ? FL_LEVITATE
                                                                  : FL_NONE);

    case MONS_ZOMBIE_SMALL: case MONS_ZOMBIE_LARGE:
        result += " zombie"; break;
    case MONS_SKELETON_SMALL: case MONS_SKELETON_LARGE:
        result += " skeleton"; break;
    case MONS_SIMULACRUM_SMALL: case MONS_SIMULACRUM_LARGE:
        result += " simulacrum"; break;
    default: break;

    case MONS_ZOMBIE_SMALL:
    case MONS_ZOMBIE_LARGE:
        result += " zombie";
        break;
    case MONS_SKELETON_SMALL:
    case MONS_SKELETON_LARGE:
        result += " skeleton";
        break;
    case MONS_SIMULACRUM_SMALL:
    case MONS_SIMULACRUM_LARGE:
        result += " simulacrum";
        break;
    default:
        break;

    return mons_habitat_by_type(
        mons_is_zombified(m)? mons_zombie_base(m) : m->type );

    return mons_habitat_by_type( mons_is_zombified(m) ? mons_zombie_base(m)
                                                      : m->type );

        {

        }

// "another lava thing" has no stats!  (GDL)
//    case MONS_ANOTHER_LAVA_THING:

void turn_corpse_into_skeleton(item_def &corpse, int time = 200);

}
// Vampire draining corpses currently leaves them a time of 90, while the
// default time is 200. I'm not sure whether this is for balancing reasons
// or just an arbitrary difference. (jpeg)
void turn_corpse_into_skeleton(item_def &corpse, int time)
{
    ASSERT(corpse.base_type == OBJ_CORPSES && corpse.sub_type == CORPSE_BODY);
    // Some monsters' corpses lack the structure to leave skeletons behind.
    if (!mons_skeleton( corpse.plus ))
        return;
    // While it is possible to distinguish draconian corpses by colour, their
    // skeletons are indistinguishable.
    if (mons_genus(corpse.plus) == MONS_DRACONIAN
        && corpse.plus != MONS_DRACONIAN)
    {
        corpse.plus = MONS_DRACONIAN;
    }
    corpse.sub_type = CORPSE_SKELETON;
    corpse.special  = time;
    corpse.colour   = LIGHTGREY;

// assumes the item is equipped in the first place!

// NOTE: Assumes the item is equipped in the first place!

    // weapons and staves are only truly equipped if wielded

    // Weapons and staves are only truly equipped if wielded.

    // cursed armour and rings are only truly equipped if *not* wielded

    // Cursed armour and rings are only truly equipped if *not* wielded.

// returns whether there's any action you can take with an item in inventory
// apart from dropping it

// Returns whether there's any action you can take with an item in inventory
// apart from dropping it.

    // vampires can drain corpses

    // Vampires can drain corpses.

        // misc. items/rods can always be evoked, cursed or not

        // Misc. items/rods can always be evoked, cursed or not.

        // you can't unwield/fire a wielded cursed weapon/staff
        // but cursed armour and rings can be unwielded without problems

        // You can't unwield/fire a wielded cursed weapon/staff
        // but cursed armour and rings can be unwielded without problems.

    // mummies can't do anything with food or potions

    // Mummies can't do anything with food or potions.

    // in all other cases you can use the item in some way

    // In all other cases you can use the item in some way.

    // clean the relevant parts of the object:

    // Clean the relevant parts of the object.

            mitm[o].quantity = 0;

            mitm[o].quantity  = 0;

static int count_nonsquelched_items( int obj )

static int _count_nonsquelched_items( int obj )

    while ( obj != NON_ITEM )

    while (obj != NON_ITEM)

        if ( !_invisible_to_player(mitm[obj]) )

        if (!_invisible_to_player(mitm[obj]))

/* Fill items with the items on a square.
   Squelched items (marked with =k) are ignored, unless
   the square contains *only* squelched items, in which case they
   are included. If force_squelch is true, squelched items are
   never displayed.
 */

// Fill items with the items on a square.
// Squelched items (marked with =k) are ignored, unless
// the square contains *only* squelched items, in which case they
// are included. If force_squelch is true, squelched items are
// never displayed.

    const bool have_nonsquelched = (force_squelch ||
                                    count_nonsquelched_items(obj));

    const bool have_nonsquelched = (force_squelch
                                    || _count_nonsquelched_items(obj));

    /* loop through the items */

    // Loop through the items.

        /* add them to the items list if they qualify */

        // Add them to the items list if they qualify.

        {

        }

static int item_name_specialness(const item_def& item)

static int _item_name_specialness(const item_def& item)

    if (item.base_type != OBJ_WEAPONS && item.base_type != OBJ_ARMOUR &&
        item.base_type != OBJ_MISSILES)

    if (item.base_type != OBJ_WEAPONS && item.base_type != OBJ_ARMOUR
        && item.base_type != OBJ_MISSILES)
    {

    }

    // Missiles don't get name descriptors.

        return 0;               // missiles don't get name descriptors

        return 0;

    // XXX Fixedarts and unrandarts might upset the apple-cart, though.

    // XXX: Fixedarts and unrandarts might upset the apple-cart, though.

        if ( verbose )

        if (verbose)

                                  (10 - item_name_specialness(*(items[i]))) );

                                  (10 - _item_name_specialness(*(items[i]))) );

                switch ( specialness )

                switch (specialness)

                case 2: out_string += "<yellow>"; break; // artefact
                case 1: out_string += "<white>"; break;  // glowing/runed

                case 2: out_string += "<yellow>";   break; // artefact
                case 1: out_string += "<white>";    break; // glowing/runed

static int first_corpse_monnum(int x, int y)

static int _first_corpse_monnum(int x, int y)

    // Actually, it would be easy to add the monster type to a corpse
    // (or to another item) by setting orig_monnum when the monster dies
    // (already done for unique monsters to get named zombies), but
    // personally, I rather like the way the player can't tell where an
    // item came from if he just finds it lying on the floor. (jpeg)

static std::string milestone_rune(const item_def &item)

static std::string _milestone_rune(const item_def &item)

static void milestone_check(const item_def &item)

static void _milestone_check(const item_def &item)

        mark_milestone("rune", milestone_rune(item));

        mark_milestone("rune", _milestone_rune(item));

static void check_note_item(item_def &item)

static void _check_note_item(item_def &item)

    int monnum = first_corpse_monnum(x, y);

    int monnum = _first_corpse_monnum(x, y);

        milestone_check(item);

        _milestone_check(item);

    item.orig_monnum = first_corpse_monnum(x, y);

    item.orig_monnum = _first_corpse_monnum(x, y);

        check_note_item(item);

        _check_note_item(item);

        milestone_check(item);

        _milestone_check(item);

    const int num_nonsquelched = count_nonsquelched_items(o);

    const int num_nonsquelched = _count_nonsquelched_items(o);

static int userdef_find_free_slot(const item_def &i)

static int _userdef_find_free_slot(const item_def &i)

    int slot = userdef_find_free_slot(i);

    int slot = _userdef_find_free_slot(i);

                check_note_item(mitm[obj]);

                _check_note_item(mitm[obj]);

    check_note_item(item);

    _check_note_item(item);

    // must be a valid reference to a valid object

    // Must be a valid reference to a valid object.

static std::string drop_menu_invstatus(const Menu *menu)

static std::string _drop_menu_invstatus(const Menu *menu)

static std::string drop_menu_title(const Menu *menu, const std::string &oldt)

static std::string _drop_menu_title(const Menu *menu, const std::string &oldt)

    std::string res = drop_menu_invstatus(menu) + " " + oldt;

    std::string res = _drop_menu_invstatus(menu) + " " + oldt;

static std::string drop_selitem_text( const std::vector<MenuEntry*> *s )

static std::string _drop_selitem_text( const std::vector<MenuEntry*> *s )

static bool drop_item_order(const SelItem &first, const SelItem &second)

static bool _drop_item_order(const SelItem &first, const SelItem &second)

                                     drop_menu_title, true, true, 0,
                                     &Options.drop_filter, drop_selitem_text,

                                     _drop_menu_title, true, true, 0,
                                     &Options.drop_filter, _drop_selitem_text,

    std::sort( tmp_items.begin(), tmp_items.end(), drop_item_order );

    std::sort( tmp_items.begin(), tmp_items.end(), _drop_item_order );

static inline std::string autopickup_item_name(const item_def &item)

static inline std::string _autopickup_item_name(const item_def &item)

static bool is_denied_autopickup(const item_def &item, std::string &iname)

static bool _is_denied_autopickup(const item_def &item, std::string &iname)

        iname = autopickup_item_name(item);

        iname = _autopickup_item_name(item);

    {

    }

static bool is_forced_autopickup(const item_def &item, std::string &iname)

static bool _is_forced_autopickup(const item_def &item, std::string &iname)

        iname = autopickup_item_name(item);

        iname = _autopickup_item_name(item);

    {

    }

             || is_forced_autopickup(item, itemname))

             || _is_forced_autopickup(item, itemname))

            && !is_denied_autopickup(item, itemname));

            && !_is_denied_autopickup(item, itemname));

static void do_autopickup()

static void _do_autopickup()

    do_autopickup();

    _do_autopickup();

static bool find_subtype_by_name(item_def &item,
                                 object_class_type base_type, int ntypes,
                                 const std::string &name)

static bool _find_subtype_by_name(item_def &item,
                                  object_class_type base_type, int ntypes,
                                  const std::string &name)

            if (find_subtype_by_name(item, static_cast<object_class_type>(i),
                                     max_subtype[i], name))

            if (_find_subtype_by_name(item, static_cast<object_class_type>(i),
                                      max_subtype[i], name))

    {
        find_subtype_by_name(item, base_type, max_subtype[base_type], name);
    }

        _find_subtype_by_name(item, base_type, max_subtype[base_type], name);

void inscribe_item();

void prompt_inscribe_item();

void inscribe_item()

void prompt_inscribe_item()

    char buf[79];

    mpr( you.inv[item_slot].name(DESC_INVENTORY).c_str(), MSGCH_EQUIPMENT );
    mpr( "Inscribe with what? ", MSGCH_PROMPT );
    if (!cancelable_get_line(buf, sizeof buf))
    {
        // strip spaces from the end
        for (int i = strlen(buf) - 1; i >= 0; i--)
        {
            if (isspace( buf[i] ))
                buf[i] = 0;
            else
                break;
        }

        you.inv[item_slot].inscription = std::string(buf);
        you.wield_change  = true;
    }
    else
    {
        canned_msg(MSG_OK);
    }

    inscribe_item(you.inv[item_slot]);

        // no switching necessary

        // No switching necessary.

    // look for a butchering implement in your pack

    // Look for a butchering implement in your pack.

        if (obj.base_type == OBJ_CORPSES)

        if (obj.base_type == OBJ_CORPSES && obj.sub_type == CORPSE_BODY)

             << "ground or into shallow water then you could " << verb
             << " " << pronoun  << ".";

             << "ground then you could " << verb << " " << pronoun  << ".";

            // Carried skeletons are not destroyed.

                continue;       // carried skeletons are not destroyed

                continue;

            you.inv[i].sub_type   = CORPSE_SKELETON;
            you.inv[i].special    = 0;
            you.inv[i].colour     = LIGHTGREY;

            turn_corpse_into_skeleton(you.inv[i]);

                {
                    it.sub_type = CORPSE_SKELETON;
                    it.special  = 200;
                    it.colour   = LIGHTGREY;
                }

                    turn_corpse_into_skeleton(it);

void inscribe_item( item_def &item );

void inscribe_item(item_def &item)
{
    mpr(item.name(DESC_INVENTORY).c_str(), MSGCH_EQUIPMENT);
    std::string ainscrip;
    if (is_random_artefact(item))
        ainscrip = _randart_auto_inscription(item);
    // Only allow autoinscription if we don't have all the text
    // already.
    const bool autoinscribe =
            is_random_artefact(item)
            && !ainscrip.empty()
            && item.inscription.find(ainscrip) == std::string::npos;

    mprf( MSGCH_PROMPT, "Inscribe with what%s? ",
          autoinscribe ? " ('a' to autoinscribe)" : "" );

    char buf[79];
    if (!cancelable_get_line(buf, sizeof buf))
    {
        // Strip spaces from the end.
        for (int i = strlen(buf) - 1; i >= 0; i--)
        {
            if (isspace( buf[i] ))
                buf[i] = 0;
            else
                break;
        }
        if (autoinscribe && buf[1] == 0 && (buf[0] == 'a' || buf[0] == 'A'))
        {
            // Remove previous randart inscription
            _trim_randart_inscrip(item);
            if (!item.inscription.empty())
                item.inscription += ", ";
            item.inscription += ainscrip;
        }
        else
            item.inscription = std::string(buf);
        mpr(item.name(DESC_INVENTORY).c_str(), MSGCH_EQUIPMENT);
        you.wield_change  = true;
    }
    else
    {
        canned_msg(MSG_OK);
    }
}

// monster cannot be affected in these states
// (all results of Recite, plus friendly + stupid;
// note that berserk monsters are also hasted)

// Monsters cannot be affected in these states.
// (All results of Recite, plus friendly + stupid;
//  note that berserk monsters are also hasted.)

            corpse.sub_type = CORPSE_SKELETON;
            corpse.special  = 90;
            corpse.colour   = LIGHTGREY;

            turn_corpse_into_skeleton(corpse, 90);

        {
            corpse.sub_type = CORPSE_SKELETON;
            corpse.special = 90;
            corpse.colour = LIGHTGREY;
        }

            turn_corpse_into_skeleton(corpse, 90);

        StashTrack.update_stash(); // Don't stash-track this corpse anymore.

        inscribe_item();

        prompt_inscribe_item();