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

int n, m;
char orig[505][505];
pair<int, int> t[505][505];
char reverse_dir(char c) {
    switch (c) {
        case 'G':
            return 'D';
        case 'D':
            return 'G';
        case 'L':
            return 'P';
        case 'P':
            return 'L';
    }

    exit(1);
}

bool horizontal(char c) { return c == 'L' || c == 'P'; }
bool vertical(char c) { return !horizontal(c); }
bool opposite(char c1, char c2) { return reverse_dir(c1) == c2; }

bool same_axis(char c1, char c2) {
    return (vertical(c1) && vertical(c2)) || (horizontal(c1) && horizontal(c2));
}
string trim_redundant(string moves, char first_move) {
    if (!same_axis(moves[0], first_move)) return moves;

    int i = 0;
    while (i + 1 < moves.size() && same_axis(moves[i + 1], first_move)) {
        i++;
    }
    return moves.substr(i);
}

pair<int, int> DUMMY = {0, 0};

void perform_move(char c) {
    switch (c) {
        case 'G':
            for (int col = 1; col <= m; col++) {
                int src_row = 1;
                for (int dst_row = 1; dst_row <= n; dst_row++) {
                    while (src_row <= n && t[src_row][col] == DUMMY) src_row++;
                    if (src_row > n) break;
                    swap(t[src_row][col], t[dst_row][col]);
                    src_row++;
                }
            }
            break;
        case 'D':
            for (int col = 1; col <= m; col++) {
                int src_row = n;
                for (int dst_row = n; dst_row >= 1; dst_row--) {
                    while (src_row > 0 && t[src_row][col] == DUMMY) src_row--;
                    if (src_row <= 0) break;
                    swap(t[src_row][col], t[dst_row][col]);
                    src_row--;
                }
            }
            break;
        case 'L':
            for (int row = 1; row <= n; row++) {
                int src_col = 1;
                for (int dst_col = 1; dst_col <= m; dst_col++) {
                    while (src_col <= m && t[row][src_col] == DUMMY) src_col++;
                    if (src_col > m) break;
                    swap(t[row][src_col], t[row][dst_col]);
                    src_col++;
                }
            }
            break;
        case 'P':
            for (int row = 1; row <= n; row++) {
                int src_col = m;
                for (int dst_col = m; dst_col >= 1; dst_col--) {
                    while (src_col > 0 && t[row][src_col] == DUMMY) src_col--;
                    if (src_col < 0) break;
                    swap(t[row][src_col], t[row][dst_col]);
                    src_col--;
                }
            }
            break;
    }
}

string without_first(string s) {
    if (s.empty()) return s;
    return s.substr(1);
}

bool double_move(char c, string &res, string &premoves) {
    for (int i = res.size() - 1; i >= 0; i--) {
        if (res[i] == c) return true;
        if (opposite(res[i], c)) return false;
    }

    for (int i = premoves.size() - 1; i >= 0; i--) {
        if (premoves[i] == c) return true;
        if (opposite(premoves[i], c)) return false;
    }

    return false;
}

string reduce_moves(string moves, string premoves) {
    string res;
    for (auto c : moves) {
        // Dwa razy pod rząd to samo nic nie robi.
        if ((!res.empty() && res.back() == c) ||
            (res.size() == 0 && !premoves.empty() && premoves.back() == c))
            continue;
        // Zjadamy poprzedni ruch.
        else if (!res.empty() && opposite(c, res.back()))
            res.pop_back();
        // Dwa razy w góre nic nie zmieni nawet jak sie zrobi coś po drodze.
        // else if ((res.size() >= 2 && res[res.size() - 2] == c) ||
        //          (res.size() == 0 && premoves.size() >= 2 && premoves[premoves.size() - 2] == c)
        //          || (res.size() == 1 && premoves.size() >= 1 && premoves.back() == c))
        else if (double_move(c, res, premoves))
            continue;
        // Normalny ruch.
        else {
            res += c;
        }
    }
    return res;
}

