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>
const int MF = 1e5 + 100;
const int MN = 3e5 + 100;
using ll = long long;
int F, a[MF], m[MF], o[MF], p[MF];
std::vector<int> f[MF];
int C, Q = 1;
std::set<int> b[MN];
struct LLN {
 public:
  static int X;
  LLN *p, *n;
  int val;
};
int LLN::X = 0;
LLN pool[2 * MN];
LLN* nn(int val, LLN* p = nullptr, LLN* n = nullptr) {
  assert(LLN::X < 2 * MN);
  pool[LLN::X].val = val, pool[LLN::X].p = p, pool[LLN::X].n = n;
  return pool + LLN::X++;
}
LLN* root = nullptr;
bool edge(int u, int v) {
  assert(v != u);
  if (v < u) std::swap(u, v);
  return b[u].find(v) != b[u].end();
}
void pre(void) {
  root = nn(Q), f[F - 1].push_back(Q), ++Q;
  LLN* cur = root;
  for (int i = 0; i < a[F - 1] - 1; ++i) {
    b[Q - 1].insert(Q);
    cur->n = nn(Q);
    cur->n->p = cur;
    cur = cur->n;
    f[F - 1].push_back(Q), ++Q;
  }
}
int main(void) {
  scanf("%d", &F);
  for (int i = 0; i < F; ++i) scanf("%d", a + i), m[i] = a[i], C += a[i];
  std::sort(a, a + F);
  for (int i = 0, t; i < F; ++i)
    t = std::lower_bound(a, a + F, m[i]) - a, m[i] = t + o[t]++;
  for (int i = 0; i < F; ++i) p[i + 1] = p[i] + a[i];
  pre();
  int cur = a[F - 1];
  for (int i = F - 2, d; i >= 0; --i) {
    if (cur + a[i] - 2 - (p[i] - i * 2) <= 4)
      d = 1;
    else if (cur - a[i] + 2 - (p[i] - i * 2) >= 3)
      d = a[i] - 1;
    else
      d = (cur + a[i] - 3 - (p[i] - i * 2)) / 2;
    assert(0 < d && d < a[i]);
    LLN *x = root, *y = root;
    for (int j = 0; j < d; ++j) y = y->n;
    if (d + 1 == a[i] && edge(x->val, y->val)) x = x->n, y = y->n;
    for (LLN* k = y; k != x; k = k->p) f[i].push_back(k->val);
    f[i].push_back(x->val);
    for (int j = 0; j < a[i] - d - 1; ++j) {
      x->n = nn(Q);
      f[i].push_back(Q);
      b[x->val].insert(Q), ++Q;
      x->n->p = x, x = x->n;
    }
    x->n = y, y->p = x;
    if (d + 1 < a[i]) b[y->val].insert(x->val);
    cur += a[i] - 2 * d;
  }
  printf("%d\n", Q - 1);
  for (int i = 0; i < F; ++i) {
    for (int x : f[m[i]]) printf("%d ", x);
    printf("\n");
  }
  return 0;
}