#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
using namespace std;
typedef long long  ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
typedef double ld;
typedef complex<ld> Point;
const ll INF = mod * mod;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
const ld eps = 1e-6;
const ld pi = acos(-1.0);
typedef pair<ld, ld> LDP;
typedef pair<ll, ll> LP;

typedef vector<int> vec;

//上、前、右、奥、左、下の順に
struct dice {
	int f[6];
	dice() {}
	dice(vector<int> &v) {
		rep(i, 6)f[i] = v[i];
	}
	dice(int x) {
		rep(i, 6) {
			f[i] = x % 2;
			x /= 2;
		}
	}
	bool operator<(const dice &r)const {
		rep(i, 5)if (f[i] != r.f[i])return f[i] < r.f[i];
		return f[5] < r.f[5];
	}
};
int calc(dice &d) {
	int ret = 0;
	int s = 1;
	rep(i, 6) {
		if (d.f[i])ret += s;
		s *= 2;
	}
	return ret;
}
dice ident(int a, int b) {
	dice res;
	int c;
	if (a == 1) {
		if (b == 2)c = 3;
		else if (b == 3)c = 5;
		else if (b == 5)c = 4;
		else c = 2;
	}
	else if (a == 2) {
		if (b == 1)c = 4;
		else if (b == 4)c = 6;
		else if (b == 6)c = 3;
		else c = 1;
	}
	else if (a == 3) {
		if (b == 1)c = 2;
		else if (b == 2)c = 6;
		else if (b == 5)c = 1;
		else c = 5;
	}
	else if (a == 4) {
		if (b == 1)c = 5;
		else if (b == 5)c = 6;
		else if (b == 6)c = 2;
		else c = 1;
	}
	else if (a == 5) {
		if (b == 1)c = 3;
		else if (b == 3)c = 6;
		else if (b == 6)c = 4;
		else c = 1;
	}
	else {
		if (b == 2)c = 4;
		else if (b == 3)c = 2;
		else if (b == 5)c = 3;
		else c = 5;
	}

	vector<int> z = { a,b,c,7 - b,7 - c,7 - a };
	dice ret(z);
	return ret;
}
dice rollfront(dice x) {
	vector<int> z = { x.f[3],x.f[0],x.f[2],x.f[5],x.f[4],x.f[1] };
	dice ret(z);
	return ret;
}
dice rollback(dice x) {
	vector<int> z = { x.f[1],x.f[5],x.f[2],x.f[0],x.f[4],x.f[3] };
	dice ret(z);
	return ret;
}
dice rollright(dice x) {
	vector<int> z = { x.f[4],x.f[1],x.f[0],x.f[3],x.f[5],x.f[2] };
	dice ret(z);
	return ret;
}
dice rollleft(dice x) {
	vector<int> z = { x.f[2],x.f[1],x.f[5],x.f[3],x.f[0],x.f[4] };
	dice ret(z);
	return ret;
}

int dx[4] = { -1,0,1,0 };
int dy[4] = { 0,1,0,-1 };
dice roll(dice x, int t) {
	if (t == 0) {
		x = rollback(x);
	}
	else if (t == 1) {
		x = rollright(x);
	}
	else if (t == 2) {
		x = rollfront(x);
	}
	else {
		x = rollleft(x);
	}
	return x;
}

int h, w;
char mp[30][30];
map<dice, bool> used[30][30][6];
struct vertice {
	int x, y, c; dice d;
};

void solve() {
	int sx, sy;
	rep(i, h) {
		rep(j, w) {
			cin >> mp[i][j];
			rep(k, 6)used[i][j][k].clear();
			if (mp[i][j] == '#') {
				mp[i][j] = 'w';
				sx = i, sy = j;
			}
		}
	}
	string s; cin >> s;
	string init = "rmbgyc";
	vec sta(6);
	rep(i, 6) {
		rep(j, 6)if (init[i] == s[j])sta[i] = j;
	}
	queue<vertice> q;
	q.push({ sx,sy,0,sta });
	used[sx][sy][0][sta] = true;
	int tmp = 0;
	while (!q.empty()) {
		tmp++;
		int len = q.size();
		rep(aa, len) {
			vertice v = q.front(); q.pop();
			//cout << v.x << " " << v.y << endl;
			rep(j, 4) {
				dice r = roll(v.d, j);
				int nx = v.x + dx[j], ny = v.y + dy[j], nc = v.c;
				if (nx < 0 || ny < 0 || nx >= h || ny >= w)continue;
				if (mp[nx][ny] == 'k')continue;
				if (mp[nx][ny] != 'w') {
					if (s[nc] != mp[nx][ny])continue;
					if (r.f[0] != nc)continue;
					nc++;
				}
				if (nc == 6) {
					cout << tmp << endl; return;
				}
				if (used[nx][ny][nc][r])continue;
				used[nx][ny][nc][r] = true;
				q.push({ nx,ny,nc,r });
			}
		}
	}
	cout << "unreachable" << endl;
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	while (cin >> w >> h, h)solve();
	//solve();
	//stop
	return 0;
}

