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 

import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader;
import java.util.*;  
import java.io.*;
  
public class abc
{ 
	static PrintWriter pw;
    static class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastReader() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        } 
  
        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 
  
        int nextInt() 
        { 
            return Integer.parseInt(next()); 
        } 
  
        long nextLong() 
        { 
            return Long.parseLong(next()); 
        } 
  
        double nextDouble() 
        { 
            return Double.parseDouble(next()); 
        } 
  
        String nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
    } 
 
    public static int gcd(int a,int b)
    {
        return b==0?a:gcd(b,a%b);
    }
 
    public static boolean isPrime(long n)
    {
        if(n==2)return true;
        int i=2;
        while(i*i<=n)
        {
            if(n%i==0) return false;
            i++;
        }
        return true;
    }
    
    public static long[] remove(long n)
    {
        long res[]=new long[1000000000];
        long rese=0;
        int i=0;
        while(n>0)
        {
            long dig=n%10;
            n=n/10;
            if(dig>0)
            {
                rese=dig;
                	res[i++]=rese;
            }
        }
        return res;
    }
    static int ceil(int x, int y) {
		return (x % y == 0 ? x / y : (x / y + 1));
	}
 
	static long ceil(long x, long y) {
		return (x % y == 0 ? x / y : (x / y + 1));
	}
 
	static int max(int x, int y) {
		return Math.max(x, y);
	}
 
	static int min(int x, int y) {
		return Math.min(x, y);
	}
 
	static int abs(int x) {
		return Math.abs(x);
	}
 
	static long abs(long x) {
		return Math.abs(x);
	}
 
	static int log2(int N) {
		int result = (int) (Math.log(N) / Math.log(2));
		return result;
	}
 
	static long max(long x, long y) {
		return Math.max(x, y);
	}
 
	static long min(long x, long y) {
		return Math.min(x, y);
	}
	public static class pair{
		int x;
		int y;
		public pair(int a,int b){
		   x=a;
		   y=b;
		}
	}
	
	public static class Comp implements Comparator<pair>{
		public int compare(pair a,pair b){
		    if(a.x!=b.x){
		        return a.x-b.x;
		    }else{
		        return a.y-b.y;
		   }
		}
	}
	
	
    public static void main(String[] args) 
    {
    	
        FastReader ob=new FastReader();
        pw = new PrintWriter(System.out);
        int n = ob.nextInt();
        int k= ob.nextInt();
        int j=0;
        int a[]=new int[k];
        for (int i = 0; i < k; i++)
        	a[i]=ob.nextInt();
        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < k; i++)
            set.add(a[i]);
        int temp=1;
        for (int i = 0; i < k; i++) {
            j=1;
            pw.print(a[i]+" ");
            while (j < n) {
                if (!set.contains(temp)){
                    pw.print(temp+" ");
                    temp++;
                    j++;
                }
                else
                    temp++;
            }
            pw.println();
        }
        pw.flush();
    }
}
