#include <iostream>
using namespace std;
#include <set>
#include <algorithm>
#include <cmath>
#include <map>
#include <cstdio>
#include <string>
#include <cstring>
#include <string.h>
#include <stdlib.h>
#include <iomanip>
#include <fstream>
#include <stdio.h>
#include <stack>
#include <queue>
#include <ctype.h>
#include <vector>
#include <random>
#include <list>
#define ll long long
#define ull unsigned long long
#define pb push_back
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, a, n) for (int i = n; i >= a; i--)
#define pii pair<int, int>
#define pli pair<ll, int>
#define pil pair<int, ll>
#define pll pair<ll, ll>
#define lowbit(x) ((x) & (-x))
ll extend_gcd(ll a, ll b, ll &x, ll &y)
{
    if (b == 0)
    {
        x = 1;
        y = 0;
        return a;
    }
    ll d = extend_gcd(b, a % b, y, x);
    y -= a / b * x;
    return d;
}
ll fastpow(ll a, ll n, ll mod)
{
    ll ans = 1;
    a %= mod;
    while (n)
    {
        if (n & 1)
            ans = (ans * a) % mod; //% mod
        a = (a * a) % mod;         //% mod
        n >>= 1;
    }
    return ans;
}

inline void write(__int128 x)
{
    if (x > 9)
    {
        write(x / 10);
    }
    putchar(x % 10 + '0');
}
__int128 sqrt(__int128 m)
{
    __int128 leftt = 0, rightt = ((__int128)1) << 51, ret = -1, mid;
    while (leftt < rightt)
    {
        mid = (leftt + rightt) / 2;
        if (mid * mid > m)
        {
            rightt = mid;
        }
        else
        {
            leftt = mid + 1;
            ret = mid;
        }
    }
    return ret;
}

const double eps = 1e-6;
int sgn(double x)
{
    if (fabs(x) < eps)
    {
        return 0;
    }
    else
        return x < 0 ? -1 : 1;
}

struct Point
{
    double x, y;
    Point()
    {
    }
    Point(double x, double y) : x(x), y(y)
    {
    }
    Point operator+(Point B)
    {
        return Point(x + B.x, y + B.y);
    }
    Point operator-(Point B)
    {
        return Point(x - B.x, y - B.y);
    }
    bool operator==(Point B)
    {
        return sgn(x - B.x) == 0 && sgn(y - B.y) == 0;
    }
    bool operator<(Point B)
    {
        return sgn(x - B.x) < 0 || (sgn(x - B.x) == 0 && sgn(y - B.y) < 0);
    }
};
typedef Point Vector;
double Cross(Vector A, Vector B) // 叉积
{
    return A.x * B.y - A.y * B.x;
}
double Distance(Point A, Point B)
{
    return hypot(A.x - B.x, A.y - B.y);
}
int Convex_hull(Point *p, int n, Point *ch)
{
    n = unique(p, p + n) - p;
    sort(p, p + n);
    int v = 0;

    for (int i = 0; i < n; i++)
    {
        while (v > 1 && sgn(Cross(ch[v - 1] - ch[v - 2], p[i] - ch[v - 1])) <= 0)
        {
            v--;
        }
        ch[v++] = p[i];
    }

    int j = v;

    for (int i = n - 2; i >= 0; i--)
    {
        while (v > j && sgn(Cross(ch[v - 1] - ch[v - 2], p[i] - ch[v - 1])) <= 0)
        {
            v--;
        }
        ch[v++] = p[i];
    }
    if (n > 1)
    {
        v--;
    }
    return v;
}

int kmp(string s, string p)
{
    int ans = 0, lastt = -1;
    int lenp = p.size();
    vector<int> Next(lenp + 3, 0);
    rep(i, 1, lenp - 1)
    {
        int j = Next[i];
        while (j && p[j] != p[i])
        {
            j = Next[j];
        }
        if (p[j] == p[i])
        {
            Next[i + 1] = j + 1;
        }
        else
        {
            Next[i + 1] = 0;
        }
    }
    int lens = s.size();
    int j = 0;
    rep(i, 0, lens - 1)
    {
        while (j && s[i] != p[j])
        {
            j = Next[j];
        }
        if (s[i] == p[j])
        {
            j++;
        }
        if (j == lenp)
        {
            ans++;
        }
    }
    return ans;
}

int dir[4][2] =
    {
        {-1, 0}, {0, 1}, {1, 0}, {0, -1}}; // 左右上下
// int dir[8][2]={
//         {-1, 0}, {0, 1}, {1, 0}, {0, -1},{-1,-1},{-1,1},{1,-1},{1,1}
// };

#define endl '\n' // 交互题请删除本行
const ll inf = 1000000000000000000ll;
const ll mod1 = 998244353ll, P1 = 131, mod2 = 1e9 + 7ll, P2 = 13331;
ll inverse(ll x)
{
    return fastpow(x, mod1 - 2, mod1);
}

const int N = 1e5 + 10, M = 1e6 + 10;

///////////////////////////////////
#define i64 ll
int tt;

