Problem: One day Ms Swan bought an orange in a shop. The orange consisted of n·k segments, numbered with integers from 1 to n·k. 

There were k children waiting for Ms Swan at home. The children have recently learned about the orange and they decided to divide it between them. For that each child took a piece of paper and wrote the number of the segment that he would like to get: the i-th (1 ≤ i ≤ k) child wrote the number ai (1 ≤ ai ≤ n·k). All numbers ai accidentally turned out to be different.

Now the children wonder, how to divide the orange so as to meet these conditions:

  * each child gets exactly n orange segments; 
  * the i-th child gets the segment with number ai for sure; 
  * no segment goes to two children simultaneously. 



Help the children, divide the orange and fulfill the requirements, described above.

Input

The first line contains two integers n, k (1 ≤ n, k ≤ 30). The second line contains k space-separated integers a1, a2, ..., ak (1 ≤ ai ≤ n·k), where ai is the number of the orange segment that the i-th child would like to get.

It is guaranteed that all numbers ai are distinct.

Output

Print exactly n·k distinct integers. The first n integers represent the indexes of the segments the first child will get, the second n integers represent the indexes of the segments the second child will get, and so on. Separate the printed numbers with whitespaces.

You can print a child's segment indexes in any order. It is guaranteed that the answer always exists. If there are multiple correct answers, print any of them.

Examples

Input

2 2
4 1


Output

2 4 
1 3 


Input

3 1
2


Output

3 2 1 

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
long long modulo = 1000000007;
int choose(int n, int r) {
  if (n < r) {
    return 0;
  }
  if (n == r || r == 0) {
    return 1;
  }
  return choose(n - 1, r - 1) + choose(n - 1, r);
}
int get_factors(int n) {
  int numFactors = 0;
  for (int i = 1; i <= sqrt(n); i++) {
    bool divisible = n % i == 0;
    if (!divisible) {
      continue;
    }
    int quotient = n / i;
    numFactors++;
    if (quotient != i) {
      numFactors++;
    }
  }
  return numFactors;
}
int sumDigits(int num) {
  int sum = 0;
  while (num > 0) {
    sum += num % 10;
    num /= 10;
  }
  return sum;
}
int gcd(int a, int b) {
  if (b == 0) return a;
  return gcd(b, a % b);
}
vector<int> dfs(int i, vector<int> graph[], vector<bool>& visited) {
  vector<int> group = {i};
  vector<int> connected = graph[i];
  visited[i] = true;
  for (int j : connected) {
    if (!visited[j]) {
      vector<int> vals = dfs(j, graph, visited);
      for (int val : vals) {
        group.push_back(val);
      }
    }
  }
  return group;
}
bool comparePairs(pair<long long, long long> p1,
                  pair<long long, long long> p2) {
  if (p1.first < p2.first) {
    return true;
  } else if (p1.first > p2.first) {
    return false;
  } else {
    return p1.second < p2.second;
  }
}
vector<int> primes(int n) {
  vector<int> p(n + 1);
  for (int i = 0; i <= n; i++) {
    p[i] = i;
  }
  p[0] = -1;
  p[1] = -1;
  for (int i = 2; i <= n; i++) {
    if (p[i] == -1) {
      continue;
    }
    int temp = i * i;
    while (temp <= n) {
      p[temp] = -1;
      temp += i;
    }
  }
  return p;
}
vector<long long> nextPrimes(long long n) {
  vector<long long> p(n + 1, 0);
  for (long long i = 0; i <= n; i++) {
    p[i] = i;
  }
  p[0] = -1;
  p[1] = -1;
  for (long long i = 2; i <= n; i++) {
    if (p[i] == -1) {
      continue;
    }
    long long temp = i * i;
    while (temp <= n) {
      p[temp] = -1;
      temp += i;
    }
  }
  long long last = -1;
  for (long long i = n; i >= 0; i--) {
    if (p[i] == -1) {
      p[i] = last;
    } else {
      last = p[i];
    }
  }
  return p;
}
bool comparePairs(const pair<int, int>& lhs, const pair<int, int>& rhs) {
  return abs(lhs.first - lhs.second) < abs(rhs.first - lhs.second);
}
void solve() {
  int n, k;
  cin >> n >> k;
  vector<int> want(k + 1);
  vector<bool> taken(n * k + 1, false);
  for (int i = 1; i < k + 1; i++) {
    int iOfWant;
    cin >> iOfWant;
    want[i] = iOfWant;
    taken[iOfWant] = true;
  }
  int curr = 1;
  for (int i = 1; i < k + 1; i++) {
    cout << want[i] << " ";
    for (int j = 0; j < n - 1; j++) {
      while (taken[curr]) {
        curr++;
      }
      cout << curr << " ";
      curr++;
    }
    cout << "\n";
  }
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  int t = 1;
  while (t-- > 0) {
    solve();
    cout << "\n";
  }
  return 0;
}