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;
const int N = 300005;
int q[N], S[N], n, nd;
int pre[N], nxt[N], co[N];
vector<int> vec[N];
pair<int, int> a[N];
set<int> SS;
void erase(int x) {
  SS.erase(x);
  SS.erase(pre[x]);
  SS.erase(nxt[x]);
  pre[nxt[x]] = pre[x];
  nxt[pre[x]] = nxt[x];
  if (co[pre[pre[x]]] != co[pre[x]]) SS.insert(pre[x]);
  if (co[pre[nxt[x]]] != co[nxt[x]]) SS.insert(nxt[x]);
}
void insert(int x, int c) {
  SS.erase(x);
  SS.erase(nxt[x]);
  pre[++nd] = x;
  nxt[nd] = nxt[x];
  pre[nxt[x]] = nd;
  nxt[x] = nd;
  co[nd] = c;
  if (co[pre[pre[nd]]] != co[pre[nd]]) SS.insert(pre[nd]);
  if (co[pre[nxt[nd]]] != co[nxt[nd]]) SS.insert(nxt[nd]);
  if (co[pre[nd]] != co[nd]) SS.insert(nd);
}
int main() {
  scanf("%d", &n);
  for (int i = (int)(1); i <= (int)(n); i++)
    scanf("%d", &a[i].first), a[i].second = i;
  sort(a + 1, a + n + 1, greater<pair<int, int> >());
  for (int i = (int)(n); i >= (int)(1); i--) S[i] = S[i + 1] + a[i].first - 2;
  for (int i = (int)(1); i <= (int)(a[1].first); i++)
    vec[a[1].second].push_back(++nd);
  for (int i = (int)(1); i <= (int)(nd); i++) {
    pre[i] = (i == 1 ? nd : i - 1);
    nxt[i] = (i == nd ? 1 : i + 1);
    co[i] = 1;
  }
  *q = nd;
  for (int i = (int)(2); i <= (int)(n); i++) {
    int con = 2;
    for (; con < a[i].first && con < (*q) &&
           (*q) + a[i].first - 2 * (con + 1) + 2 - 2 > S[i + 1] &&
           (*q) + a[i].first - 2 * (con + 1) + 2 >= 3;
         ++con)
      ;
    int posi = (i == 2 ? 1 : pre[*SS.begin()]);
    vec[a[i].second].push_back(posi);
    for (int j = (int)(1); j <= (int)(con - 2); j++) {
      vec[a[i].second].push_back(nxt[posi]);
      erase(nxt[posi]);
    }
    vec[a[i].second].push_back(nxt[posi]);
    SS.erase(posi);
    co[posi] = i;
    if (co[pre[posi]] != co[posi]) SS.insert(posi);
    for (int j = (int)(con + 1); j <= (int)(a[i].first); j++) {
      insert(posi, i);
      vec[a[i].second].push_back(nd);
    }
    *q = *q + a[i].first - 2 * con + 2;
  }
  printf("%d\n", nd);
  for (int i = (int)(1); i <= (int)(n); i++) {
    for (auto j : vec[i]) printf("%d ", j);
    puts("");
  }
}