#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;
}