#include <bits/stdc++.h>

using namespace std;

#define int long long
#define all(v) begin(v), end(v)
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define reps(i, s, n) for(int i = (int)(s); i < (int)(n); i++)
#define min(...) min({__VA_ARGS__})
#define max(...) max({__VA_ARGS__})

template<class T1, class T2> void chmin(T1 &a, T2 b){if(a>b)a=b;}
template<class T1, class T2> void chmax(T1 &a, T2 b){if(a<b)a=b;}

using pint = pair<int, int>;
using tint = tuple<int, int, int>;
using vint = vector<int>;

const int inf = 1LL << 55;
const int mod = 1e9 + 7;

#define TOP 0
#define BOTTOM 1
#define SOUTH 2
#define NORTH 3
#define EAST 4
#define WEST 5

struct Dice {
  char face[6];
  Dice(){}
  Dice(char up, char down, char fore, char back, char right, char left) {
    face[TOP] = up;
    face[BOTTOM] = down;
    face[SOUTH] = fore;
    face[NORTH] = back;
    face[EAST] = right;
    face[WEST] = left;
  }
  void roll(int a, int b, int c, int d) {
    swap(face[a], face[c]);
    swap(face[b], face[d]);
    swap(face[c], face[d]);
  }
  void rolls() {roll(SOUTH, NORTH, TOP, BOTTOM);}
  void rolln() {roll(NORTH, SOUTH, TOP, BOTTOM);}
  void rolle() {roll(EAST, WEST, TOP, BOTTOM);}
  void rollw() {roll(WEST, EAST, TOP, BOTTOM);}
  void print() {
    printf("TOP    : %c\n", face[TOP]);
    printf("BOTTOM : %c\n", face[BOTTOM]);
    printf("SOUTH  : %c\n", face[SOUTH]);
    printf("NORTH  : %c\n", face[NORTH]);
    printf("EAST   : %c\n", face[EAST]);
    printf("WEST   : %c\n", face[WEST]);
  }
  bool operator == (const Dice& d) const {
    rep(i, 6) if(face[i] != d.face[i]) return false;
    return true;
  }
  bool operator < (const Dice& d) const {
    rep(i, 6) if(face[i] != d.face[i]) return face[i] < d.face[i];
    return false;
  }
};

struct State {
  int x, y, idx;
  Dice dice;
  State(){}
  State(int x, int y, int idx, Dice dice)
    :x(x), y(y), idx(idx), dice(dice){}
  bool operator < (const State& st) const {
    if(x != st.x) return x < st.x;
    if(y != st.y) return y < st.y;
    if(idx != st.idx) return idx < st.idx;
    return dice < st.dice;
  }
};

#define MAX_W 30
#define MAX_D 30

int w, d;
char c[MAX_D][MAX_W];
string v;

int sx, sy;
map<State, int> dist;

int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
char dir[] = {'s', 'e', 'n', 'w'};

bool in(int x, int y) {
  return 0<=x&&x<w&&0<=y&&y<d&&c[y][x]!='k';
}

int bfs() {
  dist.clear();
  Dice ini_dice = Dice('r', 'c', 'm', 'g', 'b', 'y');
  State ini_st = State(sx, sy, 0, ini_dice);
  queue<State> que;
  dist[ini_st] = 0;
  que.push(ini_st);
  while(que.size()) {
    State s = que.front(); que.pop();
    int x = s.x, y = s.y, idx = s.idx;
    Dice dice = s.dice;
    if(idx == v.size()) return dist[s];
    rep(i, 4) {
      int nx = x + dx[i], ny = y + dy[i];
      if(!in(nx, ny)) continue;
      Dice next_dice = dice;
      switch(dir[i]) {
      case 's': next_dice.rolls(); break;
      case 'e': next_dice.rolle(); break;
      case 'n': next_dice.rolln(); break;
      case 'w': next_dice.rollw(); break;
      }
      if(next_dice.face[TOP] == c[ny][nx] &&
	 v[idx] == c[ny][nx]) {
	State next_st = State(nx, ny, idx+1, next_dice);
	if(dist.count(next_st)) continue;
	dist[next_st] = dist[s]+1;
	que.push(next_st);
      } else if(c[ny][nx] == 'w') {
	State next_st = State(nx, ny, idx, next_dice);
	if(dist.count(next_st)) continue;
	dist[next_st] = dist[s]+1;
	que.push(next_st);
      }
    }
  }
  return -1;
}

signed main()
{
  cin.tie(0);
  ios_base::sync_with_stdio(0);
  cout << fixed << setprecision(12);

  while(cin >> w >> d, w || d) {
    rep(i, d) rep(j, w) {
      cin >> c[i][j];
      if(c[i][j] == '#') {
	sy = i, sx = j;
	c[i][j] = 'w';
      }
    }
    cin >> v;
    int res = bfs();
    if(~res) cout << res << endl;
    else cout << "unreachable" << endl;
  }

  return 0;
}

Measured memory_bytes: 8344