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 Scala (2.11.7) (judge verdict: Accepted)

import scala.annotation.tailrec

object Main{
  // 定数関係
  final private val mod : Int = 1e9.toInt + 7
  
  @tailrec
  def gcd(a : BigInt, b : BigInt): BigInt = {
      if(b == 0) a
      else if(a < b) gcd(b, a)
      else gcd(a % b, b)
  }
  def lcm(a : BigInt, b : BigInt): BigInt = a / gcd(a, b) * b
  
  type INTEGER = Long
  def power(a : Int, n : Int): Int = {
      val hd = 32 - java.lang.Integer.numberOfLeadingZeros(n)
      var isMATCH = 1 << hd
      var ans : INTEGER = 1

      while(isMATCH != 0){
          ans = ans * ans % mod
          if((n & isMATCH) != 0){
              ans = a * ans % mod
          }
          isMATCH >>>= 1
      }
      ans.toInt
  }
  def inv(n : Int): Int = power(n, mod - 2)
  
  
  // main 関数本体
  def main(args : Array[String]): Unit = {
      val n = scala.io.StdIn.readLine().toInt
      val A = scala.io.StdIn.readLine().split(' ').map(_.toInt)
      var sumInv : Int = 0
      var LCM : BigInt = 1
      for(ele <- A){
          LCM = lcm(ele, LCM)
          sumInv += inv(ele)
          if(sumInv >= mod) sumInv -= mod
      }
      val lcmMod : Long = (LCM % mod).toLong
      val ans = lcmMod * sumInv.toLong % mod
      println(ans)
  }
}