#pragma GCC optimize("Ofast")
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"

using namespace std;

using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using i8 = int8_t;
using i32 = int32_t;
using i64 = int64_t;

constexpr char newl = '\n';
constexpr double eps = 1e-10;

#define FOR(i,a,b) for (int i = (a); i < (b); i++)
#define F0R(i,b) FOR(i,0,b)
#define RFO(i,a,b) for (int i = ((b)-1); i >=(a); i--)
#define RF0(i,b) RFO(i,0,b)
//#define fi first
//#define se second
#define debug(x) cout << #x << ": " << x << '\n';
#define rng(a) a.begin(),a.end()
#define rrng(a) a.rbegin(),a.rend()

template<typename T1, typename T2> inline void chmin(T1& a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> inline void chmax(T1& a, T2 b) { if (a < b) a = b; }
template<class T> void Print(vector<T> v) {
  F0R(i, v.size()) {
    cout << v[i] << ' ';
  }
  cout << newl;
}

#if 1

#ifdef __GNUC__
// __builtin_popcount
// __builtin_popcountl
// __builtin_popcountll
constexpr auto popcount = __builtin_popcountll;
#else
// 立っているビットを数える
constexpr int popcount(u64 x)
{
  x = (x & 0x5555555555555555) + (x >> 1 & 0x5555555555555555);
  x = (x & 0x3333333333333333) + (x >> 2 & 0x3333333333333333);
  x = (x & 0x0f0f0f0f0f0f0f0f) + (x >> 4 & 0x0f0f0f0f0f0f0f0f);
  x = (x & 0x00ff00ff00ff00ff) + (x >> 8 & 0x00ff00ff00ff00ff);
  x = (x & 0x0000ffff0000ffff) + (x >> 16 & 0x0000ffff0000ffff);
  return (int)((x & 0x00000000ffffffff) + (x >> 32 & 0x00000000ffffffff));
}
#endif

int next_combination(int sub) {
  int x = sub & -sub, y = sub + x;
  return (((sub & ~y) / x) >> 1) | y;
}

// INSERT ABOVE HERE
signed main() {
  cin.tie(0);
  ios_base::sync_with_stdio(false);

  int N;
  cin >> N;
  vector<vector<pair<int, int>>> gs(N);
  F0R(i, N - 1) {
    int a, b;
    cin >> a >> b;
    a--; b--;
    gs[a].emplace_back(i, b);
    gs[b].emplace_back(i, a);
  }

  int M;
  cin >> M;
  vector<u64> cs(M);  // bitで表した辺の集合
  F0R(i, M) {
    int u, v;
    cin >> u >> v;
    u--; v--;

    // 制約は、辺の集合に変換する
    auto dfs = [&](auto dfs, int v, int p, int dest)->u64 {

      for (auto pair : gs[v]) {
        auto c = pair.second;
        if (c == p) continue;

        if (c == dest) {
          return (u64)1 << pair.first;
        }

        auto r = dfs(dfs, c, v, dest);
        if (r) return r | ((u64)1 << pair.first);
      }
      return 0;
    };
    cs[i] = dfs(dfs, u, -1, v);
    //cout << bitset<64>(cs[i]) << newl;
  }

  i64 result = pow(2, N - 1);

  // 解説を読む:
  // 包除原理を使う。

  // まず一つの制約を満たさない（制約のパスが全て白）数を、引いていく

  // 引き過ぎたので、2つの制約を同時に満たさない数を、足す

  // 足しすぎたので、3つの制約を…

  // という風に、足す引くを交互にやっていくことで、最終的に
  // 1つの制約を満たさない、のorが取れ、「いずれか」１つの制約を満たさない、になる

  // 「ありうる全ての場合の数」-「いずれか1つ以上の制約を満たさない数」
  // ＝「全ての制約を満たす数」

  // まとめる数
  FOR(gc, 1, cs.size() + 1) {

    //debug(gc);
    for (int bit = (1 << gc) - 1; bit < (1 << cs.size())
      ; bit = next_combination(bit)) {
      u64 a = 0;
      auto b = bit;
      for (int j = 0; b; b >>= 1, j++) {
        if (b & 1) {
          a |= cs[j];
          //cout << j << ' ';
        }
      }
      //cout << newl;
      if (gc & 1) result -= pow(2, N - 1 - popcount(a));
      else result += pow(2, N - 1 - popcount(a));
    }
  }

  cout << result;
}
#endif


Measured memory_bytes: 256