#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;

template<typename T>
struct RMQ {
    int n;
    std::vector<int> BIT;
    std::vector<std::vector<T>> st;

    RMQ() {}
    RMQ(const std::vector<T> &v) {
        init(v);
    }

    void initBIT(int n) {
        BIT.resize(n + 1);
        for(int i = 2; i <= n; i ++ ) {
            BIT[i] = BIT[i / 2] + 1;
        }
    }

    void init(const std::vector<T> &v) {
        n = v.size();

        initBIT(n);

        const int K = BIT[n];
        st.assign(n, std::vector<T>(K + 1));

        for(int i = 0; i < n; i ++ ) {
            st[i][0] = v[i];
        }
        for(int x = 1; x <= K; x ++ ) {
            for(int i = 0; i + (1 << x) - 1 < n; i ++ ) {
                st[i][x] = std::gcd(st[i][x - 1], st[i + (1 << (x - 1))][x - 1]);
            }
        }
    }

    T query(int l, int r) {
        int B = BIT[r - l + 1];
        return std::gcd(st[l][B], st[r - (1 << B) + 1][B]);
    }

};

void solve() {
    i64 n, k;
    std::cin >> n >> k;

    std::vector<i64> g(n + 2), rg(n + 2), a(n + 2);
    for(int i = 1; i <= n; i ++ ) {
        std::cin >> a[i];
        g[i] = std::gcd(g[i - 1], a[i]);
    }

    for(int i = n; i >= 1; i -- ) {
        rg[i] = std::gcd(rg[i + 1], a[i]);
    }
    for(int i = 1; i <= n; i ++ ) {
        a[i] += k;
    }

    RMQ<i64> rmq(a);

    auto fidr = [&](int p, i64 v) -> int {
        if(a[p] % v) return -1;
        int l = p, r = n;
        while(l < r) {
            int mid = l + r + 1 >> 1;
            if((rmq.query(p, mid) % v) == 0) l = mid;
            else r = mid - 1;
        }
        return l;
    };

    auto fidl = [&](int p, i64 v) -> int {
        if(a[p]% v) return -1;
        int l = 1, r = p;
        while(l < r) {
            int mid = l + r >> 1;
            if(rmq.query(mid, p) % v == 0) r = mid;
            else l = mid + 1;
        }
        return r;
    };

    i64 ans = g[n];
    for(int i = 1; i <= n; i ++ ) {
        if(i == n) continue;
        int p = fidr(i + 1, g[i]);
        if(p != -1) {
            if(p == n) {
                ans = std::max(ans, g[i]);
            } else if((rg[p + 1] % g[i]) == 0) {
                ans = std::max(ans, rg[i]);
            }
        }
    }
    
    for(int i = n; i >= 1; i -- ) {
        if(i == 1) continue;
        int p = fidl(i - 1, rg[i]);
        if(p != -1) {
            if(p == 1) {
                ans = std::max(ans, rg[i]);
            } else if(g[p - 1] % rg[i] == 0) {
                ans = std::max(ans, rg[i]);
            }
        }
    }
    
    ans = std::max(ans, rmq.query(1, n));
    std::cout << ans << '\n';
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int t = 1;
    std::cin >> t;
    
    while (t--) {
        solve();
    }
    
    return 0;
}