#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 gcd(int a, int b);

int main(){
    int n;
    cin >> n;
    // your code goes here
    for( int i=1; i< n; i++){
        for( int j=1; j< n; j++){
            bool visited[n][n];
            int distance[n][n];
            for( int y=0; y<n; y++){
                for( int x=0; x<n; x++){
                    visited[y][x] = false;
                    distance[y][x] = -1;
                }
            }
            visited[0][0] = true;
            distance[0][0] = 0;
            distance[i][j] = 1;
            distance[j][i] = 1;
            while(1){
                // Find smallest distance with unvisited node
                int x1, y1, cDist = -1;
                for( int y=0; y<n; y++){
                    for( int x=0; x<n; x++){
                        if( visited[y][x] == false && distance[y][x] !=-1 && (distance[y][x] < cDist || cDist == -1 )){
                            cDist = distance[y][x];
                            x1 = x;
                            y1= y;
                            
                        }
                    }
                }
                if( cDist > -1 ){
                    
                    visited[y1][x1] = true;
                    for( int m=-1; m<=1; m+=2){
                        for( int p=-1; p<=1; p+=2){
                            int newposx = x1 + (p*i);
                            int newposy = y1 + (m*j);
                            if(( newposx >= 0 && newposx <n) && ( newposy>= 0 && newposy <n)){
                              
                                if( distance[newposy][newposx] > cDist + 1  || distance[newposy][newposx]==-1){
                                    
                                    distance[newposy][newposx] = cDist + 1;
                                }
                            }
                        }
                    }

                    // Switch moves
                    for( int m=-1; m<=1; m+=2){
                        for( int p=-1; p<=1; p+=2){
                            int newposx = x1 + (p*j);
                            int newposy = y1 + (m*i);
                            if(( newposx >= 0 && newposx <n) && ( newposy>= 0 && newposy <n)){
                                if( distance[newposy][newposx] > cDist + 1  || distance[newposy][newposx]==-1){
                                    distance[newposy][newposx] = cDist + 1;
                                }
                            }
                        }
                    }
                }else{
                    if( distance[n-1][n-1] == -1){
                        cout<< "-1 ";
                    }else{
                        cout<<distance[n-1][n-1]<< " ";
                    }/*
                    for( int y=0; y<n; y++){
                        for( int x=0; x<n; x++){
                            cout<<distance[y][x]<<" ";
                        }
                        cout<<endl;
                    }*/
                    break;
                }

            }
        

    }
        cout<<endl;
    }
    return 0;
}