// Marcin Knapik

#pragma GCC optimize ("O3")
#include<bits/stdc++.h>
using namespace std;

#define FOR(i, n) for (int i = 0; i < n; i++)
#define f first
#define s second
#define pb push_back
#define all(s) s.begin(), s.end()
#define sz(s) (int)s.size()

using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;

template <class T>ostream &operator<<(ostream &os, vector<T> &vec){for (T &el : vec){os << el << ' ';}return os;}
template <class T>istream &operator>>(istream &is, vector<T> &vec) {for (T &el : vec){is >> el;}return is;}

template <class T, class G> ostream &operator<<(ostream &os, pair<T, G> para) { os << para.f << ' ' << para.s; return os;}

int n, m;

using vi = vector<int>;
using ii = pair<int, int>;
using vii = vector<ii>;

const int N = 505;
string orig[N];
using mac = vector<vector<ii>>;

ii operator + (ii a, ii b){
    return {a.f + b.f, a.s + b.s};
}

ii operator - (ii a, ii b){
    return {a.f - b.f, a.s - b.s};
}

map<char, ii> mapa_kier = {
    {'L', {0, -1}},
    {'P', {0, 1}},
    {'G', {-1, 0}},
    {'D', {1, 0}}
};

bool kolor(ii poz){
    return orig[poz.f][poz.s] != '.';
}

bool bounds(ii poz){
    return poz.f >= 0 and poz.s >= 0 and poz.f < n and poz.s < m;
}

mac make_move(mac mapa, char c){
    ii kier = mapa_kier[c];

    vii startowe;
    if(c == 'L' or c == 'P'){
        for(int i = 0; i < n; i++) {
            startowe.pb({i, (m - 1) * (c == 'L')});
        }
    } else {
        for(int j = 0; j < m; j++) {
            startowe.pb({(n - 1) * (c == 'G'), j});
        }
    }

    mac ret = mac(sz(mapa), vii(sz(mapa[0])));
    for(auto start : startowe){
        vii pelne;
        vii puste;

        while(bounds(start)){
            if(kolor(mapa[start.f][start.s])){
                pelne.pb(mapa[start.f][start.s]);
            } else {
                puste.pb(mapa[start.f][start.s]);
            }
            start = start + kier;
        }

        start = start - kier;
        while(bounds(start)){
            if(sz(pelne)){
                mapa[start.f][start.s] = pelne.back();
                pelne.pop_back();
            } else {
                mapa[start.f][start.s] = puste.back();
                puste.pop_back();
            }
            start = start - kier;
        }
        assert(sz(pelne) == 0 and sz(puste) == 0);
    }

    return mapa;
}

mac operator * (mac a, mac b){
    assert(sz(a) == sz(b) and sz(a) > 0 and sz(a[0]) == sz(b[0]));
    mac ret = a;
    for(int i = 0; i < sz(ret); i++){
        for(int j = 0; j < sz(ret[0]); j++){
            ii step = a[i][j];
            ret[i][j] = b[step.f][step.s];
        }
    }
    return ret;
}

mac operator / (mac a, mac b){
    assert(sz(a) == sz(b) and sz(a) > 0 and sz(a[0]) == sz(b[0]));
    mac ret = a;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            ret[b[i][j].f][b[i][j].s] = a[i][j];
        }
    }
    return ret;
}

mac id(){
    mac ret(n, vii(m));
    FOR(i, n){
        FOR(j, m){
            ret[i][j] = {i, j};
        }
    }
    return ret;
}

mac operator ^ (mac a, int pot){
    mac ret = id(); 
    while(pot){
        if(pot & 1){
            ret = ret * a;
        }
        a = a * a;
        pot >>= 1;
    }
    return ret;
}

void wypisz(mac mapa){
    FOR(i, n){
        FOR(j, m){
            cout << orig[mapa[i][j].f][mapa[i][j].s];
        }
        cout << '\n';
    }
}

void debug(mac mapa){
    FOR(i, n){
        FOR(j, m){
            cout << "(" << mapa[i][j].f << ',' << mapa[i][j].s << ")" << ' ';
        }
        cout << '\n';
    }
}

void solve () {
    cin >> n >> m;

    FOR(i, n){
        cin >> orig[i];
    }

    vector<vector<ii> > mapa = id();

    string ruchy;
    cin >> ruchy >> ruchy;

    auto reduce = [](string s){
        map<char, char> inny = {{'G', 'D'}, {'D', 'G'}, {'L', 'P'}, {'P', 'L'}};
        string ret;
        for(auto & u : s){
            if(sz(ret) and (ret.back() == inny[u] or ret.back() == u)) {
                ret.pop_back();
            }
            if(sz(ret) <= 1 or ret[sz(ret) - 2] == inny[u]){
                ret += u;
            }
        }
        return ret;
    };

    ruchy = reduce(ruchy);

    auto zmiana = [](mac pocz, mac kon){
        mac ret(n, vii(m));
        map<ii, ii> where;
        
        FOR(i, n){
            FOR(j, m){
                where[kon[i][j]] = {i, j};
            }
        }
        
        FOR(i, n){
            FOR(j, m){
                ret[i][j] = where[pocz[i][j]];
            }
        }

        return ret;
    };

    if(sz(ruchy) < 6){
        // int cnt = 0;
        for(auto & u : ruchy){
            // cout << cnt++ << endl;
            // wypisz(mapa);
            mapa = make_move(mapa, u);
        }
    } else {
        mapa = make_move(mapa, ruchy[0]);
        mapa = make_move(mapa, ruchy[1]);

        auto pom = mapa;
        for(int i = 2; i < 6; i++){
            pom = make_move(pom, ruchy[i]);
        } 
        int ile = (sz(ruchy) - 2) / 4;

        mapa = mapa / (zmiana(mapa, pom) ^ ile);
        for(int i = 2 + ile * 4; i < sz(ruchy); i++){
            mapa = make_move(mapa, ruchy[i]);
        }
    }

    wypisz(mapa);
}

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

    int tests = 1;
    // cin >> tests;

    for (int test = 1; test <= tests; test++) {
        solve();
    }

    return 0;
}