#include <bits/stdc++.h>

constexpr int N = 100005;

int n, m, q;
std::vector<int> t[N];

int dep[N], siz[N], son[N], fa[N];

void dfs1(int u) {
    siz[u] = 1;
    for (const int &v : t[u]) {
        if (v == fa[u])
            continue;
        dep[v] = dep[u] + 1;
        fa[v] = u;
        dfs1(v);
        siz[u] += siz[v];
        if (siz[v] > siz[son[u]]) son[u] = v;
    }
}

int dfn[N], rnk[N], top[N], tot;

void dfs2(int u, int tp) {
    dfn[u] = ++tot;
    rnk[tot] = u;
    top[u] = tp;
    if (son[u])
        dfs2(son[u], tp);
    for (const int &v : t[u]) {
        if (v == fa[u] || v == son[u])
            continue;
        dfs2(v, v);
    }
}

inline int lca(int x, int y) {
    int fx = top[x], fy = top[y];
    while (fx != fy) {
        if (dep[fx] > dep[fy])
            x = fa[fx], fx = top[x];
        else 
            y = fa[fy], fy = top[y];
    }
    return dep[x] < dep[y] ? x : y;
}

int c[N];
int st[25][N];

inline void st_init() {
    for (int i = 1; i <= m; i++)
        st[0][i] = c[i];
    for (int k = 1; k <= 20; k++)
        for (int i = 1; i + (1 << k) - 1 <= m; i++)
            st[k][i] = lca(st[k - 1][i], st[k - 1][i + (1 << (k - 1))]);
}

inline int lca_lr(int l, int r) {
    int k = std::__lg(r - l + 1);
    return lca(st[k][l], st[k][r - (1 << k) + 1]);
}

struct node {
    int l, r, v;
}tree[N << 2];

#define ls(p) (p << 1)
#define rs(p) (ls(p) | 1)
#define l(p)  tree[p].l
#define r(p)  tree[p].r
#define v(p)  tree[p].v

void build(int p, int l, int r) {
    l(p) = l, r(p) = r;
    if (l == r) return;
    int mid = (l + r) >> 1;
    build(ls(p), l, mid);
    build(rs(p), mid + 1, r);
}

void add(int p, int x, int vl) {
    if (x > r(p) || x < l(p))
        return;
    v(p) += vl;
    if (l(p) == r(p)) {
        assert(v(p) >= 0);
        return;
    }
    add(ls(p), x, vl);
    add(rs(p), x, vl); 
}

int sum(int p, int l, int r) {
    if (l > r(p) || r < l(p))
        return 0;
    if (l <= l(p) && r(p) <= r)
        return v(p);
    return sum(ls(p), l, r) + sum(rs(p), l, r);
}

struct odt_node {
    int l, r, v;
    odt_node(int _l = 0, int _r = 0, int _v = 0) {
        l = _l, r = _r, v = _v;
    }
    bool operator<(odt_node x) const {
        return l < x.l;
    }
};

std::set<odt_node> odt;

inline auto split(int x) {
    if (x > m) return odt.end();
    auto it = --odt.upper_bound(odt_node(x, 0, 0));
    if (it->l == x) 
        return it;
    int l = it->l, r = it->r, v = it->v;
    odt.erase(it);
    odt.insert(odt_node(l, x - 1, v));
    return odt.insert(odt_node(x, r, v)).first;
}

inline void assign(int l, int r, int v) {
    auto itr = split(r + 1), itl = split(l);
    for (auto it = itl; it != itr; it++)
        add(1, it->v, -(it->r - it->l + 1));
    odt.erase(itl, itr);
    odt.insert(odt_node(l, r, v));
    add(1, v, r - l + 1);
}

inline void ins(int id) {
    int x = c[id];
    int fx = top[x];
    while (x) {
        assign(dfn[fx], dfn[x], id);
        x = fa[fx], fx = top[x];
    }
}

std::vector<std::pair<int, int> > qs[N];
int ans[N];
int main() {
    std::cin >> n >> m >> q;
    for (int i = 1, u, v; i <= n - 1; i++) {
        std::cin >> u >> v;
        t[u].push_back(v);
        t[v].push_back(u);
    }
    dfs1(1);
    dfs2(1, 1);
    for (int i = 1; i <= m; i++)
        std::cin >> c[i];
    st_init();
    build(1, 1, m);
    odt.insert({1, m, 0});
    add(1, 0, m);
    for (int i = 1, l, r; i <= q; i++) {
        std::cin >> l >> r;
        qs[r].push_back({l, i});
    }
    for (int r = 1; r <= m; r++) {
        ins(r);
        for (const auto &[l, id] : qs[r]) 
            ans[id] = sum(1, l, r) - dep[lca_lr(l, r)];// std::cout << dep[lca_lr(l, r)] << '\n';
    }
    for (int i = 1; i <= q; i++)
        std::cout << ans[i] << '\n';
}