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: Time Limit Exceeded)

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

class Program
{
    static void Main(string[] args)
    {
		var _N = long.Parse(Console.ReadLine());
		var _As = Console.ReadLine().Split().Select(x => long.Parse(x)).ToList();

		var PrimeList = new List<long>();
		var tmpList = new bool[1000001];
		for(var i = 2; i <= 1000000; i++)
		{
			if(!tmpList[i])
			{
				PrimeList.Add(i);
				for(var j = 1; j * i < 1000001; j++)
				{
					tmpList[j * i] = true;
				}
			}
		}
		var primeCount = new long[PrimeList.Count];
		var primeCountList = new List<List<long>>();
		for (var i = 0; i < _N; i++)
		{
			var pCount = PrimeFactor(_As[i], PrimeList);
			primeCountList.Add(pCount);
			for (var j = 0; j < PrimeList.Count; j++)
			{
				if(primeCount[j] < pCount[j])
				{
					primeCount[j] = pCount[j];
				}
			}
		}
		var lcmList = new List<MInt>();
		var bList = new List<List<long>>();
		for (var i = 0; i < _N; i++)
		{
			var bUnit = new List<long>();
			for (var j = 0; j < PrimeList.Count; j++)
			{
				bUnit.Add(primeCount[j] - primeCountList[i][j]);
			}
			bList.Add(bUnit);
		}
		var ans = new MInt(0);
		for (var i = 0; i < _N; i++)
		{
			var sum = new MInt(1);
			for (var j = 0; j < PrimeList.Count; j++)
			{
				if(bList[i][j] != 0)
				{
					sum *= new MInt(PrimeList[j]).Pow((int)bList[i][j]);
				}
			}
			ans += sum;
		}

		Console.WriteLine(ans.V);
#if DEBUG
		Console.ReadKey();
#endif

    }
	static List<long> PrimeFactor(long m, List<long> primeList)
	{
		var ret = new List<long>();
		var tmp = m;
		foreach (var prime in primeList)
		{
			long count = 0;
			while (tmp % prime == 0)
			{
				count++;
				tmp = tmp / prime;
			}
			ret.Add(count);
		}
		return ret;
	}
}

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;
		}
	}
}