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 sys, os, io
  def rs(): return sys.stdin.readline().rstrip()
  def ri(): return int(sys.stdin.readline())
  def ria(): return list(map(int, sys.stdin.readline().split()))
  def ws(s): sys.stdout.write(s + '\n')
  def wi(n): sys.stdout.write(str(n) + '\n')
  def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
  import math,datetime,functools,itertools,operator,bisect,fractions,statistics
  from collections import deque,defaultdict,OrderedDict,Counter
  from fractions import Fraction
  from decimal import Decimal
  from sys import stdout
  from heapq import heappush, heappop, heapify ,_heapify_max,_heappop_max,nsmallest,nlargest
  # sys.setrecursionlimit(111111) 
  INF=999999999999999999999999
  alphabets="abcdefghijklmnopqrstuvwxyz"
  class SortedList:
      def __init__(self, iterable=[], _load=200):
          """Initialize sorted list instance."""
          values = sorted(iterable)
          self._len = _len = len(values)
          self._load = _load
          self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
          self._list_lens = [len(_list) for _list in _lists]
          self._mins = [_list[0] for _list in _lists]
          self._fen_tree = []
          self._rebuild = True
   
      def _fen_build(self):
          """Build a fenwick tree instance."""
          self._fen_tree[:] = self._list_lens
          _fen_tree = self._fen_tree
          for i in range(len(_fen_tree)):
              if i | i + 1 < len(_fen_tree):
                  _fen_tree[i | i + 1] += _fen_tree[i]
          self._rebuild = False
   
      def _fen_update(self, index, value):
          """Update `fen_tree[index] += value`."""
          if not self._rebuild:
              _fen_tree = self._fen_tree
              while index < len(_fen_tree):
                  _fen_tree[index] += value
                  index |= index + 1
   
      def _fen_query(self, end):
          """Return `sum(_fen_tree[:end])`."""
          if self._rebuild:
              self._fen_build()
   
          _fen_tree = self._fen_tree
          x = 0
          while end:
              x += _fen_tree[end - 1]
              end &= end - 1
          return x
   
      def _fen_findkth(self, k):
          """Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
          _list_lens = self._list_lens
          if k < _list_lens[0]:
              return 0, k
          if k >= self._len - _list_lens[-1]:
              return len(_list_lens) - 1, k + _list_lens[-1] - self._len
          if self._rebuild:
              self._fen_build()
   
          _fen_tree = self._fen_tree
          idx = -1
          for d in reversed(range(len(_fen_tree).bit_length())):
              right_idx = idx + (1 << d)
              if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
                  idx = right_idx
                  k -= _fen_tree[idx]
          return idx + 1, k
   
      def _delete(self, pos, idx):
          """Delete value at the given `(pos, idx)`."""
          _lists = self._lists
          _mins = self._mins
          _list_lens = self._list_lens
   
          self._len -= 1
          self._fen_update(pos, -1)
          del _lists[pos][idx]
          _list_lens[pos] -= 1
   
          if _list_lens[pos]:
              _mins[pos] = _lists[pos][0]
          else:
              del _lists[pos]
              del _list_lens[pos]
              del _mins[pos]
              self._rebuild = True
   
      def _loc_left(self, value):
          """Return an index pair that corresponds to the first position of `value` in the sorted list."""
          if not self._len:
              return 0, 0
   
          _lists = self._lists
          _mins = self._mins
   
          lo, pos = -1, len(_lists) - 1
          while lo + 1 < pos:
              mi = (lo + pos) >> 1
              if value <= _mins[mi]:
                  pos = mi
              else:
                  lo = mi
   
          if pos and value <= _lists[pos - 1][-1]:
              pos -= 1
   
          _list = _lists[pos]
          lo, idx = -1, len(_list)
          while lo + 1 < idx:
              mi = (lo + idx) >> 1
              if value <= _list[mi]:
                  idx = mi
              else:
                  lo = mi
   
          return pos, idx
   
      def _loc_right(self, value):
          """Return an index pair that corresponds to the last position of `value` in the sorted list."""
          if not self._len:
              return 0, 0
   
          _lists = self._lists
          _mins = self._mins
   
          pos, hi = 0, len(_lists)
          while pos + 1 < hi:
              mi = (pos + hi) >> 1
              if value < _mins[mi]:
                  hi = mi
              else:
                  pos = mi
   
          _list = _lists[pos]
          lo, idx = -1, len(_list)
          while lo + 1 < idx:
              mi = (lo + idx) >> 1
              if value < _list[mi]:
                  idx = mi
              else:
                  lo = mi
   
          return pos, idx
   
      def add(self, value):
          """Add `value` to sorted list."""
          _load = self._load
          _lists = self._lists
          _mins = self._mins
          _list_lens = self._list_lens
   
          self._len += 1
          if _lists:
              pos, idx = self._loc_right(value)
              self._fen_update(pos, 1)
              _list = _lists[pos]
              _list.insert(idx, value)
              _list_lens[pos] += 1
              _mins[pos] = _list[0]
              if _load + _load < len(_list):
                  _lists.insert(pos + 1, _list[_load:])
                  _list_lens.insert(pos + 1, len(_list) - _load)
                  _mins.insert(pos + 1, _list[_load])
                  _list_lens[pos] = _load
                  del _list[_load:]
                  self._rebuild = True
          else:
              _lists.append([value])
              _mins.append(value)
              _list_lens.append(1)
              self._rebuild = True
   
      def discard(self, value):
          """Remove `value` from sorted list if it is a member."""
          _lists = self._lists
          if _lists:
              pos, idx = self._loc_right(value)
              if idx and _lists[pos][idx - 1] == value:
                  self._delete(pos, idx - 1)
   
      def remove(self, value):
          """Remove `value` from sorted list; `value` must be a member."""
          _len = self._len
          self.discard(value)
          if _len == self._len:
              raise ValueError('{0!r} not in list'.format(value))
   
      def pop(self, index=-1):
          """Remove and return value at `index` in sorted list."""
          pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
          value = self._lists[pos][idx]
          self._delete(pos, idx)
          return value
   
      def bisect_left(self, value):
          """Return the first index to insert `value` in the sorted list."""
          pos, idx = self._loc_left(value)
          return self._fen_query(pos) + idx
   
      def bisect_right(self, value):
          """Return the last index to insert `value` in the sorted list."""
          pos, idx = self._loc_right(value)
          return self._fen_query(pos) + idx
   
      def count(self, value):
          """Return number of occurrences of `value` in the sorted list."""
          return self.bisect_right(value) - self.bisect_left(value)
   
      def __len__(self):
          """Return the size of the sorted list."""
          return self._len
   
      def __getitem__(self, index):
          """Lookup value at `index` in sorted list."""
          pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
          return self._lists[pos][idx]
   
      def __delitem__(self, index):
          """Remove value at `index` from sorted list."""
          pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
          self._delete(pos, idx)
   
      def __contains__(self, value):
          """Return true if `value` is an element of the sorted list."""
          _lists = self._lists
          if _lists:
              pos, idx = self._loc_left(value)
              return idx < len(_lists[pos]) and _lists[pos][idx] == value
          return False
   
      def __iter__(self):
          """Return an iterator over the sorted list."""
          return (value for _list in self._lists for value in _list)
   
      def __reversed__(self):
          """Return a reverse iterator over the sorted list."""
          return (value for _list in reversed(self._lists) for value in reversed(_list))
   
      def __repr__(self):
          """Return string representation of sorted list."""
          return 'SortedList({0})'.format(list(self))
      
  class SegTree:
      
      def __init__(self, n):
          self.N = 1 << n.bit_length()
          self.tree = [0] * (self.N<<1)
      
      def update(self, i, j, v):
          i += self.N
          j += self.N
          while i <= j:
              if i%2==1: self.tree[i] += v
              if j%2==0: self.tree[j] += v
              i, j = (i+1) >> 1, (j-1) >> 1
      
      def query(self, i):
          v = 0
          i += self.N
          while i > 0:
              v += self.tree[i]
              i >>= 1
          return v
  
  def SieveOfEratosthenes(limit):
      """Returns all primes not greater than limit."""
      isPrime = [True]*(limit+1)
      isPrime[0] = isPrime[1] = False
      primes = []
      for i in range(2, limit+1):
          if not isPrime[i]:continue
          primes += [i]
          for j in range(i*i, limit+1, i):
              isPrime[j] = False
      return primes
  
  def main():
  
      mod=1000000007
      # InverseofNumber(mod)
      # InverseofFactorial(mod)
      # factorial(mod)
      starttime=datetime.datetime.now()
      if(os.path.exists('input.txt')):
          sys.stdin = open("input.txt","r")
          sys.stdout = open("output.txt","w")
      
      ###CODE
      
      def valid_graph(b,n,m):
          # Creating graph with edges (ai,bi) where b is offset permutation and a is given permutation
          graph=[[] for v in range(n+1)]
          vis=[0]*(n+1)
          for i in range(n):
              graph[a[i]].append(b[i])
              graph[b[i]].append(a[i])
          connected_components=0
          
          def dfs(v):
              vis[v]=1
              for u in graph[v]:
                  if not vis[u]:
                      dfs(u)
                  
          for i in range(1,n+1):
              if not vis[i]:
                  connected_components+=1
                  dfs(i)
          
          if n-connected_components<=m:
              return True
          return False
              
      tc = ri()
      for _ in range(tc):
          n,m=ria()
          a=ria()
          # LOGIC:
          # We have to answer total k offset values with m swaps to make sure a is satisfied
          # m swaps means 2*m numbers after offset at most are at different positions
          # 3*m<=n given in the question
          # If there are n numbers now atleast n-2*m numbers are in correct position after offset k
          # atleast n-2*(n/3)
          # atleast n/3 numbers are having correct offset values and rest are swapped
          # so we need to just check offset values which satisfies n/3 or more numbers
          # how many different offset values do we need to check now?
          # let say first set of n/3 numbers have offset k1
          # let say second set of n/3 numbers have offset k2
          # let say third set of n/3 numbers have offset k3
          # can we have fourth offset value for another n/3 numbers no we dont have numbers left
          # 3 sets of numbers with different offset value is max we can get with each set having n/3 or more numbers
          # At max only 3 different offset values of k we have to check
          # How to check for 1 different offset value if rest swapped numbers can be reverted back to this permutation
          # we have to just check if number of swapped values<=2*m
          # or if min swaps in which we can revert back to this offset permutation<m
          # let say with current offset value k our permutation is b
          # given permutation is a
          # we have to change b to a with minimum swaps 
          # Read this article for the idea
          # https://www.geeksforgeeks.org/minimum-number-swaps-required-sort-array/
          # We generate a graph with edges (ai,bi)
          # Every cycle in this graph can be swapped back in cycle size-1 swaps
          # Minimum swaps =  Σ(cycle size_i-1) = Σcycle size - Σ1
          #               =  n(summation of all cycle size of all cycles) - c(total number of cycles or you can say components)
  
          
          
          # Calculate offset value frequency dictionary
          offsets={}
          for pos in range(1,n+1):
              offset=0
              #if pos>a[pos-1]:
              #    offset=pos-a[pos-1]
              #else:
              #    offset=n-(a[pos-1]-pos)=n+(pos-a[pos-1])
              offset = (n+pos-a[pos-1])%n
              if offset in offsets:
                  offsets[offset]+=1
              else:
                  offsets[offset]=1
          
          
          # All values of k offset which have frequency>=n/3
          valid_frequency_offsets=[]
          for offset in offsets:
              if offsets[offset]>=n//3:
                  valid_frequency_offsets.append(offset)
          
          # Check if offset permutation can be turned into given permutation in less than m swaps
          valid_offsets=[]
          for offset in valid_frequency_offsets:
              # Creating offset permutation
              offset_permutation=[0]*n
              for i in range(1,n+1):
                  pos=(i+offset-1)%n
                  offset_permutation[pos]=i
              # Create and Check the graph if n-connected components<=2*m
              if valid_graph(offset_permutation,n,m):
                  valid_offsets.append(offset)
          print(len(valid_offsets),*sorted(valid_offsets))
                      
                  
          
              
  
  
                  
  
          
          
          
          
          
         
          
         
  
          
          
  
              
              
              
                  
              
  
              
              
          
          
             
          
          
                   
                  
          
          
  
          
          
  
          
          
          
              
          
          
              
                  
  
              
              
                  
              
              
              
              
          
          
         
           
          
  
          
          
                      
                          
  
                      
             
                       
              
          
                  
          
          
              
          
          
          
          
          
  
      
          
          
          
                  
                  
          
          
          
      
  
          
          
          
  
          
                               
          
          
          
              
          
          
                       
          
          
                      
          
                       
                      
                      
                  
                  
                      
                  
          
          
              
                     
          
                      
  
          
          
                  
              
              
      
              
                          
          
      
  
          
      #<--Solving Area Ends
      endtime=datetime.datetime.now()
      time=(endtime-starttime).total_seconds()*1000
      if(os.path.exists('input.txt')):
          print("Time:",time,"ms")  
      
                  
  class FastReader(io.IOBase):
      newlines = 0
  
      def __init__(self, fd, chunk_size=1024 * 8):
          self._fd = fd
          self._chunk_size = chunk_size
          self.buffer = io.BytesIO()
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
              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, size=-1):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
              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()
  
  
  class FastWriter(io.IOBase):
  
      def __init__(self, fd):
          self._fd = fd
          self.buffer = io.BytesIO()
          self.write = self.buffer.write
  
      def flush(self):
          os.write(self._fd, self.buffer.getvalue())
          self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class FastStdin(io.IOBase):
      def __init__(self, fd=0):
          self.buffer = FastReader(fd)
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  class FastStdout(io.IOBase):
      def __init__(self, fd=1):
          self.buffer = FastWriter(fd)
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.flush = self.buffer.flush
  
  
  if __name__ == '__main__':
      sys.stdin = FastStdin()
      sys.stdout = FastStdout()
      main()
      