#include <bits/stdc++.h>

#define fir first
#define sec second
#ifdef LOCAL
#define dbg(x) cerr << "In Line " << __LINE__ << " the " << #x << " = " << x << '\n';
#define dpi(x, y) cerr << "In Line " << __LINE__ << " the " << #x << " = " << x << " ; " << "the " << #y << " = " << y << '\n';
#define dbgf(fmt, args...) fprintf(stderr, fmt, ##args);
#else
#define dbg(x) void();
#define dpi(x, y) void();
#define dbgf(fmt, args...) void();
#endif

using namespace std;

using ll = long long;
using ull = unsigned long long;
using i128 = __int128_t;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using vi = vector<int>;
using vpii = vector<pii>;

bool Mbe;
constexpr int MOD = 998244353;
template<typename T> T add(T a, T b, T p = MOD) { return (a + b >= p) ? (a + b - p) : (a + b); }
template<typename T> T del(T a, T b, T p = MOD) { return (a - b < 0) ? (a - b + p) : (a - b); }
template<typename T> T mul(T a, T b, T p = MOD) { return 1ll * a * b % p; }
template<typename T> T cadd(T &a, T b, T p = MOD) { return a = add(a, b, p); }
template<typename T> T cdel(T &a, T b, T p = MOD) { return a = del(a, b, p); }
template<typename T> T cmul(T &a, T b, T p = MOD) { return a = mul(a, b, p); }
template<typename T> bool cmax(T &a, T b) { return a < b ? a = b, true : false; }
template<typename T> bool cmin(T &a, T b) { return a > b ? a = b, true : false; }

namespace FastIO {
	constexpr int LEN = 1 << 20;
	char in[LEN + 1], out[LEN + 1];
	char *pin = in, *pout = out, *ein = in, *eout = out + LEN;

	char gc() { return pin == ein && (ein = (pin = in) + fread(in, 1, LEN, stdin), ein == in) ? EOF : *pin ++; }
	void pc(char c) { pout == eout && (fwrite(out, 1, LEN, stdout), pout = out); (*pout ++) = c; return; }
	void Flush() { fwrite(out, 1, pout - out, stdout); pout = out; }

	template<typename T> T Read() {
		T x = 0; int f = 1; char ch = gc();
		while (ch < '0' || ch > '9') f = (ch == '-' ? (~f + 1) : f), ch = gc();
		while (ch >= '0' && ch <= '9') x = (x << 1) + (x << 3) + (ch ^ 48), ch = gc();
		return x * f;
	}
	template<typename T> void Write(T x, char c) {
		static char stk[40]; int tp = 0;
		if (x < 0) pc('-'), x = ~x + 1;
		do stk[tp++] = x % 10 + 48, x /= 10; while (x);
		while (tp --) pc(stk[tp]); pc(c); return;
	}
	void Read(char *s) {
		char ch = gc();
		while (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
			(ch >= '0' && ch <= '9'))) ch = gc();
		while ((ch != EOF) && ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
			(ch >= '0' && ch <= '9'))) *s = ch, s ++, ch = gc();
		*s = '\0'; return;
	}
	void Write(char *s) {
		while (*s != '\0') pc(*s), s ++; return;
	}
	void Puts(char *s) {
		Write(s), pc('\n'); return;
	}
}

#define getchar FastIO::gc
#define putchar FastIO::pc
#define Flush FastIO::Flush
#define Read FastIO::Read
#define Write FastIO::Write
#define Puts FastIO::Puts

constexpr int N = 5e5 + 5, LG = 19;
int n, op; ll k;
vector<int> G[N];

