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>
#pragma GCC optimize("O3")
using namespace std;
const int maxN = 1 << 19;
template <class T1, class T2>
inline void remin(T1& a, T2 b) {
  a = min(a, (T1)b);
}
template <class T1, class T2>
inline void remax(T1& a, T2 b) {
  a = max(a, (T1)b);
}
int a[maxN];
long long suf[maxN];
vector<int> ans[maxN];
list<int> C;
set<pair<int, int> > E;
bool check(list<int>::iterator it, int e) {
  int u = *it;
  while (e--) it++;
  int v = *it;
  if (u > v) swap(u, v);
  return E.find(make_pair(u, v)) != E.end();
}
bool cmp(int i, int j) { return a[i] > a[j]; }
void add(int i, int j) { E.insert({min(i, j), max(i, j)}); }
void solve() {
  int n;
  scanf("%d", &n);
  for (int i = (0); i < (int)(n); i++) scanf("%d", a + i);
  vector<int> ord(n);
  iota((ord).begin(), (ord).end(), 0);
  sort((ord).begin(), (ord).end(), cmp);
  long long S = 0;
  for (auto it = ord.rbegin(); it != ord.rend(); it++) {
    int i = *it;
    suf[i] = S;
    S += a[i] - 2;
  }
  int m = 0, j = ord[0];
  for (int _ = (0); _ < (int)(a[j]); _++) C.push_back(++m), ans[j].push_back(m);
  for (int i = (1); i < (int)(m); i++) add(i, i + 1);
  add(1, m);
  for (int i : ord)
    if (i != j) {
      long long glue = (C.size() + a[i] - 2 - suf[i]) / 2;
      remax(glue, 1);
      remin(glue, a[i] - 1);
      remin(glue, C.size() - 2);
      auto it = C.begin();
      if (glue == a[i] - 1 and check(it, glue)) it++;
      ans[i].push_back(*it++);
      for (int _ = (0); _ < (int)(glue - 1); _++)
        ans[i].push_back(*it), it = C.erase(it);
      int prv = *it;
      ans[i].push_back(prv);
      for (int _ = (0); _ < (int)(a[i] - glue - 1); _++) {
        ans[i].push_back(++m);
        it = C.insert(it, m);
        add(m, prv);
        prv = m;
      }
      add(*prev(it), prv);
    }
  printf("%d\n", m);
  for (int i = (0); i < (int)(n); i++) {
    for (int j : ans[i]) printf("%d ", j);
    printf("\n");
  }
}
int main() {
  int t;
  t = 1;
  while (t--) solve();
  return 0;
}