Problem: Ujan has finally cleaned up his house and now wants to decorate the interior. He decided to place a beautiful carpet that would really tie the guest room together.

He is interested in carpets that are made up of polygonal patches such that each side of a patch is either a side of another (different) patch, or is an exterior side of the whole carpet. In other words, the carpet can be represented as a planar graph, where each patch corresponds to a face of the graph, each face is a simple polygon. The perimeter of the carpet is the number of the exterior sides. 

Ujan considers a carpet beautiful if it consists of f patches, where the i-th patch has exactly a_i sides, and the perimeter is the smallest possible. Find an example of such a carpet, so that Ujan can order it!

Input

The first line of input contains a single integer f (1 ≤ f ≤ 10^5), the number of patches in the carpet. 

The next line contains f integers a_1, …, a_f (3 ≤ a_i ≤ 3⋅ 10^5), the number of sides of the patches. The total number of the sides of the patches a_1 + … + a_f does not exceed 3⋅10^5.

Output

Output the description of the carpet as a graph. 

First, output a single integer n (3 ≤ n ≤ 3 ⋅ 10^5), the total number of vertices in your graph (the vertices must be numbered from 1 to n). 

Then output f lines containing the description of the faces. The i-th line should describe the i-th face and contain a_i distinct integers v_{i,1}, …, v_{i,a_i} (1 ≤ v_{i,j} ≤ n), which means that the vertices v_{i,j} and v_{i,(j mod{a_i})+1} are connected by an edge for any 1 ≤ j ≤ a_i.

The graph should be planar and satisfy the restrictions described in the problem statement. Its perimeter should be the smallest possible. There should be no double edges or self-loops in the graph. The graph should be connected. Note that a solution always exists; if there are multiple solutions, output any of them.

Examples

Input


2
3 3


Output


4
2 1 4 
1 2 3 


Input


3
5 3 5


Output


6
1 2 3 4 5
4 5 6
1 3 4 6 5

Note

In the first sample, the two triangular faces are connected by a single edge, which results in the minimum perimeter 4.

The figure shows one possible configuration for the second sample. The minimum perimeter in this case is 3. 

<image>

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
int a[100000];
vector<int> faces[100000];
int num = 0;
priority_queue<pair<int, int> > H;
set<pair<int, int> > edges;
int main() {
  int i;
  int f;
  scanf("%d", &f);
  for (i = 0; i < f; i++) scanf("%d", &a[i]), H.push(make_pair(a[i], i));
  int j;
  for (i = 0; i < H.top().first; i++) faces[H.top().second].push_back(++num);
  int p = H.top().second;
  deque<int> curr;
  for (i = 0; i < faces[p].size(); i++) curr.push_back(faces[p][i]);
  H.pop();
  for (i = 1; i < f; i++) {
    int u = H.top().second;
    H.pop();
    int want;
    if (i == f - 1)
      want = 3;
    else
      want = H.top().first;
    if (curr.size() - a[u] + 2 > want + 1) {
      for (j = 0; j < a[u]; j++)
        faces[u].push_back(curr.back()), curr.pop_back();
      curr.push_back(faces[u].back()), curr.push_back(faces[u][0]);
    } else {
      if (((curr.size() + a[u]) & 1) == (want & 1)) {
        int over = (curr.size() + a[u] - want) / 2;
        "case1", over;
        for (j = 0; j < over + 1; j++)
          faces[u].push_back(curr.back()), curr.pop_back();
        curr.push_back(faces[u].back());
        for (j = 0; j < a[u] - over - 1; j++)
          faces[u].push_back(++num), curr.push_back(num);
        curr.push_back(faces[u][0]);
      } else {
        int over = (curr.size() + a[u] - want - 1) / 2;
        "case2", over;
        for (j = 0; j < over + 1; j++)
          faces[u].push_back(curr.back()), curr.pop_back();
        curr.push_back(faces[u].back());
        for (j = 0; j < a[u] - over - 1; j++)
          faces[u].push_back(++num), curr.push_back(num);
        curr.push_back(faces[u][0]);
      }
    }
    curr.push_back(curr[0]), curr.pop_front();
    ;
  }
  printf("%d\n", num);
  for (i = 0; i < f; i++) {
    for (j = 0; j < faces[i].size(); j++) printf("%d ", faces[i][j]);
    printf("\n");
  }
  for (i = 0; i < f; i++) {
    for (j = 0; j < faces[i].size(); j++) {
      int a = faces[i][j], b = faces[i][(j + 1) % faces[i].size()];
      if (a > b) swap(a, b);
      assert(a <= num);
      assert(b <= num);
      if (edges.count(make_pair(a, b)))
        edges.erase(make_pair(a, b));
      else
        edges.insert(make_pair(a, b));
    }
  }
  edges.size();
  return 0;
}