description: 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] 
solution: import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;
  import java.io.IOException;import java.io.InputStream;import java.io.PrintWriter;
  import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;
  import java.lang.reflect.Array;import java.lang.reflect.Field;import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;import java.security.AccessControlException;import java.util.*;
  import java.util.Arrays;import java.util.Collection;import java.util.Comparator;
  import java.util.List;import java.util.Map;import java.util.Objects;import java.util.TreeMap;
  import java.util.function.Function;import java.util.stream.Collectors;import java.util.stream.IntStream;
  import java.util.stream.LongStream;import java.util.stream.Stream;public class _B {
  static public void main(final String[] args) throws IOException{B._main(args);}
  
  static class B extends Solver{public B(){}@Override public void solve()throws IOException
  {int n=sc.nextInt();sc.nextLine();int[]a=Arrays.stream(sc.nextLine().trim().split("\\s+")).filter($s2
  ->!$s2.isEmpty()).mapToInt(Integer::parseInt).toArray();TreeSet<int[]>set=new TreeSet<>((x,
  y)->x[0]!=y[0]?x[0]-y[0]:x[1]-y[1]);PriorityQueue<int[]>pq=new PriorityQueue<>(Comparator.comparingInt(x
  ->x[1]));List<int[]>listi=Datas.listi(a);set.addAll(listi);pq.addAll(listi);ArrayList<int[]>
  res=new ArrayList<>();ArrayList<int[]>cache=new ArrayList<>();while(!set.isEmpty())
  {int[]it=set.first();int[]it1=pq.peek();if(it[1]!=it1[1]){int r=it[1];int l=it1[1];
  int d=r-l;res.add(new int[]{l+1,r+1,d});cache.clear();while(true){it1=pq.poll();
  set.remove(it1);boolean last=it1[1]==r;if(last){it1[1]=l;}else{it1[1]++;}cache.add(it1);
  if(last){break;}}pq.addAll(cache);set.addAll(cache);}set.pollFirst();pq.poll();}
  pw.println(res.size());res.forEach(v->pw.println(Datas.join(v)));}static public void _main(String[]
  args)throws IOException{new B().run();}}static class Datas{final static String SPACE
  =" ";public static TreeMap<Integer,Integer>mapc(final int[]a){return IntStream.range(0,
  a.length).collect(()->new TreeMap<Integer,Integer>(),(res,i)->{res.put(a[i],res.getOrDefault(a[i],
  0)+1);},Map::putAll);}public static TreeMap<Long,Integer>mapc(final long[]a){return 
  IntStream.range(0,a.length).collect(()->new TreeMap<Long,Integer>(),(res,i)->{res.put(a[i],
  res.getOrDefault(a[i],0)+1);},Map::putAll);}public static<T>TreeMap<T,Integer>mapc(final 
  T[]a,Comparator<T>cmp){return IntStream.range(0,a.length).collect(cmp!=null?()->
  new TreeMap<T,Integer>(cmp):()->new TreeMap<T,Integer>(),(res,i)->{res.put(a[i],
  res.getOrDefault(a[i],0)+1);},Map::putAll);}public static<T>TreeMap<T,Integer>mapc(final 
  T[]a){return mapc(a,null);}public static TreeMap<Integer,Integer>mapc(final IntStream 
  a){return a.collect(()->new TreeMap<Integer,Integer>(),(res,v)->{res.put(v,res.getOrDefault(v,
  0)+1);},Map::putAll);}public static TreeMap<Long,Integer>mapc(final LongStream a)
  {return a.collect(()->new TreeMap<Long,Integer>(),(res,v)->{res.put(v,res.getOrDefault(v,
  0)+1);},Map::putAll);}public static<T>TreeMap<T,Integer>mapc(final Stream<T>a,Comparator<T>
  cmp){return a.collect(cmp!=null?()->new TreeMap<T,Integer>(cmp):()->new TreeMap<T,
  Integer>(),(res,v)->{res.put(v,res.getOrDefault(v,0)+1);},Map::putAll);}public static
  <T>TreeMap<T,Integer>mapc(final Stream<T>a){return mapc(a,null);}public static<T>
  TreeMap<T,Integer>mapc(final Collection<T>a,Comparator<T>cmp){return mapc(a.stream(),
  cmp);}public static<T>TreeMap<T,Integer>mapc(final Collection<T>a){return mapc(a.stream());
  }public static TreeMap<Integer,List<Integer>>mapi(final int[]a){return IntStream.range(0,
  a.length).collect(()->new TreeMap<Integer,List<Integer>>(),(res,i)->{if(!res.containsKey(a[i]))
  {res.put(a[i],Stream.of(i).collect(Collectors.toList()));}else{res.get(a[i]).add(i);
  }},Map::putAll);}public static TreeMap<Long,List<Integer>>mapi(final long[]a){return 
  IntStream.range(0,a.length).collect(()->new TreeMap<Long,List<Integer>>(),(res,i)
  ->{if(!res.containsKey(a[i])){res.put(a[i],Stream.of(i).collect(Collectors.toList()));
  }else{res.get(a[i]).add(i);}},Map::putAll);}public static<T>TreeMap<T,List<Integer>>
  mapi(final T[]a,Comparator<T>cmp){return IntStream.range(0,a.length).collect(cmp
  !=null?()->new TreeMap<T,List<Integer>>(cmp):()->new TreeMap<T,List<Integer>>(),
  (res,i)->{if(!res.containsKey(a[i])){res.put(a[i],Stream.of(i).collect(Collectors.toList()));
  }else{res.get(a[i]).add(i);}},Map::putAll);}public static<T>TreeMap<T,List<Integer>>
  mapi(final T[]a){return mapi(a,null);}public static TreeMap<Integer,List<Integer>>
  mapi(final IntStream a){int[]i=new int[]{0};return a.collect(()->new TreeMap<Integer,
  List<Integer>>(),(res,v)->{if(!res.containsKey(v)){res.put(v,Stream.of(i[0]).collect(Collectors.toList()));
  }else{res.get(v).add(i[0]);}i[0]++;},Map::putAll);}public static TreeMap<Long,List<Integer>>
  mapi(final LongStream a){int[]i=new int[]{0};return a.collect(()->new TreeMap<Long,
  List<Integer>>(),(res,v)->{if(!res.containsKey(v)){res.put(v,Stream.of(i[0]).collect(Collectors.toList()));
  }else{res.get(v).add(i[0]);}i[0]++;},Map::putAll);}public static<T>TreeMap<T,List<Integer>>
  mapi(final Stream<T>a,Comparator<T>cmp){int[]i=new int[]{0};return a.collect(cmp
  !=null?()->new TreeMap<T,List<Integer>>(cmp):()->new TreeMap<T,List<Integer>>(),
  (res,v)->{if(!res.containsKey(v)){res.put(v,Stream.of(i[0]).collect(Collectors.toList()));
  }else{res.get(v).add(i[0]);}i[0]++;},Map::putAll);}public static<T>TreeMap<T,List<Integer>>
  mapi(final Stream<T>a){return mapi(a,null);}public static<T>TreeMap<T,List<Integer>>
  mapi(final Collection<T>a,Comparator<T>cmp){return mapi(a.stream(),cmp);}public 
  static<T>TreeMap<T,List<Integer>>mapi(final Collection<T>a){return mapi(a.stream());
  }public static List<int[]>listi(final int[]a){return IntStream.range(0,a.length).mapToObj(i
  ->new int[]{a[i],i}).collect(Collectors.toList());}public static List<long[]>listi(final 
  long[]a){return IntStream.range(0,a.length).mapToObj(i->new long[]{a[i],i}).collect(Collectors.toList());
  }public static<T>List<Pair<T,Integer>>listi(final T[]a){return IntStream.range(0,
  a.length).mapToObj(i->new Pair<T,Integer>(a[i],i)).collect(Collectors.toList());
  }public static List<int[]>listi(final IntStream a){int[]i=new int[]{0};return a.mapToObj(v
  ->new int[]{v,i[0]++}).collect(Collectors.toList());}public static List<long[]>listi(final 
  LongStream a){int[]i=new int[]{0};return a.mapToObj(v->new long[]{v,i[0]++}).collect(Collectors.toList());
  }public static<T>List<Pair<T,Integer>>listi(final Stream<T>a){int[]i=new int[]{0};
  return a.map(v->new Pair<T,Integer>(v,i[0]++)).collect(Collectors.toList());}public 
  static<T>List<Pair<T,Integer>>listi(final Collection<T>a){int[]i=new int[]{0};return 
  a.stream().map(v->new Pair<T,Integer>(v,i[0]++)).collect(Collectors.toList());}public 
  static String join(final int[]a){return Arrays.stream(a).mapToObj(Integer::toString).collect(Collectors.joining(SPACE));
  }public static String join(final long[]a){return Arrays.stream(a).mapToObj(Long::toString).collect(Collectors.joining(SPACE));
  }public static<T>String join(final T[]a){return Arrays.stream(a).map(v->Objects.toString(v)).collect(Collectors.joining(SPACE));
  }public static<T>String join(final T[]a,final Function<T,String>toString){return 
  Arrays.stream(a).map(v->toString.apply(v)).collect(Collectors.joining(SPACE));}public 
  static<T>String join(final Collection<T>a){return a.stream().map(v->Objects.toString(v)).collect(Collectors.joining(SPACE));
  }public static<T>String join(final Collection<T>a,final Function<T,String>toString)
  {return a.stream().map(v->toString.apply(v)).collect(Collectors.joining(SPACE));
  }public static<T>String join(final Stream<T>a){return a.map(v->Objects.toString(v)).collect(Collectors.joining(SPACE));
  }public static<T>String join(final Stream<T>a,final Function<T,String>toString){
  return a.map(v->toString.apply(v)).collect(Collectors.joining(SPACE));}public static
  <T>String join(final IntStream a){return a.mapToObj(Integer::toString).collect(Collectors.joining(SPACE));
  }public static<T>String join(final LongStream a){return a.mapToObj(Long::toString).collect(Collectors.joining(SPACE));
  }public static List<Integer>list(final int[]a){return Arrays.stream(a).mapToObj(Integer::valueOf).collect(Collectors.toList());
  }public static List<Integer>list(final IntStream a){return a.mapToObj(Integer::valueOf).collect(Collectors.toList());
  }public static List<Long>list(final long[]a){return Arrays.stream(a).mapToObj(Long::valueOf).collect(Collectors.toList());
  }public static List<Long>list(final LongStream a){return a.mapToObj(Long::valueOf).collect(Collectors.toList());
  }public static<T>List<T>list(final Stream<T>a){return a.collect(Collectors.toList());
  }public static<T>List<T>list(final Collection<T>a){return a.stream().collect(Collectors.toList());
  }public static<T>List<T>list(final T[]a){return Arrays.stream(a).collect(Collectors.toList());
  }public static String yesNo(final boolean res){return res?"YES":"NO";}public static 
  String dump(Object obj){String res="";if(obj!=null){Class cl=obj.getClass();String 
  cls=cl.getName();if(cls.startsWith("[")){res+="[";for(int i=0;;i++){try{Object o
  =Array.get(obj,i);String s=dump(o);if(i>0){res+=", ";}res+=s;}catch(ArrayIndexOutOfBoundsException 
  ex){break;}}res+="]";}else if(Collection.class.isAssignableFrom(cl)){@SuppressWarnings("unchecked")final 
  Object s=((Collection)obj).stream().map(v->dump(v)).collect(Collectors.joining(", ",
  "[","]"));res+=s.toString();}else if(Map.class.isAssignableFrom(cl)){@SuppressWarnings("unchecked")final 
  Object s=((Map)obj).entrySet().stream().map(v->dump(v)).collect(Collectors.joining(", ",
  "{","}"));res+=s.toString();}else if(Character.class.isInstance(obj)|| Integer.class.isInstance(obj)
  || Long.class.isInstance(obj)|| Float.class.isInstance(obj)|| Double.class.isInstance(obj)|| String.class.isInstance(obj)
  ){res+=Objects.toString(obj);}else if(Map.Entry.class.isInstance(obj)){res+=dump(((Map.Entry)obj).getKey())
  +"="+dump(((Map.Entry)obj).getValue());}else if(Stream.class.isInstance(obj)){@SuppressWarnings("unchecked")
  final Object s=((Stream)obj).map(v->dump(v)).collect(Collectors.joining(", ","[",
  "]"));res+=s.toString();}else{res+=Stream.concat(Arrays.stream(obj.getClass().getFields()).map(v
  ->{String name=v.getName();String val;try{Object o=v.get(obj);if(o!=null && v.isAnnotationPresent(Dump.class))
  {Dump an=v.getAnnotation(Dump.class);Class ocl=o.getClass();val="{";for(String fn:an.fields())
  {try{Field f=ocl.getField(fn);val+=fn+"="+dump(f.get(o))+", ";}catch(NoSuchFieldException 
  nsfex){try{@SuppressWarnings("unchecked")final Method m=ocl.getMethod(fn);val+=fn+"="+dump(m.invoke(o))
  +", ";}catch(NoSuchMethodException | IllegalArgumentException | InvocationTargetException 
  nsmex){}}}if(val.endsWith(", ")){val=val.substring(0,val.length()-2);}val+="}";}
  else{val=dump(o);}}catch(IllegalAccessException ex){val="N/A";}return name+"="+val;
  }),Arrays.stream(obj.getClass().getMethods()).filter(m->m.isAnnotationPresent(Getter.class)).map(m
  ->{String name=m.getName();String val;try{Object o=m.invoke(obj);if(o!=null && m.isAnnotationPresent(Dump.class))
  {Dump an=m.getAnnotation(Dump.class);Class ocl=o.getClass();val="{";for(String fn:an.fields())
  {try{Field f=ocl.getField(fn);val+=fn+"="+dump(f.get(o))+", ";}catch(NoSuchFieldException 
  nsfex){try{@SuppressWarnings("unchecked")final Method m1=ocl.getMethod(fn);val+=fn+"="+dump(m1.invoke(o))
  +", ";}catch(NoSuchMethodException | IllegalArgumentException | InvocationTargetException 
  nsmex){}}}if(val.endsWith(", ")){val=val.substring(0,val.length()-2);}val+="}";}else
  {val=dump(o);}}catch(IllegalAccessException | InvocationTargetException ex){val=
  "N/A";}return name+"="+val;})).collect(Collectors.joining(", ","{"+obj.getClass().getName()
  +": ","}"));}}if(res.length()==0){res="<null>";}return res;}}@Retention(RetentionPolicy.RUNTIME)
  public @interface Dump{String[]fields();}@Retention(RetentionPolicy.RUNTIME)public @interface Getter{}static class 
  Pair<K,V>{private K k;private V v;public Pair(final K t,final V u){this.k=t;this.v
  =u;}public K getKey(){return k;}public V getValue(){return v;}public void setKey(K 
  t){k=t;}public void setValue(V t){v=t;}}static class MyScanner{private StringBuilder 
  cache=new StringBuilder();int cache_pos=0;private int first_linebreak=-1;private 
  int second_linebreak=-1;private StringBuilder sb=new StringBuilder();private InputStream 
  is=null;public MyScanner(final InputStream is){this.is=is;}public String charToString(final 
  int c){return String.format("'%s'",c=='\n'?"\\n":(c=='\r'?"\\r":String.valueOf((char)c)));
  }public int get(){int res=-1;if(cache_pos<cache.length()){res=cache.charAt(cache_pos);
  cache_pos++;if(cache_pos==cache.length()){cache.delete(0,cache_pos);cache_pos=0;
  }}else{try{res=is.read();}catch(IOException ex){throw new RuntimeException(ex);}
  }return res;}private void unget(final int c){if(cache_pos==0){cache.insert(0,(char)c);
  }else{cache_pos--;}}public String nextLine(){sb.delete(0,sb.length());int c;boolean 
  done=false;boolean end=false;while((c=get())!=-1){if(check_linebreak(c)){done=true;
  if(c==first_linebreak){if(!end){end=true;}else{cache.append((char)c);break;}}else 
  if(second_linebreak!=-1 && c==second_linebreak){break;}}if(end && c!=first_linebreak 
  && c!=second_linebreak){cache.append((char)c);break;}if(!done){sb.append((char)c);
  }}return!done && sb.length()==0?null:sb.toString();}private boolean check_linebreak(int 
  c){if(c=='\n'|| c=='\r'){if(first_linebreak==-1){first_linebreak=c;}else if(c!=first_linebreak 
  && second_linebreak==-1){second_linebreak=c;}return true;}return false;}public int 
  nextInt(){return Integer.parseInt(next());}public long nextLong(){return Long.parseLong(next());
  }public boolean hasNext(){boolean res=false;int c;while((c=get())!=-1){if(!check_linebreak(c)
  && c!=' '&& c!='\t'){res=true;unget(c);break;}}return res;}public String next(){
  sb.delete(0,sb.length());boolean started=false;int c;while((c=get())!=-1){if(check_linebreak(c)
  || c==' '|| c=='\t'){if(started){unget(c);break;}}else{started=true;sb.append((char)c);
  }}return sb.toString();}public int nextChar(){return get();}public boolean eof()
  {int c=get();boolean res=false;if(c!=-1){unget(c);}else{res=true;}return res;}public 
  double nextDouble(){return Double.parseDouble(next());}}static abstract class Solver
  {protected String nameIn=null;protected String nameOut=null;protected boolean singleTest
  =false;protected MyScanner sc=null;protected PrintWriter pw=null;private int current_test
  =0;private int count_tests=0;protected int currentTest(){return current_test;}protected 
  int countTests(){return count_tests;}private void process()throws IOException{if(!singleTest)
  {count_tests=sc.nextInt();sc.nextLine();for(current_test=1;current_test<=count_tests;
  current_test++){solve();pw.flush();}}else{count_tests=1;current_test=1;solve();}
  }abstract protected void solve()throws IOException;public void run()throws IOException
  {boolean done=false;try{if(nameIn!=null){if(new File(nameIn).exists()){try(FileInputStream 
  fis=new FileInputStream(nameIn);PrintWriter pw0=select_output();){select_output();
  done=true;sc=new MyScanner(fis);pw=pw0;process();}}else{throw new RuntimeException("File "
  +new File(nameIn).getAbsolutePath()+" does not exist!");}}}catch(IOException | AccessControlException 
  ex){}if(!done){try(PrintWriter pw0=select_output();){sc=new MyScanner(System.in);
  pw=pw0;process();}}}private PrintWriter select_output()throws FileNotFoundException
  {if(nameOut!=null){return new PrintWriter(nameOut);}return new PrintWriter(System.out);
  }}static abstract class Tester{static public int getRandomInt(final int min,final 
  int max){return(min+(int)Math.floor(Math.random()*(max-min+1)));}static public long 
  getRandomLong(final long min,final long max){return(min+(long)Math.floor(Math.random()
  *(max-min+1)));}static public double getRandomDouble(final double min,final double 
  maxExclusive){return(min+Math.random()*(maxExclusive-min));}abstract protected void 
  testOutput(final List<String>output_data);abstract protected void generateInput();
  abstract protected String inputDataToString();private boolean break_tester=false;
  protected void beforeTesting(){}protected void breakTester(){break_tester=true;}
  public boolean broken(){return break_tester;}}}
  