#include <bits/stdc++.h>

using namespace std;

using ll = long long;

const int N = 2e5;
const int B = 300;
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];
void dfs(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), dfs(v), siz[u] += siz[v];
  sort(ch[u].begin(), ch[u].end(), [](int x, int y) { return siz[x] > siz[y]; });
}
struct SqrtDecomposition {
  static const int B = 447;
  static const int C = (N - 1) / B + 1;
  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>> tqry;
vector<tuple<int, int, int, int>> opt[N + 5];
vector<tuple<int, int, int>> qry[N + 5];

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);
  }
  dfs(rt);
  auto insertQuery = [&](int l, int r, int u, int w, int qid) {
    opt[id[u]].emplace_back(l, r, 1, tqry.size()), opt[id[u] + siz[u]].emplace_back(l, r, -1, tqry.size()),
    tqry.emplace_back(w, qid, 0);
  };
  for (int i = 1; i <= m; ++i) {
    int l, r, u; scanf("%d%d%d", &l, &r, &u), insertQuery(l, r, u, 1, i);
    for (int j = 0; j < B && j < ch[u].size(); ++j) insertQuery(l, r, ch[u][j], -1, i);
    qry[u].emplace_back(l, r, i);
  }
  sd.init(n);
  for (int i = n; i; --i) {
    sd.update(rk[i], 1);
    for (auto [l, r, w, id] : opt[i]) get<2>(tqry[id]) += sd.query(l, r) * w;
  }
  for (auto [w, id, cur] : tqry) ans[id] += (ll)cur * (cur - 1) / 2 * w;
  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(), [&](tuple<int, int, int> a, tuple<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]);
}