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.
#include <bits/stdc++.h>

using namespace std;

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int tc;
    cin >> tc;
    while (tc--) {
        int n;
        cin >> n;
        vector<vector<int>> adj(n);
        vector<tuple<int, int, int, int>> ans;
        for (int i = 1; i < n; i++) {
            int u, v;
            cin >> u >> v;
            --u, --v;
            adj[u].emplace_back(v);
            adj[v].emplace_back(u);
        }
        int root = 0;
        while ((int) adj[root].size() > 1) {
            ++root;
        }

        function<int(int, int)> dfs = [&](int u, int p) {
            int ch = 0, to = u;
            for (int v : adj[u]) {
                if (v == p) continue;
                int x = dfs(v, u);
                if (x < 0) continue;
                ++ch;
                if (ch == 1) {
                    to = x;
                } else if (ch == 2) {
                    ans.emplace_back(p, u, to, x);
                    to = -1;
                } else {
                    ans.emplace_back(u, v, v, x);
                }
            }
            return to;
        };

        int to = dfs(root, -1);
        cout << ans.size() << '\n';
        for (auto& [x1, y1, x2, y2] : ans) {
            cout << x1 + 1 << ' ' << y1 + 1 << ' ' << to + 1 << ' ' << x2 + 1 << '\n';
            to = y2;
        }
    }

    return 0;
}