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# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
		checked
		{
			var _N = long.Parse(Console.ReadLine());
			var _As = Console.ReadLine().Split().Select(x => ulong.Parse(x)).ToList();
			ulong lcm = 1;
			for (var i = 0; i < _N; i++)
			{
				lcm = Lcm(lcm, _As[i]);
			}
			var lcmList = new List<MInt>();
			for (var i = 0; i < _N; i++)
			{
				lcmList.Add(new MInt((long)(lcm / _As[i])));
			}
			var ans = lcmList.Aggregate(new MInt(0), (n, elem) => n + elem);
			Console.WriteLine(ans.V);
#if DEBUG
			Console.ReadKey();
#endif
		}
    }

	#region 最大公約数、最小公倍数
	static ulong Lcm(ulong a, ulong b) => a * b / Gcd(a, b);
	static ulong Gcd(ulong a, ulong b) => a > b ? GcdRecursive(a, b) : GcdRecursive(b, a);
	static ulong GcdRecursive(ulong a, ulong b) => b == 0 ? a : GcdRecursive(b, a % b);
	#endregion
}

struct MInt
{
	const int M = 1000000007;
	public long V;
	public MInt(long v) { V = (v %= M) < 0 ? v + M : v; }

	public static implicit operator MInt(long v) => new MInt(v);
	public static MInt operator +(MInt x) => x;
	public static MInt operator -(MInt x) => -x.V;
	public static MInt operator +(MInt x, MInt y) => x.V + y.V;
	public static MInt operator -(MInt x, MInt y) => x.V - y.V;
	public static MInt operator *(MInt x, MInt y) => x.V * y.V;
	public static MInt operator /(MInt x, MInt y) => x * y.Inv();

	public MInt Pow(int i) => MPow(V, i);
	public MInt Inv() => MPow(V, M - 2);

	static long MPow(long b, int i)
	{
		for (var r = 1L; ; b = b * b % M)
		{
			if (i % 2 > 0) r = r * b % M;
			if ((i /= 2) < 1) return r;
		}
	}
}