The new generation external memory contains an array of integers a[1 … n] = [a_1, a_2, …, a_n].

This type of memory does not support changing the value of an arbitrary element. Instead, it allows you to cut out any segment of the given array, cyclically shift (rotate) it by any offset and insert it back into the same place.

Technically, each cyclic shift consists of two consecutive actions: 

  1. You may select arbitrary indices l and r (1 ≤ l < r ≤ n) as the boundaries of the segment. 
  2. Then you replace the segment a[l … r] with it's cyclic shift to the left by an arbitrary offset d. The concept of a cyclic shift can be also explained by following relations: the sequence [1, 4, 1, 3] is a cyclic shift of the sequence [3, 1, 4, 1] to the left by the offset 1 and the sequence [4, 1, 3, 1] is a cyclic shift of the sequence [3, 1, 4, 1] to the left by the offset 2. 



For example, if a = [1, \color{blue}{3, 2, 8}, 5], then choosing l = 2, r = 4 and d = 2 yields a segment a[2 … 4] = [3, 2, 8]. This segment is then shifted by the offset d = 2 to the left, and you get a segment [8, 3, 2] which then takes the place of of the original elements of the segment. In the end you get a = [1, \color{blue}{8, 3, 2}, 5].

Sort the given array a using no more than n cyclic shifts of any of its segments. Note that you don't need to minimize the number of cyclic shifts. Any method that requires n or less cyclic shifts will be accepted.

Input

The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases.

The next 2t lines contain the descriptions of the test cases. 

The first line of each test case description contains an integer n (2 ≤ n ≤ 50) — the length of the array. The second line consists of space-separated elements of the array a_i (-10^9 ≤ a_i ≤ 10^9). Elements of array a may repeat and don't have to be unique.

Output

Print t answers to all input test cases. 

The first line of the answer of each test case should contain an integer k (0 ≤ k ≤ n) — the number of actions to sort the array. The next k lines should contain descriptions of the actions formatted as "l r d" (without quotes) where l and r (1 ≤ l < r ≤ n) are the boundaries of the segment being shifted, while d (1 ≤ d ≤ r - l) is the offset value. Please remember that only the cyclic shifts to the left are considered so the chosen segment will be shifted by the offset d to the to the left.

Note that you are not required to find the minimum number of cyclic shifts needed for sorting. Any sorting method where the number of shifts does not exceed n will be accepted.

If the given array a is already sorted, one of the possible answers is k = 0 and an empty sequence of cyclic shifts.

If there are several possible answers, you may print any of them.

Example

Input


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


Output


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

Note

Explanation of the fourth data set in the example: 

  1. The segment a[2 … 4] is selected and is shifted to the left by 2: [2, \color{blue}{5, 1, 4}, 3] \longrightarrow [2, \color{blue}{4, 5, 1}, 3] 
  2. The segment a[1 … 5] is then selected and is shifted to the left by 3: [\color{blue}{2, 4, 5, 1, 3}] \longrightarrow [\color{blue}{1, 3, 2, 4, 5}] 
  3. After that the segment a[1 … 2] is selected and is shifted to the left by 1: [\color{blue}{1, 3}, 2, 4, 5] \longrightarrow [\color{blue}{3, 1}, 2, 4, 5] 
  4. And in the end the segment a[1 … 3] is selected and is shifted to the left by 1: [\color{blue}{3, 1, 2}, 4, 5] \longrightarrow [\color{blue}{1, 2, 3}, 4, 5] 
import java.io.*;
import java.util.Arrays;
import java.util.*;
import java.util.Scanner;
import java.util.StringTokenizer;



public class copy{


