#nullable enable

#region
var _input = Array.Empty<string>();
var _iter = 0;
string String()
{
    while (_iter >= _input.Length) (_input, _iter) = (Console.ReadLine()!.Trim().Split(' '), 0);
    return _input[_iter++];
}
T I<T>() where T : IParsable<T> => T.Parse(String(), null);
#endregion

T[] Range<T>(int n, Func<T> F) => Enumerable.Range(0, n).Select(_ => F()).ToArray();

var n = I<int>();
var az = Range(n, I<int>);
var g = Range(n, () => new List<int>());
for (var i = 1; i < n; i++)
{
    var u = I<int>() - 1;
    var v = I<int>() - 1;
    g[u].Add(v);
    g[v].Add(u);
}

const int Mod = 998244353;
var max = az.Max();
var primes = new Prime(max).Primes;
var kl = 0;
while (kl < primes.Length && primes[kl] * primes[kl] <= max) kl++;
var ptz = Range(kl, () => new List<long>());
for (var i = 0; i < kl; i++)
{
    var pt = ptz[i];
    var p = primes[i];
    var last = 1L;
    while (last <= max)
    {
        pt.Add(last);
        last *= p;
    }
}
var ans = new long[n];
ans.AsSpan().Fill(1);

int[] S(int v, int prev, ReadOnlySpan<int> primes)
{
    var res = new int[kl];
    var a = az[v];
    for (var i = 0; i < kl; i++)
    {
        var p = primes[i];
        while (a % p == 0)
        {
            a /= p;
            res[i]++;
        }
    }
    az[v] = a;
    foreach (var next in g[v]) if (next != prev)
    {
        var nl = S(next, v, primes);
        for (var i = 0; i < kl; i++) res[i] = Math.Max(res[i], nl[i]);
    }
    for (var i = 0; i < kl; i++) ans[v] = ans[v] * ptz[i][res[i]] % Mod;
    return res;
}
S(0, -1, primes);

var invz = new Dictionary<int, long>();
for (var i = kl; i < primes.Length; i++)
{
    var p = primes[i];
    var power = Mod - 2;
    var v = 1L;
    var t = (long)p;
    while (power > 0)
    {
        if ((power & 1) != 0) v = v * t % Mod;
        t = t * t % Mod;
        power >>= 1;
    }
    invz[p] = v;
}

(HashSet<int>, long) T(int v, int prev)
{
    var rs = new HashSet<int>();
    long rv = az[v];
    if (rv > 1) rs.Add((int)rv);
    foreach (var next in g[v]) if (next != prev)
    {
        var (ns, nv) = T(next, v);
        if (ns.Count > rs.Count) (rs, rv, ns, nv) = (ns, nv, rs, rv);
        rv = rv * nv % Mod;
        foreach (var p in ns)
        {
            if (rs.Contains(p)) rv = rv * invz[p] % Mod;
            else rs.Add(p);
        }
    }
    ans[v] = ans[v] * rv % Mod;
    return (rs, rv);
}
T(0, -1);

Console.WriteLine(string.Join(Environment.NewLine, ans));

class Prime
{
    readonly ReadOnlyMemory<int> _sieve;
    readonly ReadOnlyMemory<int> _primes;
    public ReadOnlySpan<int> Sieve => _sieve.Span;
    public ReadOnlySpan<int> Primes => _primes.Span;

    public Prime(int n)
    {
        if (n <= 3) n = 3;
        var sieve = new int[n + 1];
        var (d, i) = (2, 5);
        var primes = new List<int>(){ 2, 3 };
        var span = sieve.AsSpan();
        span[1] = 1;
        for (var j = 2; j <= n; j += 2) span[j] = 2;
        for (var j = 3; j <= n; j += 3) span[j] = 3;
        while (i <= n)
        {
            if (span[i] == 0)
            {
                primes.Add(i);
                for (var j = i; j <= n; j += i) span[j] = i;
            }
            i += d;
            d ^= 6;
        }
        _sieve = sieve;
        _primes = primes.ToArray();
    }
}