#include<iostream>
#include<vector>
#include<utility>
#include<map>

/*
A = 2 3 4
B = 60 40 20 -> 130
このようなBの列の和が最小となるBを求める. 今回なら
B = 6 4 3 -> 13

どうやって求めるか？
条件を満たすBを考えるとK = A_i B_iが任意のiで成立する
従ってKはA_i(i = 0, 1, ...)の公倍数である
またこのときの和は\sum B_i = \sum K / A_i
なのでこれが最小となるためにはそのような最小のKを取れば良い.
つまりA_i(i = 0, 1, ...)の最小公倍数を取ればよい

but !
最小公倍数を取ろうとすると桁がでかすぎておそらく入らない
-> 素因数分解した形を持つようにする
A_iを素因数分解していて素数pの累乗の最大値を取れば良い


おまけ：
桁が入らない -> boostの多倍長整数を使用するのもあり
*/

using ll = long long;
const ll mod = 1e9 + 7;
const int maxA = 1e6;

struct mint {
  ll x; // typedef long long ll;
  mint(ll x=0):x((x%mod+mod)%mod){}
  mint operator-() const { return mint(-x);}
  mint& operator+=(const mint a) {
    if ((x += a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator-=(const mint a) {
    if ((x += mod-a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator*=(const mint a) {
    (x *= a.x) %= mod;
    return *this;
  }
  mint operator+(const mint a) const {
    mint res(*this);
    return res+=a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res-=a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res*=a;
  }
  mint pow(ll t) const {
    if (!t) return 1;
    mint a = pow(t>>1);
    a *= a;
    if (t&1) a *= *this;
    return a;
  }
 
  // for prime mod
  mint inv() const {
    return pow(mod-2);
  }
  mint& operator/=(const mint a) {
    return (*this) *= a.inv();
  }
  mint operator/(const mint a) const {
    mint res(*this);
    return res/=a;
  }
};


// x^n % modを返す
long long powerMod(long long x, long long n, long long mod){
    long long res = 1;
    if(n > 0){
        res = powerMod(x, n / 2, mod);
        if(n % 2 == 0) res = (res * res) % mod;
        else res = (((res * res) % mod) * (x % mod)) % mod;
    }
    return res;
}

// aの逆元のmodを返す
long long modInv(long long a, long long mod){
    return powerMod(a, mod - 2, mod);
}

// a / b のmodを返す, つまりa = bC(mod)なるmodより小さいC
long long modDivision(long long a, long long b, long long mod){
    long long res = modInv(a, mod);
    return modInv((b * res) % mod, mod);
}


// エラトステネスをかける
struct Sieve{
    int n;
    std::vector<int> factor; // その値の持つ素因数の最小値
    std::vector<int> primes;
    Sieve(int n=1): n(n), factor(n + 1){
        // こいつらは素数でないので例外処理
        factor[0] = -1;
        factor[1] = -1;
        for(ll i = 2; i <= n; i++){
            if(factor[i]) continue; // 素数でないならば飛ばす
            primes.push_back(i);
            factor[i] = i;
            for(ll j = i * i; j <= n; j += i){
                if(!factor[j]) factor[j] = i;
            }
        }
    }

    bool isPrime(int x){
        return factor[x] == x;
    }

    // xを素因数分解する関数
    // 戻り値は素因数を小さい順に持つ
    std::vector<int> factorList(int x){
        std::vector<int> res;
        while(x != 1){
            res.push_back(factor[x]);
            x /= factor[x];
        }
        return res;
    }

    // xの素因数分解についてその素因数と累乗のペアのvectorを返す
    std::vector<std::pair<int, int>> factorCount(int x){
        std::vector<int> factors = factorList(x);
        if(factors.size() == 0) return {};
        std::vector<std::pair<int, int>> res(1, std::make_pair(factors[0], 0));
        for(int p : factors){
            if(res.back().first == p){
                res.back().second++;
            }else{
                res.emplace_back(p, 1);
            }
        }
        return res;
    }
};



int main(){
    int N;
    scanf("%d%*c", &N);
    Sieve sieve(maxA);
    std::vector<int> A(N);
    for(int i = 0; i < N; i++){
        scanf("%d%*c", &A[i]);
    }

    std::map<int, int> mp;
    for(int i = 0; i < N; i++){
        // a[i]の素因数分解を取得
        auto f = sieve.factorCount(A[i]);
        // より大きい素因数分解があれば取得
        for(auto p : f){
            mp[p.first] = std::max(mp[p.first], p.second);
        }
    }
    // ここでAの最大公約数の素因数分解が得られた
    // 最大公約数のmodを求める.
    ll lcmMod = 1;
    for(auto iter = mp.begin(); iter != mp.end(); iter++){
        for(int i = 0; i < iter->second; i++){
            lcmMod = (lcmMod * (iter->first % mod)) % mod;
        }
    }

    ll ans = 0;
    for(int i = 0; i < N; i++){
        ll b = modDivision(lcmMod, A[i], mod);
        ans = (ans + b) % mod;
    }

    std::cout << ans << std::endl;

    return 0;
}

Measured memory_bytes: 4984