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: Runtime Error)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AtCoder
{
    static class Program
    {
        static void Main()
        {
            Solve();

            Console.ReadKey();
        }

        static void Solve()
        {
            var N = IO.GetInt();
            var A = IO.GetIntList();
            long mod = 1000000007;

            Dictionary<int, int> lcm = new Dictionary<int, int>();
            Dictionary<int, int>[] afac = new Dictionary<int, int>[N];
            long ans = 0;

            for(int i = 0; i < N; i++)
            {
                afac[i] = new Dictionary<int, int>();
                Factoring(A[i], ref afac[i]);

                for(int j=0;j<lcm.Count;j++)
                {
                    var key = lcm.Keys.ToArray()[j];
                    if (afac[i].ContainsKey(key))
                    {
                        lcm[key] = Math.Max(lcm[key], afac[i][key]);
                    }
                }
                for (int j = 0; j < afac[i].Count; j++)
                {
                    var key = afac[i].Keys.ToArray()[j];
                    if (lcm.ContainsKey(key))
                    {
                        lcm[key] = Math.Max(lcm[key], afac[i][key]);
                    }
                    else
                    {
                        lcm.Add(key,afac[i][key]);
                    }
                }
            }

            for(int i = 0; i < N; i++)
            {
                long temp = 1;
                for(int j = 0; j < lcm.Count; j++)
                {
                    var key = lcm.Keys.ToArray()[j];
                    for(int k = 0; k < lcm[key]-afac[i].TryGetValueEx(key,0); k++)
                    {
                        temp = temp * key % mod;
                    }
                }
                ans = (ans + temp)%mod;
            }

            Console.WriteLine(ans);
        }

        static public void Factoring(int num, ref Dictionary<int, int> vs)
        {
            bool prime = true;
            if (num == 1)
            {
                vs.Add(1, 1);
            }
            while (num % 2 == 0)
            {
                prime = false;
                if (vs.ContainsKey(2) == false) { vs.Add(2, 0); }
                vs[2]++;
                num /= 2;

            }
            int i = 3;
            while (i <= Math.Sqrt(num))
            {
                if (num % i == 0)
                {
                    prime = false;
                    if (vs.ContainsKey(i) == false) { vs.Add(i, 0); }
                    vs[i]++;
                    num /= i;
                }
                else
                {
                    i += 2;
                }
            }
            if (i == num)
            {
                if (vs.ContainsKey(i) == false) { vs.Add(i, 0); }
                vs[i]++;
            }
            else
            {
                if (vs.ContainsKey(i) == false) { vs.Add(num, 1); }
                else { vs[num]++; }
            }
        }

    }

    static class IO
    {
        static public string GetString() { return Console.ReadLine(); }
        static public int GetInt() { return int.Parse(Console.ReadLine()); }
        static public long GetLong() { return long.Parse(Console.ReadLine()); }
        static public List<string> GetStringList() { return Console.ReadLine().Split(' ').ToList(); }
        static public List<int> GetIntList() { return Console.ReadLine().Split(' ').Select(int.Parse).ToList(); }
        static public List<long> GetLongList() { return Console.ReadLine().Split(' ').Select(long.Parse).ToList(); }
        static public List<double> GetDoubleList() { return Console.ReadLine().Split(' ').Select(double.Parse).ToList(); }
        static public void WriteStrings<T>(IEnumerable<T> values) { foreach (var o in values) { Console.Write(o + " "); } }
    }

    /// <summary>
    /// Dictionaryの拡張クラス
    /// </summary>
    public static class DictionaryExtensions
    {

        /// <summary>
        /// 値を取得、keyがなければデフォルト値を設定し、デフォルト値を取得
        /// </summary>
        public static TValue TryGetValueEx<TKey, TValue>(this IDictionary<TKey, TValue> source, TKey key, TValue defaultValue)
        {

            //Dictionary自体がnullの場合はインスタンス作成
            if (source == null)
            {
                source = new Dictionary<TKey, TValue>();
            }

            //keyが存在しない場合はデフォルト値を設定
            if (!source.ContainsKey(key))
            {
                source[key] = defaultValue;
            }

            return source[key];
        }

    }
}