Problem: There are n piles of pebbles on the table, the i-th pile contains ai pebbles. Your task is to paint each pebble using one of the k given colors so that for each color c and any two piles i and j the difference between the number of pebbles of color c in pile i and number of pebbles of color c in pile j is at most one.

In other words, let's say that bi, c is the number of pebbles of color c in the i-th pile. Then for any 1 ≤ c ≤ k, 1 ≤ i, j ≤ n the following condition must be satisfied |bi, c - bj, c| ≤ 1. It isn't necessary to use all k colors: if color c hasn't been used in pile i, then bi, c is considered to be zero.

Input

The first line of the input contains positive integers n and k (1 ≤ n, k ≤ 100), separated by a space — the number of piles and the number of colors respectively.

The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 100) denoting number of pebbles in each of the piles.

Output

If there is no way to paint the pebbles satisfying the given condition, output "NO" (without quotes) .

Otherwise in the first line output "YES" (without quotes). Then n lines should follow, the i-th of them should contain ai space-separated integers. j-th (1 ≤ j ≤ ai) of these integers should be equal to the color of the j-th pebble in the i-th pile. If there are several possible answers, you may output any of them.

Examples

Input

4 4
1 2 3 4


Output

YES
1
1 4
1 2 4
1 2 3 4


Input

5 2
3 2 4 1 3


Output

NO


Input

5 4
3 2 4 3 5


Output

YES
1 2 3
1 3
1 2 3 4
1 3 4
1 1 2 3 4

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;
public class Asd {
static PrintWriter w=new PrintWriter(System.out);
static FastScanner s=new FastScanner();
static HashSet<Long> list=new HashSet<>();
	public static void main(String[] args) {
		
		//int t=s.nextInt();
                int t=1;
		while(t-->0)
                {
		    solve();
		}
	       w.close();
        }
        /* Function to print all the permutations of the string
        static String swap(String str, int i, int j)
        {
        char ch;
        char[] array = str.toCharArray();
        ch = array[i];
        array[i] = array[j];
        array[j] = ch;
        return String.valueOf(array);
       }
    
      static void permute(String str,int low,int high)
    {
        if(low == high)
            list.add(Long.parseLong(str));
 
        int i;
        for(i = low; i<=high; i++){
            str = swap(str,low,i);
            permute(str, low+1,high);
            str = swap(str,low,i);
        }
    }
        use  permute(str2,0,str2.length()-1); to perform combinations
        */
           public static void solve()
        {
            int n=s.nextInt();
	int k=s.nextInt();
	int[] a=s.readArray(n);
	int [][] arr=new int[n][k];
        for(int i=0;i<n;i++)
        {
            int rem=a[i]%k;
            for(int j=0;j<k;j++)
            {
                arr[i][j]=a[i]/k;
                if(rem>0)
                {
                    arr[i][j]++;rem--;
                }
            }
        }
        for(int i=0;i<k;i++)
        {
            int max=-1;
            int min=200;
            for(int j=0;j<n;j++){
               max=Math.max(arr[j][i],max);min=Math.min(arr[j][i],min);
            }
            if(max-min>1)
            {
                w.println("NO");return;
            }
                
        }
        w.println("YES");
        for(int i=0;i<n;i++)
        {
            
            for(int j=0;j<k;j++)
            {
                for(int y=0;y<arr[i][j];y++)
                    w.print(j+1+" ");
            }
            w.println();
        }
            }
        
           
        static void noofdivisors(int n)
        {
            //it counts no of divisors of every number upto number n
            
            int arr[]=new int[n+1];
              for(int i=1;i<=(n);i++)
			for(int j=i;j<=(n);j=j+i)
				arr[j]++;
        }
           
        
       
        static char[] reverse(char arr[])
        {
            char[] b = new char[arr.length]; 
        int j = arr.length; 
        for (int i = 0; i < arr.length; i++) { 
            b[j - 1] = arr[i]; 
            j = j - 1; 
        }
        return b;
        }
        
        
	static long factorial(int n)
        {
            long su=1;
            for(int i=1;i<=n;i++)
                su*=(long)i;
            return su;
        }
	static class FastScanner {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer("");
		public String next() {
			while (!st.hasMoreElements())
				try {
					st=new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}
		int[] readArray(int n) {
			int[] a=new int[n]; 
			for (int i=0; i<n; i++) a[i]=nextInt();
			return a;
		}
		
		int nextInt () {
			return Integer.parseInt(next());
		}
                long nextLong () {
			return Long.parseLong(next());
		}
                double nextDouble () {
			return Double.parseDouble(next());
		}
	}

}