#ifdef LOCAL
class SS {
   int x[0];
};
extern "C" SS __sanitizer_print_stack_trace();
#define __last_state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
   }                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
   ;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
   SS x {                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
      __sanitizer_print_stack_trace()
#endif
#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define mp make_pair
#define st first
#define nd second
#define pii pair<int, int>
#define vi vector<int>
#define pb push_back
#define _upgrade ios_base::sync_with_stdio(0), cout.setf(ios::fixed), cout.precision(10), cin.tie(0), cout.tie(0);
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define fwd(i, a, b) for (int i = (a); i < (b); ++i)
#define trav(a, x) for (auto &a : x)
#define all(c) (c).begin(), (c).end()
#define sz(X) (int)((X).size())
typedef long double ld;
typedef unsigned long long ull;
typedef long long ll;
#ifdef LOCAL
ostream &operator<<(ostream &out, string str) {
   for (char c : str)
      out << c;
   return out;
}
template <class L, class R> ostream &operator<<(ostream &out, pair<L, R> p) { return out << "(" << p.st << ", " << p.nd << ")"; }
template <class L, class R, class S> ostream &operator<<(ostream &out, tuple<L, R, S> p) {
   auto &[a, b, c] = p;
   return out << "(" << a << ", " << b << ", " << c << ")";
}
template <class T> auto operator<<(ostream &out, T a) -> decltype(a.begin(), out) {
   out << '{';
   for (auto it = a.begin(); it != a.end(); it = next(it))
      out << (it != a.begin() ? ", " : "") << *it;
   return out << '}';
}
void dump() { cerr << "\n"; }
template <class T, class... Ts> void dump(T a, Ts... x) {
   cerr << a << ", ";
   dump(x...);
}
#define debug(...) cerr << "[" #__VA_ARGS__ "]: ", dump(__VA_ARGS__)
#else
#define debug(...) 42
#endif

namespace SOLVE {
   int n;

   void print(auto res) {
      //   return;
      cout << sz(res) << endl;
      for (auto v : res) {
         cout << sz(v) << endl;
         for (auto x : v)
            cout << x + 1 << " ";
         cout << endl;
      }
   }

   void apply(vector<int> &Y, vector<int> v) { rep(i, sz(v) / 2) swap(Y[v[i]], Y[v[sz(v) - i - 1]]); }

   void apply(vector<int> Y, auto res) {
      debug(Y, res);
      for (auto v : res)
         apply(Y, v);
      debug(Y);
      assert(is_sorted(all(Y)));
   }

   void norm(vector<int> &X) {
      auto Y = X;
      sort(all(Y));
      for (auto &x : X)
         x = lower_bound(all(Y), x) - Y.begin();
   }

   deque<vector<int>> solvee(vector<int> X) {
      n = sz(X);

      auto CP = X;
      norm(X);

      vector<deque<int>> Y;

      rep(i, n) if (X[i] != -1) {
         deque<int> v;
         int cur = i;
         do {
            debug(cur);
            v.push_back(cur);
            int tmp = X[cur];
            X[cur] = -1;
            swap(cur, tmp);
         } while (cur != i);
         Y.push_back(v);
      }
      debug(CP, Y);

      vector<int> A, B;
      for (auto &v : Y) {
         for (int i = 1; i <= sz(v) / 2; i++) {
            A.push_back(v[i]);
            B.push_back(v[(sz(v) + 1 - i) % sz(v)]);
         }
      }

      if (sz(A) == 0)
         return {};

      reverse(all(B));
      A.insert(A.end(), all(B));
      debug(A);

      apply(CP, A);
      auto res = solvee(CP);
      res.push_front(A);
      return res;
   }

   int solve(vector<int> X) {
      auto res = solvee(X);
      apply(X, res);
      print(res);
      return sz(res);
   }

} // namespace SOLVE

// namespace BRUT {
//    const int MAXN = 8;
//    vector<vector<int>> perm[MAXN];
//    set<vector<int>> pref[MAXN];
//    map<vector<int>, int> M[MAXN];

//    void init() {
//       for (int n = 1; n < MAXN; n++) {
//          vector<int> v(n);
//          iota(all(v), 0);
//          do {
//             perm[n].push_back(v);
//          } while (next_permutation(all(v)));
//          for (auto p : perm[n])
//             fwd(i, 1, n + 1) pref[n].insert(vector<int>(p.begin(), p.begin() + i));

//          M[n][perm[n][0]] = 0;
//          deque<vi> Q = {perm[n][0]};

//          while (!Q.empty() && sz(M[n]) != sz(perm[n])) {

//             auto v = Q.front();
//             Q.pop_front();
//             int d = M[n][v];
//             for (auto p : pref[n]) {
//                auto t = v;
//                SOLVE::apply(t, p);
//                if (M[n].find(t) == M[n].end()) {
//                   M[n][t] = d + 1;
//                   assert(d + 1 <= 2);
//                   Q.push_back(t);
//                }
//             }
//          }
//          debug(n, perm[n], pref[n], M[n]);
//       }
//    }

//    int solve(vector<int> X) { return M[sz(X)][X]; }

// } // namespace BRUT

int32_t main() {
   //    BRUT::init();

   //    for (int n = 1; n < BRUT::MAXN; n++) {
   //       for (auto X : BRUT::perm[n]) {
   //          auto a = SOLVE::solve(X);
   //          auto b = BRUT::solve(X);
   //          debug(X, a, b);
   //          assert(a == b);
   //       }
   //    }
   //    debug("DONE");

   _upgrade;
   int n;
   cin >> n;
   vector<int> X(n);
   for (auto &x : X)
      cin >> x;
   SOLVE::solve(X);
}