#include <bits/stdc++.h>
#include <bits/extc++.h>

using namespace std;
using namespace __gnu_pbds;

#define SZ(x) ((int)((x).size()))
#define lb(x) ((x) & (-(x)))
#define bp(x) __builtin_popcount(x)
#define bpll(x) __builtin_popcountll(x)
#define mkp make_pair
#define pb push_back
#define fi first
#define se second
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
typedef pair<double, int> pdi;
typedef __gnu_pbds::tree<pii, null_type, less<pii>, __gnu_pbds::rb_tree_tag, 
        __gnu_pbds::tree_order_statistics_node_update> rbt;

mt19937 mrnd(std::chrono::steady_clock::now().time_since_epoch().count());
int rnd(int l, int r) {
    return mrnd() % (r - l + 1) + l;
}
double rnd01() {
    return mrnd() * 1.0 / UINT32_MAX;
}

void solve() {
    int n;
    cin >> n;
    vector G(n + 1, vector<int>());
    vector deg(n + 1, 0);
    for (int i = 1; i <= n - 1; i++) {
        int x, y;
        cin >> x >> y;
        G[x].push_back(y);
        G[y].push_back(x);
        deg[x]++;
        deg[y]++;
    }

    vector<pii> ans;
    vector dep(n + 1, 0);
    vector pid(n + 1, 0);
    auto sol = [&](int rt) -> bool {
        ans.clear();
        
        auto dfs_init = [&](auto &&self, int u, int fa, int d) -> void {
            dep[u] = d;
            for (auto v : G[u]) {
                if (v == fa) {
                    continue;
                }
                self(self, v, u, d + 1);
            }
        };
        dfs_init(dfs_init, rt, 0, 0);
        
        for (int i = 1; i <= n; i++) {
            pid[i] = i;
        }
        auto dfs_f = [&](auto &&self, int u, int fa) -> void {
            int mxd = 0, id = 0;
            for (auto v : G[u]) {
                if (v == fa) {
                    continue;
                }
                self(self, v, u);
                if (dep[pid[v]] > mxd) {
                    mxd = dep[pid[v]];
                    id = v;
                }
            }
            // sort(G[u].begin(), G[u].end(), [&](auto x, auto y) -> bool {
            //     return dep[pid[x]] < dep[pid[y]];
            // });
            if (id != 0) {
                G[u].erase(find(G[u].begin(), G[u].end(), id));
                G[u].push_back(id);
            }

            int lst = -1;
            for (auto v : G[u]) {
                if (v == fa) {
                    continue;
                }
                if (lst != -1) {
                    ans.push_back({lst, pid[v]});
                    lst = -1;
                } else {
                    lst = pid[v];
                }
            }
            if (lst != -1) {
                pid[u] = lst;
                if (dep[pid[u]] > dep[u] + 1) {
                    ans.push_back({pid[u], u});
                    pid[u] = u;
                }
            }
        };

        dfs_f(dfs_f, rt, 0);

        for (auto x : G[rt]) {
            if (x == pid[rt]) {
                return false;
            }
        }
        return true;
    };

    for (int i = 1; i <= n; i++) {
        if (deg[i] % 2 == 0) {
            bool res = sol(i);
            assert(res);
            cout << SZ(ans) << '\n';
            for (auto [x, y] : ans) {
                cout << x << " " << y << '\n';
            }
            return ;
        }
    }
    cout << -1 << '\n';

    // int st = clock();
    // for (int t = 1; t <= 130; t++) {
    //     int rt = rnd(1, n);
    //     bool res = sol(rt);
    //     // if (res) {
    //     //     cout << "rt = " << rt << '\n';
    //     // }
    //     if (res) {
    //         cout << SZ(ans) << '\n';
    //         for (auto [x, y] : ans) {
    //             cout << x << " " << y << '\n';
    //         }
    //         return ;
    //     }

    //     // int ed = clock();
    //     // if (1.0 * (ed - st) / CLOCKS_PER_SEC >= 1) {
    //     //     cout << -1 << '\n';
    //     //     return ;
    //     // }
    // }
    // cout << -1 << '\n';
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int T;
    cin >> T;
    while (T--) solve();
    return 0;
}