#include <bits/stdc++.h>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
string col="rcgmby";

struct dice {
	int top;
	int bottom;
	int front;
	int back;
	int left;
	int right;
	void rotate_front(){
		int tmp=top;
		top=back;
		back=bottom;
		bottom=front;
		front=tmp;
	}
	void rotate_back(){
		int tmp=top;
		top=front;
		front=bottom;
		bottom=back;
		back=tmp;
	}

	void rotate_right(){
		int tmp=top;
		top=left;
		left=bottom;
		bottom=right;
		right=tmp;
	}

	void rotate_left(){
		int tmp=top;
		top=right;
		right=bottom;
		bottom=left;
		left=tmp;
	}
};

struct trie{
	int to[26];
	int val;
	trie(){
		val=0;
	}
};

int size=1;
trie t[1<<15];

void pushTrie(int* vec,int id){
	int node=0;
	for(int i=0;i<6;i++){
		int b=vec[i];
		if(t[node].to[b]==0){
			t[node].to[b]=size++;
		}
		node=t[node].to[b];
	}
	t[node].val=id;
}

int getValue(int* vec){
	int node=0;
	for(int i=0;i<6;i++){
		int b=vec[i];
		if(t[node].to[b]==0)return 0;
		node=t[node].to[b];
	}
	return t[node].val;
}


int cnt=0;
int tmp[7];
bool used[7];
int dicecol[720][7];
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};

void dfs(int v){
	if(v==6){
		for(int i=0;i<6;i++){
			dicecol[cnt][i]=tmp[i];
		}
		pushTrie(tmp,cnt++);
	}else{
		for(int i=0;i<6;i++){
			if(used[i])continue;
			tmp[v]=i;
			used[i]=true;
			dfs(v+1);
			used[i]=false;
		}
	}
}

struct data{
	int state;
	int y,x,now;
	data(){}
	data(int ss,int yy,int xx,int nn){
		state=ss;
		y=yy;
		x=xx;
		now=nn;
	}
};

int w,h;
string ord;
int ordnum[6];
int fie[31][31];
int dp[729][31][31][7];
int sy,sx;

void solve(){
	memset(dp,-1,sizeof(dp));
	queue<data> que;
	for(int i=0;i<6;i++){
		tmp[i]=i;
	}
	data d=data(getValue(tmp),sy,sx,0);
	dp[d.state][sy][sx][0]=0;
	que.push(d);
	while(que.size()){
		data qd=que.front();
		que.pop();
		//if(qd.now>=3)printf("%d %d %d %d\n",qd.state,qd.x,qd.y,qd.now);
		dice nowdice;
		nowdice.top=dicecol[qd.state][0];
		nowdice.bottom=dicecol[qd.state][1];
		nowdice.back=dicecol[qd.state][2];
		nowdice.front=dicecol[qd.state][3];
		nowdice.right=dicecol[qd.state][4];
		nowdice.left=dicecol[qd.state][5];
		for(int i=0;i<4;i++){
			int nx=qd.x+dx[i],ny=qd.y+dy[i];
			if(nx>=0 && nx<w && ny>=0 && ny<h){
				if(fie[ny][nx]>=0){
					if(i==0)nowdice.rotate_right();
					if(i==1)nowdice.rotate_front();
					if(i==2)nowdice.rotate_left();
					if(i==3)nowdice.rotate_back();
					tmp[0]=nowdice.top;
					tmp[1]=nowdice.bottom;
					tmp[2]=nowdice.back;
					tmp[3]=nowdice.front;
					tmp[4]=nowdice.right;
					tmp[5]=nowdice.left;
					int nstate=getValue(tmp);
					if(fie[ny][nx]==0){
						if(dp[nstate][ny][nx][qd.now]==-1){
							dp[nstate][ny][nx][qd.now]=dp[qd.state][qd.y][qd.x][qd.now]+1;
							que.push(data(nstate,ny,nx,qd.now));
						}
					}

					if(fie[ny][nx]>0){
						if(nowdice.top==(fie[ny][nx]-1)){
							if(qd.now==5){
								if(ordnum[qd.now]==fie[ny][nx]){
									printf("%d\n",dp[qd.state][qd.y][qd.x][qd.now]+1);
									return;
								}
							}else{
								if(dp[nstate][ny][nx][qd.now+1]==-1 && ordnum[qd.now]==fie[ny][nx]){
									dp[nstate][ny][nx][qd.now+1]=dp[qd.state][qd.y][qd.x][qd.now]+1;
									que.push(data(nstate,ny,nx,qd.now+1));
								}
							}
						}
					}
					if(i==2)nowdice.rotate_right();
					if(i==3)nowdice.rotate_front();
					if(i==0)nowdice.rotate_left();
					if(i==1)nowdice.rotate_back();
				}
			}
		}
	}
	printf("unreachable\n");
}

int main(void){
	dfs(0);
	while(1){
		scanf("%d%d",&w,&h);
		if(w==0 && h==0)break;
		memset(fie,0,sizeof(fie));
		for(int i=0;i<h;i++){
			string c;
			cin >> c;
			for(int j=0;j<w;j++){
				if(c[j]=='k'){
					fie[i][j]=-1;
				}
				if(c[j]=='#'){
					sy=i;
					sx=j;
				}
				for(int k=0;k<6;k++){
					if(c[j]==col[k]){
						fie[i][j]=k+1;
					}
				}
			}
		}
		cin >> ord;
		for(int i=0;i<6;i++){
			for(int j=0;j<6;j++){
				if(ord[i]==col[j])ordnum[i]=j+1;
			}
		}
		solve();
	}
	return 0;
}

Measured memory_bytes: 25984