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)

//package com.questetra.test.java;

import java.util.Arrays;
import java.util.BitSet;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
import java.util.stream.Collectors;

public class Main {
    static final long MOD = 1000000007L;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        final int N = sc.nextInt();
        sc.nextLine();
        final long[] A = new long[N];
        long[] lcd = new long[N];
        Arrays.fill(lcd, 1L);
        for (int i = 0; i < A.length; i++) {
            A[i] = sc.nextLong();
            if (i != 0) {
                long gcd = gcd(lcd, A[i]);
                lcd[i] = A[i] / gcd;
            } else {
                lcd[i] = A[i];
            }
        }

        //        for (int i = 0; i < A.length; i++) {
        //            System.out.print(":" + lcd[i]);
        //        }
        //        System.out.println();

        long sum = 0;
        long sumB = 0;
        for (int i = 0; i < A.length; i++) {
            long b = 1;
            long bB = 1;
            for (int j = 0; j < A.length; j++) {
                if (i == j) {
                    if (A[j] != lcd[j]) {
                        b = b * lcd[j] % MOD;
                        b = b * modinv(A[j], MOD);
                        bB = bB * lcd[j] / A[j];
                    }
                } else {
                    b = b * lcd[j];
                    bB = bB * lcd[j];
                }
                b = b % MOD;
//                System.out.println("tmp:" + b + ":" + bB);
            }
            //System.out.println(b + ":" + bB);
            sum += b;
            sumB += bB;
        }
        //System.out.println(":" + sum);
        //System.out.println(sumB);
        //        System.out.println(sumB % MOD);
        System.out.println(sum % MOD);
    }

    //    public static void main(String[] args) {
    //        System.out.println(modinv(3, 11));
    //        System.out.println(modinv(3, 31));
    //        System.out.println(modinv2(3, 31));
    //        System.out.println(modinv(3, MOD));
    //        System.out.println(modinv2(3, MOD));
    //    }

    // mod. m での a の逆元 a^{-1} を計算する
    static long modinv(long a, long m) {
        long result = 1;
        for (long i = m - 2; i > 0; i >>= 1) {
            if (i % 2 == 1) {
                result = result * a % m;
            }
            a = a * a % m;
        }
        return result;
    }

    static long modinv2(long a, long m) {
        long result = 1;
        for (long i = 0; i < m - 2; i++) {
            result = result * a % m;
        }
        return result;
    }

    private static long gcd(long[] n1, long n2) {
        while (true) {
            long n1Result = 1;
            boolean n1IsBigger = false;
            for (int i = 0; n1Result != 0 && i < n1.length; i++) {
                n1Result = n1Result * n1[i];
                if (n1Result >= n2) {
                    n1Result = n1Result % n2;
                    n1IsBigger = true;
                }
            }
            long result;
            if (n1IsBigger) {
                result = n1Result;
            } else {
                result = n2 % n1Result;
                n2 = n1Result;
            }
            if (result == 0) {
                break;
            }
            n2 = result;
            n1 = new long[]{n2};
        }
        return n2;
    }
}