#include <bits/stdc++.h>
    
using namespace std;
    
typedef long long ll;
const int  N = 2e5 + 12, MOD = (int)1e9 + 7;

#pragma GCC optimize ("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
const int L = 17;
int n, m, q, tin[N], tout[N], timer, dep[N], s[N], up[N][18], ver[N * 2];
vector<int> g[N];

void dfs(int v, int pr = 1) {
    tin[v] = ++timer;
    s[v] = 1;
    up[v][0] = pr;
    ver[timer] = v;
    for(int i = 1; i < L; ++i) {
        up[v][i] = up[up[v][i - 1]][i - 1];
    }
    for(int to:g[v]) {
        if(to != pr) {
            dep[to] = dep[v] + 1;
            dfs(to, v);
            s[v] += s[to];
        }
    }
    tout[v] = ++timer;
}
bool is(int v, int u) {
    return (tin[v] <= tin[u] && tout[v] >= tout[u]);
}
int lca(int v, int u) {
    return min(u, v);
    if(is(v, u)) return v;
    if(is(u, v)) return u;
    for(int i = L - 1; i >= 0; i--) {
        if(!is(up[v][i], u)) {
            v = up[v][i];
        }
    }
    return up[v][0];
}
int  c[N];
pair<int, int> t[N * 4];
void build(int v = 1, int tl = 1, int tr = m - 1) {
    if(tl == tr) {
        int x = lca(c[tl], c[tl + 1]);
        t[v] = {dep[x], x};
    } else {
        int tm = (tl + tr) >> 1;
        build(v + v, tl, tm);
        build(v + v + 1, tm + 1, tr);
        t[v] = min(t[v + v], t[v + v + 1]);
    }
}
const int inf = 1e9;
pair<int, int> get(int l, int r, int v = 1, int tl = 1, int tr = m - 1) {
    if(l > r || tl > r || l > tr) return {inf, inf};
    if(tl >= l && tr <= r) return t[v];
    int tm = (tl + tr) >> 1;
    return min(get(l, r, v + v, tl, tm), get(l, r, v + v + 1, tm + 1, tr));
}
struct query{
    int l, r, id;
};
vector<query> v;
int res[N];
int bl = 316;

bool cmp(query x,query y){
    if(x.l / bl != y.l / bl) return x.l < y.l;
    return x.r < y.r;
}

multiset<int> cur;
int ans = 0;
int find(int x, int y) {
    return dep[ver[y]] - dep[lca(ver[x], ver[y])];
}
void add(int v) {
    v = c[v];
    int t = tin[v];
    if(cur.count(t)) {
        cur.insert(t);
        return;
    }
    if(cur.empty() || t < (*cur.begin())) {
        if(!cur.empty()) {
            ans -= dep[ver[*cur.begin()]];
            ans += find(t, (*cur.begin()));
        }
        ans += dep[v];
        cur.insert(t);
    } else {
        auto it = cur.upper_bound(t);
        auto it1 = cur.lower_bound(t);
        it1--;
        ans += find(*it1, t);
        // cout << ver[*it1] << ' ' << ver[t] << ' ' << find(*it1, t) << '\n';
        if(it != cur.end()) {
            ans += find(t, *it);
            ans -= find(*it1, *it);
        }
        cur.insert(t);
    }
}
void del(int v) {
    v = c[v];
    int t = tin[v];
    cur.erase(cur.find(t));
    if(cur.count(t)) {
        return;
    }
    if(cur.empty() || t < (*cur.begin())) {
        if(!cur.empty()) {
            ans += dep[ver[*cur.begin()]];
            ans -= find(t, (*cur.begin()));
        }
        ans -= dep[v];
    } else {
        auto it = cur.upper_bound(t);
        auto it1 = cur.lower_bound(t);
        it1--;
        ans -= find(*it1, t);
        // cout << ver[*it1] << ' ' << ver[t] << ' ' << find(*it1, t) << '\n';
        if(it != cur.end()) {
            ans -= find(t, *it);
            ans += find(*it1, *it);
        }
    }
}
void test() {
    cin >> n >> m >> q;
    for(int i = 1; i <= n - 1; i++) {
        int x, y;
        cin >> x >> y;
        g[x].push_back(y);
        g[y].push_back(x);
    }
    dep[1] = 1;
    dfs(1);
    for(int i = 1; i <= m; i++) {
        cin >> c[i];
    }
    if(m > 1) build();
    for(int i = 1; i <= q; i++) {
        query f;
        int l, r;
        cin >> l >> r;
        if(l == r) {
            res[i] = 1;
            continue;
        }
        f.l = l;
        f.r = r;
        f.id = i;
        v.push_back(f);
    }
    sort(v.begin(), v.end(), cmp);
    int l = 1, r = 0;
    for(int i = 0; i < (int)v.size(); i++) {
        while(l > v[i].l) add(--l);
        while(r < v[i].r) add(++r);
        while(r > v[i].r) del(r--);
        while(l < v[i].l) del(l++);
        int x = get(v[i].l, v[i].r - 1).second;
        res[v[i].id] = ans - dep[x] + 1;
    }
    for(int i = 1; i <= q; i++) {
        cout << res[i] << '\n';
    }
}
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0); 
    
    int t = 1; 
    // cin >> t;
    
    while(t--) 
        test();
    return 0;
}