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 PYTHON3):

Solution:
from math import ceil, floor
import copy

num_piles, num_colors = map(int, input().split())
p = list(map(int, input().split()))
piles = sorted(copy.deepcopy(p))

p_h = [[(p[x]%num_colors) if (p[x]%num_colors) != 0 else num_colors, ceil(p[x]/num_colors)] for x in range(num_piles)]
p_l = []
peebles_high_colors = [[(piles[x]%num_colors) if (piles[x]%num_colors) != 0 else num_colors, ceil(piles[x]/num_colors)] for x in range(num_piles)]
peebles_lower_colors = []

for i in range(num_piles):
    i1 = num_colors-peebles_high_colors[i][0]
    i2 = 0
    if i1 != 0:
        i2 = (piles[i] - (peebles_high_colors[i][1]*peebles_high_colors[i][0]))//i1
    else:
        i2 = piles[i] - (peebles_high_colors[i][1]*peebles_high_colors[i][0])

    peebles_lower_colors.append([i1,i2])

    j1 = num_colors-p_h[i][0]
    j2 = 0
    if j1 != 0:
        j2 = (p[i] - (p_h[i][1]*p_h[i][0]))//j1
    else:
        j2 = p[i] - (p[i] - (p_h[i][1]*p_h[i][0]))

    p_l.append([j1,j2])


def check():

    if peebles_high_colors[num_piles-1][0] <= peebles_high_colors[0][0]:
        if peebles_high_colors[num_piles-1][1] - peebles_high_colors[0][1] > 1:
            return False

    elif peebles_high_colors[num_piles-1][1] - peebles_lower_colors[0][1] > 1:
        return False

    return True

def prtline(i):

    cur_color = 1
    aux = 0

    max = p_h[i][1]
    for j in range(p_h[i][0]*p_h[i][1]):

        if aux >= max:
            aux = 0
            cur_color += 1

        print(cur_color, end=' ')
        aux += 1

    max = p_l[i][1]
    for j in range(p_l[i][0] * p_l[i][1]):
        if aux >= max:
            aux = 0
            cur_color += 1

        print(cur_color, end=' ')
        aux += 1

    print()


def prt():
    global p
    for i in range(num_piles):
        prtline(i)


if check():
    print("YES")
    prt()
else:
    print("NO")