#include <iostream>
#include <sstream>
#include <vector>
#include <cctype>


typedef unsigned short int UShort;
typedef const UShort CUShort;
typedef std::string Str;
typedef const Str CStr;


bool IsFalling(const std::vector<UShort>& abysses, CUShort currRI)
{
    for (UShort i = 0; i < abysses.size(); ++i)
        if (abysses[i] == currRI) return true;
}


void ExtractCommand(Str& currCommand)
{
    switch (currCommand[0])
    {
        case 'u': currCommand = "up"; break;
        case 'd': currCommand = "down"; break;
        case 'f': currCommand = "forward"; break;
        case 'b': currCommand = "backward"; break;
        case 'l': currCommand = "left"; break;
        case 'r': currCommand = "right"; break;
        default: currCommand = "end"; break;
    }
}


void ExtractNumberOfSteps(CStr& currCommand, UShort& steps)
{
    std::string numVal = "";

    for (UShort i = 0; i < currCommand.length(); ++i)
    {
        if (isdigit(currCommand[i]))
            numVal += currCommand[i];
    }

    std::stringstream tempVal(numVal);
    tempVal >> steps;
}


void HandleSnakeMovement(const std::vector<UShort>& abysses, CUShort cubeSize, UShort& currLI, UShort& currRI, Str& snakeStatus, CStr& currCommand)
{
    CStr snakeIsDead = "dead";
    CUShort lastAbyss = abysses.back();

    if (currCommand == "up")
    {
        if (currRI <= cubeSize - 1) snakeStatus = snakeIsDead;
        else currRI -= (cubeSize + 3);
    }

    else if (currCommand == "down")
    {
        if (currRI >= lastAbyss) snakeStatus = snakeIsDead;
        else currRI += (cubeSize + 3);
    }

    else if (currCommand == "forward")
    {
        if (currLI == 0) snakeStatus = snakeIsDead;
        else currLI--;
    }

    else if (currCommand == "backward")
    {
        if (currLI == cubeSize - 1) snakeStatus = snakeIsDead;
        else currLI++;
    }

    else if (currCommand == "left")
    {
        if (currRI == 0) snakeStatus = snakeIsDead;

        else
        {
            currRI--;
            if (IsFalling(abysses, currRI)) snakeStatus = snakeIsDead;
        }
    }

    else
    {
        currRI++;
        if (currRI > lastAbyss + cubeSize || IsFalling(abysses, currRI)) snakeStatus = snakeIsDead;
    }

}


int main()
{
    UShort cubeSize;
    std::cin >> cubeSize;
    CUShort cubeFencesPerRow = cubeSize - 1;
    CUShort cubeAbyssesPerRow = cubeFencesPerRow << 1;
    CUShort cubeRows = cubeSize;
    CUShort cubeCols = (cubeSize * cubeSize) + cubeFencesPerRow + cubeAbyssesPerRow;
    char cubeFields[cubeRows][cubeCols];
    const char snakeBirthPoint = 's', apple = 'a', delimeter = '|';
    UShort currLI, currRI;
    Str snakeStatus;
    CStr snakeIsAlive = "alive", snakeIsDead = "dead";
    std::vector<UShort> abysses;

    std::cin.sync();

    for (UShort r = 0; r < cubeSize; ++r)
    {
        Str singleCubeField;
        std::getline(std::cin, singleCubeField);

        for (UShort c = 0, s = 0; c < cubeCols && s < singleCubeField.length(); ++c, ++s)
        {
            cubeFields[r][c] = singleCubeField[s];

            if (singleCubeField[s] == snakeBirthPoint)
            {
                currLI = r;
                currRI = c;
                snakeStatus = snakeIsAlive;
            }
        }
    }

     for (UShort c = 0; c < cubeCols; ++c)
        if (cubeFields[0][c] == delimeter)
        {
            abysses.push_back(c - 1);
            abysses.push_back(c + 1);
        }

    UShort applesEatenBySnake = 0, numOfCommands = 0;
    CUShort commandsLimit = 100;

    static Str prevCommand;
    std::cin.sync();
    std::cin >> prevCommand;

    while (snakeStatus != snakeIsDead && numOfCommands <= commandsLimit)
    {
        std::cin.sync();
        Str currCommand;
        std::getline(std::cin, currCommand);
        numOfCommands++;
        UShort steps;

        ExtractNumberOfSteps(currCommand, steps);
        ExtractCommand(currCommand);

        for (UShort repeatCommand = 0; repeatCommand < steps; ++repeatCommand)
        {
            HandleSnakeMovement(abysses, cubeSize, currLI, currRI, snakeStatus, prevCommand);
            if (cubeFields[currLI][currRI] == apple) applesEatenBySnake++;
        }

        if (currCommand == "end")
        {
            std::cout << '\n';
            break;
        }

        prevCommand = currCommand;
    }

    std::cout << "Points collected: " << applesEatenBySnake << '\n';
    if (snakeStatus == snakeIsDead) std::cout << "The snake dies.";
}