monster->seen_context = "";

        monster->seen_context.clear();

    // Abyss, Xom is stimulated in proprotion to the number of

    // Abyss, Xom is stimulated in proportion to the number of

        int num_runes = runes_in_pack();

        const int num_runes = runes_in_pack();

        mprf("Welcome back to %s!",
             branches[you.where_are_you].longname);

        mprf("Welcome back to %s!", branches[you.where_are_you].longname);

    int x,y,i;

    for (x = 0; x < GXM; x++)

    for (int x = 0; x < GXM; x++)

        for (y = 0; y < GYM; y++)

        for (int y = 0; y < GYM; y++)

            i = igrd[x][y];

            int i = igrd[x][y];

    int i,j;

    for (i = 0; i < GXM; i++)
    {
        for (j = 0; j < GYM; j++)
            igrd[i][j] = NON_ITEM;
    }

    igrd.init(NON_ITEM);

    for (i = 0; i < MAX_ITEMS; i++)

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

    // 5. never clean food or Orbs

    // never clean food or Orbs

    int x,y, item, next;

    for (x = 5; x < GXM; x++)

    for (int x = 5; x < GXM; x++)

        for (y = 5; y < GYM; y++)

        for (int y = 5; y < GYM; y++)

            int next;

            for (item = igrd[x][y]; item != NON_ITEM; item = next)

            for (int item = igrd[x][y]; item != NON_ITEM; item = next)

    LOAD_START_GAME,
    LOAD_RESTART_GAME,
    LOAD_ENTER_LEVEL

    LOAD_START_GAME,            // game has just begun
    LOAD_RESTART_GAME,          // loaded savefile
    LOAD_ENTER_LEVEL,           // entered a level for the first time
    LOAD_VISITOR                // Visitor pattern to see all levels

bool load( dungeon_feature_type stair_taken, int load_mode,

bool load( dungeon_feature_type stair_taken, load_mode_type load_mode,

void apply_to_all_dungeons(void (*applicator)());

bool load( dungeon_feature_type stair_taken, int load_mode,

bool load( dungeon_feature_type stair_taken, load_mode_type load_mode,

           branch_type where_were_you2 )

           branch_type old_branch )

    const bool make_changes =
        (load_mode != LOAD_RESTART_GAME && load_mode != LOAD_VISITOR);

    if (load_mode != LOAD_RESTART_GAME)

    if (make_changes)

            save_level( old_level, LEVEL_DUNGEON, where_were_you2 );

            save_level( old_level, LEVEL_DUNGEON, old_branch );

    do_lost_items(old_level_type);

    if ( make_changes )
        do_lost_items(old_level_type);

        ASSERT( load_mode != LOAD_VISITOR );

    if (load_mode != LOAD_RESTART_GAME)

    if ( make_changes )
    {

    if (load_mode != LOAD_RESTART_GAME)
    {

            place_player_on_stair(where_were_you2, stair_taken);

            place_player_on_stair(old_branch, stair_taken);

    if (mgrd[you.x_pos][you.y_pos] != NON_MONSTER)

    if (make_changes && mgrd[you.x_pos][you.y_pos] != NON_MONSTER)

    dungeon_events.fire_event(DET_ENTERING_LEVEL);

    if (load_mode != LOAD_VISITOR)
        dungeon_events.fire_event(DET_ENTERING_LEVEL);

    save_level( you.your_level, you.level_type, you.where_are_you );

    if ( make_changes )
        save_level( you.your_level, you.level_type, you.where_are_you );

    if (get_level_annotation().length() > 0

    if (load_mode != LOAD_VISITOR
        && !get_level_annotation().empty()

        char buf[200];
        sprintf(buf, "Level annotation: %s\n",
                get_level_annotation().c_str() );
        mpr(buf, MSGCH_PLAIN, YELLOW);

        mprf(MSGCH_PLAIN, YELLOW, "Level annotation: %s",
             get_level_annotation().c_str());

    crawl_state.level_annotation_shown = false;

    if (load_mode != LOAD_VISITOR)
        crawl_state.level_annotation_shown = false;

    if (load_mode != LOAD_RESTART_GAME)

    if ( make_changes )

             (where_were_you2 != you.where_are_you ||

             (old_branch != you.where_are_you ||

    dungeon_events.fire_event(DET_ENTERED_LEVEL);

    if ( load_mode != LOAD_VISITOR )
        dungeon_events.fire_event(DET_ENTERED_LEVEL);

void apply_to_all_dungeons(void (*applicator)())
{
    const branch_type original_branch = you.where_are_you;
    const int original_level = you.your_level;
    const level_area_type original_type = you.level_type;
    branch_type last_visited_branch = original_branch;
    int last_visited_level = original_level;
    const coord_def old_pos(you.pos());
    // Apply to current level, then save it out.
    applicator();
    save_level(original_level, original_type, original_branch);
    you.level_type = LEVEL_DUNGEON;
    for ( int i = 0; i < MAX_LEVELS; ++i )
    {
        for ( int j = 0; j < NUM_BRANCHES; ++j )
        {
            if ( tmp_file_pairs[i][j] )
            {
                you.your_level = i;
                you.where_are_you = static_cast<branch_type>(j);
                // Don't apply to the original level - already done up top.
                if ( original_type == you.level_type &&
                     original_level == you.your_level &&
                     original_branch == you.where_are_you )
                    continue;
                // Load the dungeon level...
                load( DNGN_STONE_STAIRS_DOWN_I, LOAD_VISITOR,
                      LEVEL_DUNGEON, last_visited_level,
                      last_visited_branch );
                // Modify it...
                applicator();
                // And save it back.
                save_level(you.your_level, LEVEL_DUNGEON, you.where_are_you);
                last_visited_branch = you.where_are_you;
                last_visited_level = you.your_level;
            }
        }
    }
    // Reload the original level.
    you.where_are_you = original_branch;
    you.your_level = original_level;
    you.level_type = original_type;
    load( DNGN_STONE_STAIRS_DOWN_I, LOAD_VISITOR,
          original_type, original_level, original_branch );
}