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]. 
import sys, os
import heapq, functools, collections
import math, random
from collections import Counter, defaultdict

# available on Google, not available on Codeforces
# import numpy as np
# import scipy


def solve_(lst):
    # your solution here
    original_lst = [x for x in lst]
    length = len(lst)
    if length == 1 or sorted(lst) == lst:
        return []
    if sorted(lst) == lst[::-1]:
        return [[1]*length]

    res = []
    check = False

    for i in range(1, length+1):
        ops = []
        idx = lst.index(i)

        ops = [idx] + [length - idx - (i-1)] + [1]*(i-1)            
        ops = [x for x in ops if x > 0]

        console(ops)
        assert(sum(ops) == length)

        # if len(ops) == 1:
        #     ops = [1] + [length-1] 
        #     res.append(ops)
        #     res.append(ops)
        #     console("len(ops) == 1", ops)
        #     check = True
        #     continue

        arr = []
        ptr = 0
        for op in ops:
            arr.append(lst[ptr:ptr+op])
            ptr += op


        arr = arr[::-1]
        brr = []
        for ar in arr:
            brr.extend(ar)
        lst = brr
        lst = lst[::-1]
        
        console("ops", ops)
        console("arr", arr)
        console("brr", brr)
        console("lst", lst)
        # print()
        res.append(ops)

    # if not check:
    res[1::2] = [ops[::-1] for ops in res[1::2]]
    # else:
    #     res[::2] = [ops[::-1] for ops in res[::2]]
    # if length%2 == 0:
    #     res.pop()

    lst = original_lst
    console(lst)
    
    # for ops in res:
    #     assert len(ops) >= 2

    res2 = []
    for ops in res:
        if len(ops) == 1:
            continue
        arr = []
        ptr = 0
        for op in ops:
            arr.append(lst[ptr:ptr+op])
            ptr += op
        arr = arr[::-1]
        brr = []
        for ar in arr:
            brr.extend(ar)
        lst = brr
        console("ops", ops)
        console(lst)

        res2.append(ops)
        if lst == sorted(lst):
            console("early escape")
            return res2

    assert lst == sorted(lst)


    return res


def console(*args):  
    # print on terminal in different color
    print('\033[36m', *args, '\033[0m', file=sys.stderr)
    pass


# if Codeforces environment
if os.path.exists('input.txt'):
    sys.stdin = open("input.txt","r")
    sys.stdout = open("output.txt","w")

    def console(*args):
        pass


def solve(*args):
    # screen input
    console("----- solving ------")
    console(*args)
    console("----- ------- ------")
    return solve_(*args)


if True:
    # if memory is not a constraint
    inp = iter(sys.stdin.buffer.readlines())
    input = lambda: next(inp)
else:
    # if memory is a constraint
    input = sys.stdin.buffer.readline


for case_num in [1]:
    # read line as a string
    # strr = input()

    # read line as an integer
    _ = int(input())
    
    # read one line and parse each word as a string
    # lst = input().split()

    # read one line and parse each word as an integer
    lst = list(map(int,input().split()))

    # read matrix and parse as integers (after reading read nrows)
    # lst = list(map(int,input().split()))
    # nrows = lst[0]  # index containing information, please change
    # grid = []
    # for _ in range(nrows):
    #     grid.append(list(map(int,input().split())))

    res = solve(lst)  # please change
    
    # post processing methods
    # res = [str(x) for x in res]
    # res = " ".join(res)

    # print result
    # Google - case number required
    # print("Case #{}: {}".format(case_num+1, res))
    print(len(res))

    console(lst, res)

    for row in res:
        print("{} {}".format(len(row), " ".join([str(x) for x in row])))
    # Codeforces - no case number required
    # print(res)

# import itertools
# for i in range(1,10):
#     for lst in itertools.permutations(range(1, i+1)):
#         console("TEST", list(lst))
#         solve(list(lst))
        