#include <bits/stdc++.h>
using namespace std;

// loops
#define FOR_3(i, a, b) for (int i = (a), bb##i = (b); i <= bb##i; ++i)
#define FORR_3(i, a, b) for (int i = (b), aa##i = (a); i >= aa##i; --i)

#define FOR_2(i, n) FOR_3(i, 0, (n)-1)
#define FORR_2(i, n) FORR_3(i, 0, (n)-1)

#define FOR_1(n) FOR_2(_i##__LINE__, n)
#define FOR_0() for (;;)

#define OVERLOAD(_0, _1, _2, _3, NAME, ...) NAME
#define FOR(...)                                                         \
	OVERLOAD(_0 __VA_OPT__(, )##__VA_ARGS__, FOR_3, FOR_2, FOR_1, FOR_0) \
	(__VA_ARGS__)

#define FORR(...)                                                           \
	OVERLOAD(_0 __VA_OPT__(, )##__VA_ARGS__, FORR_3, FORR_2, FORR_1, FOR_0) \
	(__VA_ARGS__)

#ifdef LOCAL
#include <sys/prctl.h>
#include <sys/wait.h>
#include <unistd.h>

void print_trace()
{
	char pid_buf[30];
	sprintf(pid_buf, "%d", getpid());
	char name_buf[512];
	name_buf[readlink("/proc/self/exe", name_buf, 511)] = 0;
	prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0);
	int child_pid = fork();
	if (!child_pid)
	{
		dup2(2, 1); // redirect output to stderr - edit: unnecessary?
		execl("/usr/bin/gdb", "gdb", "--batch", "-n", "-ex", "thread", "-ex", "bt",
			  name_buf, pid_buf, NULL);
		abort(); /* If gdb failed to start */
	}
	else
	{
		waitpid(child_pid, NULL, 0);
	}
}

extern const char *const sys_siglist[];

void handler(int sig)
{
	cerr << "SIGNAL " << sig << " (" << sys_siglist[sig] << ")" << endl;
	print_trace();
	exit(1);
}

#define INDENT_SIZE 2
string indent;

void _E() { cerr << endl; }
template <class ARG, class... ARGS>
void _E(ARG &&arg, ARGS &&...args)
{
	cerr << std::forward<ARG>(arg) << " ";
	_E(std::forward<ARGS>(args)...);
}

#define ERR(...)                                   \
	{                                              \
		cerr << indent << "[" << __LINE__ << "] "; \
		_E(__VA_ARGS__);                           \
	}

#define _V5(x) #x, "==", (x)
#define _V4(x, ...) #x, "==", (x)__VA_OPT__(, "|", _V5(__VA_ARGS__))
#define _V3(x, ...) #x, "==", (x)__VA_OPT__(, "|", _V4(__VA_ARGS__))
#define _V2(x, ...) #x, "==", (x)__VA_OPT__(, "|", _V3(__VA_ARGS__))
#define _V1(x, ...) #x, "==", (x)__VA_OPT__(, "|", _V2(__VA_ARGS__))
#define ERRV(...) ERR(_V1(__VA_ARGS__))
#define INDENT auto _indenter = Indenter();

struct Indenter
{
	Indenter()
	{
		FOR(INDENT_SIZE)
		indent.push_back(' ');
	}
	~Indenter()
	{
		FOR(INDENT_SIZE)
		indent.pop_back();
	}
};

#define FAIL(str)                                                                 \
	{                                                                             \
		cerr << "ASSERT FAILED   " << str << "   " << __FILE__ << ':' << __LINE__ \
			 << endl;                                                             \
		abort();                                                                  \
	}

#define SLEEP this_thread::sleep_for(100ms);

#else
#define INDENT
#define SLEEP
#define FAIL(x) \
	{           \
	}
#define ERR(...) \
	{            \
	}
#define ERRV(...) \
	{             \
	}
#endif

// asserts
#define CHECK(cond) \
	if (!(cond))    \
	FAIL(#cond)

#define CHECK_OP(op, a, b, res) \
	if (!(res))                 \
	FAIL(#a " " op " " #b "   (" + to_string(a) + " vs " + to_string(b) + ")")

#define CHECK_EQ(a, b) CHECK_OP("==", a, b, (a) == (b))
#define CHECK_NE(a, b) CHECK_OP("!=", a, b, (a) != (b))
#define CHECK_LE(a, b) CHECK_OP("<=", a, b, (a) <= (b))
#define CHECK_GE(a, b) CHECK_OP(">=", a, b, (a) >= (b))
#define CHECK_LT(a, b) CHECK_OP("<", a, b, (a) < (b))
#define CHECK_GT(a, b) CHECK_OP(">", a, b, (a) > (b))

#define CHECK_RANGE(x, a, b) \
	if (!(a <= x && x < b))  \
	FAIL(#x " in [" #a "," #b ")")

// min / max
template <class T>
auto min(T &&t) { return move(t); };
template <class T, class... TS>
auto min(T &&t, TS &&...ts)
{
	auto rest = min(forward<TS>(ts)...);
	return t < rest ? t : rest;
}

template <class T>
auto max(T &&t) { return move(t); };
template <class T, class... TS>
auto max(T &&t, TS &&...ts)
{
	auto rest = max(forward<TS>(ts)...);
	return t > rest ? t : rest;
}

#define REMIN(a, b) ((a) = min(a, b));
#define REMAX(a, b) ((a) = max(a, b));

// containers / arrays
#define ALL(c) (c).begin(), (c).end()
#define SZ(x) int((x).size())
#define ZERO(x) memset(x, 0, sizeof(x));

// other
#define UNUSED(...) (void)(__VA_ARGS__);

// magic 1-indexed vector
template <class T>
struct vec : vector<T>
{
	decltype(vector<T>()[0]) operator[](int i)
	{
		CHECK_GE(i, 1);
		while (i > size())
			vector<T>::emplace_back();
		return vector<T>::operator[](i - 1);
	}
	int size() { return vector<T>::size(); }
};

// magic 1-indexed deque
template <class T>
struct deq : deque<T>
{
	auto &operator[](int i)
	{
		CHECK_GE(i, 1);
		while (i > size())
			deque<T>::emplace_back();
		return deque<T>::operator[](i - 1);
	}
	int size() { return deque<T>::size(); }
};

// magic 1-indexed array
template <class T, int sz>
struct arr : array<T, sz>
{
	auto &operator[](int i) { return array<T, sz>::operator[](i - 1); }
};

// types
#define umap unordered_map
#define deq deque
using ll = long long;
using ld = long double;
using pii = pair<int, int>;

using vi = vec<int>;
using vll = vec<ll>;
using vpii = vec<pii>;
using vb = vec<bool>;

using di = deq<int>;
using dll = deq<ll>;
using dpii = deq<pii>;

// abbrevs
#define push push_back
#define pop pop_back
#define CMP bool operator<(const auto &o) const

// array operations
#define SORT(v) sort(ALL(v));
#define UNIQUE(c)                         \
	{                                     \
		SORT(c);                          \
		c.erase(unique(ALL(c)), c.end()); \
	}

auto PERM(int n)
{
	di v(n);
	FOR(i, n)
	v[i] = i;
	return v;
}

template <class V>
auto esort(const V &v)
{
	auto perm = PERM(SZ(v));
	sort(ALL(perm), [&](int a, int b)
		 { return v[a] < v[b]; });
	return perm;
}

template <class V>
auto eremap(V &&vv)
{
	auto v = move(vv);
	SORT(v);
	umap<typename V::value_type, int> r;
	int nxt = 0;
	for (auto &e : v)
		if (r.emplace(e, nxt).second)
			++nxt;
	return r;
}

template <class X, class FR, class TO>
bool range(const X &x, const FR &fr, const TO &to)
{
	return !(x < fr) && x < to;
}

template <class A, class B>
auto divup(A a, B b) { return (a + b - 1) / b; }

// bit operations
int msb(int x)
{
	CHECK_GT(x, 0)
	return 31 - __builtin_clz(x);
}

int msb(ll x)
{
	CHECK_GT(x, 0)
	return 63 - __builtin_clzll(x);
}

int lsb(int x)
{
	CHECK_GT(x, 0)
	return __builtin_ctz(x);
}

int lsb(ll x)
{
	CHECK_GT(x, 0)
	return __builtin_ctzll(x);
}

int popcount(int x) { return __builtin_popcount(x); }
int popcount(ll x) { return __builtin_popcountll(x); }

#define FORB(b, mask) \
	for (auto m = mask, bit = lsb(m); m; m ^= (1 << b), bit = lsb(m))

#define FORS(s, mask) \
	for (auto s = mask; s; s = (s - 1) & mask) // iterate subsets

template <class T>
int log2up(T x)
{
	return x <= 1 ? 0 : msb(x - 1) + 1;
}

default_random_engine RNG(123);
#define SHUFFLE(c) shuffle(ALL(c), RNG);

// stdin
template <class T>
T read()
{
	T x;
	cin >> x;
	return x;
}
#define II read<int>()
#define ILL read<ll>()

void _I()
{
}
template <class ARG, class... ARGS>
void _I(ARG &&arg, ARGS &&...args)
{
	cin >> arg;
	_I(forward<ARGS>(args)...);
}
#define I(...) _I(__VA_ARGS__);

// stdout
template <class T>
void _print(T x)
{
	cout << x;
	bool space = true;
	if constexpr (is_same_v<T, char>)
	{
		if (x == '\n')
			space = false;
	}
	if (space)
		cout << " ";
}
template <class T>
void _print(deq<T> &d)
{
	for (auto &e : d)
		cout << e << " ";
}
void _O() {}
template <class ARG, class... ARGS>
void _O(ARG &&arg, ARGS &&...args)
{
	_print(arg);
	_O(forward<ARGS>(args)...);
}
#define O(...) _O(__VA_ARGS__ __VA_OPT__(, ) '\n');
#define OO(...) _O(__VA_ARGS__);

// stderr
template <class T>
auto &operator<<(ostream &os, deq<T> &v)
{
	os << "{";
	bool first = true;
	for (auto &e : v)
	{
		if (first)
			first = false;
		else
			os << " ";
		os << e;
	}
	return os << "}";
}

template <class A, class B>
auto &operator<<(ostream &os, pair<A, B> &p)
{
	return os << "{" << p.first << " " << p.second << "}";
}

////////////////////////////////////////////////////////////////////////////////
//  _          _     _   _                                                    //
// | |        | |   | | | |                                                   //
// | |     ___| |_  | |_| |__   ___    __ _  __ _ _ __ ___   ___              //
// | |    / _ \ __| | __| '_ \ / _ \  / _` |/ _` | '_ ` _ \ / _ \             //
// | |___|  __/ |_  | |_| | | |  __/ | (_| | (_| | | | | | |  __/             //
// \_____/\___|\__|  \__|_| |_|\___|  \__, |\__,_|_| |_| |_|\___|             //
//                                     __/ |                                  //
//                                    |___/                                   //
//  ██████▓▓▒▒░░░░░░▒▒▒▒▒▒▒▒░░░░▒▒▒▒░░▒▒▒▒░░░░░░░░▒▒▒▒▒▒▒▒░░░░░░░░░░░░██████  //
//  ██████░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒░░░░░░░░░░▒▒░░▒▒░░░░░░░░░░░░  ░░▒▒████  //
//  ████░░░░░░░░░░▒▒░░░░░░░░░░░░░░░░▒▒▒▒▒▒░░░░▒▒░░░░▒▒    ░░░░░░░░░░  ░░████  //
//  ████░░░░░░▒▒▓▓████▓▓▓▓▓▓░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒░░░░▒▒▓▓▓▓████▓▓▒▒░░  ▓▓██  //
//  ████░░▒▒▓▓██████▓▓▓▓▓▓▓▓██▒▒░░░░░░░░▓▓▓▓░░░░░░░░██▓▓▓▓▒▒▒▒████▓▓▒▒░░████  //
//  ████▓▓▒▒▒▒▓▓████▓▓▓▓██▓▓████░░░░░░░░▒▒▒▒░░░░░░████▓▓▓▓▓▓░░▓▓██▓▓░░░░████  //
//  ████▒▒▒▒▓▓▓▓████▓▓▓▓▓▓▓▓████▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒████▓▓▓▓▓▓▒▒████▓▓░░░░▓▓██  //
//  ████▒▒▒▒▒▒▓▓▓▓██████▓▓██████░░▒▒▒▒▒▒▒▒▒▒░░░░░░████▓▓▓▓▓▓████▓▓▒▒░░░░▓▓██  //
//  ████▓▓▓▓▓▓▒▒▓▓▓▓▓▓██████▓▓▒▒▒▒▒▒▒▒░░▒▒░░░░░░░░▒▒████████▓▓▓▓▒▒░░▒▒▒▒░░██  //
//  ██▓▓░░░░▒▒▓▓██▒▒▒▒▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░░░░░░░░▒▒▓▓▓▓▒▒▒▒▒▒▓▓▓▓░░▒▒██  //
//  ██░░▓▓▓▓▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░░░░░░    ░░░░░░░░▒▒░░▒▒▓▓▒▒░░░░░░▓▓  //
//  ██░░░░▒▒▓▓▓▓▒▒▓▓▓▓▒▒▒▒▒▒░░▒▒░░░░░░░░░░░░      ░░░░░░░░▒▒▒▒▓▓▒▒▒▒▓▓▓▓▒▒▒▒  //
//  ▓▓▒▒▒▒▒▒░░▓▓▓▓▒▒▓▓▒▒▒▒▒▒░░░░░░░░░░░░░░░░      ░░░░░░░░▒▒▓▓▓▓▒▒▓▓░░        //
//  ▓▓▒▒▒▒▓▓▒▒▒▒▓▓▒▒▓▓▓▓▒▒▒▒░░░░░░░░░░░░░░░░      ░░░░░░▒▒▒▒██▒▒▓▓▓▓░░▒▒▒▒▒▒  //
//  ▓▓▒▒░░░░▓▓░░▓▓▓▓▒▒▓▓▒▒▒▒░░░░░░░░░░░░░░░░        ░░▒▒▒▒▓▓▓▓▒▒▓▓▒▒▒▒░░  ░░  //
//  ██▒▒▒▒░░▒▒▓▓▒▒▓▓▒▒▓▓▒▒▒▒░░░░░░░░░░░░░░░░        ░░░░▒▒▓▓▓▓▒▒▓▓░░▓▓  ▒▒    //
//  ██▒▒▒▒▒▒▒▒▓▓░░▓▓▒▒▓▓▒▒▒▒▒▒░░░░░░░░░░░░░░      ░░░░▒▒▒▒▒▒▓▓░░▓▓░░▓▓░░░░▓▓  //
//  ██▓▓▓▓▓▓▓▓▒▒▒▒▓▓▒▒▓▓▒▒▒▒▒▒▒▒░░░░░░░░░░░░    ░░▒▒▒▒▒▒▒▒▒▒▓▓▒▒▓▓░░▒▒▒▒░░██  //
//  ████▓▓▒▒▒▒▓▓▓▓▒▒▓▓▒▒▒▒▓▓▒▒▒▒░░░░░░░░░░░░      ░░▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▒▒████  //
//  ██████████▓▓▒▒▒▒▒▒▒▒██▓▓▓▓▒▒░░░░░░░░░░░░      ░░░░░░▒▒▒▒░░▒▒▒▒▓▓████████  //
//  ██████████████░░░░░░▒▒██▓▓▓▓██▓▓░░░░░░░░    ▓▓▒▒▒▒▓▓▓▓▒▒░░  ▒▒██████████  //
//  ████████████████░░░░░░▓▓▓▓▓▓▓▓▓▓▓▓▒▒░░░░▒▒▓▓▓▓▓▓▓▓▒▒▒▒      ████████████  //
//  ████████████████░░░░░░▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒░░      ░░████████████  //
//  ████████████████░░░░░░▒▒░░▒▒▒▒░░▒▒▒▒▒▒▒▒▒▒░░░░░░▒▒        ██████████████  //
//  ████████████████▒▒░░░░▒▒░░░░░░░░░░░░▒▒▒▒░░░░░░░░▒▒░░    ▒▒██████████████  //
//  ██████████████████░░░░▒▒░░░░░░░░░░▒▒▒▒▒▒▒▒░░░░  ▓▓░░    ████████████████  //
//  ██████████████████░░░░▒▒░░░░░░░░░░▒▒▒▒▒▒▒▒░░░░  ▓▓░░  ▓▓████████████████  //
//                                                                            //
//           ;;;;;              ██████╗ ███████╗ ██████╗ ██╗███╗   ██╗        //
//           ;;;;;              ██╔══██╗██╔════╝██╔════╝ ██║████╗  ██║        //
//           ;;;;;              ██████╔╝█████╗  ██║  ███╗██║██╔██╗ ██║        //
//         ..;;;;;..            ██╔══██╗██╔══╝  ██║   ██║██║██║╚██╗██║        //
//          ':::::'             ██████╔╝███████╗╚██████╔╝██║██║ ╚████║        //
//            ':`               ╚═════╝ ╚══════╝ ╚═════╝ ╚═╝╚═╝  ╚═══╝        //
//                                                                            //

const bool MULTIPLE_TEST_CASES = true;

// using F = Modulo<1e9 + 7>;
// using F = Modulo<998'244'353>;

struct VE
{
	int dest;
	int ith;
};

struct V
{
	vector<VE> tos;
	bool select = false;
};

struct G
{
	vector<V> vs;
};

struct In
{
	int n;
	int m;
	int k;
};

struct Test_Case
{
	In in;
	G g;

	struct Op
	{
		int v;
		vector<int> tos;
	};

	set<pair<int, int>> all_edges;

	void add_edge(int a, int b)
	{
		int ith_a = SZ(g.vs[a].tos);
		int ith_b = SZ(g.vs[b].tos);
		g.vs[a].tos.push_back({b, ith_b});
		g.vs[b].tos.push_back({a, ith_a});
	}

	void initial_add_edge(int a, int b)
	{
		if (all_edges.find({a, b}) != all_edges.end())
			return;

		all_edges.insert({a, b});

		add_edge(a, b);
	}

	void move_edge(int v, int fr, int to)
	{
		auto ve = g.vs[v].tos[fr];
		g.vs[ve.dest].tos[ve.ith].ith = to;
		g.vs[v].tos[to] = ve;
	}

	void remove_edge_1(VE &ve)
	{
		remove_from_map(ve.dest);

		move_edge(ve.dest, SZ(g.vs[ve.dest].tos) - 1, ve.ith);
		g.vs[ve.dest].tos.pop_back();

		add_to_map(ve.dest);
	}

	//

	map<int, set<int>> vs_by_degree;
	int sum_degrees = 0;

	void add_to_map(int v)
	{
		int idx = g.vs[v].tos.size();
		vs_by_degree[idx].insert(v);
		sum_degrees += idx;
	}

	void remove_from_map(int v)
	{
		int idx = g.vs[v].tos.size();

		vs_by_degree[idx].erase(v);

		if (vs_by_degree[idx].size() == 0)
			vs_by_degree.erase(idx);

		sum_degrees -= idx;
	}

	void init_vs_by_degree()
	{
		FOR(v, in.n)
		{
			add_to_map(v);
		}
	}

	vector<Op> ops;

	void select(int v, int ignore = -1)
	{
		ERR("select", v);

		assert(!g.vs[v].select);

		//

		ops.push_back({});
		ops.back().v = v;

		for (auto &ve : g.vs[v].tos)
		{
			ops.back().tos.push_back(ve.dest);
		}

		//

		g.vs[v].select = 1;

		FOR(e, SZ(g.vs[v].tos))
		{
			remove_edge_1(g.vs[v].tos[e]);
		}

		// for (auto &ve : g.vs[v].tos)
		// {
		// 	remove_leaf(ve.dest);
		// }

		remove_from_map(v);

		g.vs[v].tos.clear();

		add_to_map(v);
	}

	void undo(const Op &op)
	{
		INDENT;
		ERR("undo", op.v);
		for (auto vv : op.tos)
		{
			ERRV(vv);
		}

		remove_from_map(op.v);
		for (auto vv : op.tos)
		{
			remove_from_map(vv);
		}

		CHECK(g.vs[op.v].select);

		g.vs[op.v].select = 0;

		for (auto to : op.tos)
		{
			add_edge(op.v, to);
		}

		//

		add_to_map(op.v);
		for (auto vv : op.tos)
		{
			add_to_map(vv);
		}
	}

	void undo_until(int idx)
	{
		FORR(i, idx, SZ(ops) - 1)
		{
			auto &op = ops[i];
			undo(op);
		}
		ops.resize(idx);
	}

	// void remove_leaf(int v)
	// {
	// 	if (g.vs[v].tos.size() != 1)
	// 		return;

	// 	auto u = g.vs[v].tos[0];

	// 	auto tos = g.vs[u.dest].tos;

	// 	select(u.dest);

	// 	for (auto &ve : tos)
	// 	{
	// 		remove_leaf(ve.dest);
	// 	}
	// }

	struct Result
	{
		bool good;
		vector<int> vs;
	};

	int want = 0;

	Result trace()
	{
		int k = want - SZ(ops);

		INDENT
		ERR("TRACE", "need more verts:", k);

		Result result;
		result.good = false;

		int edges_left = sum_degrees / 2;

		int sum_k_degrees = 0;
		auto it = vs_by_degree.end();
		int want_k = k;
		for (;;)
		{
			if (want_k <= 0)
				break;
			if (it == vs_by_degree.begin())
				break;
			it = prev(it);

			int degree = it->first;
			int num = it->second.size();

			if (num >= want_k)
			{
				sum_k_degrees += degree * want_k;
				want_k = 0;
				break;
			}
			else
			{
				sum_k_degrees += degree * num;
				want_k -= num;
			}
		}

		if (k == 0)
		{
			result.good = prev(vs_by_degree.end())->first == 0;
		}
		else if (k > 0 && sum_k_degrees < edges_left)
		{
			result.good = false; // not enough verts to cover all edges
		}
		else if (k > 0)
		{
			int op_idx = SZ(ops);

			CHECK(!vs_by_degree.empty());

			int v = *prev(vs_by_degree.end())->second.begin();
			ERR("highest degree", v, "degree: ", prev(vs_by_degree.end())->first);

			ERRV(v, SZ(g.vs[v].tos));

			// select highest degree
			auto v_tos = g.vs[v].tos;

			select(v);
			// for (auto &ve : v_tos)
			// 	remove_leaf(ve.dest);

			auto r = trace();
			if (r.good)
			{
				result.good = true;
				result.vs.push_back(v);
				for (auto vv : r.vs)
					result.vs.push_back(vv);
			}

			undo_until(op_idx);

			ERRV(v, SZ(g.vs[v].tos));

			//

			auto tos = g.vs[v].tos;
			// vector<int> tostos;
			// for (auto &ve : tos)
			// {
			// 	tostos.push_back(ve.dest);
			// 	for (auto &veve : g.vs[ve.dest].tos)
			// 	{
			// 		tostos.push_back(veve.dest);
			// 	}
			// }

			ERR("select", v, "'s neighbors instead -", SZ(tos), "total");

			for (auto &ve : tos)
			{
				select(ve.dest);
			}

			// for (auto &ve : tostos)
			// {
			// 	remove_leaf(ve);
			// }

			r = trace();
			if (r.good)
			{
				result.good = true;

				for (auto &ve : tos)
				{
					result.vs.push_back(ve.dest);
				}

				for (auto vv : r.vs)
					result.vs.push_back(vv);
			}

			undo_until(op_idx);
		}

		return result;
	}

	Test_Case()
	{
		I(in.n);
		I(in.m);
		I(in.k);

		g.vs.resize(in.n);

		FOR(in.m)
		{
			int a, b;
			I(a, b);
			--a;
			--b;
			initial_add_edge(a, b);
		}

		init_vs_by_degree();

		// FOR(v, in.n)
		// {
		// 	remove_leaf(v);
		// }

		// vector<int> by_default;

		// for (auto &op : ops)
		// {
		// 	by_default.push_back(op.v);
		// }

		Result r;
		r.good = false;
		int r_arg = -1;

		FOR(k, 1, in.k)
		{
			ERR("BEGIN TRACE DEPTH", k);

			want = k;
			r = trace();
			if (r.good)
			{
				r_arg = k + SZ(ops);
				break;
			}
		}

		ERRV(r_arg);

		if (r.good)
		{
			// for (auto v : by_default)
			// {
			// 	r.vs.push_back(v);
			// }

			sort(ALL(r.vs));
			auto last = unique(ALL(r.vs));
			r.vs.resize(last - r.vs.begin());

			O(r_arg, SZ(r.vs));

			sort(ALL(r.vs));
			for (auto v : r.vs)
				cout << v + 1 << " ";

			O();
		}
		else
		{
			O(-1);
		}
	}
};

//                                                                            //
// ════════════ ('\../') ═════════════                                        //
// ════════════ (◕.◕) ═══════════════                                        //
// ════════════ (,,)(,,) ═════════════                                        //
// .▀█▀.█▄█.█▀█.█▄.█.█▄▀　█▄█.█▀█.█─█.                                        //
// ─.█.─█▀█.█▀█.█.▀█.█▀▄　─█.─█▄█.█▄█- for reading my code!                   //
// ═══════════════════════════════════              --Adam                    //
////////////////////////////////////////////////////////////////////////////////

int main()
{
#ifdef LOCAL
	signal(SIGSEGV, handler);
	// signal(SIGABRT, handler);
#endif
	ios_base::sync_with_stdio(0);
	cout.precision(20);
	cout << fixed;

	int num_cases = 1;
	if (MULTIPLE_TEST_CASES)
		cin >> num_cases;

	FOR(i, num_cases)
	{
		ERR()
		ERR("TEST CASE", i + 1)
		INDENT
		Test_Case tc;
	}

	return 0;
}