#include <bits/stdc++.h>
#define File(name) freopen(#name".in", "r", stdin); freopen(#name".out", "w", stdout);
using namespace std;
using ll = long long;
using ull = unsigned long long;
template<typename T>
inline T read(){
    T n = 0; int f = 1; char ch = getchar();
    while(!isdigit(ch)){
        if(ch == '-') f = -1;
        ch = getchar();
    }
    while(isdigit(ch)){
        n = n * 10 + ch - '0';
        ch = getchar();
    }
    return f * n;
}
template<typename T>
void write(T n){
    if(n < 0) return putchar('-'), write(-n);
    if(n / 10) write(n / 10);
    putchar(n % 10 + '0');
}
void input() {}
template<typename Type, typename... Types>
void input(Type &arg, Types &...args){
    arg = read<Type>();
    input(args...);
}
namespace Main{
    const int N = 500005, K = 25;
    int t, n, k, q, bfn[N], bfnCnt, fa[N], L[K][N], R[K][N], ans[N];
    vector<int> g[N];
    vector<pair<int, int>> ask[N];
    struct bit{
        int t[N];
        void clear(int n) { fill(t + 1, t + n + 1, 0); }
        int lowbit(int x) { return x & -x; }
        void add(int x, int k) { for(; x < N; x += lowbit(x)) t[x] += k; }
        int query(int x) { int res = 0; for(; x; x -= lowbit(x)) res += t[x]; return res; }
    }tree;
    struct odt_node{
        int l, r, v;
        odt_node() = default;
        odt_node(int l, int r, int v): l(l), r(r), v(v) {}
        bool operator<(const odt_node &b) const& {
            return l < b.l;
        }
    };
    set<odt_node> odt;
    set<odt_node>::iterator split(int x){
        auto it = odt.lower_bound({x, 0, 0});
        if(it == odt.end() || it->l == x) return it;
        it--;
        auto [l, r, v] = *it;
        odt.erase(it);
        odt.emplace(l, x - 1, v);
        return odt.emplace(x, r, v).first;
    }
    void cover(int l, int r, int v){
        auto itr = split(r + 1), itl = split(l);
        for(auto it = itl; it != itr; it++){
            tree.add(it->v, -(it->r - it->l + 1));
        }
        odt.erase(itl, itr);
        odt.emplace(l, r, v);
        tree.add(v, r - l + 1);
    }
    void bfs(){
        queue<int> q;
        q.push(1);
        bfn[1] = ++bfnCnt;
        while(!q.empty()){
            int u = q.front(); q.pop();
            for(int v: g[u]){
                if(!bfn[v]){
                    bfn[v] = ++bfnCnt;
                    q.push(v);
                }
            }
        }
    }
    void dfs(int u, int f){
        fa[u] = f;
        L[0][u] = R[0][u] = bfn[u];
        for(int i = 1; i <= k; i++) L[i][u] = R[i][u] = 0;
        for(int v: g[u]){
            if(v == f) continue;
            dfs(v, u);
            for(int i = 1; i <= k; i++) if(!L[i][u]) L[i][u] = L[i - 1][v];
            for(int i = 1; i <= k; i++) if(R[i - 1][v]) R[i][u] = R[i - 1][v];
        }
    }
    void cover_dep(int u, int d, int v){
        if(d < 0 || !L[d][u]) return;
        cover(L[d][u], R[d][u], v);
    }
    void Main(){
        input(t);
        while(t--){
            input(n, k, q);
            for(int i = 1; i <= n; i++) g[i].clear(), ask[i].clear();
            for(int i = 1, u, v; i < n; i++){
                input(u, v);
                g[u].push_back(v), g[v].push_back(u);
            }
            for(int i = 0, l, r; i < q; i++){
                input(l, r);
                ask[l].emplace_back(r, i);
            }
            bfnCnt = 0, fill(bfn + 1, bfn + n + 1, 0);
            bfs();
            dfs(1, 0);
            odt = {{1, n, n + 1}};
            tree.clear(n);
            for(int i = n; i >= 1; i--){
                int u = i, d = k;
                while(u && d >= 0){
                    cover_dep(u, d, i), cover_dep(u, d - 1, i);
                    u = fa[u], d--;
                }
                while(d >= 0) cover_dep(1, d--, i);
                for(auto [r, id]: ask[i]) ans[id] = tree.query(r);
            }
            for(int i = 0; i < q; i++) write(ans[i]), puts("");
        }
        return;
    }
} // namespace Main
int main(){
#ifdef Liuxizai
    freopen("in", "r", stdin);
    freopen("out", "w", stdout);
#endif // Liuxizai
    Main::Main();
    return 0;
}