#include <bits/stdc++.h>

using namespace std;

#define UP    'G'
#define DOWN  'D'
#define LEFT  'L'
#define RIGHT 'P'

#define EMPTY '.' 
#define BLACK 'C'
#define WHITE 'B'

using ull = unsigned long long;

void print_grid(vector<vector<int>> &grid, vector<char> &mapping) {
    int h = grid.size();
    int w = grid[0].size();
    for (int row = 0; row < h; row++) {
        for (int col = 0; col < w; col++) {
            int v = grid[row][col];
            cout << mapping[v];
            // cout << v;
        }
        cout << '\n';
    }
    cout.flush();
}

bool is_vertical(char c) {
    return (c == UP) || (c == DOWN);
}

void fix(string &s) {
    int n;
    while ((n = s.size()) > 1) {
        // cerr << '.';
        // cerr << s << endl;
        if (s[n - 1] == s[n - 2]) s.pop_back();
        else if (is_vertical(s[n - 1]) == is_vertical(s[n - 2])) {
            s[n - 2] = s[n - 1];
            s.pop_back();
        }
        else if (s.size() > 2 && s[n - 3] == s[n - 1]) s.pop_back();
        else break;
    }
}

string normalize(const string &s) {
    string res;
    for (char c : s) {
        res.push_back(c);
        fix(res);
    }
    return res;
}
void apply_perm(vector<vector<int>> &grid, vector<vector<int>> &cycles, int times) {
    vector<int> perm(1, 0);
    for (auto &cycle : cycles) {
        int n = cycle.size();
        for (int i = 0; i < n; i++) {
            while (int(perm.size()) < cycle[i] + 1) perm.emplace_back();
            perm[cycle[i]] = cycle[(i + times) % cycle.size()];
        }
    }
    

    int h = grid.size();
    int w = grid[0].size();
    for (int row = 0; row < h; row++) {
        for (int col = 0; col < w; col++) {
            grid[row][col] = perm[grid[row][col]];
        }
    }
}

void onemove(vector<vector<int>> &grid, char dir) {
    // cerr << "doing " << dir << endl;
    int h = grid.size();
    int w = grid[0].size();
    if (dir == UP) {
        for (int col = 0; col < w; col++) {
            int writerow = 0;
            for (int row = 0; row < h; row++) {
                int c = grid[row][col];
                if (!c) continue;
                else {
                    grid[writerow++][col] = c;
                }
            }
            for (int row = writerow; row < h; row++) {
                grid[row][col] = 0;
            }
        }
    } else if (dir == DOWN) {
        for (int col = 0; col < w; col++) {
            int writerow = h - 1;
            for (int row = h - 1; row >= 0; row--) {
                int c = grid[row][col];
                if (!c) continue;
                else {
                    grid[writerow--][col] = c;
                }
            }
            for (int row = writerow; row >= 0; row--) {
                grid[row][col] = 0;
            }
        }
    } else if (dir == LEFT) {
        for (int row = 0; row < h; row++) {
            int writecol = 0;
            for (int col = 0; col < w; col++) {
                int c = grid[row][col];
                if (!c) continue;
                else {
                    grid[row][writecol++] = c;
                }
            }
            for (int col = writecol; col < w; col++) {
                grid[row][col] = 0;
            }
        }
    } else {
        for (int row = 0; row < h; row++) {
            int writecol = w - 1;
            for (int col = w - 1; col >= 0; col--) {
                int c = grid[row][col];
                if (!c) continue;
                else {
                    grid[row][writecol--] = c;
                }
            }
            for (int col = writecol; col >= 0; col--) {
                grid[row][col] = 0;
            }
        }
    }

    // seen.insert(grid_hash(grid));
    // print_grid(grid);

}



vector<vector<int>> get_perm(vector<vector<int>> &grid, string rep) {

    // print_grid(grid, mapping);
    vector<vector<int>> ngrid = grid;
    vector<int> perm(1, 0);
    for (char c: rep) onemove(ngrid, c);
    // cerr << "did onemoves" << endl;
    int h = grid.size();
    int w = grid[0].size();
    for (int row = 0; row < h; row++) {
        for (int col = 0; col < w; col++) {
            int v = grid[row][col];
            while (int(perm.size()) < v + 1) perm.emplace_back();
            perm[v] = ngrid[row][col];
        }
    }

    // print_grid(ngrid, mapping);

    // cerr << "perm" << endl;
    // for (int v : perm) cerr << v << ' ';
    // cerr << endl;

    vector<vector<int>> cycles;
    for (int i = 0; i < int(perm.size()); i++) {
        int target = perm[i];
        if (target == -1) continue;
        cycles.emplace_back();
        while (true) {
            cycles.back().push_back(target);
            int next_target = perm[target];
            perm[target] = -1;
            if (target == i) break;
            target = next_target;
        }
    }

    return cycles;
}


void solve() {
    int h, w;
    cin >> h >> w;
    vector<vector<int>> grid(h, vector<int>(w));
    int which = 1;

    vector<char> mapping;
    mapping.push_back('.');
    for (int row = 0; row < h; row++) {
        for (int col = 0; col < w; col++) {
            char c;
            cin >> c;
            if (c == '.') grid[row][col] = 0;
            else {
                grid[row][col] = which++;
                mapping.push_back(c);
            }
        }
    }
    int k;
    cin >> k;
    string s;
    cin >> s;
    // cout << s << endl;
    // cout << "~~~~~~" << endl;
    // onemove(grid, s[0]);
    int i = 1;
    while (i < k) {
        if (is_vertical(s[i]) != is_vertical(s[i - 1])) break;
        i++;
    }
    onemove(grid, s[i - 1]);
    i++;
    while (i < k) {
        if (is_vertical(s[i]) != is_vertical(s[i - 1])) break;
        i++;
    }
    if (i <= k) onemove(grid, s[i - 1]);

    if (i >= k) {
        print_grid(grid, mapping);
        return;
    }
    s = s.substr(i, string::npos);

    // // cerr << s << endl;
    // cerr << s << endl;
    s = normalize(s);
    // cerr << s << endl;
    if (s.size() >= 4 + s.size() % 4) {
        for (int j = 0; j < int(4 + s.size() % 4); j++) onemove(grid, s[j]);
        string rep = s.substr(s.size() - 4, string::npos);
        // cerr << rep << endl;
        auto v = get_perm(grid, rep);
        apply_perm(grid, v, (s.size() / 4) - 1);
        // s.resize(s.size() % 4);
    } else {
        for (char c : s) onemove(grid, c);
    }
    // cerr << s << endl;
    // int new_size = 120 + s.size() % 120;
    // if (new_size < int(s.size())) {
    //     s.resize(new_size);
    // }

    // print_grid(grid);
    // onemove(grid, s[0]);
    // if (s.size() > 0) {
    //     onemove(grid, s[1]);
    // }
    // if (s.size() > 4) {
    //     onemove(grid, s[s.size() - 2]);
    // }
    // if (s.size() > 3) {
    //     onemove(grid, s[s.size() - 1]);
    // }
    // char c;
    // while (cin >> c) onemove(grid, c);
    // cout << seen.size() << endl;
    print_grid(grid, mapping);
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);

// #ifdef LOCAL
//     int t; cin >> t; while (t--)
// #endif

    solve();

    cout.flush();
}