/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author cherrypi59
 */

#pragma GCC optimize ("O2")
#pragma GCC optimize ("tree-vectorize")
#pragma GCC target ("sse4")

#include <bits/stdc++.h>
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define FFOR(i, a, b) FOR(i, a, b+1)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) FOR(i, 1, n+1)
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define LEN(x) (int)(x).size()
#define DUMP(x) cerr<<__LINE__<<' '<<#x<<"="<<(x)<<endl;
#define popcnt(x) __builtin_popcount(x)
#define popcntll(x) __builtin_popcountll(x)
#define pb push_back
#define eb emplace_back
#define mp make_pair

using namespace std;
using lint = long long;
using pii =  pair<int, int>;
using pll =  pair<lint, lint>;
template <typename T> using vc = vector<T>;
template <typename T> using vvc = vector<vector<T>>;
template <typename T> inline bool chmax(T &a, T b){if(a<b){a = b; return true;} return false;}
template <typename T> inline bool chmin(T &a, T b){if(a>b){a = b; return true;} return false;}

constexpr lint ten(int n) {return n==0 ? 1 : ten(n-1)*10;}

namespace ModInt{
    constexpr long long MOD = (long long)1e9 + 7;
    struct mint {
        long long x;

        mint(long long 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(long long t) const {
            mint res = 1, a(*this);
            while(t){
                if(t&1) res *= a;
                t >>= 1, a *= a;
            }
            return res;
        }
        mint invPow(long long t) const {
            return pow(MOD-1-t);
        }
        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;
        }
        friend istream& operator>>(istream& in, mint& a){
            long long _v; in>>_v;
            a = mint(_v);
            return in;
        }
        friend ostream& operator<<(ostream& out, const mint& a){
            return out<<a.x;
        }
        friend bool operator==(const mint& a, const mint& b){
            return a.x == b.x;
        }
        friend bool operator!=(const mint& a, const mint& b){
            return a.x != b.x;
        }
    };
    template <typename T, typename U>
    mint modPow(T a, U x){
        // return a^x mod MOD
        return mint(a).pow(x);
    }
    template <typename T, typename U>
    mint invPow(T a, U x){
        // return 1 / (a^x) mod MOD
        return mint(a).pow(MOD-1-x);
    }
    mint operator+(const int a, const mint b){
        return b + a;
    }
    mint operator+(const long long a, const mint b){
        return b + a;
    }
    mint operator-(const int a, const mint b){
        return mint(MOD-b.x) + a;
    }
    mint operator-(const long long a, const mint b){
        return mint(MOD-b.x) + a;
    }
    mint operator*(const int a, const mint b){
        return b * a;
    }
    mint operator*(const long long a, const mint b){
        return b * a;
    }
    mint operator/(const int a, const mint b){
        return b.inv() * a;
    }
    mint operator/(const long long a, const mint b){
        return b.inv() * a;
    }
}

using namespace ModInt;

class EFlatten {
public:
    static map<int, int> pf(int x){
        map<int, int> res;
        for(int i=2;i*i<=x;++i){
            if(x%i==0){
                int cnt = 0;
                while(x%i==0){
                    ++cnt;
                    x /= i;
                }
                res[i] = cnt;
            }
        }
        if(x>1) res[x]++;
        return res;
    }

    void solve(std::istream& in, std::ostream& out){
        ios_base::sync_with_stdio(false);
        in.tie(nullptr), out.tie(nullptr);
        int N;
        in>>N;
        vc<int> A(N);
        REP(i, N) in>>A[i];
        map<int, int> F;
        REP(i, N){
            auto tmp = pf(A[i]);
            for(auto& p : tmp){
                chmax(F[p.first], p.second);
            }
        }
        mint lcm = 1, sum = 0;
        for(auto& p : F){
            lcm *= modPow(p.first, p.second);
        }
        for(auto& a : A){
            sum += mint(a).inv();
        }
        out<<lcm*sum<<'\n';
    }
};


int main() {
	EFlatten solver;
	std::istream& in(std::cin);
	std::ostream& out(std::cout);
	solver.solve(in, out);
	return 0;
}


Measured memory_bytes: 3984