}
// Inflict any enchantments the parent slime has on its offspring,
// leaving durations unchanged I guess. -cao
static void _split_ench_durations(monsters * initial_slime, monsters * split_off)
{
    mon_enchant_list::iterator i;
    for( i=initial_slime->enchantments.begin();
        i!=initial_slime->enchantments.end(); ++i)
    {
        split_off->add_ench(i->second);
    }
}
// What to do about any enchantments these two slimes may have?
// For now we are averaging the durations -cao
static void _merge_ench_durations(monsters * initial_slime, monsters * merge_to)
{
    mon_enchant_list::iterator i;
    int initial_count = initial_slime->number;
    int merge_to_count = merge_to->number;
    int total_count = initial_count + merge_to_count;
    for (i = initial_slime->enchantments.begin();
         i != initial_slime->enchantments.end(); ++i)
    {
        // does the other slime have this enchantment as well?
        mon_enchant temp = merge_to->get_ench(i->first);
        // If not use duration 0 for their part of the average.
        int duration = temp.ench == ENCH_NONE ? 0 : temp.duration;
        i->second.duration = (i->second.duration * initial_count
                              + duration * merge_to_count)/total_count;
        if(!i->second.duration)
            i->second.duration=1;
        merge_to->add_ench(i->second);
    }
    for (i = merge_to->enchantments.begin();
         i != merge_to->enchantments.end(); ++i)
    {
        if(initial_slime->enchantments.find(i->first)
           != initial_slime->enchantments.end()
           && i->second.duration > 1)
        {
            i->second.duration = (merge_to_count * i->second.duration)
                                  /total_count;
            merge_to->update_ench(i->second);
        }
    }

    int hd_per_blob = 11;

    monsterentry* entry = get_monster_data(slime->type);
    int base_hd = entry->hpdice[0];

    slime->hit_dice = slime->number * hd_per_blob;

    slime->hit_dice = slime->number * base_hd;

    mprf("Splitting slime at pos %d, %d", thing->pos().x, thing->pos().y);
    mprf("splitting to %d, %d", target.x, target.y);

    // Inflict the new slime with any enchantments on the parent
    _split_ench_durations(thing, new_slime);
    new_slime->attitude = thing->attitude;

    if(you.can_see(thing))
    {
        mprf("%s splits.", thing->name(DESC_CAP_A).c_str());
    }

    mprf("Merging slimes, inital at %d, %d", initial_slime->pos().x, initial_slime->pos().y);
    mprf("Merging to %d, %d", merge_to->pos().x, merge_to->pos().y);

    // Combine enchantment durations
    _merge_ench_durations(initial_slime, merge_to);

    // Overwrite the state of the slime getting merged into because
    // it might have been resting or something.
    merge_to->behaviour = initial_slime->behaviour;
    merge_to->foe = initial_slime->foe;
    behaviour_event(merge_to, ME_EVAL);
    // Messaging
    if(you.can_see(merge_to))
    {
        if(you.can_see(initial_slime))
        {
            mprf("Two slime creatures merge to form %s.",
                 merge_to->name(DESC_NOCAP_A).c_str());
        }
        else
        {
            mprf("A slime creatures suddenly becomes %s.",
                 merge_to->name(DESC_NOCAP_A).c_str());
        }
    }

    // No merging/splitting shapeshifters
    if(mons_is_shapeshifter(thing))
        return false;

    int max_slime_merge = 8;

    int max_slime_merge = 5;

               && other_thing->attitude == thing->attitude)

               && other_thing->attitude == thing->attitude
               && other_thing->is_summoned() == thing->is_summoned())

                if(new_blob_count < max_slime_merge

                if(new_blob_count <= max_slime_merge

    if (!mons_near(monster)
        || mons_is_sleeping(monster)
        || mons_is_submerged(monster))

    // Slime creatures can split while out of sight.
    if ((!mons_near(monster)
         || mons_is_sleeping(monster)
         || mons_is_submerged(monster))
         && monster->mons_species() != MONS_SLIME_CREATURE)

        if (mon.number < 11)
        {
            const char* cardinals[] = {"one", "two", "three", "four", "five",
                                       "six", "seven", "eight", "nine", "ten"};
            result += cardinals[mon.number - 1];
        }
        else
            result += make_stringf("%d", mon.number);

        ASSERT(mon.number <=5);
        const char* cardinals[] = {"", "large ", "very large ",
                                   "enormous ", "titanic "};
        result += cardinals[mon.number - 1];
    }

        result += "-blob ";
    }