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


int main(){
    int n;
    cin >> n;
    
    std::vector<std::vector<int>> stored_moves(n-1, std::vector<int>(n-1, -1));

    std::pair<int,int> target(0,0);
    if(n < 5 || n> 25)  return -1;
    for(int i=1; i<n; i++)
    {
        for(int j=i; j<n; j++)
        {            
            std::vector<std::vector<bool>> current_board(n, std::vector<bool>(n, false));
            std::vector<std::vector<bool>> last_board(n, std::vector<bool>(n, false));
            std::vector<int> new_x;
            std::vector<int> new_y;
            new_x.push_back(n-1);
            new_y.push_back(n-1);
            current_board[n-1][n-1] = true;
            
            int while_count = 0;
            while(!current_board[0][0] && !new_x.empty())
            {
                vector<int> last_x = new_x;
                new_x.clear();
                vector<int> last_y = new_y;                
                new_y.clear();
                for(int k=0; k<last_x.size(); k++)
                {
                    int x=last_x[k];
                    int y=last_y[k];
                    int xpi = x+i;
                    int xmi = x-i;
                    int ypj = y+j;
                    int ymj = y-j;
                    if(xpi > 0 && xpi < n)
                    {
                        if(ypj >= 0 && ypj < n && !current_board[xpi][ypj])
                        {
                            new_x.push_back(xpi);
                            new_y.push_back(ypj);
                            current_board[xpi][ypj] = true;
                        }
                        if(ymj >= 0 && ymj < n && !current_board[xpi][ymj])
                        {
                            new_x.push_back(xpi);
                            new_y.push_back(ymj);
                            current_board[xpi][ymj] = true;
                        }
                    }
                    if(xmi >= 0 && xmi < n)
                    {
                        if(ypj >= 0 && ypj < n && !current_board[xmi][ypj])
                        {
                            new_x.push_back(xmi);
                            new_y.push_back(ypj);
                            current_board[xmi][ypj] = true;
                        }
                        if(ymj >= 0 && ymj < n && !current_board[xmi][ymj])
                        {
                            new_x.push_back(xmi);
                            new_y.push_back(ymj);
                            current_board[xmi][ymj] = true;
                        }
                    }
                    // lazy:
                    /*
                    int xpj = x+j;
                    int xmj = x-j;                    
                    int ypi = y+i;
                    int ymi = y-i;*/
                    xpi = x+j;
                    xmi = x-j;
                    ypj = y+i;
                    ymj = y-i;
                    if(xpi > 0 && xpi < n)
                    {
                        if(ypj >= 0 && ypj < n && !current_board[xpi][ypj])
                        {
                            new_x.push_back(xpi);
                            new_y.push_back(ypj);
                            current_board[xpi][ypj] = true;
                        }
                        if(ymj >= 0 && ymj < n && !current_board[xpi][ymj])
                        {
                            new_x.push_back(xpi);
                            new_y.push_back(ymj);
                            current_board[xpi][ymj] = true;
                        }
                    }
                    if(xmi >= 0 && xmi < n)
                    {
                        if(ypj >= 0 && ypj < n && !current_board[xmi][ypj])
                        {
                            new_x.push_back(xmi);
                            new_y.push_back(ypj);
                            current_board[xmi][ypj] = true;
                        }
                        if(ymj >= 0 && ymj < n && !current_board[xmi][ymj])
                        {
                            new_x.push_back(xmi);
                            new_y.push_back(ymj);
                            current_board[xmi][ymj] = true;
                        }
                    }
                }
                while_count++;
            }
            if(current_board[0][0] == true)
            {
                stored_moves[i-1][j-1] = while_count;
                stored_moves[j-1][i-1] = while_count;
            }
        }        
    }
    
    for(int i=0; i<n-1; i++)
    {
        for(int j=0; j<n-1; j++)
        {
            cout << stored_moves[i][j] << " ";
        }
        cout << endl;
    }
    

    // your code goes here
    return 0;
}