#include <bits/stdc++.h>
using namespace std;
#define repr(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) for(int i=0;i<n;i++)
#define reprrev(i,a,b) for(int i=b-1;i>=a;i--) // [a, b)
#define reprev(i,n) reprrev(i,0,n)
typedef long long ll;
typedef unsigned long long ull;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }

/* attention
    long longのシフト演算には気をつけよう
    タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
*/

const ll mod = 1e9+7;

void chmod(ll &M){
    if(M >= mod) M %= mod;
    else if(M < 0){
        M += (abs(M)/mod + 1)*mod;
        M %= mod;
    }
}

ll modpow(ll x, ll n){
    if(n==0) return 1;
    ll res=modpow(x, n/2);

    if(n%2==0) return res*res%mod;
    else return res*res%mod*x%mod;
}

int getl(int i, int N) { return i==0? N-1:i-1; };
int getr(int i, int N) { return i==N-1? 0:i+1; };


// 線分 ab の偏角 返り値は[-π, π]
double argument(const pair<double, double> &a, const pair<double, double> &b){
    double ax=a.first, ay=a.second, bx=b.first, by=b.second;
    return atan2(by-ay, bx-ax);
}

/* <-----------------------------------------------------------------------------------> */
/* <-----------------------------------------------------------------------------------> */
/* <-----------------------------------------------------------------------------------> */
/* <-----------------------------------------------------------------------------------> */


struct LCA {
    int n; // 頂点数
    int root; // 根
    int l; // floor(log(n))
    vector<vector<int>> const & adj; // 隣接リストへの参照
    vector<vector<int>> parent; // parent[k][v] := v から 2^k 個上にいった頂点の番号（根を通り過ぎるなら -1 ）
    vector<int> depth;

    // コンストラクタ
    LCA(int _n, int _root, vector<vector<int>> const & G) :n(_n), root(_root), adj(G) {
        l = 0;
        while((1<<l) < n) ++l;
        parent.resize(l+5, vector<int>(n, 0));
        depth.resize(n, 0);
    }

    // 深さをセットする
    void dfs(int now, int par, int dep) {
        parent[0][now] = par;
        depth[now] = dep;
        for(auto to: adj[now]) if (to != par) dfs(to, now, dep+1);
    }

    // 初期化
    void init() {
        dfs(root, -1, 0);
        // parent の設定
        for(int k=0; k+1<l; ++k) {
            for(int v=0; v<n; ++v) {
                if (parent[k][v] < 0) parent[k+1][v] = -1;
                else parent[k+1][v] = parent[k][parent[k][v]];
            }
        }
    }

    // u と v の LCA を求める
    int lca(int u, int v) {
        // 深い方が v になるようにする
        // u と v の深さが同じになるまで v に先祖を辿らせる
        if (depth[u] > depth[v]) swap(u, v);
        for(int k=0; k<l; ++k) {
            if ((depth[v] - depth[u]) >> k & 1) { v = parent[k][v]; }
        }
        if (u == v) return u;
        // 二分探索で LCA を求める
        for(int k=l-1; k>=0; --k) {
            if (parent[k][u] != parent[k][v]) {
                u = parent[k][u];
                v = parent[k][v];
            }
        }
        return parent[0][u];
    }
};

int n, m;
vector<vector<int>> seen(55, vector<int>(55, -1));
vector<vector<int>> adj;
vector<int> u, v;

void input() {
    cin >> n;
    adj.resize(n);
    rep(i, n-1) {
        int a, b; cin >> a >> b; --a; --b;
        adj[a].push_back(b);
        adj[b].push_back(a);
    }
    cin >> m;
    u.resize(m);
    v.resize(m);
    rep(i, m) { cin >> u[i] >> v[i]; --u[i]; --v[i]; }
}

void solve() {
    ll ans = 1;
    rep(i, n-1) ans *= 2LL;
    LCA lchan(n, 0, adj);
    lchan.init();

    vector<vector<int>> LLCA(n, vector<int>(n));
    rep(i, n) rep(j, n) LLCA[i][j] = lchan.lca(i, j);

    //rep(i, n) repr(j, i+1, n) cout << i << " " << j << " " << lchan.lca(i, j) << endl;
    int flg = 0;
    repr(bit, 1, 1<<m) {
        int cnt = __builtin_popcount(bit);
        ++flg;
        int k = 0;
        rep(i, m) if (bit&1<<i) {
            int left = u[i], right = v[i];
            int ca = LLCA[left][right];
            //cout << ca << " " << left << " " << right << endl;
            while(ca != left) {
                int pa = lchan.parent[0][left];
                assert(left>=0 && pa>=0);
                int minv = min(left, pa), maxv = max(left, pa);
                if (seen[minv][maxv]!=flg) { seen[minv][maxv] = flg; ++k; }
                left = lchan.parent[0][left];
            }
            while(ca != right) {
                int pa = lchan.parent[0][right];
                assert(right>=0 && pa>=0);
                // cout << "hoge";
                if(!(right>=0 && pa>=0)) continue;
                int minv = min(right, pa), maxv = max(right, pa);
                if (seen[minv][maxv]!=flg) { seen[minv][maxv] = flg; ++k; }
                right = lchan.parent[0][right];
            }
        }
        ll val = 1;
        rep(i, n-1-k) val *= 2;
        if (cnt%2) ans -= val;
        else ans += val;
    }
    cout << ans << endl;
}

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);

    input();
    solve();
    
    return 0;
}




Measured memory_bytes: 256