#include<bits/stdc++.h>
using namespace std;
#define pr pair<int, int>
#define pb push_back
#define mid (l + r) / 2
#define ls num << 1
#define rs num << 1 | 1

inline int read() {
    int x = 0, m = 1;
    char ch = getchar();

    while (!isdigit(ch)) {
        if (ch == '-') m = -1;
        ch = getchar();
    }

    while (isdigit(ch)) {
        x = x * 10 + ch - 48;
        ch = getchar();
    }

    return x * m;
}

inline void write(int x) {
    if (x < 0) {
        putchar('-');
        write(-x);
        return;
    }

    if (x >= 10) write(x / 10);
    putchar(x % 10 + '0');
}

mt19937_64 rnd(chrono :: system_clock().now().time_since_epoch().count());

int gen(int l, int r) {
    return rnd() % (r - l + 1) + l;
}

const int N = 5e4 + 5, inf = 1e8;

vector<int> v[N];
int id[N], res[N];
int n, s, t;

namespace BF {
    const int M = 10;
    int dis[M], d[M][M];
    void dfs(int ro, int fa, int len) {
        dis[ro] = len;
        for (auto u : v[ro]) {
            if (u == fa) continue;
            dfs(u, ro, len + 1);
        }
    }
    void solve() {
        for (int i = 1; i <= n; i++) {
            dfs(i, 0, 0);
            for (int j = 1; j <= n; j++) d[i][j] = dis[j];
        }
        int k = 0;
        for (int i = 1; i <= n; i++) {
            if (i == s || i == t) continue;
            id[++k] = i;
        }
        int Ans = inf;
        res[1] = s;
        res[n] = t;
        if (n == 2) {
            Ans = d[s][t];
        }
        else {
            do {
                int ans = d[s][id[1]] ^ d[id[k]][t];
                for (int i = 1; i < k; i++) {
                    ans ^= d[id[i]][id[i + 1]];
                }
                if (Ans > ans) {
                    Ans = ans;
                    for (int i = 2; i < n; i++) res[i] = id[i - 1];
                }
            } while (next_permutation(id + 1, id + k + 1));
        }
    }
}

namespace Random {
    int dfn[N], dep[N], F[N];
    pr f[18][N];
    int num;
    void dfs(int ro, int fa) {
        F[ro] = fa;
        dfn[ro] = ++num;
        dep[ro] = dep[fa] + 1;
        f[0][dfn[ro]] = {dep[ro], ro};
        for (auto u : v[ro]) {
            if (u == fa) continue;
            dfs(u, ro);
        }
    }
    pr query(int l, int r) {
        int t = __lg(r - l + 1);
        return min(f[t][l], f[t][r - (1 << t) + 1]);
    }
    int lca(int x, int y) {
        if (dfn[x] > dfn[y]) swap(x, y);
        if (x == y) return x;
        return F[query(dfn[x] + 1, dfn[y]).second];
    }
    int dis(int x, int y) {
        int z = lca(x, y);
        return dep[x] + dep[y] - 2 * dep[z];
    }
    void solve() {
        num = 0;
        dfs(1, 0);
        for (int i = 1; i <= 17; i++) {
            for (int j = 1; j + (1 << i) - 1 <= n; j++) {
                f[i][j] = min(f[i - 1][j], f[i - 1][j + (1 << (i - 1))]);
            }
        }
        int k = 1;
        id[1] = s;
        id[n] = t;
        for (int i = 1; i <= n; i++) {
            if (i == s || i == t) continue;
            id[++k] = i;
        }
        shuffle(id + 2, id + n, rnd);
        int T = 30 * n, Ans = 0;
        for (int i = 1; i < n; i++) {
            Ans ^= dis(id[i], id[i + 1]);
        }
        int P = 0;
        for (int i = 1; i <= n; i++) {
            if (v[i].size() == n - 1) P = 1;
        }
        while (T--) {
            int x, y;
            do {
                x = gen(2, n - 1), y = gen(2, n - 1);
            } while (x == y);
            Ans ^= dis(id[x - 1], id[x]) ^ dis(id[x], id[x + 1]) ^ dis(id[y - 1], id[y]) ^ dis(id[y], id[y + 1]);
            swap(id[x], id[y]);
            Ans ^= dis(id[x - 1], id[x]) ^ dis(id[x], id[x + 1]) ^ dis(id[y - 1], id[y]) ^ dis(id[y], id[y + 1]);
            if (Ans < 2 || P) break;
        }
        for (int i = 1; i <= n; i++) res[i] = id[i];
    }
}

signed main() {
    int T = read();

    while (T--) {
        n = read(), s = read(), t = read();

        for (int i = 1; i < n; i++) {
            int x = read(), y = read();
            v[x].pb(y);
            v[y].pb(x);
        }

        if (n <= 9) {
            BF :: solve();
        }
        else {
            Random :: solve();
        }

        for (int i = 1; i <= n; i++) {
            write(res[i]);
            putchar(" \n"[i == n]);
        }

        for (int i = 1; i <= n; i++) v[i].clear();
    }
}