#include <iostream>
#include <vector>
#include <cstring>
#include <string>
#include <algorithm>
#include <iomanip>
#include <cmath>
#include <cassert>
#include <map>
#include <set>
#include <queue>
using namespace std;
#define rep(i,n) for(int i = 0; i < (int)(n); i++)

enum { U, F, R, D, B, L };
struct Dice {
	int face[6];
	Dice() { face[F] = 1; face[R] = 2; face[U] = 3; face[B] = 6; face[L] = 5; face[D] = 4; }
	int find_face(int f) {
		rep(i, 6) if(face[i] == f) return i;
		return -1;
	}
	void turn(int dir) {
		switch(dir) {
		case R: rotate(U, R, D, L); break;
		case B: rotate(U, B, D, F); break;
		case L: rotate(U, L, D, R); break;
		case F: rotate(U, F, D, B); break;
		case U: rotate(F, R, B, L); break; // ??????????????????????¨???????
		case D: rotate(F, L, B, R); break; // ??????????????????????¨???????
		default: assert(false);
		}
	}
	int & operator[](int n) { return face[n]; }
	vector<Dice> all() {
		vector<Dice> res;
		rep(k, 6) {
			rep(i, 4) { res.push_back(*this); turn(R); }
			if(k & 1) turn(U); else turn(F);
		}
		return res;
	}
	void rotate(int a, int b, int c, int d) {
		int t = face[d];
		face[d] = face[c]; face[c] = face[b]; face[b] = face[a]; face[a] = t;
	}
};

string b[30];

struct S {
	int x, y, t;
	Dice d;
	S() {}
	S(int x, int y, int t, Dice d) : x(x), y(y), t(t), d(d) {
	}
};

int w, h, sx = -1, sy = -1;
// [y][x][F][R][U][t]
int dist[30][30][7][7][7][7];

bool in(int x, int y) {
	return 0 <= x && x < w && 0 <= y && y < h;
}

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);

	string s;
	while(cin >> w >> h, w | h) {
		for(int i = 0; i < h; i++) {
			cin >> b[i];
			for(int j = 0; j < w; j++) {
				if(b[i][j] == '#') {
					sx = j, sy = i;
					b[i][j] = 'w';
				}
			}
		}
		cin >> s;
		map<char, int> ord;
		for(int i = 0; i < 6; i++) {
			ord[s[i]] = i;
		}

		// [y][x][F][R][U][t]
		Dice dice;
		queue<S> q;
		q.push(S(sx, sy, 0, dice));

		memset(dist, -1, sizeof dist);
		dist[sy][sx][dice[F]][dice[R]][dice[U]][0] = 0;

		while(q.size()) {
			int x = q.front().x, y = q.front().y, t = q.front().t;
			dice = q.front().d;
			q.pop();

			int d = dist[y][x][dice[F]][dice[R]][dice[U]][t];

			char color[7] = { ' ', 'm', 'b', 'r', 'c', 'y', 'g' };
			//cout << "F " << color[dice[F]] << " R " << color[dice[R]] << " U " << color[dice[U]] << endl;
			assert(d != -1);

			int dx[4] = { 1, 0, -1, 0 }, dy[4] = { 0, 1, 0, -1 };
			int dir[4] = { R, F, L, B };
			for(int k = 0; k < 4; k++) {
				int nx = x + dx[k], ny = y + dy[k];
				if(!in(nx, ny) || b[ny][nx] == 'k') continue;

				Dice nd = dice;
				nd.turn(dir[k]);

				//cout << "  F " << color[nd[F]] << " R " << color[nd[R]] << " U " << color[nd[U]] << endl;

				int nt = t;
				if(b[ny][nx] != 'w') {
					char c = b[ny][nx];
					if(ord[c] != t) continue;
					if(c != color[nd[U]]) continue;
					nt++;
				}

				if(dist[ny][nx][nd[F]][nd[R]][nd[U]][nt] != -1) continue;
				dist[ny][nx][nd[F]][nd[R]][nd[U]][nt] = d + 1;
				q.push(S(nx, ny, nt, nd));
			}
		}

		int ans = 1 << 28;
		for(int y = 0; y < h; y++) {
			for(int x = 0; x < w; x++) {
				for(int f = 0; f < 7; f++) {
					for(int r = 0; r < 7; r++) {
						for(int u = 0; u < 7; u++) {
							if(dist[y][x][f][r][u][6] == -1) continue;
							ans = min(ans, dist[y][x][f][r][u][6]);
						}
					}
				}
			}
		}
		if(ans == 1 << 28) {
			cout << "unreachable" << endl;
		}
		else {
			cout << ans << endl;
		}
	}
}

Measured memory_bytes: 11560