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]. 
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;
   while(i<=n){
     if(inv[i]==i){i++;}
     else{inv[p[i]]=inv[i];i++;ans++;}
   }
   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------------------------------------------------- 
}