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;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXFACE = 100000;
struct Face {
  int nside, id;
};
bool operator<(const Face &a, const Face &b) { return a.nside > b.nside; }
int nface;
Face face[MAXFACE];
int ansn;
vector<int> ans[MAXFACE];
int perim[MAXFACE];
int overlap[MAXFACE];
void solve() {
  sort(face, face + nface);
  perim[0] = face[0].nside, overlap[0] = 0;
  for (int i = (1); i < (nface); ++i) {
    assert(perim[i - 1] >= face[i].nside);
    int lim = i + 1 < nface ? face[i + 1].nside : 3;
    overlap[i] =
        min(face[i].nside - 1, (perim[i - 1] + face[i].nside - lim) / 2);
    perim[i] = perim[i - 1] + face[i].nside - 2 * overlap[i];
  }
  ansn = 0;
  for (int i = (0); i < (nface); ++i) ans[i].clear();
  vector<int> cur(perim[0]);
  for (int i = (0); i < (((int)(cur).size())); ++i) cur[i] = ansn++;
  ans[face[0].id] = cur;
  for (int i = (1); i < (nface); ++i) {
    assert(overlap[i] < face[i].nside && overlap[i] < ((int)(cur).size()) &&
           ((int)(cur).size()) + face[i].nside - 2 * overlap[i] >= 3);
    vector<int> me;
    me.push_back(cur[0]);
    for (int j = (0); j < (overlap[i] - 1); ++j) {
      int x = cur.back();
      cur.pop_back();
      me.push_back(x);
    }
    me.push_back(cur.back());
    for (int j = (0); j < (face[i].nside - overlap[i] - 1); ++j) {
      int x = ansn++;
      me.push_back(x);
      cur.push_back(x);
    }
    ans[face[i].id] = me;
    assert(((int)(cur).size()) == perim[i]);
    assert(((int)(me).size()) == face[i].nside);
    if (perim[i - 1] == 3 && overlap[i] == 1)
      rotate(cur.begin(), cur.begin() + ((int)(cur).size()) - 1, cur.end());
  }
}
void run() {
  scanf("%d", &nface);
  for (int i = (0); i < (nface); ++i)
    scanf("%d", &face[i].nside), face[i].id = i;
  solve();
  printf("%d\n", ansn);
  for (int i = (0); i < (nface); ++i) {
    for (int j = (0); j < (((int)(ans[i]).size())); ++j) {
      if (j != 0) printf(" ");
      printf("%d", ans[i][j] + 1);
    }
    puts("");
  }
}
int main() {
  run();
  return 0;
}