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;
#define M 100005
#define oo 1000000000
#define ll long long 
int sz[M],son[M],ed[M],ed2[M],In[M],Out[M],tot;
struct bao{
	int a,b,c,d;
}Q[M];
int hav;
vector<int>vec[M];
void dfs(int now,int f){
	sz[now]=1;
	int cnt=0;
	In[now]=++tot;
	for(int i=0;i<vec[now].size();i++){
		int  y=vec[now][i];
		if(y==f)continue;
		dfs(y,now);
		sz[now]+=sz[y];
		//if(sz[y]>sz[son[now]])son[now]=y;
		cnt++;
	}
	if(cnt==0){
		ed[now]=now;
		ed2[now]=now;
	}
	Out[now]=tot;
}
void chuli(int now,int f){
	for(int i=vec[now].size()-1;i>=0;i--){
		int y=vec[now][i];
		if(y!=f&&In[ed2[now]]>=In[y]&&In[ed2[now]]<=Out[y]){
			Q[++hav]=(bao){now,y,ed[now],y};
			ed[now]=ed2[now];
			ed2[now]=now;
			break;
		}
	}
}
void rdfs(int now,int f){
	int cao=0;
	for(int i=0;i<vec[now].size();i++){
		int y=vec[now][i];
		if(y==f)continue;
		rdfs(y,now);
		if(y==ed2[y])son[now]=y;
		cao=y;
	}
	if(son[now])ed[now]=ed[son[now]];
	else if(cao){
		chuli(cao,now);
		son[now]=cao;
		//printf("cnm%d\n",cao);
		ed[now]=ed[son[now]];
	}
	int cnt=1;
	for(int i=0;i<vec[now].size();i++){
		int y=vec[now][i];
		if(y==f)continue;
		if(y!=son[now]){
			if(cnt>=2||ed2[y]!=y){
				Q[++hav]=(bao){now,y,ed[now],ed2[y]};
				ed[now]=ed[y];	
			}
			else {
				ed2[now]=ed[y];
				cnt++;
			}
			
		}
	}
	if(cnt<2)ed2[now]=now;
}
int main(){
	int T,n,m,i,j,a,b;
	cin>>T;
	while(T--){
		cin>>n;
		hav=0;
		tot=0;
		for(i=1;i<n;i++){
			cin>>a>>b;
			vec[a].push_back(b);
			vec[b].push_back(a);
		}
		dfs(1,0);
		rdfs(1,0);
		printf("%d\n",hav);
		for(i=1;i<=hav;i++){
			printf("%d %d %d %d\n",Q[i].a,Q[i].b,Q[i].c,Q[i].d);
		}for(i=1;i<=n;i++)vec[i].clear();
		for(i=1;i<=n;i++){	
			son[i]=0;
			ed[i]=0;
			ed2[i]=0;
		}
	}
}