#include <bits/stdc++.h>
using namespace std;
using ll = long long;

const int INF = (int)1e9 + 7;
const int TRESHOLD = 600;

// returns number of elements strictly smaller than v in vec
template<class T>
int bins(const vector<T>& vec, T v) {
	int low = 0;
	int high = vec.size();
	while(low != high) {
		int mid = (low + high) >> 1;
		if (vec[mid] < v) low = mid + 1;
		else high = mid;
	}
	return low;
}

void offer(int v, int off, vector<int>& bst) {
	bst[v] = max(bst[v], off);
}

void solve() {
	int n;
	cin >> n;

	vector<int> as(n);
	for (int& a : as) cin >> a;
	
	vector<int> cmp = as;
	sort(cmp.begin(), cmp.end());
	cmp.erase(unique(cmp.begin(), cmp.end()), cmp.end());
	for (int i = 0; i < n; ++i) as[i] = bins(cmp, as[i]);
	int k = cmp.size();

	vector<int> tot(k, 0), suff_max(n + 1, 0);
	for (int i = n-1; i >= 0; --i) {
		++tot[as[i]];
		suff_max[i] = max(suff_max[i + 1], tot[as[i]]);
	}

	int h = 0;
	for (int v : tot) h = max(h, v);

	vector<int> pre(n), lst(k, -1);
	for (int i = 0; i < n; ++i) {
		pre[i] = lst[as[i]];
		lst[as[i]] = i;
	}

	vector<int> ans(k, 0);

	if (h >= TRESHOLD) {
		// O(n^2 / h)
		for (int v = 0; v < k; ++v) {
			if (tot[v] < h/2) continue;

			vector<int> cou(n + 1, 0);
			for (int i = 0; i < n; ++i) cou[i + 1] = (cou[i] + (as[i] == v));
	
			for (int v2 = 0; v2 < k; ++v2) {
				if (v2 == v) continue;
				
				vector<int> apps = {lst[v2]};
				for (int j = pre[lst[v2]]; j >= 0; j = pre[j]) apps.push_back(j);
				reverse(apps.begin(), apps.end());

				// Have v2 on the inside
				int bst = -INF;
				for (int j = (int)apps.size() - 1; j >= 0; --j) {
					bst = max(bst, j + 1 - cou[apps[j]]);
					offer(v, tot[v] + bst - j + cou[apps[j]], ans);
					
					// cerr << v << ' ' << v2 << ' ' << j << ' ' << apps[j] << ": " << tot[v] << ' ' <<  bst << ' ' <<  j << ' ' << cou[apps[j]] << '\n';
				}

				// Have v2 on the outside
				bst = -INF;
				for (int j = (int)apps.size() - 1; j >= 0; --j) {
					bst = max(bst, cou[apps[j]] - j);
					offer(v2, tot[v2] + bst + j + 1 - cou[apps[j]], ans);
	
					// Simple offers
					offer(v2, tot[v] + j+1 - cou[apps[j]], ans);
					offer(v2, cou[apps[j]] + tot[v2] - j, ans);
				}
			}
		}
	} else {
		// O(nh)
		vector<int> counts = {n};
		for (int i = 0; i < n; ++i) {
			for (int a = 1, b = 0, j = pre[i]; a < counts.size(); ++a) {
				while(counts[a] <= j) {
					++b;
					j = pre[j];
				}
				offer(as[i], tot[as[i]] + a - b, ans);
			}

			int cur = 0;
			for (int j = i, cou = 1; j >= 0; j = pre[j], ++cou, ++cur) {
				if (counts.size() <= cou) counts.emplace_back(j);
				else counts[cou] = max(counts[cou], j);
			}
			
			offer(as[i], cur + suff_max[i + 1], ans);
		}
	}

	int res = 0;
	for (int v : ans) res = max(res, v);

	cout << res << '\n';
	for (int v = 0; v < k; ++v) {
		if (ans[v] == res) cout << cmp[v] << ' '; cout << '\n';
	}
}


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

	int t;
	cin >> t;
	for (int ti = 0; ti < t; ++ti) solve();
}