#include <stdio.h>
#define MAX_SIZE 10

void ReadMatrix(int[MAX_SIZE][MAX_SIZE], int*);
int IsOrdered(int[MAX_SIZE][MAX_SIZE], int, int);
void Step(int[MAX_SIZE][MAX_SIZE], int, int);
int OrderMat(int[MAX_SIZE][MAX_SIZE], int, int*);

void ReadMatrix(int a[MAX_SIZE][MAX_SIZE], int* ActualSize)
{
    int i,j;
    for(i=0;i<MAX_SIZE;i++)
    {
        for(j=0;j<MAX_SIZE;j++)
        {
            a[i][j] = -1;
        }
    }

    for(i=0;i<(*ActualSize);i++)
    {
        for(j=0;j<(*ActualSize);j++)
        {
            scanf("%d",&a[i][j]);
        }
    }
}


int IsOrdered(int a[MAX_SIZE][MAX_SIZE], int ActualSize, int Layer)
{
    int i,j,Counter=0;
    for(j=Layer;j<=ActualSize-Layer;j++)
    {
        if((a[Layer-1][j] != (a[Layer-1][j-1] + 1)) || (a[ActualSize-Layer][j] != (a[ActualSize-Layer][j-1] + 1))) //ROWS
        {
            Counter = 1;
            break;
        }
    }
    for(i=Layer;i<=ActualSize-Layer;i++)
    {
        if((a[i][Layer-1] != (a[i-1][Layer-1] + ActualSize)) || ( a[i][ActualSize-Layer] != (a[i-1][ActualSize-Layer] + ActualSize))) //COLUMNS
        {
            Counter = 1;
            break;
        }
    }
    if(Counter==1)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}

void Step(int a[MAX_SIZE][MAX_SIZE], int ActualSize, int Layer)
{
  int i,j;
  int temp = a[Layer-1][Layer-1];
  int LastLayer = (ActualSize/2) + 1;

  if(ActualSize%2!=0 && (Layer==LastLayer))
  {
  }
  else
  {
    for(i=Layer-1;i<ActualSize-Layer;i++) //LEFT COLUMN
  {
      a[i][Layer-1] = a[i+1][Layer-1];
  }

    for(j=Layer-1;j<ActualSize-Layer;j++) //BOTTOM ROW
  {
      a[ActualSize-Layer][j] = a[ActualSize-Layer][j+1];
  }

    for(i=ActualSize-Layer;i>Layer-1;i--) // RIGHT COLUMN
  {
      a[i][ActualSize-Layer] = a[i-1][ActualSize-Layer];
  }

    for(j=ActualSize-Layer;j>Layer;j--)   //TOP ROW
  {
      a[Layer-1][j] = a[Layer-1][j-1];
  }

    a[Layer-1][Layer]=temp;
  }
}

int OrderMat(int a[MAX_SIZE][MAX_SIZE], int ActualSize, int* P)
{
    int i;
    int LastLayer;
    int OrderedLayers;
    int UnOrdered;
    if(ActualSize%2!=0)
    {
        LastLayer = (ActualSize/2) + 1;
    }
    else{LastLayer = ActualSize/2;}
    OrderedLayers = LastLayer;

    for(i=1;i<=LastLayer;i++)
    {
        if(!(IsOrdered(a,ActualSize,i)))
           {
               /*printf("\nLayer Number %d isn't ordered\n",i);*/
               OrderedLayers--;
           }
    }
    if(OrderedLayers < LastLayer)
    {
        UnOrdered = 1;
    }
    else{return 2;}

    if(UnOrdered == 1)
    {
        for(i=0;i<LastLayer;i++)
        {
            P[i] = 0;
            while(!(IsOrdered(a,ActualSize,i+1)))
            {
                Step(a,ActualSize,i+1);
                P[i] = P[i] +1;
                if(P[i]>(ActualSize*ActualSize))
                {
                    return 0;
                }
            }
        }
        return 1;
    }
}
int main()
{
    int a[MAX_SIZE][MAX_SIZE],P[MAX_SIZE];
    int Dimension,i,j,LastLayer,Status;
    scanf("%d",&Dimension);
    ReadMatrix(a,&Dimension);
    Status = OrderMat(a,Dimension,&P[0]);
    switch(Status)
    {
        case 2:
        printf("ALREADY ORDERED\n");
        break;

        case 1:
        printf("CAN BE ORDERED WITH THE FOLLOWING STEPS:\n");
        if(Dimension%2!=0)
        {
            LastLayer = (Dimension/2) + 1;
        }
        else{LastLayer = Dimension/2;}
        for(i=0;i<LastLayer;i++)
        {
            printf("%d : %d\n",i+1,P[i]);
        }
        break;

        case 0:
        printf("CANNOT BE ORDERED\n");
        break;
    }
    return 0;
}