    public static boolean checker(long[] arr,long K,long diff)
    {
        long collect=0;
        for(int i=0;i<arr.length;i++)
        {
            if(arr[i]>diff)
                collect+=arr[i]-diff;
        }

        if(collect>=K)
            return true;
        else
            return false;
    }
    public static long search(long[] arr,long K,long R)
    {
        long l=0;
        long r=R;

        while(l<=r)
        {
            long mid=(l+r)/2;

            if(checker(arr,K,mid))
            {
                if(checker(arr,K,mid+1))
                    l=mid+1;
                else
                    return mid;
            }
            else
                r=mid-1;
        }
        return -1;
    }

    static void sieveOfEratosthenes(int n,ArrayList<Integer> arr,ArrayList<Integer> arr1)
    {
        // Create a boolean array
        // "prime[0..n]" and
        // initialize all entries
        // it as true. A value in
        // prime[i] will finally be
        // false if i is Not a
        // prime, else true.
        boolean prime[] = new boolean[n + 1];
        for (int i = 0; i <= n; i++)
            prime[i] = true;

        for (int p = 2; p * p <= n; p++)
        {
            // If prime[p] is not changed, then it is a
            // prime
            if (prime[p] == true)
            {

                // Update all multiples of p
                for (int i = p * p; i <= n; i += p)
                    prime[i] = false;
            }
        }

        // Print all prime numbers
        int x=0;
        for (int i = 2; i <= n; i++)
        {
            if (prime[i] == true)
            {

                arr.add(i);


            }

        }
        System.out.println(arr.size());
    }

    public static boolean check(String s,int K,char ch)
    {
        ArrayList<Integer> arr=new ArrayList<>();
        for(int i=0;i<s.length();i++)
        {
            if(s.charAt(i)==ch)
                arr.add(i);
        }
//        if(K==1 && ch=='z')
//            System.out.println(arr);
        if(arr.size()==0)
            return false;
        if(arr.get(0)>=K)
            return false;
        if(s.length()-1-arr.get(arr.size()-1)>=K)
            return false;
        for(int i=1;i<arr.size();i++)
        {
            if(arr.get(i)-arr.get(i-1)>K)
                return false;
        }
        return true;
    }

    public static int check(long N)
    {
        int sum=0;
        while(N>0)
        {
            sum+=N%10;
            N=N/10;
        }
        return sum;

    }

    public static long call(long N)
    {
        long l=1;
        long r=(long)Math.floor(Math.sqrt(N));
        while(l<=r)
        {
            long mid=(l+r)/2;
            double left=N/(double)(mid)-mid;
            int right=check(mid);
            System.out.println(mid+" "+left+" "+right);
            if(mid==10)
                System.out.println(left+" "+right);
            if(left>right)
                l=mid+1;
            else if(right>left)
                r=mid-1;
            else
                return mid;
        }
        return -1;
    }

    public static int path(ArrayList<ArrayList<Integer>> arr,int X,int parent,int[] gold,PriorityQueue<Integer> pq)
    {
        int max=0;
        ArrayList<Integer> ch=new ArrayList<>();
        for(int i:arr.get(X))
        {
            if(i!=parent)
            {
                ch.add(path(arr,i,X,gold,pq));
            }
        }
        Collections.sort(ch,Collections.reverseOrder());
        for(int i=1;i<ch.size();i++)
            pq.add(ch.get(i));


        if(ch.size()==0)
        return gold[X];
        else
            return ch.get(0)+gold[X];

    }

    public static long fac(long N,long mod)
    {
        if(N==0)
            return 1;
        return ((N%mod)*(fac(N-1,mod)%mod))%mod;
    }

    public static String form(char ch,int freq)
    {
        String s="";
        for(int i=1;i<=freq;i++)
            s+=ch;
        return s;
    }

    static long power(long x, long y, long p)
    {

        // Initialize result
        long res = 1;

        // Update x if it is more than or
        // equal to p
        x = x % p;

        while (y > 0) {

            // If y is odd, multiply x
            // with result
            if (y % 2 == 1)
                res = (res * x) % p;

            // y must be even now
            y = y >> 1; // y = y/2
            x = (x * x) % p;
        }

        return res;
    }

