#include <iostream>
#include <iomanip>
#include <sstream>
#include <cstdio>
#include <string>
#include <vector>
#include <algorithm>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <cassert>
#include <climits>
#include <queue>
#include <set>
#include <map>
#include <valarray>
#include <bitset>
#include <stack>
using namespace std;

#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
typedef pair<int,int> pii;
const int INF = 1<<29;
const double PI = acos(-1);
const double EPS = 1e-8;

#include <iostream>
#include <vector>
#include <string>
#include <queue>
using namespace std;

// Aho-Corasick
// UVa 10679
// Æè ¦¸ MM > 128ÉµÄ¨¯ÎASCIIÍüé
// TrieÅÀµÄ¢éÌÅAø¦Í«¢
const int MM = 150;

struct Node {
  int id;
  int next[MM];
  int fail;
  vector<int> value;
  Node() {
    for(int i=0; i<MM; ++i) next[i] = 0;
    value.clear();
  }
};

class Trie {
public:
  Trie(const vector<string> &vs) {
    nodes.push_back(new Node()); // dummy
    nodes.push_back(new Node());
    for(int i=0; i<vs.size(); ++i)
      insert(vs[i],i);
  }
  Trie() {
    nodes.clear();
  }

  void insert(const string &s,int k) {
    Node *cur = nodes[1];
    for(int i=0; i<s.length(); ++i) {
      if(cur->next[s[i]] == 0) {
        cur->next[s[i]] = nodes.size();
        nodes.push_back(new Node());
      }
      cur = nodes[cur->next[s[i]]];
    }
    cur->value.push_back(k);
  }
  vector<Node*> nodes;
};

class Aho_Corasick {
public:
  Aho_Corasick(const vector<string> &vs) {
    nodes = Trie(vs).nodes;
    make_failure_link();
  }

  void make_failure_link() {
    //const vector<Node*> &nodes = _trie.nodes;
    queue<int> q;
    Node *root = nodes[1];
    for(int i=0; i<MM; ++i) {
      if(root->next[i]) {
        nodes[root->next[i]]->fail = 1;
        q.push(root->next[i]);
      }else root->next[i] = 1;
    }

    while(!q.empty()) {
      Node *t = nodes[q.front()]; q.pop();
      for(int i=0; i<MM; ++i) {
        int u = t->next[i];
        if(u) {
          q.push(u);
          int r = t->fail;
          while(!nodes[r]->next[i]) r = nodes[r]->fail;
          nodes[u]->fail = nodes[r]->next[i];
          FOR(it, nodes[nodes[u]->fail]->value) {
            nodes[u]->value.push_back(*it);
          }
        }
      }
    }
  }

  int match(const string &s) {
    int ret = 0;
    int v = 1;
    for(int i=0; i<s.length(); ++i) {
      while(!nodes[v]->next[s[i]]) {
        v = nodes[v]->fail;
      }
      v = nodes[v]->next[s[i]];
      if(!(nodes[v]->value.empty())) { // found the word
        ret += nodes[v]->value.size();
      }
    }
    return ret;
  }

  int next(int v, char c) {
    while(!nodes[v]->next[c]) {
      v = nodes[v]->fail;
    }
    v = nodes[v]->next[c];
    if(!(nodes[v]->value.empty())) { // found the word
      return -1;
    }
    return v;
  }
  
  void free() {
    for(int i=0; i<nodes.size(); ++i)
      delete nodes[i];
  }
  vector<Node*> nodes;
};

char ba[50][50];
int dx[4] = {0,1,0,-1};
int dy[4] = {-1,0,1,0};
char dir[4] = {'U','R','D','L'};

struct P {
  int y, x, v;
  P(int y, int x, int v) : y(y),x(x),v(v) {}
};
int dis[50][50][102];
int main() {
  int h, w;
  while(cin >> h >> w, h||w) {
    int sy,sx;
    REP(i, h) {
      REP(j, w) {
        cin >> ba[i][j];
        if (ba[i][j] == 'S') sy=i,sx=j;
      }
    }
    int m;
    cin >> m;
    vector<string> vs(m);
    REP(i, m) cin >> vs[i];
    Aho_Corasick pma(vs);
    queue<P> Q;
    Q.push(P(sy,sx,1));
    memset(dis,-1,sizeof(dis));
    dis[sy][sx][1] = 0;
    int ans = -1;
    while(!Q.empty()) {
      P p = Q.front(); Q.pop();
      // cout << string(dis[p.y][p.x][p.v], ' ');
      // cout << p.x << " " << p.y << " " << p.v << endl;
      if (ba[p.y][p.x] == 'G') {
        ans = dis[p.y][p.x][p.v];
        break;
      }
      REP(k, 4) {
        int yy = p.y+dy[k];
        int xx = p.x+dx[k];
        if (yy<0||yy>=h||xx<0||xx>=w) continue;
        if (ba[yy][xx] == '#') continue;
        int vv = pma.next(p.v, dir[k]);
        //cout << xx << ":" << yy << ":" << vv << endl;
        //cout << dis[yy][xx][vv] << endl;
        if (vv != -1 && dis[yy][xx][vv] == -1) {
          dis[yy][xx][vv] = dis[p.y][p.x][p.v]+1;
          Q.push(P(yy,xx,vv));
        }
      }  
    }
    cout << ans << endl;
  }
}
  

Measured memory_bytes: 3008