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.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.PrintWriter;
  import java.util.*;
  import java.util.function.IntUnaryOperator;
  import java.util.function.LongUnaryOperator;
  import java.util.stream.Collectors;
  
  public class Main {
      static In in = new In();
      static Out out = new Out();
      static final long inf = 0x1fffffffffffffffL;
      static final int iinf = 0x3fffffff;
      static final double eps = 1e-9;
      static long mod = 1000000007;
  
      void solve() {
          int t = in.nextInt();
          for (int i = 0; i < t; i++) {
              int n = in.nextInt();
              int m = in.nextInt();
              int[] p = in.nextIntArray(n, j -> j - 1);
              List<Integer> list = f(n, m, p);
              Collections.sort(list);
              StringJoiner joiner = new StringJoiner(" ");
              joiner.add(Integer.toString(list.size()));
              for (Integer v : list) {
                  joiner.add(Integer.toString(v));
              }
              out.println(joiner);
          }
      }
  
      List<Integer> f(int n, int m, int[] p) {
          List<Integer> ans = new ArrayList<>();
          int[] count = new int[n];
          for (int i = 0; i < n; i++) {
              count[(i + n - p[i]) % n]++;
          }
          for (int i = 0; i < n; i++) {
              if (count[i] * 3 >= n) {
                  int[] q = p.clone();
                  for (int j = 0; j < n; j++) {
                      q[j] = (p[j] + i) % n;
                  }
                  if (f(n, m, i, q)) {
                      ans.add(i);
                  }
              }
          }
          return ans;
      }
  
      boolean f(int n, int m, int k, int[] p) {
          boolean[] visited = new boolean[n];
          int cycles = 0;
          for (int i = 0; i < n; i++) {
              if (visited[i]) {
                  continue;
              }
              cycles++;
              int j = i;
              while (!visited[j]) {
                  visited[j] = true;
                  j = p[j];
              }
          }
          return n - cycles <= m;
      }
  
      public static void main(String[] args) {
          new Main().solve();
          out.flush();
      }
  }
  
  class In {
      private final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 0x10000);
      private StringTokenizer tokenizer;
  
      String next() {
          try {
              while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                  tokenizer = new StringTokenizer(reader.readLine());
              }
          } catch (IOException ignored) {
          }
          return tokenizer.nextToken();
      }
  
      int nextInt() {
          return Integer.parseInt(next());
      }
  
      long nextLong() {
          return Long.parseLong(next());
      }
  
      double nextDouble() {
          return Double.parseDouble(next());
      }
  
      char[] nextCharArray() {
          return next().toCharArray();
      }
  
      String[] nextStringArray(int n) {
          String[] s = new String[n];
          for (int i = 0; i < n; i++) {
              s[i] = next();
          }
          return s;
      }
  
      char[][] nextCharGrid(int n, int m) {
          char[][] a = new char[n][m];
          for (int i = 0; i < n; i++) {
              a[i] = next().toCharArray();
          }
          return a;
      }
  
      int[] nextIntArray(int n) {
          int[] a = new int[n];
          for (int i = 0; i < n; i++) {
              a[i] = nextInt();
          }
          return a;
      }
  
      int[] nextIntArray(int n, IntUnaryOperator op) {
          int[] a = new int[n];
          for (int i = 0; i < n; i++) {
              a[i] = op.applyAsInt(nextInt());
          }
          return a;
      }
  
      int[][] nextIntMatrix(int h, int w) {
          int[][] a = new int[h][w];
          for (int i = 0; i < h; i++) {
              a[i] = nextIntArray(w);
          }
          return a;
      }
  
      long[] nextLongArray(int n) {
          long[] a = new long[n];
          for (int i = 0; i < n; i++) {
              a[i] = nextLong();
          }
          return a;
      }
  
      long[] nextLongArray(int n, LongUnaryOperator op) {
          long[] a = new long[n];
          for (int i = 0; i < n; i++) {
              a[i] = op.applyAsLong(nextLong());
          }
          return a;
      }
  
      long[][] nextLongMatrix(int h, int w) {
          long[][] a = new long[h][w];
          for (int i = 0; i < h; i++) {
              a[i] = nextLongArray(w);
          }
          return a;
      }
  
      List<List<Integer>> nextEdges(int n, int m) {
          List<List<Integer>> res = new ArrayList<>();
          for (int i = 0; i < n; i++) {
              res.add(new ArrayList<>());
          }
          for (int i = 0; i < m; i++) {
              int u = nextInt() - 1;
              int v = nextInt() - 1;
              res.get(u).add(v);
              res.get(v).add(u);
          }
          return res;
      }
  }
  
  class Out {
      private final PrintWriter out = new PrintWriter(System.out);
      boolean autoFlush = false;
  
      void println(Object... args) {
          if (args == null || args.getClass() != Object[].class) {
              args = new Object[] {args};
          }
          out.println(Arrays.stream(args).map(obj -> {
              Class<?> clazz = obj == null ? null : obj.getClass();
              return clazz == byte[].class ? Arrays.toString((byte[])obj) :
                      clazz == short[].class ? Arrays.toString((short[])obj) :
                              clazz == int[].class ? Arrays.toString((int[])obj) :
                                      clazz == long[].class ? Arrays.toString((long[])obj) :
                                              clazz == char[].class ? Arrays.toString((char[])obj) :
                                                      clazz == float[].class ? Arrays.toString((float[])obj) :
                                                              clazz == double[].class ? Arrays.toString((double[])obj) :
                                                                      clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
                                                                              obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
                                                                                      String.valueOf(obj);
          }).collect(Collectors.joining(" ")));
          if (autoFlush) {
              out.flush();
          }
      }
  
      void println(char[] s) {
          out.println(String.valueOf(s));
          if (autoFlush) {
              out.flush();
          }
      }
  
      void println(int[] a) {
          StringJoiner joiner = new StringJoiner(" ");
          for (int i : a) {
              joiner.add(Integer.toString(i));
          }
          out.println(joiner);
          if (autoFlush) {
              out.flush();
          }
      }
  
      void println(long[] a) {
          StringJoiner joiner = new StringJoiner(" ");
          for (long i : a) {
              joiner.add(Long.toString(i));
          }
          out.println(joiner);
          if (autoFlush) {
              out.flush();
          }
      }
  
      void flush() {
          out.flush();
      }
  }
  