#include <bits/stdc++.h>

template<typename P, typename Q> std::istream& operator>>(std::istream& is, std::pair<P, Q>& v) { std::cin >> v.first >> v.second; return is; }
template<typename P, typename Q> std::ostream& operator<<(std::ostream& os, std::pair<P, Q>& v) { std::cout << v.first << ' ' << v.second; return os; }
template<typename T, std::size_t N> std::istream& operator>>(std::istream& is, std::array<T, N>& v) { for (auto& i : v) is >> i; return is; }
template<typename T, std::size_t N> std::ostream& operator<<(std::ostream& os, std::array<T, N>& v) { for (auto& i : v) os << i << ' '; return os; }
template<typename T> std::istream& operator>>(std::istream& is, std::vector<T>& v) { for (auto& i : v) is >> i; return is; }
template<typename T> std::ostream& operator<<(std::ostream& os, std::vector<T>& v) { for (auto& i : v) os << i << ' '; return os; }
template<typename...Args> void debug(Args...args) { ((std::cerr << args << ' '), ...); std::cerr << '\n'; }
template<typename...Args> void println(Args...args) { ((std::cout << args << ' '), ...); std::cout << '\n'; }
template<typename P, typename Q> void chmax(P& a, Q b) { a = (b > a ? b : a); }
template<typename P, typename Q> void chmin(P& a, Q b) { a = (b < a ? b : a); }

using i64 = long long;

std::vector<int> minp, primes;

void sieve(int n) {
    minp.assign(n + 1, 0);
    primes.clear();

    for (int i = 2; i <= n; i++) {
        if (minp[i] == 0) {
            minp[i] = i;
            primes.push_back(i);
        }

        for (auto p : primes) {
            if (i * p > n) {
                break;
            }
            minp[i * p] = p;
            if (p == minp[i]) {
                break;
            }
        }
    }
}

constexpr int P = 1000000007;

constexpr i64 power(i64 a, i64 b, i64 P = ::P) {
    i64 res = 1;
    for (; b; b /= 2, a = a * a % P) {
        if (b % 2) {
            res = res * a % P;
        }
    }
    return res;
}

constexpr i64 inv(i64 a, i64 b = ::P - 2, i64 P = ::P) {
    i64 res = 1;
    for (; b; b /= 2, a = a * a % P) {
        if (b % 2) {
            res = res * a % P;
        }
    }
    return res;
}

int main() {
    sieve(1000000);
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);

    int n;
    std::cin >> n;

    std::vector<int> a(n);
    std::cin >> a;

    if (n == 1) {
        std::cout << "1\n";
        return 0;
    }

    std::vector<std::vector<std::array<int, 2>>> ps(n);

    for (int i = 0; i < n; i++) {
        int x = a[i];
        while (x > 1) {
            int p = minp[x];
            int t = 0;
            while (x % p == 0) {
                x /= p;
                t++;
            }
            if (t % 2) {
                ps[i].push_back({ p, t });
            }
            x = minp[x];
        }
    }

    int ans = 1;
    for (int i = 0; i < n - 1; i++) {
        std::map<int, int> mp;
        for (auto [x, t] : ps[i]) {
            mp[x] += t;
        }
        for (auto [x, t] : ps[i + 1]) {
            mp[x] += t;
        }

        for (auto [x, t] : mp) {
            if (t % 2) {
                ans = 1LL * ans * x % P;
            }
        }
    }

    int mn = *std::min_element(a.begin(), a.end());
    for (int x : a) {
        if (x == mn) {
            ans = 1LL * ans * inv(mn) % P;
        }
    }
    if (ans < 0) {
        ans += P;
    }

    std::cout << ans << "\n";

    return 0;
}