//曼哈顿距离：初始状态每个位置的数到目标状态位置的最短距离之和
//IDA* 基于深搜的一种优化算法
//当前的曼哈顿距离+已经走过的深度<=当前假定的最优解
//当前假定的最优解：初始曼哈顿距离，每搜索一次，这个值+1
//判断八数码问题是否有解： 按行的顺序将矩阵链接起来，求逆序数，忽略零，若为偶数，则有解
#include<bits/stdc++.h>
using namespace std;

int Map[4][4];
int max1,min1;
int stx,sty;
int flag;
int dir[][2]={
   -1,0,0,1,0,-1,1,0};//对称安排 
int path[10000];
int start[10];

int mhd(){
   
	int num=0;
	for(int i=0;i<3;i++){
   
		for(int j=0;j<3;j++){
   
			if(Map[i][j]==0)
				continue;
			else
				num+=fabs( (Map[i][j]-1)/3-i )+ fabs( (Map[i][j]-1)%3-j );
		}
	}
	return num;
} 

void chushi0(){
   
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			if(Map[i][j]==0){
   
				stx=i;
				sty=j;
				return;
			}
}

void dfs(int x,int y,int s,int last_step){
   
	if(flag) return;
	if(s==max1){
   
		int l=mhd();
		if(l==0){
   
			min1=s;
			flag=1;
		}
	}
	for(int i=0;i<4;i++){
   
		if(last_step+i==3&&s>0) continue;
		int dx=x+dir[i][0];
		int dy=y+dir[i][1];
		if(dx<0||dy<0||dx>=3||dy>=3) continue;
		swap(Map[dx][dy],Map[x][y]);
		if(mhd()+s<=max1&&!flag){
   
			path[s]=i;
			dfs(dx,dy,s+1,i);
			if(flag) return; 
		}
		swap(Map[dx][dy],Map[x][y]);//回溯 
	}
}

bool check(){
   
	int num=0;
	for(int i=0;i<8;i++)
		for(int j=i+1;j<8;j++)
			if(start[j]<start[i])
				num++;			//逆序数 
	if(num%2)//逆序是奇数 
		return true;			//无解 
	else
		return false;			//有解 
} 

int main(){
   
	char a[110];
	char dis[]={
   'u','r','l','d'};
	gets(a);
	int k=0;
	int sum=-1;
	for(int i=0;i<strlen(a);i++){
   
		if(a[i]==' ') continue;
		sum++;
		if(a[i]=='x')
			Map[sum/3][sum%3]=0;
		if(a[i]>='1'&&a[i]<='9')
			Map[sum/3][sum%3]=a[i]-'0';
			start[k++]=a[i]-'0';
	}
	chushi0();
	if(check()){
   
		cout<<"unsolvable\n";
		return 0;
	}
	max1=mhd();
	if(max1==0){
   
		printf("\n");
		return 0;
	}
	flag=0;
	while(!flag){
   
		dfs(stx,sty,0,0);
		if(!flag) max1++;
	}
	for(int i=0;i<min1;i++){
   
		printf("%c",dis[path[i]]);
	}
	printf("\n");
	return 0;
}