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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.util.*;

public class Main{
    private boolean isValid(int[] a, int n, int k){
        int max = max(a), min = min(a);
        if (max-min > k) return false;
        return true;
    }
    private  void solve() throws Exception{
        int[] in = ria(2);
        int n = in[0], k = in[1];
        int[] a = ria(n);
        if (!isValid(a, n, k)) println("NO");
        else{
            println("YES");
            for (int x: a){
                for (int i = 1; i < x; i++){
                    int t = (i%k == 0) ? k : i%k;
                    print(t+" ");
                }
                int t = (x%k == 0) ? k : x%k;
                println(""+t);
            }
        }
    }

    public static void main(String[] args) throws Exception{
        Main m = new Main();
        m.solve();
    }

    /* Template Methods */
    private BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    private PrintWriter out = new PrintWriter(System.out, true);
    private StringTokenizer st;
    /* console write methods */
    private void print(String s){
        out.print(s);
    }
    private void println(String s){
        out.println(s);
    }

    /* console read methods */
    private String rs() throws IOException{
        return in.readLine();
    }
    private int ri() throws IOException{
        return Integer.parseInt(rs());
    }
    private float rf() throws  IOException{
        return Float.parseFloat(rs());
    }
    private double rd() throws IOException{
        return Double.parseDouble(rs());
    }
    private int[] ria(int size) throws IOException{
        int[] a = new int[size];
        st = new StringTokenizer(rs(), " ");
        int i = 0;
        while(st.hasMoreTokens()){ a[i] = Integer.parseInt(st.nextToken()); i++; }
        return a;
    }
    private long[] rla(int size) throws IOException{
        long[] a = new long[size];
        st = new StringTokenizer(rs(), " ");
        int i = 0;
        while(st.hasMoreTokens()){ a[i] = Long.parseLong(st.nextToken()); i++; }
        return a;
    }
    private ArrayList ral() throws IOException{
        ArrayList al = new ArrayList();
        st = new StringTokenizer(rs(), " ");
        while(st.hasMoreTokens()) al.add(st.nextToken());
        return al;
    }
    /* MAX & MIN */
    private int max(int[] a){
        int max = Integer.MIN_VALUE;
        for (int x: a) if (x > max) max = x;
        return max;
    }
    private int min(int[] a){
        int min = Integer.MAX_VALUE;
        for (int x: a) if (x < min) min = x;
        return min;
    }
}