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   int   long   long
#define  mod  1000000007
#define  pb push_back
#define  ss second
#define  ff first
#define  all(v)  v.begin(),  v.end()
#define  deb(x)  cerr  <<   "\n" \
                    << #x << "=" << x << "\n";
#define  deb2(x,  y)  cerr  <<   "\n"                   \
                        << #x << "=" << x << "\n" \
                        << #y << "=" << y << "\n";
#define  w(x) \
  int  x;     \
cin  >>  x;  \
  while   (x--)
 
int  n,m;
const   int  N  =   1e5   +   2;
vector<int>  v[N];
vector<vector<int>>  add,erase;
vector<pair<int,int>>  ds;
 
pair<int,int>  dfs(int  x,int  p  =   0) {
	vector<vector<int>>  children;
 
	for(int  i:  v[x]) {
		if(i  !=  p) {
pair<int,int>  res  =  dfs(i,x);
			if(res.ff  !=  INT_MAX) {
children.pb({i,res.ff,res.ss});
			}
		}
	}
 
	if(children.size()   <=   1) {
		if(p  ==   0)
ds.pb({x,x});
		if(children.empty())
			return   {x,x};
		return   {children[0][1],children[0][2]};
	}
	
	if(children.size()   >   2) {
		for(int  i  =   0;i  <  children.size()   -   2;  ++i) {
erase.pb({children[i][0],x});
ds.pb({children[i][0],children[i][1]});
		}
	}
	if(p  !=   0) {
erase.pb({x,p});
	}
 
ds.pb({children[children.size()   -   1][1],children[children.size()   -   2][1]});
 
	return   {INT_MAX,INT_MIN};
}
 
int32_t  main() {
 
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
	
w(tt) {
cin  >>  n;
m  =  n  -   1;
 
		for(int  i  =   0;i  <  m;  ++i) {
			int  a,  b;
cin  >>  a  >>  b;
v[a].push_back(b);
v[b].push_back(a);
		}
 
dfs(1);
 
		for(int  i  =   1;i  <  ds.size();  ++i) {
add.pb({ds[i].ff,ds[i  -   1].ss});
		}
 
assert(add.size()   ==  erase.size());
 
cout  <<  add.size()   <<   "\n";
 
		for(int  i  =   0;i  <  add.size();  ++i) {
cout  <<  erase[i][0]   <<   " "   <<  erase[i][1]   <<   " "   <<  add[i][0]   <<   " "   <<  add[i][1]   <<   "\n";
		}
 
add.clear();
erase.clear();
ds.clear();
		for(int  i  =   0;i  <=  n;  ++i)
v[i].clear();
	}
	return   0;
}