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 N = 100010;
struct Polygon {
  int sz, id;
  std::vector<int> a;
  explicit Polygon(int sz = 0, int id = 0) : sz(sz), id(id), a() {}
  bool operator<(const Polygon &p) const { return sz > p.sz; }
};
int a[N];
Polygon p[N];
std::vector<int> ans[N];
int main() {
  int f;
  scanf("%d", &f);
  for (int i = 0; i < f; ++i) {
    scanf("%d", &a[i]);
    p[i] = Polygon(a[i], i);
  }
  int n;
  if (f == 1) {
    n = a[0];
    for (int i = 1; i <= n; ++i) {
      p[0].a.push_back(i);
    }
  } else if (f == 2) {
    if (p[0].sz == p[1].sz) {
      n = a[0] + 1;
      p[0].a.push_back(1);
      p[0].a.push_back(2);
      p[0].a.push_back(3);
      for (int i = 5; i <= n; ++i) {
        p[0].a.push_back(i);
      }
      p[1].a.push_back(1);
      p[1].a.push_back(4);
      p[1].a.push_back(3);
      for (int i = 5; i <= n; ++i) {
        p[1].a.push_back(i);
      }
    } else {
      std::sort(p, p + f);
      n = p[0].sz;
      for (int i = 1; i <= n; ++i) {
        p[0].a.push_back(i);
      }
      for (int i = 1; i <= p[1].sz; ++i) {
        p[1].a.push_back(i);
      }
    }
  } else {
    std::sort(p, p + f);
    int sum = 0;
    for (int i = 0; i < f; ++i) {
      sum += a[i];
    }
    int other = sum - p[0].sz;
    if (p[0].sz - (other - 2 * (f - 1)) > 4) {
      n = p[0].sz;
      for (int i = 1; i <= n; ++i) {
        p[0].a.push_back(i);
      }
      int tmp = n;
      for (int i = 1; i < f; ++i) {
        for (int j = tmp; j >= tmp - p[i].sz + 2; --j) {
          p[i].a.push_back(j);
        }
        p[i].a.push_back(1);
        tmp -= p[i].sz - 2;
      }
    } else {
      for (int i = 1; i <= p[0].sz; ++i) {
        p[0].a.push_back(i);
      }
      std::vector<int> stack;
      if (sum % 2 == 1) {
        if (p[0].sz == 3) {
          stack = {4, 2, 3, 1};
          n = 4;
        } else {
          for (int i = 2; i <= p[0].sz; ++i) {
            stack.push_back(i);
          }
          n = p[0].sz;
        }
      } else {
        if (p[0].sz == 3) {
          stack = {5, 4, 2, 3, 1};
          n = 5;
        } else if (p[0].sz == 4) {
          stack = {2, 5, 4, 3};
          n = 5;
        } else {
          for (int i = 2; i < p[0].sz; ++i) {
            stack.push_back(i);
          }
          n = p[0].sz;
        }
      }
      int delta = int(stack.size()) - 2 - (other - 2 * (f - 1));
      bool rotated = false;
      std::vector<int> x_vec(f);
      for (int i = 1; i < f - 1; ++i) {
        int x = std::min(-delta, 2 * (p[i].sz - 2));
        delta += x;
        if (!rotated && x == 0) {
          rotated = true;
          std::rotate(stack.begin(), stack.end() - 1, stack.end());
        }
        x = x / 2 + 1;
        int back = stack.back(), front = -1;
        int del_num = p[i].sz - x + 1;
        for (int j = 0; j < del_num; ++j) {
          front = stack.back();
          stack.pop_back();
          p[i].a.push_back(front);
        }
        stack.push_back(front);
        int append_num = x - 1;
        for (int j = 0; j < append_num; ++j) {
          ++n;
          stack.push_back(n);
          p[i].a.push_back(n);
        }
        stack.push_back(back);
      }
      for (auto u : stack) {
        p[f - 1].a.push_back(u);
      }
    }
  }
  printf("%d\n", n);
  for (int i = 0; i < f; ++i) {
    ans[p[i].id] = p[i].a;
  }
  for (int i = 0; i < f; ++i) {
    for (int j = 0; j < a[i]; ++j) {
      printf("%d%c", ans[i][j], " \n"[j == a[i] - 1]);
    }
  }
  return 0;
}