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;
int n;
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  cin >> n;
  vector<int> a(n);
  int sum = 0;
  for (int i = 0; i < n; i++) {
    cin >> a[i];
    sum += a[i] - 2;
  }
  int pos = max_element(a.begin(), a.end()) - a.begin();
  int res = 2 * a[pos] - 2 - sum;
  if ((res % 2 == 0 && res >= 4) || (res % 2 != 0 && res >= 3)) {
    cout << a[pos] << endl;
    int cur = 1;
    for (int i = 0; i < n; i++) {
      if (i == pos) {
        for (int j = 0; j < a[pos]; j++) cout << j + 1 << " ";
      } else {
        cout << 1 << " ";
        for (int j = 0; j < a[i] - 1; j++) cout << cur + j + 1 << " ";
        cur += a[i] - 2;
      }
      cout << endl;
    }
  } else {
    if (res % 2 == 0)
      res = 4;
    else
      res = 3;
    int s = a[pos];
    sum -= a[pos] - 2;
    vector<vector<int>> ans(n);
    ans[pos].resize(s);
    iota(ans[pos].begin(), ans[pos].end(), 0);
    vector<int> cur = ans[pos];
    set<pair<int, int>> edges;
    auto handle = [&](int i) {
      int ss = ans[i].size();
      for (int j = 0; j < ss; j++) {
        edges.insert(make_pair(ans[i][j], ans[i][(j + 1) % ss]));
        edges.insert(make_pair(ans[i][(j + 1) % ss], ans[i][j]));
      }
    };
    vector<int> id(n);
    iota(id.begin(), id.end(), 0);
    stable_sort(id.begin(), id.end(),
                [&](int x, int y) { return a[x] > a[y]; });
    for (int ii = 0; ii < n; ii++) {
      int i = id[ii];
      if (i == pos) continue;
      int sz = cur.size();
      int y = max(0, a[i] - 1 - (sum + res - sz) / 2);
      int x = a[i] - y;
      if (x == 1) {
        for (int j : cur) assert(j < s);
        auto get = [&](int j, int p) {
          for (int st = p; st < p + a[j]; st++) ans[j].push_back(cur[st]);
          vector<int> add;
          for (int st = p + a[j] - 1; st < (int)cur.size(); st++)
            add.push_back(cur[st]);
          cur.resize(p + 1);
          for (int st : add) cur.push_back(st);
          handle(j);
        };
        for (int j = ii; j < n; j++) {
          for (int x = cur.size() - 2; x > -1; x--) {
            if (edges.find(make_pair(cur[x], cur[x - a[id[j]] + 1])) ==
                edges.end()) {
              get(id[j], x - a[id[j]] + 1);
              break;
            }
          }
        }
        break;
      }
      int p = cur.back();
      for (int j = sz - 1; j > sz - y - 2; j--) ans[i].push_back(cur[j]);
      cur.resize(sz - y);
      for (int j = 0; j < x - 1; j++) {
        ans[i].push_back(s);
        cur.push_back(s);
        s++;
      }
      handle(i);
      cur.push_back(p);
      sum -= a[i] - 2;
    }
    cout << s << endl;
    for (int i = 0; i < n; i++) {
      for (int j : ans[i]) {
        assert(j < s);
        cout << j + 1 << " ";
      }
      cout << endl;
    }
  }
  return 0;
}