#include <queue>

#include <cmath>

#include <cstdio>

#include <cstring>

#include <iostream>

using namespace std;

const int MAX_N =  + ;

int map[];

bool close[MAX_N];

char dir[MAX_N], direction[] = "udlr";

int open[MAX_N], pa[MAX_N], f[MAX_N];

const int FACT[] = {, , , , , , , , };

const int MOVE[][] = {{, -}, {, }, {-, }, {, }};

struct Node

{

    int id;

    int f, g, h;

    int flags;   // 表示该状态被松弛次数

    Node() {}

    Node(int a_id, int a_g, int a_h, int a_flags)

    {

        id = a_id, g = a_g, h = a_h, flags = a_flags;

        f = g + h;

    }

    friend bool operator<(const Node &lhs, const Node &rhs);

};

bool operator<(const Node &lhs, const Node &rhs)  { return lhs.f > rhs.f; }

priority_queue<Node> find_min;

int StateToCanto()

{

    int state_num = ;

    for (int i = ; i < ; ++i)

    {

        int temp = map[i] - ;

        for (int j = ; j < i; ++j)

            temp -= (map[j] < map[i]);

        state_num += temp * FACT[ - i];

    }

    return state_num;

}

int StateToId()

{

    int ans = ;

    for (int i = ; i < ; ++i)

        ans = ans *  + map[i];

    return ans;

}

void IdToState(int num)

{

    int i = ;

    while (num)

    {

        map[i--] = num % ;

        num /= ;

    }

}

int Heuristic()

{

    int sum = ;

    for (int i = ; i < ; i++)

    for (int j = ; j < ; j++)

    {

        int k = i *  + j;

        if (map[k] == ) continue;

        sum += abs(i - (map[k] - ) / ) + abs(j - (map[k] - ) % );

    }

    return sum;

}

inline bool inversionNumberCheck()

{

    int cnt = ;

    for (int i = ; i < ; ++i)

    {

        if (map[i] == ) continue;

        for (int k = i - ; k >= ; --k)

        {

            if (map[k] == ) continue;

            if (map[k] > map[i])

                cnt++;

        }

    }

    return cnt & ;

}

void FindX(int &x, int &y)

{

    for (int i = ; i < ; ++i)

    {

        if (map[i] == )

        {

            y = i / ;

            x = i % ;

            return;

        }

    }

}

int A_star()

{

    int state_canto, state_id;

    state_canto = StateToCanto();

    state_id = StateToId();

    open[state_canto] += ;

    Node start(state_id, , Heuristic(), open[state_canto]);

    f[state_canto] = start.f;

    find_min.push(start);

    pa[state_canto] = -;

    dir[state_canto] = '';

    if (state_id == )

        return state_canto;

    while (!find_min.empty())

    {

        Node parent = find_min.top();

        Node child;

        int p_x, p_y, c_x, c_y, parent_canto;

        find_min.pop();

        IdToState(parent.id);

        parent_canto = StateToCanto();

        if (parent.flags != open[parent_canto]) // 一个状态可能被松弛多次，检测parent是否为该状态最后一次松弛的状态

            continue;

        close[StateToCanto()] = ; // To do

        FindX(p_x, p_y);

        for (int i = ; i < ; ++i)

        {

            int temp_swap, child_state_conto;

            c_x = p_x;

            c_y = p_y;

            c_x += MOVE[i][];

            c_y += MOVE[i][];

            if (c_x <  || c_x >=  || c_y <  || c_y >= )

                continue;

            temp_swap = map[p_x + p_y * ];

            map[p_x + p_y * ] = map[c_x + c_y * ];

            map[c_x + c_y * ] = temp_swap;

            child_state_conto = StateToCanto();

            if (close[child_state_conto] == )

            {

                temp_swap = map[p_x + p_y * ];

                map[p_x + p_y * ] = map[c_x + c_y * ];

                map[c_x + c_y * ] = temp_swap;

                continue;

            }

            child.id = StateToId();

            if (child.id == )

            {

                pa[child_state_conto] = parent_canto;

                dir[child_state_conto] = direction[i];

                return child_state_conto;

            }

            child.h = Heuristic();

            child.g = parent.g + ;

            child.f = child.g + child.h;

            child.flags = open[child_state_conto] + ;

            pa[child_state_conto] = parent_canto;

            dir[child_state_conto] = direction[i];

            if (open[child_state_conto] ==  || f[child_state_conto] > child.f)

            {

                f[child_state_conto] = child.f;

                open[child_state_conto] = child.flags;

                find_min.push(child);

            }

            temp_swap = map[p_x + p_y * ];

            map[p_x + p_y * ] = map[c_x + c_y * ];

            map[c_x + c_y * ] = temp_swap;

        }

    }

    return -;

}

void Find(int i)

{

    if (pa[i] == -)

        return;

    else

    {

        Find(pa[i]);

        printf("%c", dir[i]);

    }

}

void PrintPath()

{

    int end_canto;

    for (int i = ; i < ; ++i)

        map[i] = i + ;

    end_canto = StateToCanto();

    Find(end_canto);

    printf("\n");

}

int main()

{

    int ans = ;

    while (scanf("%s", &map[]) != EOF)

    {

        map[] = (map[] == 'x' ?  : (map[] -= ''));

        for (int i = ; i < ; ++i)

        {

            scanf("%s", &map[i]);

            map[i] = (map[i] == 'x' ?  : (map[i] -= ''));

        }

        if (inversionNumberCheck())

        {

            printf("unsolvable\n");

            continue;

        }

        memset(open, , sizeof(open));

        memset(close, , sizeof(close));

        memset(pa, , sizeof(pa));

        memset(f, , sizeof(f));

        memset(dir, , sizeof(dir));

        ans = A_star();

        if (ans == -)

            printf("unsolvable\n");

        else

            PrintPath();

        while (find_min.empty())

            find_min.pop();

    }

    return ;

}