#include <fstream>
#include <vector>
#include <algorithm>

using namespace std;

const int MAXN = 5;

int n, a[1 + MAXN * MAXN][1 + MAXN * MAXN], which[1 + MAXN * MAXN][1 + MAXN * MAXN];
bool line[1 + MAXN * MAXN][1 + MAXN * MAXN], column[1 + MAXN * MAXN][1 + MAXN * MAXN], square[1 + MAXN * MAXN][1 + MAXN * MAXN];

struct Cell {
    int line;
    int column;
    vector<int> maybe;

    bool operator < (const Cell &other) const {
        return maybe.size() < other.maybe.size();
    }
};

Cell bad[1 + MAXN * MAXN * MAXN * MAXN];
int need = 0;

int Get(int l, int c, int n) {
    return ((l - 1) / n) * n + (c - 1) / n + 1;
}

void Backtracking(int level) {
    if (level == need + 1) {
        for (int i = 1; i <= n * n; i++, printf("\n"))
            for(int j = 1; j <= n * n; j++)
                printf("%d ", a[i][j]);
        exit(0);
    }
    int i = bad[level].line, j = bad[level].column;
    for (int x = 0; x < bad[level].maybe.size(); x++) {
        int k = bad[level].maybe[x];
        if (!line[i][k] && !column[j][k] && !square[which[i][j]][k]) {
            a[i][j] = k;
            line[i][k] = column[j][k] = square[which[i][j]][k] = true;
            Backtracking(level + 1);
            line[i][k] = column[j][k] = square[which[i][j]][k] = false;
            a[i][j] = 0;
        }
    }
}

int main() {
    //freopen("d.in", "r", stdin);
    //freopen("d.out", "w", stdout);
    scanf("%d", &n);
    for (int i = 1; i <= n * n; i++)
        for (int j = 1; j <= n * n; j++) {
            scanf("%d", &a[i][j]);
            which[i][j] = Get(i, j, n);
            if (a[i][j])
                line[i][a[i][j]] = column[j][a[i][j]] = square[which[i][j]][a[i][j]] = true;
        }
    for (int i = 1; i <= n * n; i++)
        for (int j = 1; j <= n * n; j++)
            if (!a[i][j]) {
                need++;
                bad[need].line = i;
                bad[need].column = j;
                for (int k = 1; k <= n * n; k++)
                    if (!line[i][k] && !column[j][k] && !square[which[i][j]][k])
                        bad[need].maybe.push_back(k);
            }
    sort(bad + 1, bad + need + 1);
    Backtracking(1);
    return 0;
}