#include<bits/stdc++.h>

using namespace std;

struct Dice
{
  int x, y;
  int l, r, f, b, d, u;

  void RollN()
  {
    ++y;
    int buff = d;
    d = f;
    f = u;
    u = b;
    b = buff;
  }

  void RollS()
  {
    --y;
    int buff = d;
    d = b;
    b = u;
    u = f;
    f = buff;
  }

  void RollL() // ----->
  {
    int buff = f;
    f = l;
    l = b;
    b = r;
    r = buff;
  }

  void RollR() // <------
  {
    int buff = f;
    f = r;
    r = b;
    b = l;
    l = buff;
  }

  void RollE() // .o -> o.
  {
    --x;
    int buff = d;
    d = l;
    l = u;
    u = r;
    r = buff;
  }


  void RollW() // o. -> .o
  {
    ++x;
    int buff = d;
    d = r;
    r = u;
    u = l;
    l = buff;
  }


  vector< Dice > makeDice()
  {
    vector< Dice > ret;
    for(int i = 0; i < 6; i++) {
      Dice d(*this);
      if(i == 1) d.RollN();
      if(i == 2) d.RollS();
      if(i == 3) d.RollS(), d.RollS();
      if(i == 4) d.RollL();
      if(i == 5) d.RollR();
      for(int j = 0; j < 4; j++) {
        ret.emplace_back(d);
        d.RollE();
      }
    }
    return (ret);
  }

  bool operator<(const Dice &p) const
  {
    auto latte = make_tuple(x, y, l, r, f, b, d, u);
    auto malta = make_tuple(p.x, p.y, p.l, p.r, p.f, p.b, p.d, p.u);
    return (latte < malta);
  }
};

int main()
{
  int W, H;
  string S[30];


  while(cin >> W >> H, W) {
    int sx, sy;
    for(int i = 0; i < H; i++) {
      cin >> S[i];
      for(int j = 0; j < W; j++) {
        if(S[i][j] == '#') {
          sx = j;
          sy = i;
          S[i][j] = 'w';
        }
      }
    }

    Dice dice;
    dice.u = 'r';
    dice.d = 'c';
    dice.b = 'g';
    dice.f = 'm';
    dice.r = 'b';
    dice.l = 'y';
    dice.x = sx;
    dice.y = sy;

    string D;
    cin >> D;

    map< Dice, int > dp[7];
    queue< pair< int, Dice > > que;
    que.emplace(0, dice);
    dp[0][dice] = 0;

    bool flag = false;
    while(!que.empty()) {
      auto p = que.front();
      int cost = dp[p.first][p.second];
      que.pop();

      if(p.first == 6) {
        cout << cost << endl;
        flag = true;
        break;
      }
      {
        Dice q = p.second;
        q.RollE();
        if(0 <= q.x && q.x < W && 0 <= q.y && q.y < H) {
          if(S[q.y][q.x] == 'w') {
            if(!dp[p.first].count(q)) {
              dp[p.first][q] = cost + 1;
              que.emplace(p.first, q);
            }
          } else if(S[q.y][q.x] == D[p.first] && q.u == D[p.first]) {
            if(!dp[p.first + 1].count(q)) {
              dp[p.first + 1][q] = cost + 1;
              que.emplace(p.first + 1, q);
            }
          }
        }
      }
      {
        Dice q = p.second;
        q.RollW();
        if(0 <= q.x && q.x < W && 0 <= q.y && q.y < H) {
          if(S[q.y][q.x] == 'w') {
            if(!dp[p.first].count(q)) {
              dp[p.first][q] = cost + 1;
              que.emplace(p.first, q);
            }
          } else if(S[q.y][q.x] == D[p.first] && q.u == D[p.first]) {
            if(!dp[p.first + 1].count(q)) {
              dp[p.first + 1][q] = cost + 1;
              que.emplace(p.first + 1, q);
            }
          }
        }
      }
      {
        Dice q = p.second;
        q.RollN();
        if(0 <= q.x && q.x < W && 0 <= q.y && q.y < H) {
          if(S[q.y][q.x] == 'w') {
            if(!dp[p.first].count(q)) {
              dp[p.first][q] = cost + 1;
              que.emplace(p.first, q);
            }
          } else if(S[q.y][q.x] == D[p.first] && q.u == D[p.first]) {
            if(!dp[p.first + 1].count(q)) {
              dp[p.first + 1][q] = cost + 1;
              que.emplace(p.first + 1, q);
            }
          }
        }
      }
      {
        Dice q = p.second;
        q.RollS();
        if(0 <= q.x && q.x < W && 0 <= q.y && q.y < H) {
          if(S[q.y][q.x] == 'w') {
            if(!dp[p.first].count(q)) {
              dp[p.first][q] = cost + 1;
              que.emplace(p.first, q);
            }
          } else if(S[q.y][q.x] == D[p.first] && q.u == D[p.first]) {
            if(!dp[p.first + 1].count(q)) {
              dp[p.first + 1][q] = cost + 1;
              que.emplace(p.first + 1, q);
            }
          }
        }
      }
    }

    if(!flag) cout << "unreachable" << endl;
  }

}

Measured memory_bytes: 8072