#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <cmath>
#include <queue>
#include <map>
#include <stack>
#include <numeric> //lcm
#include <iomanip> //double精度 setprecision


#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = n-1; i >= 0; --i)
#define rep1(i,n) for(int i = 1; i <= (n); ++i)
#define all(vec) (vec).begin(),(vec).end()

#define debug(vec) for(auto v : vec) cout << v << " "; cout << endl;

#define debug2D(vec2D) for(auto vec : vec2D) { for (auto v : vec) cout << v << " "; cout << endl; } 

using namespace std;

typedef long long ll;

const long long int INF = 1000000000; //<10^10
//const ll MOD = 998244353;
const ll MOD = 1000000007;

template<class T>inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } else return false; }
template<class T>inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } else return false; }

struct ModInt {
	ModInt(ll n) : mInt(n) {};
	//~ModInt(){};
	ll mInt;
	static ll mMod;
	//todo
	ModInt& operator=(const ModInt& a) { mInt = a.mInt; return *this; }
	ModInt& operator+=(const ModInt& a) { mInt += a.mInt; mInt %= mMod; return *this; }
	ModInt& operator-=(const ModInt& a) { mInt -= a.mInt; if (mInt < 0) mInt += mMod; return *this; }
	ModInt& operator*=(const ModInt& a) { mInt *= a.mInt; mInt %= mMod; return *this; }
	ModInt operator+(const ModInt a) { return ModInt(mInt + a.mInt % mMod); }
	ModInt operator-(const ModInt a) { return ModInt(mInt - a.mInt < 0 ? mInt - a.mInt + mMod : mInt - a.mInt); }
	ModInt operator*(const ModInt a) { return ModInt(mInt * a.mInt % mMod); }
	ModInt& operator=(const ll& a) { mInt = a; return *this; }
	ModInt& operator+=(const ll& a) { mInt += a; mInt %= mMod; return *this; }
	ModInt& operator-=(const ll& a) { mInt -= a; if (mInt < 0) mInt += mMod; return *this; }
	ModInt& operator*=(const ll& a) { mInt *= a; mInt %= mMod; return *this; }
	ModInt operator+(const ll a) { return ModInt(mInt + a % mMod); }
	ModInt operator-(const ll a) { return ModInt(mInt - a < 0 ? mInt - a + mMod : mInt - a); }
	ModInt operator*(const ll a) { return ModInt(mInt * a % mMod); }
	ModInt operator++() { return ModInt(++mInt % mMod); }
	ModInt operator--() { return ModInt(++mInt % mMod); }
	bool operator==(ModInt a) { return mInt == a.mInt; }
	bool operator!=(ModInt a) { return mInt != a.mInt; }
	bool operator<=(ModInt a) { return mInt <= a.mInt; }
	bool operator>=(ModInt a) { return mInt >= a.mInt; }
	bool operator<(ModInt a) { return mInt < a.mInt; }
	bool operator>(ModInt a) { return mInt > a.mInt; }
	friend ostream& operator<<(ostream& os, const ModInt& n) {
		os << n.mInt;
		return os;
	}
	void setMod(ll mod) {
		ModInt::mMod = mod;
	}
};
ll ModInt::mMod = MOD;

ModInt pow(ModInt a, int b) {
	ModInt pow = 1;
	while (b > 0) {
		if (b & 1) pow = pow * a;
		a = a * a;
		b >>= 1;
	}
	return pow;
}

ModInt inv(ModInt n) {
	return pow(n, n.mMod - 2);
}

ModInt fact(int n) {
	ModInt fac = 1;
	for (int i = n; i > 0; --i) fac *= i;
	return fac;
}

ModInt comb(ll n, ll r) {
	ModInt com = 1;
	if (n / 2 < r) return comb(n, n - r);
	else {
		for (int i = 0; i < r; ++i)
			com *= n - i;
		return com * inv(fact(r));
	}
}

void setComb(vector<ModInt>& combs, ll n, ll r) {
	//nCk = nCk-1 * n-k+1/k
	// combs[i] = nCi
	ModInt comb = 1;
	combs[0] = combs[n] = comb;
	if (n / 2 < r) setComb(combs, n, n - r);
	else {
		for (ll i = 1; i <= r; ++i) {
			comb *= inv(i) * (n - i + 1);
			combs[i] = combs[n - i] = comb;
		}
	}
}

void setComb(vector<ModInt>& combs, ll n) { setComb(combs, n, (n + 1) / 2); }

void primeFactor(map<ll, int>& ret, ll n) {
	while (n % 2 == 0) {
		n /= 2;
		ret[2]++;
	}

	for (ll i = 3; i*i <= n; i += 2) {
		while (n % i == 0) {
			n /= i;
			ret[i]++;
		}
	}
	if (n != 1) ret.insert({ n,1 });
}

ModInt getInt(map<ll, int>& mp) {
	ModInt ret = 1;
	for (auto pe : mp) {
		ret *= pow(pe.first, pe.second);
	}
	return ret;
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);

  int n;
	cin >> n;

	vector<map<ll,int>> a0(n);
	map<ll,int> lcm;
	vector<int> a(n);
	rep(i, n) {
		cin >> a[i];

		primeFactor(a0[i],a[i]);
		for (auto pe : a0[i]) {
		  chmax(lcm[pe.first], pe.second);
		}
	}

	ModInt lcm0(1);
	for (auto pe : lcm) {
		lcm0 *= pow(ModInt(pe.first), pe.second);
	}

	ModInt ans(0);
	rep(i, n) {
	  ans += lcm0 * inv(a[i]);
	}

	cout << ans << endl;
}


Measured memory_bytes: 3840