void printMat() {
    for (int i = 1; i <= n; i++) {
        string row;
        for (int j = 1; j <= m; j++) {
            int x = t[i][j].first;
            int y = t[i][j].second;
            row += orig[x][y];
        }
        cout << row << "\n";
    }
}

void dbgMat() {
    for (int i = 1; i <= n; i++) {
        string row;
        for (int j = 1; j <= m; j++) {
            int x = t[i][j].first - 1;
            int y = t[i][j].second - 1;
            if (x == -1 && y == -1)
                row += ".";
            else
                row += (char)('0' + x * 3 + y);
        }
        cerr << row << "\n";
    }
}

pair<int, int> przed_cyklem[505][505];
pair<int, int> po_cyklu[505][505];
bool vis[505][505];
int32_t main() {
    orig[0][0] = '.';
    cin >> n >> m;
    string s;
    for (int i = 1; i <= n; i++) {
        cin >> s;
        for (int j = 1; j <= m; j++) {
            orig[i][j] = s[j - 1];
            if (s[j - 1] == '.')
                t[i][j] = DUMMY;
            else
                t[i][j] = {i, j};
        }
    }

    int l;
    cin >> l;
    string moves;
    cin >> moves;
    string premoves;

    // Najpierw pójdź do ściany.
    char first_move = moves[0];
    perform_move(first_move);
    moves = without_first(moves);
    premoves += first_move;
    // Usuń redundantne ruchy przed pójściem w róg.
    moves = trim_redundant(moves, first_move);
    // cerr << moves << "\n";
    // Idź do rogu.
    char second_move = moves[0];
    perform_move(moves[0]);
    premoves += moves[0];
    moves = without_first(moves);

    if (same_axis(first_move, second_move)) {
        perform_move(moves[0]);
        premoves += moves[0];
        moves = without_first(moves);
    }

    // Sprowadź ruchy do chodzenia po cyklu.
    moves = reduce_moves(moves, premoves);
    // cerr << moves << "\n";
    // Zrób tak, żeby zostało same cyklenie się N razy.
    while (moves.size() % 4 != 0) {
        perform_move(moves[0]);
        moves = without_first(moves);
    }

    if (moves.size() == 0) {
        printMat();
        return 0;
    }

    // Zapamietaj gdzie kto stał przed cyklem.
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            przed_cyklem[t[i][j].first][t[i][j].second] = {i, j};
        }
    }

    // dbgMat();
    // cerr << "\n";

    // Zrób pełny obrót.
    for (int i = 1; i <= 4; i++) {
        perform_move(moves[0]);
        moves = without_first(moves);
    }

    // Zapisz gdzie kto stoi po cyklu.
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            po_cyklu[t[i][j].first][t[i][j].second] = {i, j};
        }
    }

    // dbgMat();
    // cerr << "\n";

    // while (!moves.empty()) {
    //     perform_move(moves[0]);
    //     moves = without_first(moves);
    // }

    // printMat();
    // return 0;

    int obroty = moves.size() / 4;
    // Znajdź cykle w permutacji (przed -> po) i przepermutuj.
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            auto value = t[i][j];
            if (!vis[value.first][value.second]) {
                vector<pair<int, int>> cycle;
                while (!vis[value.first][value.second]) {
                    vis[value.first][value.second] = true;
                    cycle.push_back(value);
                    auto przed = przed_cyklem[value.first][value.second];
                    value = t[przed.first][przed.second];
                }

                int to_shift = obroty % cycle.size();
                for (int p = 0; p < cycle.size(); p++) {
                    auto dst = po_cyklu[cycle[p].first][cycle[p].second];
                    t[dst.first][dst.second] = cycle[(p + to_shift) % cycle.size()];
                }

                // for (auto p : cycle) {
                //     cerr << "(" << p.first << "," << p.second << ") -> ";
                // }
                // cerr << "\n";
            }
        }
    }

    printMat();
}