static int _average_hp(const monsters* mon)
{
    const monsterentry* me = get_monster_data(mon->type);
    return me->hpdice[0] * (me->hpdice[1] + me->hpdice[2]>>1) + me->hpdice[3];
}

    const int xp1 = mons_type_hit_dice(m1->type);
    const int xp2 = mons_type_hit_dice(m2->type);

    const int xp1 = _average_hp(m1);
    const int xp2 = _average_hp(m2);

_print_next_monster_desc(const std::vector<monsters*>& mons,
                         int& start)

_print_next_monster_desc(const std::vector<monsters*>& mons, int& start)

    // skip forward to the end of the range of identical monsters
    monsters* m1 = mons[start];
    unsigned int cur = start;
    while (true)

    // skip forward to past the end of the range of identical monsters
    unsigned int end;
    for (end=start+1; end < mons.size(); ++end)

        if (cur + 1 == mons.size()) break;
        // If m1 < m2, they can't be "equal"
        // (and since array is sorted, they are otherwise "equal")
        if (_by_attitude_and_experience(m1, mons[cur])) break;
        cur += 1;

        // Array is sorted, so if !(m1 < m2), m1 and m2 are "equal"
        if (_by_attitude_and_experience(mons[start], mons[end]))
            break;

    // Postcondition: all monsters in [start, end) are "equal"

    // start and cur are "equal" monsters.  It shouldn't matter
    // which one we choose in that range.  I will choose start.

    // Print one of the monsters we've found; shouldn't matter which.

        const monsters* mon = mons[start]; // arbitrary

        get_mons_glyph(m1, &glyph, &glyph_color);

        get_mons_glyph(mon, &glyph, &glyph_color);

        const int count = (cur - start + 1);

        const int count = (end - start);

            std::string name = mons_type_name(m1->type, DESC_CAP_A);

            std::string name = mons_type_name(mon->type, DESC_CAP_A);

            std::string name = pluralise(mons_type_name(m1->type, DESC_PLAIN));

            std::string name = pluralise(mons_type_name(mon->type, DESC_PLAIN));

#if DEBUG_DIAGNOSTICS
        cprintf(" av%d %d/%d", _average_hp(mon), mon->hit_points, mon->max_hit_points);
#endif

            const mon_attitude_type att = mons_attitude(m1);

            const mon_attitude_type att = mons_attitude(mon);

    // Increment start to the next un-described monster
    start = cur + 1;

    // Set start to the next un-described monster
    start = end;