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

constexpr int INF = 1e9;
constexpr int dx[4] = {0, 1, 0, -1};
constexpr int dy[4] = {-1, 0, 1, 0};
constexpr int rot[4] = {3, 1, 0, 2};

enum {
    TOP = 0,
    FRONT,
    RIGHT,
    LEFT,
    BACK,
    BOTTOM
};

enum {
    red = 0,
    green,
    blue,
    cyan,
    magenta,
    yellow,
    white,
    black
};

string color = "rgbcmywk";

class dice {
public:
    dice() 
        : v_(6)
    {
        v_[TOP] = red;
        v_[FRONT] = magenta;
        v_[BOTTOM] = cyan;
        v_[BACK] = green;
        v_[RIGHT] = blue;
        v_[LEFT] = yellow;
    }
    dice(vector<int> const& v)
        : v_(v)
    {}

    dice roll(int dir) {
        vector<int> res(6);
        for(int i=0; i<6; ++i) {
            res[i] = v_[rot[dir][i]];
        }
        return dice(res);
    }

    int get(int idx) const {
        if(idx < 0 || 6 <= idx) {
            return -1;
        }
        return v_[idx];
    }

private:
    std::vector<int> v_;
    int rot[6][6] = {{4, 0, 2, 3, 5, 1},  // south 
                     {3, 1, 0, 5, 4, 2},  // east
                     {2, 1, 5, 0, 4, 3},  // west
                     {1, 5, 2, 3, 0, 4},  // north 
                     {0, 2, 4, 1, 3, 5},  // right(not move)
                     {0, 3, 1, 4, 2, 5}}; // left(not move)
};

struct state {
    int y, x;
    string ord;
    dice d;

    bool operator<(state const& s) const {
        auto t1 = make_tuple(y, x, d.get(TOP), d.get(FRONT), ord);
        auto t2 = make_tuple(s.y, s.x, s.d.get(TOP), s.d.get(FRONT), s.ord);
        return t1 < t2;
    }
};

int main() {
    int w, d;
    while(cin >> w >> d, w) {
        vector<string> c(d);
        int sy, sx;
        for(int i=0; i<d; ++i) {
            cin >> c[i];
            for(int j=0; j<w; ++j) {
                if(c[i][j] == '#') {
                    sy = i;
                    sx = j;
                    c[i][j] = 'w';
                }
            }
        }
        string v;
        cin >> v;
        map<state, int> memo;
        queue<state> que;
        que.push(state{sy, sx, v, dice{}});
        memo[state{sy, sx, v, dice{}}] = 0;
        int res = INF;
        while(!que.empty()) {
            auto now = que.front();
            que.pop();
            if(now.ord.size() == 0) {
                res = memo[now];
                break;
            }
            for(int i=0; i<4; ++i) {
                int ny = now.y + dy[i];
                int nx = now.x + dx[i];
                if(ny < 0 || d <= ny || nx < 0 || w <= nx || c[ny][nx] == 'k') {
                    continue;
                }
                if(c[ny][nx] == 'w') {
                    auto next = state{ny, nx, now.ord, now.d.roll(rot[i])};
                    if(memo.count(next) == 0) {
                        memo[next] = memo[now] + 1;
                        que.push(next);
                    }
                } else if(c[ny][nx] != now.ord[0]) {
                    continue;
                } else {
                    auto nd = now.d.roll(rot[i]);
                    if(color[nd.get(TOP)] != c[ny][nx]) {
                        continue;
                    }
                    auto next = state{ny, nx, now.ord.substr(1), nd};
                    if(memo.count(next) == 0) {
                        memo[next] = memo[now] + 1;
                        que.push(next);
                    }
                }
            }
        }
        if(res == INF) {
            cout << "unreachable" << endl;
        } else {
            cout << res << endl;
        }
    }
}


Measured memory_bytes: 22004