Problem: Nastia has an unweighted tree with n vertices and wants to play with it!

The girl will perform the following operation with her tree, as long as she needs:

  1. Remove any existing edge. 
  2. Add an edge between any pair of vertices. 



What is the minimum number of operations Nastia needs to get a bamboo from a tree? A bamboo is a tree in which no node has a degree greater than 2.

Input

The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.

The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the number of vertices in the tree.

Next n - 1 lines of each test cases describe the edges of the tree in form a_i, b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i).

It's guaranteed the given graph is a tree and the sum of n in one test doesn't exceed 2 ⋅ 10^5.

Output

For each test case in the first line print a single integer k — the minimum number of operations required to obtain a bamboo from the initial tree.

In the next k lines print 4 integers x_1, y_1, x_2, y_2 (1 ≤ x_1, y_1, x_2, y_{2} ≤ n, x_1 ≠ y_1, x_2 ≠ y_2) — this way you remove the edge (x_1, y_1) and add an undirected edge (x_2, y_2).

Note that the edge (x_1, y_1) must be present in the graph at the moment of removing.

Example

Input


2
7
1 2
1 3
2 4
2 5
3 6
3 7
4
1 2
1 3
3 4


Output


2
2 5 6 7
3 6 4 5
0

Note

Note the graph can be unconnected after a certain operation.

Consider the first test case of the example: 

<image> The red edges are removed, and the green ones are added.

Solution (in CPP):

Solution:
#include<bits/stdc++.h>
using namespace std;
using ll = long long;

const int N = 2e5 + 5;

int n, nComp;
int keep[N], vis[N];
vector<int> adj[N];
vector<int> comp[N];
set<pair<int, int> > edge;
vector<pair<int, int> > ins, del;

void dfs(int u, int p) {
	int cnt = 0;
	for (int v : adj[u]) {
		if (v != p) {
			dfs(v, u);
			cnt += keep[v];
		}
	}
	if (cnt == 0) {
		keep[u] = 1;
	} else {
		if (cnt == 1) {
			keep[u] = 1;
		} else {
			keep[u] = 0;
			if (u != p) {
				del.push_back({min(u, p), max(u, p)});
			}
			int tmp = 0;
			for (int v : adj[u]) {
				if (v != p && keep[v] == 1) {
					tmp++;
					if (tmp > 2) {
						del.push_back({min(v, u), max(v, u)});
					}
				}
			}
		}
	}
}

void dfs1(int u, int p) {
	vis[u] = 1;
	if ((int)adj[u].size() <= 1) comp[nComp].push_back(u);
	for (int v : adj[u]) {
		if (v != p) {
			dfs1(v, u);
		}
	}
}

int main() {
	ios_base::sync_with_stdio(0); cin.tie(0);
	
	int tc; cin >> tc;
	while (tc--) {
		cin >> n;
		for (int i = 1; i <= n; i++) {
			adj[i].clear();
			keep[i] = vis[i] = 0;
		}
		edge.clear();
		ins.clear(); del.clear();
		for (int i = 1; i < n; i++) {
			int u, v; cin >> u >> v;
			adj[u].push_back(v);
			adj[v].push_back(u);
			edge.insert({min(u, v), max(u, v)});
		}
		dfs(1, 1);
	
		for (auto i : del) edge.erase(i);
		for (int i = 1; i <= n; i++) adj[i].clear();
		for (auto i : edge) {
			int u = i.first, v = i.second;
			adj[u].push_back(v);
			adj[v].push_back(u);
		}
		
		nComp = 0;
		for (int i = 1; i <= n; i++) {
			if (vis[i] == 0) {
				comp[++nComp].clear();
				dfs1(i, i);
				if ((int)comp[nComp].size() == 1) {
					comp[nComp].push_back(i);
				}
			}
		}
		
		for (int i = 1; i + 1 <= nComp; i++) {
			ins.push_back({comp[i][1], comp[i + 1][0]});
		}
//		cout << del.size() << " " << ins.size() << endl;
		cout << (int)ins.size() << "\n";
		for (int i = 0; i < (int)ins.size(); i++) {
			cout << del[i].first << " " << del[i].second << " ";
			cout << ins[i].first << " " << ins[i].second << "\n";
		}
	}
}