#include<bits/stdc++.h>

using namespace std;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
typedef long long ll;
#define int ll
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

#define pb push_back
#define all(x) x.begin(), x.end()
#define sz(x) (int)x.size()
#define mispertion ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define F first
#define S second
#define getlast(s) (*s.rbegin())
#define debg cout << "OK\n"

const ld PI = 3.1415926535;
const int N = 5e5 + 1;
const int M = 50 + 1;
const int mod = 1e9+7;
const int infi = INT_MAX;
const ll infl = LLONG_MAX;
const int P = 31;

int mult(int a, int b) {
    return a * 1LL * b % mod;
}

int sum(int a, int b) { 
    if (a + b < 0)
        return a + b + mod;
    if (a + b >= mod)
        return a + b - mod;
    return a + b;
}

ll binpow(ll a, ll n) {
    if (n == 0)
        return 1;
    if (n % 2 == 1) {
        return binpow(a, n - 1) * a % mod;
    } else {
        ll b = binpow(a, n / 2);
        return b * b % mod;
    }
}

struct fenwick{
    int f[N];
    
    void add(int i, int x){
        for(; i < N; i = (i | (i + 1)))
            f[i] += x;
    }
    
    int get(int r){
        int ret = 0;
        for(; r >= 0; r = (r & (r + 1)) - 1)
            ret += f[r];
        return ret;
    }

    int get(int l, int r){
        return get(r) - get(l - 1);
    }
};

int n, m, q, c[N], sz[N], d[N], h[N], cmp[N], par[N], cur;
vector<int> g[N];
set<pair<pii, int>> st[N];
vector<int> sp[N];
fenwick f;

void dfs(int v, int p){
    par[v] = p;
    sz[v] = 1;
    for(auto u : g[v]){
        if(u == p) continue;
        d[u] = d[v] + 1;
        dfs(u, v);
        sz[v] += sz[u];
    }
}

void dfs1(int v, int r){
    h[v] = r;
    sp[r].pb(v);
    int mxu = -1;
    for(auto u : g[v]){
        if(u == par[v]) continue;
        if(mxu == -1 || sz[mxu] < sz[u])
            mxu = u;
    }
    if(mxu != -1){
        for(auto u : g[v]){
            if(u == par[v]) continue;
            dfs1(u, (u == mxu ? r : u));
        }
    }
}

void upd(int i, int l, int r, int x){
    auto s = st[i].upper_bound({{l, -1}, -1});
    vector<pair<pii, int>> td = {};
    for(auto it = s; it != st[i].end(); it++){
        if(it->F.S > r) break;
        f.add(it->S, -(it->F.S - it->F.F + 1));
        td.pb(*it);
    }
    for(auto e : td)
        st[i].erase(e);
    s = st[i].upper_bound({{l, -1}, -1});
    if(s != st[i].end()){
        if(s->F.F <= r){
            f.add(s->S, -(r - s->F.F + 1));
            auto par = *s;
            st[i].erase(s);
            st[i].insert({{r + 1, par.F.S}, par.S});
        }
    }
    s = st[i].upper_bound({{l, -1}, -1});
    if(s != st[i].begin()){
        s--;
        if(l <= s->F.S){
            f.add(s->S, -(s->F.S - l + 1));
            auto par = *s;
            st[i].erase(s);
            st[i].insert({{par.F.F, l - 1}, par.S});
        }
    }
    f.add(x, r - l + 1);
    st[i].insert({{l, r}, x});
}

void upd1(int u, int v, int x){
    while(true){
        if(h[v] == h[u]){
            if(d[u] > d[v])
                swap(u, v);
            int l = lower_bound(all(sp[h[v]]), u) - sp[h[v]].begin();
            int r = lower_bound(all(sp[h[v]]), v) - sp[h[v]].begin();
            upd(h[v], l, r, x);
            break;
        }
        if(d[h[v]] < d[h[u]])
            swap(u, v);
        int r = lower_bound(all(sp[h[v]]), v) - sp[h[v]].begin();
        upd(h[v], 0, r, x);
        v = par[h[v]];
    }
}

vector<pii> rs[N];
int ans[N];

void solve(){
    cin >> n >> m >> q;
    for(int i = 1; i < n; i++){
        int u, v;
        cin >> u >> v;
        g[v].pb(u);
        g[u].pb(v);
    }
    for(int i = 1; i <= m; i++){
        cin >> c[i];
    }
    for(int i = 1; i <= q; i++){
        int l, r;
        cin >> l >> r;
        rs[r].pb({l, i});
    }
    dfs(1, 0);
    dfs1(1, 1);
    for(int r = 1; r <= m; r++){
        if(r != 1){
            upd1(c[r - 1], c[r], r - 1);
        }
        for(auto e : rs[r]){
            if(e.F == r){
                ans[e.S] = 1;
                continue;
            }
            ans[e.S] = f.get(e.F, m);
        }
    }
    for(int i = 1; i <= q; i++){
        cout << ans[i] << '\n';
    }
}   

signed main() {
    mispertion;
    int t = 1;
    //cin >> t;
    while(t--){
        solve();
    }
    return 0;
}