#include <bits/stdc++.h>
#define int long long
using namespace std;

const int N = 5e5 + 5;
const int mod = 201314;

int deep [N], dfn [N], fa [N], siz [N], son [N], pre [N], tot, tp [N];

int head [N << 1], number;
struct node {
  int to, next;
}k[N << 1];

void add (int x, int y) {
  k [++ number].next = head [x];
  k [number].to = y;
  head [x] = number;
}

void dfs (int x, int f) {
  deep [x] = deep [f] + 1;
  siz [x] = 1; fa [x] = f;
  for (int d = head [x]; d; d = k[d].next) {
    int i = k[d].to;
    dfs (i, x); siz [x] += siz [i];
    if (siz [i] > siz [son [x]]) son [x] = i; 
  }
}

void dfs2 (int x, int T) {
  dfn [x] = ++tot; tp [x] = T; pre [tot] = x;
  if (son [x]) dfs2 (son [x], T);
  for (int d = head[x]; d; d = k[d].next) {
    int i = k[d].to;
    if (i == son [x]) continue;
    dfs2 (i, i);
  } 
}

struct Seg {
  int val, tag; 
} t [N << 2];

inline void pushup (int cur) {
  t [cur].val = t [cur << 1].val + t [cur << 1 | 1].val;
}

void build (int cur, int l, int r) {
  if (l == r) return t [cur].val = t [cur].tag = 0, void ();
  int mid = l + r >> 1;
  build (cur << 1, l, mid), build (cur << 1 | 1, mid + 1, r);
  pushup (cur);
}

void addtag (int cur, int l, int r, int val) {
  t [cur].val += (r - l + 1) * val; t [cur].tag += val;
}

void pushdown (int cur, int l, int r) {
  if (t [cur].tag == 0) return ;
  int mid = l + r >> 1;
  addtag (cur << 1, l, mid, t [cur].tag);
  addtag (cur << 1 | 1, mid + 1, r, t [cur].tag);
  t [cur].tag = 0;
}

void update (int cur, int l, int r, int x, int y, int val) {
  if (l >= x and r <= y) return addtag (cur, l, r, val);
  int mid = l + r >> 1; pushdown (cur, l, r);
  if (x <= mid) update (cur << 1, l, mid, x, y, val);
  if (y > mid) update (cur << 1 | 1, mid + 1, r, x, y, val);
  pushup (cur);
}

int ask (int cur, int l, int r, int x, int y) {
  if (l == r) return t [cur].val;
  int mid = l + r >> 1, ans = 0; pushdown (cur, l, r);
  if (x <= mid) ans += ask (cur << 1, l, mid, x, y);
  if (y > mid) ans += ask (cur << 1 | 1, mid + 1, r, x, y);
  return ans;
}

int n, m;

inline void upd (int x, int y, int val) {
  swap (x, y);
  while (tp [x] != tp [y]) {
    if (deep [tp [x]] < deep [tp [y]]) swap (x, y);
    update (1, 1, n, dfn [tp [x]], dfn [x], val);
    x = fa [tp [x]];
  }
  if (deep [x] < deep [y]) swap (x, y);
  update (1, 1, n, dfn [y], dfn [x], val);
}

inline int qry (int x, int y) {
  int ans = 0; swap (x, y);
  while (tp [x] != tp [y]) {
    if (deep [tp [x]] < deep [tp [y]]) swap (x, y);
    ans += ask (1, 1, n, dfn [tp [x]], dfn [x]);
    x = fa [tp [x]];
  }
  if (deep [x] < deep [y]) swap (x, y);
  ans += ask (1, 1, n, dfn [y], dfn [x]);
  return ans; 
}

struct aaa {
  int id, x, type, key;
}A[N];

int Ans [N], num;

signed main () {
 // freopen ("in.in", "r", stdin);
 // freopen ("out.out", "w", stdout);
  scanf ("%lld%lld", &n, &m);
  for (int i = 1; i < n; i ++) { 
    int x; scanf ("%lld", &x);
    add (++ x, i + 1);
  }
  dfs (1, 0), dfs2 (1, 1);
  for (int i = 1; i <= m; i ++) {
    int l, r, z; scanf ("%lld%lld%lld", &l, &r, &z);
    if (l > r) swap (l, r);
    ++ l, ++ r; z ++;
    A [++ num] = {i, z, -1, l - 1};
    A [++ num] = {i, z, 1, r};
  }
  sort (A + 1, A + num + 1, [] (aaa a, aaa b) {
    return a.key < b.key;
  });
  A[0].key = -1; int now = 0;
  for (int i = 1; i <= num; i ++) {
    while (now < A[i].key) upd (1, ++ now, 1);
    //cout << now << "\n";
    Ans [A[i].id] += qry (1, A[i].x) * A[i].type;
  }

  for (int i = 1; i <= m; i ++)
    printf ("%lld\n", Ans[i] % mod);
}