#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;

struct position {
    int x;
    int y;
    struct position& operator+=(const position& rhs) { x += rhs.x; y += rhs.y; return *this;}
    //position operator+(position const& lhs, position const& rhs);
};

position operator+(position lhs, const position& rhs) { return lhs += rhs;}
/*bool operator==(const position &lhs, const position& rhs) {
    if (lhs.x==rhs.x && lhs.y==rhs.y){
        return 
    }
}*/

/*
friend std::ostream& operator<< (std::ostream &out, const Point &point);
};

std::ostream& operator<< (std::ostream &out, const Point &point)
{
    // Since operator<< is a friend of the Point class, we can access Point's members directly.
    out << "Point(" << point.m_x << ", " << point.m_y << ", " << point.m_z << ")";
 
    return out;
}*/



int main(){
    int n;
    cin >> n;
    // your code goes here
    vector<vector<int>> min_steps(n-1, vector<int>(n-1)); // for storing min. no of steps for given KnightL
    vector<position> moves(8);

    //vector<vector<bool>> visited (n,vector<bool>(n,false)); // for marking visited positions, matrix rep.
    vector<position> present;//(n*n); // for positions reached after current no of steps, list rep.
    vector<position> future;//(n*n); // for positions reached after current + 1 no of steps
    int steps = 0;
    bool reached_finish = false;
    position next;
    //position final_position = {n-1,n-1};
    
    for(int a=1; a<n; ++a){
        for(int b=1; b<n; ++b){
            if(b<=a){
                // assign possible moves values
                moves[0] = {a,b};
                moves[1] = {a,-b};
                moves[2] = {-a,b};
                moves[3] = {-a,-b};
                moves[4] = {b,a};
                moves[5] = {b,-a};
                moves[6] = {-b,a};
                moves[7] = {-b,-a};
                
                // main loop
                    /*for(auto sub: visited){
                    for (auto :sub){

                    }
                }
                //fill(visited.begin(), visited.end(), false);
                */
                vector<vector<bool>> visited (n,vector<bool>(n,false)); // for marking visited positions, matrix rep.

                //cout << endl << "Checking Knight(" << a << ","<< b << "):" << endl;
                
                present.push_back({0,0});
                visited[0][0] = true;

                steps = 0;
                reached_finish = false;
                
                while(!present.empty()){
                    ++steps;
                    //cout << endl << "step:" << steps;
                    for (auto pos : present){
                        //cout << endl << "position (" << pos.x << "," << pos.y << ") check." << endl;
                        for (auto move: moves){
                            next = pos+move;
                            //cout << "possible next (" << next.x << "," << next.y << ")";
                            // check if in bounds
                            if(next.x >=0 && next.x <n && next.y>=0 && next.y<n){
                                //cout << " !In bounds!";
                                // if it's the final position
                                if(next.x == n-1 && next.y == n-1){
                                    reached_finish = true;
                                    goto endloop;
                                }
                                // check if not visited - since symmetrical values added one check should suffice
                                if (visited[next.x][next.y] == false){
                                    // add position and its symmetrical to visited
                                    visited[next.x][next.y] = true;
                                    visited[next.y][next.x] = true;
                                    // add to future
                                    //cout << " Adding to visited" << endl;
                                    future.push_back(next);
                                }
                            }
                        }
                    }
                    
                    present=future;
                    future.clear();
                }
                endloop:
                //cout << endl << "Out of loop, minimum steps:" ;
                // save no of steps
                if(reached_finish){
                    min_steps[a-1][b-1]=min_steps[b-1][a-1]=steps;
                    //cout << steps;
                } else {
                    min_steps[a-1][b-1]=min_steps[b-1][a-1]=-1;
                    //cout << "-1";
                }
                //cout << endl;

                present.clear();
                future.clear();
            }
        }
    }
    
    //vector<vector<int>> min_steps(n-1, vector<int>(n-1));
    for (int i=0; i<n-1; ++i){
        for (int j=0; j<n-1; j++){
            cout << min_steps[i][j] << " ";
        }
        cout << endl;
    }
    
    
    return 0;
}