#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


template <class T> void bAdd(vector<T> &bit, int pos, const T &val) {
  const int bitN = bit.size();
  for (int x = pos; x < bitN; x |= x + 1) bit[x] += val;
}
template <class T> T bSum(const vector<T> &bit, int pos) {
  T ret = 0;
  for (int x = pos; x > 0; x &= x - 1) ret += bit[x - 1];
  return ret;
}
template <class T> T bSum(const vector<T> &bit, int pos0, int pos1) {
  return bSum(bit, pos1) - bSum(bit, pos0);
}


struct Set {
  // max{ceil(log_64(n)), 1}
  int log64N, n;
  vector<unsigned long long> a[6];
  explicit Set(int n_ = 0) : n(n_) {
    assert(n >= 0);
    int m = n ? n : 1;
    for (int d = 0; ; ++d) {
      m = (m + 63) >> 6;
      a[d].assign(m, 0);
      if (m == 1) {
        log64N = d + 1;
        break;
      }
    }
  }
  bool empty() const {
    return !a[log64N - 1][0];
  }
  bool contains(int x) const {
    return (a[0][x >> 6] >> (x & 63)) & 1;
  }
  void insert(int x) {
    for (int d = 0; d < log64N; ++d) {
      const int q = x >> 6, r = x & 63;
      a[d][q] |= 1ULL << r;
      x = q;
    }
  }
  void erase(int x) {
    for (int d = 0; d < log64N; ++d) {
      const int q = x >> 6, r = x & 63;
      if ((a[d][q] &= ~(1ULL << r))) break;
      x = q;
    }
  }
  // max s.t. <= x (or -1)
  int prev(int x) const {
    if (x > n - 1) x = n - 1;
    for (int d = 0; d <= log64N; ++d) {
      if (x < 0) break;
      const int q = x >> 6, r = x & 63;
      const unsigned long long lower = a[d][q] << (63 - r);
      if (lower) {
        x -= __builtin_clzll(lower);
        for (int e = d; --e >= 0; ) x = x << 6 | (63 - __builtin_clzll(a[e][x]));
        return x;
      }
      x = q - 1;
    }
    return -1;
  }
  // min s.t. >= x (or n)
  int next(int x) const {
    if (x < 0) x = 0;
    for (int d = 0; d < log64N; ++d) {
      const int q = x >> 6, r = x & 63;
      if (static_cast<unsigned>(q) >= a[d].size()) break;
      const unsigned long long upper = a[d][q] >> r;
      if (upper) {
        x += __builtin_ctzll(upper);
        for (int e = d; --e >= 0; ) x = x << 6 | __builtin_ctzll(a[e][x]);
        return x;
      }
      x = q + 1;
    }
    return n;
  }
};

template <class T> struct Painter {
  int n;
  Set s;
  vector<T> ts;
  Painter() {}
  Painter(int n_, const T &t) : n(n_), s(n + 1), ts(n + 2, t) {}
  template <class F> void paint(int a, int b, const T &t, F f) {
    assert(0 <= a); assert(a <= b); assert(b <= n);
    if (a == b) return;
    // auto it = this->lower_bound(a);
    int c = s.next(a);
    if (b < c) {
      f(a, b, ts[c]);
      s.insert(a); ts[a] = ts[c];
      s.insert(b); ts[b] = t;
    } else if (a < c) {
      const T ta = ts[c];
      int k = a;
      for (; c <= b; s.erase(c), c = s.next(c)) {
        f(k, c, ts[c]);
        k = c;
      }
      if (k < b) {
        f(k, b, ts[c]);
      }
      s.insert(a); ts[a] = ta;
      s.insert(b); ts[b] = t;
    } else {
      c = s.next(c + 1);
      int k = a;
      for (; c <= b; s.erase(c), c = s.next(c)) {
        f(k, c, ts[c]);
        k = c;
      }
      if (k < b) {
        f(k, b, ts[c]);
      }
      s.insert(b); ts[b] = t;
    }
  }
  void paint(int a, int b, const T &t) {
    paint(a, b, t, [&](int, int, const T &) -> void {});
  }
  T get(int k) const {
    assert(0 <= k); assert(k < n);
    return ts[s.next(k + 1)];
  }
};

////////////////////////////////////////////////////////////////////////////////


int N, K, Q;
vector<int> A, B;
vector<int> L, R;

vector<vector<int>> graph;
void ae(int u, int v) {
  graph[u].push_back(v);
  graph[v].push_back(u);
}

int main() {
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    scanf("%d%d%d", &N, &K, &Q);
    A.resize(N - 1);
    B.resize(N - 1);
    for (int i = 0; i < N - 1; ++i) {
      scanf("%d%d", &A[i], &B[i]);
      --A[i];
      --B[i];
    }
    L.resize(Q);
    R.resize(Q);
    for (int q = 0; q < Q; ++q) {
      scanf("%d%d", &L[q], &R[q]);
      --L[q];
    }
    
    const int rt = N + K - 1;
    graph.assign(N + K, {});
    for (int k = 0; k < K; ++k) {
      ae(N + k - 1, N + k);
    }
    for (int i = 0; i < N - 1; ++i) {
      ae(A[i], B[i]);
    }
    
    queue<int> que;
    vector<int> dist(N + K, -1);
    vector<int> par(N + K, -1);
    dist[rt] = 0;
    que.push(rt);
    int zeit = 0;
    vector<int> su(N + K, -1);
    vector<int> us(N + K, -1);
    for (; que.size(); ) {
      const int u = que.front();
      que.pop();
      su[u] = zeit++;
      us[su[u]] = u;
      for (const int v : graph[u]) {
        if (!~dist[v]) {
          dist[v] = dist[u] + 1;
          par[v] = u;
          que.push(v);
        }
      }
    }
// cerr<<"us = "<<us<<endl;
    
    vector<vector<pair<int, int>>> f(N + K, vector<pair<int, int>>(K + 1));
    for (int j = N + K; --j >= 0; ) {
      const int u = us[j];
      f[u][0] = make_pair(j, j + 1);
      for (int k = 1; k <= K; ++k) {
        f[u][k] = make_pair(N + K, 0);
      }
      for (const int v : graph[u]) if (par[u] != v) {
        for (int k = 1; k <= K; ++k) {
          chmin(f[u][k].first , f[v][k - 1].first );
          chmax(f[u][k].second, f[v][k - 1].second);
        }
      }
// cerr<<"f["<<u<<"] = "<<f[u]<<endl;
    }
    
    vector<vector<int>> qss(N);
    for (int q = 0; q < Q; ++q) qss[L[q]].push_back(q);
    vector<int> ans(Q, 0);
    
    vector<int> bit(N + 1, 0);
    Painter<int> pa(N + K, N);
    bAdd(bit, N, N);
    for (int u = N; --u >= 0; ) {
      auto add = [&](const pair<int, int> &a) -> void {
        if (a.first < a.second) {
// cerr<<"[add] u = "<<u<<", a = "<<a<<endl;
          pa.paint(a.first, a.second, u, [&](int l, int r, int old) -> void {
            chmax(l, K);
            if (l < r) {
              bAdd(bit, old, -(r - l));
              bAdd(bit, u, +(r - l));
            }
          });
        }
      };
// cerr<<"pa = ";pv(pa.begin(),pa.end());
      for (int v = u, k = K; ; v = par[v]) {
        add(f[v][k]);
        if (k == 0) break;
        add(f[v][--k]);
      }
      for (const int q : qss[u]) {
        ans[q] = bSum(bit, R[q]);
      }
    }
    
    for (int q = 0; q < Q; ++q) {
      printf("%d\n", ans[q]);
    }
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}