//#pragma GCC optimize("Ofast")
//#pragma GCC optimize ("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>

using namespace std;

//#define int long long
const int N = 100005, P = 19;
const int M = 1e6 + 5;

int a[N];
struct Edge {
    int u, v, g;
    Edge(int u, int v, int g): u(u), v(v),g(g) {}
    Edge(){}
};
vector<Edge > edges;

int prime[M];

void seive(){
    for(int i = 2; i < M; ++i){
        if (prime[i]) continue;
        for(int j = i; j < M; j += i)
            prime[j] = i;
    }
}
bool vis[M];

struct {
    int par[N], rnk[N];
    void init(int n){
        for(int i = 1; i <= n; ++i)
            par[i] = i, rnk[i] = 1;
    }
    int findParent(int u){
        return par[u] = (par[u] == u ? u : findParent(par[u]));
    }
    bool merge(int u, int v){
        u = findParent(u);
        v = findParent(v);
        if(u == v)return false;
        if(rnk[u] < rnk[v])
            swap(u,v);
        par[v] = u;
        rnk[u] += rnk[v];
        return true;
    }

}dsu;
signed main() {
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int n;
    cin >> n;
    seive();
    for(int i = 1; i <= n; ++i)
        cin >> a[i];
    int u , v;
    set<int> st;
    for(int i = 0; i < n - 1; ++i){
        cin >> u >> v;
        int gc = __gcd(a[u],a[v]);
        if(gc == 1)continue;
        edges.emplace_back(u,v, gc);
        if(!vis[gc]){
            int x = gc;
            for (int p = prime[x]; p > 1; p = prime[x]) {
                st.insert(p);
                for (; x % p == 0; x /= p);
            }
            vis[gc] = 1;
        }
    }
    dsu.init(n);

    int ans = 0;
    vector<pair<int, int> > changes;
    for(auto &gc: st){
        for(int i = 0; i < edges.size(); ++i){
            if(edges[i].g % gc == 0){
                bool res = dsu.merge(edges[i].u, edges[i].v);
                if(res)changes.emplace_back(edges[i].u, edges[i].v);
            }
        }
        for(auto &[u,v]: changes){
            ans = max(ans, dsu.rnk[dsu.findParent(u)]);
            ans = max(ans, dsu.rnk[dsu.findParent(v)]);
        }
        for(auto &[u,v ]: changes){
            dsu.par[u] = u;
            dsu.par[v] = v;
            dsu.rnk[u] = dsu.rnk[v] = 1;
        }
        changes.clear();
    }
    cout << ans << '\n';

    return 0;
}