namespace Solve2 {
int rt, sz[N], mxp[N], dfn[N], ord[N], dfc, dep[N], bel[N];
pair<int, int> st[LG][N];
priority_queue<pair<int, int>> Q;
multiset<pair<int, int>> s;
vector<int> son, ans;
vector<pair<int, int>> dis[N], rng[N];
bool mrk[N];

void Get_Root(int u, int fa) {
	sz[u] = 1, mxp[u] = 0;
	for (auto v : G[u]) if (v ^ fa)
		Get_Root(v, u), sz[u] += sz[v], cmax(mxp[u], sz[v]);
	cmax(mxp[u], n - sz[u]), rt = mxp[u] < mxp[rt] ? u : rt;
	return;
}
void Dfs1(int u, int fa, int anc) {
	sz[ord[dfn[u] = ++ dfc] = u] = 1, bel[u] = anc;
	st[0][dfn[u]] = make_pair(dep[u] = dep[fa] + 1, fa);
	for (auto v : G[u]) if (v ^ fa) Dfs1(v, u, anc), sz[u] += sz[v];
	return;
}
pair<int, int> ST_Query(int l, int r) {
	int k = __lg(r - l + 1);
	return min(st[k][l], st[k][r - (1 << k) + 1]);
}
int Get_Lca(int u, int v) {
	if (u == v) return u;
	if ((u = dfn[u]) > (v = dfn[v])) swap(u, v);
	return ST_Query(u + 1, v).sec;
}

vector<int> Main(ll k, int o) {
	mxp[0] = n + 1, Get_Root(1, rt = 0);
	sz[rt] = dep[rt] = 0, dfn[rt] = dfc = 1, bel[rt] = rt, ord[1] = rt;
	for (auto u : G[rt]) son.emplace_back(u), Dfs1(u, rt, u), sz[rt] += sz[u];
	for (int i = 1; i < LG; i ++)
		for (int j = 1; j + (1 << i) - 1 <= n; j ++)
			st[i][j] = min(st[i - 1][j], st[i - 1][j + (1 << i - 1)]);
	{
		ll L = 2 * (n - 1), R = 0;
		for (int u = 1; u <= n; u ++) R += dep[u]; R <<= 1;
//		cout << L << ' ' << R << endl;
		if ((k & 1) || k < L || k > R) return vector<int>(1, -1);
		k = (R - k) >> 1;
	};
	for (int i = 1; i <= n; i ++) {
		if (bel[ord[i]] != bel[ord[i + 1]]) continue;
		dis[bel[ord[i]]].emplace_back(dep[Get_Lca(ord[i], ord[i + 1])], ord[i]);
	}
	for (auto u : son) if (dis[u].size())
		sort(dis[u].begin(), dis[u].end()), Q.emplace(make_pair(dis[u].size(), u));
//	for (auto u : son) {
//		cout << u << ": ";
//		for (auto dist : dis[u]) cout << dist.fir << ' ';
//		cout << endl;
//	}
	if (k) {
		while (Q.size()) {
			int u = Q.top().sec; Q.pop();
			int dist, v; tie(dist, v) = dis[u].back();
			if (dist < k) k -= dist, dis[u].pop_back(), mrk[v] = true;
			else {
				while (dis[u].back().fir > k) dis[u].pop_back();
				mrk[dis[u].back().sec] = true, k = 0; break;
			}
			if (dis[u].size()) Q.emplace(dis[u].size(), u);
		}
	}
	for (int l = 1, r; l <= n; l = r + 1) {
		r = l;
		while (bel[ord[r + 1]] == bel[ord[l]] && mrk[ord[r]]) r ++;
		rng[bel[ord[l]]].emplace_back(l, r);
	}
	{
		vector<pair<int, int>> ret;
//		for (int i = 1; i <= n; i ++) cout << ord[i] << ' '; cout << endl;
//		for (auto u : son) for (auto _ : rng[u])
//			cout << u << ": " << '[' << _.fir << ',' << _.sec << ']' << endl;
//		cout << endl;
		for (auto u : son) s.insert({rng[u].size(), u});
		if (!o) {
			int u = (*-- s.end()).sec; s.erase(-- s.end());
			reverse(rng[u].begin(), rng[u].end());
			int l, r; tie(l, r) = rng[u].back(); rng[u].pop_back();
			reverse(rng[u].begin(), rng[u].end()); ret.emplace_back(l, r);
			if (rng[u].size()) s.insert({rng[u].size(), u});
		}
		ret.emplace_back(dfn[rt], dfn[rt]);
		while (s.size() > 1) {
			int u = (*-- s.end()).sec; s.erase(-- s.end());
			int v = (*-- s.end()).sec; s.erase(-- s.end());
			int l, r; tie(l, r) = rng[u].back(); rng[u].pop_back(); ret.emplace_back(l, r);
			tie(l, r) = rng[v].back(); rng[v].pop_back(); ret.emplace_back(l, r);
			if (rng[u].size()) s.insert({rng[u].size(), u});
			if (rng[v].size()) s.insert({rng[v].size(), v});
		}
		if (s.size()) {
			int u = (*s.begin()).sec, l, r;
//			cout << u << endl;
			tie(l, r) = rng[u].back(); ret.emplace_back(l, r);
		}
//		for (auto _ : ret) cout << _.fir << ' ' << _.sec << endl;
		if (o) {
			for (auto _ : ret)
				for (int i = _.sec; i >= _.fir; i --)
					ans.emplace_back(ord[i]);
		} else {
			for (int i = 0; i + 1 < ret.size(); i ++) {
				int l, r; tie(l, r) = ret[i];
				for (int j = l; j <= r; j ++) ans.emplace_back(ord[j]);
			}
			int l, r; tie(l, r) = ret.back();
			for (int i = r; i >= l; i --) ans.emplace_back(ord[i]);
		}
	};
	return ans;
}
void Clear() {
	rt = dfc = 0; while (Q.size()) Q.pop();
	son.clear(), s.clear(), ans.clear();
	for (int i = 1; i <= n; i ++) {
		sz[i] = mxp[i] = dfn[i] = ord[i] = dep[i] = 0, G[i].clear();
		bel[i] = 0, mrk[i] = false, dis[i].clear(), rng[i].clear();
		for (int j = 0; j < LG; j ++) st[j][i] = {0, 0};
	}
	return;
}
}

