description: An identity permutation of length n is an array [1, 2, 3, ..., n].
  
  We performed the following operations to an identity permutation of length n:
  
    * firstly, we cyclically shifted it to the right by k positions, where k is unknown to you (the only thing you know is that 0 ≤ k ≤ n - 1). When an array is cyclically shifted to the right by k positions, the resulting array is formed by taking k last elements of the original array (without changing their relative order), and then appending n - k first elements to the right of them (without changing relative order of the first n - k elements as well). For example, if we cyclically shift the identity permutation of length 6 by 2 positions, we get the array [5, 6, 1, 2, 3, 4]; 
    * secondly, we performed the following operation at most m times: pick any two elements of the array and swap them. 
  
  
  
  You are given the values of n and m, and the resulting array. Your task is to find all possible values of k in the cyclic shift operation.
  
  Input
  
  The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases.
  
  Each test case consists of two lines. The first line contains two integers n and m (3 ≤ n ≤ 3 ⋅ 10^5; 0 ≤ m ≤ n/3).
  
  The second line contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, each integer from 1 to n appears in this sequence exactly once) — the resulting array.
  
  The sum of n over all test cases does not exceed 3 ⋅ 10^5.
  
  Output
  
  For each test case, print the answer in the following way:
  
    * firstly, print one integer r (0 ≤ r ≤ n) — the number of possible values of k for the cyclic shift operation; 
    * secondly, print r integers k_1, k_2, ..., k_r (0 ≤ k_i ≤ n - 1) — all possible values of k in increasing order. 
  
  Example
  
  Input
  
  
  4
  4 1
  2 3 1 4
  3 1
  1 2 3
  3 1
  3 2 1
  6 0
  1 2 3 4 6 5
  
  
  Output
  
  
  1 3
  1 0
  3 0 1 2
  0
  
  Note
  
  Consider the example: 
  
    * in the first test case, the only possible value for the cyclic shift is 3. If we shift [1, 2, 3, 4] by 3 positions, we get [2, 3, 4, 1]. Then we can swap the 3-rd and the 4-th elements to get the array [2, 3, 1, 4]; 
    * in the second test case, the only possible value for the cyclic shift is 0. If we shift [1, 2, 3] by 0 positions, we get [1, 2, 3]. Then we don't change the array at all (we stated that we made at most 1 swap), so the resulting array stays [1, 2, 3]; 
    * in the third test case, all values from 0 to 2 are possible for the cyclic shift: 
      * if we shift [1, 2, 3] by 0 positions, we get [1, 2, 3]. Then we can swap the 1-st and the 3-rd elements to get [3, 2, 1]; 
      * if we shift [1, 2, 3] by 1 position, we get [3, 1, 2]. Then we can swap the 2-nd and the 3-rd elements to get [3, 2, 1]; 
      * if we shift [1, 2, 3] by 2 positions, we get [2, 3, 1]. Then we can swap the 1-st and the 2-nd elements to get [3, 2, 1]; 
    * in the fourth test case, we stated that we didn't do any swaps after the cyclic shift, but no value of cyclic shift could produce the array [1, 2, 3, 4, 6, 5]. 
