#include <bits/stdc++.h>
using namespace std;
using ll = long long;

constexpr int N = 7e5 + 10;
int n; vector<int> G[N];

namespace Tree {
  int dep[N], siz[N], son[N], fa[N], top[N], dfn[N], dn;
  inline void dfs1(int u) {
    son[u] = -1, siz[u] = 1;
    for(auto v : G[u]) {
      if(v == fa[u]) continue;
      fa[v] = u, dep[v] = dep[u] + 1;
      dfs1(v);
      siz[u] += siz[v];
      if(son[u] == -1 || siz[son[u]] < siz[v]) son[u] = v;
    }
  }
  int seq[N << 1], m, fir[N];
  inline void dfs2(int u, int t) {
    top[u] = t;
    dfn[u] = ++dn;
    seq[++m] = u; fir[u] = m;
    if(son[u] == -1) return;
    dfs2(son[u], t);
    seq[++m] = u;
    for(auto v : G[u]) {
      if(v == fa[u] || v == son[u]) continue;
      dfs2(v, v);
      seq[++m] = u;
    }
  }
  inline bool subt(int u, int v) {
    return dfn[u] <= dfn[v] && dfn[v] < dfn[u] + siz[u];
  }

  int st[21][N << 1];
  inline void buildst() {
    for(int i = 1; i <= m; i++) {
      st[0][i] = seq[i];
    }
    for(int i = 1; i <= 20; i++) {
      for(int j = 1; j + (1 << i) - 1 <= m; j++) {
        int l = st[i - 1][j], r = st[i - 1][j + (1 << i - 1)];
        st[i][j] = dep[l] < dep[r] ? l : r;
      }
    }
  }
  inline int lca(int u, int v) {
    int l = fir[u], r = fir[v];
    if(l > r) swap(l, r);
    int L = __lg(r - l + 1);
    int x = st[L][l], y = st[L][r - (1 << L) + 1];
    return dep[x] < dep[y] ? x : y;
  }

  void build() {
    dfs1(1), dfs2(1, 1);
    assert(m == 2 * n - 1);
    buildst();
  }
}
using Tree::subt, Tree::lca;
int m, Q, a[N];

struct Info {
  int A, res;
  int id, l, r;
};
vector<Info> res;
struct SegmentTree {
  Info t[N << 2];
  inline int calc(int k, int l, int r, int p) {
    if(l == r) return subt(t[k].A, p);
    // if(subt(p, t[k].A) && p != t[k].A) return 0;
    int mid = l + r >> 1;
    // if(subt(p, t[k << 1].A) && p != t[k << 1].A) return calc(k << 1 | 1, mid + 1, r, p);
    // else return calc(k << 1, l, mid, p) + t[k].res - t[k << 1].res;
    if(subt(t[k << 1].A, p)) return calc(k << 1, l, mid, p) + t[k].res - t[k << 1].res;
    else return calc(k << 1 | 1, mid + 1, r, lca(t[k << 1].A, p));
  }
  inline void build(int k, int l, int r) {
    t[k].id = k, t[k].l = l, t[k].r = r;
    if(l == r) {
      t[k].A = a[l];
      t[k].res = 1;
      return;
    }
    int mid = l + r >> 1;
    build(k << 1, l, mid);
    build(k << 1 | 1, mid + 1, r);
    t[k].A = lca(t[k << 1].A, t[k << 1 | 1].A);
    t[k].res = t[k << 1].res + calc(k << 1 | 1, mid + 1, r, t[k << 1].A);
  }
  inline void query(int k, int l, int r, int x, int y) {
    if(x <= l && r <= y) return res.push_back(t[k]), void();
    int mid = l + r >> 1;
    if(x <= mid) query(k << 1, l, mid, x, y);
    if(mid < y) query(k << 1 | 1, mid + 1, r, x, y);
  }
} tr;

int L[N], R[N];

inline void read(int &x) {
  char ch = getchar(); x = 0;
  while(!isdigit(ch)) ch = getchar();
  while(isdigit(ch)) x = x * 10 + (ch ^ 48), ch = getchar();
}

int main() {
  // freopen("tree.in", "r", stdin);
  // freopen("tree.out", "w", stdout);
  // ios::sync_with_stdio(false);
  // cin.tie(nullptr), cout.tie(nullptr);
  
  read(n), read(m), read(Q);
  for(int i = 1; i < n; i++) {
    int u, v; read(u), read(v);
    G[u].push_back(v), G[v].push_back(u);
  }
  Tree::build();
  for(int i = 1; i <= m; i++) {
    read(a[i]);
  }
  tr.build(1, 1, m);
  while(Q--) {
    int k; read(k);
    res.clear();
    vector<pair<int, int>> S;
    for(int i = 1; i <= k; i++) {
      read(L[i]), read(R[i]);
      S.emplace_back(L[i], R[i]);
    }
    sort(S.begin(), S.end());
    for(auto [l, r] : S) {
      tr.query(1, 1, m, l, r);
    }
    for(int i = 1; i < res.size(); i++) {
      res[i].A = lca(res[i - 1].A, res[i].A);
      res[i].res = res[i - 1].res + tr.calc(res[i].id, res[i].l, res[i].r, res[i - 1].A);
    }
    printf("%d\n", res.back().res);
  }
  // cerr << clock() * 1e3 / CLOCKS_PER_SEC << " ms\n";
}