Problem:
Score : 500 points

Problem Statement

Given are N positive integers A_1,...,A_N.

Consider positive integers B_1, ..., B_N that satisfy the following condition.

Condition: For any i, j such that 1 \leq i < j \leq N, A_i B_i = A_j B_j holds.

Find the minimum possible value of B_1 + ... + B_N for such B_1,...,B_N.

Since the answer can be enormous, print the sum modulo (10^9 +7).

Constraints

1 \leq N \leq 10^4

1 \leq A_i \leq 10^6

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 ... A_N

Output

Print the minimum possible value of B_1 + ... + B_N for B_1,...,B_N that satisfy the condition, modulo (10^9 +7).

Sample Input 1

3
2 3 4

Sample Output 1

13

Let B_1=6, B_2=4, and B_3=3, and the condition will be satisfied.

Sample Input 2

5
12 12 12 12 12

Sample Output 2

5

We can let all B_i be 1.

Sample Input 3

3
1000000 999999 999998

Sample Output 3

996989508

Print the sum modulo (10^9+7).

Solution in C++14 (GCC 5.4.1) (judge verdict: Time Limit Exceeded)

#include<iostream>
#include<iomanip>
#include<climits>
#include<vector>
#include<list>
#include<functional>
#include<algorithm>
#include<string>
#include<cmath>
#include<complex>
#include<set>
#include<map>
#include<unordered_map>
#include<stack>
#include<queue>
#include<deque>
#include<tuple>
#define FOR(i, a, b) for(int i = (a);i < (b);++i)
#define FORR(i, b, a) for (int i = (b) - 1;i >= 0;--i)
#define REP(i, n) for(int i = 0;i < (n);++i)
#define REPR(i, n) for(int i = (n) - 1;i >= 0;--i)
#define ITER(itr, v) for(auto itr = v.begin();itr != v.end();++itr)
#define SORT(v) sort(v.begin(), v.end())
using namespace std;
typedef long long ll;
typedef pair<int, int> P;

const int p = 1000000007;

class Fp {
protected:
	ll n;
public:
	Fp(ll N) :n(N % p) {};
	Fp operator+(ll m) {
		return Fp(n + m);
	}
	Fp operator-(ll m) {
		return Fp(n - m + p);
	}
	Fp operator*(ll m) {
		return Fp(n * m);
	}
	Fp operator/(ll m) {
		return *this * Fp(m).pow(p - 2).get();
	}
	Fp pow(int i) {
		if (i == 0) return Fp(1);
		if (i % 2) return *this * pow(i - 1).get();
		Fp tmp = pow(i / 2);
		return tmp * tmp.get();
	}
	ll get() {
		return n;
	}
};

class PrimeFact :public Fp {
	map<int, int> mp;
public:
	PrimeFact(int N) :Fp(N) {
		while (N % 2 == 0) {
			mp[2]++;
			N /= 2;
		}
		int i = 3;
		while (i * i <= N) {
			while (N % i == 0) {
				mp[i]++;
				N /= i;
			}
			i += 2;
		}
		if (N > 1) mp[N]++;
	}
	PrimeFact lcm(ll m) {
		PrimeFact a = *this, b(m);
		ITER(itr, b.mp) {
			int d = itr->second - mp[itr->first];
			if (d > 0) {
				a.mp[itr->first] = itr->second;
				a.n = (Fp(a.n) * Fp(itr->first).pow(d).get()).get();
			}
		}
		return a;
	}
};

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

	int N;
	cin >> N;
	vector<int> A(N);
	PrimeFact a(1);
	REP(i, N) {
		cin >> A[i];
		a = a.lcm(A[i]);
	}
	Fp res(0);
	REP(i, N) res = res + (a / A[i]).get();
	cout << res.get() << endl;

	return 0;
}