#include <bits/stdc++.h>

using namespace std;

using ll = long long;

const int N = 2e5;
const int B = 500;
const int C = (N - 1) / B + 1;

int n, m, rt;
vector<int> e[N + 5], ch[N + 5];
int fa[N + 5], siz[N + 5], id[N + 5], rk[N + 5];
bool heavy[N + 5];
void dfs1(int u) {
  static int tot = 0;
  rk[id[u] = ++tot] = u, siz[u] = 1;
  for (int v : e[u])
    if (v != fa[u])
      fa[v] = u, ch[u].push_back(v), dfs1(v), siz[u] += siz[v];
  sort(ch[u].begin(), ch[u].end(), [](int x, int y) { return siz[x] > siz[y]; });
  for (int i = 0; i < B && i < ch[u].size(); ++i) heavy[ch[u][i]] = 1;
}
struct SqrtDecomposition {
  int pos[N + 5], val[N + 5], sum[C + 5];
  void init(int n) { for (int i = 1; i <= n; ++i) pos[i] = (i - 1) / B + 1; }
  void update(int x, int k) {
    for (int i = x; i <= min(pos[x] * B, n); ++i) val[i] += k;
    for (int p = pos[x] + 1; p <= pos[n]; ++p) sum[p] += k;
  }
  int query(int x) { return val[x] + sum[pos[x]]; }
  int query(int l, int r) { return query(r) - query(l - 1); }
} sd;

ll ans[N + 5];
vector<tuple<int, int, int, int, int>> qry[N + 5];

void dfs2(int u) {
  for (auto &[l, r, id, pre0, pre1] : qry[u]) pre0 = sd.query(l, r);
  if (heavy[u])
    for (auto &[l, r, id, pre0, pre1] : qry[fa[u]]) pre1 = sd.query(l, r);
  sd.update(u, 1);
  for (int v : ch[u]) dfs2(v);
  for (auto &[l, r, id, pre0, pre1] : qry[u]) {
    int tmp = sd.query(l, r) - pre0;
    ans[id] += (ll)tmp * (tmp - 1) / 2;
  }
  if (heavy[u])
    for (auto &[l, r, id, pre0, pre1] : qry[fa[u]]) {
      int tmp = sd.query(l, r) - pre1;
      ans[id] -= (ll)tmp * (tmp - 1) / 2;
    }
}

int cnt[N + 5];

int main() {
  scanf("%d%d%d", &n, &m, &rt);
  for (int i = 2; i <= n; ++i) {
    int u, v; scanf("%d%d", &u, &v), e[u].push_back(v), e[v].push_back(u);
  }
  dfs1(rt);
  for (int i = 1; i <= m; ++i) {
    int l, r, u; scanf("%d%d%d", &l, &r, &u), qry[u].emplace_back(l, r, i, 0, 0);
  }
  sd.init(n), dfs2(rt);
  for (int u = 1; u <= n; ++u) {
    if (B >= ch[u].size()) continue;
    vector<pair<int, int>> vec;
    for (int j = B; j < ch[u].size(); ++j) {
      int v = ch[u][j];
      for (int k = id[v]; k < id[v] + siz[v]; ++k) vec.emplace_back(rk[k], v);
    }
    sort(vec.begin(), vec.end());
    int block = sqrt(vec.size());
    for (auto &[l, r, id, _, __] : qry[u])
      l = lower_bound(vec.begin(), vec.end(), make_pair(l, 0)) - vec.begin(),
      r = upper_bound(vec.begin(), vec.end(), make_pair(r, n)) - vec.begin() - 1;
    sort(qry[u].begin(), qry[u].end(), [&](const tuple<int, int, int, int, int> &a, const tuple<int, int, int, int, int> &b) {
      return get<0>(a) / block != get<0>(b) / block ? get<0>(a) < get<0>(b) : ~(get<0>(a) / block) & 1 ? get<1>(a) < get<1>(b) : get<1>(a) > get<1>(b);
    });
    fill_n(cnt + 1, n, 0);
    int tl = 0, tr = -1; ll cur = 0;
    for (auto &[l, r, id, _, __] : qry[u]) {
      while (tr < r) cur += cnt[vec[++tr].second]++;
      while (tl > l) cur += cnt[vec[--tl].second]++;
      while (tr > r) cur -= --cnt[vec[tr--].second];
      while (tl < l) cur -= --cnt[vec[tl++].second];
      ans[id] -= cur;
    }
  }
  for (int i = 1; i <= m; ++i) printf("%lld\n", ans[i]);
}