The only difference between easy and hard versions is constraints.

You are given a sequence $a$ consisting of $n$ positive integers.

Let's define a three blocks palindrome as the sequence, consisting of at most two distinct elements (let these elements are $a$ and $b$, $a$ can be equal $b$) and is as follows: $[\underbrace{a, a, \dots, a}_{x}, \underbrace{b, b, \dots, b}_{y}, \underbrace{a, a, \dots, a}_{x}]$. There $x, y$ are integers greater than or equal to $0$. For example, sequences $[]$, $[2]$, $[1, 1]$, $[1, 2, 1]$, $[1, 2, 2, 1]$ and $[1, 1, 2, 1, 1]$ are three block palindromes but $[1, 2, 3, 2, 1]$, $[1, 2, 1, 2, 1]$ and $[1, 2]$ are not.

Your task is to choose the maximum by length subsequence of $a$ that is a three blocks palindrome.

You have to answer $t$ independent test cases.

Recall that the sequence $t$ is a a subsequence of the sequence $s$ if $t$ can be derived from $s$ by removing zero or more elements without changing the order of the remaining elements. For example, if $s=[1, 2, 1, 3, 1, 2, 1]$, then possible subsequences are: $[1, 1, 1, 1]$, $[3]$ and $[1, 2, 1, 3, 1, 2, 1]$, but not $[3, 2, 3]$ and $[1, 1, 1, 1, 2]$.


-----Input-----

The first line of the input contains one integer $t$ ($1 \le t \le 2000$) — the number of test cases. Then $t$ test cases follow.

The first line of the test case contains one integer $n$ ($1 \le n \le 2000$) — the length of $a$. The second line of the test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 26$), where $a_i$ is the $i$-th element of $a$. Note that the maximum value of $a_i$ can be up to $26$.

It is guaranteed that the sum of $n$ over all test cases does not exceed $2000$ ($\sum n \le 2000$).


-----Output-----

For each test case, print the answer — the maximum possible length of some subsequence of $a$ that is a three blocks palindrome.


-----Example-----
Input
6
8
1 1 2 2 3 2 1 1
3
1 3 3
4
1 10 10 1
1
26
2
2 1
3
1 1 1

Output
7
2
4
1
1
3

Difficulty: introductory

Starter code:

Solutions:
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    def f(a,b):
        if a == b:
            return len(d[a])
        da = d[a]
        db = d[b]
        res = 0
        for x in range(len(da) >> 1):
            l = da[x]
            r = da[-1-x]
            i = bisect.bisect_left(db,l)
            j = bisect.bisect_left(db,r)
            y = max(0,j-i)
            s = 2*(x+1)+y
            if res < s:
                res = s
        return res

    t = I()
    for _ in range(t):
        n = I()
        a = LI()
        m = max(a)
        d = [[] for i in range(m)]
        for i in range(n):
            ai = a[i]-1
            d[ai].append(i)
        ans = 1
        for a in range(m):
            if not d[a]:
                continue
            for b in range(m):
                if not d[b]:
                    continue
                res = f(a,b)
                if ans < res:
                    ans = res
        print(ans)
    return

#Solve
def __starting_point():
    solve()

__starting_point()

for _ in range(int(input())):
	n = int(input())
	r = list(map(int, input().split()))
	d = {i: [] for i in range(1, 27)}
	for i in range(n):
		d[r[i]].append(i)
	ans = 1
	for end in range(1, 27):
		c = 1
		while c * 2 <= len(d[end]):
			ll, rr = d[end][c - 1] + 1, d[end][-c] - 1
			dd = [0] * 27
			for p in range(ll, rr + 1):
				dd[r[p]] += 1
			ans = max(ans, max(dd) + 2 * c)
			c += 1
	print (ans)