    // Returns n^(-1) mod p
    static long modInverse(long n, long p)
    {
        return power(n, p - 2, p);
    }

    // Returns nCr % p using Fermat's
    // little theorem.
    static long nCrModPFermat(long n, long r,
                             long p)
    {

        if (n<r)
            return 0;
        // Base case
        if (r == 0)
            return 1;

        // Fill factorial array so that we
        // can find all factorial of r, n
        // and n-r



//        System.out.println(modInverse(fac(r,p),p));
//        System.out.println(modInverse(fac(n-r,p),p));
        return ((fac(n,p)%p * (modInverse(fac(r,p), p)
                % p))%p *( modInverse(fac(n-r,p), p)
                % p)) % p;
    }

    public static boolean check(long[] arr, long time, int M)
    {
        long sum=0;
        int count=0;
        for(int i=0;i<arr.length;i++)
        {
            sum+=arr[i];
            if(sum>=time)
            {
                ++count;
                sum=0;
            }
        }

        if(sum>=time)
            ++count;

        return count>=M;
    }

    public static int check(ArrayList<Integer> arr,ArrayList<Integer> arr2)
    {
        int l=0,r=0,ans=0;
        while(l<arr.size() && r<arr2.size())
        {
            if(arr.get(l)<arr2.get(r))
                ++l;
            else if(arr.get(l)>arr2.get(r))
                ++r;
            else
            {
                ++ans;
                ++l;
                ++r;
            }
        }
        return ans;
    }


    public static int find(int[] parent,int x)
    {
        if(parent[x]==x)
            return x;
        return find(parent,parent[x]);
    }

    public static void merge(int[] parent, int[] rank,int x,int y)
    {
        int x1=find(parent,x);
        int y1=find(parent,y);
        if(rank[x1]>rank[y1])
        {
            parent[y1]=x1;

        }
        else if(rank[y1]>rank[x1])
        {
            parent[x1]=y1;
        }
        else
        {
            parent[y1]=x1;
            rank[x1]++;
        }
    }

    public static int check(ArrayList<ArrayList<Integer>> arr,int e1,int e2,int N)
    {
        boolean[] visited=new boolean[N];
        visited[0]=true;
        int[] dist=new int[N];
        Queue<Integer> queue=new LinkedList<>();
        queue.add(0);
        Arrays.fill(dist,-1);
        dist[0]=0;
        while(queue.size()>0)
        {
            int x=queue.poll();
            for(int i:arr.get(x))
            {
                if(!visited[i] || (e1==x && e2==i))
                {
                    System.out.println(x+" "+dist[x]);
                    dist[i]=dist[x]+1;
                    visited[i]=true;
                    queue.add(i);
                }
            }

        }


        return dist[N-1];
    }

    static int N;

    static void rotate90Clockwise(String a[][])
    {

        // Traverse each cycle
        for (int i = 0; i < N / 2; i++)
        {
            for (int j = i; j < N - i - 1; j++)
            {

                // Swap elements of each cycle
                // in clockwise direction
                String temp = a[i][j];
                a[i][j] = a[N - 1 - j][i];
                a[N - 1 - j][i] = a[N - 1 - i][N - 1 - j];
                a[N - 1 - i][N - 1 - j] = a[j][N - 1 - i];
                a[j][N - 1 - i] = temp;
            }
        }
    }


    public static void moves(String s,int i,int[] movx,int[] movy,int x,int y)
    {
        if(i>=s.length())
            return;
        //System.out.println(x+" hello "+y);
        if(s.charAt(i)=='L')
        {
            movy[i]=y;
            movx[i]=x-1;
            moves(s,i+1,movx,movy,x-1,y);
        }
        else if(s.charAt(i)=='R')
        {
            movy[i]=y;
            movx[i]=x+1;
            moves(s,i+1,movx,movy,x+1,y);
        }
        else if(s.charAt(i)=='U')
        {
            movy[i]=y+1;
            movx[i]=x;
            moves(s,i+1,movx,movy,x,y+1);
        }
        else
        {
            movy[i]=y-1;
            movx[i]=x;
            moves(s,i+1,movx,movy,x,y-1);
        }

    }


