// Writer: Hridaya   Time:2024.9.12   By:NFLS
/********************************************/
// #pragma GCC optimize(3,"Ofast","inline")
// #include <iostream>       // cin, cout, cerr, getline
#include <bits/stdc++.h>
// #include <utility>        // pair, make_pair, swap, move
// #include <ctime>          // clock, time, difftime, tm, localtime
// #include <unordered_map>  // unordered_map, unordered_multimap
// #include <unordered_set>  // unordered_set, unordered_multiset
// #include <algorithm>      // sort, find, reverse, binary_search, max_element, min_element
// #include <ios>            // ios_base, ios_base::failure, ios::sync_with_stdio
// #include <vector>         // vector, vector::push_back, vector::size, vector::at
// #include <bitset>         // bitset, bitset::set, bitset::reset
// #include <cstring>        // memset, memcpy, strcmp, strlen
// #include <map>            // map, multimap, map::insert
// #include <set>            // set, multiset, set::insert
// #include <queue>          // queue, priority_queue
// #include <stack>          // stack, stack::push, stack::pop
// #include <deque>          // deque, deque::push_back, deque::pop_front
// #include <list>           // list, list::push_back, list::remove
// #include <cmath>          // sqrt, pow, sin, cos, log
// #include <cstddef>        // size_t, ptrdiff_t
// #include <cstdint>        // int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t, uint32_t, uint64_t
// #include <climits>        // INT_MAX, CHAR_MIN
// #include <iterator>       // iterator, advance, next, prev
// #include <chrono>         // chrono::steady_clock, chrono::system_clock, chrono::duration
// #include <fstream>        // ifstream, ofstream, fstream
using namespace std;
typedef long long ll;
#define foru(i,x,y) for (register int i(x); i <= y; ++i)
#define ford(i,x,y) for (register int i(x); i >= y; --i)
#define Linf 9223372036854775807
#define Iinf 2147483647
#define Sinf 32767
namespace IO {
	char ch ('~');
	template<typename Type>
	inline Type read() {
		Type x(0);
		bool m(0);
		while (!isdigit(ch)) {
			m |= (ch == '-');
			ch = getchar(); }
		while (isdigit(ch)) {
			x = (x << 1) + (x << 3) + (ch ^ 48);
			ch = getchar(); }
		return m ? (~x + 1) : x; }
	template<typename Type>
	inline void write(Type x) {
		if (x < 0) putchar('-'), x = (~x + 1);
		if (x > 9) write(x / 10);
		putchar(x % 10 ^ 48); }
	template<typename Type>
	inline void writes(Type x, char c) {
		write(x), putchar(c); }
#define read() read<int>()
#define Jianghu_bloke \
	freopen("QwQ.in", "r", stdin); freopen("QwQ.out", "w", stdout);
} using namespace IO;
const int N (5e4 + 10);
struct Graph {
	struct edge {
		int from, to, next;
		int w; } e[N << 1];
	int cnt, n, head[N];
	inline void ins(int u, int v, int w = 0) {
		e[++cnt] = {u, v, head[u], w }, n = max({n, u, v }), head[u] = cnt; }
	inline void twi(int u, int v, int w = 0) {
		ins(u, v, w), ins(v, u, w); }
	inline void clear() {
		foru(i, 1, cnt) head[e[i].from] = 0;
		cnt = 0; }
#define Tra(u, v, W, G, i) \
	for (int i = G.head[u], v = G.e[i].to, W = G.e[i].w; i; i = G.e[i].next, v = G.e[i].to, W = G.e[i].w)
} G;
int n, s, t;
int pos[N];
struct LCA {
	int dfn[N], dfncnt = 0, pre[N], siz[N], f[N][25], dep[N];
	void dfs(int u, int fa) {
		dfn[u] = ++dfncnt;
		dep[u] = dep[fa] + 1;
		pre[dfncnt] = u;
		f[u][0] = fa;
		foru(i, 1, 20) f[u][i] = f[f[u][i - 1]][i - 1];
		Tra(u, v, W, G, i) {
			if (v == fa) continue;
			dfs(v, u);
			pre[++dfncnt] = u; } }
	int logn[N << 1];
	int st[N << 1][25];
	inline void init() {
		logn[0] = -1;
		foru(i, 1, dfncnt) {
			logn[i] = logn[i / 2] + 1;
			st[i][0] = pre[i]; }
		foru(j, 1, log2(dfncnt)) foru(i, 1, dfncnt - (1 << j) + 1) {
			int u (st[i][j - 1]), v (st[i + (1 << (j - 1))][j - 1]);
			st[i][j] = ((dep[u] > dep[v]) ? v : u); } }
	inline int lca(int l, int r) {
		int ql = dfn[l], qr = dfn[r];
		if (qr < ql) swap(qr, ql);
		int k = logn[qr - ql + 1];
		if (dep[st[ql][k]] < dep[st[qr - (1 << k) + 1][k]]) return st[ql][k];
		else return st[qr - (1 << k) + 1][k]; }
	inline int dist(int u, int v) {
		int w = lca(u, v);
		return dep[u] + dep[v] - 2 * dep[w]; } } f;
inline bool check() {
	foru(u, 1, n) {
		int ans (0);
		Tra(u, v, w, G, i) ++ans;
		if (ans == n - 1) return 1; }
	return 0; }
mt19937_64 rnd(chrono :: system_clock().now().time_since_epoch().count());
inline int rand(int l, int r) {
	return rnd() % (r - l + 1) + l; }
inline int get(int x) {
	return f.dist(pos[x], pos[x - 1]) ^ f.dist(pos[x], pos[x + 1]); }
bool vis[N];
int ans (Iinf), opt[N];
inline void answer() {
	int res (0);
	foru(i, 1, n - 1) res ^= f.dist(pos[i], pos[i + 1]);
	if (res < ans) {
		ans = res;
		foru(i, 1, n) opt[i] = pos[i]; } }
inline void dfs(int u) {
	if (u >= n) return answer();
	foru(i, 1, n) {
		if (vis[i]) continue;
		pos[u] = i, vis[i] = 1;
		dfs(u + 1), vis[i] = 0; } }
namespace Hridaya {
	inline void solve() {
		n = read(), s = read(), t = read();
		G.clear(), f.dfncnt = 0;
		foru(i, 2, n) G.twi(read(), read());
		pos[1] = s, pos[n] = t;
		int l (1);
		foru(i, 2, n - 1) {
			while (l == s || l == t) ++l;
			pos[i] = l, ++l; }
		f.dfs(1, 0), f.init();
		int res (0);
		foru(i, 1, n - 1) res ^= f.dist(pos[i], pos[i + 1]);
		if (check()) {
			foru(i, 1, n) writes(pos[i], ' ');
			return putchar('\n'), void(); }
		if (n < 9) {
			foru(i, 1, n) vis[i] = 0;
			vis[s] = vis[t] = 1;
			ans = 1e9, dfs(2);
			foru(i, 1, n) writes(opt[i], ' ');
			return putchar('\n'), void(); }
		while (res > 1) {
			int x (rand(2, n - 1)), y (rand(2, n - 1));
			while (x == y) y = rand(2, n - 1);
			res ^= get(x) ^ get(y);
			swap(pos[x], pos[y]);
			res ^= get(x) ^ get(y); }
		foru(i, 1, n) write(pos[i]), putchar(" \n" [i == n]);
		return ; }
	signed main() {
		int T (read<int>());
		while (T--) solve();
		return 0; }
//	Main Space
}
signed main() {
//	Jianghu_bloke
	Hridaya :: main();
//	Coding Completed!
	return 0; }