/*
これを入れて実行
g++ code.cpp
./a.out
 */
 
#include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
#include <cstring>
#include <queue>
#include <deque>
#include <stack>
#include <algorithm>
#include <utility>
#include <set>
#include <map>
#include <unordered_map>
#include <cmath>
#include <math.h>
#include <tuple>
#include <iomanip>
#include <bitset>
#include <functional>
#include <cassert>

#define all(x) (x).begin(),(x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
 
using namespace std;
typedef long long ll;
typedef long double ld;
 
int dy4[4] = {-1, 0, +1, 0};
int dx4[4] = {0, +1, 0, -1};
int dy8[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int dx8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
 
const long long INF = 1LL << 60;
const ll MOD = 1e9 + 7;
 
bool greaterSecond(const pair<int, int>& f, const pair<int, int>& s){
    return f.second > s.second;
}
 
ll gcd(ll a, ll b){
	if (b == 0)return a;
	return gcd(b, a % b);
}
 
ll lcm(ll a, ll b){
    return a / gcd(a, b) * b;
}

ll conbinationMemo[100][100];

void cmemoInit(){
    rep(i, 100){
        rep(j, 100){
            conbinationMemo[i][j] = -1;
        }
    }
}
 
ll nCr(ll n, ll r){
    if(conbinationMemo[n][r] != -1) return conbinationMemo[n][r];
    if(r == 0 || r == n){
        return 1;
    } else if(r == 1){
        return n;
    }
    return conbinationMemo[n][r] = (nCr(n - 1, r) + nCr(n - 1, r - 1));
}
 
ll nPr(ll n, ll r){
    r = n - r;
    ll ret = 1;
    for (ll i = n; i >= r + 1; i--) ret *= i;
    return ret;
}
//-----------------------ここから-----------
ll n;
ll m;
vector<ll> table[(2LL << 20) + 1];
vector<vector<pair<ll,ll>>> g;
vector<pair<ll,ll>> r;
vector<ll> bfs(ll start, ll goal){

    vector<int> visited(n, 0);
    queue<pair<ll,vector<ll>>> q;
    q.push({start, vector<ll>()});
    visited[start] = 1;
    while(!q.empty()){
        ll now = q.front().first;
        vector<ll> nowpath = q.front().second;
        q.pop();
        rep(i, g[now].size()){
            ll next = g[now][i].first;
            ll nextp = g[now][i].second;
            if(visited[next]) continue;
            vector<ll> nextpath = nowpath;
            nextpath.push_back(nextp);
            if(next == goal){
                return nextpath;
            }
            visited[next] = 1;
            q.push({next, nextpath});
        }
    }
}
int main(void){
    cin >> n;
    g.resize(n);
    rep(i, n - 1){
        ll a, b;
        cin >> a >> b;
        a--, b--;
        g[a].push_back({b, i});
        g[b].push_back({a, i});
    }
    cin >> m;
    r.resize(m);
    rep(i, m){
        ll a, b;
        cin >> a >> b;
        a--, b--;
        r[i] = {a, b};
    }

    vector<ll> path[51][51];
    rep(i, n){
        rep(j, n){
            if(i == j)continue;
            vector<ll> p = bfs(i, j);
            path[i][j] = p;
        }
    }

    ll ans = 0;

    for(ll bit = 0; bit < (1LL << m); bit++){
        vector<ll> totalcnt(n - 1, 0);
        ll sz = 0;
        rep(i, m){
            if(bit & (1LL << i)){
                pair<ll,ll> tmp = r[i];
                vector<ll> p = path[tmp.first][tmp.second];
                rep(j, p.size()){
                    totalcnt[p[j]]++;
                }
                sz++;
            }
        }
        if(sz == 0) continue;
        ll cnt = 0;
        rep(i, totalcnt.size()){
            if(totalcnt[i] > 0) cnt++;
        }

        ll tmpans = pow(2LL, n - 1 - cnt);

        if(sz % 2 == 0){
            ans -= tmpans;
        } else {
            ans += tmpans;
        }

    }
    cout << (ll)pow(2LL, n - 1) - ans << endl;
}



Measured memory_bytes: 53468