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>
int main() {
  std::ios::sync_with_stdio(0);
  std::cin.tie(0);
  int n;
  std::cin >> n;
  struct poly {
    int ind, nside;
  };
  std::vector<poly> ps(n);
  for (int i = 0; i < n; ++i) {
    ps[i].ind = i;
    std::cin >> ps[i].nside;
  }
  std::sort(begin(ps), end(ps),
            [](poly a, poly b) { return a.nside < b.nside; });
  std::vector<std::pair<int, int>> dp(n);
  dp[0] = {ps[0].nside, ps[0].nside};
  for (int i = 1; i < n; ++i) {
    auto& out = dp[i];
    auto const [a, b] = dp[i - 1];
    int const c = ps[i].nside;
    if (c < a)
      out = {a - c + 2, b + c - 2};
    else if (c > b)
      out = {c - b + 2, c + b - 2};
    else
      out = {3 + not((a ^ c) & 1), c + b - 2};
  }
  std::vector<int> g(n);
  g.back() = dp.back().first;
  for (int i = n - 1; i; --i) {
    auto const [a, b] = dp[i - 1];
    int const c = ps[i].nside;
    int const d = g[i];
    int& od = g[i - 1];
    assert(od == 0);
    for (int od1 : {a, b, c, c - 1, c + 1}) {
      if (!(a <= od1 and od1 <= b and (od1 & 1) == (a & 1))) {
        continue;
      }
      int mind = c == od1 ? 4 : std::abs(c - od1) + 2;
      int maxd = c + od1 - 2;
      assert((maxd & 1) == (mind & 1));
      assert((d & 1) == (mind & 1));
      if (mind <= d and d <= maxd) {
        od = od1;
        break;
      }
    }
    assert(od > 0);
  }
  std::vector<std::vector<int>> ans(n);
  assert(g[0] == ps[0].nside);
  int nnode = g[0];
  std::vector<int> cur(nnode - 1);
  int const root = 0;
  std::iota(begin(cur), end(cur), 1);
  ans[ps[0].ind] = cur;
  ans[ps[0].ind].push_back(root);
  for (int i = 1; i < n; ++i) {
    int oldg = g[i - 1];
    assert(oldg == (int)cur.size() + 1);
    int nside = ps[i].nside;
    int newg = g[i];
    int n_shared_side = (oldg + nside - newg) / 2;
    int n_shared_node = n_shared_side + 1;
    assert(n_shared_node >= 2);
    assert(n_shared_node <= nside);
    std::vector<int> newp;
    newp.reserve(nside);
    if (n_shared_node == 3 && nside == 3) {
      assert(cur.size() >= 3);
      newp.assign(cur.end() - 3, cur.end());
      cur.erase(cur.end() - 2);
    } else {
      for (int z = n_shared_node - 2; z--;) {
        newp.push_back(cur.back());
        cur.pop_back();
      }
      newp.push_back(cur.back());
      for (int z = nside - n_shared_node; z--;) {
        cur.push_back(nnode);
        newp.push_back(nnode);
        ++nnode;
      }
      newp.push_back(root);
    }
    assert(newp.size() == nside);
    ans[ps[i].ind] = newp;
  }
  std::cout << nnode << '\n';
  for (auto x : ans) {
    for (auto y : x) std::cout << y + 1 << ' ';
    std::cout << '\n';
  }
}