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: #include <bits/stdc++.h>
  #pragma GCC target("avx")
  #pragma GCC optimize("O3")
  #pragma GCC optimize("unroll-loops")
  using namespace std;
  using ll = long long;
  using datas = pair<ll, ll>;
  using ddatas = pair<long double, long double>;
  using tdata = pair<ll, datas>;
  using vec = vector<ll>;
  using mat = vector<vec>;
  using pvec = vector<datas>;
  using pmat = vector<pvec>;
  constexpr ll mod = 1000000007;
  constexpr ll inf = 1LL << 60;
  constexpr long double eps = 1e-9;
  const long double PI = acosl(-1);
  template <class T, class E>
  ostream& operator<<(ostream& os, const pair<T, E>& p) {
    return os << "(" << p.first << "," << p.second << ")";
  }
  template <class T>
  ostream& operator<<(ostream& os, const vector<T>& v) {
    os << "{";
    bool f = false;
    for (auto& x : v) {
      if (f) os << ",";
      os << x;
      f = true;
    }
    os << "}";
    return os;
  }
  template <class T>
  ostream& operator<<(ostream& os, const set<T>& v) {
    os << "{";
    bool f = false;
    for (auto& x : v) {
      if (f) os << ",";
      os << x;
      f = true;
    }
    os << "}";
    return os;
  }
  template <class T>
  ostream& operator<<(ostream& os, const multiset<T>& v) {
    os << "{";
    bool f = false;
    for (auto& x : v) {
      if (f) os << ",";
      os << x;
      f = true;
    }
    os << "}";
    return os;
  }
  template <class T, class E>
  ostream& operator<<(ostream& os, const map<T, E>& v) {
    os << "{";
    bool f = false;
    for (auto& x : v) {
      if (f) os << ",";
      os << x;
      f = true;
    }
    os << "}";
    return os;
  }
  template <class T>
  inline bool chmax(T& a, const T b) {
    bool x = a < b;
    if (x) a = b;
    return x;
  }
  template <class T>
  inline bool chmin(T& a, const T b) {
    bool x = a > b;
    if (x) a = b;
    return x;
  }
  inline void startupcpp(void) noexcept {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(15);
  }
  ll modinv(ll a, const ll m = mod) noexcept {
    ll b = m, u = 1, v = 0, t;
    while (b) {
      t = a / b;
      a -= t * b;
      swap(a, b);
      u -= t * v;
      swap(u, v);
    }
    return (u + m) % m;
  }
  ll moddevide(const ll a, const ll b) noexcept { return (a * modinv(b)) % mod; }
  vec modncrlistp, modncrlistm;
  ll modncr(const ll n, const ll r) noexcept {
    if (n < r) return 0;
    ll i, size = modncrlistp.size();
    if (size <= n) {
      modncrlistp.resize(n + 1);
      modncrlistm.resize(n + 1);
      if (!size) {
        modncrlistp[0] = modncrlistm[0] = 1;
        size++;
      }
      for (i = size; i < (ll)n + 1; ++i)
        modncrlistp[i] = modncrlistp[i - 1] * i % mod;
      modncrlistm[n] = modinv(modncrlistp[n]);
      for (i = n; i > size; --i) modncrlistm[i - 1] = modncrlistm[i] * i % mod;
    }
    return modncrlistp[n] * modncrlistm[r] % mod * modncrlistm[n - r] % mod;
  }
  ll modpow(ll a, ll n, const ll m = mod) {
    if (n < 0) return 0;
    ll res = 1;
    while (n > 0) {
      if (n & 1) res = res * a % m;
      a = a * a % m;
      n >>= 1;
    }
    return res;
  }
  constexpr ll gcd(const ll a, const ll b) noexcept {
    return (!b) ? abs(a) : (a % b == 0) ? abs(b) : gcd(b, a % b);
  }
  constexpr ll lcm(const ll a, const ll b) noexcept { return a / gcd(a, b) * b; }
  struct unionfind {
   private:
    int maxN;
    vector<int> par, treesize;
  
   public:
    unionfind(int N) : maxN(N), par(N), treesize(N, 1) {
      for (int i = 0; i < maxN; ++i) par[i] = i;
    }
    int root(int x) {
      while (par[x] != x) {
        x = par[x] = par[par[x]];
      }
      return x;
    }
    bool unite(int x, int y) {
      x = root(x);
      y = root(y);
      if (x == y) return false;
      if (treesize[x] > treesize[y]) swap(x, y);
      par[x] = y;
      treesize[y] += treesize[x];
      return true;
    }
    bool unite(pair<int, int> v) { return unite(v.first, v.second); }
    bool parcheck(int x, int y) { return root(x) == root(y); }
    bool parcheck(pair<int, int> v) { return parcheck(v.first, v.second); }
    int size(int x) { return treesize[root(x)]; }
    void clear() {
      treesize.assign(maxN, 1);
      for (int i = 0; i < maxN; ++i) par[i] = i;
    }
    vector<vector<int>> groups() {
      vector<vector<int>> res(maxN);
      for (int i = 0; i < maxN; ++i) res[root(i)].emplace_back(i);
      vector<vector<int>> res2;
      for (vector<int> x : res) {
        if (x.size()) res2.emplace_back(x);
      }
      return res2;
    }
  };
  ll N, M, K, H, W, A, B, C, D;
  string s, t;
  ll ans;
  int main() {
    startupcpp();
    int codeforces;
    cin >> codeforces;
    while (codeforces--) {
      ll i, j;
      cin >> N >> M;
      vec p(N);
      map<ll, ll> mp;
      for (i = 0; i < (ll)N; ++i) {
        cin >> p[i];
        --p[i];
        mp[i - p[i] < 0 ? i - p[i] + N : i - p[i]]++;
      }
      vec ans;
      for (auto [val, cnt] : mp) {
        if (cnt < N - M * 2) continue;
        unionfind dsu(N);
        for (i = 0; i < (ll)N; ++i)
          dsu.unite(p[i], i >= val ? i - val : i - val + N);
        if (N - dsu.groups().size() <= M) ans.emplace_back(val);
      }
      cout << ans.size() << " ";
      do {
        bool f = 0;
        for (auto outi : ans) {
          cout << (f ? " " : "") << outi;
          f = 1;
        }
        cout << "\n";
      } while (0);
    }
  }
  