#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/priority_queue.hpp>
#include "bits/stdc++.h"
using namespace std;
using ll = int;
#define rep(i,n) for(int i=0;i<n;i++)
#define pb(a) push_back(a)
#define all(a) a.begin(), a.end()
const ll INF = (1LL << 30);
using namespace __gnu_pbds;
// base: bafcf8
unsigned int bit_ceil(unsigned int n) {
unsigned int x = 1;
while(x < (unsigned int)(n)) x *= 2;
return x;
}
int countr_zero(unsigned int n) { return __builtin_ctz(n); }
constexpr int countr_zero_constexpr(unsigned int n) {
int x = 0;
while(!(n & (1 << x))) x++;
return x;
}
template<class S, S (*op)(S, S), S (*e)()> struct segtree {
public:
segtree() : segtree(0) {}
explicit segtree(int n) : segtree(vector<S>(n, e())) {}
explicit segtree(const vector<S>& v) : _n(int(v.size())) {
size = (int)bit_ceil((unsigned int)(_n));
log = countr_zero((unsigned int)size);
d = vector<S>(2 * size, e());
for(int i = 0; i < _n; i++) d[size + i] = v[i];
for(int i = size - 1; i >= 1; i--) { update(i); }
}
void set(int p, S x) {
// assert(0 <= p && p < _n);
p += size;
d[p] = x;
for(int i = 1; i <= log; i++) update(p >> i);
}
S get(int p) const {
// assert(0 <= p && p < _n);
return d[p + size];
}
S prod(int l, int r) const {
// assert(0 <= l && l <= r && r <= _n);
S sml = e(), smr = e();
l += size;
r += size;
while(l < r) {
if(l & 1) sml = op(sml, d[l++]);
if(r & 1) smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() const { return d[1]; }
template<class F> int max_right(int l, F f) {
// assert(0 <= l && l <= _n);
// assert(f(e()));
if(l == _n) return _n;
l += size;
S sm = e();
do {
while(l % 2 == 0) l >>= 1;
if(!f(op(sm, d[l]))) {
while(l < size) {
l = (2 * l);
if(f(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while((l & -l) != l);
return _n;
} // faa03f
template<class F> int min_left(int r, F f) {
// assert(0 <= r && r <= _n);
// assert(f(e()));
if(r == 0) return 0;
r += size;
S sm = e();
do {
r--;
while(r > 1 && (r % 2)) r >>= 1;
if(!f(op(d[r], sm))) {
while(r < size) {
r = (2 * r + 1);
if(f(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while((r & -r) != r);
return 0;
} // efa466
private:
int _n, size, log;
vector<S> d;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};
using P = pair<ll, int> ;
P e1() {
return {INF, -1};
}
P op1(P a, P b) {
return min(a, b);
}
ll e() {
return 0;
}
ll op(ll a, ll b) {
return __gcd(a, b);
}
vector<ll> divisor(ll n) {
vector<ll> v;
for(ll i = 1; i * i <= n; i ++) {
if(n % i == 0) {
if(i * i != n) v.pb(n/i);
v.pb(i);
}
}
return v;
}
void solve() {
ll n, k;
cin >> n >> k;
vector<ll> a(n);
rep(i, n) {
cin >> a[i];
}
auto b = a;
sort(all(b));
ll g = 0;
rep(i, n - 1) g = __gcd(g, b[i + 1] - b[i]);
if(g == 0) {
long long K = k;
cout << K << " " << (K + 1) * K / 2 << endl;
return ;
}
vector<P> minbase(n);
rep(i, n) {
minbase[i] = {a[i], i};
}
segtree<P, op1, e1> segmin(minbase);
vector<ll> c(n - 1);
rep(i, n - 1) c[i] = abs(a[i + 1] - a[i]);
segtree<ll, op, e> seggcd(c);
gp_hash_table<ll, P> mpmin;
gp_hash_table<ll, ll> mpgcd;
unordered_set<ll> st;
// unordered_map<ll, P> mpmin;
// unordered_map<ll, ll> mpgcd;
auto dfs = [&](auto dfs, ll le, ll ri, ll x) -> bool {
if(le >= ri) return true;
ll idx = ri * n + le;
if(!st.count(idx)) {
mpmin[idx] = segmin.prod(le, ri);
mpgcd[idx] = seggcd.prod(le, ri - 1);
st.insert(idx);
}
ll G = mpgcd[idx];
if(G == 0) return true;
auto [M, Mid] = mpmin[idx];
if(G % (M + x) == 0) {
return (dfs(dfs, le, Mid, x) & dfs(dfs, Mid + 1, ri, x));
} else return false;
};
ll Min = b[0];
auto vec = divisor(g);
ll cnt = 0, ans = 0;
for(ll e : vec) {
if(e > Min) {
if(e - Min > k) continue;
if(dfs(dfs, 0, n, e - Min)) {
ans += e - Min;
cnt ++;
}
}
}
cout << cnt << " " << ans << endl;
}
int main(){
int t; cin >> t;
rep(i, t) solve();
return 0;
}