#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int MOD;
struct modint {
 private:
  int v;
  static int minv(int a, int m) {
    a %= m;
    assert(a);
    return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
  }

 public:
  modint() : v(0) {}
  modint(ll v_) : v(int(v_ % MOD)) {
    if (v < 0) v += MOD;
  }
  explicit operator int() const { return v; }
  friend std::ostream& operator<<(std::ostream& out, const modint& n) {
    return out << int(n);
  }
  friend std::istream& operator>>(std::istream& in, modint& n) {
    ll v_;
    in >> v_;
    n = modint(v_);
    return in;
  }
  friend bool operator==(const modint& a, const modint& b) {
    return a.v == b.v;
  }
  friend bool operator!=(const modint& a, const modint& b) {
    return a.v != b.v;
  }
  modint inv() const {
    modint res;
    res.v = minv(v, MOD);
    return res;
  }
  friend modint inv(const modint& m) { return m.inv(); }
  modint neg() const {
    modint res;
    res.v = v ? MOD - v : 0;
    return res;
  }
  friend modint neg(const modint& m) { return m.neg(); }
  modint operator-() const { return neg(); }
  modint operator+() const { return modint(*this); }
  modint& operator++() {
    v++;
    if (v == MOD) v = 0;
    return *this;
  }
  modint& operator--() {
    if (v == 0) v = MOD;
    v--;
    return *this;
  }
  modint& operator+=(const modint& o) {
    v += o.v;
    if (v >= MOD) v -= MOD;
    return *this;
  }
  modint& operator-=(const modint& o) {
    v -= o.v;
    if (v < 0) v += MOD;
    return *this;
  }
  modint& operator*=(const modint& o) {
    v = int(ll(v) * ll(o.v) % MOD);
    return *this;
  }
  modint& operator/=(const modint& o) { return *this *= o.inv(); }
  friend modint operator++(modint& a, int) {
    modint r = a;
    ++a;
    return r;
  }
  friend modint operator--(modint& a, int) {
    modint r = a;
    --a;
    return r;
  }
  friend modint operator+(const modint& a, const modint& b) {
    return modint(a) += b;
  }
  friend modint operator-(const modint& a, const modint& b) {
    return modint(a) -= b;
  }
  friend modint operator*(const modint& a, const modint& b) {
    return modint(a) *= b;
  }
  friend modint operator/(const modint& a, const modint& b) {
    return modint(a) /= b;
  }
};
namespace IO {
template <class T>
void _R(T& x) {
  cin >> x;
}
void _R(int& x) { scanf("%d", &x); }
void _R(ll& x) { scanf("%lld", &x); }
void _R(double& x) { scanf("%lf", &x); }
void _R(char& x) { x = getchar(); }
void _R(char* x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T& head, U&... tail) {
  _R(head), R(tail...);
}
template <class T>
void _W(const T& x) {
  cout << x;
}
void _W(const int& x) { printf("%d", x); }
void _W(const ll& x) { printf("%lld", x); }
void _W(const double& x) { printf("%.16f", x); }
void _W(const char& x) { putchar(x); }
void _W(const char* x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U>& x) {
  _W(x.first), putchar(' '), _W(x.second);
}
template <class T>
void _W(const vector<T>& x) {
  for (auto i = x.begin(); i != x.end(); _W(*i++))
    if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T& head, const U&... tail) {
  _W(head), putchar(sizeof...(tail) ? ' ' : '\n'), W(tail...);
}
}  // namespace IO
using namespace IO;
template <typename T>
T pow(T a, long long b) {
  assert(b >= 0);
  T r = 1;
  while (b) {
    if (b & 1) r *= a;
    b >>= 1;
    a *= a;
  }
  return r;
}
const int maxn = 1e5 + 50;
const int maxp = 1e5 * 32 + 50;
int tot = 0, n;
int ls[maxp], rs[maxp], mx[maxp];
ll sum[maxp];
void pushup(int x) {
  if (mx[ls[x]] >= mx[rs[x]]) {
    mx[x] = mx[ls[x]];
    sum[x] = sum[ls[x]];
    if (mx[ls[x]] == mx[rs[x]]) sum[x] += sum[rs[x]];
  } else {
    mx[x] = mx[rs[x]];
    sum[x] = sum[rs[x]];
  }
}
void insert(int& x, int l, int r, int y) {
  if (!x) x = ++tot;
  sum[x] = y, mx[x] = 1;
  if (l == r) return;
  int mid = l + r >> 1;
  if (y <= mid)
    insert(ls[x], l, mid, y);
  else
    insert(rs[x], mid + 1, r, y);
}
void merge(int& x, int y, int l, int r) {
  if (!x) {
    x = y;
    return;
  }
  if (!y) return;
  if (l == r) {
    mx[x] += mx[y];
    return;
  }
  int mid = l + r >> 1;
  merge(ls[x], ls[y], l, mid);
  merge(rs[x], rs[y], mid + 1, r);
  pushup(x);
}
int p[maxn], x[maxn];
ll res[maxn];
vector<int> e[maxn];
void dfs(int u, int pre) {
  insert(p[u], 1, n, x[u]);
  for (auto v : e[u]) {
    if (v == pre) continue;
    dfs(v, u);
    merge(p[u], p[v], 1, n);
  }
  res[u] = sum[p[u]];
}
int main() {
  R(n);
  for (int i = 1; i <= n; ++i) R(x[i]);
  for (int i = 1; i < n; ++i) {
    int u, v;
    R(u, v);
    e[u].push_back(v);
    e[v].push_back(u);
  }
  dfs(1, 0);
  W(vector<ll>(res + 1, res + 1 + n));
  return 0;
}
