Arpa has found a list containing n numbers. He calls a list bad if and only if it is not empty and gcd (see notes section for more information) of numbers in the list is 1.

Arpa can perform two types of operations:

  * Choose a number and delete it with cost x. 
  * Choose a number and increase it by 1 with cost y. 



Arpa can apply these operations to as many numbers as he wishes, and he is allowed to apply the second operation arbitrarily many times on the same number.

Help Arpa to find the minimum possible cost to make the list good.

Input

First line contains three integers n, x and y (1 ≤ n ≤ 5·105, 1 ≤ x, y ≤ 109) — the number of elements in the list and the integers x and y.

Second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the elements of the list.

Output

Print a single integer: the minimum possible cost to make the list good.

Examples

Input

4 23 17
1 17 17 16


Output

40


Input

10 6 2
100 49 71 73 66 96 8 60 41 63


Output

10

Note

In example, number 1 must be deleted (with cost 23) and number 16 must increased by 1 (with cost 17).

A gcd (greatest common divisor) of a set of numbers is the maximum integer that divides all integers in the set. Read more about gcd [here](https://en.wikipedia.org/wiki/Greatest_common_divisor).
#include <bits/stdc++.h>
using namespace std;
constexpr int MOD = 1000000007;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
  i >> p.first >> p.second;
  return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
  for (auto& v : t) {
    i >> v;
  }
  return i;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
  for (size_t i = 0; i < t.size(); ++i) {
    o << t[i] << " \n"[i == t.size() - 1];
  }
  return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
auto fraclt = [](const std::pair<int, int>& a, const std::pair<int, int>& b) {
  return (long long)a.first * b.second < (long long)b.first * a.second;
};
struct cmpfrac {
  bool operator()(const std::pair<int, int>& a,
                  const std::pair<int, int>& b) const {
    return (long long)a.first * b.second < (long long)b.first * a.second;
  }
};
template <typename T>
bool in(T a, T b, T c) {
  return a <= b && b < c;
}
unsigned int logceil(long long first) {
  unsigned int b = 0;
  while (first) {
    first >>= 1;
    ++b;
  }
  return b;
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
  hash<T> t;
  hash<U> u;
  size_t operator()(const pair<T, U>& p) const {
    return t(p.first) ^ (u(p.second) << 7);
  }
};
}  // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
  T r = -1, m;
  while (l <= h) {
    m = (l + h) / 2;
    if (f(m)) {
      l = m + 1;
      r = m;
    } else {
      h = m - 1;
    }
  }
  return r;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
  T r = -1, m;
  while (l <= h) {
    m = (l + h) / 2;
    if (f(m)) {
      h = m - 1;
      r = m;
    } else {
      l = m + 1;
    }
  }
  return r;
}
template <typename T>
T gcd(T a, T b) {
  if (a < b) swap(a, b);
  return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
 public:
  vector2() {}
  vector2(size_t a, size_t b, T t = T())
      : vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector<vector<T>>> {
 public:
  vector3() {}
  vector3(size_t a, size_t b, size_t c, T t = T())
      : vector<vector<vector<T>>>(a, vector<vector<T>>(b, vector<T>(c, t))) {}
};
template <typename T>
struct bounded_priority_queue {
  inline bounded_priority_queue(unsigned int X) : A(X), B(0) {}
  inline void push(unsigned int L, T V) {
    B = max(B, L);
    A[L].push(V);
  }
  inline const T& top() const { return A[B].front(); }
  inline void pop() {
    A[B].pop();
    while (B > 0 && A[B].empty()) --B;
  }
  inline bool empty() const { return A[B].empty(); }
  inline void clear() {
    B = 0;
    for (auto& a : A) a = queue<T>();
  }

 private:
  vector<queue<T>> A;
  unsigned int B;
};
struct UnionFind {
  UnionFind(size_t N) : P(N, -1), comp(N) {}
  int find(int first) {
    while (P[first] >= 0) {
      first = P[first];
    }
    return first;
  }
  bool united(int first, int second) { return find(first) == find(second); }
  bool unite(int first, int second) {
    first = find(first);
    second = find(second);
    if (first == second) {
      return false;
    }
    --comp;
    if (P[first] > P[second]) {
      swap(first, second);
    }
    P[first] += P[second];
    P[second] = first;
    return true;
  }
  vector<int> P;
  size_t comp;
};
unsigned long long mulull(unsigned long long a, unsigned long long z,
                          unsigned long long mod) {
  __int128 result = ((__int128)a * (__int128)z) % (__int128)mod;
  return (unsigned long long)result;
}
pair<unsigned long long, unsigned long long> mulull(unsigned long long a,
                                                    unsigned long long b) {
  __int128 result = (__int128)a * (__int128)b;
  return {(unsigned long long)(result >> 64), (unsigned long long)result};
}
bool fractionGreaterOrEqual(long long a, long long b, long long c,
                            long long d) {
  if (b < 0) {
    b = -b;
    a = -a;
  }
  if (d < 0) {
    d = -d;
    c = -c;
  }
  return a < 0 && c < 0 ? mulull(-a, d) <= mulull(-c, b)
                        : (a >= 0) && (c < 0 || mulull(a, d) >= mulull(c, b));
}
bool fractionGreaterOrEqual(double a, double b, double c, double d) {
  return a / b >= c / d;
}
namespace Envelope {
template <typename T>
struct Line {
  T m, b;
  mutable function<const Line<T>*()> succ;
  bool operator<(const Line& rhs) const {
    if (rhs.b != numeric_limits<T>::min()) return m < rhs.m;
    const Line* s = succ();
    if (!s) return 0;
    return b - s->b < (s->m - m) * rhs.m;
  }
};
template <typename T>
struct Upper : public multiset<Envelope::Line<T>> {
  using parent = multiset<Line<T>>;
  bool bad(typename parent::iterator second) {
    auto z = next(second);
    if (second == parent::begin()) {
      return z != parent::end() && second->m == z->m && second->b <= z->b;
    } else {
      auto first = prev(second);
      if (z == parent::end()) {
        return second->m == first->m && second->b <= first->b;
      } else {
        return fractionGreaterOrEqual(first->b - second->b,
                                      second->m - first->m, second->b - z->b,
                                      z->m - second->m);
      }
    }
  }
  void insert_line(T m, T b) {
    auto second = parent::insert({m, b});
    second->succ = [=] {
      return next(second) == parent::end() ? 0 : &*next(second);
    };
    if (bad(second)) {
      parent::erase(second);
      return;
    }
    while (next(second) != parent::end() && bad(next(second)))
      parent::erase(next(second));
    while (second != parent::begin() && bad(prev(second)))
      parent::erase(prev(second));
  }
  T operator[](T first) const {
    auto l = parent::lower_bound({first, numeric_limits<T>::min()});
    return l == parent::end() ? numeric_limits<T>::min() : l->m * first + l->b;
  }
};
template <typename T>
struct Lower : public Upper<T> {
  void insert_line(T m, T b) { Upper<T>::insert_line(-m, -b); }
  T operator[](T first) const { return -Upper<T>::operator[](first); }
};
}  // namespace Envelope
struct Sieve : public std::vector<bool> {
  explicit Sieve(unsigned int n) : vector<bool>(n + 1, true), n(n) {
    at(0) = false;
    at(1) = false;
    for (unsigned int i = 2; i * i <= n; ++i) {
      if (at(i))
        for (int j = i * i; j <= n; j += i) (*this)[j] = false;
    }
  }
  vector<int> primes() const {
    vector<int> ans;
    for (int i = 2; i <= n; ++i)
      if (at(i)) ans.push_back(i);
    return ans;
  }

 private:
  int n;
};
struct Moebius : public std::vector<std::pair<int, int>> {
  explicit Moebius(unsigned int n) : Moebius(n, Sieve{n}.primes()) {}
  Moebius(int n, const vector<int>& primes) {
    search(-1, 1, 1, n, primes);
    std::sort(begin(), end());
  }

 private:
  void search(int i, int first, int second, int n, const vector<int>& primes) {
    push_back({first, second});
    while (++i < primes.size() && (long long)first * primes[i] <= n)
      search(i, first * primes[i], -second, n, primes);
  }
};
struct LargePrimes : public vector<int> {
  LargePrimes()
      : vector<int>{
            7,     9,     21,    33,    87,    93,    97,    103,   123,
            181,   207,   223,   241,   271,   289,   297,   321,   349,
            363,   403,   409,   411,   427,   433,   439,   447,   453,
            459,   483,   513,   531,   579,   607,   613,   637,   663,
            711,   753,   787,   801,   829,   861,   871,   891,   901,
            919,   931,   933,   993,   1011,  1021,  1053,  1087,  1099,
            1137,  1161,  1203,  1213,  1237,  1263,  1269,  1273,  1279,
            1311,  1329,  1333,  1351,  1371,  1393,  1413,  1447,  1449,
            1491,  1501,  1531,  1537,  1539,  1581,  1617,  1621,  1633,
            1647,  1663,  1677,  1699,  1759,  1773,  1789,  1791,  1801,
            1803,  1819,  1857,  1887,  1917,  1927,  1957,  1963,  1969,
            2043,  2089,  2103,  2139,  2149,  2161,  2173,  2187,  2193,
            2233,  2239,  2277,  2307,  2359,  2361,  2431,  2449,  2457,
            2499,  2571,  2581,  2607,  2631,  2637,  2649,  2667,  2727,
            2791,  2803,  2821,  2823,  2827,  2907,  2937,  2989,  3009,
            3013,  3051,  3057,  3097,  3111,  3133,  3153,  3157,  3163,
            3211,  3241,  3247,  3253,  3267,  3271,  3273,  3283,  3309,
            3337,  3351,  3357,  3373,  3379,  3397,  3469,  3471,  3513,
            3519,  3559,  3577,  3579,  3601,  3621,  3643,  3651,  3663,
            3679,  3709,  3747,  3751,  3769,  3777,  3787,  3793,  3843,
            3853,  3871,  3889,  3891,  3909,  3919,  3931,  3951,  3957,
            3967,  3987,  3999,  4023,  4059,  4099,  4119,  4123,  4207,
            4233,  4249,  4251,  4263,  4321,  4329,  4381,  4389,  4437,
            4449,  4459,  4497,  4507,  4519,  4539,  4567,  4569,  4581,
            4609,  4611,  4627,  4633,  4647,  4693,  4699,  4717,  4771,
            4777,  4783,  4791,  4807,  4839,  4843,  4849,  4857,  4867,
            4869,  4891,  4893,  4897,  4927,  4933,  4977,  4981,  5001,
            5029,  5053,  5067,  5103,  5133,  5187,  5197,  5203,  5233,
            5277,  5287,  5299,  5317,  5329,  5341,  5353,  5361,  5403,
            5407,  5437,  5443,  5449,  5451,  5469,  5491,  5527,  5541,
            5547,  5583,  5631,  5647,  5683,  5731,  5737,  5751,  5763,
            5791,  5823,  5827,  5833,  5847,  5863,  5899,  5907,  5947,
            5953,  5959,  5971,  5973,  5991,  5997,  6019,  6027,  6037,
            6039,  6061,  6093,  6099,  6127,  6129,  6177,  6193,  6211,
            6223,  6229,  6307,  6313,  6331,  6349,  6379,  6393,  6417,
            6421,  6457,  6459,  6477,  6541,  6571,  6577,  6583,  6607,
            6621,  6661,  6663,  6697,  6717,  6751,  6781,  6837,  6867,
            6901,  6957,  6961,  6967,  6981,  7003,  7023,  7027,  7089,
            7117,  7137,  7147,  7159,  7191,  7209,  7237,  7243,  7257,
            7279,  7321,  7347,  7383,  7389,  7417,  7429,  7447,  7453,
            7467,  7479,  7497,  7513,  7521,  7531,  7537,  7557,  7633,
            7647,  7651,  7653,  7681,  7707,  7719,  7741,  7759,  7773,
            7803,  7819,  7837,  7873,  7887,  7909,  7923,  7927,  7929,
            7941,  8041,  8083,  8089,  8101,  8109,  8127,  8173,  8181,
            8223,  8257,  8259,  8271,  8277,  8311,  8313,  8343,  8349,
            8397,  8403,  8419,  8431,  8439,  8487,  8511,  8557,  8593,
            8617,  8637,  8649,  8661,  8671,  8679,  8719,  8727,  8761,
            8773,  8791,  8797,  8803,  8811,  8829,  8853,  8899,  8917,
            8937,  8967,  9009,  9013,  9063,  9081,  9093,  9099,  9123,
            9133,  9163,  9183,  9211,  9223,  9259,  9277,  9279,  9289,
            9301,  9321,  9331,  9363,  9399,  9403,  9421,  9441,  9457,
            9469,  9487,  9519,  9529,  9531,  9541,  9559,  9561,  9567,
            9573,  9579,  9597,  9601,  9609,  9631,  9651,  9667,  9679,
            9711,  9733,  9739,  9757,  9789,  9831,  9859,  9867,  9961,
            9999,  10029, 10051, 10069, 10101, 10153, 10173, 10189, 10197,
            10233, 10243, 10251, 10267, 10281, 10303, 10321, 10327, 10351,
            10357, 10381, 10449, 10467, 10483, 10503, 10513, 10549, 10593,
            10597, 10611, 10633, 10659, 10699, 10707, 10723, 10747, 10749,
            10761, 10773, 10777, 10801, 10833, 10903, 10953, 10969, 10971,
            10981, 10987, 11007, 11011, 11071, 11083, 11091, 11107, 11109,
            11137, 11149, 11161, 11223, 11239, 11253, 11269, 11277, 11283,
            11289, 11301, 11317, 11329, 11371, 11377, 11391, 11421, 11479,
            11487, 11497, 11517, 11533, 11539, 11559, 11583, 11601, 11619,
            11631, 11659, 11673, 11679, 11707, 11763, 11767, 11769, 11773,
            11799, 11811, 11821, 11823, 11847, 11869, 11967, 11983, 11989,
            12019, 12037, 12121, 12157, 12177, 12187, 12217, 12219, 12231,
            12241, 12253, 12297, 12309, 12333, 12337, 12339, 12361, 12367,
            12399, 12411, 12459, 12463, 12483, 12501, 12513, 12523, 12547,
            12553, 12577, 12609, 12631, 12649, 12679, 12681, 12703, 12723,
            12733, 12747, 12753, 12759, 12799, 12847, 12877, 12891, 12901,
            12903, 12927, 12939, 12963, 13011, 13017, 13029, 13039, 13081,
            13087, 13089, 13101, 13107, 13137, 13141, 13143, 13153, 13191,
            13207, 13213, 13237, 13323, 13369, 13419, 13437, 13447, 13477,
            13519, 13537, 13561, 13563, 13587, 13591, 13723, 13741, 13759,
            13789, 13801, 13857, 13881, 13897, 13921, 13923, 13939, 13999,
            14011, 14073, 14077, 14083, 14097, 14121, 14131, 14143, 14157,
            14161, 14167, 14181, 14193, 14209, 14241, 14259, 14271, 14293,
            14361, 14391, 14397, 14437, 14529, 14551, 14581, 14583, 14599,
            14607, 14611, 14643, 14727, 14761, 14773, 14779, 14791, 14823,
            14853, 14881, 14889, 14901, 14931, 14937, 14997, 15031, 15043,
            15057, 15063, 15069, 15097, 15103, 15109, 15117, 15141, 15147,
            15187, 15199, 15217, 15231, 15253, 15271, 15279, 15283, 15307,
            15339, 15349, 15351, 15363, 15369, 15409, 15427, 15447, 15477,
            15487, 15553, 15579, 15591, 15649, 15651, 15673, 15693, 15703,
            15717, 15727, 15747, 15799, 15811, 15823, 15859, 15889, 15963,
            15981, 16009, 16021, 16029, 16047, 16063, 16089, 16093, 16107,
            16153, 16167, 16191, 16201, 16231, 16233, 16261, 16267, 16273,
            16317, 16323, 16411, 16419, 16431, 16489, 16491, 16513, 16539,
            16617, 16621, 16623, 16627, 16651, 16659, 16671, 16711} {
    for (int& i : *this) i += 1000000000;
  }
};
bool isPrime(long long n) {
  for (int p :
       {2,   3,   5,   7,   11,  13,  17,  19,  23,  29,  31,  37,  41,  43,
        47,  53,  59,  61,  67,  71,  73,  79,  83,  89,  97,  101, 103, 107,
        109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181,
        191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257})
    if (p < n && n % p == 0) return false;
  long long d = n - 1, r = 0;
  while (d % 2 == 0) {
    d /= 2;
    r += 1;
  }
  auto composite = [=](int a) {
    long long first = 1, p = a, e = d;
    while (e > 0) {
      if (e % 2 > 0) {
        first = mulull(first, p, n);
      }
      e /= 2;
      p = mulull(p, p, n);
    }
    if (first == 1 || first == n - 1) return false;
    for (int i = 1; i < r; ++i) {
      first = mulull(first, first, n);
      if (first == 1) return true;
      if (first == n - 1) return false;
    }
    return true;
  };
  return !(composite(2)) && (n < 2047 || !composite(3)) &&
         (n < 1373653 || !composite(5)) && (n < 25326001 || !composite(7)) &&
         (n < 3215031751LL || !composite(11)) &&
         (n < 2152302898747LL || !composite(13)) &&
         (n < 3474749660383LL || !composite(17)) &&
         (n < 341550071728321LL || (!composite(19) && !composite(23))) &&
         (n < 3825123056546413051LL ||
          (!composite(29) && !composite(31) && !composite(37)));
}
class TaskB {
 public:
  void solve(istream& cin, ostream& cout) {
    int N, X, Y;
    cin >> N >> X >> Y;
    vector<int> C(2000001, 0), PC(2000001, 0);
    vector<long long> S(2000001, 0), PS(2000001, 0);
    for (int i = 0; i < N; ++i) {
      int a;
      cin >> a;
      C[a]++;
      S[a] += a;
    }
    for (int i = 1; i < 2000001; ++i) {
      PC[i] = PC[i - 1] + C[i];
      PS[i] = PS[i - 1] + S[i];
    }
    int maxDiff = X / Y + 1;
    long long ans = numeric_limits<long long>::max();
    for (int p : Sieve{1000000}.primes()) {
      long long cost = 0;
      for (int i = p; i - p <= 1000000; i += p) {
        cost += Y * ((long long)i * (PC[i] - PC[i - min(maxDiff, p)]) -
                     (PS[i] - PS[i - min(p, maxDiff)]));
        cost += X * (long long)(PC[i - min(maxDiff, p)] - PC[i - p]);
      }
      ans = min(ans, cost);
    }
    cout << ans << endl;
  }
};
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  cout.tie(nullptr);
  TaskB solver;
  std::istream& in(std::cin);
  std::ostream& out(std::cout);
  solver.solve(in, out);
  return 0;
}
