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.Text;
using System.Diagnostics;

namespace AtCoder
{
    class Program
    {
        private static string Read() { return Console.ReadLine(); }
        private static int ReadInt() { return int.Parse(Read()); }
        private static long ReadLong() { return long.Parse(Read()); }
        private static double ReadDouble() { return double.Parse(Read()); }
        private static int[] ReadInts() { return Array.ConvertAll(Read().Split(), int.Parse); }
        private static long[] ReadLongs() { return Array.ConvertAll(Read().Split(), long.Parse); }
        private static double[] ReadDoubles() { return Array.ConvertAll(Read().Split(), double.Parse); }

        class Modular
        {
            private const int M = 1000000007;
            private long value;

            public Modular(long value) { this.value = value; }
            public static implicit operator Modular(long a)
            {
                var m = a % M;
                return new Modular((m < 0) ? m + M : m);
            }
            public static Modular operator +(Modular a, Modular b) { return a.value + b.value; }
            public static Modular operator -(Modular a, Modular b) { return a.value - b.value; }
            public static Modular operator *(Modular a, Modular b) { return a.value * b.value; }
            public static Modular Pow(Modular a, int n)
            {
                switch (n)
                {
                case 0:
                    return 1;
                case 1:
                    return a;
                default:
                    var p = Pow(a, n / 2);
                    return p * p * Pow(a, n % 2);
                }
            }
            public static Modular operator /(Modular a, Modular b) { return a * Pow(b, M - 2); }
            private static readonly List<int> facs = new List<int> { 1 };
            private static Modular Fac(int n)
            {
                for (int i = facs.Count; i <= n; ++i) { facs.Add((int)(Math.BigMul(facs.Last(), i) % M)); }
                return facs[n];
            }
            public static Modular Ncr(int n, int r)
            {
                return (n < r) ? 0
                     : (n == r) ? 1
                                : Fac(n) / (Fac(r) * Fac(n - r));
            }
            public static explicit operator int(Modular a) { return (int)a.value; }
        }

        static Dictionary<int, int> Factorize(int n)
        {
            var ans = new Dictionary<int, int>();
            for (int i = 2; i * i <= n; ++i)
            {
                int cnt = 0;
                while (n % i == 0)
                {
                    n /= i;
                    ++cnt;
                }
                if (cnt > 0) { ans[i] = cnt; }
            }
            if (n > 1) { ans[n] = 1; }
            return ans;
        }

        static long Solve(int N, int[] A)
        {
            var max = new Dictionary<int, int>();
            var facs = new Dictionary<int, int>[N];
            for (int i = 0; i < N; ++i)
            {
                facs[i] = Factorize(A[i]);
                foreach (var pair in facs[i])
                {
                    int value = max.ContainsKey(pair.Key) ? max[pair.Key] : 0;
                    max[pair.Key] = Math.Max(pair.Value, value);
                }
            }
            var ans = new Modular(0);
            foreach (var fac in facs)
            {
                var n = new Modular(1);
                foreach (var pair in max)
                {
                    int value = fac.ContainsKey(pair.Key) ? fac[pair.Key] : 0;
                    n *= Modular.Pow(pair.Key, pair.Value - value);
                }
                ans += n;
            }
            return (long)ans;
        }

        static void Main(string[] args)
        {
            int N = ReadInt();
            int[] A = ReadInts();
            Console.WriteLine(Solve(N, A));
        }
    }
}