#include <bits/stdc++.h>
using namespace std;
 
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define EACH(it, cont) for (auto &it : cont)
#define FOR(i, b, e)  for (int i = (b); i <= (e); ++i)
#define FORD(i, b, e) for (int i = (b); i >= (e); --i)
#define ALL(c)   begin(c), end(c)

#define dump     fancy_dumper::DumpFirst<&std::cerr>(),
#define say      fancy_dumper::DumpFirst<&std::cout>(),
#define $dump    fancy_dumper::Dumper<&std::cerr>
#define $say     fancy_dumper::Dumper<&std::cout>
#define $(x) #x, fancy_dumper::ToggleSeparator(), (x),\
				 fancy_dumper::ToggleSeparator()
 
namespace fancy_dumper {
 
struct ToggleSeparator { };
 
template<std::ostream *Out>
struct DumpFirst { };
 
template<std::ostream *Out>
struct Dumper {
	static void *&last() {
		static void *p;
		return p;
	}
	static const char *&separator() {
		static const char *s = " ";
		return s;
	}
	static const char *&separatorNewLine() {
		static const char *s = "\n";
		return s;
	}
	static const char *&unseparator() {
		static const char *s = "=";
		return s;
	}
	Dumper() {
		last() = this;
	}
	~Dumper() {
		if (this == last()) {
			*Out << separatorNewLine();
			last() = 0;
		}
	}
	Dumper operator, (ToggleSeparator) {
		std::swap(separator(), unseparator());
		return Dumper();
	}
};
 
template<std::ostream *Out, class T>
Dumper<Out> operator,(Dumper<Out>, const T &e) {
	*Out << Dumper<Out>::separator() << e;
	return Dumper<Out>();
}
 
template<std::ostream *Out, class T>
Dumper<Out> operator, (DumpFirst<Out>, const T &e) {
	*Out << e;
	return Dumper<Out>();
}
 
}
 
template<class T, class Y>
std::ostream &operator<< (std::ostream &o, const std::pair<T, Y> &p) {
	return o << p.first << ' ' << p.second;
}
 
template<class T>
std::ostream &operator<< (std::ostream &o, const std::vector<T> &v) {
	bool isBegin = true;
	EACH (e, v) {
		if (!isBegin) { o << ' '; }
		isBegin = false;
		o << e;
	}
	return o;
}
 
template<class T>
std::ostream &operator<< (std::ostream &o, const std::set<T> &v) {
	bool isBegin = true;
	EACH (e, v) {
		if (!isBegin) { o << ' '; }
		isBegin = false;
		o << e;
	}
	return o;
}

template<class T>
std::ostream &operator,(std::ostream &o, const T &t) {
	return o << t;
}
 
struct StdinReader {
	StdinReader() { std::ios::sync_with_stdio(0); }
} stdinReader;
#define get stdinReader,
 
template<class T> StdinReader &operator, (StdinReader &sr, T &t) { std::cin >> t; return sr; }
template<class T> StdinReader &operator, (StdinReader &sr, std::vector<T> &v) { EACH (x, v) sr, x; return sr; }
template<class T, class U> StdinReader &operator, (StdinReader &sr, std::pair<T, U> &p) { return sr, p.first, p.second; }

struct GetSizeHelper {
	int s;
	operator int  () const { return s; }
	operator bool () const { return s; }
	template<class T> GetSizeHelper(const T &t) : s((int) size(t)) {}
};
#define isize (GetSizeHelper) 
template <class T, class U> bool remin(T &a, const U &b) { return b < a ? a = b, true : false; }
template <class T, class U> bool remax(T &a, const U &b) { return b > a ? a = b, true : false; }

const int inf = 1000000001;
using ll = long long;

// code starts here

struct Lam {
	int Y, X;
	vector<string> M, M2;
	string Q;
	int mhash;

	Lam() {
		get Y, X;
		M.resize(Y);
		int _;
		get M, _, Q;
	}

