#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
#include <set>
#define gc (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2) ? EOF : *p1 ++)

char buf[100000], *p1, *p2;
inline int read() {
    char ch; int x = 0; while ((ch = gc) < 48);
    do x = x * 10 + ch - 48; while ((ch = gc) >= 48); return x;
}
using std::min; using std::max; using std::prev; using std::next;
std::vector<int> G[100005];
std::vector<std::pair<int, int> > vec[100005];
struct node {
    mutable int l, r, v;
    inline bool operator < (const node &rhs) const {return l < rhs.l;}
};
int L[100005][21], R[100005][21], fa[100005], Q[100005], ord[100005], hd, tl, n, k, q, num;
int ans[100005];
bool vis[100005];
std::set<node> s;
void dfs(int u) {
    L[u][0] = R[u][0] = ord[u];
    for (int v : G[u]) if (v != fa[u]) {
        fa[v] = u, dfs(v);
        for (int i = 1; i <= k; ++ i)
            L[u][i] = min(L[u][i], L[v][i - 1]), R[u][i] = max(R[u][i], R[v][i - 1]);
    }
}
struct BIT {
    int c[100005];
    void add(int x, int d) {
        for (int i = n + 1 - x; i <= n; i += (i & ~i + 1)) c[i] += d;
    }
    int qry(int x) {
        int s = 0;
        for (int i = n + 1 - x; i; i &= i - 1) s += c[i];
        return s;
    }
} bit;
void assign(int l, int r, int x) {
    if (l > r) return;
    bit.add(x, r - l + 1);
    auto itl = prev(s.upper_bound(node{l, 0, 0})), itr = prev(s.upper_bound(node{r, 0, 0}));
    node i1 = *itl, i2 = *itr;
    if (itl != itr)
    for (auto i = next(itl); i != itr;) {
        auto nx = next(i);
        bit.add(i -> v, -(i -> r - i -> l + 1)), s.erase(i), i = nx;
    }
    if (itl == itr) {
        bit.add(i1.v, -(r - l + 1));
        s.erase(itl);
        if (i1.l < l) s.insert(node{i1.l, l - 1, i1.v});
        if (r < i1.r) s.insert(node{r + 1, i1.r, i1.v});
        s.insert(node{l, r, x});
        return;
    }
    bit.add(i1.v, -(i1.r - l + 1));
    bit.add(i2.v, -(r - i2.l + 1));
    s.erase(itl), s.erase(itr);
    if (i1.l < l) s.insert(node{i1.l, l - 1, i1.v});
    if (r < i2.r) s.insert(node{r + 1, i2.r, i2.v});
    s.insert(node{l, r, x});
}

void Main() {
    num = 0;
    n = read(), k = read(), q = read();
    for (int i = 1, u, v; i < n; ++ i)
        u = read(), v = read(), G[u].push_back(v), G[v].push_back(u);
    Q[hd = tl = 1] = vis[1] = 1;
    while (hd <= tl) {
        int u = Q[hd ++]; ord[u] = ++ num;
        for (int v : G[u]) if (!vis[v]) vis[v] = true, Q[++ tl] = v;
    }
    dfs(1);
    for (int i = 1, l, r; i <= q; ++ i)
        l = read(), r = read(), vec[r].push_back(std::make_pair(l, i));
    s.clear(), s.insert(node{1, n, 0});
    for (int i = 1; i <= n; ++ i) {
        for (int j = 0; j <= k; ++ j) assign(L[i][j], R[i][j], i);
        int u = i;
        for (int _ = 1; _ <= k && (u = fa[u]); ++ _) {
            assign(L[u][k - _], R[u][k - _], i);
            if (k - _) assign(L[u][k - _ - 1], R[u][k - _ - 1], i);
        }
        for (auto j : vec[i]) ans[j.second] = bit.qry(j.first);
    }
    for (int i = 1; i <= q; ++ i) printf("%d\n", ans[i]);
    for (int i = 1; i <= n; ++ i) {
        memset(L[i], 0x3f, sizeof L[i]), memset(R[i], 0, sizeof R[i]);
        G[i].clear(), vis[i] = bit.c[i] = fa[i] = 0, vec[i].clear();
    }
    num = 0;
}

int main() {
    memset(L, 0x3f, sizeof L);
    int _; scanf("%d", &_); while (_ --) Main();
    return 0;
}