Problem: You are given an array of n positive integers a_1, a_2, ..., a_n. You can perform the following operation any number of times: select several distinct indices i_1, i_2, ..., i_k (1 ≤ i_j ≤ n) and move the number standing at the position i_1 to the position i_2, the number at the position i_2 to the position i_3, ..., the number at the position i_k to the position i_1. In other words, the operation cyclically shifts elements: i_1 → i_2 → … i_k → i_1.

For example, if you have n=4, an array a_1=10, a_2=20, a_3=30, a_4=40, and you choose three indices i_1=2, i_2=1, i_3=4, then the resulting array would become a_1=20, a_2=40, a_3=30, a_4=10.

Your goal is to make the array sorted in non-decreasing order with the minimum number of operations. The additional constraint is that the sum of cycle lengths over all operations should be less than or equal to a number s. If it's impossible to sort the array while satisfying that constraint, your solution should report that as well.

Input

The first line of the input contains two integers n and s (1 ≤ n ≤ 200 000, 0 ≤ s ≤ 200 000)—the number of elements in the array and the upper bound on the sum of cycle lengths.

The next line contains n integers a_1, a_2, ..., a_n—elements of the array (1 ≤ a_i ≤ 10^9).

Output

If it's impossible to sort the array using cycles of total length not exceeding s, print a single number "-1" (quotes for clarity).

Otherwise, print a single number q— the minimum number of operations required to sort the array.

On the next 2 ⋅ q lines print descriptions of operations in the order they are applied to the array. The description of i-th operation begins with a single line containing one integer k (1 ≤ k ≤ n)—the length of the cycle (that is, the number of selected indices). The next line should contain k distinct integers i_1, i_2, ..., i_k (1 ≤ i_j ≤ n)—the indices of the cycle.

The sum of lengths of these cycles should be less than or equal to s, and the array should be sorted after applying these q operations.

If there are several possible answers with the optimal q, print any of them.

Examples

Input

5 5
3 2 3 1 1


Output

1
5
1 4 2 3 5 


Input

4 3
2 1 4 3


Output

-1

Input

2 0
2 2


Output

0

Note

In the first example, it's also possible to sort the array with two operations of total length 5: first apply the cycle 1 → 4 → 1 (of length 2), then apply the cycle 2 → 3 → 5 → 2 (of length 3). However, it would be wrong answer as you're asked to use the minimal possible number of operations, which is 1 in that case.

In the second example, it's possible to the sort the array with two cycles of total length 4 (1 → 2 → 1 and 3 → 4 → 3). However, it's impossible to achieve the same using shorter cycles, which is required by s=3.

