#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <queue>
#include <ctime>
#include <cmath>
using namespace std;
int a[7],y[1000000][7],br,used[1000000],rect[1000000],connection[4][10],count1[1000000],used1[1000000],cost[1000000],Z,n;
int graph[1000000][4],color[200][200][3],aim[200][200][3],list[1000000],br5=0;
string moves[1000000],answer;
std::clock_t start;
double duration;
char ch[3],direction[1000000][4];
void perm(int x,int n)
{
    used[x]=1;
    a[n-1]=x;
    if(n==6)
    {
        int seven=1,place=0;;
        for(int i=n-1; i>=0; i--)
        {
            y[br][i]=a[i];
            place+=a[i]*seven;
            seven*=7;
        }
        rect[place]=br;
        br++;
    }
    for(int i=1; i<=6; i++)
    {

        if(!used[i])
        {
            perm(i,n+1);
        }
    }

    used[x]=0;
}
void connect()
{
    int br1=1;
    for(int i=0; i<br; i++)
    {

        for(int j=0; j<3; j++)
        {
            for(int k=0; k<6; k++)
            {
                connection[j][k]=y[i][k];
            }
        }
        int x;
        br1=1;
        for(int j=0; j<6; j++)
            if(y[i][j]==1)
                x=j;
        if(x>=3)
            swap(connection[0][x],connection[0][x-3]),ch[0]='U';
        else
            swap(connection[0][x],connection[0][x+3]),ch[0]='D';
        if(x!=2&&x!=5)
        {
            swap(connection[br1][x],connection[br1][x+1]);
            ch[br1]='R';
            br1++;
        }
        if(x!=0&&x!=3)
        {
            swap(connection[br1][x],connection[br1][x-1]);
            ch[br1]='L';
            br1++;
        }
        graph[i][0]=br1;
        for(int j=0; j<br1; j++)
        {
            int seven=1,place=0;;
            for(int k=5; k>=0; k--)
            {
                place+=seven*connection[j][k];
                seven*=7;
            }
            graph[i][j]=rect[place];
            direction[i][j]=ch[j];
        }
        count1[i]=br1;
    }
}
int bfs(int v)
{
    v=rect[v];
    used1[v]=1;
    queue <int> q;
    q.push(v);
    int size1=1;
    int br3=0;
    moves[v]="";
    while(!q.empty())
    {
        for(int i=0; i<size1; i++)
        {
            int x=q.front();
            q.pop();
            cost[x]=br3;
            for(int j=0; j<count1[x]; j++)
            {
                int z=graph[x][j];
                if(!used1[z])
                {
                    used1[z]=1;
                    list[br5++]=z;
                    moves[z]=moves[x]+direction[x][j];
                    q.push(z);
                }
            }
        }
        size1=q.size();
        br3++;
    }
    return br3;
}
void init()
{
    perm(6,1);
    perm(1,1);
    perm(2,1);
    perm(3,1);
    perm(4,1);
    perm(5,1);
    connect();
    bfs(7*7*7*7*7*2+7*7*7*7*3+7*7*7*4+7*7*5+7*6+1);
}
void read()
{

    freopen("puzzle.in","r",stdin);
    freopen("puzzle.out","w",stdout);
    cin>>Z;
    for(int i=0; i<200; i++)
        for(int j=0; j<200; j++)
            scanf("%d %d %d",&color[i][j][0],&color[i][j][1],&color[i][j][2]);
    for(int i=0; i<n; i++)
        for(int j=0; j<n; j++)
            scanf("%d %d %d",&aim[i][j][0],&aim[i][j][1],&aim[i][j][2]);
    fclose(stdin);
}
void swap_positions(int i1,int j1,int i2,int j2)
{
    char chgrowi,chgrowj;
    int growi,growj;
    if(i1<i2)
        growi=1,chgrowi='D';
    else growi=-1,chgrowi='U';
    if(j1<j2)
        growj=1,chgrowj='R';
    else growj=-1,chgrowj='L';
    while(i1!=i2)
    {
        i1+=growi;
        answer+=chgrowi;
        for(int i=0;i<Z;i++)
        {
            for(int j=0;j<Z;j++)
            {
                swap(color[i1*Z+i][j1*Z+j][0],color[(i1-growi)*Z+i][j1*Z+j][0]);
                swap(color[i1*Z+i][j1*Z+j][1],color[(i1-growi)*Z+i][j1*Z+j][1]);
                swap(color[i1*Z+i][j1*Z+j][2],color[(i1-growi)*Z+i][j1*Z+j][2]);
            }
        }

    }
    while(j1!=j2)
    {
        answer+=chgrowj;
        j1+=growj;
        for(int i=0;i<Z;i++)
        {
            for(int j=0;j<Z;j++)
            {
                swap(color[i1*Z+i][j1*Z+j][0],color[i1*Z+i][(j1-growj)*Z+j][0]);
                swap(color[i1*Z+i][j1*Z+j][1],color[i1*Z+i][(j1-growj)*Z+j][1]);
                swap(color[i1*Z+i][j1*Z+j][2],color[i1*Z+i][(j1-growj)*Z+j][2]);
            }
        }

    }
}
void make_move(int &i1,int &j1,char where)
{
    if(where=='R')
    {
        for(int i=0;i<Z;i++)
        {
            for(int j=0;j<Z;j++)
            {
                swap(color[i1*Z+i][j1*Z+j][0],color[i1*Z+i][(j1+1)*Z+j][0]);
                swap(color[i1*Z+i][j1*Z+j][1],color[i1*Z+i][(j1+1)*Z+j][1]);
                swap(color[i1*Z+i][j1*Z+j][2],color[i1*Z+i][(j1+1)*Z+j][2]);
            }
        }
        j1++;
    }
    else if(where=='L')
    {
        for(int i=0;i<Z;i++)
        {
            for(int j=0;j<Z;j++)
            {
                swap(color[i1*Z+i][j1*Z+j][0],color[i1*Z+i][(j1-1)*Z+j][0]);
                swap(color[i1*Z+i][j1*Z+j][1],color[i1*Z+i][(j1-1)*Z+j][1]);
                swap(color[i1*Z+i][j1*Z+j][2],color[i1*Z+i][(j1-1)*Z+j][2]);
            }
        }
        j1--;
    }
    else if(where=='U')
    {
        for(int i=0;i<Z;i++)
        {
            for(int j=0;j<Z;j++)
            {
                swap(color[i1*Z+i][j1*Z+j][0],color[(i1-1)*Z+i][j1*Z+j][0]);
                swap(color[i1*Z+i][j1*Z+j][1],color[(i1-1)*Z+i][j1*Z+j][1]);
                swap(color[i1*Z+i][j1*Z+j][2],color[(i1-1)*Z+i][j1*Z+j][2]);
            }
        }
        i1--;
    }
    else if(where=='D')
    {
        for(int i=0;i<Z;i++)
        {
            for(int j=0;j<Z;j++)
            {
                swap(color[i1*Z+i][j1*Z+j][0],color[(i1+1)*Z+i][j1*Z+j][0]);
                swap(color[i1*Z+i][j1*Z+j][1],color[(i1+1)*Z+i][j1*Z+j][1]);
                swap(color[i1*Z+i][j1*Z+j][2],color[(i1+1)*Z+i][j1*Z+j][2]);
            }
        }
        i1++;
    }
}
int count=0;
double differs[2][3][2][3],endans,realdif;
string endmovecomposition="";
int endrandi,endrandj,endcost;
int cini;
int randi,randj,movesreq;
double min1=100000000;double curans=10000000000000;
int ansi;double curdif=0;
int priceforcurrentmagic;
void find_relatively_best_move(int maxi,int maxj)
{
    endans=1000000000,
    realdif=0;
    endmovecomposition="";
    duration = ( std::clock() - start ) / (double) CLOCKS_PER_SEC;
        if(duration>4.0)
            return;
    for(randi=0;randi<n;randi++)
    for(randj=0;randj<n;randj++)
    {
        ///randi=rand()%(n-1)+1;
        ///randj=rand()%(n-2)+2;
        movesreq=fabs(randi-maxi)+fabs(randj-maxj);
        for(int i1=0; i1<2; i1++)
            for(int j1=0; j1<3; j1++)
                for(int i2=0; i2<2; i2++)
                    for(int j2=0; j2<3; j2++)
                        differs[i1][j1][i2][j2]=0;
        realdif=0;
        for(int i1=randi-1; i1<=randi; i1++)
        {
            for(int j1=randj-2; j1<=randj; j1++)
            {
                for(int i3=0; i3<Z; i3++)
                {
                    for(int j3=0; j3<Z; j3++)
                    {
                        realdif+=sqrt((color[i1*Z+i3][j1*Z+j3][0]-aim[i1*Z+i3][j1*Z+j3][0])*(color[i1*Z+i3][j1*Z+j3][0]-aim[i1*Z+i3][j1*Z+j3][0])+
                                      (color[i1*Z+i3][j1*Z+j3][1]-aim[i1*Z+i3][j1*Z+j3][1])*(color[i1*Z+i3][j1*Z+j3][1]-aim[i1*Z+i3][j1*Z+j3][1])+
                                      (color[i1*Z+i3][j1*Z+j3][2]-aim[i1*Z+i3][j1*Z+j3][2])*(color[i1*Z+i3][j1*Z+j3][2]-aim[i1*Z+i3][j1*Z+j3][2]));
                    }

                }
            }
        }
        for(int i1=randi-1; i1<=randi; i1++)
        {
            for(int j1=randj-2; j1<=randj; j1++)
            {
                for(int i2=randi-1; i2<=randi; i2++)
                {
                    for(int j2=randj-2; j2<=randj; j2++)
                    {
                        for(int i3=0; i3<Z; i3++)
                        {
                            for(int j3=0; j3<Z; j3++)
                            {
                                differs[i1-randi+1][j1-randj+2][i2-randi+1][j2-randj+2]+=sqrt((color[i1*Z+i3][j1*Z+j3][0]-aim[i2*Z+i3][j2*Z+j3][0])*(color[i1*Z+i3][j1*Z+j3][0]-aim[i2*Z+i3][j2*Z+j3][0])+
                                                                                              (color[i1*Z+i3][j1*Z+j3][1]-aim[i2*Z+i3][j2*Z+j3][1])*(color[i1*Z+i3][j1*Z+j3][1]-aim[i2*Z+i3][j2*Z+j3][1])+
                                                                                              (color[i1*Z+i3][j1*Z+j3][2]-aim[i2*Z+i3][j2*Z+j3][2])*(color[i1*Z+i3][j1*Z+j3][2]-aim[i2*Z+i3][j2*Z+j3][2]));
                            }
                        }
                    }
                }
            }
        }
        min1=100000000;
        curans=10000000000000;
        for(int j=0;j<br5;j++)
        {
            priceforcurrentmagic=cost[list[j]];
            curdif=0;
            for(int l=0;l<6;l++)
            {

                int r1,r2;
                if(y[list[j]][l]==1)
                {

                    r1=5;
                    r2=l;
                    int i1=randi-1,j1=randj-2;
                    int i2=randi-l/3,j2=randj-l%3;
                    curdif+=differs[randi-i1][randj-j1][randi-i2][randj-j2];
                }
                else
                {
                    r1=y[list[j]][l]-2;
                    r2=l;
                    int i1=randi-r1/3,j1=randj-r1%3;
                    int i2=randi-r2/3,j2=randj-r2%3;
                    curdif+=differs[randi-i1][randj-j1][randi-i2][randj-j2];
                }

            }
            if(curdif<curans)
                curans=curdif,ansi=j;
        }
        curans=curans-realdif;
        int curcost=fabs(maxi-randi)+fabs(maxj-randj)+cost[list[ansi]];
        curans+=curcost;
        ///cout<<curans<<endl;
        if(curans<endans||(curans==endans&&endcost>curcost))
        {
            endans=curans;
            endrandi=randi;
            endrandj=randj;
            endcost=curcost;
            endmovecomposition=moves[list[ansi]];
        }
    }
    if(endans<0&&answer.length()+endcost<500)
    {
        swap_positions(maxi,maxj,endrandi,endrandj);

        answer+=endmovecomposition;
        for(int i=0;i<endmovecomposition.length();i++)
        {
            make_move(endrandi,endrandj,endmovecomposition[i]);
        }
        find_relatively_best_move(endrandi,endrandj);
    }
    else return;
}
void solve()
{
    n=200/Z;
    double maxdif=0;;
    int maxdifi,maxdifj;
    double dif=0;
    for(int i=1; i<n; i++)
    {
        for(int j=2; j<n; j++)
        {
            dif=0;
            for(int i1=i*Z; i1<Z*i+Z; i1++)
            {
                for(int j1=j*Z; j1<j*Z+Z; j1++)
                {
                    dif+=sqrt((color[i1][j1][0]-aim[i1][j1][0])*(color[i1][j1][0]-aim[i1][j1][0])+
                              (color[i1][j1][1]-aim[i1][j1][1])*(color[i1][j1][1]-aim[i1][j1][1])+
                              (color[i1][j1][2]-aim[i1][j1][2])*(color[i1][j1][2]-aim[i1][j1][2]));
                }
            }
            if(dif>maxdif)
			{
                maxdif=dif;
            	maxdifi=i;
                maxdifj=j;
  			}
        }
    }
    cout<<maxdifi<<" "<<maxdifj<<endl;
    find_relatively_best_move(maxdifi,maxdifj);
    cout<<answer<<endl;
}
int main()
{
    ///std::ios::sync_with_stdio(false);
    ///init();
    read();
    ///solve();
    cout<<"1 1"<<endl;
    cout<<"U"<<endl;;
}
/**/