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:
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")

#include<bits/stdc++.h>
using namespace std;

#define pb push_back
#define mp make_pair
#define F first
#define S second
#define lb lower_bound
#define ub upper_bound
#define sz(x) (int)(x).size()
#define all(x) x.begin(), x.end()

typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
typedef pair<int, int> pii;
typedef pair<ll,ll> pll;
typedef pair<ld,ld> pld;
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pii> vpi;
typedef vector<pll> vpl;

#define FOR(i, a, b) for (int i=a; i<(b); i++)
#define F0R(i, a) for (int i=0; i<(a); i++)
#define FORd(i,a,b) for (int i = (b)-1; i >= a; i--)
#define F0Rd(i,a) for (int i = (a)-1; i >= 0; i--)
#define trav(a,x) for (auto& a : x)

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
 
ll powmod(ll a,ll b) {ll res=1; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a;a=a*a;}return res;}
ll gcd(ll a,ll b) { return b?gcd(b,a%b):a;}
struct V{
    int a,b,c,d;
};
vector<V> ans;

pii dfs(int v,int p,vector<vector<int>> &g) {
    pii str={-1,-1};
    trav(x, g[v])
        if(x!=p) {
            pii k = dfs(x,v,g); 
            if(k.F!=x && k.S!=x)  ans.pb({v,x,k.F,-k.S-1});
            else {
                if(str.F==-1){ str.F=k.S; continue; }
                else if(str.S!=-1) ans.pb({v,x,str.S,x});
                str.S = k.S;
            }
        }
    if(str.F==-1) return {v,v};
    if(str.S==-1) return {v,str.F};
    return str;
}

void solve() {
    int n; cin >> n;
    vector<vi> g(n); ans.clear();
    F0R(i,n-1) {
        int a,b; cin >> a >> b; --a;--b;
        g[a].pb(b); g[b].pb(a);
    }
    int L = dfs(0,-1,g).F;
    cout<<ans.size()<<'\n';
    trav(l,ans) {
        if(l.d<0) { int s=l.d+1; l.d=L;  L=-s; }
        cout << l.a+1 << ' ' << l.b+1 << ' ' << l.c+1 << ' ' << l.d+1 << '\n';
    }
}


int main(){
    ios_base::sync_with_stdio(false); cin.tie(NULL); 
    int t=1;
    cin>>t;
    while(t--) solve();
  return 0;
}