#include <bits/stdc++.h>

using namespace std;

int szamok[22][22];
int kezd[80][3];
int veg[80][3];
vector<vector<vector<int> > > mezok;

int main()
{
    int n;
    cin >> n;
    int kezddb = 0;
    int j = 1;
    for (int i = 1; i<=n; i++) {
        cin >> szamok[i][1];
        if (szamok[i][1]>0) {
            j = 1;
            while (kezd[j][0] != szamok[i][1] && j <= kezddb) {
                j++;
            }
            if (j > kezddb) {
                kezddb++;
                kezd[kezddb][0] = szamok[i][1];
                kezd[kezddb][1] = i;
                kezd[kezddb][2] = 1;
            } else {
                veg[j][0] = kezd[j][0];
                veg[j][1] = i;
                veg[j][2] = 1;
            }
        }
    }
    for (int i = 1; i<=n; i++) {
        cin >> szamok[n][i];
        if (szamok[n][i]>0) {
            j = 1;
            while (kezd[j][0] != szamok[n][i] && j <= kezddb) {
                j++;
            }
            if (j > kezddb) {
                kezddb++;
                kezd[kezddb][0] = szamok[n][i];
                kezd[kezddb][1] = n;
                kezd[kezddb][2] = i;
            } else {
                veg[j][0] = kezd[j][0];
                veg[j][1] = n;
                veg[j][2] = i;
            }
        }
    }
    for (int i = n; i>=1; i--) {
        cin >> szamok[i][n];
        if (szamok[i][n]>0) {
            j = 1;
            while (kezd[j][0] != szamok[i][n] && j <= kezddb) {
                j++;
            }
            if (j > kezddb) {
                kezddb++;
                kezd[kezddb][0] = szamok[i][n];
                kezd[kezddb][1] = i;
                kezd[kezddb][2] = n;
            } else {
                veg[j][0] = kezd[j][0];
                veg[j][1] = i;
                veg[j][2] = n;
            }
        }
    }
    for (int i = n; i>=1; i--) {
        cin >> szamok[1][i];
        if (szamok[1][i]>0) {
            j = 1;
            while (kezd[j][0] != szamok[1][i] && j <= kezddb) {
                j++;
            }
            if (j > kezddb) {
                kezddb++;
                kezd[kezddb][0] = szamok[1][i];
                kezd[kezddb][1] = 1;
                kezd[kezddb][2] = i;
            } else {
                veg[j][0] = kezd[j][0];
                veg[j][1] = 1;
                veg[j][2] = i;
            }
        }
    }


    for (int i = 2; i<=n-1; i++) {
        for (int j = 2; j<=n-1; j++) {
            szamok[i][j] = 1;
        }
    }

    for (int i = 0; i<=n+1; i++) {
        mezok.push_back(vector<vector<int> >());
        for (int j = 0; j<=n+1; j++) {
            mezok[i].push_back(vector<int>());
        }
    }

    for (int i = 1; i<=kezddb; i++) {
        if ((kezd[i][2] == 1 && veg[i][2] == n) && kezd[i][1] == veg[i][1]) {
            for (int j = 2; j<=n-1; j++) {
                szamok[kezd[i][1]][j] *= kezd[i][0];
                mezok[kezd[i][1]][j].push_back(kezd[i][0]);
            }
        } else if ((kezd[i][1] == n && veg[i][1] == 1) && kezd[i][2] == veg[i][2]) {
            for (int j = 2; j<=n-1; j++) {
                szamok[j][kezd[i][2]] *= kezd[i][0];
                mezok[j][kezd[i][2]].push_back(kezd[i][0]);
            }
        }
    }

    for (int i = 1; i<=kezddb; i++) {
        if (kezd[i][2] == 1 && veg[i][1] == 1) {
            for (int j = 2; j<=veg[i][2]; j++) {
                szamok[kezd[i][1]][j] *= kezd[i][0];
                mezok[kezd[i][1]][j].push_back(kezd[i][0]);
            }
            for (int j = 2; j<kezd[i][1]; j++) {
                szamok[j][veg[i][2]] *= kezd[i][0];
                mezok[j][veg[i][2]].push_back(kezd[i][0]);
            }
        } else if (kezd[i][2] == 1 && veg[i][1] == n) {
            for (int j = 2; j<=veg[i][2]; j++) {
                szamok[kezd[i][1]][j] *= kezd[i][0];
                mezok[kezd[i][1]][j].push_back(kezd[i][0]);
            }
            for (int j = n-1; j>kezd[i][1]; j--) {
                szamok[j][veg[i][2]] *= kezd[i][0];
                mezok[j][veg[i][2]].push_back(kezd[i][0]);
            }
        } else if (kezd[i][1] == n && veg[i][2] == n) {
            for (int j = n-1; j>=veg[i][1]; j--) {
                szamok[j][kezd[i][2]] *= kezd[i][0];
                mezok[j][kezd[i][2]].push_back(kezd[i][0]);
            }
            for (int j = n-1; j>kezd[i][2]; j--) {
                szamok[veg[i][1]][j] *= kezd[i][0];
                mezok[veg[i][1]][j].push_back(kezd[i][0]);
            }
        } else if (kezd[i][2] == n && veg[i][1] == 1) {
            for (int j = n-1; j>=veg[i][2]; j--) {
                szamok[kezd[i][1]][j] *= kezd[i][0];
                mezok[kezd[i][1]][j].push_back(kezd[i][0]);
            }
            for (int j = 2; j<kezd[i][1]; j++) {
                szamok[j][veg[i][2]] *= kezd[i][0];
                mezok[j][veg[i][2]].push_back(kezd[i][0]);
            }
        }
    }

    for (int i = 1; i<=kezddb; i++) {
        if (kezd[i][2] == 1 && veg[i][2] == 1) {
            if (kezd[i][1] < veg[i][1]) {
                int pont = 0;
                int k = 2;
                while (pont == 0 && k < n-1) {
                    int igaz = 0;
                    int l = kezd[i][1]-1;
                    while (igaz == 0 && l <= veg[i][1]) {
                        if (szamok[l+1][k] != 1 && szamok[l][k] != 1) {
                            for (int j : mezok[l][k]) {
                                auto it = find(mezok[l+1][k].begin(),mezok[l+1][k].end(),j);
                                if (it != mezok[l+1][k].end()) {
                                    igaz = 1;
                                }
                            }
                        }
                        l++;
                    }
                    if (igaz == 0) {
                        pont = k;
                    }
                    k++;
                }
                if (pont == 0) {
                    pont = k;
                }
                for (int j = 2; j<=pont; j++) {
                    szamok[kezd[i][1]][j] *= kezd[i][0];
                    mezok[kezd[i][1]][j].push_back(kezd[i][0]);
                }
                for (int j = 1; j<=(veg[i][1]-kezd[i][1]-1); j++) {
                    szamok[kezd[i][1]+j][pont] *= kezd[i][0];
                    mezok[kezd[i][1]+j][pont].push_back(kezd[i][0]);
                }
                for (int j = 2; j<=pont; j++) {
                    szamok[veg[i][1]][j] *= kezd[i][0];
                    mezok[veg[i][1]][j].push_back(kezd[i][0]);
                }
            } else {
                int pont = 0;
                int k = 2;
                while (pont == 0 && k < n-1) {
                    int igaz = 0;
                    int l = veg[i][1]-1;
                    while (igaz == 0 && l <= kezd[i][1]) {
                        if (szamok[l+1][k] != 1 && szamok[l][k] != 1) {
                            for (int j : mezok[l][k]) {
                                auto it = find(mezok[l+1][k].begin(),mezok[l+1][k].end(),j);
                                if (it != mezok[l+1][k].end()) {
                                    igaz = 1;
                                }
                            }
                        }
                        l++;
                    }
                    if (igaz == 0) {
                        pont = k;
                    }
                    k++;
                }
                if (pont == 0) {
                    pont = k;
                }
                for (int j = 2; j<=pont; j++) {
                    szamok[kezd[i][1]][j] *= kezd[i][0];
                    mezok[kezd[i][1]][j].push_back(kezd[i][0]);
                }
                for (int j = 1; j<=(kezd[i][1]-veg[i][1]-1); j++) {
                    szamok[veg[i][1]+j][pont] *= kezd[i][0];
                    mezok[veg[i][1]+j][pont].push_back(kezd[i][0]);
                }
                for (int j = 2; j<=pont; j++) {
                    szamok[veg[i][1]][j] *= kezd[i][0];
                    mezok[veg[i][1]][j].push_back(kezd[i][0]);
                }
            }
        } else if (kezd[i][1] == n && veg[i][1] == n) {
            if (kezd[i][2] < veg[i][2]) {
                int pont = 0;
                int k = n-1;
                while (pont == 0 && k > 2) {
                    int igaz = 0;
                    int l = kezd[i][2]-1;
                    while (igaz == 0 && l <= veg[i][2]) {
                        if (szamok[k][l+1] != 1 && szamok[k][l] != 1) {
                            for (int j : mezok[k][l]) {
                                auto it = find(mezok[k][l+1].begin(),mezok[k][l+1].end(),j);
                                if (it != mezok[k][l+1].end()) {
                                    igaz = 1;
                                }
                            }
                        }
                        l++;
                    }
                    if (igaz == 0) {
                        pont = k;
                    }
                    k--;
                }
                if (pont == 0) {
                    pont = k;
                }
                for (int j = n-1; j>=pont; j--) {
                    szamok[j][kezd[i][2]] *= kezd[i][0];
                    mezok[j][kezd[i][2]].push_back(kezd[i][0]);
                }
                for (int j = 1; j<=(veg[i][2]-kezd[i][2]-1); j++) {
                    szamok[pont][kezd[i][2]+j] *= kezd[i][0];
                    mezok[pont][kezd[i][2]+j].push_back(kezd[i][0]);
                }
                for (int j = n-1; j>=pont; j--) {
                    szamok[j][veg[i][2]] *= kezd[i][0];
                    mezok[j][veg[i][2]].push_back(kezd[i][0]);
                }
            } else {
                int pont = 0;
                int k = n-1;
                while (pont == 0 && k > 2) {
                    int igaz = 0;
                    int l = veg[i][2]-1;
                    while (igaz == 0 && l <= kezd[i][2]) {
                        if (szamok[k][l+1] != 1 && szamok[k][l] != 1) {
                            for (int j : mezok[k][l]) {
                                auto it = find(mezok[k][l+1].begin(),mezok[k][l+1].end(),j);
                                if (it != mezok[k][l+1].end()) {
                                    igaz = 1;
                                }
                            }
                        }
                        l++;
                    }
                    if (igaz == 0) {
                        pont = k;
                    }
                    k--;
                }
                if (pont == 0) {
                    pont = k;
                }
                for (int j = n-1; j>=pont; j--) {
                    szamok[j][kezd[i][2]] *= kezd[i][0];
                    mezok[j][kezd[i][2]].push_back(kezd[i][0]);
                }
                for (int j = 1; j<=(kezd[i][2]-veg[i][2]-1); j++) {
                    szamok[pont][veg[i][2]+j] *= kezd[i][0];
                    mezok[pont][veg[i][2]+j].push_back(kezd[i][0]);
                }
                for (int j = n-1; j>=pont; j--) {
                    szamok[j][veg[i][2]] *= kezd[i][0];
                    mezok[j][veg[i][2]].push_back(kezd[i][0]);
                }
            }
        } else if (kezd[i][2] == n && veg[i][2] == n) {
            if (kezd[i][1] < veg[i][1]) {
                int pont = 0;
                int k = n-1;
                while (pont == 0 && k > 2) {
                    int igaz = 0;
                    int l = kezd[i][1]-1;
                    while (igaz == 0 && l <= veg[i][1]) {
                        if (szamok[l+1][k] != 1 && szamok[l][k] != 1) {
                            for (int j : mezok[l][k]) {
                                auto it = find(mezok[l+1][k].begin(),mezok[l+1][k].end(),j);
                                if (it != mezok[l+1][k].end()) {
                                    igaz = 1;
                                }
                            }
                        }
                        l++;
                    }
                    if (igaz == 0) {
                        pont = k;
                    }
                    k--;
                }
                if (pont == 0) {
                    pont = k;
                }
                for (int j = n-1; j>=pont; j--) {
                    szamok[kezd[i][1]][j] *= kezd[i][0];
                    mezok[kezd[i][1]][j].push_back(kezd[i][0]);
                }
                for (int j = 1; j<=(veg[i][1]-kezd[i][1]-1); j++) {
                    szamok[kezd[i][1]+j][pont] *= kezd[i][0];
                    mezok[kezd[i][1]+j][pont].push_back(kezd[i][0]);
                }
                for (int j = n-1; j>=pont; j--) {
                    szamok[veg[i][1]][j] *= kezd[i][0];
                    mezok[veg[i][1]][j].push_back(kezd[i][0]);
                }
            } else {
                int pont = 0;
                int k = n-1;
                while (pont == 0 && k > 2) {
                    int igaz = 0;
                    int l = veg[i][1]-1;
                    while (igaz == 0 && l <= kezd[i][1]) {
                        if (szamok[l+1][k] != 1 && szamok[l][k] != 1) {
                            for (int j : mezok[l][k]) {
                                auto it = find(mezok[l+1][k].begin(),mezok[l+1][k].end(),j);
                                if (it != mezok[l+1][k].end()) {
                                    igaz = 1;
                                }
                            }
                        }
                        l++;
                    }
                    if (igaz == 0) {
                        pont = k;
                    }
                    k--;
                }
                if (pont == 0) {
                    pont = k;
                }
                for (int j = n-1; j>=pont; j--) {
                    szamok[kezd[i][1]][j] *= kezd[i][0];
                    mezok[kezd[i][1]][j].push_back(kezd[i][0]);
                }
                for (int j = 1; j<=(kezd[i][1]-veg[i][1]-1); j++) {
                    szamok[veg[i][1]+j][pont] *= kezd[i][0];
                    mezok[veg[i][1]+j][pont].push_back(kezd[i][0]);
                }
                for (int j = n-1; j>=pont; j--) {
                    szamok[veg[i][1]][j] *= kezd[i][0];
                    mezok[veg[i][1]][j].push_back(kezd[i][0]);
                }
            }
        } else if (kezd[i][1] == 1 && veg[i][1] == 1) {
            if (kezd[i][2] < veg[i][2]) {
                int pont = 0;
                int k = 2;
                while (pont == 0 && k < n-1) {
                    int igaz = 0;
                    int l = kezd[i][2]-1;
                    while (igaz == 0 && l <= veg[i][2]) {
                        if (szamok[k][l+1] != 1 && szamok[k][l] != 1) {
                            for (int j : mezok[k][l]) {
                                auto it = find(mezok[k][l+1].begin(),mezok[k][l+1].end(),j);
                                if (it != mezok[k][l+1].end()) {
                                    igaz = 1;
                                }
                            }
                        }
                        l++;
                    }
                    if (igaz == 0) {
                        pont = k;
                    }
                    k++;
                }
                if (pont == 0) {
                    pont = k;
                }
                for (int j = 2; j<=pont; j++) {
                    szamok[j][kezd[i][2]] *= kezd[i][0];
                    mezok[j][kezd[i][2]].push_back(kezd[i][0]);
                }
                for (int j = 1; j<=(veg[i][2]-kezd[i][2]-1); j++) {
                    szamok[pont][kezd[i][2]+j] *= kezd[i][0];
                    mezok[pont][kezd[i][2]+j].push_back(kezd[i][0]);
                }
                for (int j = 2; j<=pont; j++) {
                    szamok[j][veg[i][2]] *= kezd[i][0];
                    mezok[j][veg[i][2]].push_back(kezd[i][0]);
                }
            } else {
                int pont = 0;
                int k = 2;
                while (pont == 0 && k < n-1) {
                    int igaz = 0;
                    int l = veg[i][2]-1;
                    while (igaz == 0 && l <= kezd[i][2]) {
                        if (szamok[k][l+1] != 1 && szamok[k][l] != 1) {
                            for (int j : mezok[k][l]) {
                                auto it = find(mezok[k][l+1].begin(),mezok[k][l+1].end(),j);
                                if (it != mezok[k][l+1].end()) {
                                    igaz = 1;
                                }
                            }
                        }
                        l++;
                    }
                    if (igaz == 0) {
                        pont = k;
                    }
                    k++;
                }
                if (pont == 0) {
                    pont = k;
                }
                for (int j = 2; j<=pont; j++) {
                    szamok[j][kezd[i][2]] *= kezd[i][0];
                    mezok[j][kezd[i][2]].push_back(kezd[i][0]);
                }
                for (int j = 1; j<=(kezd[i][2]-veg[i][2]-1); j++) {
                    szamok[pont][veg[i][2]+j] *= kezd[i][0];
                    mezok[pont][veg[i][2]+j].push_back(kezd[i][0]);
                }
                for (int j = 2; j<=pont; j++) {
                    szamok[j][veg[i][2]] *= kezd[i][0];
                    mezok[j][veg[i][2]].push_back(kezd[i][0]);
                }
            }
        }
    }

    for (int i = 1; i<=kezddb; i++) {
        if ((kezd[i][2] == 1 && veg[i][2] == n) && kezd[i][1] != veg[i][1]) {
            if (kezd[i][1] < veg[i][1]) {
                int k = 2;
                int pont = 0;
                while (pont == 0 && k < n-1) {
                    int igaz = 0;
                    int l = kezd[i][1]-1;
                    while (igaz == 0 && l <= veg[i][1]) {
                        if (szamok[l+1][k] != 1 && szamok[l][k] != 1) {
                            for (int j : mezok[l][k]) {
                                auto it = find(mezok[l+1][k].begin(),mezok[l+1][k].end(),j);
                                if (it != mezok[l+1][k].end()) {
                                    igaz = 1;
                                }
                            }
                        }
                        l++;
                    }
                    if (igaz == 0) {
                        l = k-1;
                        while (igaz == 0 && l < n-1) {
                            if (szamok[veg[i][1]][l+1] != 1 && szamok[veg[i][1]][l] != 1) {
                                for (int j : mezok[veg[i][1]][l]) {
                                    auto it = find(mezok[veg[i][1]][l+1].begin(),mezok[veg[i][1]][l+1].end(),j);
                                    if (it != mezok[veg[i][1]][l+1].end()) {
                                        igaz = 1;
                                    }
                                }

                            }
                            l++;
                        }
                        if (igaz == 0) {
                            pont = k;
                        }
                    }
                    k++;
                }
                if (pont == 0) {
                    pont = k;
                }
                for (int j = 2; j<=pont; j++) {
                    szamok[kezd[i][1]][j] *= kezd[i][0];
                    mezok[kezd[i][1]][j].push_back(kezd[i][0]);
                }
                for (int j = 1; j<=(veg[i][1]-kezd[i][1]-1); j++) {
                    szamok[kezd[i][1]+j][pont] *= kezd[i][0];
                    mezok[kezd[i][1]+j][pont].push_back(kezd[i][0]);
                }
                for (int j = n-1; j>=pont; j--) {
                    szamok[veg[i][1]][j] *= kezd[i][0];
                    mezok[veg[i][1]][j].push_back(kezd[i][0]);
                }
            } else {
                int k = 2;
                int pont = 0;
                while (pont == 0 && k < n-1) {
                    int igaz = 0;
                    int l = kezd[i][1]+1;
                    while (igaz == 0 && l >= veg[i][1]) {
                        if (szamok[l-1][k] != 1 && szamok[l][k] != 1) {
                            for (int j : mezok[l][k]) {
                                auto it = find(mezok[l-1][k].begin(),mezok[l-1][k].end(),j);
                                if (it != mezok[l-1][k].end()) {
                                    igaz = 1;
                                }
                            }
                        }
                        l--;
                    }
                    if (igaz == 0) {
                        l = k-1;
                        while (igaz == 0 && l < n-1) {
                            if (szamok[veg[i][1]][l+1] != 1 && szamok[veg[i][1]][l] != 1) {
                                for (int j : mezok[veg[i][1]][l]) {
                                    auto it = find(mezok[veg[i][1]][l+1].begin(),mezok[veg[i][1]][l+1].end(),j);
                                    if (it != mezok[veg[i][1]][l+1].end()) {
                                        igaz = 1;
                                    }
                                }
                            }
                            l++;
                        }
                        if (igaz == 0) {
                            pont = k;
                        }
                    }
                    k++;
                }
                if (pont == 0) {
                    pont = k;
                }
                for (int j = 2; j<=pont; j++) {
                    szamok[kezd[i][1]][j] *= kezd[i][0];
                    mezok[kezd[i][1]][j].push_back(kezd[i][0]);
                }
                for (int j = 1; j<=(kezd[i][1]-veg[i][1]-1); j++) {
                    szamok[veg[i][1]+j][pont] *= kezd[i][0];
                    mezok[veg[i][1]+j][pont].push_back(kezd[i][0]);
                }
                for (int j = n-1; j>=pont; j--) {
                    szamok[veg[i][1]][j] *= kezd[i][0];
                    mezok[veg[i][1]][j].push_back(kezd[i][0]);
                }
            }
        } else if ((kezd[i][1] == n && veg[i][1] == 1) && kezd[i][2] != veg[i][2]) {
            if (kezd[i][2] < veg[i][2]) {
                int k = n-1;
                int pont = 0;
                while (pont == 0 && k > 2) {
                    int igaz = 0;
                    int l = kezd[i][2]-1;
                    while (igaz == 0 && l <= veg[i][2]) {
                        if (szamok[k][l+1] != 1 && szamok[k][l] != 1) {
                            for (int j : mezok[k][l]) {
                                auto it = find(mezok[k][l+1].begin(),mezok[k][l+1].end(),j);
                                if (it != mezok[k][l+1].end()) {
                                    igaz = 1;
                                }
                            }
                        }
                        l++;
                    }
                    if (igaz == 0) {
                        l = k+1;
                        while (igaz == 0 && l > 2) {
                            if (szamok[l-1][veg[i][2]] != 1 && szamok[l][veg[i][2]] != 1) {
                                for (int j : mezok[l][veg[i][2]]) {
                                    auto it = find(mezok[l-1][veg[i][2]].begin(),mezok[l-1][veg[i][2]].end(),j);
                                    if (it != mezok[l-1][veg[i][2]].end()) {
                                        igaz = 1;
                                    }
                                }
                            }
                            l--;
                        }
                        if (igaz == 0) {
                            pont = k;
                        }
                    }
                    k--;
                }
                if (pont == 0) {
                    pont = k;
                }
                for (int j = n-1; j>=pont; j--) {
                    szamok[j][kezd[i][2]] *= kezd[i][0];
                    mezok[j][kezd[i][2]].push_back(kezd[i][0]);
                }
                for (int j = 1; j<=(veg[i][2]-kezd[i][2]-1); j++) {
                    szamok[pont][kezd[i][2]+j] *= kezd[i][0];
                    mezok[pont][kezd[i][2]+j].push_back(kezd[i][0]);
                }
                for (int j = 2; j<=pont; j++) {
                    szamok[j][veg[i][2]] *= kezd[i][0];
                    mezok[j][veg[i][2]].push_back(kezd[i][0]);
                }
            } else {
                int k = n-1;
                int pont = 0;
                while (pont == 0 && k > 2) {
                    int igaz = 0;
                    int l = kezd[i][2]+1;
                    while (igaz == 0 && l >= veg[i][2]) {
                        if (szamok[k][l-1] != 1 && szamok[k][l] != 1) {
                            for (int j : mezok[k][l]) {
                                auto it = find(mezok[k][l-1].begin(),mezok[k][l-1].end(),j);
                                if (it != mezok[k][l-1].end()) {
                                    igaz = 1;
                                }
                            }
                        }
                        l--;
                    }
                    if (igaz == 0) {
                        l = k+1;
                        while (igaz == 0 && l > 2) {
                            if (szamok[l-1][veg[i][2]] != 1 && szamok[l][veg[i][2]] != 1) {
                                for (int j : mezok[l][veg[i][2]]) {
                                    auto it = find(mezok[l-1][veg[i][2]].begin(),mezok[l-1][veg[i][2]].end(),j);
                                    if (it != mezok[l-1][veg[i][2]].end()) {
                                        igaz = 1;
                                    }
                                }
                            }
                            l--;
                        }
                        if (igaz == 0) {
                            pont = k;
                        }
                    }
                    k--;
                }
                if (pont == 0) {
                    pont = k;
                }
                for (int j = n-1; j>=pont; j--) {
                    szamok[j][kezd[i][2]] *= kezd[i][0];
                    mezok[j][kezd[i][2]].push_back(kezd[i][0]);
                }
                for (int j = 1; j<=(kezd[i][2]-veg[i][2]-1); j++) {
                    szamok[pont][veg[i][2]+j] *= kezd[i][0];
                    mezok[pont][veg[i][2]+j].push_back(kezd[i][0]);
                }
                for (int j = 2; j<=pont; j++) {
                    szamok[j][veg[i][2]] *= kezd[i][0];
                    mezok[j][veg[i][2]].push_back(kezd[i][0]);
                }
            }
        }
    }

    cout << "<table>" << endl;
    for (int j = 1; j<=n; j++) {
        cout << "<tr>";
        for (int i = 1; i<=n; i++) {
            if (szamok[i][j] == 1 || szamok[i][j] == 0) {
                cout << "<td>&nbsp;</td>";
            } else {
                cout << "<td>" << szamok[i][j] << "</td>";
            }
        }
        cout << "</tr>" << endl;
    }
    cout << "</table>";
    return 0;
}