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;

const int maxn = 5e5 + 555;

set<int>G[maxn];
int fa[maxn];
int soncnt[maxn];

vector<int>savedep[maxn];
void dfs(int s, int f, int dep){
    fa[s] = f;
    soncnt[s] = 0;
    savedep[dep].push_back(s);
    G[s].erase(f);
    for(int d : G[s]){
        dfs(d, s, dep + 1);
        soncnt[s]++;
    }
}

vector<int>save;
void bfs(int s){
    save.clear();
    queue<int>q;
    q.push(s);
    while(!q.empty()){
        int nowid = q.front();
        q.pop();
        int soncnt = 0;
        for(int d : G[nowid]){
            q.push(d);
            soncnt++;
        }
        if(soncnt == 0)
            save.push_back(nowid);
    }
}

typedef pair<int, int> pii;
vector<pii>DEL;
vector<pii>ADD;
vector<pii>sa;

void del(int id1, int id2){
    DEL.push_back(make_pair(id1, id2));
}

void solve(){
    int n;
    scanf("%d", &n);

    DEL.clear();
    ADD.clear();
    sa.clear();
    for(int i = 0; i <= n; i++){
        G[i].clear();
        savedep[i].clear();
    }

    for(int i = 1; i < n; i++){
        int a, b;
        scanf("%d %d", &a, &b);
        G[a].insert(b);
        G[b].insert(a);
    }
    int root = 0;
    for(int i = 1; i <= n; i++){
        if(G[i].size() == 1){
            root = i;
            break;
        }
    }
    dfs(root, -1, 0);

    for(int dep = n; dep >= 0; dep--){
        for(int nowid : savedep[dep]){
            int nowf = fa[nowid];
            if(soncnt[nowid] >= 2){//这个点有多个孩子， 需要删除
                //删除与父亲节点的连边
                if(nowf != -1){
                    del(nowid, nowf);
                    G[nowf].erase(nowid);
                    soncnt[nowf]--;
                }
                //删除与孩子节点的连边
                int totcnt = soncnt[nowid] - 2;
                set<int>::iterator ite = G[nowid].begin();
                while(totcnt > 0){
                    totcnt--;
                    int sonid = *ite;
                    del(nowid, sonid);
                    bfs(sonid);
                    sa.push_back(make_pair(sonid, save[0]));
                    ite++;
                    G[nowid].erase(sonid);
                }
                bfs(nowid);
                sa.push_back(make_pair(save[0], save[1]));
            }
        }
    }
    bfs(root);

    sa.push_back(make_pair(root, save[0]));
    for(int i = 0; i < sa.size() - 1; i++){
        ADD.push_back(make_pair(sa[i].second, sa[i + 1].first));
    }
    printf("%d\n", ADD.size());
    for(int i = 0; i < DEL.size(); i++){
        printf("%d %d %d %d\n", DEL[i].first, DEL[i].second, ADD[i].first, ADD[i].second);
    }
}

signed main(){
    //freopen("in.txt", "r", stdin);
    int T = 1;
    cin>>T;
    while(T--)
        solve();
}