Problem: You are given a deck of n cards numbered from 1 to n (not necessarily in this order in the deck). You have to sort the deck by repeating the following operation. 

  * Choose 2 ≤ k ≤ n and split the deck in k nonempty contiguous parts D_1, D_2,..., D_k (D_1 contains the first |D_1| cards of the deck, D_2 contains the following |D_2| cards and so on). Then reverse the order of the parts, transforming the deck into D_k, D_{k-1}, ..., D_2, D_1 (so, the first |D_k| cards of the new deck are D_k, the following |D_{k-1}| cards are D_{k-1} and so on). The internal order of each packet of cards D_i is unchanged by the operation. 



You have to obtain a sorted deck (i.e., a deck where the first card is 1, the second is 2 and so on) performing at most n operations. It can be proven that it is always possible to sort the deck performing at most n operations.

Examples of operation: The following are three examples of valid operations (on three decks with different sizes). 

  * If the deck is [3 6 2 1 4 5 7] (so 3 is the first card and 7 is the last card), we may apply the operation with k=4 and D_1=[3 6], D_2=[2 1 4], D_3=[5], D_4=[7]. Doing so, the deck becomes [7 5 2 1 4 3 6]. 
  * If the deck is [3 1 2], we may apply the operation with k=3 and D_1=[3], D_2=[1], D_3=[2]. Doing so, the deck becomes [2 1 3]. 
  * If the deck is [5 1 2 4 3 6], we may apply the operation with k=2 and D_1=[5 1], D_2=[2 4 3 6]. Doing so, the deck becomes [2 4 3 6 5 1]. 

Input

The first line of the input contains one integer n (1≤ n≤ 52) — the number of cards in the deck.

The second line contains n integers c_1, c_2, ..., c_n — the cards in the deck. The first card is c_1, the second is c_2 and so on.

It is guaranteed that for all i=1,...,n there is exactly one j∈\{1,...,n\} such that c_j = i.

Output

On the first line, print the number q of operations you perform (it must hold 0≤ q≤ n).

Then, print q lines, each describing one operation.

To describe an operation, print on a single line the number k of parts you are going to split the deck in, followed by the size of the k parts: |D_1|, |D_2|, ... , |D_k|. 

It must hold 2≤ k≤ n, and |D_i|≥ 1 for all i=1,...,k, and |D_1|+|D_2|+⋅⋅⋅ + |D_k| = n.

It can be proven that it is always possible to sort the deck performing at most n operations. If there are several ways to sort the deck you can output any of them.

Examples

Input


4
3 1 2 4


Output


2
3 1 2 1
2 1 3


Input


6
6 5 4 3 2 1


Output


1
6 1 1 1 1 1 1


Input


1
1


Output


0

Note

Explanation of the first testcase: Initially the deck is [3 1 2 4]. 

  * The first operation splits the deck as [(3) (1 2) (4)] and then transforms it into [4 1 2 3]. 
  * The second operation splits the deck as [(4) (1 2 3)] and then transforms it into [1 2 3 4]. 

Explanation of the second testcase: Initially the deck is [6 5 4 3 2 1]. 

  * The first (and only) operation splits the deck as [(6) (5) (4) (3) (2) (1)] and then transforms it into [1 2 3 4 5 6]. 

Solution (in JAVA):

