#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

// using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


using Int = __int128;
constexpr Int INF = (Int)1001001001001001001LL * (Int)1001001001001001001LL;

int N;
vector<int> A, B;
vector<Int> C;
vector<Int> P, Q;

vector<Int> ans;

vector<vector<int>> G;
vector<int> sz, del;
void dfsSz(int u, int p) {
  sz[u] = 1;
  for (const int i : G[u]) {
    const int v = A[i] ^ B[i] ^ u;
    if (v != p) {
      dfsSz(v, u);
      sz[u] += sz[v];
    }
  }
}
string dfsString(int u, int p) {
  ostringstream oss;
  oss << "[" << u;
  for (const int i : G[u]) {
    const int v = A[i] ^ B[i] ^ u;
    if (!del[v] && v != p) {
      oss << " " << dfsString(v, u);
    }
  }
  oss << "]";
  return oss.str();
}
/// vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
vector<vector<pair<int, Int>>> rcss;
void dfs(int j, int u, int p, int d, int r, Int c) {
  rcss[u].emplace_back(r, c);
  for (const int i : G[u]) {
    const int v = A[i] ^ B[i] ^ u;
    if (!del[v] && v != p) {
      dfs(j, v, u, d + 1, r, c + C[i]);
    }
  }
}
/// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
void solveSubtree(int depth, int r) {
#ifdef LOCAL
  cerr << string(2 * depth, ' ') << "solveSubtree " << dfsString(r, -1) << endl;
#endif
  vector<int> is, vs;
  for (const int i : G[r]) {
    const int v = A[i] ^ B[i] ^ r;
    if (!del[v]) {
      is.push_back(i);
      vs.push_back(v);
    }
  }
  const int len = vs.size();
  /// vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
  rcss[r].emplace_back(r, 0);
  for (int j = 0; j < len; ++j) {
    const int i = is[j], v = vs[j];
    dfs(j, v, r, 1, r, C[i]);
  }
  /// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
}
void solveRec(int depth, int u) {
  for (; ; ) {
    int vm = -1;
    for (const int i : G[u]) {
      const int v = A[i] ^ B[i] ^ u;
      if (!del[v]) {
        if (!~vm || sz[vm] < sz[v]) {
          vm = v;
        }
      }
    }
    if (!~vm || 2 * sz[vm] <= sz[u]) {
      solveSubtree(depth, u);
      del[u] = 1;
      for (const int i : G[u]) {
        const int v = A[i] ^ B[i] ^ u;
        if (!del[v]) {
          solveRec(depth + 1, v);
        }
      }
      break;
    } else {
      sz[u] -= sz[vm];
      sz[vm] += sz[u];
      u = vm;
    }
  }
}
void centroidDecomp() {
  sz.assign(N, 0);
  dfsSz(0, -1);
  del.assign(N, 0);
  solveRec(0, 0);
}


// floor(a / b)
Int divFloor(Int a, Int b) {
  return a / b - (((a ^ b) < 0 && a % b != 0) ? 1 : 0);
}

// ceil(a / b)
Int divCeil(Int a, Int b) {
  return a / b + (((a ^ b) > 0 && a % b != 0) ? 1 : 0);
}

// p + q x,  q: decreasing
struct Convex {
  int len;
  vector<pair<Int, Int>> pqs;
  vector<Int> xs;
  Convex() : len(0), pqs{}, xs{} {}
  void add(Int p, Int q) {
    if (len >= 1) {
      assert(pqs[len-1].second >= q);
    }
    if (len >= 1 && pqs[len-1].second == q && pqs[len-1].first <= p) {
      return;
    }
    for (; len >= 1; --len) {
      if (pqs[len-1].second == q) {
        continue;
      }
      const Int x = divFloor(-(pqs[len-1].first - p), (pqs[len-1].second - q));
      if (xs[len-1] < x) {
        ++len;
        pqs.resize(len); pqs.back() = make_pair(p, q);
        xs.resize(len); xs.back() = x;
        return;
      }
    }
    ++len;
    pqs.emplace_back(p, q);
    xs.emplace_back(-INF);
  }
  Int get(Int x) const {
    if (len == 0) {
      return INF;
    }
    const int pos = upper_bound(xs.begin(), xs.end(), x) - xs.begin() - 1;
    Int ret = INF;
    for (int i = pos - 2; i <= pos + 2; ++i) if (0 <= i && i < len) {
      chmin(ret, pqs[i].first + pqs[i].second * x);
    }
    return ret;
  }
};
vector<Convex> cons;

void Add(int u) {
  for (const auto &rc : rcss[u]) {
    const int r = rc.first;
    const Int c = rc.second;
// cerr<<"Add "<<u<<" "<<rc<<" "<<(ans[u]+P[u]+Q[u]*c)<<" "<<Q[u]<<endl;
    cons[r].add(ans[u] + P[u] + Q[u] * c, Q[u]);
  }
}
Int Get(int u) {
  Int ret = INF;
  for (const auto &rc : rcss[u]) {
    const int r = rc.first;
    const Int c = rc.second;
    const Int res = cons[r].get(c);
// cerr<<"Get "<<u<<" "<<rc<<" = "<<res<<endl;
    chmin(ret, res);
  }
  return ret;
}

void run() {
  G.assign(N, {});
  for (int i = 0; i < N - 1; ++i) {
    G[A[i]].push_back(i);
    G[B[i]].push_back(i);
  }
  rcss.assign(N, {});
  centroidDecomp();
// cerr<<"rcss = "<<rcss<<endl;
  
  vector<pair<Int, int>> qus(N);
  for (int u = 0; u < N; ++u) {
    qus[u] = make_pair(-Q[u], u);
  }
  sort(qus.begin(), qus.end());
  ans.assign(N, INF);
  ans[0] = 0;
  cons.assign(N, Convex());
  for (const auto &qu : qus) {
    const int u = qu.second;
    chmin(ans[u], Get(u));
    if (ans[u] < INF) {
      Add(u);
    }
  }
  for (int u = 0; u < N; ++u) {
    chmin(ans[u], Get(u));
  }
}

std::vector<long long> travel(
    std::vector<long long> P_,
    std::vector<int> Q_,
    std::vector<int> A_,
    std::vector<int> B_,
    std::vector<int> C_)
{
  N = P_.size();
  A = A_;
  B = B_;
  C = vector<Int>(C_.begin(), C_.end());
  P = vector<Int>(P_.begin(), P_.end());
  Q = vector<Int>(Q_.begin(), Q_.end());
  run();
  return vector<long long>(ans.begin() + 1, ans.end());
}