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 read_stdin() -> String {
    use std::io::Read;
    let mut input = String::new();
    std::io::stdin().read_to_string(&mut input).unwrap();
    input
}

fn scan<'a, I: Iterator<Item = &'a str>, T: std::str::FromStr>(tokens: &mut I) -> T {
    tokens.next().unwrap().parse().ok().unwrap()
}

fn vec<T, F: FnMut(usize) -> T>(n: usize, mut f: F) -> Vec<T> {
    (0..n).map(|i| f(i)).collect()
}

fn main() {
    use std::collections::HashMap;
    let input = read_stdin();
    let tokens = &mut input.split_whitespace();
    let n: usize = scan(tokens);
    let a: Vec<usize> = vec(n, |_| scan(tokens));
    let m: usize = a.iter().max().unwrap() + 1;
    let divisor: Vec<usize> = {
        let mut divisor: Vec<usize> = (0..m).collect();
        let mut i = 2;
        while i * i < m {
            if divisor[i] == i {
                let mut j = i * i;
                while j < m {
                    divisor[j] = i;
                    j += i;
                }
            }
            i += 1;
        }
        divisor
    };
    let lcm: F = {
        let mut max_count: HashMap<usize, usize> = HashMap::new();
        for &ai in &a {
            let mut count = HashMap::new();
            let mut x = ai;
            while x != 1 {
                let d = divisor[x];
                *count.entry(d).or_insert(0) += 1;
                x /= d;
            }
            for (p, e) in count {
                let f = max_count.entry(p).or_insert(0);
                *f = std::cmp::max(*f, e);
            }
        }
        let mut lcm = F(1);
        for (p, e) in max_count {
            lcm = lcm * F(p).pow(e);
        }
        lcm
    };
    let mut ans = F(0);
    for i in 0..n {
        ans = ans + lcm / F(a[i]);
    }
    println!("{}", ans.value());
}

const MODULO: usize = 1_000_000_007;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct F(usize);

impl F {
    fn value(self) -> usize {
        self.0
    }
    fn pow(self, e: usize) -> F {
        let mut a = F(1);
        let mut b = self;
        let mut e = e;
        while e != 0 {
            if e & 1 != 0 {
                a = a * b;
            }
            b = b * b;
            e >>= 1;
        }
        a
    }
    fn inverse(self) -> F {
        self.pow(MODULO - 2)
    }
}

impl std::ops::Add for F {
    type Output = F;
    fn add(self, other: F) -> F {
        F((self.value() + other.value()) % MODULO)
    }
}

impl std::ops::Sub for F {
    type Output = F;
    fn sub(self, other: F) -> F {
        F((self.value() + MODULO - other.value()) % MODULO)
    }
}

impl std::ops::Mul for F {
    type Output = F;
    fn mul(self, other: F) -> F {
        F((self.value() * other.value()) % MODULO)
    }
}

impl std::ops::Div for F {
    type Output = F;
    fn div(self, other: F) -> F {
        self * other.inverse()
    }
}