// Copyright (c) 2023, Le Duc Phuc Long

/*If you don't think twice, you have to code twice.*/

// Include
#include <bits/stdc++.h>  // NOLINT
// #include <conio.h>

// Namespace
using namespace std;  // NOLINT

// Define
#define nln '\n'

// Typedef and Struct
typedef int64_t lo;

// Constant

// Declare global variables.
vector<lo> prm;
// End of global variable declaration.

bool is_prime(lo n) {
    if (n < 2) return false;
    for (lo i = 2; i <= round(sqrt(n)); ++i)
        if (n % i == 0) return false;
    return true;
}

void precompute() {
    lo limit = 1e7, prd = 1;
    for (lo i = 2; i <= limit; i++) {
        if (prd > limit)
            break;
        if (is_prime(i)) {
            prd *= i;
            prm.push_back(i);
        }
    }
}

class Disjoint_set {
    private:
    public:
    lo *par, *rnk, n;

    Disjoint_set(lo n) {
        this->n = n;
        par = new lo[n+1], rnk = new lo[n+1];
        for (lo i = 1; i <= n; ++i)
            par[i] = i, rnk[i] = 0;
    }

    ~Disjoint_set() {
        delete[] par, delete[] rnk;
    }

    lo Find(lo v) {
        if (par[v] == v)
            return v;
        lo p = Find(par[v]);
        par[v] = p;
        return par[v];
    }

    void Union(lo u, lo v) {
        lo par_u = Find(u), par_v = Find(v);
        if (rnk[par_u] < rnk[par_v]) {
            par[par_u] = par_v;
        } else {
            par[par_v] = par_u;
            if (rnk[par_u] == rnk[par_v])
                rnk[par_u]++;
        }
    }

    lo Biggest_set() {
        lo mav = 0;
        map<lo, lo> cnt;
        for (lo i = 1; i <= n; ++i) {
            lo pi = Find(i);
            cnt[pi]++;
            mav = max(mav, cnt[pi]);
        }
        return mav;
    }
};

void solve() {
    // Input
    lo n;   cin >> n;
    set<lo> sav;
    vector<lo> arr(n+1);
    for (lo i = 1; i <= n; ++i) {
        cin >> arr[i];
        sav.insert(arr[i]);
    }
    vector<pair<lo, lo>> edges(n-1);
    for (auto &p : edges)
        cin >> p.first >> p.second;
    // Solve
    // Special case
    if (arr[1] == 1 and sav.size() == 1) {
        cout << 0 << nln;
        return;
    }
    // Another special case, when all nodes are prime ans the same value
    map<lo, set<lo>> clt;
    for (auto &e : edges)
        if (arr[e.first] == arr[e.second]) {
            clt[arr[e.first]].insert(e.first);
            clt[arr[e.first]].insert(e.second);
        }
    lo s_ans = 0;
    for (auto &p : clt)
        if (p.second.size() > s_ans)
            s_ans = p.second.size();
    // Process the latter case
    lo ans = 1;  // at least 1 is size of sastified subtree
    // Use Disjoint Set
    for (auto p : prm) {
        Disjoint_set s(n);
        for (auto e : edges) 
            if (__gcd(arr[e.first], arr[e.second]) % p == 0)
                s.Union(e.first, e.second);
        ans = max(ans, s.Biggest_set());
    }
    cout << max(ans, s_ans) << nln;
}

int main(int argc, char* argv[]) {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    cin.tie(0)->sync_with_stdio(0);
    cout.tie(0)->sync_with_stdio(0);
    int T = 1;
    // cin >> T;
    precompute();
    while (T--) {
        solve();
    }
    cerr << "It's ok Long, Good for now !!" << nln;
    return 0;
}