solution: import java.util.*;
  import java.io.*;
  public class Sol{
   
  /*   
  ->n=1 important test case
  ->Dont get stuck on one approach try all possibilities
  ->check int overflow,array bounds,etc
  ->Dont think just idea think of its (correct) implementation completely (then only code)
  ->No concept of tutorial exists(solve or leave it)
  ->If you get stuck on problem (hint:check constraints e.g m<=n/3 or k<=min(100,n))
  */
   
  public static void main(String []args){
  //precomp();
  int times=ni();while(times-->0){solve();}out.close();}
  
  static void solve(){  
       int n=ni();int m=ni();
       int p[]=new int[n+1];int count[]=new int[n+1];
       for(int i=1;i<=n;i++){p[i]=ni();int k=0;
           if(p[i]<=i){k=i-p[i];}
           else{k=n+i-p[i];}count[k]++;
      }
       //for(int i=0;i<n;i++){out.print(count[i]+" ");}out.println();
       ArrayList<Integer> al=new ArrayList<>();
       for(int i=0;i<n;i++){
          if(count[i]+2*m>=n ){if(check(n,m,p,i))al.add(i);}
       }     
       out.print(al.size()+" ");
       for(int x:al){out.print(x+" ");}out.println();
       return;
   }
  
  static boolean check(int n,int m, int []c,int k){
     int a[]=new int[2*n+1];
     for(int i=1;i<=n;i++){a[i]=c[i];a[n+i]=c[i];}
     //for(int i=1;i<=2*n;i++){out.print(a[i]+" ");}out.println();
     int p[]=new int[n+1];
     for(int i=k+1;i<=n+k;i++)p[i-k]=a[i];
     //out.println(k);
     //for(int i=1;i<=n;i++){out.print(p[i]+" ");}out.println();
     int inv[]=new int[n+1];
     for(int i=1;i<=n;i++)inv[p[i]]=i;
     int i=1;int ans=0;
     //for(int j=1;j<=n;j++){out.print(inv[j]+" ");}out.println();
     while(i<=n){
       if(inv[i]==i){i++;}
       else{
         p[inv[i]]=p[i];
         inv[p[i]]=inv[i];
         i++;ans++;}
       //out.println(i+" "+ans);
       //for(int j=1;j<=n;j++){out.print(inv[j]+" ");}out.println();
     }
     return ans<=m;
   }
        
  //-----------------Utility--------------------------------------------
  
  static int st[],lazy[];
  
  static void point_update(int i,int v){
      st[i]=v;int j=i/2;
      while(j>=1){
        st[j]=Math.min(st[2*j],st[2*j+1]);j/=2;
      }
   }
  static void prop(int i,int l,int r){
     if(l!=r)
     {lazy[2*i+1]+=lazy[i];lazy[2*i]+=lazy[i];}st[i]+=lazy[i];lazy[i]=0; 
   }
  
  static void update(int i,int l,int r,int L,int R,int v){
     prop(i,l,r);
     if(L>r || l>R)return;
     if(L<=l && R>=r){lazy[i]+=v;return;}
     int mid=(l+r)/2;
     update(2*i,l,mid,L,R,v);update(2*i+1,mid+1,r,L,R,v);
     //out.println(i+" "+l+" "+r+" "+L+" "+R);
     st[i]=Math.min(st[2*i]+lazy[2*i],st[2*i+1]+lazy[2*i+1]);
     
   }
  
  static long gcd(long a,long b){if(b==0)return a; return gcd(b,a%b);}
   
  static int Max=Integer.MAX_VALUE; static long mod=1000000007;
   
  static int v(char c){return (int)(c-'a');}
   
  public static long power(long x, long y )
      {
          //0^0 = 1
          long res = 1L;
          x = x%mod;
          while(y > 0)
          {
              if((y&1)==1)
                  res = (res*x)%mod;
              y >>= 1;
              x = (x*x)%mod;
          }
          return res;
      }
   
  static class Pair implements Comparable<Pair>{
          int id;int value;Pair next;
          public Pair(int id,int value) {
           
            this.id=id;this.value=value;next=null;
          }
          @Override
          public int compareTo(Pair p){return Long.compare(value,p.value);}
      }
   
  //----------------------I/O---------------------------------------------
   
  static InputStream inputStream = System.in;
  static OutputStream outputStream = System.out;
  static FastReader in=new FastReader(inputStream);
  static PrintWriter out=new PrintWriter(outputStream);
   
  static class FastReader 
  { 
    BufferedReader br; 
    StringTokenizer st; 
   
          FastReader(InputStream is) {
              br = new BufferedReader(new InputStreamReader(is));
          }
   
    public String next() 
    { 
        while (st == null || !st.hasMoreElements()) 
        { 
            try
            { 
                st = new StringTokenizer(br.readLine()); 
            } 
            catch (IOException  e) 
            { 
                e.printStackTrace(); 
            } 
        } 
        return st.nextToken(); 
    } 
   
    public int nextInt() 
    { 
        return Integer.parseInt(next()); 
    } 
   
    public long nextLong() 
    { 
        return Long.parseLong(next()); 
    } 
   
   public  double nextDouble() 
    { 
        return Double.parseDouble(next()); 
    } 
   
   
    String nextLine() 
    { 
        String str = ""; 
        try
        { 
            str = br.readLine(); 
        } 
        catch (IOException e) 
        { 
            e.printStackTrace(); 
        } 
        return str; 
    } 
  }
  static int ni() {
          return in.nextInt();
      }
  static long nl(){return in.nextLong();}
  static String ns(){return in.nextLine();}
  //---------------------I/O------------------------------------------------- 
  }