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

#define CPP_STR(x) CPP_STR_I(x)
#define CPP_CAT(x,y) CPP_CAT_I(x,y)
#define CPP_STR_I(args...) #args
#define CPP_CAT_I(x,y) x ## y

using i8  = int8_t;
using u8  = uint8_t;
using i16 = int16_t;
using u16 = uint16_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;

using f32 = float;
using f64 = double;

#define FOR(i, start, end) for(i64 i = (start), CPP_CAT(i,xxxx_end)=(end); i < CPP_CAT(i,xxxx_end); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPS(i, n) for(i64 i = 1; i <= n; ++i)
#define RREP(i, n) for(i64 i = n - 1; i >= 0 ; --i)
#define RREPS(i, n) for(i64 i = n; i >= 1; --i)

#define ALL(f,c,...) (([&](decltype((c)) cccc) { return (f)(std::begin(cccc), std::end(cccc), ## __VA_ARGS__); })(c))

#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );

#define pb push_back
#define mp make_pair
#define F first
#define S second

template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }

template<typename C>
i64 SIZE(const C& c) { return static_cast<i64>(c.size()); }

template<typename T, size_t N>
i64 SIZE(const T (&)[N]) { return static_cast<i64>(N); }


struct ProconInit {
    static constexpr int IOS_PREC = 15;
    static constexpr bool AUTOFLUSH = false;

    ProconInit() {
        cin.tie(nullptr);
        ios::sync_with_stdio(false);
        cout << fixed << setprecision(IOS_PREC);
        if(AUTOFLUSH)
            cout << unitbuf;
    }
} PROCON_INIT;


template<int MOD>
struct Fp {
    i64 val;
    constexpr Fp(i64 v = 0) noexcept : val(v % MOD) {
        if (val < 0) val += MOD;
    }
    constexpr int getmod() { return MOD; }
    constexpr Fp operator - () const noexcept {
        return val ? MOD - val : 0;
    }
    constexpr Fp operator + (const Fp& r) const noexcept { return Fp(*this) += r; }
    constexpr Fp operator - (const Fp& r) const noexcept { return Fp(*this) -= r; }
    constexpr Fp operator * (const Fp& r) const noexcept { return Fp(*this) *= r; }
    constexpr Fp operator / (const Fp& r) const noexcept { return Fp(*this) /= r; }
    constexpr Fp& operator += (const Fp& r) noexcept {
        val += r.val;
        if (val >= MOD) val -= MOD;
        return *this;
    }
    constexpr Fp& operator -= (const Fp& r) noexcept {
        val -= r.val;
        if (val < 0) val += MOD;
        return *this;
    }
    constexpr Fp& operator *= (const Fp& r) noexcept {
        val = val * r.val % MOD;
        return *this;
    }
    constexpr Fp& operator /= (const Fp& r) noexcept {
        i64 a = r.val, b = MOD, u = 1, v = 0;
        while (b) {
            i64 t = a / b;
            a -= t * b; swap(a, b);
            u -= t * v; swap(u, v);
        }
        val = val * u % MOD;
        if (val < 0) val += MOD;
        return *this;
    }
    constexpr bool operator == (const Fp& r) const noexcept {
        return this->val == r.val;
    }
    constexpr bool operator != (const Fp& r) const noexcept {
        return this->val != r.val;
    }
    constexpr bool operator > (const Fp& r) const noexcept {
        return this->val > r.val;
    }
    constexpr bool operator >= (const Fp& r) const noexcept {
        return this->val >= r.val;
    }
    friend constexpr ostream& operator << (ostream &os, const Fp<MOD>& x) noexcept {
        return os << x.val;
    }
    friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, i64 n) noexcept {
        if (n == 0) return 1;
        auto t = modpow(a, n / 2);
        t = t * t;
        if (n & 1) t = t * a;
        return t;
    }
};


using P = pair<i64, i64>;

struct Sieve {
    i64 n;
    vector<i64> f, primes;

    Sieve(i64 n = 1) : n(n), f(n + 1) {
        f[0] = f[1] = -1;
        for (i64 i = 2; i <= n; i++) {
            if (f[i]) continue;
            primes.push_back(i);
            f[i] = i;
            for (i64 j = i * i; j <= n; j += i) {
                if (f[j] == 0) f[j] = i;
            }
        }
    }

    bool is_prime(i64 x) {
        return f[x] == x;
    }

    vector<i64> factor_list(i64 x) {
        vector<i64> res;
        while (x != 1) {
            res.push_back(f[x]);
            x /= f[x];
        }
        return res;
    }

    vector<P> factor(i64 x) {
        vector<i64> fl = factor_list(x);
        if (fl.size() == 0) return {};
        vector<P> res(1, P(fl[0], 0));
        for (i64 p : fl) {
            if (res.back().first == p) {
                res.back().second++;
            } else {
                res.emplace_back(p, 1);
            }
        }
        return res;
    }
};

#define MOD 1'000'000'007
#define MAX_A 1'000'000
using mint = Fp<MOD>;


int main() {
    // (1) a1b1 = a2b2 = ... = a_n * b_n = K
    // a1 <= a2 <= ... <= a_n
    // b1 = K / a1
    // b2 = K / a2
    // ...
    // b_n = K / a_n
    // b1 >= b2 >= ... >= b_n

    // Kを大きくすると、b_nも大きくなる
    // min{b1, ..., b_n} = b_nなので、b1 + ... + b_nも大きくなる
    // 結局、求めるのは(1)を満たすKで最小のもの
    // Kは a1, ..., a_n を約数にもつもので最小
    // b1 = K / a1
    i64 N; cin >> N;
    vector<i64> A(N);
    REP(i, N) cin >> A[i];

    Sieve sieve(MAX_A);

    unordered_map<i64, i64> mp;
    REP(i, N) {
        auto f = sieve.factor(A[i]);
        for (auto p : f) {
            chmax(mp[p.first], p.second);
        }
    }

    mint lcm = 1;
    for (auto p : mp) {
        REP(i, p.second) {
            lcm *= p.first;
        }
    }

    mint ans = 0;
    REP(i, N) {
        ans += lcm / (mint)A[i];
    }
    cout << ans << endl;

    return 0;
}

Measured memory_bytes: 9336