#include <bits/stdc++.h>
constexpr int N = 5e5 + 5;
constexpr int INF = 1e9;

struct Tree {
    int ls, rs;
    int val;
}t[N * 60];
int idx;

void pushup(int p) {
    t[p].val = t[t[p].ls].val + t[t[p].rs].val;
}

int build(int l, int r) {
    int p = ++idx;
    if (l == r) {
        return p;
    }
    int mid = l + r >> 1;
    t[p].ls = build(l, mid);
    t[p].rs = build(mid + 1, r);
    return p;
}

int modify(int now, int l, int r, int x, int val) {
    int p = ++idx;
    t[p] = t[now];
    if (l == r) {
        t[p].val = val;
        return p;
    }
    int mid = l + r >> 1;
    if (x <= mid) t[p].ls = modify(t[now].ls, l, mid, x, val);
    else t[p].rs = modify(t[now].rs, mid + 1, r, x, val);
    pushup(p);
    return p;
}

int query(int p, int l, int r, int ql, int qr) {
    if (ql > qr) return 0;
    if (!p) return 0;
    if (l >= ql && qr >= r) {
        return t[p].val;
    }
    int mid = l + r >> 1, ans = 0;
    if (ql <= mid) ans += query(t[p].ls, l, mid, ql, qr);
    if (qr > mid) ans += query(t[p].rs, mid + 1, r, ql, qr);
    return ans;
}

std::vector<std::vector<int>> pos(N);
std::vector<int> pre(N);

void solve() {
    int n, m;
    std::cin >> n >> m;

    idx = 0;

    std::vector<int> a(n + 1, 0);
    std::vector<int> allnum; allnum.clear();
    allnum.emplace_back(1);
    for (int i = 1; i <= n; i++) {
        std::cin >> a[i];
        allnum.emplace_back(a[i] + 1);
    }
    
    std::sort(allnum.begin(), allnum.end());
    allnum.erase(std::unique(allnum.begin(), allnum.end()), allnum.end());

    for (auto num : allnum) {
        pos[num].emplace_back(0);
    }
    for (int i = 1; i <= n; i++) {
        pos[a[i]].emplace_back(i);
    }

    std::vector<int> root(n + 1, 0);
    root[0] = build(1, n);

    
    // std::vector<int> pre(m + 1, 0);
    for (int i = 1; i <= n; i++) {
        if (!pre[a[i]]) {
            root[i] = modify(root[i - 1], 1, n, i, 1);
            pre[a[i]] = i;
        } else {
            int tmp = modify(root[i - 1], 1, n, pre[a[i]], 0);
            root[i] = modify(tmp, 1, n, i, 1);
            pre[a[i]] = i;
        }
    }

    int ans = -1;
    for (auto mex : allnum) {
        pos[mex].emplace_back(n + 1);
        for (int i = 0, len = (int)pos[mex].size(); i < len - 1; i++) {
            int l = pos[mex][i] + 1, r = pos[mex][i + 1] - 1;
            ans = std::max(ans, ((l > r) ? 0 : query(root[r], 1, n, l, r)) - mex);
        }
    }

    std::cout << ans << '\n';

    for (int i = 1; i <= n; i++) {
        pos[a[i]].clear();
        pos[a[i] + 1].clear();
        pre[a[i]] = 0;
    }
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);

    int T;
    std::cin >> T;

    while (T--) {
        solve();
    }
    return 0;
}