Recently Evlampy installed one interesting computer game, one of aspects of which is to split army into several groups and then fight with enemy's groups. Let us consider a simplified version of the battle.

In the nearest battle Evlampy should fight an enemy army that consists of m groups, the i-th of which has hp_i health points.

Evlampy's army consists of n equal soldiers. Before each battle he should split his army in exactly m groups (possibly, empty) so that the total size of the groups is n. The battle is played step-by-step. On each step each of Evlampy's groups attacks exactly one enemy group. Thus, each step is described with an array of m integers a_1, a_2, …, a_m, meaning that the i-th Evlampy's group attacks the a_i-th enemy group. Different groups can attack same group, on each step the array a is chosen independently.

After each step the health points of each enemy group decreases by the total number of soldiers in Evlampy's groups that attacked this enemy group at this step. Enemy group is destroyed once its health points are zero or negative. Evlampy's soldiers do not lose health.

<image> An example of a step. The numbers in green circles represent the number of soldiers in Evlampy's groups, the arrows represent attacks, the numbers in red circles represent health points of enemy groups, the blue numbers represent how much the health points will decrease after the step.

Evlampy understands that the upcoming battle will take the whole night. He became sad because this way he won't have enough time to finish his homework. Now Evlampy wants you to write a program that will help him win in the smallest possible number of steps. Can you help him?

In other words, find the smallest number of steps needed to destroy all enemy groups and show a possible way of doing this. Find the requires splitting of the army into m groups and the arrays a for each step.

Input

The first line contains two integers n and m (1 ≤ m ≤ n ≤ 10^{6}) — the number of soldiers in Evlampy's army and the number of groups in enemy army. m is also equal to the maximum possible number of groups Evlampy can split the army to.

The second line contains m integers hp_1, hp_2, …, hp_m (1 ≤ hp_i ≤ 10^{6}) — the health points of each of the enemy groups.

It is guaranteed that the sum of hp_i does not exceed 10^{6}.

Output

Print a single integer t — the minimum possible number of steps needed to win the battle.

After that print m integers s_1, s_2, …, s_m (s_i ≥ 0, s_1 + s_2 + … + s_m = n), meaning that the i-th group of Evlampy's army should contain s_i soldiers.

In each of the next t lines print m integers a_1, a_2, …, a_m (1 ≤ a_i ≤ m) — the description of one step. The integers mean that on the corresponding step the i-th Evlampy's group should attack the a_i-th enemy group. It is allowed to attack an already destroyed group.

Examples

Input


13 7
6 4 3 7 2 1 5


Output


3
0 1 2 3 1 2 4
2 6 2 4 4 2 4
3 1 7 1 7 7 1
3 1 5 3 7 5 1


Input


6 5
3 3 3 3 3


Output


3
3 3 0 0 0
1 2 3 4 5
3 4 5 5 5
5 5 5 5 5


Input


7 4
1 5 9 2


Output


3
1 2 4 0
1 4 2 3
2 3 3 3
3 3 3 3

Note

The first example is shown below.

<image>
#include <bits/stdc++.h>
using std::sort;
const int MAXM = 1000011;
int N, M;
int A[MAXM];
int T;
int L[MAXM];
int C[MAXM];
int Aim[MAXM];
struct Pair {
  int *p, v;
  Pair() {}
  Pair(int *_p, int _v) {
    p = _p;
    v = _v;
  }
} P[MAXM];
inline bool operator<(const Pair &A, const Pair &B) { return A.v < B.v; }
void Set(int p) {
  if (Aim[1]) return;
  Aim[1] = p;
}
void Lanch() {
  Aim[0] = 1;
  for (int i = 1; i <= M; ++i)
    if (!Aim[i]) Aim[i] = Aim[i - 1];
  for (int i = 1; i <= M; ++i) printf("%d ", Aim[i]);
  puts("");
  for (int i = 1; i <= M; ++i) Aim[i] = 0;
}
void Leave(int p) {
  if (p <= 1) return;
  Aim[p] = Aim[1];
  Aim[1] = 0;
}
int main() {
  scanf("%d%d", &N, &M);
  for (int i = 1; i <= M; ++i) scanf("%d", &A[i]);
  for (int i = 1, v = N; i <= M; ++i) {
    L[i] = A[i];
    L[i] -= v;
    while (L[i] > 0) L[i] -= N;
    L[i] = -L[i];
    v = L[i];
  }
  L[M] = 0;
  for (int i = 1; i <= M; ++i) P[i] = Pair(&L[i], L[i]);
  sort(P + 1, P + M + 1);
  for (int i = 1; i <= M; ++i) *P[i].p = i;
  for (int i = 1; i < M; ++i) C[i] = P[i + 1].v - P[i].v;
  C[M] = N - P[M].v;
  int Sum = 0;
  for (int i = 1; i <= M; ++i) Sum += A[i];
  T = Sum / N;
  if (Sum % N != 0) ++T;
  printf("%d\n", T);
  for (int i = 1; i <= M; ++i) printf("%d ", C[i]);
  puts("");
  for (int i = 1, v = N; i <= M; ++i) {
    Set(i);
    A[i] -= v;
    while (A[i] > 0) {
      Lanch();
      Set(i);
      A[i] -= N;
    }
    Leave(L[i]);
    v = -A[i];
  }
  Lanch();
  return 0;
}
