bool is_memorised(spell_type spell);

        if (origin_is_acquirement(book) ||
            origin_is_god_gift(book, &god) && god == GOD_SIF_MUNA)

        if (origin_is_acquirement(book)
            || origin_is_god_gift(book, &god) && god == GOD_SIF_MUNA)

    set_ident_flags( book, ISFLAG_IDENT_MASK);

static bool _is_memorised(spell_type spell)

bool is_memorised(spell_type spell)

    {

    }

bool make_book_level_randart(item_def &book, int level,
                             int num_spells)

bool make_book_level_randart(item_def &book, int level, int num_spells)

        // Stuf parameters into book.plus and book.plus2, then call

        // Stuff parameters into book.plus and book.plus2, then call

        if (avoid_memorised[spell_pos] && _is_memorised(spell))

        if (avoid_memorised[spell_pos] && is_memorised(spell))

    do {

    do
    {

    } while(disciplines_conflict(disc1, disc2));

    }
    while(disciplines_conflict(disc1, disc2));

            else if (!_is_memorised(spell))

            else if (!is_memorised(spell))

    while(book_pos < num_spells && max_levels > 0 && spells_left > 0)

    while (book_pos < num_spells && max_levels > 0 && spells_left > 0)

                    && !(grid_destroys_items(grd(you.pos()))))

                    && !grid_destroys_items(grd(you.pos())))

    bool redo = !origin_is_god_gift(book, &god) || god != GOD_XOM;

    bool redo = (!origin_is_god_gift(book, &god) || god != GOD_XOM);

    // This already is a randart.

    // This item already is a randart.

        while (book_rarity(item.sub_type) == 100);

        while (item.sub_type == BOOK_HEALING);

                                    //     because of BCR acquirement hack

                                    // because of BCR acquirement hack

           || (force_class == OBJ_WEAPONS || force_class == OBJ_ARMOUR
                   || force_class == OBJ_MISSILES)
               && force_type != OBJ_RANDOM);

           || force_type != OBJ_RANDOM
              && (force_class == OBJ_WEAPONS || force_class == OBJ_ARMOUR
                  || force_class == OBJ_MISSILES));

        return(true);

        return (true);

            && sub_type != BOOK_DESTRUCTION
            && sub_type != BOOK_MANUAL)

               && sub_type != BOOK_DESTRUCTION
               && sub_type != BOOK_MANUAL)

    return (base_type == OBJ_BOOKS?   sub_type                             :
            base_type == OBJ_STAVES?  sub_type + NUM_BOOKS - STAFF_SMITING :
            -1);

    return (base_type == OBJ_BOOKS  ? sub_type                             :
            base_type == OBJ_STAVES ? sub_type + NUM_BOOKS - STAFF_SMITING
                                    : -1);

                    || ch == "artefact" || ch == "artifact")

                || ch == "artefact" || ch == "artifact")
            {

            }

                    || ch == "ego_armour")

                     || ch == "ego_armour")
            {

            }

                    || ch == "ego_weapon" || ch == "ego weapons"
                    || ch == "ego_weapons")

                     || ch == "ego_weapon" || ch == "ego weapons"
                     || ch == "ego_weapons")
            {

            }

                    if (best_any >= SK_FIGHTING
                                && best_any <= SK_STAVES)

                    if (best_any >= SK_FIGHTING && best_any <= SK_STAVES)

                while (book_rarity(type_wanted) == 100)

                while (type_wanted == BOOK_HEALING)

    // Non-normal books are rare enough without turning them into
    // randart books.

    // Non-normal books (i.e. manuals/book of destruction) are rare enough
    // without turning them into randart books.

        {

        }

    int choice_weights[4] = {
                               55, // fixed themed
                               24, // leave alone
             level == -1 ? 0 : 12, // fixed level
        agent == GOD_XOM ? 0 :  6, // manual (too useful for Xom)
        };

    int choice = random_choose_weighted(
            55, BOOK_RANDART_THEME,
            24, book.sub_type,
            level == -1 ? 0 : 12, BOOK_RANDART_LEVEL,
       agent == GOD_XOM ? 0 : 6, BOOK_MANUAL, // too useful for Xom
            0);

    int choice = choose_random_weighted(choice_weights, choice_weights + 4);

    // No changes.
    if (choice == book.sub_type)
        return;

    switch(choice)

    book.sub_type = choice;
    switch (choice)

    case 0:

    case BOOK_RANDART_THEME:

        break;
    case 1:
        // Leave alone

    case 2:

    case BOOK_RANDART_LEVEL:

    case 3:

    case BOOK_MANUAL:

    const bool god_agent = agent > GOD_NO_GOD && agent < NUM_GODS;

        if (god_agent)

        if (agent > GOD_NO_GOD && agent < NUM_GODS)

            int want_arts = class_wanted == OBJ_BOOKS ? 0 : 1;

            int want_arts = (class_wanted == OBJ_BOOKS ? 0 : 1);

            }
            // Sif Muna shouldn't gift Vehumet or Kiku's special books.
            // (The spells therein are still fair game for randart books.)
            if (agent == GOD_SIF_MUNA
                && doodad.sub_type >= MIN_GOD_ONLY_BOOK
                && doodad.sub_type <= MAX_GOD_ONLY_BOOK)
            {
                ASSERT(doodad.base_type == OBJ_BOOKS);
                // Try again.
                destroy_item(thing_created);
                thing_created = NON_ITEM;
                continue;

                    && !thing.base_type == OBJ_BOOKS)

                    && thing.base_type != OBJ_BOOKS)

