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;
template <class T>
void _R(T &_x) {
  cin >> _x;
}
void _R(int &_x) { scanf("%d", &_x); }
void _R(int64_t &_x) { scanf("%" SCNd64, &_x); }
void _R(double &_x) { scanf("%lf", &_x); }
void _R(char &_x) { scanf(" %c", &_x); }
void _R(char *_x) { scanf("%s", _x); }
template <class T, class U>
void _R(pair<T, U> &_x) {
  _R(_x.first);
  _R(_x.second);
}
void R() {}
template <class T, class... U>
void R(T &_head, U &..._tail) {
  _R(_head);
  R(_tail...);
}
template <class T>
void _W(const T &_x) {
  cout << _x;
}
void _W(const int &_x) { printf("%d", _x); }
void _W(const int64_t &_x) { printf("%" PRId64, _x); }
void _W(const double &_x) { printf("%.16f", _x); }
void _W(const char &_x) { putchar(_x); }
void _W(const char *_x) { printf("%s", _x); }
template <class T, class U>
void _W(const pair<T, U> &_x) {
  _W(_x.first);
  putchar(' ');
  _W(_x.second);
}
template <class T>
void _W(const vector<T> &_x) {
  for (auto i = _x.begin(); i != _x.end(); _W(*i++))
    if (i != _x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &_head, const U &..._tail) {
  _W(_head);
  putchar(sizeof...(_tail) ? ' ' : '\n');
  W(_tail...);
}
template <class T, class... U>
void DB(const T &_head, const U &..._tail) {}
template <class T>
using MaxHeap = priority_queue<T>;
template <class T>
using MinHeap = priority_queue<T, vector<T>, greater<T>>;
inline int LG(const unsigned int &_x) { return 31 - __builtin_clz(_x); }
int f;
vector<int> as, ids, invids;
int main() {
  R(f);
  as.assign(f, 0);
  for (int i = (0); i <= (int(f) - 1); ++i) R(as[i]);
  if (f == 1) {
    W(as[0]);
    for (int i = (1); i <= (as[0]); ++i) W(i);
    return 0;
  }
  ids.assign(f, 0), invids.assign(f, 0);
  iota((ids).begin(), (ids).end(), 0);
  sort((ids).begin(), (ids).end(), [](int a, int b) { return as[a] > as[b]; });
  for (int i = (0); i <= (int(f) - 1); ++i) invids[ids[i]] = i;
  vector<vector<int>> ans(f);
  vector<int> &s = ans[0];
  int mx = as[ids[0]], ext = -1;
  int total = 1;
  s.emplace_back(1);
  int i = 1;
  for (; i < f; ++i) {
    int a = as[ids[i]];
    if (a == 3 && mx - (int)((s).size()) + (ext != -1) <= 2) break;
    ans[i].emplace_back(1);
    if (ext != -1) ans[i].emplace_back(ext);
    if (s.back() != 1) ans[i].emplace_back(s.back());
    int need = a - (int)((ans[i]).size());
    for (; (int)((s).size()) > 1 && need > 0 && (int)((s).size()) + need > mx;
         --need) {
      s.pop_back();
      ans[i].emplace_back(s.back());
    }
    while ((int)((s).size()) < mx - 1 && (int)((ans[i]).size()) < a) {
      s.emplace_back(++total);
      ans[i].emplace_back(s.back());
    }
    if ((int)((ans[i]).size()) < a) {
      ext = ++total;
      ans[i].emplace_back(ext);
      assert((int)((ans[i]).size()) == a);
    } else {
      ext = -1;
    }
  }
  if ((int)((s).size()) < mx - 1 && s.back() != 1) ext = s.back();
  while ((int)((s).size()) < mx - 1) s.emplace_back(++total);
  s.emplace_back(++total);
  vector<int> s2{1, total, s[mx - 2]};
  if (ext != -1) s2.emplace_back(ext);
  for (; i < f; ++i) {
    if ((int)((s2).size()) == 3) {
      ans[i] = {s2[0], s2[2], ++total};
      s2.emplace_back(total);
    } else {
      ans[i] = {s2[1], s2[2], s2[3]};
      s2[2] = s2[3];
      s2.pop_back();
    }
  }
  W(total);
  for (int j = (0); j <= (int(f) - 1); ++j) {
    W(ans[invids[j]]);
  }
  return 0;
}