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: Accepted)

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

namespace ABC152E
{
    class Program
    {
        static void Main(string[] args)
        {
            int N = int.Parse(Console.ReadLine());
            BigInteger[] A = ReadLong();

            BigInteger mod = 1000000007;
            BigInteger lcm = 1;
            lcm = (A.Aggregate(Calc.Lcm) % mod);
            //for (int i = 0; i < N; i++)
            //{
            //    lcm = Calc.Lcm(A[i], lcm) % mod;
            //}

            BigInteger sum = 0;
            for (int i = 0; i < N; i++)
            {
                sum += (lcm * Calc.ModPow(A[i], mod - 2, mod)) % mod;
                sum %= mod;
            }

            Console.WriteLine(sum);
            Console.ReadKey();
        }

        static int[] ReadInt()
        {
            int[] ret = Console.ReadLine().Split().Select(int.Parse).ToArray();
            return ret;
        }
        static BigInteger[] ReadLong()
        {
            BigInteger[] ret = Console.ReadLine().Split().Select(BigInteger.Parse).ToArray();
            return ret;
        }
    }

    class Calc
    {
        // 最小公倍数
        public static BigInteger Lcm(BigInteger a, BigInteger b)
        {
            //return a / Gcd(a, b) * b;
            return a / (BigInteger)BigInteger.GreatestCommonDivisor(a, b) * b;
        }

        // ユークリッドの互除法 
        public static BigInteger Gcd(BigInteger a, BigInteger b)
        {
            if (a < b)
                // 引数を入替えて自分を呼び出す
                return Gcd(b, a);
            while (b != 0)
            {
                var remainder = a % b;
                a = b;
                b = remainder;
            }
            return a;
        }

        /// <summary>
        /// a^n (mod p)
        /// nが非常に大きい時に有効
        /// </summary>
        /// <param name="a"></param>
        /// <param name="n"></param>
        /// <param name="mod"></param>
        /// <returns></returns>
        public static BigInteger ModPow(BigInteger a, BigInteger n, BigInteger p)
        {
            if (n == 1) return a % p;
            if (n % 2 == 1) return (a * ModPow(a, n - 1, p)) % p;

            BigInteger t = ModPow(a, n / 2, p);
            return (t * t) % p;
        }

        /// <summary>
        /// 組み合わせ個数
        /// </summary>
        /// <param name="n"></param>
        /// <param name="k"></param>
        /// <param name="p"></param>
        /// <returns></returns>
        public static BigInteger nCk(BigInteger n, BigInteger k, BigInteger p)
        {
            BigInteger ans = 1;
            for (BigInteger i = n; i > n - k; i--)
            {
                ans = (ans * i) % p;
            }

            for (BigInteger i = 1; i <= k; i++)
            {
                ans = (ans * ModPow(i, p - 2, p)) % p;
            }

            return ans;
        }
    }
}