#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize "Ofast"

typedef unsigned uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<pii> vpii;
typedef complex<double> cpx;
template <typename T> using minPq = priority_queue<T, vector<T>, greater<T>>;
#define ms(a, x) memset(a, x, sizeof(a))
#define pb push_back
#define fs first
#define sn second
#define ALL(v) begin(v), end(v)
#define SZ(v) ((int) (v).size())
#define lbv(v, x) (lower_bound(ALL(v), x) - (v).begin())
#define ubv(v, x) (upper_bound(ALL(v), x) - (v).begin())
template <typename T> inline void UNIQUE(vector<T> &v){sort(ALL(v)); v.resize(unique(ALL(v)) - v.begin());}
const int INF = 0x3f3f3f3f;
const ll LLINF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
#define FR(i, n) for(int i = 0; i < (n); i++)
#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define FORR(i, a, b) for(int i = (a); i >= (b); i--)
#define dbg(x) {cerr << #x << ' ' << x << endl;}
#define dbgArr(arr, n) {cerr << #arr; FR(_i, n) cerr << ' ' << (arr)[_i]; cerr << endl;}
template <typename T, typename U>
ostream& operator<<(ostream &os, pair<T, U> p){return os << "(" << p.fs << ", " << p.sn << ")";}

const int MK = 21;
const int MN = 1e5 + 5;
const int MQ = 5e5 + 5;
int n, k, q;
vi adjList[MN];
int par[MN], anc[MN][MK], lDec[MN][MK], rDec[MN][MK];
int dep[MN], ord[MN];
int qu[MN], ql, qr;
pii updVs[MN][MK*2];
int updCnt[MN];

vpii queries[MN];
int ans[MQ];

void bfs(){
    ql = qr = 0;
    qu[qr++] = 0;
    while(ql < qr){
        int n1 = qu[ql++];
        if(par[n1] != -1){
            adjList[n1].erase(find(ALL(adjList[n1]), par[n1]));
            copy(anc[par[n1]], anc[par[n1]]+k, anc[n1]+1);
        }
        anc[n1][0] = n1;
        for(int n2 : adjList[n1]) par[n2] = n1, dep[n2] = dep[n1]+1, qu[qr++] = n2;
    }
    assert(qr == n);

    FORR(i, qr-1, 0){
        int n1 = qu[i];
        lDec[n1][0] = rDec[n1][0] = i;
        if(par[n1] != -1) FR(j, k){
            lDec[par[n1]][j+1] = min(lDec[par[n1]][j+1], lDec[n1][j]);
            rDec[par[n1]][j+1] = max(rDec[par[n1]][j+1], rDec[n1][j]);
        }
    }

    FR(i, n){
        int n1 = qu[i];
        int ind = 0;
        FORR(d, k, -min(k, dep[n1])){
            int ancD = min(dep[n1], (k-d)/2);
            pii p = {lDec[anc[n1][ancD]][d+ancD], rDec[anc[n1][ancD]][d+ancD]+1};
            if(p.sn) updVs[n1][ind++] = p;
        }
        updCnt[n1] = ind;
    }
}

namespace DS {
    int ds[MN];

    int query(int cut){
        //cerr << "query " << cut << endl;
        int res = 0;
        FR(i, n) res += ds[i] >= cut;
        return res;
    }

    void upd(int l, int r, int v){
        //cerr << "upd " << l << ' ' << r << ' ' << v << endl;
        FOR(i, l, r) ds[i] = v;
    }

    void reset(){
        FR(i, n) ds[i] = -1;
    }
};

void sweep(){
    DS::reset();
    FR(i, n){
        FR(j, updCnt[i]){
            auto [l, r] = updVs[i][j];
            DS::upd(l, r, i);
        }
        for(auto [l, ind] : queries[i]){
            ans[ind] = DS::query(l);
        }
    }
}

void solve(){
    cin >> n >> k >> q;
    FR(i, n-1){
        int a, b;
        cin >> a >> b;
        a--; b--;
        adjList[a].pb(b);
        adjList[b].pb(a);
    }
    fill_n(*anc, n*MK, -1);
    fill_n(*lDec, n*MK, INF);
    fill_n(*rDec, n*MK, -1);
    par[0] = -1;
    bfs();

    FR(i, q){
        int l, r;
        cin >> l >> r;
        l--; r--;
        queries[r].pb({l, i});
    }
    sweep();

    FR(i, q) cout << ans[i] << '\n';
}

int main(){
    cin.sync_with_stdio(0); cin.tie(0);
    int t; cin >> t;
    while(t--){
        solve();
        FR(i, n) adjList[i].clear();
        FR(i, n) queries[i].clear();
    }
}