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))

const int inf = (1 << 28);

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) {
        DFSA(r, -1);
        DFSB(r, -1);

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

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

        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;
            return vl;
        } else return inf;
    }

    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 = inf;
        repeat (r, n_) {
            if (aT_[r].size() == 1) {
                int old = *aT_[r].begin();
                aT_[r].erase(old);
                aT_[old].erase(r);

                repeat (u, n_) {
                    if (r == u) continue;

                    aT_[r].insert(u);
                    aT_[u].insert(r);

                    ans = min(ans, solveWithFixed(r) + (old != u));

                    aT_[r].erase(u);
                    aT_[u].erase(r);
                }
                aT_[r].insert(old);
                aT_[old].insert(r);
            }
        }

        if (ans >= inf) ans = -1;
        cout << ans << endl;
    }
}

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

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

    return 0;
}