Problem: Snuke has found two trees A and B, each with N vertices numbered 1 to N. The i-th edge of A connects Vertex a_i and b_i, and the j-th edge of B connects Vertex c_j and d_j. Also, all vertices of A are initially painted white.

Snuke would like to perform the following operation on A zero or more times so that A coincides with B:

* Choose a leaf vertex that is painted white. (Let this vertex be v.)
* Remove the edge incident to v, and add a new edge that connects v to another vertex.
* Paint v black.



Determine if A can be made to coincide with B, ignoring color. If the answer is yes, find the minimum number of operations required.

You are given T cases of this kind. Find the answer for each of them.

Constraints

* 1 \leq T \leq 20
* 3 \leq N \leq 50
* 1 \leq a_i,b_i,c_i,d_i \leq N
* All given graphs are trees.

Input

Input is given from Standard Input in the following format:


T
case_1
:
case_{T}


Each case is given in the following format:


N
a_1 b_1
:
a_{N-1} b_{N-1}
c_1 d_1
:
c_{N-1} d_{N-1}


Output

For each case, if A can be made to coincide with B ignoring color, print the minimum number of operations required, and print `-1` if it cannot.

Examples

Input

2
3
1 2
2 3
1 3
3 2
6
1 2
2 3
3 4
4 5
5 6
1 2
2 4
4 3
3 5
5 6


Output

1
-1


Input

3
8
2 7
4 8
8 6
7 1
7 3
5 7
7 8
4 2
5 2
1 2
8 1
3 2
2 6
2 7
4
1 2
2 3
3 4
3 4
2 1
3 2
9
5 3
4 3
9 3
6 8
2 3
1 3
3 8
1 7
4 1
2 8
9 6
3 6
3 5
1 8
9 7
1 6


Output

6
0
7

Solution (in CPP):

Solution:
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <cstring>
#include <queue>
#include <functional>
#include <cmath>
#include <string>
#include <set>
#include <map>
#include <numeric>
using namespace std;

#define repeat(i, x) for (int64_t i = 0; (i) < (int64_t)(x); ++(i))

namespace TaskF {
    using Tree = vector<set<int>>;

    int n_;
    Tree aT_, bT_;
    vector<int> aParents_, bParents_;
    vector<int> deg_;
    vector<bool> use_;

    void DFSA(int u, int p) {
        aParents_[u] = p;
        for (int v : aT_[u]) {
            if (v != p) DFSA(v, u);
        }
    }

    void DFSB(int u, int p) {
        bParents_[u] = p;
        for (int v : bT_[u]) {
            if (v != p) DFSB(v, u);
        }
    }

    Tree inputTree() {
        Tree t(n_);
        repeat (i, n_ - 1) {
            int a, b;
            cin >> a >> b; a--; b--;
            t[a].insert(b);
            t[b].insert(a);
        }
        return t;
    }

    int solveWithFixed(int r) {
    }

    void solve(int testNumber) {
        cin >> n_;

        aParents_.resize(n_, 0);
        bParents_.resize(n_, 0);
        deg_.resize(n_, 0);
        use_.resize(n_, false);

        aT_ = inputTree();
        bT_ = inputTree();

        int ans = -1;
        repeat (s, n_) {
            if (aT_[s].size() == 1) {
                int t = *aT_[s].begin();
                aT_[s].erase(t);
                aT_[t].erase(s);

                repeat (i, n_) {
                    if (s == i) continue;

                    aT_[s].insert(i);
                    aT_[i].insert(s);

                    DFSA(s, -1);
                    DFSB(s, -1);

                    fill(use_.begin(), use_.end(), false);

                    queue <int> que;
                    int cnt = 0;
                    que.push(s);

                    while (!que.empty()) {
                        int v = que.front(); que.pop();
                        use_[v]=true;
                        cnt++;

                        for (int to : aT_[v]) {
                            if(to != aParents_[v] and bParents_[to] == v) que.push(to);
                        }
                    }
                    repeat (j, n_) {
                        deg_[j] = aT_[j].size() - 1;
                    }

                    while (true) {
                        int v = -1;
                        repeat (j, n_) {
                            if(!use_[j] and deg_[j]==0 and use_[bParents_[j]]) {
                                v = j;
                                break;
                            }
                        }
                        if(v == -1) break;
                        use_[v]=true;
                        deg_[aParents_[v]]--;
                    }

                    bool up=true;
                    repeat (j, n_) {
                        if(!use_[j]) {
                            up=false;
                        }
                    }

                    if(up) {
                        int vl=n_-cnt+(t != i);
                        if(ans==-1) ans=vl;
                        else ans=min(ans,vl);
                    }

                    aT_[s].erase(i);
                    aT_[i].erase(s);
                }
                aT_[s].insert(t);
                aT_[t].insert(s);
            }
        }
        cout << ans << endl;
    }
}

int main() {
    int T;
    cin >> T;

    repeat (_, T) {
        TaskF::solve(_);
    }

    return 0;
}