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

public class Solution {
    static int n;
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        // your code goes here
        
        Node[][] nodes=new Node[n][n];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                nodes[i][j]=new Node(i,j);
            }
        }
        
        
        for(int x=1;x<n;x++){
            for(int y=1;y<n;y++){
                System.out.print(findLeast(x,y,nodes)+" ");
            } 
            System.out.println();
        }
        
        
        
       
        
        
        
    }
    
    public static Node removeLeast(ArrayList<Node> list){
        int least=1000000000;
        int l=-1;
        for(int i=0;i<list.size();i++){
            if(list.get(i).dist<least){
                least=list.get(i).dist;
                l=i;
            }
        }
        
        return list.remove(l);
    }
    
    public static int findLeast(int x, int y, Node[][] nodes){
        ArrayList<Node> list = new ArrayList<>();
        
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                nodes[i][j]=new Node(i,j);
                list.add(nodes[i][j]);
            }
        }
        
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(i+x<n){
                    if(j+y<n){
                        nodes[i][j].links.add(nodes[i+x][j+y]);
                        nodes[i][j].links.add(nodes[j+y][i+x]);
                    } 
                    if(j-y>=0){
                        nodes[i][j].links.add(nodes[i+x][j-y]);
                        nodes[i][j].links.add(nodes[j-y][i+x]);
                    } 
                }
                
                if(i-x>=0){
                    if(j+y<n){
                        nodes[i][j].links.add(nodes[i-x][j+y]);
                        nodes[i][j].links.add(nodes[j+y][i-x]);
                    } 
                    if(j-y>=0){
                        nodes[i][j].links.add(nodes[i-x][j-y]);
                        nodes[i][j].links.add(nodes[j-y][i-x]);
                    } 
                }
            }
        }
        nodes[n-1][n-1].dist=0;
        dijkstra(list);
        if(nodes[0][0].dist==1000000) return -1;
        return nodes[0][0].dist;
        
    }
    
    public static void dijkstra(ArrayList<Node> list){
        if(list.isEmpty()) return;
        Node node=removeLeast(list);
        node.notUsed=false;
        for(int i=0;i<node.links.size();i++){
            Node temp=node.links.get(i);
            
            if(temp.notUsed){
                
                if(temp.dist>node.dist+1){
                    temp.dist=node.dist+1;
                    if(temp.x==0 && temp.y==0){
                        return;
                    }
                } 
            }            
        }
        dijkstra(list);
        
    }
    
    
    
}
class Node{
    ArrayList<Node> links;
    public int x;
    public int y;
    public int dist;
    boolean notUsed;
    Node(int z, int q){
        x=z;
        y=q;
        dist=1000000;
        links=new ArrayList<>();
        notUsed=true;
    }    
}