/*
Author: Nguyen Chi Thanh - High School for the Gifted - VNU.HCM (i2528)
*/
#include <bits/stdc++.h>
using namespace std;
/* START OF TEMPALTE */
#define int long long
#define ll long long
#define ull unsigned long long
#define ld long double
#define pii pair<int, int>
#define pll pair<ll, ll>
#define fi first
#define se second
#define popcount __builtin_popcountll
#define all(x) (x).begin(), (x).end()
#define BIT(x, i) (((x) >> (i)) & 1)
#define MASK(x) (1ll << (x))
#define SZ(a) ((int32_t)a.size())
#define debug(a, l, r) {for (int _i = (l); _i <= (r); ++_i) cout << (a)[_i] << ' '; cout << '\n';}
template<class X, class Y>
bool minimize(X &x, const Y &y) {
if (x > y) {
x = y;
return true;
} else return false;
}
template<class X, class Y>
bool maximize(X &x, const Y &y) {
if (x < y) {
x = y;
return true;
} else return false;
}
/* END OF TEMPALTE */
const int MAXN = 2e5 + 5;
const int LOG = 20;
int n, m, q, spots[MAXN], sz[MAXN], parent[MAXN];
int head[MAXN], chain[MAXN], curpos, curchain, pos[MAXN];
int mn[LOG][MAXN], mx[LOG][MAXN], lg[MAXN], depth[MAXN];
ll ans[MAXN];
vector<int> adj[MAXN];
vector<pii> queries[MAXN];
struct FenwickTree {
int n;
vector<ll> fen;
FenwickTree() {
}
void init(int _n) {
n = _n;
fen.resize(n + 5, 0);
}
void update(int idx, ll v) {
if (idx == 0) return;
for (int i = idx; i <= n; i += i & -i)
fen[i] += v;
}
ll get(int idx) {
ll sum = 0;
for (int i = idx; i; i -= i & -i)
sum += fen[i];
return sum;
}
ll query(int l, int r) {
return get(r) - get(l - 1);
}
};
FenwickTree bit;
struct Range {
int l, r, x;
bool operator < (const Range &other) const {
if (l == other.l && r == other.r) return x < other.x;
if (l == other.l) return r < other.r;
return l < other.l;
}
};
struct RangeContainer{
set<Range> st;
RangeContainer () {
st.clear();
}
void add(Range x) {
st.insert(x);
int len = (x.r - x.l + 1);
int val = x.x;
bit.update(val, len);
}
void del(Range x) {
st.erase(st.find(x));
int len = (x.r - x.l + 1);
int val = x.x;
bit.update(val, -len);
}
bool intersect(Range x, Range y) {
int a = x.l, b = x.r;
int c = y.l, d = y.r;
if (a > d || b < c) return 0;
return 1;
}
void rangeSet(int L, int R, int x) {
vector<Range> added, deleted;
auto it = st.upper_bound({L, (int)2e9, (int)2e9});
if (it != st.begin()) --it;
for (; it != st.end(); ++it) {
Range tmp = *it;
if (tmp.l > R) break;
if (intersect(tmp, {L, R, x})) {
int l = tmp.l, r = tmp.r, val = tmp.x;
if (l < L) added.push_back({l, L - 1, val});
if (R < r) added.push_back({R + 1, r, val});
deleted.push_back(tmp);
}
}
added.push_back({L, R, x});
for (auto x : deleted) del(x);
sort(all(added));
vector<Range> merged;
for (auto cur : added) {
if (merged.empty()) merged.push_back(cur);
else {
Range &last = merged.back();
if (last.r + 1 == cur.l && last.x == cur.x) {
last.r = cur.r;
} else {
merged.push_back(cur);
}
}
}
auto jt = st.lower_bound({L, -1, -1});
if (jt != st.begin()) {
auto prv = prev(jt);
if (prv->r + 1 == merged[0].l && prv->x == merged[0].x) {
Range tmp = *prv;
del(tmp);
merged[0].l = tmp.l;
}
}
jt = st.lower_bound({R + 1, -1, -1});
if (jt != st.end()) {
if (merged.back().r + 1 == jt->l && merged.back().x == jt->x) {
Range tmp = *jt;
del(tmp);
merged.back().r = tmp.r;
}
}
for (auto x : merged) add(x);
}
};
RangeContainer ds;
void buildSparseTable() {
lg[1] = 0;
for (int i = 2; i <= m; ++i) lg[i] = lg[i >> 1] + 1;
for (int i = 1; i <= m; ++i) {
mn[0][i] = spots[i];
mx[0][i] = spots[i];
}
for (int k = 1; k < LOG; ++k) {
for (int i = 1; i + (1 << k) - 1 <= m; ++i) {
int u = mn[k - 1][i];
int v = mn[k - 1][i + (1 << (k - 1))];
mn[k][i] = (pos[u] < pos[v] ? u : v);
u = mx[k - 1][i];
v = mx[k - 1][i + (1 << (k - 1))];
mx[k][i] = (pos[u] > pos[v] ? u : v);
}
}
}
int queryMin(int l, int r) {
int k = lg[r - l + 1];
int u = mn[k][l];
int v = mn[k][r - (1 << k) + 1];
return (pos[u] < pos[v] ? u : v);
}
int queryMax(int l, int r) {
int k = lg[r - l + 1];
int u = mx[k][l];
int v = mx[k][r - (1 << k) + 1];
return (pos[u] > pos[v] ? u : v);
}
void init() {
cin >> n >> m >> q;
bit.init(n);
ds.add({1, n, 0});
for (int i = 1; i < n; ++i) {
int u, v; cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= m; ++i) cin >> spots[i];
for (int i = 1; i <= q; ++i) {
int l, r; cin >> l >> r;
queries[r].push_back({l, i});
}
}
void dfs(int u, int par = 0) {
sz[u] = 1;
for (int v : adj[u]) {
if (v == par) continue;
parent[v] = u;
depth[v] = depth[u] + 1;
dfs(v, u);
sz[u] += sz[v];
}
}
void hld(int u, int par = 0) {
if (!head[curchain]) {
head[curchain] = u;
}
chain[u] = curchain;
pos[u] = curpos;
++curpos;
int nxt = 0;
for (int v : adj[u]) {
if (v == par) continue;
if (nxt == 0 || sz[v] > sz[nxt]) nxt = v;
}
if (nxt) hld(nxt, u);
for (int v : adj[u]) {
if (v == par || v == nxt) continue;
++curchain;
hld(v, u);
}
}
int updatePath(int u, int v, int x) {
int res = 0;
while (chain[u] != chain[v]) {
if (chain[u] > chain[v]) {
ds.rangeSet(pos[head[chain[u]]], pos[u], x);
u = parent[head[chain[u]]];
}
else {
ds.rangeSet(pos[head[chain[v]]], pos[v], x);
v = parent[head[chain[v]]];
}
}
if (sz[u] > sz[v]) ds.rangeSet(pos[u], pos[v], x);
else ds.rangeSet(pos[v], pos[u], x);
return res;
}
int lca(int u, int v) {
while (chain[u] != chain[v]) {
if (chain[u] > chain[v])
u = parent[head[chain[u]]];
else
v = parent[head[chain[v]]];
}
return (sz[u] > sz[v] ? u : v);
}
void solve() {
dfs(1);
curpos = 1; curchain = 1;
hld(1);
buildSparseTable();
for (int r = 1; r <= m; ++r) {
updatePath(1, spots[r], r);
for (auto &qry : queries[r]) {
int l = qry.fi, id = qry.se;
int k = lca(queryMin(l, r), queryMax(l, r));
// cout << l << ' ' << r << ' ' << k << '\n';
ans[id] = bit.query(l, r) - depth[k];
}
}
for (int i = 1; i <= q; ++i)
cout << ans[i] << '\n';
}
signed main() {
#ifdef NCTHANH
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(0);
cin.tie(nullptr); cout.tie(nullptr);
init();
solve();
return 0;
}
