#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <utility>
#include <cmath>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <tuple>
#include <numeric>
#include <functional>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define exrep(i, a, b) for(ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll mod = 1000000007;
const ll INF = 1e16;
const ll MAX_V = 200010;
const ll MAX_LOG_V = 30;

struct Edge {
    ll to, cost;
    Edge(ll to, ll cost): to(to), cost(cost) {}
};

vector<vector<Edge>> G;
ll parent[MAX_LOG_V][MAX_V];  // parent[k][v] : 親を2^k回辿って到達する頂点(根を通り過ぎる場合は-1)
ll depth[MAX_V];  // depth[v] : 頂点vの深さ

void dfs(ll v, ll p = -1, ll d = 0) {
    // 行きの処理はこのへんに書く
    parent[0][v] = p;
    depth[v] = d;
    for(Edge e : G[v]) {
        if(e.to == p) {
            continue;
        }
        dfs(e.to, v, d+1);
        // 帰りの処理はこのへんに書く
    }
}

ll LCA(ll u, ll v) {  // uとvのLCAを求める
    // uとvの深さが同じになるまで親を辿る
    if(depth[u] > depth[v]) {
        swap(u, v);
    }
    rep(k, MAX_LOG_V) {
        if((depth[v] - depth[u]) & 1LL<<k) {
            v = parent[k][v];
        }
    }
    if(u == v) {
        return u;
    }
    // 二分探索でLCAを求める
    for(ll k = MAX_LOG_V-1; k >= 0; k--) {
        if(parent[k][u] != parent[k][v]) {
            u = parent[k][u];
            v = parent[k][v];
        }
    }
    return parent[0][u];
}

ll dist(ll u, ll v) {  // u-vパスの長さを求める
    return depth[u] + depth[v] - 2*depth[LCA(u, v)];
}

bool isIn(ll u, ll v, ll x) {  // 頂点xがu-vパスに含まれるならtrue
    return dist(u, x) + dist(x, v) == dist(u, v);
}

ll countBit(ll b) {  // bの立っているbitの数を返す
    ll res = 0;
    rep(i, 60) {
        if(b & 1LL<<i) {
            res++;
        }
    }
    return res;
}

int main() {
    ll n;
    cin >> n;    
    
    G.resize(n);
    vl a(n-1), b(n-1);
    rep(i, n-1) {
        cin >> a[i] >> b[i];
        a[i]--;  b[i]--;
        G[a[i]].emplace_back(b[i], 1);
        G[b[i]].emplace_back(a[i], 1);
    }

    // parent[0]とdepthを初期化
    const ll root = 0;
    dfs(root);

    // parentを初期化
    rep(k, MAX_LOG_V-1) {
        rep(v, n) {
            if(parent[k][v] < 0) {
                parent[k+1][v] = -1;
            }
            else {
                parent[k+1][v] = parent[k][parent[k][v]];
            }
        }
    }

    ll m;
    cin >> m;
    vl e(m);  // e[i] : i番目の制約で白く塗られる辺の集合
    rep(i, m) {
        ll u, v;
        cin >> u >> v;
        u--;  v--;
        rep(j, n-1) {
            if(isIn(u, v, a[j]) && isIn(u, v, b[j])) {  // a[j]もb[j]もu-vパス上なら辺jは白く塗られる
                e[i] |= 1LL<<j;
            }
        }
    }

    ll ans = 0;
    rep(b, 1<<m) {
        ll s = 0;
        rep(i, m) {
            if(b & 1<<i) {
                s |= e[i];
            }
        }
        if(countBit(b)%2 == 0) {
            ans += 1LL<<(n-1 - countBit(s));
        }
        else {
            ans -= 1LL<<(n-1 - countBit(s));
        }
    }

    out(ans);
    re0;
}

Measured memory_bytes: 3768