#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#define rep(i, a, b) for(int i=(a); i<(b); i++)
#define repi(i, a, b) for(int i=(a); i>(b); i--)
#define db(x) (cerr << #x << ": " << (x) << '\n')
#define sync ios_base::sync_with_stdio(false), cin.tie(NULL)
#define cps CLOCKS_PER_SEC
#define tests(t) int t; cin >> t; while(t--)
#define iceil(n, x) (((n) + (x) - 1) / (x))
#define ll long long
#define gcd __gcd
#define eb emplace_back
#define pb push_back
#define pf push_front
#define pob pop_back
#define pof pop_front
#define sz size()
#define all(v) (v).begin(), (v).end()
#define uni(v) sort(all(v)), (v).erase(unique(all(v)), (v).end())
#define pii pair<int, int>
#define vi vector<int>
#define vpii vector<pii>
#define vvi vector<vi>
#define fi first
#define se second
#define mt make_tuple
#define pqueue priority_queue
#define bitcount(x) __builtin_popcount(x)
#define PI acos(-1.0)
#define EPS 1e-9
#define mod 1000000007
using namespace std;

#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
    cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
    const char* comma = strchr(names + 1, ','); cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}

template<typename T1, typename T2>
ostream& operator << (ostream& os, const pair<T1, T2>& p) { return os << '(' << p.fi << ", " << p.se << ')'; }

template<typename T>
void printv(const T& v) { for(auto i : v) cerr << i << ' '; cerr << '\n'; }

template<typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;

template<typename T>
using maxpq = priority_queue<T>;

//All indexing is 0-based
using namespace __gnu_pbds;
template<class key, class cmp = std::less<key>>
using ordered_set = tree<key, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
//methods: find_by_order(k); & order_of_key(k);
//To make it an ordered_multiset, use pairs of (value, time_of_insertion)
//to distinguish values which are similar

template<class key, class value, class cmp = std::less<key>>
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;

//Returns no. of values x for which ceil(n / x) == y (y must be > 1).
inline ll CC(ll n, ll y) { return iceil(n, y-1) - iceil(n, y); }

//Returns no. of values x for which floor(n / x) == y
inline ll FF(ll n, ll y) { return n / y - n / (y+1); }

//a and b are assumed to be taken modulo p
inline int add(int a, int b, int p = mod){ int c = a + b; if(c >= p) c -= p; return c; }
inline int sub(int a, int b, int p = mod){ int c = a - b; if(c < 0) c += p; return c; }
inline int mul(int a, int b, int p = mod){ return (a * 1ll * b) % p; }

#define N 10005
#define int ll
// #define trace(...) 42

#define lgN 17
int n; //no. of nodes
vector<int> adj[N];
//int P[N]; // ancestor in the previous section
int lvl[N]; //level of the node in the tree
int dp[N][lgN]; //dp[i][j] = 2^j th parent of ith node
int par[N]; //Parent of the node
map<pii, int> edge;
vpii edges;

void dfs(int i, int p)
{
    for(int j : adj[i]){
        if(j != p){
            par[j] = i;
            lvl[j] = lvl[i] + 1;
            dfs(j, i);
        }
    }
}

void prep()
{
    par[0] = -1;
    lvl[0] = 0;
    dfs(0, -1);
  
    memset(dp, -1, sizeof dp);
  
    //The below computation can also be done while performing the dfs, since for
    //a node, all dp values for its ancestors would already have been computed.
    for(int j = 0; 1 << j < n; j++){
        for(int i = 0; i < n; i++){
            if(j == 0)                dp[i][j] = par[i];
            else if(dp[i][j-1] != -1) dp[i][j] = dp[dp[i][j-1]][j-1];
        }
    }
}

int lca(int p, int q) {
    if(lvl[p] < lvl[q]) swap(p, q);
    //Now, p lies below q.

    for(int i = lgN - 1; i >= 0; i--) 
        if(lvl[p] - (1 << i) >= lvl[q])
            p = dp[p][i];

    if(p == q) return p;

    for(int i = lgN - 1; i >= 0; i--) 
        if(dp[p][i] != -1 && dp[p][i] != dp[q][i])
            p = dp[p][i], q = dp[q][i];
    return par[p];
}

vi path(int a, int b) {
    int l = lca(a, b);
    vi ans;

    while(a != l) {
        ans.pb(edge[{par[a], a}]);
        a = par[a];
    }

    while(b != l) {
        ans.pb(edge[{par[b], b}]);
        b = par[b];
    }

    return ans;
}

int m, maskE[N];
int dp2[55][1 << 20];

int rec(int i, int mask) {
    // trace(i, mask);
    if(i == n-1) return mask == (1 << m) - 1;

    int& ans = dp2[i][mask];
    if(ans != -1) return ans;

    ans = 0;
    int u, v; tie(u, v) = edges[i];

    ans = rec(i+1, mask);
    ans += rec(i+1, mask | maskE[i]);

    // trace(i, mask, maskE[i], ans);

    return ans;
}

main()
{   
    #ifdef CP
        freopen("/home/tarun/Desktop/input.txt", "r", stdin);
     // freopen("/home/tarun/Desktop/output.txt", "w", stdout);
    #endif
    sync;
    clock_t clk = clock();
    cerr << "I will return...\n";

    cin >> n;
    rep(i, 0, n-1) {
        int u, v; cin >> u >> v; --u, --v;
        adj[u].pb(v);
        adj[v].pb(u);
        edge[{u, v}] = edge[{v, u}] = i;
        edges.pb({u, v});
    }
    prep();

    cin >> m;
    rep(i, 0, m) {
        int u, v; cin >> u >> v; --u, --v;
        for(int j : path(u, v)) {
            maskE[j] |= 1 << i;
        }
    }

    memset(dp2, -1, sizeof dp2);
    cout << rec(0, 0) << '\n';

    cerr << "...don't you ever hang your head.\n";
    cerr << "Time (in ms): " << (double)(clock() - clk) * 1000.0 / cps << '\n';
}

//Compile using:
//g++ -o filename.exe --std=c++11 filename.cpp
//Use -D CP for defining a macro CP in the local environment




Measured memory_bytes: 452480