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 javax.annotation.processing.SupportedSourceVersion;
import java.io.*;
import java.util.*;
import java.util.regex.Matcher;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = /*new InputReader(new FileReader("input.txt"));*/   new InputReader(inputStream);
        PrintWriter out = /*new PrintWriter("output.txt"); */  new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(in, out);
        out.close();
    }

    private static class TaskB {

        static final long max = 1000000000000000000L;
        static final double eps = 0.0000001;
        static final long mod = 1000000007;

        void solve(InputReader in, PrintWriter out) throws IOException {

            int K = in.nextInt();

            String A[][] = new String[K][K];

            for (int i = 1; i < K; i++)
                for (int j = 1; j < K; j++)
                    A[i][j] = Integer.toString(i * j, K);

            for (int i = 1; i < K; i++) {
                for (int j = 1; j < K; j++)
                    out.print(A[i][j] + " ");
                out.println();
            }
        }

        long gcd(long A, long B) {
            if (B == 0) return A;
            return gcd(B, A % B);
        }

        boolean isPrime(long n) {
            if (n <= 1 || n > 3 && (n % 2 == 0 || n % 3 == 0))
                return false;
            for (long i = 5, j = 2; i * i <= n; i += j, j = 6 - j)
                if (n % i == 0)
                    return false;
            return true;
        }

        boolean isEqual(double A, double B) {
            return Math.abs(A - B) < eps;
        }

        double dist(double X1, double Y1, double X2, double Y2) {
            return Math.sqrt((X1 - X2) * (X1 - X2) + (Y1 - Y2) * (Y1 - Y2));
        }

        boolean nextPer(int[] data) {
            int i = data.length - 1;
            while (i > 0 && data[i] < data[i - 1]) {
                i--;
            }
            if (i == 0) {
                return false;
            }
            int j = data.length - 1;
            while (data[j] < data[i - 1]) {
                j--;
            }
            int temp = data[i - 1];
            data[i - 1] = data[j];
            data[j] = temp;
            Arrays.sort(data, i, data.length);
            return true;
        }

        long pow(long A, long B, long MOD) {
            if (B == 0) {
                return 1;
            }
            if (B == 1) {
                return A;
            }
            long val = pow(A, B / 2, MOD);
            if (B % 2 == 0) {
                return val * val % MOD;
            } else {
                return val * (val * A % MOD) % MOD;
            }
        }
    }

    private static class InputReader {
        StringTokenizer st;
        BufferedReader br;

        public InputReader(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public InputReader(FileReader s) throws FileNotFoundException {
            br = new BufferedReader(s);
        }

        public String next() {
            while (st == null || !st.hasMoreTokens())
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public String nextLine() {
            try {
                return br.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public boolean ready() {
            try {
                return br.ready();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}