#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
#include <list>

using namespace std;

#ifdef _MSC_VER
#define __typeof__ decltype
template <class T> int __builtin_popcount(T n) { return n ? 1 + __builtin_popcount(n & (n - 1)) : 0; }
#endif

#define foreach(it, c) for (__typeof__((c).begin()) it=(c).begin(); it != (c).end(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define popcount __builtin_popcount

#define rep(i, n) for (int i = 0; i < n; ++i)

template <class T> void max_swap(T& a, const T& b) { a = max(a, b); }
template <class T> void min_swap(T& a, const T& b) { a = min(a, b); }

typedef long long ll;
typedef pair<int, int> pint;

const double PI = acos(-1.0);
const int dx[] = { 0, 1, 0, -1 };
const int dy[] = { 1, 0, -1, 0 };


vector<int> build_pma(const vector<int>& pat)
{
	vector<int> res(pat.size() + 1);
	res[0] = -1;
	for (int i = 0, j = -1; i < pat.size(); ++i)
	{
		while (j >= 0 && pat[i] != pat[j])
			j = res[j];
		res[i + 1] = ++j;
	}
	return res;
}
ll encode(const vector<int>& states)
{
	ll res = 0;
	for (int i = states.size() - 1; i >= 0; --i)
		res = res << 4 | states[i];
	return res;
}
void decode(ll e, vector<int>& res)
{
	for (int i = 0; i < res.size(); ++i, e >>= 4)
		res[i] = e & 0xf;
}
ll next_states(const vector<vector<int> >& pat, const vector<vector<int> >& pma, ll states, int dir)
{
	ll res = 0;
	vector<int> cur(pat.size()), next;
	decode(states, cur);
	for (int i = 0; i < cur.size(); ++i)
	{
		while (cur[i] >= 0 && pat[i][cur[i]] != dir)
			cur[i] = pma[i][cur[i]];
		if (++cur[i] == pat[i].size())
			return -1;
		next.push_back(cur[i]);
	}
	return encode(next);
}
struct Node
{
	int x, y;
	ll states;
	Node(int x, int y, ll s)
		: x(x), y(y), states(s) {}
};
int main()
{
	int n, m, p;
	while (cin >> n >> m, n | m)
	{
		string maze[64], pp[16];
		rep (i, n)
			cin >> maze[i];
		cin >> p;
		rep (i, p)
			cin >> pp[i];

		int sx, sy, gx, gy;
		rep (y, n)
		{
			rep (x, m)
			{
				if (maze[y][x] == 'S')
					sx = x, sy = y;
				else if (maze[y][x] == 'G')
					gx = x, gy = y;
			}
		}

		vector<vector<int> > pat(p);
		rep (i, p)
			rep (j, pp[i].size())
				pat[i].push_back(string("DRUL").find(pp[i][j]));

		vector<vector<int> > pma(p);
		rep (i, p)
			pma[i] = build_pma(pat[i]);

		int res = -1;
		map<ll, int> visit[64][64];
		queue<Node> q;
		q.push(Node(sx, sy, 0));
		visit[sy][sx][0] = 0;
		vector<int> s(p);
		while (!q.empty())
		{
			Node cur = q.front(); q.pop();
			int cost = visit[cur.y][cur.x][cur.states] + 1;
			for (int i = 0; i < 4; ++i)
			{
				int nx = cur.x + dx[i], ny = cur.y + dy[i];
				if (0 <= nx && nx < m && 0 <= ny && ny < n
					&& maze[ny][nx] != '#')
				{
					ll ns = next_states(pat, pma, cur.states, i);
					if (ns != -1 && !visit[ny][nx].count(ns))
					{
						decode(ns, s);
						if (nx == gx && ny == gy)
						{
							res = cost;
							goto End;
						}
						else
						{
							q.push(Node(nx, ny, ns));
							visit[ny][nx][ns] = cost;
						}
					}
				}
			}
		}
End:
		cout << res << endl;
	}
}

Measured memory_bytes: 0