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

const int INF = 1<<28;
const int MAXH = 1001;
const int MAXW = 1001;
const int MAXN = 1000006;
const int di[] = {0,1,0,-1};
const int dj[] = {1,0,-1,0};

struct State {
  int pi, pj, d, step;
  bool operator < (const State &s) const {
    return step > s.step;
  }
};

int H, W, N;
char G[MAXH][MAXW];
string S;
int cost[MAXH][MAXW][4];
int mem[MAXN][4];

int minStep(int index, int dd) {
  int &res = mem[index][dd];
  if(res != -1) return res;
  if(dd == 0) return res = 0;
  if(index == N) return res = INF;
  return res = 1 + minStep(index+1,
                           (dd - (S[index] == 'R' ? 1 : -1) + 4) % 4);
}

int dijkstra(int si, int sj, int gi, int gj) {
  memset(mem, -1, sizeof(mem));
  priority_queue<State> que;
  fill(cost[0][0], cost[MAXH][0], INF);
  cost[si][sj][3] = 0;
  que.push((State){si, sj, 3, 0});
  while(que.size()) {
    const State s = que.top();
    que.pop();
    do { // forward
      State t = {s.pi + di[s.d], s.pj + dj[s.d], s.d, s.step};
      if(t.pi < 0 || t.pi >= H) break;
      if(t.pj < 0 || t.pj >= W) break;
      if(G[t.pi][t.pj] == '#') break;
      if(cost[t.pi][t.pj][t.d] <= t.step) break;
      if(t.pi == gi && t.pj == gj) return true;
      cost[t.pi][t.pj][t.d] = t.step;
      que.push(t);
    } while(0);

    // turn
    for(int nd = 0; nd < 4; ++nd) {
      if(nd == s.d) continue;
      State t = {s.pi, s.pj, nd, s.step + minStep(s.step, (nd-s.d+4)%4)};
      if(cost[t.pi][t.pj][t.d] <= t.step) continue;
      cost[t.pi][t.pj][t.d] = t.step;
      que.push(t);
    }
  }
  return INF;
}

int main() {
  while(cin >> H >> W >> N && (H|W|N)) {
    cin >> S;
    int si, sj, gi, gj;
    for(int i = 0; i < H; ++i) {
      for(int j = 0; j < W; ++j) {
        cin >> G[i][j];
        if(G[i][j] == 'S') {
          si = i; sj = j;
        }
        if(G[i][j] == 'G') {
          gi = i; gj = j;
        }
      }
    }
    if(dijkstra(si, sj, gi, gj) != INF) cout << "Yes" << endl;
    else cout << "No" << endl;
  }
  return 0;
}