// MagicDark
#include <bits/stdc++.h>
#define debug cerr << "\33[32m[" << __LINE__ << "]\33[m "
#define SZ(x) ((int) x.size() - 1)
#define all(x) x.begin(), x.end()
#define ms(x, y) memset(x, y, sizeof x)
#define F(i, x, y) for (int i = (x); i <= (y); i++)
#define DF(i, x, y) for (int i = (x); i >= (y); i--)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
template <typename T> T& chkmax(T& x, T y) {return x = max(x, y);}
template <typename T> T& chkmin(T& x, T y) {return x = min(x, y);}
template <typename T> T& read(T &x) {
    x = 0; int f = 1; char c = getchar();
    for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
    for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
    return x *= f;
}
mt19937 mrand(chrono::steady_clock::now().time_since_epoch().count());
inline int rnd(int l, int r) {return mrand() % (r - l + 1) + l;}
std::vector<int> find_order(int N);
std::vector<std::pair<int, int>> query(const std::vector<int>& order);
const int T = 1e6, N = 110;
const ll INF = 1e18;
int a[N][N], n;
int to[N], pre[N];
ll ka[N], kb[N], minn[N];
bool vis[N];
void bfs(int x) {
	F(i, 1, n) minn[i] = INF;
	int y = 0; to[y] = x;
	while (to[y]) {
		int t = to[y];
		vis[y] = true;
		ll mn = INF; int num;
		F(i, 1, n)
			if (!vis[i]) {
				ll delta = ka[t] + kb[i] - a[t][i];
				if (delta < minn[i]) minn[i] = delta, pre[i] = y;
				if (minn[i] < mn) mn = minn[i], num = i;
			}
		F(i, 0, n)
			if (vis[i]) ka[to[i]] -= mn, kb[i] += mn;
			else minn[i] -= mn;
		y = num;
	}
	while (y) to[y] = to[pre[y]], y = pre[y];
}
void KM() {
    F(i, 1, n) to[i] = 0;
    ms(ka, 0), ms(kb, 0);
	F(i, 1, n) {
		F(j, 1, n) vis[j] = false;
		bfs(i);
	}
}
std::vector<int> find_order(int n) {
    ms(a, 0x9f);
    ::n = n;
    std::vector<int> answer(n);
    vector <int> p(n);
    F(i, 0, n - 1) p[i] = i;
    F(i, 1, n) {
        // a[0][i] = -T - 1;
        F(j, 1, n) {
            a[i][j] = -T;
        }
    }
    F(i, 1, 750) {
        shuffle(all(p), mrand);
        auto aw = query(p);
        F(j, 0, n - 1) {
            a[aw[j].first + 1][j + 1] = aw[j].second;
        }
    }
    KM();
    // F(i, 1, n) {
    //     F(j, 1, n)
    //         cout << a[i][j] << ' ';
    //     cout << '\n';
    // }
    // F(i, 1, n) debug << to[i] << endl;
    F(i, 1, n) vis[i] = false;
    F(i, 1, n) {
        bool flag = false;
        F(j, 1, n) {
            int mxpos = 0;
            F(k, 1, n) {
                if (vis[k]) continue;
                if (a[k][j] > a[mxpos][j]) mxpos = k;
            }
            // debug << "! " << j << " " << to[j] << " " << mxpos << endl;
            if (to[j] == mxpos) {
                flag = true;
                vis[to[j]] = true;
                answer[i - 1] = j - 1;
                break;
            }
        }
        assert(flag);
    }
    return answer;
}
// namespace work {
//     int n, a[N][N];
//     void work() {
//         read(n);
//         F(i, 0, n - 1)
//             F(j, 0, n - 1)
//                 read(a[i][j]);
//         auto b = find_order(n);
//         F(i, 0, n - 1) cout << b[i] << ' '; cout << '\n';
//     }
//     bool vis[N];
//     int p[N];
// }
// std::vector<std::pair<int, int>> query(const std::vector<int>& order) {
//     vector<std::pair<int, int>> ans(n);
//     F(i, 0, n - 1) work::vis[i] = false;
//     F(i, 0, n - 1) {
//         F(j, 0, n - 1) work::p[j] = j;
//         sort(work::p, work::p + n, [&] (int x, int y) {
//             return work::a[order[i]][x] > work::a[order[i]][y];
//         });
//         F(j, 0, n - 1) {
//             if (!work::vis[work::p[j]]) {
//                 work::vis[work::p[j]] = true;
//                 ans[order[i]] = make_pair(work::p[j], work::a[order[i]][work::p[j]]);
//                 break;
//             }
//         }
//     }
//     return ans;
// }
// signed main() {
//     work::work();
//     return 0;
// }