Devu being a small kid, likes to play a lot, but he only likes to play with arrays. While playing he came up with an interesting question which he could not solve, can you please solve it for him?

Given an array consisting of distinct integers. Is it possible to partition the whole array into *k* disjoint non-empty parts such that *p* of the parts have even sum (each of them must have even sum) and remaining *k* - *p* have odd sum? (note that parts need not to be continuous).

If it is possible to partition the array, also give any possible way of valid partitioning.
The first line will contain three space separated integers *n*, *k*, *p* (1 ≤ *k* ≤ *n* ≤ 10<sup class="upper-index">5</sup>; 0 ≤ *p* ≤ *k*). The next line will contain *n* space-separated distinct integers representing the content of array *a*: *a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a*<sub class="lower-index">*n*</sub> (1 ≤ *a*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup>).
import heapq
import sys
from types import GeneratorType
from functools import cmp_to_key
from collections import defaultdict, Counter, deque
import math

inf = float("inf")


class FastIO:
    def __init__(self):
        return

    @staticmethod
    def _read():
        return sys.stdin.readline().strip()

    def read_int(self):
        return int(self._read())

    def read_float(self):
        return float(self._read())

    def read_ints(self):
        return map(int, self._read().split())

    def read_floats(self):
        return map(float, self._read().split())

    def read_ints_minus_one(self):
        return map(lambda x: int(x) - 1, self._read().split())

    def read_list_ints(self):
        return list(map(int, self._read().split()))

    def read_list_floats(self):
        return list(map(float, self._read().split()))

    def read_list_ints_minus_one(self):
        return list(map(lambda x: int(x) - 1, self._read().split()))

    def read_str(self):
        return self._read()

    def read_list_strs(self):
        return self._read().split()

    def read_list_str(self):
        return list(self._read())

    @staticmethod
    def st(x):
        return sys.stdout.write(str(x) + '\n')

    @staticmethod
    def lst(x):
        return sys.stdout.write(" ".join(str(w) for w in x) + '\n')

    @staticmethod
    def round_5(f):
        res = int(f)
        if f - res >= 0.5:
            res += 1
        return res

    @staticmethod
    def max(a, b):
        return a if a > b else b

    @staticmethod
    def min(a, b):
        return a if a < b else b

    @staticmethod
    def bootstrap(f, queue=[]):
        def wrappedfunc(*args, **kwargs):
            if queue:
                return f(*args, **kwargs)
            else:
                to = f(*args, **kwargs)
                while True:
                    if isinstance(to, GeneratorType):
                        queue.append(to)
                        to = next(to)
                    else:
                        queue.pop()
                        if not queue:
                            break
                        to = queue[-1].send(to)
                return to
        return wrappedfunc


def main(ac=FastIO()):
    n, k, p = ac.read_ints()
    nums = ac.read_list_ints()
    odd = []
    even = []
    for num in nums:
        if num % 2:
            odd.append(num)  # 奇数
        else:
            even.append(num)
    # p个偶数 k-p个奇数
    a, b = len(odd), len(even)
    if a < k-p or (a-(k-p)) % 2:  # 奇数不够或者奇数多余
        ac.st("NO")
        return
    ac.st("YES")
    if p == 0:
        ans = [[] for _ in range(k)]
        for j in range(k):
            ans.append([odd[j]])
        ans[-1].extend(even)
        ans[-1].extend(odd[k:])
        return

    # 偶数不够
    if b + (a-(k-p))//2 < p:
        ac.st("NO")
        return
    ans = [[] for _ in range(p)]
    for i in range(b):
        ans[(i%p)].append(even[i])

    for j in range(k-p):
        ans.append([odd[j]])

    i = b
    for j in range(k-p, a, 2):
        ans[i%p].extend([odd[j], odd[j+1]])
        i += 1

    for a in ans:
        ac.lst([len(a)]+a)
    return


main()
