Problem: Polycarp has 26 tasks. Each task is designated by a capital letter of the Latin alphabet.

The teacher asked Polycarp to solve tasks in the following way: if Polycarp began to solve some task, then he must solve it to the end, without being distracted by another task. After switching to another task, Polycarp cannot return to the previous task.

Polycarp can only solve one task during the day. Every day he wrote down what task he solved. Now the teacher wants to know if Polycarp followed his advice.

For example, if Polycarp solved tasks in the following order: "DDBBCCCBBEZ", then the teacher will see that on the third day Polycarp began to solve the task 'B', then on the fifth day he got distracted and began to solve the task 'C', on the eighth day Polycarp returned to the task 'B'. Other examples of when the teacher is suspicious: "BAB", "AABBCCDDEEBZZ" and "AAAAZAAAAA".

If Polycarp solved the tasks as follows: "FFGZZZY", then the teacher cannot have any suspicions. Please note that Polycarp is not obligated to solve all tasks. Other examples of when the teacher doesn't have any suspicious: "BA", "AFFFCC" and "YYYYY".

Help Polycarp find out if his teacher might be suspicious.

Input

The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow.

The first line of each test case contains one integer n (1 ≤ n ≤ 50) — the number of days during which Polycarp solved tasks.

The second line contains a string of length n, consisting of uppercase Latin letters, which is the order in which Polycarp solved the tasks.

Output

For each test case output: 

  * "YES", if the teacher cannot be suspicious; 
  * "NO", otherwise. 



You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answer).

Example

Input


5
3
ABA
11
DDBBCCCBBEZ
7
FFGZZZY
1
Z
2
AB


Output


NO
NO
YES
YES
YES

Solution (in PYTHON3):

Solution:
#---<Libraries>---#
import os
import collections
import itertools
import math
import bisect
from math import floor,sqrt,log
from collections import defaultdict as dd
from bisect import bisect_left as bl,bisect_right as br

inp    =lambda: int(input())
strng  =lambda: input().strip()
jn     =lambda x,l: x.join(map(str,l))
strl   =lambda: list(input().strip())
mul    =lambda: map(int,input().strip().split())
mulf   =lambda: map(float,input().strip().split())
seq    =lambda: list(map(int,input().strip().split()))

ceil   =lambda x: int(x) if(x==int(x)) else int(x)+1
ceildiv=lambda x,d: x//d if(x%d==0) else x//d+1

flush  =lambda: stdout.flush()
stdstr =lambda: stdin.readline()
stdint =lambda: int(stdin.readline())
stdpr  =lambda x: stdout.write(str(x))

mod=1000000007
#---<Mathematical Operations>---#

def gcd(num1: int, num2: int): #greatest common divisor
    if num1 == 0:
        return num2
    if num2 == 0:
        return num1
    if num1 > num2:
        return gcd(num1 % num2, num2)
    else:
        return gcd(num1, num2 % num1)

def lcm(num1: int, num2: int): #lowest common multiple
    return (num1 * num2) // gcd(num1, num2)

def big_power(num1: int, num2: int):
    result = 1
    while (num2 > 0):
        if num2 & 1:
            result = result * num1
        num1 = num1 ** 2
        num2 >>= 1
    return result

#---<Algorithms>---#

def sieve_of_eratosthenes(number: int):
    num1 = (number - 1) // 2
    arr = [True] * num1
    num2, num3, primes = 0, 3, [2]
    while (num3 * num3 < number):
        if arr[num2]:
            primes.append(num3)
            num4 = 2 * num2 * num2 + 6 * num2 + 3
            while (num4 < num1):
                arr[num4] = False
                num4 = num4 + 2 * num2 + 3
        num2 += 1
        num3 += 1
    while (num2 < num1):
        if arr[num2]:
            primes.append(num3)
        num2 += 1
        num3 += 2
    return primes

def dfs(graph, start, visited = None): #depth first search
    '''
    Here 'graph' represents the adjacency list
    of the graph, and 'start' represents the
    node from which to start
    '''
    if visited is None:
        visited = set()
    visited.add(start)
    for next in (graph[start] - visited):
        dfs(graph, next, visited)
    return visited

def dfs_paths(graph, start, goal):
    '''
    Returns all possible paths between a
    start vertex and a goal vertex
    '''
    stack = [(start, [start])]
    while (stack):
        (vertex, path) = stack.pop()
        for next in (graph[vertex] - set(path)):
            if next == goal:
                yield path + [next]
            else:
                stack.append((next, path + [next]))
    return stack

def bfs(graph, start): #breadth first search
    visited, queue = set(), [start]
    while (queue):
        vertex = queue.pop(0)
        if (vertex not in visited):
            visited.add(vertex)
            queue.extend(graph[vertex] - visited)
    return visited

def bfs_paths(graph, start, goal):
    '''
    Returns all possible paths between a
    start vertex and a goal vertex, where
    the first path is the shortest path
    '''
    queue = [(start, [start])]
    while (queue):
        (vertex, path) = queue.pop(0)
        for next in (graph[vertex] - set(path)):
            if (next == goal):
                yield path + [next]
            else:
                queue.append((next, path + [next]))
    return queue

from os import path
if(path.exists('input.txt')):
    sys.stdin = open("input.txt","r")
    sys.stdout = open("output.txt","w")

a=inp()
def func(n,m):
    b=[]
    flag=0
    for i in range(n):
        if (m[i] in b) and (m[i]!=m[i-1]):
            # print("NO")
            flag=1
            # break
        else:
            b.append(m[i])
    if flag == 1:
        print("NO")
    else:
        print("YES")
            
    pass
for i in range(a):
    n=(inp())
    m=strl()
    func(n,m)