    public static boolean check(String s,int i,int x,int y,int obsx,int obsy)
    {
        if(i>=s.length())
        {
            if(x==0 && y==0)
                return true;
            return false;
        }
        boolean status1=false,status2=false,status3=false,status4=false;
        //System.out.println(x+" "+y+" "+obsx+" "+obsy+" "+s.charAt(i));
        if(s.charAt(i)=='L')
        {
            if(x-1==obsx && y==obsy)
                status1=check(s,i+1,x,y,obsx,obsy);
            else
                status1=check(s,i+1,x-1,y,obsx,obsy);
            //moves(s,i+1,movx,movy,x-1,y);
        }
        else if(s.charAt(i)=='R')
        {
            if(x+1==obsx && y==obsy)
                status2=check(s,i+1,x,y,obsx,obsy);
            else
                status2=check(s,i+1,x+1,y,obsx,obsy);
            //moves(s,i+1,movx,movy,x+1,y);
        }
        else if(s.charAt(i)=='U')
        {
            if(y+1==obsy && x==obsx)
                status3=check(s,i+1,x,y,obsx,obsy);
            else
                status3= check(s,i+1,x,y+1,obsx,obsy);
            //moves(s,i+1,movx,movy,x,y-1);
        }
        else
        {
            if(y-1==obsy && x==obsx)
                status4= check(s,i+1,x,y,obsx,obsy);
            else
                status4=check(s,i+1,x,y-1,obsx,obsy);
        }
        return status1 || status2 || status3 || status4;
    }

    public static int mergeAndCount1(int[] arr, int l,
                                     int m, int r)
    {

        // Left subarray
        int[] left = Arrays.copyOfRange(arr, l, m + 1);

        // Right subarray
        int[] right = Arrays.copyOfRange(arr, m + 1, r + 1);

        int i = 0, j = 0, k = l, swaps = 0;

        while (i < left.length && j < right.length) {
            if (left[i] <= right[j])
                arr[k++] = left[i++];
            else {
                arr[k++] = right[j++];
                swaps += (m + 1) - (l + i);
            }
        }
        while (i < left.length)
            arr[k++] = left[i++];
        while (j < right.length)
            arr[k++] = right[j++];
        return swaps;
    }

    // Merge sort function
    public static int mergeSortAndCount(int[] arr, int l,
                                         int r) {

        // Keeps track of the inversion count at a
        // particular node of the recursion tree
        int count = 0;

        if (l < r) {
            int m = (l + r) / 2;

            // Total inversion count = left subarray count
            // + right subarray count + merge count

            // Left subarray count
            count += mergeSortAndCount(arr, l, m);

            // Right subarray count
            count += mergeSortAndCount(arr, m + 1, r);

            // Merge count
            count += mergeAndCount1(arr, l, m, r);
        }

        return count;
    }


    public static boolean checker(String s1,String s2,int[] arr,int mid)
    {
        String s="";
        int N=s1.length();
        boolean[] visited=new boolean[N];
        for(int i=0;i<=mid;i++)
            visited[arr[i]-1]=true;
        for(int i=0;i<N;i++)
        {
            if(!visited[i])
                s+=s1.charAt(i);
        }

        int l=0,index=-1;
        while(l<s2.length())
        {
            if(s.indexOf(s2.charAt(l),index+1)==-1)
                return false;
            else
            {
                index=s.indexOf(s2.charAt(l),index+1);
                ++l;
            }
        }

        return true;
    }

    public static int check(ArrayList<Integer> possible,int X,int start)
    {
        int l=start,r=possible.size()-1;

        while(l<=r)
        {
            int mid=(l+r)/2;
            if(possible.get(mid)>X)
            {
                if(mid-1>=start && possible.get(mid-1)>X)
                    r=mid-1;
                else
                    return mid;
            }
            else
                l=mid+1;
        }

        return -1;
    }


