#include <bits/stdc++.h>

struct ST {
    std::vector<std::vector<int>> data;

    ST(const std::vector<int>& vec) {
        int lg = std::bit_width(vec.size());
        data.resize(lg);
        data[0] = vec;
        for (int k = 1; k < lg; k++) {
            data[k].resize(vec.size() - (1 << k) + 1);
            for (int i = 0; i < data[k].size(); i++) {
                data[k][i] = std::min(data[k - 1][i], data[k - 1][i + (1 << k - 1)]);
            }
        }
    }

    int get_min(int l, int r) {
        int k = std::bit_width<uint32_t>(r - l) - 1;
        return std::min(data[k][l], data[k][r - (1 << k)]);
    }
};

using u64 = uint64_t;

struct TreeBitset {
    using T = uint8_t;
    static constexpr int K = sizeof(T) * 8;
    std::vector<size_t> sz;
    std::vector<std::vector<T>> data;
    int lg;

    TreeBitset(int n) {
        for (int n2 = n; n2 > 1;) {
            n2 = (n2 - 1) / K + 1;
            sz.push_back(n2);
        }
        std::reverse(sz.begin(), sz.end());
        lg = sz.size();
        data.resize(lg);
        for (int i = 0; i < lg; i++) {
            data[i].assign(sz[i], 0);
        }
    }

    void update(int i, int val) {
        for (int k = lg - 1; k >= 0; k--) {
            auto [pos, ind] = div(i, K);
            val = bool(data[k][pos] = (data[k][pos] & (~(T(1) << ind))) | T(val) << ind);
            i /= K;
        }
    }

    int find_next(int i) {
        int k = lg - 1;
        while (k >= 0) {
            auto [pos, ind] = div(i, K);
            int ind2 = std::countr_zero<T>(data[k][pos] >> ind + 1 << ind + 1);
            if (ind2 != K) {
                i = pos * K + ind2;
                for (k++; k < lg; k++) {
                    i = i * K + std::countr_zero<T>(data[k][i]);
                }
                return i;
            }
            k--, i /= K;
        }
        if (data[lg - 1][0] & 1) {
            return 0;
        }
        return find_next(0);
    }

    int find_prev(int i) {
        int k = lg - 1;
        while (k >= 0) {
            auto [pos, ind] = div(i, K);
            int ind2 = (K - 1) - std::countl_zero<T>(T(data[k][pos] << (K - ind)) >> (K - ind));
            if (ind2 != -1) {
                i = pos * K + ind2;
                for (k++; k < lg; k++) {
                    i = i * K + ((K - 1) - std::countl_zero<T>(data[k][i]));
                }
                return i;
            }
            k--, i /= K;
        }
        if (data[lg - 1][sz[lg - 1] - 1] & T(1) << K - 1) {
            return sz[lg - 1] * K - 1;
        }
        return find_prev(sz[lg - 1] * K - 1);
    }
};

int32_t main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n, m, q;
    std::cin >> n >> m >> q;
    std::vector<std::vector<int>> gr(n);
    for (int i = 0; i < n - 1; i++) {
        int u, v;
        std::cin >> u >> v;
        u--;
        v--;
        gr[u].push_back(v);
        gr[v].push_back(u);
    }
    std::vector<int> input(m);
    for (auto& i : input) {
        std::cin >> i;
        i--;
    }

    std::vector<std::array<int, 3>> quer(q);
    for (int i = 0; i < q; i++) {
        auto& [l, r, id] = quer[i];
        std::cin >> l >> r;
        l--;
        id = i;
    }

    std::vector<int> eul_dp, tin(n), tout(n), depth(n);
    auto dfs = [&](auto dfs, int v, int f) -> void {
        tin[v] = eul_dp.size();
        eul_dp.push_back(depth[v]);
        for (int t : gr[v]) {
            if (t != f) {
                depth[t] = depth[v] + 1;
                dfs(dfs, t, v);
                eul_dp.push_back(depth[v]);
            }
        }
        tout[v] = eul_dp.size();
    };
    dfs(dfs, 0, -1);

    ST st(eul_dp);

    auto get_lca_depth = [&](int u, int v) {
        return st.get_min(std::min(tin[u], tin[v]), std::max(tin[u], tin[v]) + 1);
    };
    auto get_dist = [&](int u, int v) {
        return depth[u] + depth[v] - 2 * get_lca_depth(u, v);
    };
    auto get_dist_tin = [&](int u, int v) {
        return eul_dp[u] + eul_dp[v] - 2 * st.get_min(std::min(u, v), std::max(u, v) + 1);
    };

    constexpr int K = 330;
    std::sort(quer.begin(), quer.end(), [&](auto a, auto b) {
        auto [l1, r1, id1] = a;
        auto [l2, r2, id2] = b;
        if (l1 / K != l2 / K) {
            return l1 / K < l2 / K;
        }
        return (r1 < r2) != bool(l1 / K % 2);
    });

    std::vector<int> ord(m);
    std::iota(ord.begin(), ord.end(), 0);
    std::sort(ord.begin(), ord.end(), [&](int a, int b) { return tin[input[a]] < tin[input[b]]; });
    std::vector<int> pos(m);
    std::vector<int> ord_tin(m);
    for (int i = 0; i < m; i++) {
        pos[ord[i]] = i;
        ord_tin[i] = tin[input[ord[i]]];
    }

    TreeBitset tb(m);

    int64_t total_dlt = 0;
    int sum_dist = 0;
    auto add = [&](int t, int f) {
        total_dlt++;

        // auto it = set.insert(t);
        if (f == 1) {
            tb.update(t, 1);
        }
        int t1 = tb.find_prev(t);
        int t2 = tb.find_next(t);
        if (f == -1) {
            tb.update(t, 0);
        }
        sum_dist -= get_dist_tin(ord_tin[t1], ord_tin[t2]) * f;
        sum_dist += get_dist_tin(ord_tin[t1], ord_tin[t]) * f;
        sum_dist += get_dist_tin(ord_tin[t], ord_tin[t2]) * f;
    };
    int L = 0, R = 0;
    std::vector<int> ans(q);
    for (auto [l, r, id] : quer) {
        while (R < r) {
            add(pos[R++], 1);
        }
        while (l < L) {
            add(pos[--L], 1);
        }
        while (r < R) {
            add(pos[--R], -1);
        }
        while (L < l) {
            add(pos[L++], -1);
        }

        assert(total_dlt <= 1e8);
        ans[id] = sum_dist / 2 + 1;
    }

    for (int i = 0; i < q; i++) {
        std::cout << ans[i] << "\n";
    }

    return 0;
}