//              +-- -- --++-- +-In the name of ALLAH-+ --++-- -- --+              \\

#include <bits/stdc++.h>

#define F first
#define S second
#define _sz(x) (int)x.size()

using namespace std ;
using ll = long long ;
using ld = long double ;
using pii = pair <int , int> ;

int const N = 50 + 7 ;

int T ;

int n ;
vector <int> g[2][N] ;

int par[2][N] , deg[N] ;
bool mark[2][N] ;
vector <int> child[2][N] ;

inline void init_get () {
	for (int i = 0 ; i < n ; i ++) {
		deg[i] = 0 ;
		for (int id : {0 , 1}) {
			par[id][i] = -1 ;
			mark[id][i] = 0 ;
			child[id][i].clear() ;
		}
	}
}

void pre_dfs (int v , int id) {
	for (int u : g[id][v]) {
		if (u == par[id][v]) continue ;
		par[id][u] = v ;
		child[id][v].push_back(u) ;
		pre_dfs(u , id) ;
	}
}

void dfs (int v) {
	mark[0][v] = mark[1][v] = 1 ;

	for (int u : child[0][v])
		if (v == par[1][u]) dfs(u) ;
}

int sss ;

inline int get (int root) {
	init_get() ;

	for (int id : {0 , 1}) {
		par[id][root] = -1 ;
		pre_dfs(root , id) ;
	}

	dfs(root) ;

	int ans = n ;

	for (int i = 0 ; i < n ; i ++) {
		if (mark[0][i] && mark[1][i]) {
			ans -- ;
			for (int j : child[1][i]) mark[1][j] = 1 ;
		}
	}

	int need = ans ;
	queue <int> que ;

	for (int i = 0 ; i < n ; i ++) {
		if (mark[0][i] && mark[1][i]) continue ;

		deg[i] = child[0][i].size() ;
		if (!deg[i]) {
			mark[0][i] = 1 ;
			if (mark[0][i] && mark[1][i]) que.push(i) ;
		}
	}

	while (_sz(que)) {
		int v = que.front() ;
		que.pop() ;
		need -- ;
	
		for (int u : child[1][v]) {
			mark[1][u] = 1 ;
			if (mark[0][u] && mark[1][u]) que.push(u) ;
		}

		{
			int u = par[0][v] ;
			if (!mark[0][u]) {
				deg[u] -- ;
				if (!deg[u]) mark[0][u] = 1 ;
				if (mark[0][u] && mark[1][u]) que.push(u) ;
			}
		}	
	}

	if (need) ans = n + 5 ;

	if (ans == n + 5 && sss > n && g[0][root].size() == 1) {
		for (int vv = 0 ; vv < n ; vv ++) {
			if (child[1][vv].size()) continue ;
			
			init_get() ;

			pre_dfs(root , 1) ;
			pre_dfs(vv , 0) ;

			for (int i = 0 ; i < n ; i ++) {
				deg[i] = child[0][i].size() ;
				if (!deg[i]) mark[0][i] = 1 ;
			}
	
			mark[0][root] = mark[1][root] = 1 ;
			que.push(root) ;

			need = n ;
			while (_sz(que)) {
				int v = que.front() ;
				que.pop() ;
				need -- ;

				for (int u : child[1][v]) {
					if (mark[0][u] && mark[1][u]) assert(0) ; ;
					mark[1][u] = 1 ;
					if (mark[0][u] && mark[1][u]) que.push(u) ;
				}

				{
					int u = par[0][v] ;
					if (u != -1) {
			//			if (mark[0][u] && mark[1][u]) assert(0) ;

						deg[u] -- ;
			//			assert(deg[u] >= 0) ;
						if (!deg[u]) mark[0][u] = 1 ;
						if (mark[0][u] && mark[1][u]) que.push(u) ;
					}
				}
			}

			if (!need) ans = n ;
		}
	}

	return ans ;
}

inline void init_solve () {
	init_get() ;
	for (int i = 0 ; i < n ; i ++) g[0][i].clear() , g[1][i].clear() ;
	n = 0 ; // Just for fun 
}

inline void solve () {
	init_solve() ;

	cin >> n ;

	for (int id : {0 , 1}) {
		for (int i = 0 , u , v ; i < n - 1 ; i ++) {
			cin >> u >> v ;
			u -- , v -- ;
			g[id][u].push_back(v) ;
			g[id][v].push_back(u) ;
		}
	}


	sss = n + 5 ;
	for (int i = 0 ; i < n ; i ++) sss = min(sss , get(i)) ;

	if (sss > n) sss = -1 ;

	cout << sss << '\n' ;
}

int main(){
	ios::sync_with_stdio(false) , cin.tie(0) , cout.tie(0) ;

	cin >> T ;

	while (T --) solve() ;
}

Measured memory_bytes: 256