#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;

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

inline bool out(int x, int y, int w, int h) {
	return x < 0 || y < 0 || x >= w || y >= h;
}

const string INIT = "rcgmby";
enum FACE { TOP, BOTTOM, NORTH, SOUTH, EAST, WEST, NUM };

struct dice {
	string colors;

	dice(const string &colors_ = INIT):colors(colors_) {}

	inline void roll(FACE a, FACE b, FACE c, FACE d) {
		const int t = colors[a];
		colors[a] = colors[b];
		colors[b] = colors[c];
		colors[c] = colors[d];
		colors[d] = t;
	}

	char operator[](FACE f) const { return colors[f]; }
};

inline void north(dice &die) { die.roll(TOP, SOUTH, BOTTOM, NORTH); }
inline void south(dice &die) { die.roll(TOP, NORTH, BOTTOM, SOUTH); }
inline void  east(dice &die) { die.roll(TOP,  WEST, BOTTOM,  EAST); }
inline void  west(dice &die) { die.roll(TOP,  EAST, BOTTOM,  WEST); }

int code[128];

inline void init() {
	rep(i, INIT.size()) {
		code[INIT[i]] = i + 1;
	}
}

inline int encode(const dice &die) {
	int res = 0;
	for(const auto &c : die.colors) {
		res = res * 10 + code[c] ;
	}
	return res;
}

inline dice decode(int d) {
	string colors;
	while(d > 0) {
		colors = INIT[d % 10 - 1] + colors;
		d /= 10;
	}
	return dice(colors);
}

struct state {
	int x, y, i, d;
	state(int x_, int y_, int i_, int d_):x(x_), y(y_), i(i_), d(d_) {}

	inline bool operator<(const state &s) const {
		if(x != s.x) return x < s.x;
		if(y != s.y) return y < s.y;
		if(i != s.i) return i < s.i;
		return d < s.d;
	}
};

string bfs(int sx, int sy, const string &order, const vector<string> &field) {
	static constexpr int dx[] = {0, 0, 1, -1};
	static constexpr int dy[] = {-1, 1, 0, 0};
	static const map<int, function<void(dice&)>> f{{0, &north}, {1, &south}, {2, &east}, {3, &west}};

	const int h = field.size();
	const int w = field[0].size();

	queue<state> que;
	map<state, int> dist;

	const state ini(sx, sy, 0, encode(dice()));
	que.push(ini);
	dist[ini] = 0;

	while(!que.empty()) {
		const state s = que.front();
		que.pop();

		const dice current_dice = decode(s.d);
		const int next_dist = dist[s] + 1;

		rep(d, 4) {
			const int nx = s.x + dx[d];
			const int ny = s.y + dy[d];

			if(out(nx, ny, w, h) || field[ny][nx] == 'k') continue;

			int next_idx = s.i;
			dice next_dice = current_dice;
			f.at(d)(next_dice);

			if(field[ny][nx] != 'w') {
				if(field[ny][nx] != order[next_idx] || field[ny][nx] != next_dice[TOP]) {
					continue;
				}

				if(++next_idx == order.size()) return to_string(next_dist);
			}

			const state next_state(nx, ny, next_idx, encode(next_dice));
			if(!dist.count(next_state)) {
				dist[next_state] = next_dist;
				que.push(next_state);
			}
		}
	}
	return "unreachable";
}

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

	init();

	for(int w, h; cin >> w >> h && w;) {
		vector<string> field(h);
		for(auto &e : field) cin >> e;

		string order;
		cin >> order;

		int sx, sy;
		rep(y, h) {
			rep(x, w) {
				if(field[y][x] == '#') {
					sx = x;
					sy = y;
					field[y][x] = 'w';
					break;
				}
			}
		}
		cout << bfs(sx, sy, order, field) << endl;
	}


	return EXIT_SUCCESS;
}

Measured memory_bytes: 5340