// Original C++ solution (slower):
#include <bits/stdc++.h>

#define rep(i,n) for(int i=0;i<(int)n;i++)

#define rep1(i,n) for(int i=1;i<=(int)n;i++)

typedef long long ll;

using namespace std;

const int mod = 1000000007;

long long modpow(long long a, long long n){

  long long r = 1;

  while (n) {

    r = r * ( (n%2)?a:1 ) %mod;

    a = a * a % mod;

    n >>= 1;

  }

  return r;

}



int main(void){

    int n;cin>>n;

    vector<ll> a(n),b(n,1);

    rep(i,n) cin>>a[i];

    vector<int> sieve1,sieve2(10000,0);

    sieve2[0]=sieve2[1]=-1;

    for(int i=2;i*i<=10000;i++){

        for(int j=i*i;j<10000;j+=i){

            sieve2[j]=i;

        }

    }

    rep(i,10000){

        if(sieve2[i]==0) sieve1.push_back(i);

    }

    

    ll sz=sieve1.size();

    vector<ll> lcm(sz,0);

    rep(i,n){

        ll x=a[i];

        for(int j=0;j<sz;j++){

            ll y=sieve1[j];

            ll buf=0;

            while(x%y==0&&x>1){

                x/=y;

                buf++;

            }

            lcm[j]=max(lcm[j],buf);

        }

        if(x>1){

            bool jud=true;

            rep(i,sz){

                if(x==sieve1[i]){

                    lcm[i]++;

                    jud=true;

                    break;

                }

            }

            if(jud){

                sieve1.push_back(x);

                sz++;

                lcm.push_back(1);

            }

        }

    }

    long long LCM=1;

    rep(i,sz) (LCM*=modpow(sieve1[i],lcm[i]))%=mod;

    long long ans=0;

    for(int i=0;i<n;i++){

        (ans+=LCM*modpow(a[i],mod-2)%mod)%=mod;

    }

    cout<<ans<<endl;

    

}

// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

#define rep(i,n) for(int i=0;i<(int)n;i++)

typedef long long ll;

const int mod=1e+9+7;

struct mint {

  ll x; // typedef long long ll;

  mint(ll x=0):x((x%mod+mod)%mod){}

  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;

  }

};

mint modpow(mint a,int n){

    mint r=1;

    while(n){

        r=r*((n%2)?a:1);

        a*=a;

        n>>=1;

    }

    return r;

}

int main(){

    int n;cin>>n;

    vector<int> a(n);

    rep(i,n) cin>>a[i];

    //エラトステネスの篩

    map<int,int> mp;

    rep(i,n){

        map<int,int> mpp;

        int buf=a[i];

        for(int i=2;i*i<=buf;i++){

            while(buf%i==0){

                buf/=i;

                mpp[i]++;

            }

        }

        if(buf>1) mpp[buf]++;

        for(auto& p:mpp){

            mp[p.first]=max(p.second,mp[p.first]);

        }

    }

    mint lcm=1;

    for(auto& p:mp){

        lcm*=modpow(p.first,p.second);

    }

    mint res=0;

    rep(i,n){

        res+=lcm*modpow(a[i],mod-2);

    }

    cout<<res.x<<endl;

}

// Fastest known solution for this problem: