Pussycat Sonya has an array consisting of n positive integers. There are 2n possible subsequences of the array. For each subsequence she counts the minimum number of operations to make all its elements equal. Each operation must be one of two:

  * Choose some element of the subsequence and multiply it by some prime number. 
  * Choose some element of the subsequence and divide it by some prime number. The chosen element must be divisible by the chosen prime number. 



What is the sum of minimum number of operations for all 2n possible subsequences? Find and print this sum modulo 109 + 7.

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 300 000) — the size of the array.

The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 300 000) — elements of the array.

Output

Print the sum of minimum number of operation for all possible subsequences of the given array modulo 109 + 7.

Examples

Input

3
60 60 40


Output

6


Input

4
1 2 3 4


Output

24

Note

In the first sample, there are 8 possible subsequences: (60, 60, 40), (60, 60), (60, 40), (60, 40), (60), (60), (40) and () (empty subsequence).

For a subsequence (60, 60, 40) we can make all elements equal by two operations — divide 40 by 2 to get 20, and then multiply 20 by 3 to get 60. It's impossible to achieve the goal using less operations and thus we add 2 to the answer.

There are two subsequences equal to (60, 40) and for each of them the also need to make at least 2 operations.

In each of other subsequences all numbers are already equal, so we need 0 operations for each of them. The sum is equal to 2 + 2 + 2 = 6.
#include <bits/stdc++.h>
using namespace std;
inline int ri() {
  int x;
  scanf("%d", &x);
  return x;
}
template <typename T>
inline bool smax(T& a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
inline bool smin(T& a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
inline T pw(T a, long long b) {
  T c = 1;
  while (b) {
    if (b & 1) c = (c * a);
    a = a * a;
    b >>= 1;
  }
  return c;
}
struct mint {
  const static long long mod = 1e9 + 7;
  long long x;
  mint() : x(0) {}
  mint(long long x) : x(((x % mod) + mod) % mod){};
  mint operator+=(const mint& a) {
    if ((x += a.x) >= mod) x -= mod;
    return *this;
  }
  mint operator-=(const mint& a) {
    if ((x += mod - a.x) >= mod) x -= mod;
    return *this;
  }
  mint operator*=(const mint& a) {
    (x *= a.x) %= mod;
    return *this;
  }
  mint operator+(const mint& a) const { return mint(*this) += a; }
  mint operator-(const mint& a) const { return mint(*this) -= a; }
  mint operator*(const mint& a) const { return mint(*this) *= a; }
  bool operator==(const mint& a) const { return x == a.x; }
};
const long long mod = 1e9 + 7;
template <typename T>
T inv(T a) {
  return pw(a, mod - 2);
}
const int maxn = 300010;
int p[maxn], cnt[maxn], n;
mint res, c[maxn], s[maxn];
vector<int> g[maxn];
mint f(int l, int r) {
  if (r < l || r < 0 || l > n - 2) return 0;
  if (l < 0) l = 0;
  if (r > n - 2) r = n - 2;
  return s[r] - (l == 0 ? 0 : s[l - 1]);
}
void calc(vector<int>& v) {
  v[0] = n;
  for (int i = (1); i < (20); i++) v[0] -= v[i];
  int sum = 0, num = 0;
  for (int i = 0; i < (20); i++) {
    res += f(num, v[i] + num - 1) * (num * i - sum);
    res += f(num - 1, v[i] + num - 2) * (num * i - sum);
    num += v[i];
    sum += v[i] * i;
  }
  sum = 0;
  num = 0;
  for (int i = 19; i >= 0; i--) {
    res += f(num, v[i] + num - 1) * (sum - num * i);
    res += f(num + 1, v[i] + num) * (sum - num * i);
    num += v[i];
    sum += v[i] * i;
  }
}
int main() {
  n = ri();
  for (int i = 0; i < (n); i++) cnt[ri()]++;
  c[0] = s[0] = 1;
  for (int i = 0; i < (n - 2); i++)
    c[i + 1] = c[i] * inv(mint(i + 1)) * (n - 2 - i),
          s[i + 1] = c[i + 1] + s[i];
  for (int i = (2); i < (maxn); i++) {
    if (p[i]) continue;
    for (int j = i; j < maxn; j += i)
      if (!p[j]) {
        p[j] = i;
      }
  }
  for (int i = 0; i < (maxn); i++)
    if (cnt[i]) {
      int x = i;
      while (x > 1) {
        int t = p[x], cur = 0;
        while (x % t == 0) x /= t, cur++;
        if (g[t].empty()) g[t].resize(20);
        g[t][cur] += cnt[i];
      }
    }
  for (int i = 0; i < (maxn); i++)
    if (!g[i].empty()) calc(g[i]);
  cout << res.x << endl;
  return 0;
}