int n;

ll k;

ll b[N], cnt, num[N];
ll yinshu[N], cntyinshu;
ll cntt;
ll zhi[N];

///////////////////////////////////

i64 mul(i64 a, i64 b, i64 m)
{
    return static_cast<__int128>(a) * b % m;
}

i64 power(i64 a, i64 b, i64 m)
{
    i64 res = 1 % m;
    for (; b; b >>= 1, a = mul(a, a, m))
        if (b & 1)
            res = mul(res, a, m);
    return res;
}

bool isprime(i64 n)
{
    if (n < 2)
        return false;

    static constexpr int A[] = {2, 3, 5, 7, 11, 13, 17, 19, 23};
    int s = __builtin_ctzll(n - 1);
    i64 d = (n - 1) >> s;
    for (auto a : A)
    {
        if (a == n)
            return true;
        i64 x = power(a, d, n);
        if (x == 1 || x == n - 1)
            continue;
        bool ok = 0;
        for (int i = 0; i < s - 1; i++)
        {
            x = mul(x, x, n);
            if (x == n - 1)
            {
                ok = 1;
                break;
            }
        }
        if (!ok)
            return 0;
    }
    return 1;
}
std::vector<i64> p;

void f(i64 n)
{
    if (n <= 10000)
    {
        for (int i = 2; i * i <= n; i++)
            for (; n % i == 0; n /= i)
                p.pb(i);
        if (n > 1)
            p.pb(n);
        return;
    }
    if (isprime(n))
    {
        p.pb(n);
        return;
    }
    auto g = [&](i64 x)
    {
        return (mul(x, x, n) + 1) % n;
    };
    i64 x0 = 2;
    while (true)
    {
        i64 x = x0;
        i64 y = x0;
        i64 d = 1;
        i64 power = 1, lam = 0;
        i64 v = 1;
        while (d == 1)
        {
            y = g(y);
            ++lam;
            v = mul(v, abs(x - y), n);
            if (lam % 127 == 0)
            {
                d = __gcd(v, n);
                v = 1;
            }
            if (power == lam)
            {
                x = y;
                power *= 2;
                lam = 0;
                d = __gcd(v, n);
                v = 1;
            }
        }
        if (d != n)
        {
            f(d);
            f(n / d);
            return;
        }
        ++x0;
    }
};

std::vector<i64> factorize(i64 n)
{
    p.clear();

    f(n);
    sort(p.begin(), p.end());
    return p;
}

void dfs(int ceng, ll shu)
{
    if (ceng == cnt + 1)
    {
        yinshu[++cntyinshu] = shu;
        return;
    }
    ll temp = 1;
    rep(i, 0, num[ceng])
    {
        dfs(ceng + 1, shu * temp);
        temp *= b[ceng];
    }
}

///////////////////////////////////

void init()
{
}

///////////////////////////////////

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0); // 交互题请删除本行
     //freopen("ain.txt", "r", stdin); freopen("aout.txt", "w", stdout);

    cin >> tt;
    rep(ttt,1,tt)
    {
        ll minn = 1000000000ll, gcdd = 0, maxx = 0;
        cin >> n >> k;
        bool flag=1;
        rep(i, 1, n)
        {
            cin >> zhi[i];
            if (i > 1)
            {
                gcdd = __gcd(gcdd, abs(zhi[i - 1] - zhi[i]));
                if(zhi[i-1]*2>=zhi[i]&&zhi[i-1]<zhi[i]||zhi[i]*2>=zhi[i-1]&&zhi[i]<zhi[i-1])
                {
                    flag=0;
                    break;
                }
            }
            minn = min(minn, zhi[i]);
        }
        if(flag==0)
        {
            cout<<0<<" "<<0<<endl;
            continue;
        }

        if (gcdd == 0)
        {
            ll ans = (1 + k) * k / 2;
            cout << k << " " << ans << endl;
            continue;
        }

        //
        //   cout<<gcdd<<endl;
        vector<ll> a = factorize(gcdd);

        cntt = a.size();
        cnt = 0;
        for (int i = 0; i < cntt; i++)
        {
            if (i == 0 || a[i] != a[i - 1])
            {
                cnt++;
                b[cnt] = a[i];
                num[cnt] = 1;
            }
            else
            {
                num[cnt]++;
            }
        }

        cntyinshu = 0;
        dfs(1, 1);

        int geshu = 0;
        ll sum = 0;

        rep(j, 1, cntyinshu)
        {
            //  cout<<yinshu[j]<<" ";
            if (yinshu[j] >= minn + 1)
            {
                ll add = yinshu[j] - minn;
                if (add > k)
                {
                    continue;
                }
                rep(ii, 1, n)
                {
                    zhi[ii] += add;
                }

                bool flag = 1;
                ll maxx=zhi[1];

              

                rep(ii, 1, n)
                {
                    zhi[ii] -= add;
                }
                

                if (flag)
                {
                    geshu++;
                    sum += add;
                }
            }
        }
        cout<<geshu<<" "<<sum<<endl;

    }

    return 0;
}