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 Solution
{
    static class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastReader() 
        { 
            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; 
        } 
    }
    //static final long mod=(long)1e9+7;
    static final long mod=998244353L;
    public static long pow(long a,long p)
    {
        long res=1;
        while(p>0)
        {
            if(p%2==1)
            {
                p--;
                res*=a;
                res%=mod;
            }
            else
            {
                a*=a;
                a%=mod;
                p/=2;
            }
        }
        return res;
    }
    static class Pair
    {
        int u,v;
        Pair(int u,int v)
        {
            this.u=u;
            this.v=v;
        }
    }
    /*static class Pair implements Comparable<Pair>
    {
        int v,l;
        Pair(int v,int l)
        {
            this.v=v;
            this.l=l;
        }
        public int compareTo(Pair p)
        {
            return l-p.l; 
        }
    }*/
    static long gcd(long a,long b)
    {
        if(b%a==0)
        return a;
        return gcd(b%a,a);
    }
    public static class comp implements Comparator<Pair>
    {
        public int compare(Pair p1,Pair p2)
        {
            if(p1.v>p2.v)
            return 1;
            return -1;
        }
    }
    public static void upd1(int a[],int i)
    {
        for(;i<a.length;i+=(i&(-i)))
        a[i]+=1;
    }
    public static void upd2(long a[],int up)
    {
        for(int i=up;i<a.length;i+=(i&(-i)))
        a[i]=a[i]+1L*up;
    }
    public static int q1(int a[],int i)
    {
        int s=0;
        for(;i>0;i-=(i&(-i)))
        s+=a[i];
        return s;
    }
    public static long q2(long a[],int i)
    {
        long s=0;
        for(;i>0;i-=(i&(-i)))
        s+=a[i];
        return s;
    }
    public static void main(String args[])throws Exception
    {
        FastReader fs=new FastReader();
        PrintWriter pw=new PrintWriter(System.out);
        int tc=fs.nextInt();
        while(tc-->0)
        {
            int n=fs.nextInt();
            int m=fs.nextInt();
            int a[]=new int[n];
            ArrayList<Integer> ans=new ArrayList<>();
            for(int i=0;i<n;i++)
            a[i]=fs.nextInt()-1;
            int cnt[]=new int[n];
            for(int i=0;i<n;i++)
            cnt[(i-a[i]+n)%n]++;
            for(int i=0;i<n;i++)
            {
                if(cnt[i]+2*m>=n)
                {
                    int ta[]=new int[n];
                    int in=-1;
                    for(int j=n-i;j<n;j++)
                    ta[++in]=j;
                    for(int j=0;j<n-i;j++)
                    ta[++in]=j;
                    boolean vis[]=new boolean[n];
                    int cc=0;
                    int edge[]=new int[n+1];
                    for(int j=0;j<n;j++)
                    edge[a[j]]=ta[j];
                    for(int j=0;j<n;j++)
                    {
                        if(vis[j])continue;
                        cc++;
                        int k=j;
                        while(!vis[k])
                        {
                            vis[k]=true;
                            k=edge[k];
                        }
                    }
                    if(n-cc<=m)
                    ans.add(i);
                }
            }
            pw.print(ans.size()+" ");
            for(int i:ans)
            pw.print(i+" ");
            pw.println();
        }
        pw.flush();
        pw.close();
    }
}