#include<iostream>

 #include<cstdio>

 #include<cstring>

 #include<string>

 #include<cmath>

 #include<algorithm>

 #include<queue>

 #include<map>

 using namespace std;

 typedef long long ll;

 const int maxn=1e5+;

 const int maxm=maxn;

 const ll mod=1e18;

 int fa[maxn];

 ll dep[maxn];

 ll dp[maxn];

 struct node{

     ll v;

     ll f;

 }g[maxn];

 struct edge{

     int to;

     int nxt;

     ll w;

 }e[*maxm];

 int tot;

 int n;

 int head[maxn];

 void init(){

     memset(head,-,sizeof(head));

     tot=;

     memset(dp,-,sizeof(dp));

     memset(dep,,sizeof(dep));

 }

 void add(int u,int v,ll w){

     e[tot].to=v;

     e[tot].w=w;

     e[tot].nxt=head[u];

     head[u]=tot++;

 }

 ll dis(int u,int v){

     ll tmp=g[u].f-(dep[v]-dep[u]);

     tmp=tmp*tmp;

     tmp=g[u].v-tmp;

     return tmp;

 }

 void update(int son,int u){

     if(u==) return;

     dp[u]=max(dp[u],dp[son]+dis(u,son));

     update(son,fa[u]);

 }

 void dfs(int u){

     for(int i=head[u];i!=-;i=e[i].nxt){

         int v=e[i].to;

         if(v<u) continue;

         dfs(v);

     }

     if(dp[u]==-) dp[u]=;

     update(u,fa[u]);

 }

 void getdepth(int u){

     for(int i=head[u];i!=-;i=e[i].nxt){

         int v=e[i].to;

         ll w=e[i].w;

         if(v<u) continue;

         dep[v]=dep[u]+w;

         getdepth(v);

     }

 }

 ll work(){

     getdepth();

     dfs();

     ll ans=;

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

         ans=(ans+dp[i])%mod;

     }

     return ans;

 }

 int main(){

     int T;

     scanf("%d",&T);

     while(T--){

         init();

         scanf("%d",&n);

         int u;

         ll d,v,f;

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

             scanf("%d%lld%lld%lld",&u,&d,&v,&f);

             g[i].v=v;

             g[i].f=f;

             add(u,i,d);

             add(i,u,d);

             fa[i]=u;

         }

         ll ans=work();

         printf("%lld\n",ans);

     }

     return ;

 }