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

typedef __m256i m256;
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 MDGTS = 6, PW10[MDGTS] = {0, 10, 100, 1000, 10000, 100000};
const int IO_SZ = 15 << 20;
char _buf[IO_SZ], *_ii = _buf, *_oi = _buf;
template <typename T> void scan(T &x){for(x=*_ii++-'0'; *_ii++>='0'; x=x*10+_ii[-1]-'0');}
template <typename T> void print(T x){int dgts=0; for(; dgts<MDGTS && PW10[dgts]<=x; ++dgts); for(char *i=_oi+dgts-1; i>=_oi; i--) *i=x%10+'0', x/=10; _oi+=dgts;}

const int BSZ = 1e4 + 16;
const int BC = 10;
const int MK = 21;
const int MN = 1e5 + 32;
const int MQ = 5e5 + 5;
int n, k, q, bc;
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+BC];
int updPtrs[MN][BC+1];

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;
        pii tmp[MK*2+BC];
        fill_n(updPtrs[n1], bc+1, 0);

        FORR(d, k, -min(k, dep[n1])){
            int ancD = min(dep[n1], (k-d)/2);
            int l = lDec[anc[n1][ancD]][d+ancD], r = rDec[anc[n1][ancD]][d+ancD]+1;
            FOR(j, l/BSZ, (r+BSZ-1)/BSZ){
                updPtrs[n1][j]++;
                tmp[ind++] = {max(l, j*BSZ), min(r, j*BSZ+BSZ)};
            }
        }
        FR(j, bc) updPtrs[n1][j+1] += updPtrs[n1][j];

        FR(j, ind){
            int bi = tmp[j].fs/BSZ;
            updVs[n1][--updPtrs[n1][bi]] = {tmp[j].fs - bi*BSZ, tmp[j].sn - bi*BSZ};
        }
    }
}

#define vload(ptr) _mm256_loadu_si256((m256*) (ptr))
#define vstore(ptr, v) _mm256_storeu_si256((m256*) (ptr), v)

const int MASKS[14] = {-1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0};

namespace DS {
    int sz, ds[BSZ+32];

    int query(int cut){
        m256 res1, res2, res3, res4;
        res1 = res2 = res3 = res4 = _mm256_setzero_si256();
        m256 cv = _mm256_set1_epi32(cut-1);

        for(int i = 0; i < sz; i += 32){
            m256 v1 = _mm256_cmpgt_epi32(vload(ds+i), cv);
            m256 v2 = _mm256_cmpgt_epi32(vload(ds+i+8), cv);
            m256 v3 = _mm256_cmpgt_epi32(vload(ds+i+16), cv);
            m256 v4 = _mm256_cmpgt_epi32(vload(ds+i+24), cv);
            res1 = _mm256_sub_epi32(res1, v1);
            res2 = _mm256_sub_epi32(res2, v2);
            res3 = _mm256_sub_epi32(res3, v3);
            res4 = _mm256_sub_epi32(res4, v4);
        }

        res1 = _mm256_add_epi32(res1, res2);
        res3 = _mm256_add_epi32(res3, res4);
        res1 = _mm256_add_epi32(res1, res3);
        res1 = _mm256_add_epi32(res1, _mm256_bsrli_epi128(res1, 4));
        res1 = _mm256_add_epi32(res1, _mm256_bsrli_epi128(res1, 8));
        return _mm256_extract_epi32(res1, 0) + _mm256_extract_epi32(res1, 4);
    }

    void upd(int l, int r, int v){
        m256 vv = _mm256_set1_epi32(v);
        int i = l;
        while(i+32 <= r){
            vstore(ds+i, vv);
            vstore(ds+i+8, vv);
            vstore(ds+i+16, vv);
            vstore(ds+i+24, vv);
            i += 32;
        }
        while(i+8 <= r) vstore(ds+i, vv), i += 8;
        if(i < r) _mm256_maskstore_epi32(ds+i, vload(MASKS + i+7-r), vv);
    }

    void init(int newSz){
        sz = newSz;
        m256 vv = _mm256_set1_epi32(-1);
        for(int i = 0; i < sz; i += 32){
            vstore(ds+i, vv);
            vstore(ds+i+8, vv);
            vstore(ds+i+16, vv);
            vstore(ds+i+24, vv);
        }
    }
};

void sweep(){
    FR(bi, bc){
        int sz = min(BSZ, n - bi*BSZ);
        DS::init(sz);
        FR(i, n){
            FOR(j, updPtrs[i][bi], updPtrs[i][bi+1]){
                auto [l, r] = updVs[i][j];
                DS::upd(l, r, i);
            }
            for(auto [l, ind] : queries[i]){
                ans[ind] += DS::query(l);
            }
        }
    }
}

void solve(){
    scan(n); scan(k); scan(q);
    FR(i, n-1){
        int a, b;
        scan(a); scan(b);
        a--; b--;
        adjList[a].pb(b);
        adjList[b].pb(a);
    }
    bc = (n+BSZ-1)/BSZ;
    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;
        scan(l); scan(r);
        l--; r--;
        queries[r].pb({l, i});
    }
    FR(i, q) ans[i] = 0;
    sweep();
    FR(i, q) print(ans[i]), *_oi++ = '\n';
}

int main(){
    fread(_buf, 1, IO_SZ, stdin);
    int t; scan(t);
    while(t--){
        solve();
        FR(i, n) adjList[i].clear();
        FR(i, n) queries[i].clear();
    }
    fwrite(_buf, 1, _oi-_buf, stdout);
}