Solution:
// package com.company;
import java.util.*;
import java.lang.*;
import java.io.*;
//****Use Integer Wrapper Class for Arrays.sort()****
public class FL3 {
    static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    public static void main(String[] Args)throws Exception{
        FastReader scan=new FastReader(System.in);
        int t=1;
//        t=scan.nextInt();
        while(t-->0){
            int n=scan.nextInt();
            int[] arr=new int[n];
            int[] brr=new int[n];
            for(int i=0;i<n;i++){
                arr[i]=scan.nextInt();
            }
            if(n==2){
                if(arr[0]==1){
                    out.println(0);
                }else{
                    out.println(1);
                    out.println("2 1 1");
                }
            }
            else if(n==1){
                out.println(0);
            }else{
                ArrayList<ArrayList<Integer>> ans=new ArrayList<>();
                if(arr[n-1]!=1){
                    ArrayList<Integer> add=new ArrayList<>();
                    for(int i=0;i<n;i++){
                        if(arr[i]==1){
                            add.add(i+1);
                            add.add(n-(i+1));
                            util(arr,brr,add);
                            int[] temp=arr;
                            arr=brr;
                            brr=temp;
                            break;
                        }
                    }
                    ans.add(add);
                }
                int l=2;
                int r=n;
                int li=-1;
                int ri=-1;
                for(int i=0;i<n;i++){
                    if(arr[i]==l){
                        li=i;
                    }
                    if(arr[i]==r){
                        ri=i;
                    }
                }
                ArrayList<Integer> add=new ArrayList<>();
                if(li<ri){
                    add.add(n-1);
                    add.add(1);
                }else{
                    add.add(ri+1);
                    add.add(n-2-ri);
                    add.add(1);
                }
                util(arr,brr,add);
                ans.add(add);
                int[] temp=arr;
                arr=brr;
                brr=temp;
                while(l<r){
                    if(l+1==r&&arr[l-1]==l){
                        break;
                    }
                    for(int i=0;i<n;i++){
                        if(arr[i]==l){
                            li=i;
                        }
                        if(arr[i]==r){
                            ri=i;
                        }
                    }
                    ArrayList<Integer> adder=new ArrayList<>();
                    int s1=l-1;
                    int s2=li+1-(l-1);
                    int s5=n-r;
                    int s4=(n-ri-s5);
                    int s3=n-(s1+s2+s4+s5);
                    adder.add(s1);
                    adder.add(s2);
                    if(s3!=0){
                        adder.add(s3);
                    }
                    adder.add(s4);
                    if(s5!=0){
                        adder.add(s5);
                    }
                    util(arr,brr,adder);
                    temp=arr;
                    arr=brr;
                    brr=temp;
                    ans.add(adder);
                    s1=n-r;
                    s2=1;
                    s5=l-1;
                    s4=1;
                    s3=1;
                    l++;
                    r--;
                    int s33=0;
                    if(l<r){
                        for(int i=0;i<n;i++){
                            if(arr[i]==l){
                                li=i;
                            }
                            if(arr[i]==r){
                                ri=i;
                            }
                        }
                        if(li<ri){
                            s3=n-(s1+s2+s4+s5);
                        }else{
                            s3=ri+1-(s1+s2);
                            s33=n-(s1+s2+s3+s4+s5);
                        }
                    }
                    adder=new ArrayList<>();
                    if(s1!=0){
                        adder.add(s1);
                    }if(s2!=0){
                        adder.add(s2);
                    }if(s3!=0){
                        adder.add(s3);
                    }if(s33!=0){
                        adder.add(s33);
                    }if(s4!=0){
                        adder.add(s4);
                    }if(s5!=0){
                        adder.add(s5);
                    }
                    ans.add(adder);
                    util(arr,brr,adder);
                    temp=arr;
                    arr=brr;
                    brr=temp;
                }
                out.println(ans.size());
                for(ArrayList<Integer> an:ans){
                    out.print(an.size()+" ");
                    for(Integer ss:an){
                        out.print(ss+" ");
                    }
                    out.println();
                }
            }
        }
        out.flush();
        out.close();
    }
    static void util(int[] arr,int[] brr,ArrayList<Integer> sizes){
        int n=arr.length;
        int k=0;
        int prev=0;
        for(Integer size:sizes){
            for(int i=prev+size-1;i>=prev;i--){
                brr[n-1-k]=arr[i];
                k++;
            }
            prev+=size;
        }
    }
    static class FastReader {

        byte[] buf = new byte[2048];
        int index, total;
        InputStream in;

        FastReader(InputStream is) {
            in = is;
        }

        int scan() throws IOException {
            if (index >= total) {
                index = 0;
                total = in.read(buf);
                if (total <= 0) {
                    return -1;
                }
            }
            return buf[index++];
        }

        String next() throws IOException {
            int c;
            for (c = scan(); c <= 32; c = scan()) ;
            StringBuilder sb = new StringBuilder();
            for (; c > 32; c = scan()) {
                sb.append((char) c);
            }
            return sb.toString();
        }

        int nextInt() throws IOException {
            int c, val = 0;
            for (c = scan(); c <= 32; c = scan()) ;
            boolean neg = c == '-';
            if (c == '-' || c == '+') {
                c = scan();
            }
            for (; c >= '0' && c <= '9'; c = scan()) {
                val = (val << 3) + (val << 1) + (c & 15);
            }
            return neg ? -val : val;
        }
        long nextLong() throws IOException {
            int c;
            long val = 0;
            for (c = scan(); c <= 32; c = scan()) ;
            boolean neg = c == '-';
            if (c == '-' || c == '+') {
                c = scan();
            }
            for (; c >= '0' && c <= '9'; c = scan()) {
                val = (val << 3) + (val << 1) + (c & 15);
            }
            return neg ? -val : val;
        }
    }
}