    public static int binse(ArrayList<Integer> arr,int start,int X,int N)
    {
        int l=start,r=N-1;
        while(l<=r)
        {
            int mid=(l+r)/2;
            if(arr.get(mid)-arr.get(start)<=X)
            {
                if(mid+1<N && arr.get(mid+1)-arr.get(start)<=X)
                {
                    l=mid+1;
                }
                else
                    return mid;
            }
            else
                r=mid-1;
        }
        return -1;
    }


    public static long dp(long[][] dp,int X,int[] arr,int index,long mod)
    {
        //System.out.println(index+" "+X);
        if(dp[index][X]!=-1)
            return dp[index][X];
        int index1=index+1;
        int plus=(X-arr[index1]+10)%10;
        long ans=dp(dp,plus,arr,index-1,mod)%mod;
        for(int i=0;i<10;i++)
        {
            if((arr[index1]*i)%10==X)
            ans=(ans%mod+dp(dp,i,arr,index-1,mod)%mod)%mod;
        }

        dp[index][X]=ans;
        return ans;


    }

    public static long gcd(long a,long b)
    {
        if(b==0)
            return a;

        return gcd(b,a%b);
    }

    public static int check(int x,ArrayList<ArrayList<Integer>> arr,int parent, int dist,long[] ans,int[] child)
    {
        ans[0]+=dist;
        int c=0;
        for(int i:arr.get(x))
        {
            if(i!=parent)
                c+=check(i,arr,x,dist+1,ans,child);
        }

        child[x]=c+1;
        return c+1;
    }

    public static void check(int x,int parent,ArrayList<ArrayList<Integer>> arr,int[] child,long[] ans)
    {
        ans[x]=ans[parent]-(child[x])+(arr.size()-child[x]);

        for(int i:arr.get(x))
        {
            if(i!=parent)
            {
                check(i,x,arr,child,ans);
            }
        }
    }

    public static void leftRotatebyOne(int arr[], int n)
    {
        int i, temp;
        temp = arr[0];
        for (i = 0; i < n - 1; i++)
            arr[i] = arr[i + 1];
        arr[n-1] = temp;
    }








    public static void main(String[] args)throws IOException {
        Reader.init(System.in);
        BufferedWriter output=new BufferedWriter(new OutputStreamWriter(System.out));


            int T=Reader.nextInt();
            for(int m=1;m<=T;m++)
            {
                int N=Reader.nextInt();
                int[] arr=new int[N];
                for(int i=0;i<N;i++)
                    arr[i]=Reader.nextInt();
                int c=0;
                ArrayList<ArrayList<Integer>> ans=new ArrayList<>();
                for(int i=0;i<N;i++)
                {
                    int max=Integer.MIN_VALUE;
                    int index=-1;
                    for(int j=0;j<N-i;j++)
                    {
                        if(arr[j]>max)
                        {
                            max=arr[j];
                            index=j;
                        }
                    }

                    int k=index+1;
                    if(index==N-i-1)
                        continue;
                    ArrayList<Integer> temp=new ArrayList<>();
                    temp.add(1);
                    temp.add(N-i);
                    temp.add(k);
                    ans.add(temp);
                    ++c;

                    for(int j=0;j<k;j++)
                        leftRotatebyOne(arr,N-i);

                }

                output.write(c+"\n");
                for(ArrayList<Integer> temp:ans)
                    output.write(temp.get(0)+" "+temp.get(1)+" "+temp.get(2)+"\n");

            }







        output.flush();


    }








}



class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    static void init(InputStream input) {
        reader = new BufferedReader(
                new InputStreamReader(input));
        tokenizer = new StringTokenizer("");
    }

    static String next() throws IOException {
        while (!tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(
                    reader.readLine());
        }
        return tokenizer.nextToken();
    }

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

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

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


