/*
TASK: lab
LANG: C
*/

#include <stdio.h>

#define MAXN            50
#define MAXC            10

#define INF             2000000000

typedef struct s1
{
  char x,y,z;
  char col;
  
} hnode;

int n;
int bx,by,bz;
int ex,ey,ez;
int bc1,bc2;
short cube[MAXN][MAXN][MAXN];
short mash[MAXN][MAXN][MAXN];
int dist[MAXN][MAXN][MAXN][MAXC];
short par[MAXN][MAXN][MAXN][MAXC][3];
hnode heap[MAXN*MAXN*MAXN*MAXC];
hnode ans;
char aseq[MAXN*MAXN*MAXN];
int brans;
int hc;
int posh[MAXN][MAXN][MAXN][MAXC];
char neig[6][4] = {1,0,0,'X',
                   0,1,0,'Y',
                   0,0,1,'Z',
                   -1,0,0,'U',
                   0,-1,0,'V',
                   0,0,-1,'W'};

void input()
{
  char tmp[MAXN];
  int i,i2,i3;

  scanf("%d %d %d %d %d %d %d",&n,&bx,&by,&bz,&ex,&ey,&ez);
  scanf("%s",tmp);
  bc1 = tmp[0]-'A';
  bc2 = tmp[1]-'A';

  for(i=1;i<=n;i++)
    for(i2=1;i2<=n;i2++)
    {
      scanf("%s",tmp+1);
      for(i3=1;i3<=n;i3++)
        cube[i2][i3][i] = tmp[i3]-'A';
    }
    
  for(i=1;i<=n;i++)
    for(i2=1;i2<=n;i2++)
    {
      scanf("%s",tmp+1);
      for(i3=1;i3<=n;i3++)
        mash[i2][i3][i] = tmp[i3]-'A';
    }
}

void Update(int x, int y, int z, int col)
{
  int nd;
  int ind;
  int d1,d2;
  hnode buf;

  nd = dist[x][y][z][col];
  ind = posh[x][y][z][col];

  while(ind>1)
  {
    d1 = dist[heap[ind/2].x][heap[ind/2].y][heap[ind/2].z][heap[ind/2].col];
    d2 = dist[heap[ind].x][heap[ind].y][heap[ind].z][heap[ind].col];

    if(d1>d2)
    {
      buf = heap[ind/2];
      heap[ind/2] = heap[ind];
      heap[ind] = buf;

      posh[heap[ind/2].x][heap[ind/2].y][heap[ind/2].z][heap[ind/2].col] = ind/2;
      posh[heap[ind].x][heap[ind].y][heap[ind].z][heap[ind].col] = ind;

      ind /= 2;
    }
    else
      break;
  }
}

hnode Pop()
{
  hnode save;
  hnode buf;
  int ind;
  int nind;

  save = heap[1];
  
  heap[1] = heap[hc-1];
  hc--;

  ind = 1;

  while(2*ind<hc)
  {
    nind = 2*ind;

    if(nind+1<hc)
      if(dist[heap[nind].x][heap[nind].y][heap[nind].z][heap[nind].col]>dist[heap[nind+1].x][heap[nind+1].y][heap[nind+1].z][heap[nind+1].col])
        nind++;

    if(dist[heap[nind].x][heap[nind].y][heap[nind].z][heap[nind].col]<dist[heap[ind].x][heap[ind].y][heap[ind].z][heap[ind].col])
    {
      buf = heap[ind];
      heap[ind] = heap[nind];
      heap[nind] = buf;
      posh[heap[nind].x][heap[nind].y][heap[nind].z][heap[nind].col] = nind;
      posh[heap[ind].x][heap[ind].y][heap[ind].z][heap[ind].col] = ind;

      ind = nind;
    }
    else
      break;
  }

  return save;
}

