#include <algorithm>
#include <cstdint>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <cfloat>

using namespace std;

using lint=int64_t;
using uint=uint32_t;
using ulint=uint64_t;

template<class T>
using vector2d=vector<vector<T>>;

template<class T>
bool UpdateMax(T &a, const T &b){
  if(a<b){
    a=b;
    return true;
  }else{
    return false;
  }
}

template<class T>
bool UpdateMin(T &a, const T &b){
  if(a>b){
    a=b;
    return true;
  }else{
    return false;
  }
}

template <class T>
void OutVec(const vector<T>& vec){
  for(int i = 0; i < vec.size() - 1; ++i){
    cout<<vec[i]<<" ";
  }
  cout<<vec.back()<<endl;
}

template <class T>
void OutVec2d(const vector2d<T>& vec){
  for(auto v:vec){
    OutVec(v);
  }
}



int64_t EuclidMod(int64_t v, int64_t m){
  if(0 <= v && v < m){
    return v;
  }else if(-m <= v && v < 0){
    return v + m;
  }else{
    int64_t result = v % m;
    if(result < 0){
      result += m;
    }
    return result;
  }
}

int64_t ModInv(int64_t a, int64_t m){
  int64_t b = m, u = 1, v = 0;
  while(b){
    int64_t t = a / b;
    a -= t * b;
    std::swap(a, b);
    u -= t * v;
    std::swap(u, v);
  }
  EuclidMod(u, m);
  return u;
}

// return base^exponent (MOD. mod).
int64_t RepeatedPowMod(int64_t base, int64_t exponent, int64_t mod) {
  if (exponent == 0)
    return 1;
  else if (exponent % 2 == 0) {
    int64_t root = RepeatedPowMod(base, exponent / 2, mod);
    return (root * root) % mod;
  } else {
    return (base * RepeatedPowMod(base, exponent - 1, mod)) % mod;
  }
}

template<int64_t mod>
class ModInt{
  int64_t value_;

public:
  explicit ModInt(const int64_t x = 0): value_(x % mod){
  };

  ModInt& operator=(const ModInt& another){
    value_=another.value_;
    return *this;
  }

  ModInt& operator^=(const ModInt& another){
    value_=RepeatedPowMod(value_,another.value_,mod);
    return *this;
  }

  ModInt& operator+=(const ModInt& another){
    value_ += another.value_;
    value_ = EuclidMod(value_, mod);
    return *this;
  }

  ModInt& operator-=(const ModInt& another){
    value_ -= another.value_;
    value_ = EuclidMod(value_, mod);
    return *this;
  }

  ModInt& operator*=(const ModInt& another){
    value_ *= another.value_;
    value_ = EuclidMod(value_, mod);
    return *this;
  }

  ModInt& operator/=(const ModInt& another){
    value_ = value_ * ModInv(another.value_, mod);
    value_ = EuclidMod(value_, mod);
    return *this;
  }

  ModInt& operator%=(const ModInt& another){
    value_ %= another.value_;
    value_ = EuclidMod(value_, mod);
    return *this;
  }

  ModInt& operator++(){
    value_ += 1;
    value_=EuclidMod(value_,mod);
    return *this;
  }

  ModInt operator++(int){
    ModInt tmp = *this;
    this->value_+=1;
    this->value_=EuclidMod(this->value_,mod);
    return tmp;
  }

  ModInt& operator--(){
    value_ -= 1;
    value_=EuclidMod(value_,mod);
    return *this;
  }

  ModInt operator--(int){
    ModInt tmp=*this;
    this->value_-=1;
    this->value_=EuclidMod(this->value_,mod);
    return tmp;
  }



  int64_t GetValue() const{
    return value_;
  }

};



template<int64_t mod>
ModInt<mod>
operator+(const ModInt<mod>& left, const ModInt<mod>& right){
  return ModInt<mod>(left) += right;
}

template<int64_t mod>
ModInt<mod>
operator-(const ModInt<mod>& left, const ModInt<mod>& right){
  return ModInt<mod>(left) -= right;
}

template<int64_t mod>
ModInt<mod>
operator/(const ModInt<mod>& left, const ModInt<mod>& right){
  return ModInt<mod>(left) /= right;
}

template<int64_t mod>
ModInt<mod>
operator*(const ModInt<mod>& left, const ModInt<mod>& right){
  return ModInt<mod>(left) *= right;
}

template<int64_t mod>
ModInt<mod>
operator^(const ModInt<mod>& left, const ModInt<mod>& right){
  return ModInt<mod>(left) ^= right;
}

template<int64_t mod>
ModInt<mod>
operator%(const ModInt<mod>& left, const ModInt<mod>& right){
  return ModInt<mod>(left) %= right;
}

template<int64_t mod>
std::ostream& operator<<(std::ostream& stream, const ModInt<mod>& mod_int){
  stream << mod_int.GetValue();
  return stream;
}

const int64_t MOD=1000000007;

template <int64_t mod>
ModInt<mod> GCD(ModInt<mod> a, ModInt<mod> b) {
  ModInt<MOD> power=a*b;
  if (a.GetValue() < b.GetValue())
    std::swap(a, b);
  ModInt<MOD> r;
  while (1) {
    r = a % b;
    if (r.GetValue() == 0) {
      return power/b;
    } else {
      a = b;
      b = r;
    }
  }
}

//https://www.geeksforgeeks.org/lcm-of-n-numbers-modulo-m/

#define F first
#define S second
#define MAX 1000001

typedef long long ll;
int prime[MAX];
unordered_map<int, int> max_map;

// Function to return a^n
int power(int a, int n)
{
  if (n == 0)
    return 1;
  int p = power(a, n / 2) % MOD;
  p = (p * p) % MOD;
  if (n & 1)
    p = (p * a) % MOD;
  return p;
}

// Function to find the smallest prime factors
// of numbers upto MAX
void sieve()
{
  prime[0] = prime[1] = 1;
  for (int i = 2; i < MAX; i++) {
    if (prime[i] == 0) {
      for (int j = i * 2; j < MAX; j += i) {
        if (prime[j] == 0) {
          prime[j] = i;
        }
      }
      prime[i] = i;
    }
  }
}

// Function to return the LCM modulo M
ll lcmModuloM(const int* ar, int n)
{

  for (int i = 0; i < n; i++) {
    int num = ar[i];
    unordered_map<int, int> temp;

    // Temp stores mapping of prime factor to
    // its power for the current element
    while (num > 1) {

      // Factor is the smallest prime factor of num
      int factor = prime[num];

      // Increase count of factor in temp
      temp[factor]++;

      // Reduce num by its prime factor
      num /= factor;
    }

    for (auto it : temp) {

      // Store the highest power of every prime
      // found till now in a new map max_map
      max_map[it.first] = max(max_map[it.first], it.second);
    }
  }

  ll ans = 1;

  for (auto it : max_map) {

    // LCM is product of primes to their highest powers modulo M
    ans = (ans * power(it.F, it.S)) % MOD;
  }

  return ans;
}



int main(){
  cout << std::fixed << std::setprecision(16);
  cin.tie(nullptr);
  std::ios::sync_with_stdio(false);
  sieve();

  lint n;
  cin>>n;
  int a[10001];
  for(int i=0;i<n;i++){
    cin >> a[i];
  }

  if(n==1){
    cout<<1<<endl;
    return 0;
  }

  ModInt<MOD> lcm(lcmModuloM(a,n));

  ModInt<MOD> result;
  for(int i=0;i<n;i++){
    result+=lcm/ModInt<MOD>(a[i]);
  }
  cout<<result<<endl;




  return 0;
}




Measured memory_bytes: 4608