#include <bits/stdc++.h>   using namespace std;   const int MAXN = 200010;   int nowarn;   int n, m;   namespace Tree {   int head[MAXN], nxt[MAXN], to[MAXN], eidx;   void init() {     eidx = 0;     memset(head, -1, sizeof(head));   }   void adde(int u, int v) { to[eidx] = v, nxt[eidx] = head[u], head[u] = eidx++; }   }  // namespace Tree   namespace DFN {   int dfn[MAXN], dfn_cnt, son[MAXN], dep[MAXN], top[MAXN], size[MAXN], pa[MAXN];   void dfs1(int u, int fa, int d) {     using namespace Tree;     pa[u] = fa, dep[u] = d, son[u] = 0, size[u] = 1;     for (int i = head[u]; ~i; i = nxt[i]) {       int v = to[i];       dfs1(v, u, d + 1);       size[u] += size[v];       if (size[v] > size[son[u]]) son[u] = v;     }   }   void dfs2(int u, int tp) {     using namespace Tree;     top[u] = tp, dfn[u] = ++dfn_cnt;     if (son[u]) dfs2(son[u], tp);     for (int i = head[u]; ~i; i = nxt[i]) {       int v = to[i];       if (v == son[u]) continue;       dfs2(v, v);     }   }   void prelude() {     size[0] = dfn_cnt = 0;     dfs1(1, 0, 1);     dfs2(1, 1);   }   int lca(int u, int v) {     while (top[u] != top[v]) {       if (dep[top[u]] < dep[top[v]]) swap(u, v);       u = pa[top[u]];     }     return min(u, v);   }   }  // namespace DFN   int lowbit(int x) { return x & (-x); }   struct BIT {     long long c[MAXN];     void init() { memset(c, 0, sizeof(c)); }     void add(int p, long long v) {       for (; p <= n; p += lowbit(p)) c[p] += v;     }     long long sum(int p) const {       long long s = 0;       for (; p; p -= lowbit(p)) s += c[p];       return s;     }     long long sum(int l, int r) const { return sum(r) - sum(l - 1); }   };   struct Triple {     int first, second, val;     Triple() {}     Triple(int a, int b, int c) : first(a), second(b), val(c) {}   };   vector<Triple> chain[MAXN];   BIT sf, sg;   long long query(int u, int v, const BIT &bit) {     using namespace DFN;     long long s = 0;     while (top[u] != top[v]) {       s += bit.sum(dfn[top[v]], dfn[v]);       v = pa[top[v]];     }     s += bit.sum(dfn[u], dfn[v]);     return s;   }   long long f[MAXN], g[MAXN];   void dp(int u) {     using namespace Tree;     using namespace DFN;     g[u] = 0;     for (int i = head[u]; ~i; i = nxt[i]) dp(to[i]), g[u] += f[to[i]];     sg.add(dfn[u], g[u]);     f[u] = g[u];     for (int i = 0; i < (int)chain[u].size(); ++i) {       Triple tp = chain[u][i];       int s = tp.first, t = tp.second, w = tp.val;       if (t == u) swap(s, t);       if (s == u) {         f[u] = max(f[u], query(u, t, sg) - query(u, t, sf) + w);       } else {         f[u] = max(f[u], query(u, s, sg) + query(u, t, sg) - g[u] -                              query(u, s, sf) - query(u, t, sf) + w);       }     }     sf.add(dfn[u], f[u]);   }   int main() {     nowarn = scanf( %d%d , &n, &m);     Tree::init();     for (int i = 2; i <= n; ++i) {       int p;       nowarn = scanf( %d , &p);       Tree::adde(p, i);     }     DFN::prelude();     while (m--) {       int u, v, w;       nowarn = scanf( %d%d%d , &u, &v, &w);       int lca = DFN::lca(u, v);       chain[lca].push_back(Triple(u, v, w));     }     sf.init(), sg.init();     dp(1);     printf( %lld n , f[1]);     return 0;   }   