void Improve(int x, int y, int z, int fc, int c1, int c2, int d)
{
  int i;
  int nx,ny,nz;
  int c3;

  c3 = mash[x][y][z];

/*  if(x==1 && y==3 && z==3)
  {
    i++;
  }*/

  for(i=0;i<6;i++)
  {
   nx = x+neig[i][0];
   ny = y+neig[i][1];
   nz = z+neig[i][2];

   if(nx<1 || ny<1 || nz<1 || nx>n || ny>n || nz>n)
     continue;

// minavame s c1
   
    if(c1==cube[nx][ny][nz])
    {
      if(dist[nx][ny][nz][c2]>d+1)
      {
        dist[nx][ny][nz][c2] = d+1;
        par[nx][ny][nz][c2][0] = neig[i][3];
        par[nx][ny][nz][c2][1] = fc;
        par[nx][ny][nz][c2][2] = -1;
        Update(nx,ny,nz,c2);
      }

      // ako smenim c2 s c3

      if(dist[nx][ny][nz][c3]>d+2 && c3!='O'-'A')
      {
        dist[nx][ny][nz][c3] = d+2;
        par[nx][ny][nz][c3][0] = neig[i][3];
        par[nx][ny][nz][c3][1] = fc;
        par[nx][ny][nz][c3][2] = c2;
        Update(nx,ny,nz,c3);
      }      
    }

// minavame s c2

    if(c2==cube[nx][ny][nz] && c1!=c2)
    {
      if(dist[nx][ny][nz][c1]>d+1)
      {
        dist[nx][ny][nz][c1] = d+1;
        par[nx][ny][nz][c1][0] = neig[i][3];
        par[nx][ny][nz][c1][1] = fc;
        par[nx][ny][nz][c1][2] = -1;
        Update(nx,ny,nz,c1);
      }

      // ako smenim c1 s c3

      if(dist[nx][ny][nz][c3]>d+2  && c3!='O'-'A')
      {
        dist[nx][ny][nz][c3] = d+2;
        par[nx][ny][nz][c3][0] = neig[i][3];
        par[nx][ny][nz][c3][1] = fc;
        par[nx][ny][nz][c3][2] = c1;
        Update(nx,ny,nz,c3);
      }      
    }

// minavame s c3

    if(c3==cube[nx][ny][nz] && c3!='O'-'A')
    {
      // ako smenim c2 s c3
    
      if(dist[nx][ny][nz][c1]>d+2)
      {
        dist[nx][ny][nz][c1] = d+2;
        par[nx][ny][nz][c1][0] = neig[i][3];
        par[nx][ny][nz][c1][1] = fc;
        par[nx][ny][nz][c1][2] = c2;
        Update(nx,ny,nz,c1);
      }

      // ako smenim c1 s c3
      
      if(dist[nx][ny][nz][c2]>d+2)
      {
        dist[nx][ny][nz][c2] = d+2;
        par[nx][ny][nz][c2][0] = neig[i][3];
        par[nx][ny][nz][c2][1] = fc;
        par[nx][ny][nz][c2][2] = c1;
        Update(nx,ny,nz,c2);
      }
    }
  }  
}

void Dijkstra()
{
  int i;
  hnode cur;
  int scol;
  int sd;

  while(1)
  {
    if(hc>1)
      cur = Pop();
    else
      break;

    if(cur.x==ex && cur.y==ey && cur.z==ez)
    {
      ans = cur;
      break;
    }

    scol = cube[cur.x][cur.y][cur.z];
    sd = dist[cur.x][cur.y][cur.z][cur.col];
    Improve(cur.x,cur.y,cur.z,cur.col,scol,cur.col,sd);
  
  }
}

void solve()
{
  int i,i2,i3,i4;
  hnode cur;
  int check;

  hc = 1;

  for(i=1;i<=n;i++)
    for(i2=1;i2<=n;i2++)
      for(i3=1;i3<=n;i3++)
        for(i4=0;i4<MAXC;i4++)
        {
          dist[i][i2][i3][i4] = INF;
          heap[hc].x = i;
          heap[hc].y = i2;
          heap[hc].z = i3;
          heap[hc].col = i4;
          posh[i][i2][i3][i4] = hc;
          hc++;
        }

  if(bc1==cube[bx][by][bz])
  {
    dist[bx][by][bz][bc2] = 0;
    par[bx][by][bz][bc2][0] = -1;
    Update(bx,by,bz,bc2);
  }
  else
    if(bc2==cube[bx][by][bz])
    {
      dist[bx][by][bz][bc1] = 0;
      par[bx][by][bz][bc1][0] = -1;
      Update(bx,by,bz,bc1);
    }
    else
      Improve(bx,by,bz,-1,bc1,bc2,0);

  Dijkstra();

  brans = 0;

  cur = ans;

  while(par[cur.x][cur.y][cur.z][cur.col][0]!=-1 && par[cur.x][cur.y][cur.z][cur.col][1]!=-1)
  {
    check = 0;
    aseq[brans] = par[cur.x][cur.y][cur.z][cur.col][0];
    if(par[cur.x][cur.y][cur.z][cur.col][2]!=-1)
    {
      aseq[brans+1] = par[cur.x][cur.y][cur.z][cur.col][2]+'A';
      check = 1;
    }
      
    cur.col = par[cur.x][cur.y][cur.z][cur.col][1];
    if(aseq[brans]=='X')
      cur.x--;
      
    if(aseq[brans]=='Y')
      cur.y--;
      
    if(aseq[brans]=='Z')
      cur.z--;
      
    if(aseq[brans]=='U')
      cur.x++;
      
    if(aseq[brans]=='V')
      cur.y++;
      
    if(aseq[brans]=='W')
      cur.z++;

    brans++;
    brans+=check;

  }

  if(par[cur.x][cur.y][cur.z][cur.col][1]==-1)
  {
    aseq[brans] = par[cur.x][cur.y][cur.z][cur.col][0];
    brans++;
    
    if(par[cur.x][cur.y][cur.z][cur.col][2]!=-1)
    {
      aseq[brans++] = par[cur.x][cur.y][cur.z][cur.col][2]+'A';
    }
  }
}

void output()
{
  int i;

  printf("%d\n",brans);

  for(i=brans-1;i>=0;i--)
    printf("%c",aseq[i]);

  printf("\n");
}

int main()
{
//  freopen("cube.in","r",stdin);

  input();
  solve();
  output();

  return 0;
}

