You are given a permutation p_1, p_2, ..., p_n. Recall that sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.

Find three indices i, j and k such that: 

  * 1 ≤ i < j < k ≤ n; 
  * p_i < p_j and p_j > p_k. 

Or say that there are no such indices.

Input

The first line contains a single integer T (1 ≤ T ≤ 200) — the number of test cases.

Next 2T lines contain test cases — two lines per test case. The first line of each test case contains the single integer n (3 ≤ n ≤ 1000) — the length of the permutation p.

The second line contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n; p_i ≠ p_j if i ≠ j) — the permutation p.

Output

For each test case: 

  * if there are such indices i, j and k, print YES (case insensitive) and the indices themselves; 
  * if there are no such indices, print NO (case insensitive). 



If there are multiple valid triples of indices, print any of them.

Example

Input


3
4
2 1 4 3
6
4 6 1 2 5 3
5
5 3 1 2 4


Output


YES
2 3 4
YES
3 5 6
NO
# import numpy as np

# np.random.shuffle()

test_cases = int(input())
# test_cases = np.random.randint(8000,9000)
for t in range(test_cases):
    n = int(input())
    sequence = [int(v) for v in input().split(' ')]
    i,j,k = 0,None,None
    # finite state machine
    for index,num in enumerate(sequence):
        
        if j is None:
            # second state
            if num > sequence[i]:
                j = index
            else:
                # update i
                i = index
        elif k is None:

            if num < sequence[j]:
                k = index
                break
            else:
                # update j
                j = index 

    if j is None or k is None:
        print('No')
    else:
        # assert (sequence[j] > sequence[i]) and (sequence[j] > sequence[k])," Incorrect Answer from value\n{0}".format(sequence)
        # assert (j > i) and (k > j)," Incorrect Answer of index order\n{0}".format(sequence)
        # assert (i>= 0) and (k <= n-1), "Incorrect boundary conditions {0},{1},{2}\n{3}".format(i,k,n,sequence)
        # if test_cases == 200 and t == 150:
        #     print("Yes")
        #     print(1,2,3)
        #     # print(sequence)
        # else:
        print('YES')
        print(i+1,j+1,k+1)


# results = [i+1,j+1,k+1]
## Naive solution
# for t in range(test_cases):
#     # n = int(input())
#     n = np.random.randint(5,10)
#     # sequence = input().split(' ')
#     sequence = np.arange(1,n+1,1,dtype=np.int32)
    
#     np.random.shuffle(sequence)
#     # print(sequence)
#     # print()
#     seq = [None]*n
#     for i,v in enumerate(sequence):
#         seq[i] = int(v)
#     sequence = seq
    # index_value_map = {}
    # for index, v in enumerate(sequence):
    #     index_value_map[int(v)] = index

    # for max_value in range(n,1,-1):
    #     i,j,k = None,None,None
    #     if index_value_map[max_value] == n or index_value_map[max_value] == 0:
    #         continue
    #     j = index_value_map[max_value]
    #     # look for k
    #     for indx in range(index_value_map[max_value],n,1):
    #         if sequence[indx] < max_value:
    #             k = indx
    #             break
    #     if k is None:
    #         continue
    #     for indx in range(0,index_value_map[max_value],1):
    #         if sequence[indx] < max_value:
    #             i = indx
    #             break
    #     if i is not None and j is not None:
    #         print('Yes')
    #         print(i+1,j+1,k+1)
    #         break
    # if i is None or j is None:
    #     print('No')
    # print("Solution 2")
    # i,j,k = 0,None,None
    # # finite state machine
    # for index,num in enumerate(sequence):
        
    #     if j is None:
    #         # second state
    #         if num > sequence[i]:
    #             j = index
    #         else:
    #             # update i
    #             i = index
    #     elif k is None:

    #         if num < sequence[j]:
    #             k = index
    #             break
    #         else:
    #             # update j
    #             j = index 

    # if j is None or k is None:
    #     print('No')
    #     print(sequence)
    # else:
    #     # print('YES')
    #     # print(i+1,j+1,k+1)
    #     assert (sequence[j] > sequence[i]) and (sequence[j] > sequence[k])," Incorrect Answer from value\n{0}".format(sequence)
    #     assert (j > i) and (k > i)," Incorrect Answer of index order\n{0}".format(sequence)
    #     assert (i>= 0) and (k <= n-1), "Incorrect boundary conditions {0},{1},{2}\n{3}".format(i,k,n,sequence)

# results = [i+1,j+1,k+1]

# for t in range(test_cases):
#     # n = int(input())
#     # sequence = input().split(' ')
#     i,j,k = 0,None,None
#     # finite state machine
#     for index,num in enumerate(sequence):
        
#         if j is None:
#             # second state
#             if num > sequence[i]:
#                 j = index
#             else:
#                 # update i
#                 i = index
#         elif k is None:

#             if num < sequence[j]:
#                 k = index
#                 break
#             else:
#                 # update j
#                 j = index 

#     if j is None or k is None:
#         print('No')
#     else:
#         print('YES')
#         print(i+1,j+1,k+1)