In the third example, the array is already sorted, so no operations are needed. Total length of empty set of cycles is considered to be zero.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
int get() {
  char ch;
  while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
    ;
  if (ch == '-') {
    int s = 0;
    while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
    return -s;
  }
  int s = ch - '0';
  while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
  return s;
}
const int N = 2e5 + 5;
int n, s;
int a[N], b[N];
int to[N];
int q;
bool vis[N];
struct edge {
  int x, id, nxt;
} e[N];
int h[N], tot;
int col[N];
map<int, int> id;
int k;
void inse(int x, int y, int id) {
  e[++tot].x = y;
  e[tot].id = id;
  e[tot].nxt = h[x];
  h[x] = tot;
}
bool used[N];
int st;
int u;
int que[N];
pair<int, int> key[N];
int be[N];
void euler(int x) {
  for (; h[x];) {
    int p = h[x];
    int id = e[p].id;
    int y = e[p].x;
    que[++u] = id;
    h[x] = e[p].nxt;
    euler(y);
  }
}
int fa[N], c;
int getfather(int x) { return fa[x] == x ? x : fa[x] = getfather(fa[x]); }
void add(int l, int r, int c) {
  to[l] = r;
  int x = id[a[l]];
  if (be[x] && getfather(be[x]) == getfather(c)) return;
  int fx = getfather(be[x]), fc = getfather(c);
  if (!key[x].first)
    be[x] = c, key[x] = make_pair(l, r);
  else {
    to[l] = key[x].second;
    to[key[x].first] = r;
    key[x].first = l;
    fa[fx] = fc;
  }
}
void getto() {
  c = 0;
  for (int l = 1; l <= u;) {
    int r = l;
    c++;
    fa[c] = c;
    for (; a[que[r]] != b[que[l]]; r++)
      ;
    int st = id[b[que[l]]];
    for (int i = l; i <= r - 1; i++) {
      add(que[i], que[i + 1], c);
    }
    add(que[r], que[l], c);
    l = r + 1;
  }
}
int Fa[N];
int getFa(int x) { return Fa[x] == x ? x : Fa[x] = getFa(Fa[x]); }
void merge(int x, int y) {
  int tx = getFa(x), ty = getFa(y);
  Fa[tx] = ty;
}
bool ad[N];
int kp[N];
int pv[N];
int main() {
  n = get();
  s = get();
  for (int i = 1; i <= n; i++) a[i] = get();
  for (int i = 1; i <= n; i++) b[i] = a[i];
  sort(b + 1, b + 1 + n);
  int len = n;
  for (int i = 1; i <= n; i++)
    if (b[i] == a[i]) to[i] = i, len--;
  if (len > s) return printf("-1\n"), 0;
  s -= len;
  for (int i = 1; i <= n; i++)
    if (!id[b[i]]) col[id[b[i]] = ++k] = b[i];
  for (int i = 1; i <= k; i++) Fa[i] = i;
  for (int i = 1; i <= n; i++) {
    int x = id[a[i]], y = id[b[i]];
    int tx = getFa(x), ty = getFa(y);
    if (tx == ty) {
      ad[i] = 1;
      continue;
    }
    Fa[tx] = ty;
  }
  for (int i = 1; i <= n; i++)
    if (ad[i] && a[i] != b[i]) {
      int x = getFa(id[a[i]]);
      if (!kp[x]) kp[x] = i;
    }
  int nq = 0;
  for (int i = 1; i <= k; i++)
    if (getFa(i) == i && kp[i]) nq++;
  bool predo = 0;
  int pl = 0;
  if (nq > 1 && s > 1) {
    predo = 1;
    for (int i = 1; i <= k; i++)
      if (getFa(i) == i && kp[i]) {
        if (s) {
          pv[++pl] = kp[i];
          s--;
        }
      }
    if (pl <= 1)
      predo = 0;
    else {
      int tmp = a[pv[pl]];
      for (int i = pl; i >= 2; i--) a[pv[i]] = a[pv[i - 1]];
      a[pv[1]] = tmp;
    }
  }
  for (int i = 1; i <= n; i++)
    if (a[i] != b[i]) inse(id[b[i]], id[a[i]], i);
  for (int i = 1; i <= n; i++) {
    st = i;
    u = 0;
    euler(i);
    getto();
  }
  int q = 0;
  for (int i = 1; i <= n; i++)
    if (a[i] != b[i] && !vis[i]) {
      q++;
      vis[i] = 1;
      for (int x = to[i]; x != i; x = to[x]) vis[x] = 1;
    }
  printf("%d\n", q + predo);
  if (predo) {
    printf("%d\n", pl);
    for (int i = 1; i <= pl; i++) printf("%d ", pv[i]);
    putchar('\n');
  }
  for (int i = 1; i <= n; i++)
    if (a[i] != b[i] && vis[i]) {
      int len = 1;
      vis[i] = 0;
      for (int x = to[i]; x != i; x = to[x]) vis[x] = 0, len++;
      printf("%d\n%d", len, i);
      for (int x = to[i]; x != i; x = to[x]) printf(" %d", x);
      putchar('\n');
    }
  return 0;
}