#include <bits/stdc++.h>
using namespace std;

typedef long long int LL;

const LL INF = 1000000000;

const int UNDEFINED = -1;

const int MAX_N = 505;
const int MAX_V = 1000;

struct movesDesc
{
    int g, d, l, p;

    int getNextId(const char dir)
    {
        switch(dir)
        {
        case 'G':
            return g;
        case 'D':
            return d;
        case 'L':
            return l;
        case 'P':
            return p;
        }

        return -1;
    }

    void setNextId(const char dir, const int id)
    {
        if(dir == 'G')
        {
            g = id;
        }
        else if(dir == 'D')
        {
            d = id;
        }
        else if(dir == 'L')
        {
            l = id;
        }
        else if(dir == 'P')
        {
            p = id;
        }
    }

    movesDesc()
    {
        g = d = l = p = -1;
    }
};

int n, m, k;
string moves;

vector<string> idToBoard;
unordered_map<string, int> boardToId;

vector<movesDesc> graph;

int found, missed;

void printBoard(string& board)
{
    for(int i = 0; i < n; ++i)
    {
        for(int j = 0; j < m; ++j)
        {
            cout << board[i*m + j];
        }
        cout << endl;
    }
}

void printBoard(int id)
{
    //cout << "id to print: " << id << endl;
    printBoard(idToBoard[id]);
}

string flat(const vector<string>& board)
{
    string res;

    for(const string& s : board)
    {
        res += s;
    }

    return res;
}

int boardId(const string& board)
{
    const auto iter = boardToId.find(board);

    if(iter != boardToId.cend())
    {
        return iter->second;
    }

    const int newId = idToBoard.size();
    boardToId[board] = newId;
    idToBoard.push_back(board);
    graph.push_back(movesDesc());


    //printBoard(board);
    //cout << endl << endl;

    return newId;
}

string makeMove(const string& board, char dir)
{
    const bool vertical = (dir == 'G' || dir == 'D');
    const bool decreasing = (dir == 'G' || dir == 'L');

    string newBoard(board.size(), '.');
    vector<vector<pair<int, char>>> poses((vertical ? m : n));

    for(int i = 0; i < n; ++i)
    {
        for(int j = 0; j < m; ++j)
        {
            char curr = board[i*m + j];
            if(curr == '.')
            {
                continue;
            }

            if(vertical)
            {
                poses[j].push_back(make_pair(i, curr));
            }
            else
            {
                poses[i].push_back(make_pair(j, curr));
            }
        }
    }

    //cout << "poses calculated" << endl;

    if(!decreasing)
    {
        for(auto& elem : poses)
        {
            if(elem.empty())
            {
                continue;
            }

            reverse(elem.begin(), elem.end());
        }
    }

    //cout << "poses reverted" << endl;

    const int endGroup = (vertical ? m : n);
    const int endPos = (vertical ? n : m) - 1;
    for(int i = 0; i < endGroup; ++i)
    {
        int idx = (decreasing ? 0 : endPos);
        int toAdd = (decreasing ? 1 : -1);
        for(auto& elem : poses[i])
        {
            elem.first = idx;
            idx += toAdd;
        }
    }

    //cout << "new poses calculated" << endl;

    for(int i = 0; i < endGroup; ++i)
    {
        for(auto& elem : poses[i])
        {
            if(vertical)
            {
                newBoard[elem.first*m + i] = elem.second;
            }
            else
            {
                newBoard[i*m + elem.first] = elem.second;
            }
        }
    }

    //cout << "new board created" << endl;

    return newBoard;
}

int makeMove(const int id, const char dir)
{
    if(graph[id].getNextId(dir) != UNDEFINED)
    {
        //cout << "found id->next: " << id << " -> " << graph[id].getNextId(dir) << endl;
        ++found;
        return graph[id].getNextId(dir);
    }

    const auto newBoard = makeMove(idToBoard[id], dir);
    //cout << "board created" << endl;
    const int newId = boardId(newBoard);
    //cout << "id fetched: " << newId << endl;
    ++missed;

    graph[id].setNextId(dir, newId);
    graph[newId].setNextId(dir, newId);
    //cout << "id -> nextId: " << id << " -> " << newId << ", dir: " << dir << endl;

    return newId;
}

int main()
{
    ios_base::sync_with_stdio(0);

    cin >> n >> m;

    string line;
    string board;
    for(int i = 0; i < n; ++i)
    {
        cin >> line;

        board += line;
    }

    int currId = boardId(board);

    cin >> k;
    cin >> moves;

    for(int i = 0; i < moves.size(); ++i)
    {
        //board = makeMove(board, dir);

        //cout << "dir: " << dir << endl << endl;
        //printBoard(board);
        //cout << "-----" << endl << endl;

        const char dir = moves[i];

        //cout << "move: " << i << " -> " << dir << endl;

        if(i > 0 && moves[i] == moves[i-1])
        {
            continue;
        }

        currId = makeMove(currId, dir);
    }

    //cout << idToBoard.size() << endl;
    //cout << "found: " << found << ", missed: " << missed << endl;

    printBoard(currId);

    //printBoard(currId);

    return 0;
}