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;
const int inf = (int)1.01e9;
const long long infll = (long long)1.01e18;
const long double eps = 1e-9;
const long double pi = acos((long double)-1);
mt19937 mrand(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int x) { return mrand() % x; }
void precalc() {}
const int maxn = (int)3e5 + 5;
int n;
int a[maxn];
bool read() {
  if (scanf("%d", &n) < 1) {
    return false;
  }
  for (int i = 0; i < n; i++) {
    scanf("%d", &a[i]);
  }
  return true;
}
int m;
int p[maxn], ts[maxn];
int get(int x) { return (p[x] == x ? x : p[x] = get(p[x])); }
void unite(int x, int y) {
  x = get(x);
  y = get(y);
  if (x == y) {
    return;
  }
  if (ts[x] < ts[y]) {
    swap(x, y);
  }
  p[y] = x;
  ts[x] += ts[y];
}
set<pair<int, int>, greater<pair<int, int>>> st;
deque<int> vs[maxn];
void merge(int x, int y, int k) {
  if (k < ((int)(vs[y]).size()) - 2) {
    int tmp = vs[x].front();
    vs[x].pop_front();
    vs[x].push_back(tmp);
  }
  int curk = ((int)(vs[y]).size());
  int lst = vs[x].back();
  unite(vs[x].back(), vs[y].back());
  vs[x].pop_back();
  vs[y].pop_back();
  int pr = lst;
  while (curk > k) {
    pr = vs[x].back();
    unite(vs[x].back(), vs[y].back());
    vs[x].pop_back();
    vs[y].pop_back();
    curk -= 2;
  }
  vs[x].push_back(pr);
  while (!vs[y].empty()) {
    vs[x].push_back(vs[y].back());
    vs[y].pop_back();
  }
  vs[x].push_back(lst);
}
int ids[maxn];
void printAns() {
  int curid = 0;
  for (int i = 0; i < m; i++) {
    if (p[i] == i) {
      ids[i] = curid++;
    }
  }
  printf("%d\n", curid);
  int cur = 0;
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < a[i]; j++) {
      printf("%d ", ids[get(cur++)] + 1);
    }
    printf("\n");
  }
}
void solve() {
  m = 0;
  st.clear();
  for (int i = 0; i < n; i++) {
    st.insert(make_pair(a[i], i));
    vs[i].clear();
    for (int j = 0; j < a[i]; j++) {
      vs[i].push_back(m++);
    }
  }
  for (int i = 0; i < m; i++) {
    p[i] = i;
    ts[i] = 1;
  }
  long long s = 0;
  for (int i = 0; i < n; i++) {
    s += a[i] - 2;
  }
  if (2 * (st.begin()->first - 2) - s >= 3) {
    auto it = st.begin();
    it++;
    while (it != st.end()) {
      merge(st.begin()->second, it->second, -it->first + 2);
      it++;
    }
    printAns();
    return;
  }
  while (((int)(st).size()) > 1) {
    int x = st.begin()->second;
    st.erase(st.begin());
    int y = st.begin()->second;
    st.erase(st.begin());
    bool found = false;
    for (int k = -((int)(vs[y]).size()) + 2; k <= ((int)(vs[y]).size()) - 2;
         k += 2) {
      int na = ((int)(vs[x]).size()) - 2 + k;
      if (!na) {
        continue;
      }
      long long ns = s;
      ns -= ((int)(vs[y]).size()) - 2;
      ns += k;
      if (2 * na - ns >= 3) {
        continue;
      }
      if (!st.empty()) {
        int aa = st.begin()->first - 2;
        if (2 * aa - ns >= 3) {
          continue;
        }
      }
      found = true;
      merge(x, y, k);
      s = ns;
      break;
    }
    assert(found);
    st.insert(make_pair(((int)(vs[x]).size()), x));
  }
  printAns();
}
int main() {
  precalc();
  while (read()) {
    solve();
  }
  return 0;
}