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("Ofast", "unroll-loops")
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using uint = unsigned int;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
default_random_engine generator;
struct Face {
  int cnt;
  int id;
};
bool operator<(const Face &a, const Face &b) { return a.cnt < b.cnt; }
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  cout << setprecision(12) << fixed;
  cerr << setprecision(12) << fixed;
  int n;
  cin >> n;
  vector<Face> faces(n);
  for (int i = 0; i < n; ++i) {
    cin >> faces[i].cnt;
    faces[i].id = i;
  }
  sort((faces).begin(), (faces).end());
  vector<int> pref(n + 1);
  for (int i = 0; i < n; ++i) {
    pref[i + 1] = pref[i] + faces[i].cnt - 2;
  }
  vector<vector<int>> res(n);
  vector<int> face;
  for (int i = 0; i < faces.back().cnt; ++i) {
    face.push_back(i);
  }
  res[faces.back().id] = face;
  int cnt = faces.back().cnt;
  faces.back().id = -1;
  set<pii> edges;
  for (int i = 0; i < (int)(face).size(); ++i) {
    int j = (i + 1 == (int)(face).size() ? 0 : i + 1);
    edges.insert({face[i], face[j]});
    edges.insert({face[j], face[i]});
  }
  while ((int)(faces).size() > 1) {
    int k = (int)(faces).size();
    swap(faces[k - 1], faces[k - 2]);
    int a = faces[k - 2].cnt;
    int b = faces[k - 1].cnt;
    assert(a >= b);
    int m = 1;
    while (a + b - 2 * m > pref[k - 2] + 3 && b - m > 1 &&
           (a != b || a - m > 2)) {
      ++m;
    }
    int u = 0, v = (int)(face).size() - m;
    vector<int> new_face;
    if (m != 1 && edges.count({face[u], face[v]})) {
      for (int i = (int)(face).size() - 1; i >= (int)(face).size() - m - 1;
           --i) {
        new_face.push_back(face[i]);
      }
      int tmp = face.back();
      for (int i = 0; i < m; ++i) {
        face.pop_back();
      }
      for (int i = 0; i < b - m - 1; ++i) {
        face.push_back(cnt);
        new_face.push_back(cnt++);
      }
      face.push_back(tmp);
    } else {
      new_face.push_back(face[0]);
      for (int i = (int)(face).size() - 1; i >= (int)(face).size() - m; --i) {
        new_face.push_back(face[i]);
      }
      for (int i = 0; i < m - 1; ++i) {
        face.pop_back();
      }
      for (int i = 0; i < b - m - 1; ++i) {
        face.push_back(cnt);
        new_face.push_back(cnt++);
      }
    }
    for (int i = 0; i < (int)(new_face).size(); ++i) {
      int j = (i + 1 == (int)(new_face).size() ? 0 : i + 1);
      edges.insert({new_face[i], new_face[j]});
      edges.insert({new_face[j], new_face[i]});
    }
    res[faces.back().id] = new_face;
    faces[k - 2].cnt = (int)(face).size();
    faces.pop_back();
  }
  cout << cnt << endl;
  for (int i = 0; i < n; ++i) {
    for (int u : res[i]) {
      cout << u + 1 << " ";
    }
    cout << endl;
  }
}