#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define pii pair<int, int>
#define ld long double
#define all(a) (a).begin(), (a).end()

const int MOD = 998244353;

int add(int a, int b) {
    return a + b >= MOD ? a + b - MOD : a + b;
}

int sub(int a, int b) {
    return a >= b ? a - b : a + MOD - b;
}

int mul(int a, int b) {
    return (1ll * a * b) % MOD;
}

int pw(int x, int n) {
    int res = 1;
    while (n) {
        if (n % 2 == 0) {
            x = mul(x, x);
            n /= 2;
        } else {
            res = mul(res, x);
            n--;
        }
    }
    return res;
}

const int G = 3;

void fft(vector<int>& a, bool inv = false) {
    int n = a.size();
    int k = 0;
    while ((1 << k) < n) ++k;
    static vector<int> rev, power = {0, 1};
    rev.resize(n);
    rev[0] = 0;
    for (int i = 1; i < n; ++i) {
        rev[i] = rev[i / 2] / 2 + ((i & 1) << (k - 1));
        if (i < rev[i]) {
            swap(a[i], a[rev[i]]);
        }
    }
    for (int l = 1; l < n; l *= 2) {
        if ((int)power.size() == l) {
            power.resize(2 * l);
            int w = pw(G, (MOD - 1) / 2 / l);
            for (int i = l; i < 2 * l; ++i) {
                power[i] = power[i / 2];
                if (i & 1) {
                    power[i] = mul(power[i], w);
                }
            }
        }
        for (int i = 0; i < n; i += 2 * l) {
            for (int j = 0; j < l; ++j) {
                int x = a[i + j], y = mul(a[i + j + l], power[j + l]);
                a[i + j] = add(x, y);
                a[i + j + l] = sub(x, y);
            }
        }
    }
    if (inv) {
        reverse(a.begin() + 1, a.end());
        int anti = pw(n, MOD - 2);
        for (int& x : a) {
            x = mul(x, anti);
        }
    }
}

vector<int> operator*(vector<int> a, vector<int> b) {
    int sz = a.size() + b.size() - 1;
    int k = 0;
    while ((1 << k) < sz) ++k;
    a.resize(1 << k);
    b.resize(1 << k);
    fft(a);
    fft(b);
    for (int i = 0; i < (1 << k); ++i) {
        a[i] = mul(a[i], b[i]);
    }
    fft(a, true);
    a.resize(sz);
    return a;
}

vector<int> mulT(vector<int> a, vector<int> c) {
    int n = c.size(), m = a.size();
    int k = 0;
    while ((1 << k) < n) ++k;
    a.resize(1 << k);
    c.resize(1 << k);
    fft(a);
    fft(c, true);
    for (int i = 0; i < (1 << k); ++i) {
        c[i] = mul(c[i], a[i]);
    }
    fft(c);
    c.resize(n - m + 1);
    return c;
}

int binpow(int x, int n, int mod) {
    int res = 1;
    while (n) {
        if (n % 2 == 0) {
            x = (1ll * x * x) % mod;
            n /= 2;
        } else {
            res = (1ll * res * x) % mod;
            n--;
        }
    }
    return res;
}

void solve() {
    int n, p;
    cin >> n >> p;
    vector<int> s(p - 1, 1);
    vector<int> ind(p);
    vector<int> val(p);
    vector<int> prm;
    int p1 = p - 1;
    for (int i = 2; i * i <= p1; ++i) {
        if (p1 % i == 0) {
            prm.push_back(i);
        }
        while (p1 % i == 0) {
            p1 /= i;
        }
    }
    if (p1 != 1) {
        prm.push_back(p1);
    }
    int gen = -1;
    for (int i = 1;; ++i) {
        bool is_gen = true;
        for (int q : prm) {
            if (binpow(i, (p - 1) / q, p) == 1) {
                is_gen = false;
                break;
            }
        }
        if (is_gen) {
            gen = i;
            break;
        }
    }
    /// cerr << "gen: " << gen << endl;
    for (int i = 0, cur = 1; i < p - 1; ++i, cur = (1ll * cur * gen) % p) {
        val[i] = cur;
        ind[cur] = i;
    }

    bool is_zero = false;
    int cnt = p - 1;
    for (int i = 0; i < n; ++i) {
        int x;
        cin >> x;
        if (x == 0) {
            is_zero = true;
        } else {
            s[ind[x]] = 0;
            --cnt;
        }
    }

    if (!is_zero) {
        cout << "1 1\n0\n";
        return;
    }

    int l = 0, r = p + 1;
    while (r - l > 1) {
        int m = (l + r) / 2;
        vector<int> good(2 * (p - 1));
        for (int i = m; i < p; ++i) {
            good[ind[i]] = good[ind[i] + p - 1] = 1;
        }
        auto res = mulT(s, good);
        bool is_full = false;
        for (int i = 0; i < p - 1; ++i) {
            if (res[i] == cnt) {
                is_full = true;
                break;
            }
        }
        if (is_full) {
            l = m;
        } else {
            r = m;
        }
    }
    vector<int> good(2 * (p - 1));
    for (int i = l; i < p; ++i) {
        good[ind[i]] = good[ind[i] + p - 1] = 1;
    }
    auto res = mulT(s, good);
    vector<int> ans;
    for (int i = 0; i < p - 1; ++i) {
        if (res[i] == cnt) {
            ans.push_back(val[i]);
        }
    }
    sort(ans.begin(), ans.end());
    cout << ans.size() << " " << l << "\n";
    for (int i : ans) {
        cout << i << " ";
    }
    cout << "\n";
}

signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int tst;
    cin >> tst;
    while (tst--) {
        solve();
    }

    return 0;
}