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 time
  
  #start_time = time.time()
  #def TIME_(): print(time.time()-start_time)
  
  import os, sys
  from io import BytesIO, IOBase
  from types import GeneratorType
  from bisect import bisect_left, bisect_right
  from collections import defaultdict as dd, deque as dq, Counter as dc
  import math, string, heapq as h
  BUFSIZE = 8192
  
  class FastIO(IOBase):
      newlines = 0
      def __init__(self, file):
          import os
          self.os = os
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
      def read(self):
          while True:
              b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
      def readline(self):
          while self.newlines == 0:
              b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
      def flush(self):
          if self.writable:
              self.os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
   
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  def getInt(): return int(input())
  def getStrs(): return input().split()
  def getInts(): return list(map(int,input().split()))
  def getStr(): return input()
  def listStr(): return list(input())
  def getMat(n): return [getInts() for _ in range(n)]
  def getBin(): return list(map(int,list(input())))
  def isInt(s): return '0' <= s[0] <= '9'
  def ceil_(a,b): return (a+b-1)//b
  
  MOD = 10**9 + 7
  
  """
  Cyclic shift first
  Then at most M swaps
  
  So which starting permutations could we have?
  
  Let's find the counts of (p[i] - i) % N
  
  Suppose I want to get from 2 3 1 to 3 1 2
  Min swaps? 3 2 1, 3 1 2
  
  3 4 1 2 to 1 2 3 4? Can do that in 2 swaps
  
  2 3 4 1?
  
  2 4 1 3
  2 3 1 4
  2 3 4 1 Needs 3 swaps!
  
  How many goes do I need in order to permute it back to each possibility? Feels like connected components.
  
  2 3 4 5 1
  1 3 4 5 2
  1 2 4 5 3
  1 2 3 5 4
  1 2 3 4 5
  
  3 4 1 2
  
  K = 2, 0 swaps
  K = 1? 
  
  [2,2,2,2]
  
  K = 0
  [2,2,2,2]
  K = 1
  [1,1,1,1]
  
  How long are each of the cycles for a given value of K?
  """
  
  def solve():
      N, M = getInts()
      A = getInts()
      cnt = [0]*N
      poss = []
      for i, a in enumerate(A):
          cnt[(i + 1 - a) % N] += 1
      for i in range(N):
          if (cnt[i] >= N - 2*M):
              # cnt[i] >= 1/3 * N, so we can only have at most 3 of these
              G = [[] for _ in range(N)]
              for j, a in enumerate(A):
                  # we ought to have that a[j] = 0 if j = i, a[j] = 1 if j = (i+1) % N, etc
                  G[a-1].append((j - i) % N)
                  G[(j - i) % N].append(a-1)
              tmp = 0
              used = [0]*N
              for j in range(N):
                  if not G[j] or used[j]: continue
                  Q = dq([j])
                  used[j] = 1
                  num = 1
                  while Q:
                      u = Q.popleft()
                      for v in G[u]:
                          if used[v]: continue
                          used[v] = 1
                          num += 1
                          Q.append(v)
                  tmp += num - 1
              #print(i,tmp,"HI")
              if tmp <= M: poss.append(i)
      print(len(poss),*poss)
      return
      
  for _ in range(getInt()):
      #print(solve())
      solve()
  
  #TIME_()