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 C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <vector>
#include <map>
#include <numeric>
#include <iostream>
#include <cmath>

using prime_map = std::map<int, int>;

const int MAX_A = 1000000;
const uint_fast64_t MOD = 1000000007;


prime_map prime_list;


template<class T, class Key>
typename T::mapped_type at_or_default(const T &c, Key key)
{
    auto i = c.find(key);
    if( i != c.end() )
    {
        return i->second;
    }
    else
    {
        return 0;
    }
}

prime_map listPrimes(int N)
{
    int sqrN = static_cast<int>(std::sqrt(N));
    prime_map P;
    
    for(int i = 2; i <= sqrN; ++i)
    {
        P[i] = 0;
    }
    
    for(int i = 2; i <= sqrN; ++i)
    {
        if(P[i] == 0)
        {
            for(int j = i * 2; j <= sqrN; j += i)
            {
                ++P[j];
            }
        }
    }
    
    prime_map PP;
    for(auto p : P)
    {
        if(p.second == 0)
        {
            PP.insert(p);
        }
    }
    
    prime_list = PP;
    return PP;
}

prime_map factorise(int M)
{
    prime_map P = prime_list;
    
    int mm = M;
    for(auto &p : P)
    {
        while(mm % p.first == 0)
        {
            ++p.second;
            mm = mm / p.first;
        }
    }
    
    if(mm) P[mm] = 1;
    
    return P;
}

void prime_map_max(prime_map &PMax, const prime_map &P)
{
    for(auto &p : PMax)
    {
        if(p.second < at_or_default(P, p.first))
        {
            p.second = at_or_default(P, p.first);
        }
    }
    
    for(auto p : P)
    {
        auto it = PMax.find(p.first);
        if(it == PMax.end())
        {
            PMax[it->first] = it->second;
        }
    }
}

uint_fast64_t prime_map_diff(const prime_map &P1, const prime_map &P2)
{
    uint_fast64_t b = 1;
    for(auto p : P1)
    {
        int diff = p.second - at_or_default(P2, p.first);
        for(int j = 0; j < diff; ++j)
        {
            b *= p.first;
        }
    }
    return b;
}

int main()
{
    int M;
    std::cin >> M;
    
    std::vector<int> A(M);
    for(int i = 0; i < M; ++i)
    {
        std::cin >> A[i];
    }
    
    listPrimes(MAX_A);
    
    std::vector<prime_map> PA(M);
    prime_map PMax = prime_list;
    for(int i = 0; i < M; ++i)
    {
        PA[i] = factorise(A[i]);
        prime_map_max(PMax, PA[i]);
    }
    
    
    uint_fast64_t BSum = 0;
    for(int i = 0; i < M; ++i)
    {
        uint_fast64_t b = prime_map_diff(PMax, PA[i]);
        BSum = (BSum + b) % MOD;
    }
    std::cout << BSum << std::endl;
}