#include<iostream>
#include<cstring>
#include<vector>
#include<algorithm>
#include<random>
#include<map>
#include<climits>
using namespace std;
using LL = long long;

const int s = 9;
// n < 2^78
const LL p[9] = {2, 3, 5, 7, 11, 13, 17, 19, 23};
mt19937_64 rnd(random_device{}());

LL mul(LL a, LL b, LL p){
    // return __int128(a) * b % p;
    a %= p, b %= p;
    LL c = (long double)a * b / p;
    LL ans = a * b - c * p;
    if (ans < 0)
        ans += p;
    else if (ans >= p)
        ans -= p;
    return ans;
}

LL qpow(LL a, LL n, LL p){
    LL ans = 1;
    a %= p;
    while (n){
        if (n & 1) ans = mul(ans, a, p);
        a = mul(a, a, p);
        n >>= 1;
    }
    return ans;
}

bool check(LL a, LL n, LL x, LL t){
    LL ret = qpow(a, x, n);
    LL last = ret;
    for (int i = 1; i <= t; i++){
        ret = mul(ret, ret, n);
        if (ret == 1 && last != 1 && last != n - 1)
            return true;
        last = ret;
    }
    if (ret != 1) return true;
    else return false;
}

bool Miller_Rabin(LL n){
    if (n < 2) return false;
    for(auto x : p) if (n == x) return true;
    if ((n & 1) == 0) return false;

    LL x = n - 1;
    LL t = 0;
    while ((x & 1) == 0){
        x >>= 1;
        t++;
    }

    for (int i = 0; i < s; i++){
        // LL a = uniform_int_distribution<LL>(1, n - 1)(rnd);
        // if (check(a, n, x, t))
        if (check(p[i], n, x, t)) return false;
    }
    return true;
}


LL Pollard_rho(LL x){
    LL s = 0, t = 0, c = uniform_int_distribution<LL>(1, x - 1)(rnd);
    LL step = 0, goal = 1;
    LL val = 1;
    for (goal = 1;; goal <<= 1, s = t, val = 1){
        for (step = 1; step <= goal; ++step){
            t = (mul(t, t, x) + c) % x;
            val = mul(val, abs(t - s), x);
            if ((step % 127) == 0){
                LL d = __gcd(val, x);
                if (d > 1)
                    return d;
            }
        }
        LL d = __gcd(val, x);
        if (d > 1) return d;
    }
}
LL fac[200], tot;

void findfac(LL n){
    if (n == 1) return;
    if (Miller_Rabin(n)){
        fac[++tot] = n;
        return;
    }
    LL p = n;
    while (p >= n) p = Pollard_rho(n);
    while (n % p == 0) n /= p;
    findfac(n);
    findfac(p);
}

auto go_fac(LL n){ 
   tot = 0;
   if (n > 1) findfac(n);     
   map<LL, int> mp;
   vector<pair<LL, int> > pri;
   for(int i = 1; i <= tot; i++){
       if (mp.contains(fac[i])) continue;
       int c = 0;
       while(n % fac[i] == 0) c += 1, n /= fac[i];
       mp[fac[i]] = c;
   }
   for(auto x : mp) pri.push_back(x);
   return pri;
}

int main(){

#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif

    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);

    int T;
    cin >> T;
    while(T--){
        int n; LL x, y;
        cin >> n >> x >> y;
        vector<LL> a(n);
        for(int i = 0; i < n; i++) cin >> a[i];
        auto pri = go_fac(x);
        LL ans = LLONG_MAX;

        auto get = [&](LL p, LL x){
            LL sum = 0;
            while(p){
                sum += p / x;
                p /= x;
            }
            return sum;
        };

        for(auto [p, c] : pri){
            LL tot = get(y, p);
            for(auto x : a) tot -= get(x, p);
            ans = min(ans, tot / c);
        }
        cout << ans << '\n';
    }

}