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 java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {

    public static void main(String[] args) {
        FastScanner fs = new FastScanner();

        int T = fs.nextInt();

        for (int t = 0; t < T; t++) {
            int n = fs.nextInt();
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = fs.nextLong();
            }

            MinSparseTable st = new MinSparseTable(arr);
            boolean flag = false;
            for (int i = 0; i < n-2; i++) {
                for (int j = i+1; j < n-1; j++) {
                    long a = arr[i];
                    long b = arr[j];

                    if (st.queryMin(j+1, arr.length-1) < b && a < b) {
                        int idx = st.queryMinIndex(j+1, arr.length-1);
                        System.out.println("YES");
                        System.out.println((i+1) + " " + (j+1) + " " + (idx+1));
                        flag = true;
                        break;
                    }
                }
                if (flag) break;
            }
            if (!flag) {
                System.out.println("NO");
            }

            // end test cases
        }

        // end main
    }

    static class MinSparseTable {

        // The number of elements in the original input array.
        private int n;

        // The maximum power of 2 needed. This value is floor(log2(n))
        private int P;

        // Fast log base 2 logarithm lookup table, 1 <= i <= n
        private int[] log2;

        // The sparse table values.
        private long[][] dp;

        // Index Table (IT) associated with the values in the sparse table. This table
        // is only useful when we want to query the index of the min (or max) element
        // in the range [l, r] rather than the value itself. The index table doesn’t
        // make sense for most other range query types like gcd or sum.
        private int[][] it;

        public MinSparseTable(long[] values) {
            n = values.length;
            P = (int) (Math.log(n) / Math.log(2));
            dp = new long[P + 1][n];
            it = new int[P + 1][n];

            for (int i = 0; i < n; i++) {
                dp[0][i] = values[i];
                it[0][i] = i;
            }

            log2 = new int[n + 1];
            for (int i = 2; i <= n; i++) {
                log2[i] = log2[i / 2] + 1;
            }

            // Build sparse table combining the values of the previous intervals.
            for (int p = 1; p <= P; p++) {
                for (int i = 0; i + (1 << p) <= n; i++) {
                    long leftInterval = dp[p - 1][i];
                    long rightInterval = dp[p - 1][i + (1 << (p - 1))];
                    dp[p][i] = Math.min(leftInterval, rightInterval);

                    // Propagate the index of the best value
                    if (leftInterval <= rightInterval) {
                        it[p][i] = it[p - 1][i];
                    } else {
                        it[p][i] = it[p - 1][i + (1 << (p - 1))];
                    }
                }
            }
        }

        // Do a min query on the interval [l, r] in O(1).
        //
        // We can get O(1) query by finding the smallest power of 2 that fits within
        // the interval length which we'll call k. Then we can query the intervals
        // [l, l+k] and [r-k+1, r] (which likely overlap) and apply the function
        // again. Some functions (like min and max) don't care about overlapping
        // intervals so this trick works, but for a function like sum this would
        // return the wrong result since it is not an idempotent binary function
        // (aka an overlap friendly function).
        private long queryMin(int l, int r) {
            int length = r - l + 1;
            int p = log2[length];
            int k = 1 << p; // 2 to the power of p
            return Math.min(dp[p][l], dp[p][r - k + 1]);
        }

        // Returns the index of the minimum element in the range [l, r].
        public int queryMinIndex(int l, int r) {
            int length = r - l + 1;
            int p = log2[length];
            int k = 1 << p; // 2 to the power of p
            long leftInterval = dp[p][l];
            long rightInterval = dp[p][r - k + 1];
            if (leftInterval <= rightInterval) {
                return it[p][l];
            } else {
                return it[p][r - k + 1];
            }
        }
    }


    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() { return Integer.parseInt(next()); }

        long nextLong() { return Long.parseLong(next()); }

        double nextDouble() { return Double.parseDouble(next()); }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}