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: Wrong Answer)

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		final Scanner scanner = new Scanner(System.in);

		final int n = scanner.nextInt();

		int[] a = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = scanner.nextInt();
			factorization(a[i]);
		}
		scanner.close();

		long lcm = 1;
		for (int i = 0; i < PRIME_LIST.size(); i++) {
			lcm *= power(PRIME_LIST.get(i), factorList[i]);
			lcm %= MOD;
		}

		int result = 0;
		long b;
		for (int i = 0; i < n; i++) {
			b = lcm * inverse(a[i]) % MOD;
			result += b;
			result %= MOD;
		}
		System.out.println(result);
	}

	static final int MOD = 1000000007;

	static int power(int b, int p) {//b^p
		long res = 1;
		for (long a = b % MOD; p > 0; a = a * a % MOD, p >>= 1)
			if ((p & 1) > 0)
				res = res * a % MOD;
		return (int) res;
	}

	static int inverse(int denom) {
		return power(denom, MOD - 2);
	}

	static final int A_MAX = 1000000;
	static List<Integer> PRIME_LIST = new ArrayList<Integer>();
	static {
		PRIME_LIST.add(2);
		int sieveSup = (A_MAX + 1) / 2;
		boolean[] sieve = new boolean[sieveSup];
		for (int i = 1; 2 * i * (i + 1) < sieveSup; i++) {
			for (int j = i; 2 * i * j + i + j < sieveSup; j++) {
				sieve[2 * i * j + i + j] = true;
			}
		}
		for (int i = 1; i < sieveSup; i++) {
			if (!sieve[i]) {
				PRIME_LIST.add(2 * i + 1);
			}
		}
	}

	static int[] factorList = new int[PRIME_LIST.size()];

	static void factorization(int x) {
		for (int i = 0, exponent; i < PRIME_LIST.size(); i++) {
			if (x == 1)
				break;
			if (x < PRIME_LIST.get(i)* PRIME_LIST.get(i))
				factorList[PRIME_LIST.indexOf(x)] = 1;
			exponent = 0;
			while (x % PRIME_LIST.get(i) == 0) {
				exponent++;
				x /= PRIME_LIST.get(i);
			}
			if (exponent > factorList[i])
				factorList[i] = exponent;
		}
	}
}