import java.io.*;

class IO
{

  public static int readInt() 
  // Reads an int from standard input.
  {
    String input = "";
    try 
    {
      BufferedReader bufRead = new BufferedReader
        (new InputStreamReader (System.in));
      input = bufRead.readLine();
    } 
    catch (java.io.IOException e) 
    {
      System.out.print("Error while reading input line!\n");
    }
    return Integer.valueOf(input).intValue();
  }
} 

class Warshall
// Simulation of the Warshall algorithm on a 2-dimensional mesh.
// Slow version in which a packet is not forwarded before it has 
// been processed. Running time: 5 * n - 4 rounds.

{
  int n;
  int t;
  boolean[][][] own;
  byte[][][] hor;
  byte[][][] ver;

  // Values hor and ver:
  // 0 = not received
  // 1 = received
  // 2 = processed
  // 3 = sent

  // Rules:
  // First computing, then transferring
  // For computing own[i][j][k] you must have
  // own[i][j][k - 1] && hor[i][j][k - 1] == ver[i][j][k - 1] == 1

  Warshall(int n)
  {
    this.n = n;
    t = 0;

    // row and column 0 are never used
    own = new boolean[n][n][n + 1]; 
    hor = new    byte[n][n][n];
    ver = new    byte[n][n][n];

    // Initializing own[] 
    for (int i = 0; i < n; i++)
      for (int j = 0; j < n; j++) 
      {
        own[i][j][0] = true;
        for (int k = 1; k <= n; k++) 
          own[i][j][k] = false;
      }

    // Initializing hor[] and ver[]
    for (int i = 0; i < n; i++)
      for (int j = 0; j < n; j++) 
        for (int k = 0; k < n; k++) 
          hor[i][j][k] = ver[i][j][k] = 0;
    for (int i = 0; i < n; i++)
      hor[i][0][0] = 1;
    for (int j = 0; j < n; j++)
      ver[0][j][0] = 1;
  }

  boolean notReady()
  {
    boolean ready = true; 
    for (int i = 0; i < n; i++) 
      for (int j = 0; j < n; j++) 
        ready = ready && own[i][j][n];
    return ! ready;
  }

  private void compute()
  {
    for (int i = 0; i < n; i++) 
      for (int j = 0; j < n; j++) 
      {
        int k;
        for (k = 1; k <= n && own[i][j][k]; k++);
        if (k <= n && own[i][j][k - 1] && 
            (hor[i][j][k - 1] == 1) && (ver[i][j][k - 1] == 1))
        {       
          own[i][j][k] = true; // Next value can be computed
          if (k == i)
            ver[i][j][k] = 1; // New value to be routed vertically
          if (k == j) 
            hor[i][j][k] = 1; // New value to be routed horizontally
          hor[i][j][k - 1] = 2; // Old value no longer needed
          ver[i][j][k - 1] = 2; // Old value no longer needed
        }       
      }
  }

  private void route()
  {
    for (int i = 0; i < n; i++)
      for (int j = 0; j < n; j++) 
      {
        // Find first value to be routed horizontally
        int k;
        for (k = 0; k < n && hor[i][j][k] == 3; k++);
        if (k < n && hor[i][j][k] == 2)
        {
          hor[i][j][k] = 3;
          if (j >= 1 && hor[i][j - 1][k] == 0) 
            hor[i][j - 1][k] = 1; // Route left
          if (j <= n - 2 && hor[i][j + 1][k] == 0)
            hor[i][j + 1][k] = 1; // Route right
        }
        // Find first value to be routed vertically
        for (k = 0; k < n && ver[i][j][k] == 3; k++);
        if (k < n && ver[i][j][k] == 2)
        {
          ver[i][j][k] = 3;
          if (i >= 1 && ver[i - 1][j][k] == 0)
            ver[i - 1][j][k] = 1; // Route up
          if (i <= n - 2 && ver[i + 1][j][k] == 0)
            ver[i + 1][j][k] = 1; // Route down
        }
      }
  }

  void step()
  {
    t++;
    compute();
    route();
  }

  void print()
  {
    System.out.println();
    for (int i = 0; i < n; i++)
      for (int j = 0; j < n; j++) 
      {
        System.out.print("t = " + t + 
                          " node(" + i + ", " + j + "): own = (");
        for (int k = 0; k <= n; k++)
          if (own[i][j][k])
            System.out.print("1");
          else
            System.out.print("0");
        System.out.print("), hor = (");
        for (int k = 0; k < n; k++)
          System.out.print(hor[i][j][k]);
        System.out.print("), ver = (");
        for (int k = 0; k < n; k++)
          System.out.print(ver[i][j][k]);
        System.out.print(")\n");
      }
  }
}

class WarshallTest
{
  public static void main(String[] args)
  {
    System.out.print("\nGive n   >>>   ");
    Warshall w = new Warshall(IO.readInt());

    w.print();
    while (w.notReady())
    {
      w.step();
      w.print();
    }
    System.out.println();
  }
}