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

#define rep(i,x,y) for(int i=(x);i<(y);++i)
#define debug(x) #x << "=" << (x)

#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif



const int inf=1e9;
const int64_t inf64=1e18;
const double eps=1e-9;

template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec){
    os << "[";
    for (const auto &v : vec) {
    	os << v << ",";
    }
    os << "]";
    return os;
}

using i64=int64_t;

const int alphabet_size=4;
char table[4]={'R','U','L','D'};
class pma{
public:
    pma* next[alphabet_size],*failure;
    vector<int> matches;
    string s;
    pma(){
        fill(next,next+alphabet_size,(pma*)0);
        failure=NULL;
    }
    void insert(const string &str,const int id){ insert(str,0,id); }
    void insert(const string &str,const int idx,const int id){
        s=str.substr(0,idx);
        if(idx==str.size()){
            matches.push_back(id);
            return;
        }
        if(next[str[idx]]==NULL) this->next[str[idx]]=new pma();
        next[str[idx]]->insert(str,idx+1,id);
    }
};

//ofstream ofs("graph.dot");

string convert(string s){
    string res;
    //for(char c:s) res+=table[c];
    return res;
}

void add_edge(pma* from,pma*to,string label){
    /*
    ofs << "    \"";
    ofs << convert(from->s);
    ofs << "\" -> \"";
    ofs << convert(to->s);
    ofs << "\" [label = \"" << label << "\"];" << endl;
    */
}

class aho_corasick{
public:
    vector<string> dic;
    pma* root;
    aho_corasick(const vector<string>& dic_):dic(dic_),root(new pma()){
        for(int i=0; i<dic.size(); ++i) root->insert(dic[i],i);
        root->failure=root;
        queue<pma*> que;
        que.push(root);
        add_edge(root,root,"failure");
        while(!que.empty()){
            pma* curr=que.front();
            que.pop();
            vector<bool> original_link(alphabet_size,true);
            curr->matches.insert(curr->matches.end(),curr->failure->matches.begin(),curr->failure->matches.end());
            for(int i=0; i<alphabet_size; ++i){
                pma*& next=curr->next[i];
                if(next==NULL){
                    if(curr==root) next=root;
                    else next=curr->failure->next[i];
                    //curr->matches.insert(curr->matches.end(),next->matches.begin(),next->matches.end());
                    original_link[i]=false;
                    add_edge(curr,curr->next[i],string(1,table[i]));
                    continue;
                }
            }
            for(int i=0; i<alphabet_size; ++i){
                if(!original_link[i]) continue;
                pma*& next=curr->next[i];
                if(curr==root) next->failure=root;
                else next->failure=curr->failure->next[i];
                next->matches.insert(next->matches.end(),curr->matches.begin(),curr->matches.end());
                que.push(next);
                add_edge(curr,next,string(1,table[i]));
                add_edge(next,next->failure,"failure");
            }
        }
    }
    vector<bool> match(const string& s)const{
        vector<bool> res(dic.size());
        const pma* state=root;
        for(char c:s){
            state=state->next[c];
            for(int i:state->matches) res[i]=true;
        }
        return res;
    }
};

void solve(int N,int M){
    vector<string> vs(N);
    int sy,sx,gy,gx;
    rep(i,0,N){
        cin >> vs[i];
        rep(j,0,M){
            if(vs[i][j]=='S'){
                sy=i;
                sx=j;
            }
            if(vs[i][j]=='G'){
                gy=i;
                gx=j;
            }
        }
    }

    int P;
    cin >> P;
    vector<string> ban(P);
    rep(i,0,P){
        cin >> ban[i];
        for(char& c:ban[i]){
            if(c=='R') c=0;
            if(c=='U') c=1;
            if(c=='L') c=2;
            if(c=='D') c=3;
        }
    }

    aho_corasick ac(ban);
    vector<int> dx={1,0,-1,0},dy={0,-1,0,1};
    queue<tuple<int,int,pma*,int>> que;
    set<tuple<int,int,pma*>> visited;
    que.push(make_tuple(sy,sx,ac.root,0));
    visited.insert(make_tuple(sy,sx,ac.root));
    
    while(!que.empty()){
        int y,x,d;
        pma* curr;
        tie(y,x,curr,d)=que.front();
        que.pop();
        if(y==gy and x==gx){
            cout << d << endl;
            return;
        }
        rep(i,0,4){
            int ny=y+dy[i],nx=x+dx[i];
            if(ny<0 or N<=ny or nx<0 or M<=nx or vs[ny][nx]=='#') continue;
            pma* next=curr->next[i];
            if(!next->matches.empty()){
                //print(convert(curr->s));
                //print(convert(next->s));
                continue;
            }
            if(visited.find(make_tuple(ny,nx,next))!=visited.end()) continue;
            que.push(make_tuple(ny,nx,next,d+1));
            visited.insert(make_tuple(ny,nx,next));
        }
    }
    cout << -1 << endl;
    /*
    function<int(int,int,pma*)> rec=[&](int y,int x,pma* state){
        if(memo[y][x].find(state)!=memo[y][x].end()) return memo[y][x][state];
        if(y==gy and x==gx) return memo[y][x][state]=0;
        memo[y][x][state]=inf;
        for(char c:state->s) cerr << int(c);
                cerr << endl;
        rep(i,0,4){
            int ny=y+dy[i],nx=x+dx[i];
            if(ny<0 or N<=ny or nx<0 or M<=nx or vs[ny][nx]=='#') continue;
            pma* next_state=state->next[i];
            if(!next_state->ids.empty()){
                cerr << "BAN" << endl;
                for(char c:next_state->s) cerr << int(c);
                cerr << endl;
                continue;
            }
            memo[y][x][state]=min(memo[y][x][state],rec(ny,nx,next_state)+1);
        }
        return memo[y][x][state];
    };

    int ans=rec(sy,sx,ac.root);
    if(ans==inf) ans=-1;
    cout << ans << endl;
    */
}

int main(){
    std::cin.tie(0);
    std::ios::sync_with_stdio(false);
    cout.setf(ios::fixed);
    cout.precision(10);
    //ofs << "digraph G {" << endl << "    graph [layout = dot];" << endl << "    node [shape = \"ellipse\"];" << endl;
    for(;;){
        int N,M;
        cin >> N >> M;
        if(!N and !M) break;
        solve(N,M);
    }
    //ofs << "}" << endl;
    return 0;
}

Measured memory_bytes: 9136