CodeForces

You are given a sequence a₁, a₂, ..., a_n consisting of different integers. It is required to split this sequence into the maximum number of subsequences such that after sorting integers in each of them in increasing order, the total sequence also will be sorted in increasing order.

Sorting integers in a subsequence is a process such that the numbers included in a subsequence are ordered in increasing order, and the numbers which are not included in a subsequence don't change their places.

Every element of the sequence must appear in exactly one subsequence.

Input

The first line of input data contains integer n (1 ≤ n ≤ 10⁵) — the length of the sequence.

The second line of input data contains n different integers a₁, a₂, ..., a_n ( - 10⁹ ≤ a_i ≤ 10⁹) — the elements of the sequence. It is guaranteed that all elements of the sequence are distinct.

Output

In the first line print the maximum number of subsequences k, which the original sequence can be split into while fulfilling the requirements.

In the next k lines print the description of subsequences in the following format: the number of elements in subsequence c_i (0 < c_i ≤ n), then c_i integers l₁, l₂, ..., l_ci (1 ≤ l_j ≤ n) — indices of these elements in the original sequence.

Indices could be printed in any order. Every index from 1 to n must appear in output exactly once.

If there are several possible answers, print any of them.

Example

Input

6
3 2 1 6 5 4

Output

4
2 1 3
1 2
2 4 6
1 5

Input

6
83 -75 -49 11 37 62

Output

1
6 1 2 3 4 5 6

Note

In the first sample output:

After sorting the first subsequence we will get sequence 1 2 3 6 5 4.

Sorting the second subsequence changes nothing.

After sorting the third subsequence we will get sequence 1 2 3 4 5 6.

Sorting the last subsequence changes nothing.

题目大意：给你一个乱序的序列，把这些序列中的放入1-k 的集合中，集合具有排序功能，最后将集合1-k中的数依次打印出来是排好序的。问k的最大值是多少？每个集合的大小和集合中的值分别是多少。

解题思路：对于每一个值都会有排序值后应该在的位置，我们用dfs不停的去找该位置上的值排序之后应该在的位置，对于找过的位置进行标记，把序列中的所有位置dfs一遍就得到了集合中的值。然后这些值我们应该放在优先队列中，省去了排序的环节。其中优先队列应该定义为数组的形式，这样就能够找出k了。如不理解，请看代码：

AC代码：

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
int a[100005];
struct node
{
    int val,id,flag;
} b[100005];
priority_queue<int ,vector<int>,greater<int> > que[100005];
int cmp(const node &a,const node &b)
{
    return a.val<b.val;
}
int dfs(int id,int k)
{
    que[k].push(id);
    if(b[id].flag==0) return 0;
    else
    {
        b[id].flag=0;
        dfs(b[id].id,k);
    }
    return 0;
}
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        for(int i=1; i<=n; i++)
        {
            scanf("%d",&b[i].val);
            b[i].id=i;
            b[i].flag=1;
        }
        sort(b+1,b+n+1,cmp);
        int k=0;
        for(int i=1;i<=n;i++)
        {
            if(b[i].flag)
            {
                b[i].flag=0;
                dfs(b[i].id,k);
                k++;
            }
        }
        printf("%d
",k);
        for(int i=0;i<k;i++)
        {
            printf("%d",que[i].size());
            while(!que[i].empty())
            {
                printf(" %d",que[i].top());
                que[i].pop();
            }
            printf("
");
        }
    }
    return 0;
}