void append_spells(std::string &desc, const item_def &item);

// Adds a list of all spells contained in a book or rod to its
// description string.
void append_spells(std::string &desc, const item_def &item)
{
    if (!item.has_spells())
        return;
    desc += "$$Spells                             Type                      Level$";
    for (int j = 0; j < 8; j++)
    {
        spell_type stype = which_spell_in_book(item, j);
        if (stype == SPELL_NO_SPELL)
            continue;
        std::string name = (is_memorised(stype)) ? "*" : "";
                    name += spell_title(stype);
        desc += name;
        for (unsigned int i = 0; i < 35 - name.length(); i++)
             desc += " ";
        name = "";
        if (item.base_type == OBJ_STAVES)
            name += "Evocations";
        else
        {
            bool already = false;
            for (int i = 0; i <= SPTYP_LAST_EXPONENT; i++)
            {
                if (spell_typematch( stype, 1 << i ))
                {
                    if (already)
                        name += "/" ;
                    name += spelltype_name( 1 << i );
                    already = true;
                }
            }
        }
        desc += name;
        for (unsigned int i = 36; i < 65 - name.length(); i++)
             desc += " ";
        char sval[3];
        itoa( spell_difficulty( stype ), sval, 10 );
        desc += sval;
        desc += "$";
    }
}

                         && item.base_type != OBJ_ARMOUR))

                         && item.base_type != OBJ_ARMOUR
                         && item.base_type != OBJ_BOOKS))

    // Weapons, armour, jewellery might be artefacts.

    // Weapons, armour, jewellery, books might be artefacts.

        break;
    case OBJ_BOOKS:
        if (!player_can_read_spellbook( item ))
        {
            description << "$This book is beyond your current level of "
                           "understanding.";
        }
        else if (!verbose && is_random_artefact( item ))
        {
            append_spells( desc, item );
            if (desc.empty())
                need_extra_line = false;
            else
                description << desc;
        }

        break;
    case OBJ_BOOKS:
        if (!player_can_read_spellbook( item ))
        {
            description << "$This book is beyond your current level of "
                           "understanding.";
        }

}
// Adds a list of all spells contained in a book or rod to its
// description string.
static void _append_spells(std::string &desc, const item_def &item)
{
    if (!item.has_spells())
        return;
    desc += "$$Spells                             Type                      Level$";
    for (int j = 0; j < 8; j++)
    {
        spell_type stype = which_spell_in_book(item, j);
        if (stype == SPELL_NO_SPELL)
            continue;
        std::string name = spell_title(stype);
        desc += name;
        for (unsigned int i = 0; i < 35 - name.length(); i++)
             desc += " ";
        name = "";
        if (item.base_type == OBJ_STAVES)
            name += "Evocations";
        else
        {
            bool already = false;
            for (int i = 0; i <= SPTYP_LAST_EXPONENT; i++)
            {
                if (spell_typematch( stype, 1 << i ))
                {
                    if (already)
                        name += "/" ;
                    name += spelltype_name( 1 << i );
                    already = true;
                }
            }
        }
        desc += name;
        for (unsigned int i = 36; i < 65 - name.length(); i++)
             desc += " ";
        char sval[3];
        itoa( spell_difficulty( stype ), sval, 10 );
        desc += sval;
        desc += "$";
    }

                        _append_spells(desc, mitm[thing_created]);

                        append_spells(desc, mitm[thing_created]);

static bool dump_item_origin(const item_def &item, int value)

static bool _dump_item_origin(const item_def &item, int value)

            && (is_random_artefact(item) || is_fixed_artefact(item))
            && item_ident(item, ISFLAG_KNOW_PROPERTIES))

        && (is_random_artefact(item) || is_fixed_artefact(item))
        && item_ident(item, ISFLAG_KNOW_PROPERTIES))
    {

    }

            && item.sub_type == MISC_RUNE_OF_ZOT)

        && item.sub_type == MISC_RUNE_OF_ZOT)
    {

    }

            && item_is_rod(item))

        && item_is_rod(item))
    {

    }

            && !item_is_rod(item))

        && !item_is_rod(item))
    {

    }

                            && dump_item_origin(you.inv[j], ival))

                            && _dump_item_origin(you.inv[j], ival))