namespace Solve1 {
int dep[N], prio[N];
vector<int> dia, ans;

int Dfs(int u, int fa) {
	dep[u] = dep[fa] + 1; int mx = u, x;
	for (auto v : G[u]) if (v ^ fa)
		x = Dfs(v, u), mx = dep[mx] < dep[x] ? x : mx;
	return mx;
}
int Get_Diameter() {
	int u = Dfs(1, 0), v = Dfs(u, 0);
	function<bool(int, int, int)> Find_Diameter
		= [&](int u, int fa, int goal) {
			dia.emplace_back(u);
			if (u == goal) return true;
			for (auto v : G[u]) {
				if (v == fa) continue;
				if (Find_Diameter(v, u, goal)) return true;
			}
			dia.pop_back(); return false;
		}; Find_Diameter(u, 0, v);
	return dep[v] - 1;
}
void Get_Ans(int u, int fa) {
	ans.emplace_back(u);
	sort(G[u].begin(), G[u].end(),
		[&](int x, int y) { return prio[x] < prio[y]; });
	for (auto v : G[u]) if (v ^ fa) Get_Ans(v, u);
	return;
}

vector<int> Main() {
	{
		ll L = 2 * (n - 1) - Get_Diameter();
//		dbg(L)
		if (k < L) return vector<int>(1, -1);
	};
//	cout << k + 2 - (k & 1) << ' ' << (k & 1) << endl;
	if (k >= 2 * (n - 1)) return Solve2::Main(k + 2 - (k & 1), k & 1);
	k = 2 * (n - 1) - k;
	int u = dia[k];
//	for (auto i : dia) cout << i << ' '; cout << endl;
	for (int i = 0; i < k; i ++) prio[dia[i]] = 1;
	Get_Ans(u, 0); return ans;
}
void Clear() {
	Solve2::Clear(), ans.clear(), dia.clear();
	for (int i = 1; i <= n; i ++) dep[i] = prio[i] = 0;
	return;
}
}

void slv() {
	n = Read<int>(), k = Read<ll>(), op = Read<int>();
	for (int i = 1; i < n; i ++) {
		int u = Read<int>(), v = Read<int>();
		G[u].emplace_back(v), G[v].emplace_back(u);
	}
	if (n == 1) { k ? Puts("-1") : Puts("1"); return; }
	if (n == 2) { k == op ? Puts("1 2") : Puts("-1"); return; }
	auto ans = (op == 1 ? Solve1::Main() : Solve2::Main(k, 1));
	for (auto u : ans) Write(u, ' '); Puts(""); return;
}
void clr() {
	op == 1 ? Solve1::Clear() : Solve2::Clear();
	return;
}

bool Med;
int main() {
#ifdef LOCAL
	freopen("!in.in", "r", stdin);
	freopen("!out.out", "w", stdout);
	fprintf(stderr, "%.3lf Mb\n", fabs((&Mbe - &Med) / 1048576.0));
#endif
//	int T = 1;
	int T = Read<int>();
	while (T --) slv(), clr();
	Flush();
#ifdef LOCAL
	fprintf(stderr, "%d ms\n", (int)clock());
#endif
	return 0;
}