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<set>
#include<queue>
#include<cmath>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define MAXN 100005
#define ENDL putchar('\n')
#define LL long long
#define DB double
#define lowbit(x) ((-x) & (x))
#pragma GCC optimize(2)
LL read() {
	LL f = 1,x = 0;char s = getchar();
	while(s < '0' || s > '9') {if(s=='-')f = -f;s = getchar();}
	while(s >= '0' && s <= '9') {x=x*10+(s-'0');s = getchar();}
	return f * x;
}
int n,m,i,j,s,o,k,rt;
vector<int> g[MAXN];
int tl[MAXN];
int a[MAXN],b[MAXN],c[MAXN],d[MAXN],cnt;
void dfs(int x,int ff) {
	int ct = 0;
	for(int i = 0;i < (int)g[x].size();i ++) {
		int y = g[x][i];
		if(y != ff) {
			dfs(y,x);
			if(tl[y]) {
				if(!ct) ct = y;
				else if(ct > 0) {
					int l = tl[ct],r = tl[y];
					++ cnt;
					a[cnt] = x,b[cnt] = ff;
					c[cnt] = rt,d[cnt] = l;
					rt = r;
					ct = -1;
				}
				else {
					++ cnt;
					a[cnt] = y,b[cnt] = x;
					c[cnt] = rt,d[cnt] = y;
					rt = tl[y];
				}
			}
		}
	}
	if(ct == 0) tl[x] = x;
	else if(ct > 0) tl[x] = tl[ct];
	else tl[x] = 0;
	return ;
}
int main() {
	int T = read();
	while(T --) {
		n = read();
		for(int i = 1;i <= n;i ++) g[i].clear(),tl[i] = 0;
		for(int i = 1;i < n;i ++) {
			s = read();o = read();
			g[s].push_back(o);
			g[o].push_back(s);
		}
		rt = 0;cnt = 0;
		for(int i = 1;i <= n;i ++) {
			if((int)g[i].size() == 1) {rt = i;break;}
		}
		dfs(rt,0);
		printf("%d\n",cnt);
		for(int i = 1;i <= cnt;i ++) {
			printf("%d %d %d %d\n",a[i],b[i],c[i],d[i]);
		}
	}
	return 0;
}