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 Rust (1.15.1) (judge verdict: Accepted)

fn main() {
    let _ = rv::<usize>()[0];
    let a = rv::<u64>();
    let m = *a.iter().max().unwrap()as usize+1;
    let mut p = vec![0u32;m];
    for &a in &a {
        let mut x=a;
        let mut i=2;
        while i*i<=x {
            let mut c=0;
            while x%i==0 {
                c+=1;
                x/=i;
            }
            let k=i as usize;
            p[k]=std::cmp::max(p[k],c);
            i+=1;
        }
        if x>1 {
            let k=x as usize;
            p[k]=std::cmp::max(p[k],1);
        }
    }
    let mut t=1;
    for i in 0..m { if p[i]>0 {
        t = (t*pow(i as u64,p[i]))%MOD;
    }}
    let mut s=0;
    for a in a {
        s = (s+t*pow(a,MOD as u32-2))%MOD;
    }
    println!("{}",s);
}
const MOD: u64=1000000007;
fn pow(mut x:u64, mut c:u32) -> u64 {
    let mut t=1;
    while c>0 {
        if c&1==1 {
            t=(t*x)%MOD;
        }
        x=(x*x)%MOD;
        c>>=1;
    }
    t
}
fn rl() -> String {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s
}
fn rv<T>() -> Vec<T> where T: std::str::FromStr, T::Err: std::fmt::Debug, {
    rl().split_whitespace().map(|x|x.parse::<T>().unwrap()).collect()
}