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.io.*;
import java.util.*;

class Main {

	static final int M = 1000000007;

	private static Map<Long, Long> factorize(long n) {
		Map<Long, Long> a = new HashMap<>();
		for (long i = 2; i * i <= n; i++) {
			if (n % i != 0) continue;
			long count = 0;
			while (n % i == 0) {
				count++;
				n /= i;
			}
			a.putIfAbsent(i, count);
		}

		if (n != 1) a.putIfAbsent(n, 1L);
		return a;
	}

	public static void main(String[] args) throws Exception {
		final Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		Map<Long, Long> lcm = new HashMap<>();
		long[] A = new long[N];
		for (int i = 0; i < N; i++) {
			A[i] = sc.nextLong();
			for (Map.Entry<Long, Long> e : factorize(A[i]).entrySet()) {
				lcm.putIfAbsent(e.getKey(), e.getValue());
				if (lcm.get(e.getKey()) < e.getValue()) {
					lcm.put(e.getKey(), e.getValue());
				}
			}
		}

		long LCM = 1;
		for (Map.Entry<Long, Long> e : lcm.entrySet()) {
			for (int i = 0; i < e.getValue(); i++) {
				LCM *= e.getKey();
				LCM %= M;
			}
		}

		long answer = 0;
		for (int i = 0; i < N; i++) {
			answer += LCM * pow(A[i], M - 2, M);
			answer %= M;
		}

		System.out.println(answer);
	}

	private static long pow(long a, long n, long M) {
		long x = 1;
		while (n > 0) {
			if ((n & 1) == 1) {
				x *= a;
				x %= M;
			}
			a *= a;
			a %= M;
			n >>= 1;
		}
		return x;
	}
}