#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


void expr() {
  for (int n = 1; n <= 10; ++n) {
    cerr << n << ":";
    for (int m = 1; m <= n; ++m) {
      queue<vector<int>> que;
      set<vector<int>> vis;
      {
        vector<int> ini(n);
        for (int i = 0; i < n; ++i) ini[i] = i;
        vis.insert(ini);
        que.push(ini);
      }
      for (; !que.empty(); ) {
        const auto as = que.front();
        que.pop();
        auto bs = as;
        for (int i = 0; i <= n - m; ++i) {
          reverse(bs.begin() + i, bs.begin() + (i + m));
          if (vis.insert(bs).second) {
            if (n == 6 && m == 4) {
              cout << as << " " << i << " " << bs << endl;
            }
            que.push(bs);
          }
          reverse(bs.begin() + i, bs.begin() + (i + m));
        }
      }
      cerr << " " << vis.size();
    }
    cerr << endl;
  }
}
/*
1: 1
2: 1 2
3: 1 6 2
4: 1 24 4 2
5: 1 120 12 10 2
6: 1 720 36 360 6 2
7: 1 5040 144 2520 72 14 2
8: 1 40320 576 20160 288 40320 8 2
9: 1 362880 2880 181440 1440 362880 480 18 2
10: 1 3628800 14400 1814400 7200 3628800 14400 1814400 10 2
*/


vector<int> brute(int n, int m, const vector<int> &ps) {
  assert(n <= 10);
  assert((int)ps.size() >= n);
  vector<int> fac(n + 1);
  fac[0] = 1;
  for (int i = 1; i <= n; ++i) fac[i] = fac[i - 1] * i;
  auto encode = [&](const vector<int> &as) -> int {
    int remain = (1 << n) - 1;
    int u = 0;
    for (int i = 0; i < n; ++i) {
      remain -= (1 << as[i]);
      (u *= (n - i)) += __builtin_popcount(remain & ((1 << as[i]) - 1));
    }
    return u;
  };
  auto decode = [&](int u) -> vector<int> {
    vector<int> as(n);
    for (int i = n; --i >= 0; ) {
      as[i] = u % (n - i);
      u /= (n - i);
      for (int j = i + 1; j < n; ++j) if (as[i] <= as[j]) ++as[j];
    }
    return as;
  };
  queue<int> que;
  vector<pair<int, int>> prv(fac[n], make_pair(-1, -1));
  prv[0] = make_pair(-2, -2);
  que.push(0);
  for (; !que.empty(); ) {
    const int u = que.front();
    que.pop();
    auto as = decode(u);
    for (int i = 0; i <= n - m; ++i) {
      reverse(as.begin() + i, as.begin() + (i + m));
      const int v = encode(as);
      if (!~prv[v].first) {
        prv[v] = make_pair(u, i);
        que.push(v);
      }
      reverse(as.begin() + i, as.begin() + (i + m));
    }
  }
  {
    int v = encode(ps);
    if (~prv[v].first) {
      vector<int> ans;
      for (; v != 0; ) {
        ans.push_back(prv[v].second);
        v = prv[v].first;
      }
      return ans;
    } else {
      return {-1};
    }
  }
}

int T, N, M;
vector<int> P;

vector<int> solve() {
  vector<int> ops;
  auto ps = P;
  auto check = [&]() -> bool {
    for (int i = 0; i < N; ++i) if (ps[i] != i) return false;
    return true;
  };
  auto oper = [&](int l) -> void {
    const int r = l + M;
    assert(0 <= l); assert(r <= N);
    ops.push_back(l);
    reverse(ps.begin() + l, ps.begin() + r);
  };
  if (M == 1) {
    if (check()) return ops;
    return {-1};
  } else if (M == N) {
    if (check()) return ops;
    oper(0);
    if (check()) return ops;
    return {-1};
  } else if (M == N - 1) {
    for (int h = 0; h < N; ++h) {
      if (check()) return ops;
      oper(0);
      if (check()) return ops;
      oper(1);
    }
    return {-1};
  } else {
    const int n0 = min(M + 2 + (M & 1), N);
    int n = N;
    for (; n > n0; --n) {
      int i = find(ps.begin(), ps.begin() + n, n - 1) - ps.begin();
      for (; i + (M-1) <= n - 1; i += (M-1)) {
        oper(i);
      }
      for (; ; ) {
        if (ps[n - 1] == n - 1) break;
        oper(n - M - 1);
        if (ps[n - 1] == n - 1) break;
        oper(n - M);
      }
    }
// cerr<<"n = "<<n<<", ops = "<<ops<<", ps = "<<ps<<endl;
    assert(n == n0);
    const auto res = brute(n, M, ps);
    if (res != vector<int>{-1}) {
      for (const int op : res) {
        oper(op);
      }
      assert(check());
      return ops;
    } else {
      return {-1};
    }
  }
}

int main() {
  // expr();
  
  for (; ~scanf("%d%d%d", &T, &N, &M); ) {
    P.resize(N);
    for (int i = 0; i < N; ++i) {
      scanf("%d", &P[i]);
      --P[i];
    }
    
    const auto ans = solve();
    if (ans != vector<int>{-1}) {
      printf("%d\n", (int)ans.size());
      for (const int op : ans) {
        printf("%d\n", op);
      }
    } else {
      puts("-1");
    }
  }
  return 0;
}