#include <bits/stdc++.h>
#define mk make_pair
#define pb emplace_back
#define pii pair<int, int>
#define all(x) x.begin(), x.end()

using namespace std;
inline int read() {
  int x = 0, f = 1;
  char ch = getchar();
  while (! isdigit(ch)) { if (ch == '-') f = -1; ch = getchar(); }
  while (isdigit(ch)) { x = x * 10 + ch - 48; ch = getchar(); }
  return x * f;
}

const int maxn = 1e5 + 10, maxm = 1e6 + 10;

int n, m, ql, rt, ans[maxm];
vector<int> g[maxn];

struct Node { int t, p, x, v, id; } q[maxm * 6], nw[maxn];
struct ftr {
  int c[maxn];
	Node () { memset(c, 0, sizeof c); }
  void ad(int x, int v) { x ++; while (x <= n + 1) c[x] += v, x += x & -x; }
  int qu(int x, int r = 0) { x ++; while (x) r += c[x], x -= x & -x; return r; } 
  void cl(int x) { x ++; while (x <= n + 1) c[x] = 0, x += x & -x; }
} T;

void cdq(int l, int r) {
  if (l == r) return ;

  int mi = l + r >> 1, p = l;
  cdq(l, mi), cdq(mi + 1, r);

  for (int i = mi + 1; i <= r; i ++) {
    while (p <= mi && q[p].p <= q[i].p)
      !q[p].id && (T.ad(q[p].x, q[p].v), 0), p ++;
    if (q[i].id) ans[q[i].id] += q[i].v * T.qu(q[i].x);
  }

  sort(q + l, q + r + 1, [&](Node x, Node y) { return x.p < y.p || x.p == y.p && x.id < y.id; });
  for (int i = l; i <= mi; i ++) T.cl(q[i].x);
}

int d[maxn], f[maxn];
set<int> st[maxn];

int fd(int x) { return x == f[x] ? x : f[x] = fd(f[x]); }
void md(int u, int v, int t) {
  nw[u].v = -1, nw[u].t = t, q[++ ql] = nw[u];
  nw[u].v = 1, nw[u].x = v, q[++ ql] = nw[u];
}

void mg(int x, int y, int t) {
  x = fd(x), y = fd(y);
  if (x == y) return ;
  if (st[x].size() < st[y].size()) swap(x, y);

  for (int u : st[y]) {
    auto il = st[x].lower_bound(u);
    if (il != st[x].begin()) md(u, *prev(il), t);
    auto ir = st[x].upper_bound(u);
    if (ir != st[x].end()) md(*ir, u, t);
    st[x].insert(u);
  }

  set<int>().swap(st[y]), f[y] = x;
}

int tot, fa[maxn][20], df[maxn];
vector<int> nds[maxn];

int get(int u, int v) { return df[u] < df[v] ? u : v; }
void dfs(int u, int fa) {
  nw[u] = q[++ ql] = Node {0, u, 0, 1, 0};
  st[u].insert(f[u] = u), :: fa[df[u] = ++ tot][0] = fa, nds[d[u]].pb(u);
  for (int v : g[u]) d[v] = d[u] + 1, dfs(v, u);
}

int get_time(int u, int v) {
  if ((u = df[u]) > (v = df[v])) swap(u, v);
  int t = 31 ^ __builtin_clz(v - u ++);
  return d[get(fa[u][t], fa[v - (1 << t) + 1][t])];
}

void work(vector<int> &nd) {
  set<pii> s;
  sort(all(nd), [&](int x, int y) { return df[x] < df[y]; });
  for (int i = 1; i < nd.size(); i ++) s.emplace(d[nd[i]] - get_time(nd[i - 1], nd[i]), i);
  for (auto [t, id] : s) mg(nd[id - 1], nd[id], t);
  for (int u : nd) nw[u].v = -1, nw[u].t = d[u] + 1, q[++ ql] = nw[u];
}

int main() {
  
  n = read(), m = read();
  for (int i = 1; i <= n; i ++) {
    int fa = read();
    if (!fa) rt = i; else g[fa].pb(i);
  }

  dfs(rt, 0);
  for (int j = 1; (1 << j) <= n; j ++)
    for (int i = 1; i + (1 << j) - 1 <= n; i ++)
      fa[i][j] = get(fa[i][j - 1], fa[i + (1 << j - 1)][j - 1]);

  for (int i = 0; i <= n; i ++) if (!nds[i].empty()) work(nds[i]);
  for (int i = 1; i <= m; i ++) {
    int l = read(), r = read(), x = read();
    q[++ ql] = Node {x, l - 1, l - 1, -1, i};
    q[++ ql] = Node {x, r, l - 1, 1, i};
  }

  sort(q + 1, q + ql + 1, [&](Node x, Node y) { return x.t < y.t || x.t == y.t && x.id < y.id; });
  cdq(1, ql); for (int i = 1; i <= m; i ++) printf("%d\n", ans[i]);

  return 0;
}

answer.code:24:15: error: expected unqualified-id before ‘)’ token
   24 |         Node () { memset(c, 0, sizeof c); }
      |               ^
answer.code: In function ‘void work(std::vector<int>&)’:
answer.code:91:13: warning: structured bindings only available with ‘-std=c++17’ or ‘-std=gnu++17’ [-Wc++17-extensions]
   91 |   for (auto [t, id] : s) mg(nd[id - 1], nd[id], t);
      |             ^