#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <queue>
#include <stack>
#include <string>
#include <bitset>
#include <cstdio>
#include <limits>
#include <vector>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <numeric>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <unordered_map>

using namespace std;
bool is_valid_move(int x2, int y2, int n) {
   return x2 >= 0 && x2 <= n-1 && y2 >= 0 && y2 <= n-1 ;
}
int get_rook_moves (int a, int b, int x1, int y1, vector<vector<int>>& caching_matrix, int num_moves_rook, int n) {
    if (caching_matrix[x1][y1] != 0) { return caching_matrix[x1][y1];}
    if (x1==n-1 && y1 == n-1) return num_moves_rook;
    caching_matrix[x1][y1] = -1;
    int x2, y2, min_moves = -1, num_moves;
    x2 = x1+a;y2=y1+b;
    if (is_valid_move(x2, y2, n)) {
        num_moves = get_rook_moves (a, b, x2, y2, caching_matrix, num_moves_rook+1, n);
        if (num_moves != -1) {
            if (min_moves == -1) {
                min_moves = num_moves;
            } else if(num_moves <= min_moves) {
                min_moves = num_moves;
            }
        }
    }
    x2 = x1+a;y2=y1-b;
    if (is_valid_move(x2, y2, n)) {
        num_moves = get_rook_moves (a, b, x2, y2, caching_matrix, num_moves_rook+1, n);
        if (num_moves != -1) {
            if (min_moves == -1) {
                min_moves = num_moves;
            } else if(num_moves <= min_moves) {
                min_moves = num_moves;
            }
        }
    }
    x2 = x1-a;y2=y1+b;
    if (is_valid_move(x2, y2, n)) {
        num_moves = get_rook_moves (a, b, x2, y2, caching_matrix, num_moves_rook+1, n);
        if (num_moves != -1) {
            if (min_moves == -1) {
                min_moves = num_moves;
            } else if(num_moves <= min_moves) {
                min_moves = num_moves;
            }
        }
    }    
    x2 = x1-a;y2=y1-b;
    if (is_valid_move(x2, y2, n)) {
        num_moves = get_rook_moves (a, b, x2, y2, caching_matrix, num_moves_rook+1, n);
        if (num_moves != -1) {
            if (min_moves == -1) {
                min_moves = num_moves;
            } else if(num_moves <= min_moves) {
                min_moves = num_moves;
            }
        }
    }    
    x2 = x1+b;y2=y1+a;
    if (is_valid_move(x2, y2, n)) {
        num_moves = get_rook_moves (a, b, x2, y2, caching_matrix, num_moves_rook+1, n);
        if (num_moves != -1) {
            if (min_moves == -1) {
                min_moves = num_moves;
            } else if(num_moves <= min_moves) {
                min_moves = num_moves;
            }
        }
    }    
    x2 = x1+b;y2=y1-a;
    if (is_valid_move(x2, y2, n)) {
        num_moves = get_rook_moves (a, b, x2, y2, caching_matrix, num_moves_rook+1, n);
        if (num_moves != -1) {
            if (min_moves == -1) {
                min_moves = num_moves;
            } else if(num_moves <= min_moves) {
                min_moves = num_moves;
            }
        }
    }    
    x2 = x1-b;y2=y1+a;
    if (is_valid_move(x2, y2, n)) {
        num_moves = get_rook_moves (a, b, x2, y2, caching_matrix, num_moves_rook+1, n);
        if (num_moves != -1) {
            if (min_moves == -1) {
                min_moves = num_moves;
            } else if(num_moves <= min_moves) {
                min_moves = num_moves;
            }
        }
    }    
    x2 = x1-b;y2=y1-a;
    if (is_valid_move(x2, y2, n)) {
        num_moves = get_rook_moves (a, b, x2, y2, caching_matrix, num_moves_rook+1, n);
        if (num_moves != -1) {
            if (min_moves == -1) {
                min_moves = num_moves;
            } else if(num_moves <= min_moves) {
                min_moves = num_moves;
            }
        }
    }    
    caching_matrix[x1][y1] = min_moves;
    return min_moves;
}

int main(){
    int n;
    cin >> n;
    vector<vector<int>> solution_caching_matrix(n, vector<int>(n,0));
    int x1=0,y1=0;
    int a,b;
    for (int i=1; i<n; i++) {
        for (int j=1; j<n; j++) {
            a=i;b=j;
            if (solution_caching_matrix[j][i] != 0) {
                cout <<solution_caching_matrix[j][i]<<" ";
            } else {
                vector<vector<int>> caching_matrix(n, vector<int>(n,0));
                int num_moves = 0;
                solution_caching_matrix[i][j] = get_rook_moves(a, b, x1, y1, caching_matrix, num_moves, n);
                cout<<solution_caching_matrix[i][j]<<" ";
            }
        }
        cout<<endl;
    }
    // your code goes here
    return 0;
}