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 Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import java.util.Scanner;
import java.util.Arrays;

class Main {
    static final long mod = 1000000007;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int a[] = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }

        Arrays.sort(a);

        int minFactor[] = new int[a[n - 1] + 100];
        for (int i = 2; i < minFactor.length; i++) {
            if (minFactor[i] != 0)
                continue;
            for (int j = i; j < minFactor.length; j += i) {
                minFactor[j] = i;
            }
        }

        long lcm = 1;
        int totalCount[] = new int[a[n - 1] + 100];

        for (int i = 0; i < n; i++) {
            int target = a[i];
            while (target >= 2) {
                int div = minFactor[target];
                int count = 0;
                while (target % div == 0) {
                    count++;
                    target /= div;
                }
                totalCount[div] = Math.max(totalCount[div], count);
            }
        }

        for (int i = 0; i < totalCount.length; i++) {
            for (int j = 0; j < totalCount[i]; j++) {
                lcm = (lcm * i) % mod;
            }
        }

        long answer = 0;

        for (int i = 0; i < n; i++) {
            answer = (answer + (lcm * (pow(a[i], mod - 2)) % mod) % mod);
        }

        System.out.println(answer % mod);
        sc.close();

    }

    public static long pow(long a, long n) {
        if (n == 0)
            return 1;
        if (n == 1)
            return a;
        if (n % 2 == 0)
            return pow((a * a) % mod, n / 2);
        return (a * pow((a * a) % mod, (n - 1) / 2)) % mod;
    }
}