#include <cstdio>
#include <cassert>
#include <vector>

struct state {
	bool real;
	int a, p, q;
	state() {
		real = 0;
		a = p = q = -1;
	}
};

const int N = 300000;
std::vector<int> g[N];
std::vector<state> dp[N][2];
std::vector<std::pair<int, int> > ans;
int t, n, rt;

void dfs(int v, int pr = -1) {
	for (int i = 0; i < (int)g[v].size(); ++i) if (g[v][i] == pr) g[v].erase(g[v].begin() + i);

	dp[v][0].resize(g[v].size() + 1);
	dp[v][1].resize(g[v].size() + 1);

	if (!g[v].size()) {
		dp[v][1].back().real = 1;
		dp[v][1].back().a = v;
	}
	else dp[v][0][0].real = 1;
	for (int i = 0; i < (int)g[v].size(); ++i) {
		int to = g[v][i];
		dfs(to, v);
		for (int j = 0; j < 2; ++j) {
			if (dp[v][j][i].real) {
				for (int k = 1; k < 2; ++k) {
					if (dp[to][k].back().real) {
						if (j && k) {
							dp[v][0][i + 1].real = 1;
							dp[v][0][i + 1].p = dp[v][j][i].a;
							dp[v][0][i + 1].q = dp[to][k].back().a;
						} else if (!j && !k) {
							dp[v][0][i + 1].real = 1;
						} else {
							dp[v][1][i + 1].real = 1;
							dp[v][1][i + 1].a = j ? dp[v][j][i].a : dp[to][k].back().a;
						}
					}
					if (dp[to][1].back().real && dp[to][1].back().a != to) {
						dp[v][j][i + 1].real = 1;
						dp[v][j][i + 1].a = dp[v][j][i].a;
						dp[v][j][i + 1].p = dp[to][1].back().a;
						dp[v][j][i + 1].q = v;
					}
				}
			}
		}
	}
	if (!dp[v][1].back().real && dp[v][0].back().real) {
		dp[v][1].back().real = 1;
		dp[v][1].back().a = v;
	}
	for (int i = 0; i <= (int)g[v].size(); ++i) {
		for (int j = 0; j < 2; ++j) {
			//printf("dp %d %d %d : %d, (%d %d)\n", v, j, i, dp[v][j][i].real, dp[v][j][i].a, dp[v][j][i].b);
		}
	}
}

void restore(int v, int par) {
	if (par && dp[v][par].back().a == v) {
		par ^= 1;
	}
	for (int i = (int)g[v].size() - 1; i >= 0; --i) {
		assert(dp[v][par][i + 1].real);
		if (dp[v][par][i + 1].p != -1) {
			ans.push_back(std::make_pair(dp[v][par][i + 1].p, dp[v][par][i + 1].q));
			if (dp[v][par][i + 1].q != v) par ^= 1;
			restore(g[v][i], 1);
		} else {
			if (!par) while (true);
			restore(g[v][i], 1);
			par ^= 1;
		}
	}
}

void solve() {
	scanf("%d", &n);
	for (int i = 1; i < n; ++i) {
		int a, b;
		scanf("%d%d", &a, &b);
		g[a - 1].push_back(b - 1);
		g[b - 1].push_back(a - 1);
	}
	if (n == 2) {
		printf("-1\n");
		return;
	}
	for (rt = 0; g[rt].size() == 1; ++rt);
	dfs(rt);
	if (!dp[rt][0].back().real) {
        assert(n & 1 ^ 1);
		printf("-1\n");
		return;
	}
	restore(rt, 0);
	printf("%d\n", (int)ans.size());
	for (int i = 0; i < (int)ans.size(); ++i) printf("%d %d\n", ans[i].first + 1, ans[i].second + 1);
}

int main() {
	scanf("%d", &t);
	while (t--) {
		solve();
		for (int i = 0; i < n; ++i) {
			g[i].clear();
			dp[i][0].clear();
			dp[i][1].clear();
		}
		ans.clear();
	}
	return 0;
}