#include <bits/stdc++.h>

using i64 = long long;

void solve() {
    
}

int main() {
    std::cin.tie(nullptr);
    std::ios_base::sync_with_stdio(false);

    int t;
    std::cin >> t;
    int T = t;
    for (int t = 0; t < T; t++) {
        int n, k;
        std::cin >> n >> k;
        std::vector<int> a(n);
        for (int i = 0; i < n; i++) {
            std::cin >> a[i];
        }
        std::vector<int> l(n, -1), r(n, -1);
        std::vector<int> stk;
        int rt;
        for (int i = 0; i < n; i++) {
            int last = -1;
            while (!stk.empty() && a[i] < a[stk.back()]) {
                last = stk.back();
                stk.pop_back();
            }
            if (!stk.empty()) {
                r[stk.back()] = i;
            } else {
                rt = i;
            }
            l[i] = last;
            stk.emplace_back(i);
        }
        if (t ==231) {
            for (int i = 0; i < n; i++) {
                std::cout << a[i] << " \n"[i == n - 1];
            }
        }

        //std::cerr << rt << " " << l[rt] << " " << r[rt] << "\n";
        std::vector<std::vector<int>> cand;
        auto dfs = [&](auto &&self, int x) -> int {
            int g = 0;
            if (l[x] != -1) {
                auto y = self(self, l[x]);
                g = std::__gcd(g, y);
                g = std::__gcd(g, a[l[x]] - a[x]);
            }
            if (r[x] != -1) {
                auto y = self(self, r[x]);
                g = std::__gcd(g, y);
                g = std::__gcd(g, a[r[x]] - a[x]);
            }
            if (g == 0) {
                return 0;
            }
            std::vector<int> t;
            for (int i = 1; i * i <= g; i++) {
                if (g % i == 0) {
                    int v = i;
                    if (v > a[x] && a[x] + k >= v) {
                        t.push_back(v - a[x]);
                    }
                    if (v * v != g) {
                        v = g / i;
                        if (v > a[x] && a[x] + k >= v) {
                            t.push_back(v - a[x]);
                        }
                    }
                }
            }
            cand.push_back(t);
            return g;
        };

        auto v = dfs(dfs, rt);

        if (v == 0) {
            std::cout << k << " " << 1LL * k * (k + 1) / 2 << "\n";
        } else if (v == 1) {
            std::cout << 0 << " " << 0 << "\n";
        } else {
            int cnt = 0;
            i64 res = 0;
            int N = cand.size();
            std::map<int, int> map;
            for (auto v : cand) {
                for (auto x : v) {
                    //std::cerr << x << " \n"[x == v.back()];
                    map[x]++;
                }
            }

            for (auto [x, y] : map) {
                if (y == N) {
                    cnt++;
                    res += x;
                }
            }

            std::cout << cnt << " " << res << "\n";
        }
    }

    return 0;
}