#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast","inline","-ffast-math",2,3)
mt19937 rnd(233);
const int N = 5e5 + 5;

struct PlusMinusOneRMQ {  // RMQ
  // Copyright (C) 2018 Skqliao. All rights served.
  const static int M = 9;

  int blocklen, block, Minv[N], F[N / M * 2 + 5][M << 1], T[N], f[1 << M][M][M],
      S[N];

  void init(int n) {  // 初始化
    blocklen = std::max(1, (int)(log(n * 1.0) / log(2.0)) / 2);
    block = n / blocklen + (n % blocklen > 0);
    int total = 1 << (blocklen - 1);
    for (int i = 0; i < total; i++) {
      for (int l = 0; l < blocklen; l++) {
        f[i][l][l] = l;
        int now = 0, minv = 0;
        for (int r = l + 1; r < blocklen; r++) {
          f[i][l][r] = f[i][l][r - 1];
          if ((1 << (r - 1)) & i) {
            now++;
          } else {
            now--;
            if (now < minv) {
              minv = now;
              f[i][l][r] = r;
            }
          }
        }
      }
    }
    T[1] = 0;
    for (int i = 2; i < N; i++) {
      T[i] = T[i - 1];
      if (!(i & (i - 1))) {
        T[i]++;
      }
    }
  }

  void initmin(int a[], int n) {
    for (int i = 0; i < n; i++) {
      if (i % blocklen == 0) {
        Minv[i / blocklen] = i;
        S[i / blocklen] = 0;
      } else {
        if (a[i] < a[Minv[i / blocklen]]) {
          Minv[i / blocklen] = i;
        }
        if (a[i] > a[i - 1]) {
          S[i / blocklen] |= 1 << (i % blocklen - 1);
        }
      }
    }
    for (int i = 0; i < block; i++) {
      F[i][0] = Minv[i];
    }
    for (int j = 1; (1 << j) <= block; j++) {
      for (int i = 0; i + (1 << j) - 1 < block; i++) {
        int b1 = F[i][j - 1], b2 = F[i + (1 << (j - 1))][j - 1];
        F[i][j] = a[b1] < a[b2] ? b1 : b2;
      }
    }
  }

  int querymin(int a[], int L, int R) {
    int idl = L / blocklen, idr = R / blocklen;
    if (idl == idr)
      return idl * blocklen + f[S[idl]][L % blocklen][R % blocklen];
    else {
      int b1 = idl * blocklen + f[S[idl]][L % blocklen][blocklen - 1];
      int b2 = idr * blocklen + f[S[idr]][0][R % blocklen];
      int buf = a[b1] < a[b2] ? b1 : b2;
      int c = T[idr - idl - 1];
      if (idr - idl - 1) {
        int b1 = F[idl + 1][c];
        int b2 = F[idr - 1 - (1 << c) + 1][c];
        int b = a[b1] < a[b2] ? b1 : b2;
        return a[buf] < a[b] ? buf : b;
      }
      return buf;
    }
  }
} rmq;

int n, m, s;

struct Edge {
  int v, nxt;
} e[N * 2];

int tot, head[N];

void init(int n) {
  tot = 0;
  fill(head, head + n + 1, 0);
}

void addedge(int u, int v) {  // 加边
  ++tot;
  e[tot] = (Edge){v, head[u]};
  head[u] = tot;

  ++tot;
  e[tot] = (Edge){u, head[v]};
  head[v] = tot;
}

int dfs_clock,dis[N*2], dfn[N * 2], dep[N * 2], st[N];

void dfs(int u, int fa, int d) {
  st[u] = dfs_clock;
  dis[u]=dis[fa]+1;
  dfn[dfs_clock] = u;
  dep[dfs_clock] = d;
  ++dfs_clock;

  int v;
  for (int i = head[u]; i; i = e[i].nxt) {
    v = e[i].v;
    if (v == fa) continue;
    dfs(v, u, d + 1);
    dfn[dfs_clock] = u;
    dep[dfs_clock] = d;
    ++dfs_clock;
  }
}

void build_lca() {  // like init
  rmq.init(dfs_clock);
  rmq.initmin(dep, dfs_clock);
}

int LCA(int u, int v) { 
  int l = st[u], r = st[v];
  if (l > r) swap(l, r);
  return dfn[rmq.querymin(dep, l, r)];
}
int dist(int u,int v){
	return dis[u]+dis[v]-2*dis[LCA(u,v)];
}
int t,res[N];
void solve() {
  scanf("%d %d %d", &n, &s,&t);

  init(n);
  int u, v;
  for (int i = 1; i <= n - 1; ++i) {
    scanf("%d %d", &u, &v);
    addedge(u, v);
    addedge(v,u);
  }
  vector<int>p(n+2),res(n+2);
  p[1]=s;
  p[n]=t;
  int tot=1;
  for(int i=1;i<=n;i++)if(i!=s&&i!=t)p[++tot]=i;
  res=p;
  dfs_clock = 0;
  dfs(s, 0, 0);
  build_lca();
  int nw=20,ans=0;
  for(int i=1;i<n;i++)ans^=dist(p[i],p[i+1]);
  if(n>3){
  	int cur=ans;
  	while(ans>1&&(nw--)){
  		int x=rnd()%(n-2)+2;
  		int y=rnd()%(n-3)+2;
  		y+=(y>=x);
  		cur^=dist(p[x],p[x-1]);
  		cur^=dist(p[x],p[x+1]);
  		cur^=dist(p[y],p[y-1]);
  		cur^=dist(p[y],p[y+1]);
  		swap(p[x],p[y]);
  		cur^=dist(p[x],p[x-1]);
  		cur^=dist(p[x],p[x+1]);
  		cur^=dist(p[y],p[y-1]);
  		cur^=dist(p[y],p[y+1]);
  		if(cur<ans)ans=cur,res=p;
	}
  }for(int i=1;i<=n;i++)cout<<res[i]<<' ';
  cout<<'\n';
  return ;
}
int main(){
	int t;
	cin>>t;
	while(t--)solve();
}