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 sc=new Scanner(System.in);
		int N=sc.nextInt();
		
		for(int a=1;a<N;a++){
			for(int b=1;b<N;b++){
				Node[][] board=initBoard(N);
				Node startNode=board[0][0];
				startNode.dist=0;
				startNode.priority=0;
				int moves=aStarSearch(startNode,board,a,b,N);
				System.out.print(moves+" ");
			}
			System.out.println();
		}
	}
	
	private static int aStarSearch(Node startNode,Node[][] board,int a, int b, int N){
		Queue<Node> queue=initPriorityQueue();
		queue.add(startNode);
		int moves=-1;
		while(queue.isEmpty()==false){
			Node curNode=queue.poll();			
			if(curNode.x==N-1 && curNode.y==N-1){
				moves=curNode.dist/(a+b);
				break;
			}
			Collection<Node> neighbours=getNeighbours(curNode,board, a, b, N);
			for(Node neigh:neighbours){
				int newDist=curNode.dist+a+b;
				if(newDist<neigh.dist){
					neigh.dist=newDist;
					int manhattanDist=Math.abs(neigh.x-(N-1)) + Math.abs(neigh.y-(N-1));					
					int priority=neigh.dist+manhattanDist;
					//Default priority queue is max so inverse the priority
					priority= -priority;
					neigh.priority=priority;

					queue.add(neigh);
				}
			}
		}
		return moves;
	}
	
	private static List<Node> getNeighbours(Node curNode,Node[][] board, int a, int b,int N){
		int[] x={curNode.x+a,curNode.x+a,curNode.x-a,curNode.x-a,curNode.x+b,curNode.x+b,curNode.x-b,curNode.x-b};
		int[] y={curNode.y+b,curNode.y-b,curNode.y+b,curNode.y-b,curNode.y+a,curNode.y-a,curNode.y+a,curNode.y-a};
		Set<Node> neighbours=new HashSet<Node>();
		for(int i=0;i<8;i++){
			if(x[i]>=0 && x[i]<N && y[i]>=0 && y[i]<N){
				/*Node neig=new Node();
				neig.x=x[i];
				neig.y=y[i];*/
				Node neig=board[x[i]][y[i]];
/*				neig.dist=curNode.dist+a+b;
				int manhattanDist=Math.abs(neig.x-(N-1)) + Math.abs(neig.y-(N-1));
				int priority=neig.dist+manhattanDist;
				neig.priority=priority;
*/				neighbours.add(neig);
			}
		}
		List<Node> neighboursList=new ArrayList<Node>(neighbours);
		return neighboursList;
	}
	
/*	private static int[][] initBoard(int N){
		int MAX=Integer.MAX_VALUE;
		int[][] board=new int[N][N];
		for(int i=0;i<N;i++){
			for(int j=0;j<N;j++){
				board[i][j]=MAX;
			}
		}
		return board;
	}
*/	
	
	private static Node[][] initBoard(int N){
		int MAX=Integer.MAX_VALUE;
		Node[][] board=new Node[N][N];
		for(int i=0;i<N;i++){
			for(int j=0;j<N;j++){
				Node node=new Node();
				node.x=i;
				node.y=j;
				node.dist=MAX;
				node.priority=0;
				board[i][j]=node;
			}
		}
		return board;
	}

	private static PriorityQueue<Node> initPriorityQueue(){
		PriorityQueue<Node> queue=new PriorityQueue<Node>(new Comparator<Node>() {
			@Override
			public int compare(Node o1, Node o2) {
				int res=Integer.valueOf(o2.priority).compareTo(Integer.valueOf(o1.priority));
				return res;
			}			
		});
		return queue;
	}
	
	private static class Node{
		int x;
		int y;
		int dist;
		int priority;
		
		@Override
		public boolean equals(Object nodeObj){
			Node node=(Node)nodeObj;
			boolean result=false;
			if(this.x==node.x && this.y==node.y)
				result=true;
			return result;
		}
	}
	
}