#include <bits/stdc++.h>

 typedef long long LL;

 const int N = , INF = 0x3f3f3f3f;

 const double eps = 1e-;

 struct Edge {

     int nex, v;

     LL len;

 }edge[N << ]; int tp = ;

 int e[N], _n, root, small, siz[N], deep[N], fa[N], stk[N], top2, stk2[N], SMALL, n;

 LL p[N], q[N], lim[N], d[N], f[N];

 bool del[N];

 inline bool cmp_l(const int &a, const int &b) {

     return lim[a] < lim[b];

 }

 template <class T> inline void Min(T &a, const T &b) {

     a > b ? a = b : ;

     return;

 }

 inline void add(int x, int y, LL z) {

     tp++;

     edge[tp].v = y;

     edge[tp].len = z;

     edge[tp].nex = e[x];

     e[x] = tp;

     return;

 }

 void DFS_1(int x, int f) {

     deep[x] = deep[f] + ;

     fa[x] = f;

     for(int i = e[x]; i; i = edge[i].nex) {

         int y = edge[i].v;

         if(y == f) continue;

         d[y] = d[x] + edge[i].len;

         DFS_1(y, x);

     }

     return;

 }

 void getroot(int x, int f) {

     //printf("getroot : %d  %d \n", x, f);

     int large = ;

     siz[x] = ;

     Min(SMALL, deep[x]);

     for(int i = e[x]; i; i = edge[i].nex) {

         int y = edge[i].v;

         if(del[y] || y == f) continue;

         getroot(y, x);

         siz[x] += siz[y];

         if(siz[y] > large) large = siz[y];

     }

     large = std::max(large, _n - siz[x]);

     if(small > large) {

         small = large;

         root = x;

     }

     return;

 }

 void DFS_2(int x, int f) {

     stk2[++top2] = x;

     //printf("DFS2 : %d \n", x);

     for(int i = e[x]; i; i = edge[i].nex) {

         int y = edge[i].v;

         if(del[y] || y == f) continue;

         DFS_2(y, x);

     }

     return;

 }

 inline bool check(int a, int b, int c) {

     return (long double)(f[b] - f[a]) / (d[b] - d[a]) + eps > (long double)(f[c] - f[b]) / (d[c] - d[b]);

 }

 void DFS_3(int x, int f) {

     siz[x] = ;

     for(int i = e[x]; i; i = edge[i].nex) {

         int y = edge[i].v;

         if(del[y] || y == f) continue;

         DFS_3(y, x);

         siz[x] += siz[y];

     }

     return;

 }

 void DFS_4(int x, int father, int rt) {

     if(x != rt && d[rt] >= lim[x]) {

         Min(f[x], f[rt] - p[x] * d[rt]);

         /*if(x == 5) {

             printf("f %d = %lld rt = %d \n", x, f[x], rt);

         }*/

     }

     for(int i = e[x]; i; i = edge[i].nex) {

         int y = edge[i].v;

         if(y == father || del[y]) continue;

         DFS_4(y, x, rt);

     }

     return;

 }

 void CDQ(int x) {

     //printf("CDQ : %d _n = %d \n", x, _n);

     if(_n == ) {

         f[x] += p[x] * d[x] + q[x];

         del[x] = ;

         //printf("1 : f [ %d ] = %lld \n", x, f[x]);

         return;

     }

     SMALL = small = INF;

     getroot(x, );

     int tempsmall = SMALL;

     x = root;

     DFS_3(x, );

     del[x] = ;

     ///

     if(del[fa[x]]) {

         f[x] += p[x] * d[x] + q[x];

         //printf("2 : f [ %d ] = %lld \n", x, f[x]);

         DFS_4(x, , x);

         for(int i = e[x]; i; i = edge[i].nex) {

             int y = edge[i].v;

             if(del[y]) continue;

             _n = siz[y];

             CDQ(y);

         }

         return;

     }

     _n = siz[fa[x]];

     CDQ(fa[x]);

     /**

         while(top > 1 && check(stk[top - 1], stk[top], temp)) {

             top--;

         }

     */

     top2 = ;

     DFS_2(x, );

     std::sort(stk2 + , stk2 + top2 + , cmp_l);

     std::reverse(stk2 + , stk2 + top2 + );

     int pos = fa[x], top = ;

     //printf(" ----------------- x = %d fa[x] = %d \n", x, fa[x]);

     /*printf("sort : ");

     for(int i = 1; i <= top2; i++) {

         printf("%d ", stk2[i]);

     }

     puts("");*/

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

         int xx = stk2[i];

         while(pos && deep[pos] >= tempsmall && d[pos] >= lim[xx]) {

             /// insert p

             while(top >  && check(pos, stk[top], stk[top - ])) {

                 top--;

             }

             stk[++top] = pos;

             //printf("insert pos = %d \n", pos);

             pos = fa[pos];

         }

         if(!top) continue;

         int l = , r = top;

         //printf("l = %d r = top = %d \n", l, r);

         while(l < r) {

             int mid = (l + r) >> ;

             //printf("mid = %d \n", mid);

             if(l < mid && p[xx] > (long double)(f[stk[mid]] - f[stk[mid - ]]) / (d[stk[mid]] - d[stk[mid - ]])) {

                 r = mid - ;

             }

             else if(mid < r && p[xx] < (long double)(f[stk[mid + ]] - f[stk[mid]]) / (d[stk[mid +]] - d[stk[mid]])) {

                 //printf("-------------- %lld * %lld < %lld \n", p[xx], (d[stk[mid +1]] - d[stk[mid]]), (f[stk[mid + 1]] - f[stk[mid]]));

                 l = mid + ;

             }

             else {

                 r = mid;

                 break;

             }

         }

         //printf("r = %d \n", r);

         /// branch search OVER

         //printf("Min %lld (%lld - %lld * %lld) \n", f[xx], f[stk[r]], p[xx], d[stk[r]]);

         Min(f[xx], f[stk[r]] - p[xx] * d[stk[r]]);

         //printf("%d -> %d  f[%d] = %lld \n", stk[r], xx, xx, f[xx]);

     }

     f[x] += p[x] * d[x] + q[x];

     DFS_4(x, , x);

     //printf("3 : f [ %d ] = %lld  += %lld * %lld + %lld \n", x, f[x], p[x], d[x], q[x]);

     /// rest

     for(int i = e[x]; i; i = edge[i].nex) {

         int y = edge[i].v;

         if(del[y]) continue;

         _n = siz[y];

         CDQ(y);

     }

     return;

 }

 int main() {

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

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

     memset(f, 0x3f, sizeof(f));

     f[] = ;

     int ttt; LL z;

     scanf("%d%d", &n, &ttt);

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

         scanf("%d%lld%lld%lld%lld", &x, &z, &p[i], &q[i], &lim[i]);

         add(x, i, z); add(i, x, z);

     }

     /// input over

     DFS_1(, );

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

         lim[i] = std::max(0ll, d[i] - lim[i]);

     }

     //printf("OVER \n");

     _n = n;

     CDQ();

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

         printf("%lld\n", f[i]);

     }

     return ;

 }