#include<stdio.h>
#include<algorithm>
#include<cstring>
#include<utility>
#include<map>
constexpr int N(100000),K(20),Q(500000);
struct edge {
    int v,next;
};
edge e[(N<<1)+5];
int en,last[N+5];
inline void add_edge(const int &u,const int &v) {
    e[++en]={v,last[u]};
    last[u]=en;
}
int fa[N+5];
int bfn[N+5];
int que[N+5];
int lp[N+5][K+1],rp[N+5][K+1];
struct qry {
    int id,l,r;
};
qry qq[Q+5];
int ans[Q+5];
namespace BIT {
    int sum[N+5];
    inline void clear(const int &n) {
        std::memset(sum+1,0,n*sizeof(int));
    }
    inline void modify(int x,const int &y) {
        while(x) {
            sum[x]+=y;
            x-=x&-x;
        }
    }
    inline int query(const int &n,int x) {
        int y(0);
        while(x<=n) {
            y+=sum[x];
            x+=x&-x;
        }
        return y;
    }
}
namespace ODT {
    std::map<int,std::pair<int,int>> map;
    inline void clear(const int &n) {
        map.clear();
        map.emplace(1,std::make_pair(n,0));
    }
    inline void erase(const int &l,const int &r,const int &c) {
        BIT::modify(c,-(r-l+1));
    }
    inline void color(const int &l,const int &r,const int &c) {
        BIT::modify(c,r-l+1);
    }
    inline void cover(const int &l,const int &r,const int &c) {
        if(l>r) {
            return;
        }
        // segments crossing left boundary
        auto it(map.upper_bound(l));
        if(it!=map.begin()) {
            --it;
            if(it->second.first>=r) {
                erase(l,r,it->second.second);
                if(it->second.first>r) {
                    map.emplace(r+1,it->second);
                }
            }
            else if(it->second.first>=l) {
                erase(l,it->second.first,it->second.second);
            }
            if(it->first<l) {
                it->second.first=l-1;
            }
            else {
                map.erase(it);
            }
        }
        // segments crossing right boundary
        it=map.upper_bound(r);
        if(it!=map.begin()) {
            --it;
            if(it->first>l) {
                erase(it->first,r,it->second.second);
                if(it->second.first>r) {
                    map.emplace(r+1,it->second);
                }
                map.erase(it);
            }
        }
        // segments inside
        for(it=map.lower_bound(l);it!=map.end()&&it->first<=r;it=map.erase(it)) {
            erase(it->first,it->second.first,it->second.second);
        }
        // insert the new segment
        color(l,r,c);
        map.emplace(l,std::make_pair(r,c));
    }
}
void solve() {
    int n,k,q;
    scanf("%d%d%d",&n,&k,&q);
    std::memset(last+1,0,n*sizeof(int)),en=0;
    for(int i=1;i<n;i++) {
        int u,v;
        scanf("%d%d",&u,&v);
        add_edge(u,v);
        add_edge(v,u);
    }
    int cnt(0);
    int qb(1),qe(1);
    fa[1]=0,que[1]=1;
    while(qb<=qe) {
        const int u(que[qb++]);
        bfn[u]=++cnt;
        for(int i=last[u];i;i=e[i].next) {
            const int v(e[i].v);
            if(v==fa[u]) {
                continue;
            }
            fa[v]=u,que[++qe]=v;
        }
    }
    for(int i=n;i>=1;i--) {
        lp[i][0]=rp[i][0]=bfn[i];
        for(int j=1;j<=k;j++) {
            lp[i][j]=n+1,rp[i][j]=0;
        }
        for(int j=last[i];j;j=e[j].next) {
            const int v(e[j].v);
            if(v==fa[i]) {
                continue;
            }
            for(int l=1;l<=k;l++) {
                lp[i][l]=std::min(lp[i][l],lp[v][l-1]);
                rp[i][l]=std::max(rp[i][l],rp[v][l-1]);
            }
        }
    }
    for(int i=1;i<=q;i++) {
        scanf("%d%d",&qq[i].l,&qq[i].r);
        qq[i].id=i;
    }
    std::sort(qq+1,qq+q+1,[](const qry &x,const qry &y)->bool {
        return x.r<y.r;
    });
    BIT::clear(n),ODT::clear(n);
    for(int i=1,j=1;i<=n;i++) {
        for(int j=0,u=i;j<=k;j++,u=fa[u]) {
            if(u==0) {
                for(int l=k-j-1;l>=0;l--) {
                    ODT::cover(lp[1][l],rp[1][l],i);
                }
                break;
            }
            ODT::cover(bfn[u],bfn[u],i);
            ODT::cover(lp[u][k-j],rp[u][k-j],i);
            if(j<k) {
                ODT::cover(lp[u][k-j-1],rp[u][k-j-1],i);
            }
        }
        while(j<=q&&qq[j].r==i) {
            ans[qq[j].id]=BIT::query(n,qq[j].l);
            ++j;
        }
    }
    for(int i=1;i<=q;i++) {
        printf("%d\n",ans[i]);
    }
}
int main() {
    int t;
    scanf("%d",&t);
    while(t--) {
        solve();
    }
    return 0;
}