9
 8
 6
 4
 7
 5
 2

1  2  3  4  5  6  7  8 
2  4  6  8 11 13 15 17 
3  6 10 13 16 20 23 26 
4  8 13 17 22 26 31 35 
5 11 16 22 27 33 38 44 
6 13 20 26 33 40 46 53 
7 15 23 31 38 46 54 62 
8 17 26 35 44 53 62 71 
 1  2  3  4  5  6  7 
2  4  6 10 12 14 16 
3  6 11 14 17 22 25 
4 10 14 20 24 30 34 
5 12 17 24 31 36 43 
6 14 22 30 36 44 52 
7 16 25 34 43 52 61 
 1  2  3  4  5 
2  4 10 12 14 
3 10 13 20 23 
4 12 20 24 32 
5 14 23 32 41 
 1  2  3 
2 10 12 
3 12 21 
 1  2  3  4  5  6 
2  4  6 11 13 15 
3  6 12 15 21 24 
4 11 15 22 26 33 
5 13 21 26 34 42 
6 15 24 33 42 51 
 1  2  3  4 
2  4 11 13 
3 11 14 22 
4 13 22 31 
 1 

import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;
import java.io.Writer;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Alex
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskH solver = new TaskH();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskH {
    public void solve(int testNumber, InputReader in, OutputWriter out){
	    int k = in.ri();
	    int[][] res = new int[k - 1][k - 1];
	    for(int i = 0; i < k - 1; i++) {
		    for(int j = 0; j < k - 1; j++) {
			    res[i][j] = (i + 1) * (j + 1);
		    }
	    }
	    for(int i = 0; i < res.length; i++) {
		    for(int j = 0; j < res.length; j++) {
			    out.print(Integer.toString(res[i][j], k) + " ");
		    }
		    out.printLine();
	    }
    }
}

class InputReader {
	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	public int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}
	public int ri(){
		return readInt();
	}

	public int readInt() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}
	public boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	public static boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}
	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}

class OutputWriter {
	private final PrintWriter writer;

	public OutputWriter(OutputStream outputStream) {
		writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
	}
	public void print(Object...objects) {
		for (int i = 0; i < objects.length; i++) {
			if (i != 0)
				writer.print(' ');
			writer.print(objects[i]);
		}
	}
	public void printLine() {
		writer.println();
	}
	public void close() {
		writer.close();
	}
}

