#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;
    while (tt--)
    {
        ll minn=1000000000ll,gcdd=0,maxx=0;
        cin>>n>>k;
        rep(i,1,n)
        {
            cin>>zhi[i];
            if(i>1)
            gcdd=__gcd(gcdd,abs(zhi[i-1]-zhi[i])); 

            minn=min(minn,zhi[i]);

        }

        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;

                set<ll > se;
                se.insert(zhi[1]);
                rep(ii,2,n) 
                {
                    auto it=se.lower_bound(zhi[ii]);
                    ll temp;
                    if(it==se.end())
                    {
                        --it;
                         temp=*it;
                        if(zhi[ii]%temp)
                        {
                            flag=0;
                            break;
                        }
                    }
                    else
                    {
                        temp=*it;
                        if(temp%zhi[ii])
                        {
                            flag=0;
                            break;
                        }
                        if(it!=se.begin())
                        {
                            --it;temp=*it;
                        if(temp%zhi[ii])
                        {
                            flag=0;
                            break;
                        }
                            
                        }

                    }
                    se.insert(zhi[ii]);
                }

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

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

        cout<<geshu<<" "<<sum<<endl;


        


        
    }
    
    


    return 0;
}