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 ul = std::uint32_t;
using li = std::int32_t;
using ull = std::uint64_t;
using ll = std::int64_t;
const ul maxf = 1e5;
ul f;
ul a[maxf + 1];
ul o[maxf + 1];
ul sum[maxf + 2];
std::vector<ul> ans[maxf + 1];
std::list<ul> ex;
std::map<ull, bool> al;
std::list<ul>::iterator& mm(std::list<ul>::iterator& x) {
  if (x == ex.begin()) {
    return x = std::prev(ex.end());
  } else {
    return --x;
  }
}
std::list<ul>::iterator myprev(const std::list<ul>::iterator& x) {
  if (x == ex.begin()) {
    return std::prev(ex.end());
  } else {
    return std::prev(x);
  }
}
int main() {
  std::scanf("%u", &f);
  for (ul i = 1; i <= f; ++i) {
    std::scanf("%u", &a[i]);
    o[i] = i;
  }
  std::sort(o + 1, o + f + 1, [&](ul x, ul y) { return a[x] > a[y]; });
  for (ul i = f; i; --i) {
    sum[i] = a[o[i]] - 2 + sum[i + 1];
  }
  if (f == 1) {
    std::printf("%u\n", a[1]);
    for (ul i = 1; i <= a[1]; ++i) {
      if (i != 1) {
        std::putchar(' ');
      }
      std::printf("%u", i);
    }
    std::putchar('\n');
    return 0;
  }
  ul tot = 0;
  if (a[o[1]] >= sum[2] + 3) {
    for (ul i = 1; i <= a[o[1]]; ++i) {
      ++tot;
      ex.push_back(tot);
      ans[o[1]].push_back(tot);
    }
    auto bit = ex.end();
    for (ul i = 2; i <= f; ++i) {
      mm(bit);
      ans[o[i]].push_back(*bit);
      ans[o[i]].push_back(*myprev(bit));
      for (ul j = 3; j <= a[o[i]]; ++j) {
        ex.erase(myprev(bit));
        ans[o[i]].push_back(*myprev(bit));
      }
    }
    std::printf("%u\n", tot);
    for (ul i = 1; i <= f; ++i) {
      for (ul j = 0; j != ans[i].size(); ++j) {
        if (j) {
          std::putchar(' ');
        }
        std::printf("%u", ans[i][j]);
      }
      std::putchar('\n');
    }
    return 0;
  } else {
    for (ul i = 1; i <= a[o[1]]; ++i) {
      ++tot;
      ex.push_back(tot);
      ans[o[1]].push_back(tot);
      if (tot != 1) {
        al[ull(tot - 1) << 32 | tot] = true;
      }
    }
    al[ull(tot) << 32 | 1] = true;
    ul i;
    auto bit = ex.end();
    for (i = 2; i <= f && ex.size() + a[o[i]] < sum[i + 1] + 5; ++i) {
      mm(bit);
      ans[o[i]].push_back(*bit);
      ans[o[i]].push_back(*myprev(bit));
      al[ull(tot + 1) << 32 | *myprev(bit)] = true;
      for (ul j = 3; j <= a[o[i]]; ++j) {
        ++tot;
        ans[o[i]].push_back(tot);
        ex.insert(bit, tot);
        if (j != 3) {
          al[ull(tot - 1) << 32 | tot] = true;
        }
      }
      al[ull(tot) << 32 | *bit] = true;
    }
    ul x = ex.size() + a[o[i]] - sum[i + 1] - 3 >> 1;
    mm(bit);
    ans[o[i]].push_back(*bit);
    ans[o[i]].push_back(*myprev(bit));
    for (ul j = 3; j <= x + 1; ++j) {
      ex.erase(myprev(bit));
      ans[o[i]].push_back(*myprev(bit));
    }
    al[ull(tot + 1) << 32 | *myprev(bit)] = true;
    for (ul j = x + 2; j <= a[o[i]]; ++j) {
      ++tot;
      ans[o[i]].push_back(tot);
      ex.insert(bit, tot);
      if (j != x + 2) {
        al[ull(tot - 1) << 32 | tot] = true;
      }
    }
    al[ull(tot) << 32 | *bit] = true;
    for (++i; i <= f; ++i) {
      mm(bit);
      auto it = bit;
      for (ul j = 2; j <= a[o[i]]; ++j) {
        mm(it);
      }
      if (al[ull(*it) << 32 | ull(*bit)] || al[ull(*it) | ull(*bit) << 32]) {
        mm(bit);
        mm(it);
      }
      al[ull(*it) << 32 | ull(*bit)] = true;
      ans[o[i]].push_back(*bit);
      ans[o[i]].push_back(*myprev(bit));
      for (ul j = 3; j <= a[o[i]]; ++j) {
        ex.erase(myprev(bit));
        ans[o[i]].push_back(*myprev(bit));
      }
    }
    std::printf("%u\n", tot);
    for (ul i = 1; i <= f; ++i) {
      for (ul j = 0; j != ans[i].size(); ++j) {
        if (j) {
          std::putchar(' ');
        }
        std::printf("%u", ans[i][j]);
      }
      std::putchar('\n');
    }
    return 0;
  }
}