#include <bits/stdc++.h>

template <class T>
int S(T &c) {
  return c.size();
}
template <class T>
using V = std::vector<T>;
using ll = long long;

struct slice {
  V<ll> *a, *b;
  int l, r;
  ll d;
  int pop_back(int k, auto f) {
    if (r > l) {
      for (int i = std::__lg(r - l); ~i; i--)
        if (r - (1 << i) >= l && (*a)[r - (1 << i)] + d - k + f(r - (1 << i) - l) < 0) r -= 1 << i;
    }
    while ((*a)[r] + d - k + f(r - l) < 0) assert(r > l), --r;
    ll t = std::min<ll>((*a)[r] + d, k - f(r - l + 1));
    d -= t;
    return t;
  }
  ll front() { return (*a)[l] + d; }
  ll sum() { return (*b)[l] - (*b)[r + 1] + (r - l + 1) * d; }
};

struct luck {
  V<ll> a, b;
  ll d, p, q, s;
  V<std::pair<ll *, ll>> stk;
  luck() : d(0), p(0), q(0) {}
  luck(int n, int p) : a(n), b(n + 1), d(0), p(p), q(n) {}
  void add(const luck &o, ll sgn) {
    stk.emplace_back(&q, q);
    for (int i = o.p; i < o.q; i++) {
      stk.emplace_back(&a[i - o.p + p], a[i - o.p + p]);
      if (i - o.p + p == q)
        a[q++] = -d + (o.a[i] + o.d) * sgn;
      else
        a[i - o.p + p] += (o.a[i] + o.d) * sgn;
    }
    for (int i = o.q - o.p + p - 1; i >= p; i--) {
      stk.emplace_back(&b[i], b[i]);
      b[i] = b[i + 1] + a[i];
    }
  }
  void push_front(ll v) {
    stk.emplace_back(&p, p);
    stk.emplace_back(&a[p - 1], a[p - 1]);
    stk.emplace_back(&b[p - 1], b[p - 1]);
    a[p - 1] = a[p] + v;
    b[p - 1] = b[p] + a[p - 1];
    --p;
  }
  void pop_back(ll k) {
    stk.emplace_back(&q, q);
    stk.emplace_back(&d, d);
    d -= k;
    if (p == q) return;
    for (int i = std::__lg(q - p); ~i; i--)
      if (q - (1 << i) > p && a[q - (1 << i)] + d < 0) q -= 1 << i;
  }
  void undo(int k) {
    while (S(stk) > k) {
      auto [a, b] = stk.back();
      *a = b, stk.pop_back();
    }
  }
  std::pair<luck, slice> split(int s) {
    luck re(s, 0);
    for (int i = 0; i < s; i++) {
      if (p + i < q) re.a[i] = a[p + i] + d;
      if (p + s < q) re.a[i] -= a[p + s] + d;
    }
    slice t = {&a, &b, (int)p + s, (int)q - 1, d};
    return std::make_pair(re, t);
  }
  ll operator[](int x) { return p + x < q ? a[p + x] + d : 0; }
};

int main() {
  std::cin.tie(0)->sync_with_stdio(0);
  int n;
  std::cin >> n;
  V<int> a(n + 1), b(n + 1);
  for (int i = 1; i <= n; i++) std::cin >> a[i];
  for (int i = 1; i <= n; i++) std::cin >> b[i];
  V<V<int>> g(n + 1);
  for (int i = 1; i < n; i++) {
    int u, v;
    std::cin >> u >> v;
    g[u].push_back(v);
    g[v].push_back(u);
  }
  V<int> son(n + 1), siz(n + 1), dep(n + 1), tp(n + 1), fa(n + 1), bk(n + 1);
  V<luck> c(n + 1);
  auto dfs1 = [&](auto &self, int u, int ff) -> void {
    siz[u] = 1, fa[u] = ff, dep[u] = dep[ff] + 1;
    for (int v : g[u])
      if (v != ff) {
        self(self, v, u);
        siz[u] += siz[v];
        son[u] = siz[v] > siz[son[u]] ? v : son[u];
      }
  };
  auto dfs2 = [&](auto &self, int u, int t) -> void {
    tp[u] = t;
    if (son[u]) self(self, son[u], t);
    if (!son[u]) {
      c[tp[u]] = luck(siz[tp[u]] + 1, dep[u] - dep[tp[u]] + 1);
    }
    bk[u] = S(c[tp[u]].stk);
    for (int v : g[u])
      if (v != fa[u] && v != son[u]) {
        self(self, v, v);
        c[tp[u]].add(c[v], 1);
      }
    c[tp[u]].push_front(a[u]);
    c[tp[u]].pop_back(a[u] - b[u]);
  };
  V<ll> ans(n + 1);
  using info = std::pair<std::deque<std::pair<int, slice>>, luck>;
  auto push_front = [&](info &o, int k) {
    o.second.push_front(k);
    for (auto &[a, b] : o.first) a += 1;
  };
  auto pop_back = [&](info &o, int k) {
    auto &[ve, f] = o;
    int tk = 0, bk = k;
    while (ve.size() && f[ve.back().first] + ve.back().second.front() <= k) {
      tk += ve.back().second.front(), k -= ve.back().second.front();
      ve.pop_back();
    }
    if (ve.size()) {
      if (f[ve.back().first + ve.back().second.r - ve.back().second.l + 1] < k)
        tk += ve.back().second.pop_back(k, [&](int i) {
          return f[i + ve.back().first];
        });
    }
    f.pop_back(bk - tk);
  };
  auto calc = [&](info &o) {
    ll ans = 0;
    auto &[ve, f] = o;
    ans += f.b[f.p + 1] - f.b[f.q] + (f.q - f.p - 1) * f.d;
    for (auto [d, s] : ve) ans += (d - 1) * s.front() + s.sum();
    return ans;
  };
  auto dfs3 = [&](auto &self, int u, info &o) -> void {
    auto &[ve, f] = o;
    auto bve = ve;
    int vid = S(f.stk);
    c[tp[u]].undo(bk[u]);
    for (int v : g[u])
      if (v != fa[u] && v != son[u]) f.add(c[tp[v]], 1);
    ve.emplace_front(0, c[tp[u]].split(0).second);
    int tvid = S(f.stk);
    push_front(o, a[u]);
    pop_back(o, a[u] - b[u]);
    ans[u] = calc(o);
    f.undo(tvid);
    ve = bve;
    for (int v : g[u])
      if (v != fa[u] && v != son[u]) {
        int vid = S(f.stk);
        auto bve = ve;
        auto [ta, tb] = c[tp[u]].split(siz[v]);
        f.add(c[tp[v]], -1);
        f.add(ta, 1);
        if (tb.l <= tb.r) ve.emplace_front(siz[v], tb);
        push_front(o, a[u]);
        pop_back(o, a[u] - b[u]);
        self(self, v, o);
        f.undo(vid);
        ve = bve;
      }
    push_front(o, a[u]);
    pop_back(o, a[u] - b[u]);
    if (son[u]) 
      self(self, son[u], o);
    f.undo(vid);
    ve = bve;
  };
  dfs1(dfs1, 1, 0);
  dfs2(dfs2, 1, 1);
  info o = {{}, luck(2 * n, n)};
  dfs3(dfs3, 1, o);
  for (int i = 1; i <= n; i++) std::cout << ans[i] << ' ';
  std::cout << '\n';
}