#include "bits/stdc++.h"
#define rep(i, a, n) for (auto i = a; i <= (n); ++i)
#define revrep(i, a, n) for (auto i = n; i >= (a); --i)
#define all(a) a.begin(), a.end()
#define sz(a) (int)(a).size()
template<class T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, T b) { if (b < a) { a = b; return 1; } return 0; }
using namespace std;

template<class A, class B> string to_string(const pair<A, B> &p);
template<class A, class B, class C> string to_string(const tuple<A, B, C> &p);
template<class A, class B, class C, class D> string to_string(const tuple<A, B, C, D> &p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string) s); }
string to_string(char c) { return "'" + string(1, c) + "'"; }
string to_string(bool x) { return x ? "true" : "false"; }
template<class A, class T = typename A::value_type> string to_string(const A &v) {
	bool first = 1;
	string res = "{";
	for (const auto &x: v) {
		if (!first) res += ", ";
		first = 0;
		res += to_string(x);
	}
	res += "}";
	return res;
}
template<class A, class B> string to_string(const pair<A, B> &p) {
	return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template<class A, class B, class C> string to_string(const tuple<A, B, C> &p) {
	return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template<class A, class B, class C, class D> string to_string(const tuple<A, B, C, D> &p) {
	return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}

void debug_out() { cerr << endl; }
template<class H, class... T> void debug_out(const H& h, const T&... t) {
	cerr << " " << to_string(h);
	debug_out(t...);
}
#ifndef ONLINE_JUDGE
	#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
	#define debug(...) if (0) puts("No effect.")
#endif

using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;

/**
 * Author: Yuhao Yao
 * Date: 22-10-23
 * Description: Fast bipartite matching for \textbf{bipartite} graph $G = (L \cup R, E)$. Edges $E$ should be described as pairs such that pair $(x, y)$ means that there is an edge between the $x$-th vertex in $L$ and the $y$-th vertex in $R$. You can also get a vertex cover of a bipartite graph easily. 
 * Time: O(|E| \sqrt{|L| + |R|}).
 * Status: vertex cover correctness is tested on https://ac.nowcoder.com/acm/contest/885/F.
 */
struct Hopcroft {	
	int L, R; /// start-hash
	vi lm, rm; // record the matched vertex for each vertex on both sides.
	vi ldis, rdis; // put it here so you can get vertex cover easily.

	Hopcroft(int L, int R, const vector<pii> &es): L(L), R(R), lm(L, -1), rm(R, -1) {
		vector<vi> g(L);
		for (auto [x, y]: es) g[x].push_back(y);

		while (1) {
			ldis.assign(L, -1);
			rdis.assign(R, -1);
			bool ok = 0;
			vi que;
			rep(i, 0, L - 1) if (lm[i] == -1) {
				que.push_back(i);
				ldis[i] = 0;
			}
			rep(ind, 0, sz(que) - 1) {
				int i = que[ind];
				for (auto j: g[i]) if (rdis[j] == -1) {
					rdis[j] = ldis[i] + 1;
					if (rm[j] != -1) {
						ldis[rm[j]] = rdis[j] + 1;
						que.push_back(rm[j]);
					} else ok = 1;
				}
			}

			if (ok == 0) break;
			vi vis(R); // changing to static does not speed up.

			auto find = [&](auto &dfs, int i) -> int {
				for (auto j: g[i]) if (vis[j] == 0 && rdis[j] == ldis[i] + 1) {
					vis[j] = 1;
					if (rm[j] == -1 || dfs(dfs, rm[j])) {
						lm[i] = j;
						rm[j] = i;
						return 1;
					}
				}
				return 0;
			};
			rep(i, 0, L - 1) if (lm[i] == -1) find(find, i);
		}
	} /// end-hash
	
	vi getMatch() { return lm; } // returns lm.

	pair<vi, vi> vertex_cover() { /// start-hash
		vi lvc, rvc;
		rep(i, 0, L - 1) if (ldis[i] == -1) lvc.push_back(i);
		rep(j, 0, R - 1) if (rdis[j] != -1) rvc.push_back(j);
		return {lvc, rvc};
	} /// end-hash
};


int main() {
	ios::sync_with_stdio(0); cin.tie(0);
	
	int n; cin >> n;
	vector as(n - 1, vi(n));
	for (auto &vec : as) for (auto &x : vec) {
		cin >> x;
		x--;
	}
	auto Solve = [&](int s) -> void {
		vector<pii> es;
		vector<vector<int>> lsts(n - 1);
		rep(i, 0, n - 2) {
			auto &vec = as[i];
			int ind = find(all(vec), s) - vec.begin();
			rep(j, ind + 1, n - 1) {
				int v = vec[j];
				es.emplace_back(i, v);
			}
			lsts[i] = vector<int>(vec.begin() + ind + 1, vec.end());
		}
		auto lm = Hopcroft(n - 1, n, es).getMatch();
		if (count(all(lm), -1) > 0) {
			puts("No");
			return;
		} else {
			puts("Yes");
			vector<int> rm(n, -1);
			rep(i, 0, n - 2) rm[lm[i]] = i;
			vector<int> ords;
			vector<int> vis(n - 1);
			vector<int> used(n);
			vi sta;

			rep(i, 0, n - 2) if (vis[i] == 0) {
				auto dfs = [&](auto &dfs, int now) {
					vis[now] = 2;
					sta.push_back(now);
					while (1) {
						assert(sz(lsts[now]) > 0);
						int v = lsts[now].back();
						lsts[now].pop_back();
						if (used[v]) {
							continue;
						}
						int want = lm[now];
						if (want == v) {
							vis[now] = 1;
							used[v] = 1;
							sta.pop_back();
							ords.push_back(now);
							return;
						} else if (vis[rm[v]] == 2) {
							int u = rm[v];
							while (1) {
								int cur = sta.back();
								sta.pop_back();
								vis[cur] = 1;
								ords.push_back(cur);
								if (cur == u) break;
							}
							used[v] = 1;
							return;
						} else {
							assert(vis[rm[v]] == 0);
							dfs(dfs, rm[v]);
							if (vis[now] == 1) {
								used[v] = 1;
								return;
							}
						}
					}
				};
				dfs(dfs, i);
			}
			rep(i, 0, sz(ords) - 1) printf("%d%c", ords[i] + 1, " \n"[i == sz(ords) - 1]);
		}
	};
	rep(i, 0, n - 1) Solve(i);
	return 0;
}