#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}


struct FastIO{
  FastIO(){
    cin.tie(0);
    ios::sync_with_stdio(0);
  }
}fastio_beet;


template<size_t X>
struct Trie{
  struct Node{
    char c;
    array<int, X> nxt;
    vector<int> idxs;
    int idx;
    Node(char c):c(c),idx(-1){fill(nxt.begin(),nxt.end(),-1);}
  };

  using F = function<int(char)>;
  vector<Node> vs;
  F conv;

  Trie(F conv,char c='$'):conv(conv){vs.emplace_back(c);}

  void add(const string &s,int x){
    int pos=0;
    for(int i=0;i<(int)s.size();i++){
      int k=conv(s[i]);
      if(~vs[pos].nxt[k]){
        pos=vs[pos].nxt[k];
        continue;
      }
      int npos=vs.size();
      vs[pos].nxt[k]=npos;
      vs.emplace_back(s[i]);
      pos=npos;
    }
    vs[pos].idx=x;
    vs[pos].idxs.emplace_back(x);
  }

  int find(const string &s){
    int pos=0;
    for(int i=0;i<(int)s.size();i++){
      int k=conv(s[i]);
      if(vs[pos].nxt[k]<0) return -1;
      pos=vs[pos].nxt[k];
    }
    return pos;
  }

  int find(int pos,char c){
    return vs[pos].nxt[conv(c)];
  }

  int idx(int pos){
    return pos<0?-1:vs[pos].idx;
  }

  vector<int> idxs(int pos){
    return pos<0?vector<int>():vs[pos].idxs;
  }

};


template<size_t X>
struct AhoCorasick : Trie<X+1>{
  using TRIE = Trie<X+1>;
  using TRIE::TRIE;
  vector<int> cnt;

  void build(bool heavy=true){
    auto &vs=TRIE::vs;
    int n=vs.size();
    cnt.resize(n);
    for(int i=0;i<n;i++){
      if(heavy) sort(vs[i].idxs.begin(),vs[i].idxs.end());
      cnt[i]=vs[i].idxs.size();
    }

    queue<int> que;
    for(int i=0;i<(int)X;i++){
      if(~vs[0].nxt[i]){
        vs[vs[0].nxt[i]].nxt[X]=0;
        que.emplace(vs[0].nxt[i]);
      }else{
        vs[0].nxt[i]=0;
      }
    }

    while(!que.empty()){
      auto &x=vs[que.front()];
      cnt[que.front()]+=cnt[x.nxt[X]];
      que.pop();
      for(int i=0;i<(int)X;i++){
        if(x.nxt[i]<0){
          x.nxt[i]=vs[x.nxt[X]].nxt[i];
          continue;
        }
        int fail=x.nxt[X];
        vs[x.nxt[i]].nxt[X]=vs[fail].nxt[i];
        if(heavy){
          auto &idx=vs[x.nxt[i]].idxs;
          auto &idy=vs[vs[fail].nxt[i]].idxs;
          vector<int> idz;
          set_union(idx.begin(),idx.end(),
                    idy.begin(),idy.end(),
                    back_inserter(idz));
          idx=idz;
        }
        que.emplace(x.nxt[i]);
      }
    }
  }

  vector<int> match(string s,int heavy=true){
    auto &vs=TRIE::vs;
    vector<int> res(heavy?TRIE::size():1);
    int pos=0;
    for(auto &c:s){
      pos=vs[pos].nxt[TRIE::conv(c)];
      if(heavy) for(auto &x:vs[pos].idxs) res[x]++;
      else res[0]+=cnt[pos];
    }
    return res;
  }

  int move(int pos,char c){
    auto &vs=TRIE::vs;
    assert(pos<(int)vs.size());
    return vs[pos].nxt[TRIE::conv(c)];
  }

  int count(int pos){
    return cnt[pos];
  }

  int size(){return TRIE::vs.size();}
};

//INSERT ABOVE HERE
int dp[111][55][55];
signed main(){
  int h,w;
  while(cin>>h>>w,h){
    vector<string> ss(h);
    for(int i=0;i<h;i++) cin>>ss[i];
    int p;
    cin>>p;
    vector<string> ps(p);
    for(int i=0;i<p;i++) cin>>ps[i];
    auto conv=
      [&](char c){
        if(c=='U') return 0;
        if(c=='R') return 1;
        if(c=='D') return 2;
        if(c=='L') return 3;
        return -1;
      };
    AhoCorasick<4> aho(conv);
    for(int i=0;i<p;i++) aho.add(ps[i],i);
    aho.build(false);

    memset(dp,-1,sizeof(dp));
    using T = tuple<int, int, int>;
    queue<T> que;
    for(int i=0;i<h;i++){
      for(int j=0;j<w;j++){
        if(ss[i][j]=='S'){
          dp[0][i][j]=0;
          que.emplace(0,i,j);
        }
      }
    }

    string base="URDL";
    int dy[]={-1,0,1,0};
    int dx[]={0,1,0,-1};
    auto in=[&](int y,int x){return 0<=y&&y<h&&0<=x&&x<w;};

    int ans=-1;
    while(!que.empty()){
      int p,y,x;
      tie(p,y,x)=que.front();que.pop();
      if(ss[y][x]=='G'){
        ans=dp[p][y][x];
        break;
      }
      for(int k=0;k<4;k++){
        int ny=y+dy[k],nx=x+dx[k];
        if(!in(ny,nx)||ss[ny][nx]=='#') continue;
        char c=base[k];
        int q=aho.move(p,c);
        if(aho.count(q)) continue;
        if(~dp[q][ny][nx]) continue;
        dp[q][ny][nx]=dp[p][y][x]+1;
        que.emplace(q,ny,nx);
      }
    }
    cout<<ans<<endl;
  }
  return 0;
}

