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

public class Solution {
	/*
    Solve Knight Problem with BFS
	 */
	public static void main(String[] args) {

		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		in.close();

		// 2D DP
		int T[][] = new int[n-1][n-1];

		for(int a=1;a<n;a++)
			for(int b=a;b<n;b++) {
				T[a-1][b-1]=bfs(a,b,n);
			}
		printSolution(T);
	}

	/*
	 * conduct bfs for bottom right node, starting top left
	 * returns lowest cost or -1 is there is no solution
	 */
	static int bfs(int a, int b, int n) {
		Queue<Node> edge = new LinkedList<Node>();
		Node[][] graph = new Node[n][n];
		for(int i=0;i<n;i++)
			for(int j=0;j<n;j++)
				graph[i][j]=new Node(i,j);
		int[] dx={a,a,-a,-a,b,b,-b,-b};
		int[] dy={b,-b,b,-b,a,-a,a,-a};
		graph[0][0].distance=0;
		edge.add(graph[0][0]);

		Node node;
		while(!edge.isEmpty()) {
			node=edge.remove();
			int x,y;
			for(int i=0;i<8;i++) {
				x=node.x+dx[i];
				y=node.y+dy[i];
				if((x==0&&y==0)||x<0||y<0||x>=n||y>=n) continue;
				else if(graph[x][y].distance!=0) continue;
				else if(x==n-1&&y==n-1) return node.distance+1;
				else{
					graph[x][y].distance=node.distance+1;
					edge.add(graph[x][y]);
				}
			}
		}
		return -1;
	}


	/*
	 * print the solution
	 */
	static void printSolution(int[][] T) {
		int n=T.length;
		for(int i=0;i<n;i++)
			for(int j=i+1;j<n;j++)
				T[j][i]=T[i][j];
		for(int i=0;i<n;i++) {
			for(int j=0;j<n;j++) {
				System.out.print(T[i][j]);
				if(j!=n-1) System.out.print(" ");
			}
			if(i!=n-1) System.out.println();
		}
	}
}

/*
 * Basic node class to be used in queue
 */
class Node {
	int x;
	int y;
	int distance;

	Node(int x, int y) {
		this.x=x;
		this.y=y;
	}
}