#include <iostream>

 #include <cstdio>

 #include <vector>

 #include <algorithm>

 using namespace std;

 namespace StandardIO {

     template<typename T> inline void read (T &x) {

         x=;T f=;char c=getchar();

         for (; c<''||c>''; c=getchar()) if (c=='-') f=-;

         for (; c>=''&&c<=''; c=getchar()) x=x*+c-'';

         x*=f;

     }

     template<typename T> inline void write (T x) {

         if (x<) putchar('-'),x=-x;

         if (x>=) write(x/);

         putchar(x%+'');

     }

 }

 using namespace StandardIO;

 namespace Solve {

     const int MOD=;

     const int N=;

     struct Tree {

         int tree[N*],tag[N*];

         void pushdown (int pos,int left,int right) {

             if (tag[pos]) {

                 int mid=(left+right)/;

                 tree[pos*]+=(mid-left+)*tag[pos],tree[pos*]%=MOD;

                 tree[pos*+]+=(right-mid)*tag[pos],tree[pos*+]%=MOD;

                 tag[pos*]+=tag[pos],tag[pos*+]+=tag[pos],tag[pos*]%=MOD,tag[pos*+]%=MOD;

                 tag[pos]=;

             }

         }

         void pushup (int pos) {

             tree[pos]=tree[pos*]+tree[pos*+],tree[pos]%=MOD;

         }

         void update (int pos,int left,int right,int L,int R,int add) {

             if (L<=left&&right<=R) {

                 tree[pos]+=add*(right-left+),tree[pos]%=MOD;

                 tag[pos]+=add,tag[pos]%=MOD;

                 return;

             }

             pushdown(pos,left,right);

             int mid=(left+right)/;

             if (L<=mid) update(pos*,left,mid,L,R,add);

             if (R>mid) update(pos*+,mid+,right,L,R,add);

             pushup(pos);

         }

         int query (int pos,int left,int right,int L,int R) {

             if (L<=left&&right<=R) return tree[pos];

             pushdown(pos,left,right);

             int mid=(left+right)/;

             int ans=;

             if (L<=mid) ans+=query(pos*,left,mid,L,R),ans%=MOD;

             if (R>mid) ans+=query(pos*+,mid+,right,L,R),ans%=MOD;

             return ans;

         }

     } ljz;

     int n,q;

     vector<int>M[N];

     int dep[N],siz[N],fa[N],son[N];

     int ind[N],cnt;

     int top[N];

     void dfs1 (int now,int father) {

         dep[now]=dep[father]+,fa[now]=father,siz[now]=;

         for (register vector<int>::iterator i=M[now].begin(); i!=M[now].end(); i++) {

             if(*i==father) continue;

             dfs1(*i,now);

             siz[now]+=siz[*i];

             if (siz[*i]>siz[son[now]]) son[now]=*i;

         }

     }

     void dfs2(int now,int tp){

         top[now]=tp,ind[now]=++cnt;

         if (son[now]) dfs2(son[now],tp);

         for (register vector<int>::iterator i=M[now].begin(); i!=M[now].end(); i++) {

             if (*i==fa[now]||*i==son[now]) continue;

             dfs2(*i,*i);

         }

     }

     void upd (int x,int add){

         while (x) {

             ljz.update(,,n,ind[top[x]],ind[x],add);

             x=fa[top[x]];

         }

     }

     int que (int x) {

         int ans=;

         while (x) {

             ans+=ljz.query(,,n,ind[top[x]],ind[x]),ans%=MOD;

             x=fa[top[x]];

         }

         return ans;

     }

     int A[N];

     struct Q{

         int val,ind;

         Q () {val=ind=;}

         Q (int a,int b) :val(a),ind(b) {}

         friend bool operator < (Q a,Q b) {

             return a.val<b.val;

         }

     } s1[N],s2[N];

     int a1=,a2=;

     int Ans[N];

     inline void solve () {

         read(n),read(q);

         for (register int i=; i<=n; i++) {

             int a;

             read(a);

             M[a+].push_back(i);

         }

         dfs1(,);

         dfs2(,);

         for (register int i=; i<=q; i++) {

             int a,b,c;

             read(a),read(b),read(c);

             a++,b++,c++;

             A[i]=c;

             s1[i]=Q(a-,i),s2[i]=Q(b,i);

         }

         sort(s1+,s1+q+);

         sort(s2+,s2+q+);

         while (s1[a1].val==) a1++;

         for (register int i=; i<=n; i++) {

             upd(i,);

             while (s1[a1].val==i) {

                 Ans[s1[a1].ind]-=que(A[s1[a1].ind])-MOD,Ans[s1[a1].ind]%=MOD;

                 a1++;

             }

             while (s2[a2].val==i) {

                 Ans[s2[a2].ind]+=que(A[s2[a2].ind]),Ans[s2[a2].ind]%=MOD;

                 a2++;

             }

         }

         for (register int i=; i<=q; i++) {

             write(Ans[i]),putchar('\n');

         }

     }

 }

 using namespace Solve;

 int main () {

 //    freopen(".in","r",stdin);

 //    freopen(".out","w",stdout);

     solve();

 }