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

const int NM = 2e5, K = 200;

typedef long long int lint;
typedef complex<int> vect;
typedef set<vect, decltype([](vect a, vect b){return (array<int,2>){a.real(), a.imag()} < (array<int, 2>){b.real(), b.imag()};})> setV;

int n, m, k;

template<typename T, size_t SIZE>
struct Multarr{
	size_t N, M;
	T data[SIZE];

	Multarr(){
		N = n;
		M = m;
	}

	Multarr(int N, int M){
		this->N = N;
		this->M = M;
		memset(data, 0, sizeof(data));
	}

	T* operator[](size_t i){
		return &data[i*M];
	}

	T& operator[](vect cur){
		return data[cur.real()*M + cur.imag()];
	}
};

char buff[K+5];
int c1[K], c2[K];
int change[K];
Multarr<char, 2*NM> grid;
Multarr<int, NM> req;
Multarr<vect, NM> nex;
Multarr<setV, NM> con;

void setUpArrs(){
	grid.N = n;
	grid.M = m;
	memset(grid.data, 0, sizeof(grid.data));

	req.N = n;
	req.M = m;
	memset(req.data, 0, sizeof(req.data));

	nex.N = n;
	nex.M = m;
}

map<char, vect> dir = {{'U', vect(-1, 0)}, {'D', vect(1, 0)}, {'L', vect(0, -1)}, {'R', vect(0, 1)}};

vect move(vect cur, vect mov){
	vect v = cur+mov;
	v = vect(min(max(v.real(), 0), n-1), min(max(v.imag(), 0), m-1));
	if (grid[v] != '0'){
		return v;
	}
	return cur;
}

int ans[NM+1];

int main(){
	scanf("%d %d %d", &n, &m, &k);
	scanf("%s", buff);
	setUpArrs();
	for (int x = 0; x < n; x ++){
		scanf("%s", grid[x]);
	}
	size_t sz = 0;
	for (int x = 0; x < n; x ++){
		for (int y = 0; y < m; y ++){
			if (grid[x][y] != '0'){
				sz ++;

				vect cur(x, y);
				for (int z = 0; z < k; z ++){
					cur = move(cur, dir[buff[z]]);
				}
				nex[x][y] = cur;
				con[cur].insert(vect(x, y));
				req[cur] ++;
			}
		}
	}
	vector<vect> rem;
	for (int x = 0; x < n; x ++){
		for (int y = 0; y < m; y ++){
			if (grid[x][y] != '0'){
				vect cur(x, y);
				if (!req[cur]) rem.push_back(cur);
			}
		}
	}

	memset(ans, -1, sizeof(ans));
	memset(ans+sz, 0, sizeof(ans) - sz*sizeof(int));

	int mov = 0;
	size_t i = sz-1;
	{
		setV inter;
		for (int x = 0; x < n; x ++){
			for (int y = 0; y < m; y ++){
				if (req[x][y] >= 2){
					inter.insert(vect(x, y));
				}
			}
		}
		memset(change, 0, sizeof(change));
		setV spect;
		for (vect v: inter){
			for (vect v2: con[v]){
				spect.insert(v2);
			}
		}
		for (int x = 0; x < k; x ++){
			setV newSpect;
			for (vect cur: spect){
				vect v = move(cur, dir[buff[x]]);
				newSpect.insert(v);
			}
			change[x] = spect.size() - newSpect.size();
			swap(spect, newSpect);
		}
	}
	while (!rem.empty()){
		for (int x = 0; x < k; x ++){
			sz -= change[x];
			if (sz < 0){
				exit(0);
			}
			while (i >= sz){
				ans[i--] = mov*k + x + 1;
			}
		}
		setV recalc;
		vector<vect> nexRem;
		for (vect cur: rem){
			if (req[nex[cur]] == 2){
				recalc.insert(nex[cur]);
			}
		}
		memset(c1, 0, sizeof(c1));
		memset(c2, 0, sizeof(c2));
		{
			setV spect;
			for (vect v: recalc){
				for (vect v2: con[v]){
					spect.insert(v2);
				}
			}
			for (int x = 0; x < k; x ++){
				setV newSpect;
				for (vect cur: spect){
					vect v = move(cur, dir[buff[x]]);
					newSpect.insert(v);
				}
				c1[x] = spect.size() - newSpect.size();
				swap(spect, newSpect);
			}
		}
		for (vect cur: rem){
			if (req[nex[cur]] == 2){
				recalc.erase(nex[cur]);
			}
			req[nex[cur]] --;
			con[nex[cur]].erase(cur);
			if (!req[nex[cur]]) nexRem.push_back(nex[cur]);
		}
		{
			setV spect;
			for (vect v: recalc){
				for (vect v2: con[v]){
					spect.insert(v2);
				}
			}
			for (int x = 0; x < k; x ++){
				setV newSpect;
				for (vect cur: spect){
					vect v = move(cur, dir[buff[x]]);
					newSpect.insert(v);
				}
				c2[x] = spect.size() - newSpect.size();
				swap(spect, newSpect);
			}
		}
		for (int x = 0; x < k; x ++){
			change[x] -= c1[x] - c2[x];
		}
		swap(nexRem, rem);
		mov ++;
	}


	for (int x = 1; x <= n*m; x ++){
		printf("%d\n", ans[x]);
	}
}