	//~ DDDDDDPPPPPPDDDDDDDDGGGGGDDDPPPLPLPLPLPLPLPLLPDDDLDLDLLDLDLLDLDL
	//~ (1) ... -> DPDPDLDLDLDLDLDLDL
	//~ (2) ... -> DL
	// output is some combination of basic 4 letters,
	// concatenated multiple times (could be 1.25 for 5 letters or 0.5 for just 2).
	void simplify() {
		string s;
		s += Q[0];
		EACH (c, Q) {
			// (1)
			// replace runs on horizontal or vertical moves by last one
			if (type(c) == type(s.back()))
				s.back() = c;
			else
				s += c;

			// (2)
			// don't double previous move (as we are already on that border)
			// (x)GPG -> (x)GP
			// GPDG -> GP
			if (s.size() >= 3  && s[s.size()-3] == s.back())
				s.pop_back();
		}
		Q = s;
	}

	static char type(char c) {
		if (c == 'L' || c == 'P')
			return 'H';
		return 'V'; // G || D
	}

	void loop() {
		// first two steps are moving things to the corner,
		// but for faster comparision it's ok to do up to fourth,
		// so we get to the GL or LG (corner).
		// It also makes no sense to even consider that if the k is <7
		if (Q.size() < 7) {
			while (step()) {
			}
			return;
		}

		int GLidx = 2;
		while (!((Q[GLidx-2] ^ Q[GLidx-1]) == ('G'^'L'))) {
			++GLidx;
		}

		REP (_, GLidx)
			step();

		if (!init_sum()) {
			dump "only dots on map!";
			return;
		}

		// check if we are in the same GL position each 4 steps
		while (step() && step() && step() && step()) {
			if (eq())
				break;
		}

		int cycle_len = step_cnt - GLidx;
		int left = (isize Q) - step_cnt;
		dump $(cycle_len), $(left);
		left %= cycle_len;

		REP (_, left) {
			step();
		}
	}

	int step_cnt = 0;
	bool step() {
		if (step_cnt >= isize Q)
			return false;
		step_cnt++;

		int dy = 0, dx = 0, by = 0, bx = 0;
		switch (Q[step_cnt-1]) {
			case 'G': dy = +1; break;
			case 'D': dy = -1; by = Y-1; break;
			case 'L': dx = +1; break;
			case 'P': dx = -1; bx = X-1; break;
			default: return false;
		}
		for (int x = 0; dy && x < X; ++x) {
			int oy = by;
			int iy = oy+dy;
			for (;iy >= 0 && iy < Y; iy += dy) {
				if (M[iy][x] == '.') {
					continue;
				}
				while (oy != iy && M[oy][x] != '.') {
					oy += dy;
				}
				if (oy == iy) {
					continue;
				}
				swap(M[oy][x], M[iy][x]);
			}
		}
		for (int y = 0; dx && y < Y; ++y) {
			int ox = bx;
			int ix = ox+dx;
			for (; ix >= 0 && ix < X; ix += dx) {
				if (M[y][ix] == '.')
					continue;
				while (ox != ix && M[y][ox] != '.')
					ox += dx;
				if (ox == ix)
					continue;
				swap(M[y][ix], M[y][ox]);
			}
		}

		return true;
	}

	bool init_sum() {
		M2 = M;
		int y = 0;
		for (; y < Y; ++y) {
			if (M2[y][0] == '.')
				break;
			auto pos = M2[y].find('.');
			if (pos != string::npos)
				M2[y].erase(pos);
		}
		M2.resize(y);
		return y;
	}

	bool eq() const {
		REP (y, isize M2) {
			if (M2[y].compare(0, M2[y].size(), M[y], 0, M2[y].size())) {
				return false;
			}
		}
		return true;
	}

	void out() {
		EACH (l, M) {
			say l;
		}
	}
};

int main() {
	Lam lam;
	lam.simplify();
	lam.loop();
	lam.out();
	if (isize lam.Q < 40)
		dump $(lam.Q);
	dump $(lam.step_cnt);
}