#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <random>
#include <unordered_map>
#include <unordered_set>
#include <assert.h>
#include <climits>
#include <iomanip>
using namespace std;

constexpr int MAXN = 1 << 18, LOGN = 21;
pair<int, int> table[LOGN][MAXN]; // sparse table per il minimo
void build(int N, pair<int, int> *V)
{ //$\mathcal{O}(N\log{N})$
  copy(V, V + N, table[0]);
  for (int j = 1; j < LOGN; j++)
  {
    for (int i = 0; i + (1 << j) <= N; i++)
    {
      table[j][i] = min(table[j - 1][i],
                        table[j - 1][i + (1 << j) / 2]);
    }
  } // 0-based (indici di V da 0 a N-1)
}
pair<int, int> query(int l, int r)
{ //[l, r) ($\mathcal{O}(1)$)
  int k = 31 - __builtin_clz(r - l);
  return min(table[k][l], table[k][r - (1 << k)]);
}

int table2[LOGN][MAXN]; // sparse table per il minimo
void build2(int N, int *V)
{ //$\mathcal{O}(N\log{N})$
  copy(V, V + N, table2[0]);
  for (int j = 1; j < LOGN; j++)
  {
    for (int i = 0; i + (1 << j) <= N; i++)
    {
      table2[j][i] = __gcd(table2[j - 1][i],
                           table2[j - 1][i + (1 << j) / 2]);
    }
  } // 0-based (indici di V da 0 a N-1)
}
int query2(int l, int r)
{ //[l, r) ($\mathcal{O}(1)$)
  int k = 31 - __builtin_clz(r - l);
  return __gcd(table2[k][l], table2[k][r - (1 << k)]);
}

void solve([[maybe_unused]] int t)
{
  long long n, k;
  cin >> n >> k;
  pair<int, int> v[n];
  int v2[n - 1];

  for (int i = 0; i < n; i++)
  {
    cin >> v[i].first;
    v[i].second = i;
  }
  for (int i = 0; i < n - 1; i++)
  {
    v2[i] = abs(v[i + 1].first - v[i].first);
  }

  build(n, v);
  build2(n - 1, v2);

  bool ok = true;
  vector<int> sol;

  auto upd = [&](int b, int gcd) -> void
  {
    if (gcd == 0 || !ok)
      return;
    if (gcd <= b)
    {
      ok = false;
      return;
    }

    if (sol.size() == 0)
    {
      vector<int> opz;
      for (long long i = 1; i * i <= gcd; i++)
      {
        if (gcd % i == 0)
        {
          opz.push_back(i);
          if (gcd / i != i)
            opz.push_back(gcd / i);
        }
      }

      for (auto i : opz)
      {
        if (i > b)
          sol.push_back(i - b);
      }
    }
    else
    {
      vector<int> succ;
      for (auto x : sol)
      {
        if (gcd % (b + x) == 0)
        {
          succ.push_back(x);
        }
      }
      if (succ.size() == 0)
        ok = false;
      else
        sol = succ;
    }
  };

  auto calc = [&](auto &calc, int l, int r) -> void
  {
    if (r - l <= 1)
      return;

    auto [mini, pos] = query(l, r);
    int gcd = query2(l, r - 1);

    upd(mini, gcd);

    calc(calc, l, pos);
    calc(calc, pos + 1, r);
  };

  calc(calc, 0, n);

  if (!ok)
  {
    cout << "0 0\n";
  }
  else if (sol.size() == 0)
  {
    cout << k << " " << k * (k + 1) / 2ll << "\n";
  }
  else
  {
    long long ans = 0;
    for (auto i : sol)
      ans += i;
    cout << sol.size() << " " << ans << "\n";
  }
}

int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0);

  int n = 1;
  cin >> n;
  for (int i = 1; i <= n; i++)
    solve(i);
}