{

        }

        {

        }

    if ( level < 10 && level > 0 )

    if (level < 10 && level > 0)

    if ( hunger < 0 )

    if (hunger < 0)

                            int &god_discard, int &uncastable_discard)

                            int &god_discard, int &uncastable_discard,
                            bool avoid_known = false)

            continue;
        if (avoid_known && you.seen_spell[spell])

                            int &god_discard, int &uncastable_discard)

                            int &god_discard, int &uncastable_discard,
                            bool avoid_known = false)

                    god, avoid_uncastable, god_discard, uncastable_discard);

                    god, avoid_uncastable, god_discard, uncastable_discard,
                    avoid_known);

                            int &god_discard, int &uncastable_discard)

                            int &god_discard, int &uncastable_discard,
                            bool avoid_known = false)

                    god, avoid_uncastable, god_discard, uncastable_discard);

                    god, avoid_uncastable, god_discard, uncastable_discard,
                    avoid_known);

                        junk1, junk2);

                        junk1, junk2, true);

        if(spell_list.empty())

        if (spell_list.empty())

    int apt_weights[SPTYP_LAST_EXPONENT];

    memset(apt_weights,   0, SPTYP_LAST_EXPONENT * sizeof(int));

    if (completely_random)

    if (!completely_random)

        for (int i = 0; i < num_discs; i++)
        {
            skill_weights[i] = 1;
            apt_weights[i]   = 1;
        }
    }
    else
    {

            skill_weights[i] = you.skills[skill];
            int apt = species_skills(skill, you.species);
            apt_weights[i] = (int) ( (1.0 / (double) apt) * 1000000.0);

            skill_weights[i] = you.skills[skill]
                               * 100 / species_skills(skill, you.species);

        {
            for (int i = 0; i < num_discs; i++)
                skill_weights[i] = apt_weights[i];
        }

            completely_random = true;
    }
    if (completely_random)
    {
        for (int i = 0; i < num_discs; i++)
            skill_weights[i] = 1;

        disc2 = ok_discs[choose_random_weighted(apt_weights,
                                                apt_weights + num_discs)];

        disc2 = ok_discs[choose_random_weighted(skill_weights,
                                                skill_weights + num_discs)];

    while(disciplines_conflict(disc1, disc2));

    while (disciplines_conflict(disc1, disc2));

/*

*/

        case OBJ_BOOKS:    type_wanted = _acquirement_book_subtype();    break;

        case OBJ_BOOKS:
            // type_wanted = _acquirement_book_subtype();    break;
            return OBJ_RANDOM;

}
// The weight of a spell is defined as the average of all disciplines'
// skill levels minus the doubled spell level.
static int _spell_weight(spell_type spell)
{
    ASSERT(spell != SPELL_NO_SPELL);
    int weight = 0;
    unsigned int disciplines = get_spell_disciplines(spell);
    int count = 0;
    for (int i = 0; i <= SPTYP_LAST_EXPONENT; i++)
    {
        int disc = 1 << i;
        if (disciplines & disc)
        {
            int skill = you.skills[spell_type2skill(disc)]
                        * 100 / species_skills(i, you.species);
            weight += skill;
            count++;
        }
    }
    ASSERT(count > 0);
    int level = spell_difficulty(spell);
    return std::max(0, weight/count - 2*level);
}
// When randomly picking a book for acquirement, use the sum of the
// weights of all unknown spells in the book.
static int _book_weight(int book)
{
    ASSERT(book >= 0 && book <= MAX_NORMAL_BOOK);
    if (book == BOOK_HEALING)
        return 0;
    int total_weight = 0;
    for (int i = 0; i < SPELLBOOK_SIZE; i++)
    {
        spell_type stype = which_spell_in_book(book, i);
        if (stype == SPELL_NO_SPELL)
            continue;
        // Skip over spells already seen.
        if (you.seen_spell[stype])
            continue;
        total_weight += _spell_weight(stype);
    }
    return (total_weight);

    // Non-normal books (i.e. manuals/book of destruction) are rare enough
    // without turning them into randart books.
    if (book.sub_type > MAX_NORMAL_BOOK)
        return;

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

    int choice = NUM_BOOKS;

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

    bool knows_magic = false;
    // Manuals are too useful for Xom, and useless when gifted from Sif Muna.
    if (agent != GOD_XOM && agent != GOD_SIF_MUNA)
    {
        int weights[NUM_SKILLS];
        int magic_weights = 0;
        int other_weights = 0;

    book.sub_type = choice;

        for (int i = 0; i < NUM_SKILLS; i++)
        {
            if (i > SK_UNARMED_COMBAT && i < SK_SPELLCASTING)
            {
                weights[i] = 0;
                continue;
            }
            weights[i] = you.skills[i]
                         * 100 / species_skills(i, you.species);
            if (i >= SK_SPELLCASTING && i <= SK_POISON_MAGIC)
                magic_weights += weights[i];
            else
                other_weights += weights[i];
        }
        if (x_chance_in_y(other_weights, magic_weights + other_weights))
        {
            choice = BOOK_MANUAL;
            if (magic_weights > 0)
                knows_magic = true;
        }
    }

    if (choice == NUM_BOOKS)
    {
        choice = random_choose_weighted(
                    60, BOOK_RANDART_THEME,
                    24, book.sub_type,
                level == -1      ? 0 :
           agent == GOD_SIF_MUNA ? 6 : 1, BOOK_RANDART_LEVEL,
                    0);
    }

        mpr("Make book themed randart.");
        book.sub_type = choice;

        mpr("Make book fixed level randart.");
        book.sub_type = choice;

        int weights[SK_POISON_MAGIC - SK_CONJURATIONS + 1];

        mpr("Make book manual.");
        // The Tome of Destruction is rare enough we won't change this.
        if (book.sub_type == BOOK_DESTRUCTION)
            return;
        int weights[NUM_SKILLS];

        for (int i = SK_CONJURATIONS; i <= SK_POISON_MAGIC; i++)

        for (int i = 0; i < NUM_SKILLS; i++)

            int w = std::max(0, 24 - you.skills[i])
                * 100 / species_skills(i, you.species);

            if (i > SK_UNARMED_COMBAT && i < SK_SPELLCASTING)
            {
                weights[i] = 0;
                continue;
            }

            weights[i - SK_CONJURATIONS] = w;

            int skill = you.skills[i]
                        * 100 / species_skills(i, you.species);
            int w = (skill < 12) ? skill + 3
                                 : 25 - skill;
            // If we don't know any magic skills, make non-magic skills
            // more likely.
            if (!knows_magic && i < SK_SPELLCASTING)
                w *= 2;
            weights[i] = w;

        skill += SK_CONJURATIONS;

        ASSERT(false);

    {
        mpr("Make book normal spellbook.");
        // Pick a random spellbook according to unknown spells contained.
        int weights[MAX_NORMAL_BOOK+1];
        for (int bk = 0; bk <= MAX_NORMAL_BOOK; bk++)
            weights[bk] = _book_weight(bk);
        book.sub_type = choose_random_weighted(weights,
                                               weights + ARRAYSZ(weights));

    }