You are given a permutation $p_1, p_2, \ldots, p_n$ of length $n$. You have to choose two integers $l,r$ ($1 \le l \le r \le n$) and reverse the subsegment $[l,r]$ of the permutation. The permutation will become $p_1,p_2, \dots, p_{l-1},p_r,p_{r-1}, \dots, p_l,p_{r+1},p_{r+2}, \dots ,p_n$.

Find the lexicographically smallest permutation that can be obtained by performing exactly one reverse operation on the initial permutation.

Note that for two distinct permutations of equal length $a$ and $b$, $a$ is lexicographically smaller than $b$ if at the first position they differ, $a$ has the smaller element.

A permutation is an array consisting of $n$ distinct integers from $1$ to $n$ in arbitrary order. For example, $[2,3,1,5,4]$ is a permutation, but $[1,2,2]$ is not a permutation ($2$ appears twice in the array) and $[1,3,4]$ is also not a permutation ($n=3$ but there is $4$ in the array).


-----Input-----

Each test contains multiple test cases. The first line contains a single integer $t$ ($1 \le t \le 500$) — the number of test cases. Description of the test cases follows.

The first line of each test case contains a single integer $n$ ($1 \le n \le 500$) — the length of the permutation.

The second line of each test case contains $n$ integers $p_1, p_2, \dots, p_n$ ($1 \le p_i \le n$) — the elements of the permutation.


-----Output-----

For each test case print the lexicographically smallest permutation you can obtain.


-----Examples-----

Input
4
1
1
3
2 1 3
4
1 4 2 3
5
1 2 3 4 5
Output
1 
1 2 3 
1 2 4 3 
1 2 3 4 5


-----Note-----

In the first test case, the permutation has length $1$, so the only possible segment is $[1,1]$. The resulting permutation is $[1]$.

In the second test case, we can obtain the identity permutation by reversing the segment $[1,2]$. The resulting permutation is $[1,2,3]$.

In the third test case, the best possible segment is $[2,3]$. The resulting permutation is $[1,2,4,3]$.

In the fourth test case, there is no lexicographically smaller permutation, so we can leave it unchanged by choosing the segment $[1,1]$. The resulting permutation is $[1,2,3,4,5]$.

Difficulty: EASY

Solutions:
t = int(input())
for _ in range(t):
	n = int(input())
	p = list(map(int, input().split()))
	first_wrong = 0
	while first_wrong < n and p[first_wrong] == first_wrong + 1:
		first_wrong += 1
	if first_wrong < n:
		needed_index = first_wrong
		while p[needed_index] != first_wrong + 1:
			needed_index += 1
		p = p[:first_wrong] + p[first_wrong:needed_index + 1][::-1] + p[needed_index + 1:]
	ans = ''
	for num in p:
		ans += f'{num} '
	print(ans)


tc = int(input())
for i in range(tc):
	x = int(input())
	z = list(map(int, input().split()))
	y = z.copy()
	y.insert(0, 0)
	list1 = []
	for i in range(1, x):
		if y[i] - y[i - 1] != 1:
			a = z[y.index(y[i]) - 1:y.index(y[i - 1] + 1)]
			g = z[:i - 1] + a[::-1] + z[y.index(y[i - 1] + 1):]
			str1 = ''
			for i in range(len(g)):
				str1 += str(g[i]) + ' '
			print(str1)
			break
		else:
			continue
	else:
		str1 = ''
		for i in range(len(z)):
			str1 += str(z[i]) + ' '
		print(str1)


t = int(input())
for _ in range(0, t):
	n = int(input())
	list1 = [int(num) for num in input().split()]
	list2 = []
	flag1 = 0
	j = 0
	num = 0
	s = ''
	for i in range(0, len(list1)):
		if list1[i] != i + 1:
			flag1 = 1
			num = i + 1
			j = i
			break
		else:
			s += str(list1[i]) + ' '
	if flag1 == 1:
		for j in range(i, len(list1)):
			if list1[j] == num:
				break
		k = j
		for k in range(j, i - 1, -1):
			s += str(list1[k]) + ' '
		k = j + 1
		for k in range(j + 1, len(list1)):
			s += str(list1[k]) + ' '
	print(s)


import sys
t = int(sys.stdin.readline())
for k in range(0, t):
	n = int(sys.stdin.readline())
	p = list(map(int, sys.stdin.readline().split()))
	L = 0
	R = 0
	for i in range(0, n):
		if p[i] > i + 1:
			L = i + 1
			break
	if L == 0:
		pp = p.copy()
	elif L == 1:
		R = p.index(L)
		pp = p[R:0:-1]
		pp.extend(p[0:1])
		pp.extend(p[R + 1:])
	else:
		R = p.index(L)
		pp = p[0:L - 1]
		pp.extend(p[R:L - 2:-1])
		pp.extend(p[R + 1:])
	for i in range(0, n):
		sys.stdout.write(str(pp[i]) + ' ')
	sys.stdout.write('\n')