#include <bits/stdc++.h>
#include <atcoder/all>
using namespace atcoder;

using namespace std;
using mint = modint998244353;

vector<int> sieve(int limit) {
    vector<char> is(limit+1, true);
    vector<int> primes;
    is[0] = is[1] = false;
    for (int i = 2; i <= limit; ++i) {
        if (is[i]) {
            primes.push_back(i);
            if (i * i <= limit) {
                for (int j = i*i; j <= limit; j += i) is[j] = false;
            }
        }
    }
    return primes;
}

vector<pair<int,int>> factorize(int x, const vector<int>& primes) {
    vector<pair<int,int>> res;
    int t = x;
    for (int p : primes) {
        if (p * p > t) break;
        if (t % p == 0) {
            int c = 0;
            while (t % p == 0) { t /= p; ++c; }
            res.emplace_back(p, c);
        }
    }
    if (t > 1) res.emplace_back(t, 1);
    return res;
}

int main() {
    int n;
    cin >> n;
    
    vector<int> a(n+1);
    for (int i = 1; i <= n; ++i) cin >> a[i];

    vector<vector<int>> g(n+1);
    for (int i = 0; i < n-1; ++i) {
        int u,v; cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }

    vector<int> primes = sieve(31623);

    vector<int> fa(n+1, 0);
    vector<int> ord; ord.reserve(n);
    {
        vector<pair<int,int>> st;
        st.emplace_back(1, 0);
        while (st.size()) {
            auto [v,p] = st.back(); st.pop_back();
            if (v > 0) {
                st.emplace_back(-v, p);
                fa[v] = p;
                for (int to : g[v]) if (to != p) st.emplace_back(to, v);
            } else {
                ord.push_back(-v);
            }
        }
    }

    vector<int> sz(n+1, 1), heavy(n+1, 0);
    for (int v : ord) {
        int p = fa[v];
        for (int to : g[v]) if (to != p) {
            sz[v] += sz[to];
            if (heavy[v] == 0 || sz[to] > sz[heavy[v]]) heavy[v] = to;
        }
    }

    
    vector< unordered_map<int,int>* > mp(n+1, nullptr);
    vector<mint> ans(n+1, 1);

    for (int v : ord) {
        int hv = heavy[v];
        unordered_map<int,int>* base;
        mint base_lcm = 1;
        if (hv != 0) {
            base = mp[hv];
            base_lcm = ans[hv];
        } else {
            base = new unordered_map<int,int>();
        }

        for (int to : g[v]) if (to != fa[v] && to != hv) {
            unordered_map<int,int>* small = mp[to];
            if (!small) continue;
            for (auto &kv : *small) {
                int p = kv.first, e = kv.second;
                int cur = 0;
                auto it = base->find(p);
                if (it != base->end()) cur = it->second;
                if (e > cur) {
                    int delta = e - cur;
                    (*base)[p] = e;
                    base_lcm *= mint(p).pow(delta);
                }
            }
            delete small;
            mp[to] = nullptr;
        }

        auto fac = factorize(a[v], primes);
        for (auto &pe : fac) {
            int p = pe.first, e = pe.second;
            int cur = 0;
            auto it = base->find(p);
            if (it != base->end()) cur = it->second;
            if (e > cur) {
                int delta = e - cur;
                (*base)[p] = e;
                base_lcm *= mint(p).pow(delta);
            }
        }

        mp[v] = base;
        ans[v] = base_lcm;
    }

    for (int i = 1; i <= n; ++i) {
        cout << ans[i].val() << '\n';
    }
    
    return 0;
}