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<bits/stdc++.h>
using namespace std;

#define int long long

#define rep(i,n) for(int i=0;i<(n);i++)
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
typedef vector<int>vint;
typedef pair<int,int>pint;
typedef vector<pint>vpint;

template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}


const int INF=1001001001;

int N;
int A[55],B[55],C[55],D[55];

vector<vint>G,H;

void mk(){
    G=vector<vint>(N);
    H=vector<vint>(N);
    rep(i,N-1){
        G[A[i]].pb(B[i]);G[B[i]].pb(A[i]);
        H[C[i]].pb(D[i]);H[D[i]].pb(C[i]);
    }
}

void dfs(int v,int p,vector<vint>&G,vector<int>&parG){
    parG[v]=p;
    for(auto u:G[v])if(u!=p){
        dfs(u,v,G,parG);
    }
}

int calc(int r){
    vint parG(N),parH(N);
    dfs(r,-1,G,parG);
    dfs(r,-1,H,parH);

    vector<int>used(N);
    used[r]=true;
    queue<int>que;
    que.push(r);
    while(que.size()){
        int v=que.front();
        que.pop();
        for(auto u:G[v]){
            if(used[u])continue;
            if(parH[u]==v){
                used[u]=true;
                que.push(u);
            }
        }
    }

    int ret=0;
    vector<vint>F(N);
    vint deg(N);
    rep(i,N){
        if(used[i])continue;
        ret++;
        if(!used[parG[i]]){
           F[i].pb(parG[i]);deg[parG[i]]++;
        }
        if(!used[parH[i]]){
            F[parH[i]].pb(i);deg[i]++;
        }
    }

    rep(i,N)if(deg[i]==0)que.push(i);
    while(que.size()){
        int v=que.front();
        que.pop();
        for(auto u:F[v]){
            if(--deg[u]==0)que.push(u);
        }
    }
    if(count(all(deg),0)!=N)return INF;
    return ret;
}

void solve(){
    cin>>N;
    rep(i,N-1)cin>>A[i]>>B[i],A[i]--,B[i]--;
    rep(i,N-1)cin>>C[i]>>D[i],C[i]--,D[i]--;

    int ans=INF;


    mk();

    rep(i,N)chmin(ans,calc(i));

    vint deg(N);
    rep(i,N-1)deg[A[i]]++,deg[B[i]]++;
    rep(i,N-1){
        rep(j,2){
            if(deg[A[i]]==1){
                for(int k=0;k<N;k++)if(k!=A[i]){
                    int tmp=B[i];
                    B[i]=k;

                    mk();chmin(ans,calc(A[i])+1);

                    B[i]=tmp;
                }
            }
            swap(A[i],B[i]);
        }
    }

    if(ans==INF)cout<<-1<<endl;
    else cout<<ans<<endl;
}

signed main(){
    int T;cin>>T;
    while(T--)solve();
    return 0;
}