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
import java.util.*;
import java.io.*;
 
public class Main 
{
	static FastScanner fs = new FastScanner();
	
	public static void main(String[] args) 
	{
		int n=fs.nextInt(), k=fs.nextInt();
		int ar[] = fs.readArr(n);
		int min = Min(ar), max = Max(ar);
		if(max - min > k) 
		{
			print("NO");
			return ;
		}
		print("YES");
		for(int i : ar)
		{
			for (int j = 1; j <= i; ++j)
			{
				int a = j % k;
				if(a==0) a=k;
				System.out.print(a + " ");
			}
			System.out.println();
		}
	}
	
	static void print(int a) { System.out.println(a); }
    static void print(long a) { System.out.println(a); }
    static void print(double a) { System.out.println(a); }
    static void print(boolean a) { System.out.println(a); }
    static void print(String a) { System.out.println(a); }
    static void print(char[] a) { for(char i : a) System.out.print(i); System.out.println(); }
 
    static int Ceil(int a, int b) { return (int)Math.ceil(a / (double)b); }
 
    static int Min(int a[]) {
        int min=(int)1e9;
        for(int i:a) {
            min=Math.min(min, i);
        }
        return min;
    }
 
    static int Max(int a[]) {
        int max=0;
        for(int i:a) {
            max=Math.max(max, i);
        }
        return max;
    }
    
    static void reverse(int arr[], int s, int e)
    {
    	int n = arr.length;
    	int a[] = new int[n];
		for (int i=0; i<n; ++i) a[i] = arr[i];
		int j = 0;
		for (int i = s; i < e; ++i) 
		{
			arr[i] = a[e-j];
			j++;
		}
    }
    
    static void reverse(char arr[], int s, int e)
    {
    	int n = arr.length;
    	char a[] = new char[n];
		for (int i=0; i<n; ++i) a[i] = arr[i];
		int j = 0;
		for (int i = s; i < e; ++i) 
		{
			arr[i] = a[e-j];
			j++;
		}
    }
 
    static int[] toArray(ArrayList<Integer> ar) {
        int n=ar.size();
        int ans[]=new int[n];
        int i=0;
        for(int j:ar) {
            ans[i]=j;
            i++;
        }
        return ans;
    }
 
    static void logarr(int a[]) {
        for(int i : a) {
            System.out.print(i+" ");
        }
        System.out.println();
    }
    
    static void log2Darr(int a[][]) {
        for (int i = 0; i < a.length; ++i) logarr(a[i]);
    }
 
    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;
 
        public FastScanner()
        {
            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;
        }
 
        int[] readArr(int n)
        {
            int arr[]=new int[n];
            for(int i=0; i<n; ++i) arr[i]=fs.nextInt();
            return arr;
        }
 
        long[] readLongArr(int n)
        {
            long arr[]=new long[n];
            for(int i=0; i<n; ++i) arr[i]=fs.nextInt();
            return arr;
        }
 
    }
 
}
