#include <bits/stdc++.h>

using namespace std;
constexpr int INF = 1e9 + 7;
constexpr int K = 21;

struct Fenwick {
    int n;
    vector<int> f;

    Fenwick(int n) : n(n), f(n) {}

    void upd(int i, int x) {
        for (; i < n; i |= i + 1)f[i] += x;
    }

    int get(int i) {
        int res = 0;
        for (; ~i; i &= i + 1, --i)res += f[i];
        return res;
    }

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

void solve() {
    int n, k, q;
    cin >> n >> k >> q;
    vector<vector<int>> g(n);
    for (int i = 0; i < n - 1; ++i) {
        int u, v;
        cin >> u >> v;
        --u, --v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    vector<int> pos(n);
    {
        vector<char> used(n);
        queue<int> q;
        q.push(0);
        used[0] = 1;
        int cur = 0;
        while (q.size()) {
            int v = q.front();
            pos[v] = cur++;
            q.pop();
            for (auto to: g[v]) {
                if (!used[to]) {
                    used[to] = 1;
                    q.push(to);
                }
            }
        }
    }
    vector<int> par(n);
    vector<array<array<int, 2>, K>> dp(n);
    auto dfs = [&](auto &&dfs, int v, int p) -> void {
        for (int i = 0; i < K; ++i)dp[v][i] = {INF, -INF};
        dp[v][0] = {pos[v], pos[v]};
        for (auto to: g[v]) {
            if (to == p)continue;
            par[to] = v;
            dfs(dfs, to, v);
            for (int i = 1; i < K; ++i) {
                dp[v][i][0] = min(dp[v][i][0], dp[to][i - 1][0]);
                dp[v][i][1] = max(dp[v][i][1], dp[to][i - 1][1]);
            }
        }
    };
    dfs(dfs, 0, -1);
    vector<vector<array<int, 2>>> Q(n);
    vector<int> res(q);
    for (int i = 0; i < q; ++i) {
        int l, r;
        cin >> l >> r;
        --l, --r;
        Q[r].push_back({l, i});
    }
    Fenwick f(n);
    set<array<int, 3>> s;
    auto add = [&](array<int, 3> r) {
        if (~r[2])f.upd(r[2], r[1] - r[0]);
        s.insert(r);
    };
    auto del = [&](array<int, 3> r) {
        if (~r[2])f.upd(r[2], -(r[1] - r[0]));
        s.erase(r);
    };
    auto erase = [&](array<int, 2> r) {
        while (1) {
            auto it = s.lower_bound({r[0], -1});
            if (it == s.end())break;
            auto v = *it;
            if (v[1] <= r[1]) {
                del(v);
            } else {
                del(v);
                v[0] = r[1];
                add(v);
                break;
            }
        }
        auto it = s.lower_bound({r[0], -1});
        if (it != s.begin()) {
            --it;
            auto v = *it;
            del(v);
            if (v[1] <= r[1]) {
                v[1] = r[0];
                add(v);
            }
            else{
                add({v[0],r[0],v[2]});
                add({r[1],v[1],v[2]});
            }
        }
    };
    auto insert = [&](array<int, 3> r) {
        if (r[0] > r[1])return;
        erase({r[0], r[1]});
        add(r);
    };
    insert({0, n, -1});
    for (int r = 0; r < n; ++r) {
        int cur = r;
        for (int i = 0; i <= k; ++i) {
            int need = k - i;
            insert({dp[cur][need][0], dp[cur][need][1] + 1, r});
            if (need)insert({dp[cur][need - 1][0], dp[cur][need - 1][1] + 1, r});
            cur = par[cur];
        }
        for (auto [l, id]: Q[r]) {
            res[id] = f.get(l, r);
        }
    }
    for (auto x: res)cout << x << "\n";
}

int main() {
    cin.tie(0)->sync_with_stdio(false);
    int t;
    cin >> t;
    while (t--)solve();
}