//   @author - Archit


#include<bits/stdc++.h>
using namespace std;


#define pb push_back
#define mp make_pair
#define ll long long
#define pll pair<ll,ll> 
#define all(v) v.begin(),v.end()
#define vll vector<ll> 
#define vvll vector<vll >
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);
#define ff first
#define ss second 
#define rjust(x) cout << std::right << std::setw(5) << x<<;
#define precise(x,y) cout<<std::fixed << std::setprecision(y) << x;
#define INF 1000000000000000

//INPUT
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

template<typename T>
void cres(vector<T>&Arr,int n)
{
	Arr.clear();
	Arr.resize(n);
}


template<typename T>
void cres(vector<vector<T> >&Arr,int row ,int col)
{
	Arr.clear();
	Arr.resize(row,vector<T>(col));
}

template<typename T>
void read(int x , vector<T>&Arr)
{
	for(ll i=x ;i<Arr.size();++i)
		cin>>Arr[i];
}

template<typename T >
void read(int x , vector<vector<T> >&Arr)
{
	for(ll i=x ;i<Arr.size();++i)
		{
			for(ll j=x ;j<Arr[i].size();++j)
				cin>>Arr[i][j];
		}
}

template<typename T >
void readg(vector<vector<T> >&Arr , int e)
{
	for(ll i=1 ;i<=e;++i)
		{
			ll x,y;
			cin>>x>>y;
			Arr[x].pb(y);
			Arr[y].pb(x);

		}
}

template<typename T>
void read(int x , T Arr[], int n)
{
	for(ll i=x ;i<n;++i)
		cin>>Arr[i];
}



//OUTPUT
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


template<typename T>
void write(int x , vector<T>&Arr)
{
	for(ll i=x ;i<Arr.size();++i)
		cout<<Arr[i]<<" ";
}

template<typename T>
void write(int x , vector<vector<T> >&Arr)
{
		for(ll i=x ;i<Arr.size();++i)
		{
			for(ll j=x ;j<Arr[i].size();++j)
				cout<<Arr[i][j]<< " ";
			cout<<"\n";
		}
}

template<typename T>
void write(int x , T Arr[], int n)
{
	for(ll i=x ;i<n;++i)
		cout<<Arr[i]<<" ";
}

template<typename T>
void write(set<T>&s)
{
	for(auto i : s) 
		cout<< i << " ";
}


template<typename T0, typename T1>
void write(map<T0,T1>&m)
{
	for(auto i : m) 
		cout<< i.ff << " " << i.ss<<"\n";
}



//FUNCTIONS
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// const int sieve_size = 100005;
// int sieve[sieve_size];

// void Sieve()
// {
// 	sieve[0] = sieve[1] = -1;
	
// 	for(int i=2 ;i<sieve_size ;i++)
// 		sieve[i]=i;

// 	for(int i = 2 ;i*i<=sieve_size ;++i)
// 	{
// 		if(sieve[i]==i)
// 		{
// 			for(int j = i*i ; j<sieve_size;j+=i)
// 			{
// 				if(sieve[j]==j)
// 				sieve[j]=i;
// 			}
// 		}
// 	}
// }
ll n , m , src , dest;
vector<vector<ll > >tree;
vector<pair<ll, ll > >edges , edgeTree;
vll path,edgeMask;
vector<vector<ll > > maskMap;
ll dp[51][1LL << 20];

void dfs(ll idx , ll x = src , ll par = 0 ) {
	// cout << x << " " << dest << "\n";
	path.pb(x);
	if(x == dest) {
		// for(int i = 0 ; i < path.size() ; i++) {
		// 	cout << path[i] << " ";
		// }
		for(int i = 0 ; i < path.size()-1 ; i++) {
			//cout << path[i] << " ";
			int a = min(path[i],path[i+1]);
			int b = max(path[i] , path[i+1]);
			for(int i = 0 ; i < edgeTree.size() ; i++) {
				if(edgeTree[i].first == a && edgeTree[i].second == b) {
					maskMap[idx][i] = 1;
				}	
			}

		}
		return;
	}
	for(int i = 0; i < tree[x].size() ; i++) {
		if(tree[x][i] != par) {
			dfs(idx, tree[x][i] , x);
		}
	}
	path.pop_back();
}

ll rec(ll idx , ll mask) {
	// cout << idx << " " << mask << "\n";
	if(idx == n-1) {
		return (mask == (1LL << m) -1);
	}
	
	if(dp[idx][mask] != -1) {
		return dp[idx][mask];
	}

	ll a = rec(idx + 1 , mask);
	ll b = rec(idx + 1 , mask | edgeMask[idx]);

	return dp[idx][mask] = a+b;

}

int main()
{
	fast;

	cin >> n;
	tree.resize(n + 10);
	memset(dp , -1 , sizeof dp);
	
	for(int i = 0 ; i <n-1 ; i++) {
		int x,y;
		cin >> x >> y;
		tree[x].pb(y);
		tree[y].pb(x);
		int a = min(x,y);
		int b = max(x,y);
		edgeTree.pb({a,b});
	}
 	cin >> m ;
 	maskMap.resize(m ,vector<ll >(n-1 , 0));
 	edges.resize(m + 10);
 	for(int i = 0 ; i < m ; i++) {
 		cin >> edges[i].first >> edges[i].second; 
 	}

 	for(int i = 0 ; i < m ;  i++) {
 		src = edges[i].first;
 		dest = edges[i].second;
 		// cout << i << "\n";
 		dfs(i);
 		path.clear();
 		// cout << "\n";
 	}
 	// for(int i = 0  ; i < maskMap.size(); i++) {
 	// 	for(int j = 0 ; j < maskMap[i].size() ; j++) {
 	// 		cout << maskMap[i][j];
 	// 	}
 	// 	cout << "\n";
 	// }
 	for(int i = 0 ; i < n ; i++) {
 		ll temp = maskMap[0][i];
 		for(int j = 1 ; j  < m ; j++) {
 			temp = temp << 1;
 			temp = temp | maskMap[j][i];
 		}
 		edgeMask.pb(temp); 
 	}
 	cout << rec(0 , 0);




	return 0;
	
}


Measured memory_bytes: 418048