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;
using cat = long long;
int main() {
  cin.sync_with_stdio(0);
  cin.tie(0);
  cout << fixed << setprecision(10);
  int N;
  cin >> N;
  vector<pair<int, int> > A(N);
  cat sum = 0;
  for (int i = 0; i < N; i++) {
    cin >> A[i].first;
    sum += A[i].first;
    A[i].second = i;
  }
  sort(begin(A), end(A));
  int V = A.back().first;
  vector<vector<int> > E(N);
  vector<int> V_seq;
  for (int i = 0; i < A.back().first; i++) {
    V_seq.push_back(i);
    E[A.back().second].push_back(i);
  }
  A.pop_back();
  vector<int> sums(N, 0);
  for (int i = 1; i < N; i++) sums[i] = sums[i - 1] + A[i - 1].first - 2;
  while (!A.empty()) {
    if ((int)V_seq.size() - 2 == sums[A.size()]) {
      int cur = 1;
      for (int i = 0; i < (int)A.size(); i++) {
        E[A[i].second].push_back(V);
        E[A[i].second].push_back(V_seq[cur]);
        for (int j = 0; j < A[i].first - 2; j++) {
          cur++;
          E[A[i].second].push_back(V_seq[cur]);
        }
      }
      V++;
      A.clear();
      break;
    }
    if ((int)V_seq.size() - 2 == sums[A.size()] - 1) {
      int cur = 0;
      for (int i = 0; i < (int)A.size(); i++) {
        E[A[i].second].push_back(V);
        E[A[i].second].push_back(V_seq[cur]);
        for (int j = 0; j < A[i].first - 2; j++) {
          cur++;
          E[A[i].second].push_back(V_seq[cur]);
        }
      }
      V++;
      A.clear();
      break;
    }
    int min_val = (int)V_seq.size() - A.back().first + 2;
    if (min_val == 2) min_val = 4;
    if (A.size() > 1 && min_val < A[A.size() - 2].first)
      while (min_val < A[A.size() - 2].first) min_val += 2;
    if (min_val == (int)V_seq.size() - A.back().first + 2 &&
        (int)V_seq.size() <= sums[A.size()])
      min_val += 2;
    int id = A.back().second;
    int rm_e = (V_seq.size() + A.back().first - min_val) / 2;
    int last_v = V_seq.back();
    for (int i = 0; i <= rm_e; i++) {
      E[id].push_back(V_seq.back());
      if (i < rm_e) V_seq.pop_back();
    }
    for (int i = 0; i < A.back().first - rm_e - 1; i++) {
      E[id].push_back(V);
      V_seq.push_back(V++);
    }
    V_seq.push_back(last_v);
    A.pop_back();
  }
  cout << V << "\n";
  for (int i = 0; i < N; i++)
    for (int j = 0; j < (int)E[i].size(); j++)
      cout << E[i][j] + 1 << ((j + 1 == (int)E[i].size()) ? "\n" : " ");
  cerr << (N + V - 1) * 2 - sum << "\n";
  return 0;
}