import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        for(int i=1;i<n;i++)
            {
            for(int j=1;j<n;j++)
                {
                //call the function for all possible combination of i,j
                System.out.print(knightMove(n,i,j)+" ");
            }
            System.out.println("");
        }
    }
    public static int knightMove(int n,int i,int j)
        {
        //declare a spot array to track movements
        int[][] coveredspots=new int[n][n];
        //initialize the spot array with -1
        for(int p=0;p<n;p++)
            {
            for(int q=0;q<n;q++)
                {
            coveredspots[p][q]=-1;
            }
        }
        //since the 0,0 is initial position, its initialized to 0
        coveredspots[0][0]=0;
        
        for(int p=0;p<n*n;p++)
            {
            boolean anyMovementRecorded=false;
            for(int x=0;x<n;x++)
                {
                for (int y=0; y<n;y++)
                    {
                    //look for all spots traveresed p times, which is 0,1,2...
                    if(coveredspots[x][y]==p)
                        {
                        //calculate possible steps
                        int[] possiblex=new int[8];
                        int[] possibley=new int[8];
                        possiblex[0]=x+i;
                        possibley[0]=y+j;
                        
                        possiblex[1]=x+i;
                        possibley[1]=y-j;
                        
                        possiblex[2]=x-i;
                        possibley[2]=y+j;
                        
                        possiblex[3]=x-i;
                        possibley[3]=y-j;
                        
                        possiblex[4]=x+j;
                        possibley[4]=y+i;
                        
                        possiblex[5]=x+j;
                        possibley[5]=y-i;
                        
                        possiblex[6]=x-j;
                        possibley[6]=y+i;
                        
                        possiblex[7]=x-j;
                        possibley[7]=y-i;
                       for(int r=0;r<8;r++)
                           {
                           if(possiblex[r]<n && possiblex[r]>=0 && possibley[r]<n && possibley[r]>=0)
                               {
                               //mark the possible step with step number
                               if(coveredspots[possiblex[r]][possibley[r]]==-1){
                               coveredspots[possiblex[r]][possibley[r]]=p+1;
                                   anyMovementRecorded=true;
                               }
                           }
                       }
                        //return if n-1,n-1 is covered in this movement
                        if(coveredspots[n-1][n-1]!=-1)
                            {
                            return coveredspots[n-1][n-1];
                        }
                    }
                }
            }
            if(anyMovementRecorded==false)
                {
                //no movement recorded, return with -1
                return -1;
            }
        }
        return -1;
    }
    
}