def moveNight(a, b, n, loc):
    for dx,dy in [[a,b], [b,a]]:
        for sx, sy in [[1,1], [-1,1], [1,-1], [-1,-1]]:
            x = loc[0] + dx * sx
            y = loc[1] + dy * sy
            if any([x<0, y<0, x>n-1, y>n-1]):
                # Out of bounds
                continue
            yield x,y

def breadthF(a, b, n):
    traveled = set(((0,0),))
    level = set(((0,0),))
    d = 1
    while level:
        newLevel = set()
        for loc in level:
            for x,y in moveNight(a,b,n,loc):
                if (x,y) == (n-1,n-1):
                    return d
                if (x,y) not in traveled:
                    traveled.add((x,y))
                    newLevel.add((x,y))

        level = newLevel
        d += 1

    return -1

def knightlOnAChessboard(n):
    # Loop rows and columns
    ans = [[breadthF(row,col,n) for col in range(1,n)] for row in range(1, n)]
    return ans

#include <bits/stdc++.h>

using namespace std;

string ltrim(const string &);
string rtrim(const string &);

/*
 * Complete the 'knightlOnAChessboard' function below.
 *
 * The function is expected to return a 2D_INTEGER_ARRAY.
 * The function accepts INTEGER n as parameter.
 */



int bfs(int i,int j,int n){
    queue<pair<pair<int,int>,int>> q;
    int v[n][n];
    int movesx[] = {i,i,-i,-i,j,j,-j,-j};
    int movesy[] = {j,-j,j,-j,i,-i,i,-i};
    memset(v, -1, sizeof(v));
    q.push({{0,0},0});
    
    while(!q.empty()){
        int x = q.front().first.first,y = q.front().first.second,level = q.front().second;
        
        for(int i=0;i<8;i++){
            int tempx = x+movesx[i],tempy= y+movesy[i]; 
            if(tempx>=0 && tempy>=0 && tempx<n && tempy<n && v[tempx][tempy]==-1){
                q.push({{tempx,tempy},level+1});
                v[tempx][tempy]=1;
            }
        }
        if(x==n-1 && y==n-1){
            return level;
        }
        q.pop();
    }
    return -1;
    
}

vector<vector<int>> knightlOnAChessboard(int n) {
    vector<vector<int>> res(n-1,vector<int>(n-1,0));
    
    for(int i=0;i<n-1;i++){
        for (int j=0; j<n-1; j++) {
            
            if(i==j){
                if((n+i)%(i+1)==0){
                    res[i][j] = (n+i)/(i+1)-1;
                }else{
                    res[i][j] = -1;
                }
                
            }
            
            if(res[i][j]==0 && i!=j)
                res[i][j] = bfs(i+1, j+1, n);
                res[j][i] = res[i][j];
            
        }
    }
    return res;
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    string n_temp;
    getline(cin, n_temp);

    int n = stoi(ltrim(rtrim(n_temp)));

    vector<vector<int>> result = knightlOnAChessboard(n);

    for (size_t i = 0; i < result.size(); i++) {
        for (size_t j = 0; j < result[i].size(); j++) {
            fout << result[i][j];

            if (j != result[i].size() - 1) {
                fout << " ";
            }
        }

        if (i != result.size() - 1) {
            fout << "\n";
        }
    }

    fout << "\n";

    fout.close();

    return 0;
}

string ltrim(const string &str) {
    string s(str);

    s.erase(
        s.begin(),
        find_if(s.begin(), s.end(), not1(ptr_fun<int, int>(isspace)))
    );

    return s;
}

string rtrim(const string &str) {
    string s(str);

    s.erase(
        find_if(s.rbegin(), s.rend(), not1(ptr_fun<int, int>(isspace))).base(),
        s.end()
    );

    return s;
}

from collections import deque


class Solution:

    def knightlOnAChessboard(self, n):
        res = [[-1 for _ in range(n-1)] for _ in range(n-1)]
        for i in range(1, n):
            for j in range(1, n):
                # there will be two paris for which the path len will be same, a,b and b,a.
                # So to optimize just reuse if other pair is already computed. This reduces the computation to half
                res[i-1][j-1] = res[j-1][i-1] if res[j-1][i-1] != -1 else self.knight_min_move(n, i, j)
        return res

    def knight_min_move(self, n, a, b):
        # Using a set to have distinct values only
        choices = {(a, b), (a, -b), (-a, b), (-a, -b), (b, a), (b, -a), (-b, a), (-b, -a)}

        visited = [[-1 for _ in range(n)] for _ in range(n)]

        visited[0][0] = 0

        q = deque()
        q.append((0, 0, 0))  # Stores row_index, col_index, depth

        while len(q) != 0:
            nodes_at_level = len(q)
            for i in range(nodes_at_level):
                x, y, d = q.popleft()
                if x == n - 1 and y == n - 1:
                    return d

                for choice in choices:
                    n_x = x + choice[0]
                    n_y = y + choice[1]
                    # Check if suggested new cell is valid 
                    if -1 < n_x < n and -1 < n_y < n and visited[n_x][n_y] == -1:
                        visited[n_x][n_y] = d + 1
                        q.append((n_x, n_y, d + 1))
        return -1