You are given an array $a$ consisting of $n$ integers $a_1, a_2, \dots, a_n$. You want to split it into exactly $k$ non-empty non-intersecting subsegments such that each subsegment has odd sum (i. e. for each subsegment, the sum of all elements that belong to this subsegment is odd). It is impossible to rearrange (shuffle) the elements of a given array. Each of the $n$ elements of the array $a$ must belong to exactly one of the $k$ subsegments.

Let's see some examples of dividing the array of length $5$ into $3$ subsegments (not necessarily with odd sums): $[1, 2, 3, 4, 5]$ is the initial array, then all possible ways to divide it into $3$ non-empty non-intersecting subsegments are described below:  $[1], [2], [3, 4, 5]$;  $[1], [2, 3], [4, 5]$;  $[1], [2, 3, 4], [5]$;  $[1, 2], [3], [4, 5]$;  $[1, 2], [3, 4], [5]$;  $[1, 2, 3], [4], [5]$. 

Of course, it can be impossible to divide the initial array into exactly $k$ subsegments in such a way that each of them will have odd sum of elements. In this case print "NO". Otherwise, print "YES" and any possible division of the array. See the output format for the detailed explanation.

You have to answer $q$ independent queries.


-----Input-----

The first line contains one integer $q$ ($1 \le q \le 2 \cdot 10^5$) — the number of queries. Then $q$ queries follow.

The first line of the query contains two integers $n$ and $k$ ($1 \le k \le n \le 2 \cdot 10^5$) — the number of elements in the array and the number of subsegments, respectively.

The second line of the query contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^9$), where $a_i$ is the $i$-th element of $a$.

It is guaranteed that the sum of $n$ over all queries does not exceed $2 \cdot 10^5$ ($\sum n \le 2 \cdot 10^5$).


-----Output-----

For each query, print the answer to it. If it is impossible to divide the initial array into exactly $k$ subsegments in such a way that each of them will have odd sum of elements, print "NO" in the first line. Otherwise, print "YES" in the first line and any possible division of the array in the second line. The division can be represented as $k$ integers $r_1$, $r_2$, ..., $r_k$ such that $1 \le r_1 < r_2 < \dots < r_k = n$, where $r_j$ is the right border of the $j$-th segment (the index of the last element that belongs to the $j$-th segment), so the array is divided into subsegments $[1; r_1], [r_1 + 1; r_2], [r_2 + 1, r_3], \dots, [r_{k - 1} + 1, n]$. Note that $r_k$ is always $n$ but you should print it anyway. 


-----Example-----
Input
3
5 3
7 18 3 14 1
5 4
1 2 3 4 5
6 2
1 2 8 4 10 2

Output
YES
1 3 5
NO
NO

Difficulty: EASY

Solutions:
tst = int(input())
for _ in range(tst):
	(n, k) = map(int, input().split())
	arr = list(map(int, input().split()))
	if len(arr) == 1 and arr[0] % 2 == 1:
		print('YES')
		print('1')
	elif len(arr) == 1 and arr[0] % 2 != 1:
		print('NO')
	else:
		odd = 0
		even = 0
		for i in arr:
			if i % 2 == 0:
				even += 1
			else:
				odd += 1
		if k % 2 == odd % 2 and k <= odd:
			print('YES')
			count = k
			sumval = 0
			ind = []
			i = 0
			while count > 1 and i < n:
				sumval += arr[i]
				if sumval % 2 != 0:
					ind.append(i + 1)
					count -= 1
					sumval = 0
				i += 1
			ind.append(n)
			print(' '.join(map(str, ind)))
		else:
			print('NO')


import sys
for _ in range(int(input())):
	(n, k) = map(int, sys.stdin.readline().split())
	a = list(map(int, sys.stdin.readline().split()))
	s = sum(a)
	if s % 2 == 0 and k % 2 or (s % 2 and k % 2 == 0):
		print('NO')
	else:
		s = 0
		b = []
		i = 0
		j = 0
		while i < k - 1 and j < n:
			if s % 2 == 0:
				s += a[j]
				j += 1
			else:
				b.append(j)
				s = 0
				i += 1
		b.append(n)
		if len(set(b)) == k:
			print('YES')
			print(*b)
		else:
			print('NO')


import sys

def main():
	input = sys.stdin.readline
	q = int(input())
	for z in range(q):
		(n, k) = map(int, input().split())
		a = list(map(int, input().split()))
		s = [e % 2 for e in a]
		if sum(s) < k:
			print('NO')
		elif k == 1:
			if sum(a) % 2 == 0:
				print('NO')
			else:
				print('YES')
				print(n)
		elif sum(s) % 2 != k % 2:
			print('NO')
		else:
			tsum = 0
			kotae = []
			for y in range(n):
				tsum += s[y]
				if tsum % 2 == 1:
					kotae.append(y + 1)
					tsum = 0
					if len(kotae) == k - 1:
						kotae.append(n)
						print('YES')
						print(*kotae)
main()


from sys import stdin, stdout
t = int(stdin.readline())
for _ in range(t):
	(n, k) = map(int, stdin.readline().split())
	l = list(map(int, stdin.readline().strip().split()))
	count = 0
	(i, m) = (0, 0)
	ans = []
	while i < n:
		if l[i] % 2 == 1:
			ans.append(i + 1)
		i += 1
	if len(ans) >= k and (len(ans) - k) % 2 == 0:
		ans = ans[:k]
		ans[len(ans) - 1] = n
		print('YES')
		print(*ans)
	else:
		print('NO')


for _ in range(int(input())):
	(l, m) = map(int, input().split(' '))
	li = [int(i) for i in input().split()]
	odd = 0
	for i in li:
		if i % 2 == 1:
			odd += 1
	ans = []
	x = m - 1
	if not odd < m:
		if (odd - m) % 2 == 0:
			for i in range(l):
				if li[i] % 2 == 1 and x > 0:
					ans.append(i + 1)
					x -= 1
			ans.append(l)
			print('YES')
			print(*ans)
		else:
			print('NO')
	else:
		print('NO')


t = int(input())
for _ in range(t):
	(n, k) = map(int, input().split())
	z = map(int, input().split())
	a = [x & 1 for x in z]
	if sum(a) < k or sum(a) % 2 != k % 2:
		print('NO')
		continue
	ans = []
	for i in range(n):
		if len(ans) == k - 1:
			break
		if a[i]:
			ans.append(i + 1)
	ans.append(n)
	print('YES')
	print(' '.join(map(str, ans)))


q = int(input())
answer = []
for _ in range(q):
	(n, k) = [int(x) for x in input().split()]
	odds = []
	nums = [int(x) for x in input().split()]
	for i in range(n):
		if nums[i] % 2 == 1:
			odds.append(i)
	if len(odds) < k or (len(odds) - k) % 2 == 1:
		answer.append('NO')
	else:
		result = []
		for i in range(k - 1):
			result.append(odds[i] + 1)
		result.append(n)
		answer.append('YES')
		answer.append(' '.join([str(x) for x in result]))
print('\n'.join(answer))


for _ in range(int(input())):
	(x, y) = map(int, input().split())
	(*li,) = map(int, input().split())
	li1 = [i + 1 for i in range(x) if li[i] % 2]
	cnt = len(li1)
	if cnt < y or (cnt - y) % 2:
		print('NO')
		continue
	print('YES')
	print(*li1[:y - 1], x)


import sys
t = int(input())
for z in range(t):
	(n, k) = map(int, sys.stdin.readline().split())
	a = list(map(int, sys.stdin.readline().split()))
	c = 0
	b = []
	for i in range(n):
		if a[i] % 2 != 0:
			c += 1
			b.append(i + 1)
	if c < k or c % 2 != k % 2:
		print('NO')
		continue
	print('YES')
	b = b[:k]
	b[len(b) - 1] = n
	print(*b)


import sys
import os
from io import IOBase, BytesIO
import math
import collections
mod = 10 ** 9 + 7
pie = 3.1415926536

def modinv(n, p):
	return pow(n, p - 2, p)

def ncr(n, r, p):
	t = fact[n] * (ifact[r] * ifact[n - r] % p) % p
	return t

def ain():
	return list(map(int, sin().split()))

def sin():
	return input().strip()

def GCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def read2DIntArray(row, col):
	arr = []
	for i in range(0, row):
		temp = list(map(int, sin().split()))
		arr.append(temp)
	return arr

def read2DCharArray(row, col):
	arr = []
	for i in range(0, row):
		temp = str(sin())
		arr.append(temp)
	return arr

def smallestNumber(n):
	lst = list(str(n))
	lst.sort()
	tmp = ''
	for (i, n) in enumerate(lst):
		if n != '0':
			tmp = lst.pop(i)
			break
	return str(tmp) + ''.join(lst)

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 1
	prime[0] = False
	prime[1] = False
	lst = []
	for p in range(n + 1):
		if prime[p]:
			lst.append(p)
	return lst

def nCr(n, r):
	a = 1
	b = 1
	c = 1
	for i in range(1, n + 1):
		c *= i
	for i in range(1, r + 1):
		b *= i
	for i in range(1, n - r + 1):
		a *= i
	return c // (a * b)

def sieveOfEratosthenes1(N, s):
	prime = [False] * (N + 1)
	for i in range(2, N + 1, 2):
		s[i] = 2
	for i in range(3, N + 1, 2):
		if prime[i] == False:
			s[i] = i
			for j in range(i, int(N / i) + 1, 2):
				if prime[i * j] == False:
					prime[i * j] = True
					s[i * j] = i

def generatePrimeFactors(N):
	s = [0] * (N + 1)
	sieveOfEratosthenes1(N, s)
	curr = s[N]
	cnt = 1
	factors = []
	power = []
	while N > 1:
		N //= s[N]
		if curr == s[N]:
			cnt += 1
			continue
		factors.append(curr)
		power.append(cnt)
		curr = s[N]
		cnt = 1
	return (factors, power)

def main():
	for _ in range(int(sin())):
		(n, k) = map(int, sin().split())
		a = ain()
		o = 0
		lst = []
		for i in range(n):
			if a[i] % 2 != 0:
				o += 1
				lst.append(i + 1)
		if o >= k and o % 2 == k % 2:
			print('YES')
			lst = lst[:k - 1]
			lst.append(n)
			print(*lst)
		else:
			print('NO')
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')
main()


import atexit
import io
import sys
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER

@atexit.register
def write():
	sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
t = int(input())
while t > 0:
	t -= 1
	(n, k) = list(map(int, input().split()))
	v = list(map(int, input().split()))
	cont = 0
	impares = 0
	ans = []
	for i in range(len(v)):
		if v[i] % 2 != 0:
			impares += 1
			ans.append(i + 1)
	if impares < k:
		print('NO')
	else:
		impares -= k
		if impares % 2 != 0:
			print('NO')
		else:
			print('YES')
			for i in range(k - 1):
				print(f'{ans[i]}', end=' ')
			print(f'{n}')


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	arr = list(map(int, input().split()))
	odd = 0
	even = 0
	vec = []
	sum = 0
	for i in range(n):
		sum += arr[i]
		if k != 1 and sum % 2 != 0:
			vec.append(i + 1)
			k -= 1
			sum = 0
	if k != 1 or sum % 2 == 0:
		print('NO')
	else:
		print('YES')
		for i in vec:
			print(i, end=' ')
		print(n)


def f(l1, l):
	(n, k) = l1
	if sum(l) % 2 != k % 2:
		return [['NO']]
	dl = []
	s = 0
	for i in range(n):
		s += l[i]
		if s % 2 > 0:
			if len(dl) == k - 1:
				break
			dl.append(i + 1)
			s = 0
	if len(dl) == 0 or dl[-1] < n:
		dl.append(n)
	return [['NO']] if len(dl) < k else [['YES'], dl]
q = int(input())
for _ in range(q):
	l1 = list(map(int, input().split()))
	l2 = list(map(int, input().split()))
	[print(*r) for r in f(l1, l2)]


from sys import stdin, stdout
import collections
Q = int(input())
for i in range(Q):
	(N, K) = [int(x) for x in stdin.readline().split()]
	arr = [int(x) for x in stdin.readline().split()]
	odds = 0
	for i in range(N):
		if arr[i] % 2 == 1:
			odds += 1
	if odds < K:
		print('NO')
		continue
	elif (odds - K) % 2 == 1:
		print('NO')
		continue
	three = (odds - K) // 2
	print('YES')
	odds = 0
	if K == 1:
		print(N)
		continue
	for i in range(N):
		if arr[i] % 2 == 1:
			odds += 1
		if three > 0 and odds != 3:
			continue
		elif three > 0 and odds == 3:
			K -= 1
			print(i + 1, end=' ')
			three -= 1
			odds = 0
		elif three == 0 and odds == 1:
			K -= 1
			print(i + 1, end=' ')
			odds = 0
		if K == 1:
			break
	print(N, end='\n')


import sys
inf = sys.stdin
lines = inf.readlines()
q = int(lines[0])
for tests in range(q):
	(n, k) = (int(val) for val in lines[2 * tests + 1].split())
	candy = [int(val) for val in lines[2 * tests + 2].split()]
	odds = 0
	for i in candy:
		if i % 2 == 1:
			odds += 1
	if odds < k or sum(candy) % 2 != k % 2:
		print('NO')
	else:
		print('YES')
		count = 1
		for i in range(len(candy)):
			if count >= k:
				print(n)
				break
			if candy[i] % 2 == 1:
				print(i + 1, end=' ')
				count += 1


q = int(input())
answer = []
for i in range(q):
	(n, k) = map(int, input().split())
	array = list(map(int, input().split()))
	count = 0
	ansar = []
	for i in range(n):
		if array[i] % 2 == 1:
			count += 1
			ansar.append(str(i + 1))
	if k > count:
		answer.append('NO')
		continue
	elif k == count:
		answer.append('YES\n' + ' '.join(ansar[:count - 1] + [str(n)]))
		continue
	elif (count - k + 1) % 2 == 0:
		answer.append('NO')
		continue
	else:
		ans = ansar[count - k:count]
		ans[-1] = str(n)
		answer.append('YES\n' + ' '.join(ans))
print('\n'.join(answer))


import sys
input = sys.stdin.readline
Q = int(input())

def calc(n, k, X):
	if (sum(X) - k) % 2:
		print('NO')
		return 0
	ANS = []
	if k == 1:
		print('YES')
		print(n)
		return 0
	for i in range(N - 1):
		if X[i] % 2:
			ANS.append(i + 1)
			if len(ANS) == k - 1:
				print('YES')
				print(*ANS, n)
				return 0
	else:
		print('NO')
for _ in range(Q):
	(N, K) = list(map(int, input().split()))
	calc(N, K, [int(a) for a in input().split()])


s = int(input())
for _ in range(s):
	(n, k) = list(map(int, input().split()))
	if n == 1:
		a = list(map(int, input().split()))
		if a[0] % 2 == 1:
			print('YES')
			print(1)
		else:
			print('NO')
	else:
		a = list(map(int, input().split()))
		b = [i + 1 for i in range(n) if a[i] % 2 == 1]
		l = len(b)
		if l >= k:
			if (l - k) % 2 == 1:
				print('NO')
			else:
				print('YES')
				print(*b[:k - 1], n)
		else:
			print('NO')


import sys
input = sys.stdin.readline
q = int(input())
for i in range(q):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	odd = 0
	for j in range(n):
		if a[j] % 2 != 0:
			odd += 1
	if odd < k:
		print('NO')
	elif odd > k and (odd - k) % 2 != 0:
		print('NO')
	else:
		print('YES')
		ans = []
		for j in range(n):
			if len(ans) == k - 1:
				ans.append(n)
				break
			if a[j] % 2 != 0:
				ans.append(j + 1)
		print(*ans)


import sys
q = int(sys.stdin.readline())
for _ in range(q):
	(n, k) = map(int, sys.stdin.readline().split())
	a = list(map(int, sys.stdin.readline().split()))
	odds = 0
	for i in range(n):
		if a[i] % 2 != 0:
			odds += 1
	if odds >= k:
		if odds % 2 != 0 and k % 2 != 0:
			if k == 1:
				print('YES')
				print(len(a))
			else:
				print('YES')
				res = []
				for i in range(n):
					if k == 1:
						break
					if a[i] % 2 != 0:
						res.append(i + 1)
						k -= 1
				res.append(len(a))
				res = ' '.join(map(str, res))
				print(res)
		elif odds % 2 == 0 and k % 2 == 0:
			if k == 1:
				print('YES')
				print(len(a))
			else:
				print('YES')
				res = []
				for i in range(n):
					if k == 1:
						break
					if a[i] % 2 != 0:
						res.append(i + 1)
						k -= 1
				res.append(len(a))
				res = ' '.join(map(str, res))
				print(res)
		else:
			print('NO')
	else:
		print('NO')


from sys import stdin, stdout
riga = stdin.readline()
query = int(riga)
for i in range(query):
	riga = stdin.readline()
	test = riga.split()
	n = int(test[0])
	k = int(test[1])
	riga = stdin.readline()
	test = riga.split()
	numeri = []
	conta_dispari = 0
	for j in range(n):
		numeri.append(int(test[j]))
		conta_dispari = conta_dispari + numeri[j] % 2
	if conta_dispari < k or conta_dispari % 2 != k % 2:
		stdout.write('NO' + '\n')
	else:
		stdout.write('YES' + '\n')
		j = 0
		trovati = 0
		while trovati != k - 1:
			if numeri[j] % 2 == 1:
				stdout.write(str(j + 1) + ' ')
				trovati = trovati + 1
			j = j + 1
		stdout.write(str(n) + '\n')


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	l = []
	for i in range(n):
		if a[i] % 2 == 1:
			l.append(i + 1)
	if len(l) < k or (len(l) - k) % 2 == 1:
		print('NO')
	else:
		print('YES')
		print(*l[:k - 1] + [n])


import sys
import os
import math
import copy
from math import gcd
from bisect import bisect
from io import BytesIO, IOBase
from math import sqrt, floor, factorial, gcd, log, ceil
from collections import deque, Counter, defaultdict
from itertools import permutations, combinations

def Int():
	return int(sys.stdin.readline())

def Mint():
	return map(int, sys.stdin.readline().split())

def Lstr():
	return list(sys.stdin.readline().strip())

def Str():
	return sys.stdin.readline().strip()

def Mstr():
	return map(str, sys.stdin.readline().strip().split())

def List():
	return list(map(int, sys.stdin.readline().split()))

def Hash():
	return dict()

def Mod():
	return 1000000007

def Ncr(n, r, p):
	return fact[n] * (ifact[r] * ifact[n - r] % p) % p

def Most_frequent(list):
	return max(set(list), key=list.count)

def Mat2x2(n):
	return [List() for _ in range(n)]

def Prime_factors(n):
	i = 2
	factors = set()
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			factors.add(i)
	if n > 1:
		factors.add(n)
	print(factors)
	if len(factors) == 2:
		return True
	else:
		return False

def Divisors(n):
	l = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
	return l

def Sieve(n):
	prime = [True for i in range(n + 1)]
	lst = []
	p = 2
	while p * p <= n:
		if prime[p]:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p = p + 1
	for i in range(2, n + 1):
		if prime[i]:
			lst.append(i)
	return lst

def minimum_integer_not_in_list(a):
	b = max(a)
	if b < 1:
		return 1
	A = set(a)
	B = set(range(1, b + 1))
	D = B - A
	if len(D) == 0:
		return b + 1
	else:
		return min(D)

def solution():
	for _ in range(Int()):
		(n, k) = Mint()
		a = List()
		odd = 0
		iodd = []
		for i in range(n):
			if a[i] % 2 == 1:
				odd += 1
				iodd.append(i + 1)
		if odd < k:
			print('NO')
		elif k % 2 == 0 and odd % 2 != 0 or (k % 2 != 0 and odd % 2 == 0):
			print('NO')
		else:
			print('YES')
			print(*iodd[0:k - 1], n)
solution()


q = int(input())
for _ in range(q):
	(n, k) = map(int, input().split())
	a = [int(x) for x in input().split()]
	r = []
	for i in range(n):
		if a[i] % 2 != 0:
			r.append(i + 1)
	temp = len(r)
	if k > temp:
		print('NO')
	elif (temp - k + 1) % 2 != 0:
		print('YES')
		for i in range(k - 1):
			print(r[i], end=' ')
		print(n)
	else:
		print('NO')


from sys import stdin, stdout
input = stdin.readline
print = stdout.write
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	arr = list(map(int, input().split()))
	ans = []
	cnt = 0
	for i in range(n):
		if arr[i] % 2 == 1:
			ans.append(i + 1)
			cnt += 1
	if cnt < k:
		print('NO\n')
	elif (cnt - (k - 1)) % 2 == 1:
		print('YES\n')
		for i in ans[:k - 1]:
			print('%d ' % i)
		print('%d\n' % n)
	else:
		print('NO\n')


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	ans = []
	z = k
	i = 0
	while i < n:
		if a[i] % 2 != 0:
			ans.append(i + 1)
			k -= 1
		i += 1
		if k == 0:
			if ans[-1] != n:
				ans.pop()
				ans.append(n)
			break
	s = 0
	ok = True
	if k == 0 and len(ans) == z:
		if len(ans) == 1:
			for i in range(ans[0]):
				s += a[i]
		else:
			for i in range(ans[-2], ans[-1]):
				s += a[i]
		if s % 2 == 0:
			ok = False
	else:
		ok = False
	if ok:
		print('YES')
		print(*ans)
	else:
		print('NO')


import sys
q = int(input())
result = []
for _ in range(q):
	(n, k) = map(int, input().split())
	lst = list(map(int, next(sys.stdin).split(' ')))
	c_odd = 0
	for i in lst:
		if i % 2 == 1:
			c_odd += 1
	if c_odd < k or c_odd % 2 != k % 2:
		result.append('NO')
	else:
		result.append('YES')
		buff = []
		for (i, a) in enumerate(lst, start=1):
			if k == 1:
				break
			if a % 2 == 1:
				buff.append(str(i))
				k -= 1
		buff.append(str(n))
		result.append(' '.join(buff))
print('\n'.join(result))


import sys
input = sys.stdin.readline
for i in range(int(input())):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	ans = []
	c = 0
	for x in range(n):
		if a[x] & 1:
			ans.append(x + 1)
			c += 1
	if c < k or c - k & 1:
		print('NO')
	else:
		print('YES')
		for x in range(k - 1):
			print(ans[x], end=' ')
		print(n)


import time
import sys
start = time.time()
q = int(sys.stdin.readline().rstrip())
for i in range(0, q):
	ns = [int(j) for j in sys.stdin.readline().rstrip().split(' ')]
	n = ns[0]
	k = ns[1]
	ln = [int(j) for j in sys.stdin.readline().rstrip().split(' ')]
	if len(ln) == 1:
		if ln[0] % 2 == 1:
			print('YES')
			print(1)
		else:
			print('NO')
		continue
	cc = 1
	inc = 0
	inds = []
	for j in range(0, len(ln)):
		if ln[j] % 2 == 1:
			if inc < k - 1:
				inc += 1
				inds.append(j + 1)
			elif inc < k:
				inc += 1
			else:
				cc += 1
	if inc < k or cc % 2 == 0:
		print('NO')
	else:
		inds.append(n)
		print('YES')
		print(' '.join([str(j) for j in inds]))


def main():
	import sys
	input = sys.stdin.readline

	def solve():
		(n, k) = map(int, input().split())
		arr = list(map(int, input().split()))
		curr = 0
		ans = []
		for i in range(n):
			curr += arr[i]
			if curr & 1:
				curr = 0
				ans.append(i + 1)
		if len(ans) < k or len(ans) - k & 1:
			print('NO')
		else:
			print('YES')
			print(*ans[:k - 1] + [n])
	for _ in range(int(input())):
		solve()
	return 0
main()


import sys
for z in range(int(input())):
	(n, k) = map(int, sys.stdin.readline().split())
	a = list(map(int, sys.stdin.readline().split()))
	c = 0
	for i in range(n):
		if a[i] % 2 == 1:
			c += 1
	if c < k or (c - k) % 2 == 1:
		print('NO')
	else:
		print('YES')
		co = 0
		for i in range(n):
			if a[i] % 2 == 1 and co < k - 1:
				print(i + 1, end=' ')
				co += 1
			if co == k - 1:
				break
		print(n)


import sys
input = sys.stdin.readline
t = int(input())
while t:
	(n, k) = map(int, input().split())
	l = list(map(int, input().split()))
	ll = []
	cou = 0
	ind = -1
	for i in range(n):
		if l[i] % 2:
			cou += 1
			if cou < k:
				ll.append(i + 1)
	ll.append(n)
	if cou >= k and (cou - k) % 2 == 0:
		print('YES')
		print(*ll)
	else:
		print('NO')
	t -= 1


import sys
t = int(input())
for i in range(t):
	(n, k) = map(int, input().split(' '))
	array = list(map(int, sys.stdin.readline().split()))
	location = [i + 1 for i in range(n) if array[i] % 2 == 1]
	if len(location) < k or (len(location) - k) % 2 != 0:
		print('NO')
		continue
	else:
		print('YES')
		print(*location[:k - 1] + [n])


import sys
input = sys.stdin.readline
ins = lambda : input().rstrip()
ini = lambda : int(input().rstrip())
inm = lambda : map(int, input().split())
inl = lambda : list(map(int, input().split()))
t = ini()
for _ in range(t):
	(n, k) = inm()
	a = inl()
	odd = 0
	index = []
	for i in range(n):
		if a[i] % 2 != 0:
			odd += 1
			index.append(i + 1)
	if odd < k:
		print('NO')
	elif odd == k or (odd - k + 1) % 2 != 0:
		print('YES')
		if k == 1:
			print(n)
		else:
			print(*index[:k - 1], n)
	else:
		print('NO')


from sys import *
input = stdin.buffer.readline
for u in range(int(input())):
	(n, k) = map(int, input().split())
	l = list(map(int, input().split()))
	d = []
	for i in range(n):
		if l[i] % 2 == 1:
			d.append(i + 1)
	if len(d) >= k and (len(d) - k) % 2 == 0:
		print('YES')
		print(*d[:k - 1], n)
	else:
		print('NO')


q = int(input())
ans = []
for i in range(q):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	t = 0
	u = 0
	an = []
	for i in range(n):
		if a[i] % 2 == 1:
			t += 1
			an.append(i + 1)
	if t < k or k % 2 != t % 2:
		ans.append('NO')
	else:
		ans.append('YES')
		ans.append([n, k])
		ans.append(an)
i = 0
while i < len(ans):
	if ans[i] == 'NO':
		print('NO')
	else:
		print(ans[i])
		i += 1
		(n, k) = ans[i]
		i += 1
		for j in range(k - 1):
			print(str(ans[i][j]) + ' ', end='')
		print(n)
	i += 1


import sys
t = int(input())
for i in range(t):
	(n, k) = map(int, sys.stdin.readline().split())
	a = list(map(int, sys.stdin.readline().split()))
	s = [i for i in range(len(a)) if a[i] % 2 != 0]
	ln = len(s)
	if ln == k:
		print('YES')
		for i in range(k - 1):
			print(s[i] + 1, end=' ')
		print(n)
	elif ln > k:
		dif = ln - k
		if dif % 2 == 0:
			print('YES')
			for i in range(k - 1):
				print(s[i] + 1, end=' ')
			print(n)
		else:
			print('NO')
	else:
		print('NO')


false = False
true = True
null = None
TEST = false
try:
	import sys
	for arg in sys.argv:
		if arg == 'test':
			print('test mode')
			TEST = True
	pass
except:
	pass

def AddImports(libraryNames):
	for libname in libraryNames:
		if type(libname) == type(tuple()):
			short = libname[1]
			libname = libname[0]
		else:
			short = None
		try:
			lib = __import__(libname)
		except ImportError:
			pass
		else:
			if short:
				globals()[short] = lib
			else:
				globals()[libname] = lib
	return True
libnames = ['functools', 'math', 'collections']
AddImports(libnames)
IntellisenseHint = False
if IntellisenseHint:
	import functools
	import math
	import collections

def it(args):
	if TEST:
		print(args)

def floatEqual(a, b):
	diff = math.fabs(a - b)
	if diff < 1e-10:
		return True
	else:
		return diff <= 1e-08 * max(math.fabs(a), math.fabs(b))

def ria():
	return list(map(int, input().split(' ')))
from sys import stdin
input = stdin.readline

def solve():
	q = int(input())
	for i in range(q):
		[n, k] = ria()
		arr = ria()
		cands = []
		oddsCount = 0
		candCount = 0
		for (j, a) in enumerate(arr, start=1):
			if a % 2 == 1:
				oddsCount += 1
				if candCount < k - 1:
					candCount += 1
					cands.append(j)
				pass
		cands.append(n)
		if k <= oddsCount and (oddsCount - k) % 2 == 0:
			print('YES')
			print(' '.join(map(str, cands)))
		else:
			print('NO')
			pass
		pass
	pass
solve()


from sys import stdin

def iinput():
	return int(stdin.readline())

def minput():
	return map(int, stdin.readline().split())

def linput():
	return list(map(int, stdin.readline().split()))
t = iinput()
while t:
	t -= 1
	(n, k) = minput()
	a = linput()
	odd = 0
	for e in a:
		if e & 1:
			odd += 1
	if odd < k or (odd > k and odd - k & 1):
		print('NO')
	else:
		x = []
		c = 0
		for i in range(n):
			if a[i] & 1:
				c += 1
				if c == k:
					x.append(n)
					break
				else:
					x.append(i + 1)
		print('YES')
		print(*x)


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	odd_count = len([1 for x in a if x % 2])
	if k > odd_count or k % 2 != odd_count % 2:
		print('NO')
		continue
	ans = []
	i = 0
	while len(ans) < k - 1:
		while a[i] % 2 == 0:
			i += 1
		i += 1
		ans.append(i)
	ans.append(n)
	print('YES')
	print(*ans)


import sys
Input = lambda : map(int, sys.stdin.readline().split())
for i in range(int(input())):
	(n, k) = Input()
	a = list(Input())
	t = 0
	ans = list()
	for j in range(n):
		if a[j] % 2 == 1:
			t += 1
			ans.append(j + 1)
	if t < k:
		print('NO')
	elif t > k:
		w = t - k
		if w % 2 == 1:
			print('NO')
		else:
			print('YES')
			print(*ans[:k - 1], n)
	else:
		print('YES')
		ans.pop(-1)
		ans.append(n)
		print(*ans)


import sys
q = int(input())
for _ in range(q):
	(n, k) = map(int, input().split())
	nums = list(map(int, sys.stdin.readline().split()))
	cntodd = 0
	for x in nums:
		if x % 2 == 1:
			cntodd += 1
	if cntodd < k or cntodd % 2 != k % 2:
		sys.stdout.write('NO\n')
	else:
		sys.stdout.write('YES\n')
		for i in range(n):
			if k == 1:
				break
			if nums[i] % 2 == 1:
				sys.stdout.write(str(i + 1) + ' ')
				k -= 1
		sys.stdout.write(str(n) + '\n')


import sys
input = sys.stdin.readline

def print(val):
	sys.stdout.write(val)
	sys.stdout.write('\n')
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	total = sum(a)
	if k % 2 == 0 and total % 2 == 1:
		print('NO')
	elif k % 2 == 1 and total % 2 == 0:
		print('NO')
	else:
		ans = []
		curr = 0
		for i in range(n):
			if k == 0:
				break
			curr += a[i]
			if curr % 2 == 1:
				ans.append(i + 1)
				curr = 0
				k -= 1
		if k == 0:
			ans[-1] = n
			print('YES')
			print(' '.join(map(str, ans)))
		else:
			print('NO')


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	l = list(map(int, input().split()))
	c = 0
	l1 = []
	for i in range(n):
		if l[i] % 2 == 1:
			l1.append(i + 1)
			c += 1
	p = c - k
	if p % 2 == 0 and p >= 0:
		print('YES')
		l2 = l1[:k - 1] + [n]
		print(*l2)
	else:
		print('NO')


q = int(input())
for _ in range(q):
	(n, k) = map(int, input().split())
	arr = list(map(int, input().split()))
	if n == 1 and k == 1 and (arr[0] % 2 == 1):
		print('YES')
		print('1')
		continue
	kmax = []
	for (i, x) in enumerate(arr):
		if x % 2:
			kmax.append(i + 1)
		if len(kmax) == k:
			break
	if len(kmax) == k and sum(arr[kmax[-1]:]) % 2 == 0:
		print('YES')
		if kmax[-1] != n:
			kmax[-1] = n
		print(' '.join(map(str, kmax)))
	else:
		print('NO')


import sys
input = sys.stdin.readline
q = int(input())
(n, k) = (0, 0)
a = 0
(s, t) = (0, 0)
b = 0
j = 0
for i in range(q):
	(n, k) = map(int, input().split())
	a = [int(j) % 2 for j in input().split()]
	s = sum(a)
	b = []
	if s >= k and (s - k) % 2 == 0:
		print('YES')
		for j in range(n):
			if k == 1:
				break
			if a[j] == 1:
				k -= 1
				b.append(j + 1)
		b.append(n)
		print(*b)
	else:
		print('NO')


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	r = []
	o = 0
	for i in range(n):
		if a[i] % 2 == 1:
			if o < k - 1:
				r.append(i + 1)
			o += 1
	if o >= k and (o - (k - 1)) % 2 == 1:
		r.append(n)
		print('YES')
		print(*r)
	else:
		print('NO')


from sys import stdin
for _ in range(int(stdin.readline())):
	(n, k) = map(int, stdin.readline().split())
	l = [int(i) for i in stdin.readline().split()]
	odd = sum((i % 2 == 1 for i in l))
	if odd < k or odd - k & 1:
		print('NO')
	else:
		extra = odd - k
		if extra & 1 == 0:
			cnt = 0
			print('YES')
			for i in range(n):
				if l[i] & 1:
					cnt += 1
					if cnt == k:
						break
					print(i + 1, end=' ')
			print(n)


def solve(A, k):
	odd_num = 0
	R = []
	for i in range(len(A)):
		if A[i] % 2 == 1:
			odd_num += 1
			if len(R) < k - 1:
				R.append(i + 1)
	if odd_num < k or (odd_num - k) % 2 != 0:
		return []
	R.append(len(A))
	return R
q = int(input())
Rs = []
for _ in range(q):
	(n, k) = (int(i) for i in input().split())
	A = [int(i) for i in input().split()]
	Rs.append(solve(A, k))
for R in Rs:
	if len(R) == 0:
		print('NO', flush=True)
	else:
		print('YES', flush=True)
		print(*R)


from sys import *
fi = lambda : stdin.readline()
for _ in range(int(fi())):
	(n, k) = map(int, fi().split())
	l = list(map(int, fi().split()))
	p = []
	t = 0
	for i in range(n):
		if l[i] % 2:
			t += 1
			p.append(i + 1)
	if t % 2 != k % 2 or t < k:
		print('NO')
	else:
		print('YES')
		for i in range(k - 1):
			print(p[i], end=' ')
		print(n)


import sys

class BOddSumSegments:

	def solve(self):
		q = int(input())
		for _ in range(q):
			(n, k) = [int(_) for _ in input().split()]
			a = [int(_) for _ in input().split()]
			even = 0
			odd = 0
			i = 0
			even_a = []
			odd_a = []
			while i < n:
				j = i
				if a[j] % 2 == 1:
					odd += 1
					odd_a.append(j)
					j += 1
					i = j
					continue
				even_a.append(j)
				while j < n and a[j] % 2 == 0:
					j += 1
				even += 1
				i = j
			if k <= odd:
				if (odd - k) % 2 == 0:
					print('YES')
					ans = [x + 1 for x in odd_a[-k:-1]] + [n]
					print(*ans)
				else:
					print('NO')
			else:
				print('NO')
solver = BOddSumSegments()
input = sys.stdin.readline
solver.solve()


t = int(input())
for i in range(t):
	s = [int(n) for n in input().split()]
	num = [int(m) for m in input().split()]
	if len(num) == 1 and s[1] == 1:
		if num[0] % 2 != 0:
			print('YES')
			print('1')
		else:
			print('NO')
	else:
		c = 0
		index = []
		for j in range(len(num)):
			if num[j] % 2 != 0:
				c = c + 1
				index.append(j + 1)
		index = index[::-1]
		if c < s[1] or s[1] % 2 != c % 2:
			print('NO')
		else:
			print('YES')
			if s[1] > 1:
				print(*index[1:s[1]][::-1], sep=' ', end=' ')
			print(s[0])


for w in range(int(input())):
	(n, k) = tuple(map(int, input().split()))
	a = list(map(int, input().split()))
	b = [0] * n
	count = 0
	t = 0
	l = []
	for i in range(n):
		if a[i] % 2 != 0:
			count += 1
			b[i] = 1
	if k > count:
		print('NO')
	elif k == 1:
		if count % 2 != 0:
			print('YES')
			print(n)
		else:
			print('NO')
	else:
		y = k - 1
		if k % 2 != 0 and count % 2 != 0 or (k % 2 == 0 and count % 2 == 0):
			print('YES')
			for i in range(n):
				if y > 0:
					if b[i] == 1:
						print(i + 1, end=' ')
						y -= 1
				else:
					break
			print(n)
		else:
			print('NO')


import sys
for i in range(int(input())):
	(amount, subsequence) = [int(x) for x in sys.stdin.readline().split()]
	array = [int(x) for x in sys.stdin.readline().split()]
	something = []
	for i in range(amount):
		if array[i] % 2 != 0:
			something.append(i + 1)
	if len(something) < subsequence:
		print('NO')
	elif len(something) % 2 == subsequence % 2:
		print('YES')
		print(*something[:subsequence - 1] + [amount])
	else:
		print('NO')


from sys import stdin, stdout, exit
q = int(input())
for it in range(q):
	(n, k) = map(int, stdin.readline().split())
	kk = k
	a = list(map(int, stdin.readline().split()))
	s = 0
	ans = []
	for i in range(n):
		s += a[i] % 2
		s %= 2
		if s % 2 == 1:
			s = 0
			k -= 1
			ans.append(i)
	if k > 0 or sum(a) % 2 != kk % 2:
		stdout.write('NO\n')
	else:
		stdout.write('YES\n')
		for arr in ans[:k - 1]:
			stdout.write(str(arr + 1) + ' ')
		stdout.write(str(n) + '\n')


import sys
input = sys.stdin.readline

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def nCr(n, k):
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return res

def upper_bound(a, x, lo=0):
	hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(1000000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def factoriazation(x):
	ret = {}
	while x != 1:
		ret[spf[x]] = ret.get(spf[x], 0) + 1
		x = x // spf[x]
	return ret

def int_array():
	return list(map(int, input().strip().split()))

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
for _ in range(int(input())):
	(n, k) = int_array()
	a = int_array()
	total = sum(a)
	f = 0
	ans = []
	cunt = 0
	sam = 0
	for i in range(n):
		if len(ans) == k - 1:
			if total % 2 != 0:
				ans.append(n)
			break
		sam += a[i]
		cunt += 1
		if sam % 2 != 0:
			if len(ans) != k - 1:
				ans.append(i + 1)
				total -= sam
				sam = cunt = 0
	if len(ans) == k:
		print('YES')
		print(*ans)
	else:
		print('NO')


import sys
n_cases = int(sys.stdin.readline())
for i in range(n_cases):
	(n, k) = [int(i) for i in sys.stdin.readline().split()]
	array = [int(i) for i in sys.stdin.readline().split()]
	pair = array[:]
	count_ones = 0
	for j in range(n):
		if array[j] % 2 == 1:
			pair[j] = 1
			count_ones += 1
		else:
			pair[j] = 0
	if count_ones < k:
		print('NO')
	elif (count_ones - k) % 2 == 1:
		print('NO')
	else:
		print('YES')
		zero = False
		count_1 = 0
		lista = []
		times = 0
		for j in range(n):
			if pair[j] == 1 and times < k - 1:
				lista.append(j + 1)
				times += 1
		lista.append(n)
		print(' '.join([str(x) for x in lista]))


t = int(input())
for _ in range(t):
	(n, k) = map(int, input().split())
	lst = list(map(int, input().split()))[:n]
	r = 0
	ind = []
	for i in range(n):
		if lst[i] % 2 != 0:
			r = r + 1
			ind.append(i + 1)
	if r == k:
		print('YES')
		for i in range(k - 1):
			print(ind[i], end=' ')
		print(n)
	elif r >= k:
		if (r - (k - 1)) % 2 != 0:
			print('YES')
			for i in range(k - 1):
				print(ind[i], end=' ')
			print(n)
		else:
			print('NO')
	else:
		print('NO')


import sys
input = sys.stdin.readline
q = int(input())
for _ in range(q):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	sum1 = 0
	for i in range(len(a)):
		a[i] = a[i] % 2
		sum1 += a[i]
	if sum1 < k or abs(sum1 - k) % 2 == 1:
		print('NO')
	else:
		print('YES')
		l = []
		l.append(len(a))
		k -= 1
		for i in range(len(a)):
			if a[i] == 1 and k > 0:
				l.append(i + 1)
				k -= 1
		l.sort()
		print(*l)


import sys
I = lambda : map(int, sys.stdin.readline().split())
for _ in range(int(input())):
	(n, m) = I()
	li = [0] + list(I())
	t = 0
	su = 0
	answer = []
	for (i, j) in enumerate(li):
		if t != m - 1:
			if (su + j) % 2 == 1:
				answer.append(i)
				t += 1
				su = 0
			else:
				su = su + j
		else:
			su += j
	if t == m - 1 and su % 2 == 1:
		answer.append(n)
		print('YES')
		print(*answer)
	else:
		print('NO')


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	p = 0
	pos = []
	for i in range(n):
		if a[i] & 1:
			p += 1
			pos.append(i + 1)
	if p < k:
		print('NO')
	elif p >= k:
		if p - k & 1:
			print('NO')
		else:
			pos[k - 1] = n
			print('YES')
			print(*pos[:k])


from sys import stdin, stdout
import cProfile, math
from collections import Counter, defaultdict, deque
from bisect import bisect_left, bisect, bisect_right
import itertools
from copy import deepcopy
from fractions import Fraction
import sys, threading
import operator as op
from functools import reduce
sys.setrecursionlimit(10 ** 6)
threading.stack_size(2 ** 27)
fac_warmup = False
printHeap = str()
memory_constrained = False
P = 10 ** 9 + 7
import sys

class merge_find:

	def __init__(self, n):
		self.parent = list(range(n))
		self.size = [1] * n
		self.num_sets = n
		self.lista = [[_] for _ in range(n)]

	def find(self, a):
		to_update = []
		while a != self.parent[a]:
			to_update.append(a)
			a = self.parent[a]
		for b in to_update:
			self.parent[b] = a
		return self.parent[a]

	def merge(self, a, b):
		a = self.find(a)
		b = self.find(b)
		if a == b:
			return
		if self.size[a] < self.size[b]:
			(a, b) = (b, a)
		self.num_sets -= 1
		self.parent[b] = a
		self.size[a] += self.size[b]
		self.lista[a] += self.lista[b]

	def set_size(self, a):
		return self.size[self.find(a)]

	def __len__(self):
		return self.num_sets

def display(string_to_print):
	stdout.write(str(string_to_print) + '\n')

def primeFactors(n):
	factors = dict()
	for i in range(2, math.ceil(math.sqrt(n)) + 1):
		while n % i == 0:
			if i in factors:
				factors[i] += 1
			else:
				factors[i] = 1
			n = n // i
	if n > 2:
		factors[n] = 1
	return factors

def all_factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))

def fibonacci_modP(n, MOD):
	if n < 2:
		return 1
	return (cached_fn(fibonacci_modP, (n + 1) // 2, MOD) * cached_fn(fibonacci_modP, n // 2, MOD) + cached_fn(fibonacci_modP, (n - 1) // 2, MOD) * cached_fn(fibonacci_modP, (n - 2) // 2, MOD)) % MOD

def factorial_modP_Wilson(n, p):
	if p <= n:
		return 0
	res = p - 1
	for i in range(n + 1, p):
		res = res * cached_fn(InverseEuler, i, p) % p
	return res

def binary(n, digits=20):
	b = bin(n)[2:]
	b = '0' * (digits - len(b)) + b
	return b

def isprime(n):
	if n < 4:
		return True
	if n % 2 == 0:
		return False
	if n % 3 == 0:
		return False
	i = 5
	w = 2
	while i * i <= n:
		if n % i == 0:
			return False
		i += w
		w = 6 - w
	return True

def generate_primes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 1
	return prime
factorial_modP = []

def warm_up_fac(MOD):
	global factorial_modP, fac_warmup
	if fac_warmup:
		return
	factorial_modP = [1 for _ in range(fac_warmup_size + 1)]
	for i in range(2, fac_warmup_size):
		factorial_modP[i] = factorial_modP[i - 1] * i % MOD
	fac_warmup = True

def InverseEuler(n, MOD):
	return pow(n, MOD - 2, MOD)

def nCr(n, r, MOD):
	global fac_warmup, factorial_modP
	if not fac_warmup:
		warm_up_fac(MOD)
		fac_warmup = True
	return factorial_modP[n] * (pow(factorial_modP[r], MOD - 2, MOD) * pow(factorial_modP[n - r], MOD - 2, MOD) % MOD) % MOD

def test_print(*args):
	if testingMode:
		print(args)

def display_list(list1, sep=' '):
	stdout.write(sep.join(map(str, list1)) + '\n')

def display_2D_list(li):
	for i in li:
		print(i)

def prefix_sum(li):
	sm = 0
	res = []
	for i in li:
		sm += i
		res.append(sm)
	return res

def get_int():
	return int(stdin.readline().strip())

def get_tuple():
	return map(int, stdin.readline().split())

def get_list():
	return list(map(int, stdin.readline().split()))
import heapq, itertools
pq = []
entry_finder = {}
REMOVED = '<removed-task>'

def add_task(task, priority=0):
	if task in entry_finder:
		remove_task(task)
	count = next(counter)
	entry = [priority, count, task]
	entry_finder[task] = entry
	heapq.heappush(pq, entry)

def remove_task(task):
	entry = entry_finder.pop(task)
	entry[-1] = REMOVED

def pop_task():
	while pq:
		(priority, count, task) = heapq.heappop(pq)
		if task is not REMOVED:
			del entry_finder[task]
			return task
	raise KeyError('pop from an empty priority queue')
memory = dict()

def clear_cache():
	global memory
	memory = dict()

def cached_fn(fn, *args):
	global memory
	if args in memory:
		return memory[args]
	else:
		result = fn(*args)
		memory[args] = result
		return result

def ncr(n, r):
	return math.factorial(n) / (math.factorial(n - r) * math.factorial(r))

def binary_serach(i, li):
	fn = lambda x: li[x] - x // i
	x = -1
	b = len(li)
	while b >= 1:
		while b + x < len(li) and fn(b + x) > 0:
			x += b
		b = b // 2
	return x
TestCases = True
testingMode = False
fac_warmup_size = 10 ** 5 + 100
optimiseForReccursion = False
from math import factorial

def main():
	(n, k) = get_tuple()
	li = get_list()
	odd_indexes = [i + 1 for (i, ele) in enumerate(li) if ele % 2 != 0]
	if len(odd_indexes) < k:
		print('NO')
	elif len(odd_indexes) % 2 == k % 2:
		ln = odd_indexes[:k - 1] + [n]
		print('YES')
		display_list(ln)
	else:
		print('NO')
if TestCases:
	for i in range(get_int()):
		cProfile.run('main()') if testingMode else main()
else:
	(cProfile.run('main()') if testingMode else main()) if not optimiseForReccursion else threading.Thread(target=main).start()


from sys import stdin, stdout
q = int(stdin.readline().split('\n')[0])
while q > 0:
	q -= 1
	(n, k) = map(int, stdin.readline().split('\n')[0].split(' '))
	a = map(int, stdin.readline().split('\n')[0].split(' '))
	arr = []
	for (i, ele) in enumerate(a):
		if ele % 2 == 1:
			arr.append(i + 1)
	if not (len(arr) >= k and (len(arr) - k) % 2 == 0):
		stdout.write('NO\n')
		continue
	else:
		stdout.write('YES\n')
		for i in range(k - 1):
			stdout.write(f'{arr[len(arr) - k + i]} ')
		stdout.write(f'{n}\n')


import sys
infile = sys.stdin

def inp():
	return infile.readline().strip()
for _ in range(int(inp())):
	(n, k) = (*map(int, inp().split()),)
	a = (*map(int, inp().split()),)
	if sum(a) % 2 != k % 2:
		print('NO')
		continue
	r = 0
	sm = 0
	o = []
	while r < n:
		while r < n and sm % 2 == 0:
			sm += a[r]
			r += 1
		o.append(r)
		sm = 0
	if len(o) < k:
		print('NO')
		continue
	sys.stdout.write('YES\n')
	sys.stdout.write(' '.join(map(str, o[:k - 1] + [n])))
	sys.stdout.write('\n')


import sys
N = int(input())
for i in range(N):
	(s, k) = map(int, sys.stdin.readline().split())
	ans = [str(i + 1) for (i, x) in enumerate(map(int, sys.stdin.readline().split())) if x % 2 == 1]
	cnt = len(ans)
	if cnt & 1 != k & 1 or cnt < k:
		print('NO')
	else:
		print('YES')
		if k > 1:
			print(' '.join(ans[:k - 1]) + ' ' + str(s))
		else:
			print(s)


import math
import sys
for _ in range(int(input())):
	(n, k) = map(int, sys.stdin.readline().split())
	l = list(map(int, sys.stdin.readline().split()))
	c = 0
	for i in l:
		if i % 2 != 0:
			c += 1
	if c % 2 != k % 2 or c < k:
		print('NO')
	else:
		print('YES')
		cnt = 1
		for i in range(n):
			if l[i] % 2 != 0 and cnt < k:
				print(i + 1, end=' ')
				cnt += 1
		print(n)


from collections import deque
import sys

def inp():
	return sys.stdin.readline().strip()
for _ in range(int(inp())):
	(n, k) = map(int, inp().split())
	a = list(map(int, inp().split()))
	r = []
	cs = 0
	for i in range(n):
		cs += a[i]
		if a[i] % 2 != 0 and k > 1:
			k -= 1
			cs = 0
			r.append(i + 1)
	if cs % 2 != 0 and k == 1:
		r.append(n)
		print('YES')
		print(*r)
	else:
		print('NO')


T = int(input())
for t in range(T):
	(N, K) = map(int, input().split())
	L = list(map(int, input().split()))
	d = 0
	s = list()
	for n in range(N):
		if L[n] % 2 != 0:
			d = d + 1
			s.append(n + 1)
	if d < K:
		print('NO')
	elif K % 2 == 0 and d % 2 != 0 or (K % 2 != 0 and d % 2 == 0):
		print('NO')
	else:
		print('YES')
		for n in range(K - 1):
			print(s[n], end=' ')
		print(N)


x = int(input())
z = []
for j in range(0, x):
	z1 = [[], []]
	ans = 0
	(n, k) = input().split()
	k = int(k)
	a = input().split()
	n1 = k % 2
	for i in range(0, len(a)):
		a[i] = int(a[i])
		if len(z1[1]) == k - 1:
			z1[1].append(int(n))
			ans += a[i]
		elif len(z1[1]) == k:
			ans += a[i]
		else:
			if a[i] % 2 == 1:
				z1[1].append(i + 1)
			ans += a[i]
	if len(z1[1]) >= k and ans % 2 == n1:
		z1[0].append('YES')
	else:
		z1[0].append('NO')
	z.append(z1)
for i in range(0, x):
	if z[i][0] == ['NO']:
		print('NO')
	else:
		print(*z[i][0])
		print(*z[i][1])


for q in range(int(input())):
	(a, b) = map(int, input().split())
	(d, l) = ([], list(map(int, input().split())))
	for x in range(a):
		if l[x] % 2 == 1:
			d.append(x + 1)
	c = len(d)
	if c < b:
		print('NO')
	elif (c - b) % 2 != 0:
		print('NO')
	else:
		print('YES')
		for x in range(b - 1):
			print(d[x], end=' ')
		print(a)


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	l = list(map(int, input().split()))
	z = []
	c = 0
	for i in range(n):
		if l[i] % 2 != 0:
			c += 1
			z.append(i + 1)
	if c < k or (c - k) % 2 != 0:
		print('NO')
	else:
		print('YES')
		i = 0
		for i in range(k - 1):
			print(z[i], end=' ')
		print(n)


from sys import stdin
input = stdin.readline
q = int(input())
for _ in range(q):
	(n, k) = map(int, input().split())
	a = map(int, input().split())
	r = []
	t = 0
	for (i, l) in enumerate(a, start=1):
		if l % 2 == 1:
			t += 1
			if t < k:
				r.append(i)
	if t < k or t % 2 != k % 2:
		print('NO')
	else:
		print('YES')
		print(*r, n)


from sys import stdin
input = stdin.readline
for i in range(int(input())):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	ans = [i + 1 for i in range(n) if a[i] % 2 == 1]
	z = len(ans)
	if z >= k and (z - k) % 2 == 0:
		print('YES')
		print(*ans[:k - 1], n)
	else:
		print('NO')


import sys
t = int(input())
for _ in range(t):
	(n, k) = map(int, sys.stdin.readline().split())
	a = list(map(int, sys.stdin.readline().split()))
	ans = []
	for i in range(n):
		if a[i] & 1:
			ans.append(i + 1)
	if len(ans) >= k and len(ans) % 2 == k % 2:
		print('YES')
		for i in range(k - 1):
			print(ans[i], end=' ')
		print(n)
	else:
		print('NO')


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	arr = list(map(int, input().split()))
	result_idx = [idx + 1 for idx in range(0, n) if arr[idx] % 2]
	if len(result_idx) < k or (len(result_idx) - k) % 2:
		print('NO')
	else:
		print('YES')
		print(*result_idx[:k - 1] + [n])


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import ceil, floor
from copy import *
from collections import deque, defaultdict
from collections import Counter as counter
from itertools import combinations
from itertools import permutations as permutate
from bisect import bisect_left as bl
from operator import *
from bisect import bisect_right as br
from bisect import bisect
BUFSIZE = 8192
from sys import stderr

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
from types import GeneratorType

def iterative(f, stack=[]):

	def wrapped_func(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		to = f(*args, **kwargs)
		while True:
			if type(to) is GeneratorType:
				stack.append(to)
				to = next(to)
				continue
			stack.pop()
			if not stack:
				break
			to = stack[-1].send(to)
		return to
	return wrapped_func
mod = 1000000007

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

def sep():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def fsep():
	return map(float, inp().split())

def nextline():
	out('\n')

def testcase(t):
	for p in range(t):
		solve()

def pow(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res
from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))

def gcd(a, b):
	if a == b:
		return a
	while b > 0:
		(a, b) = (b, a % b)
	return a

def prefix_sum(ar):
	return list(accumulate(ar))

def suffix_sum(ar):
	return list(accumulate(ar[::-1]))[::-1]

def N():
	return int(inp())
dx = [0, 0, 1, -1]
dy = [1, -1, 0, 0]
from collections import defaultdict

def numberOfSetBits(i):
	i = i - (i >> 1 & 1431655765)
	i = (i & 858993459) + (i >> 2 & 858993459)
	return ((i + (i >> 4) & 252645135) * 16843009 & 4294967295) >> 24
from decimal import *
from math import *

def solve():
	(n, k) = sep()
	ar = lis()
	s = sum(ar)
	if k % 2 != s % 2:
		print('NO')
		return
	ans = []
	cs = 0
	for i in range(n):
		if len(ans) == k - 1:
			ans.append(n)
			break
		if (cs + ar[i]) % 2 == 1:
			ans.append(i + 1)
			cs = 0
		else:
			cs += ar[i]
	if len(ans) == k:
		print('YES')
		print(*ans)
	else:
		print('NO')
testcase(int(inp()))


q = int(input())
for w in range(q):
	(n, k) = map(int, input().split())
	a = [int(i) for i in input().split()]
	ind = []
	if k == 1:
		if sum(a) % 2 != 0:
			print('YES')
			print(n)
		else:
			print('NO')
	else:
		c = 0
		for i in range(n):
			if a[i] % 2 != 0:
				if c < k:
					ind.append(i + 1)
				c += 1
		if c < k:
			print('NO')
		elif (c - k) % 2 != 0:
			print('NO')
		else:
			print('YES')
			for i in range(len(ind) - 1):
				print(ind[i], end=' ')
			print(n)


from sys import stdin, stdout
input = stdin.readline
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	m = 0
	for i in range(n):
		if a[i] % 2 == 1:
			m += 1
	if m < k or (m - k) % 2 == 1:
		stdout.write('NO' + '\n')
		continue
	ans = []
	for i in range(n):
		if a[i] % 2 == 1:
			ans.append(i + 1)
	stdout.write('YES' + '\n')
	for i in range(k - 1):
		stdout.write(str(ans[i]) + ' ')
	stdout.write(str(n) + '\n')


import sys
t = int(sys.stdin.readline())
for _ in range(t):
	(n, k) = map(int, sys.stdin.readline().split())
	strr = sys.stdin.readline()
	odd = [i + 1 for (i, x) in enumerate(strr.split()) if int(x) & 1]
	if len(odd) >= k:
		if k % 2 != len(odd) % 2:
			print('NO')
		else:
			print('YES')
			print(*odd[:k - 1], n)
	else:
		print('NO')


import os
import sys
from math import *
from collections import *
from bisect import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def value():
	return tuple(map(int, input().split()))

def array():
	return [int(i) for i in input().split()]

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]
for _ in range(Int()):
	(n, k) = value()
	a = array()
	c = 0
	for i in a:
		c += 1 if i % 2 else 0
	if (c - k) % 2 == 0 and c >= k:
		print('YES')
		for i in range(n - 1):
			if k == 1:
				break
			if a[i] % 2:
				k -= 1
				print(i + 1, end=' ')
		print(n)
	else:
		print('NO')


import sys
t = int(input())
for i in range(t):
	(n, k) = list(map(int, sys.stdin.readline().split()))
	a = list(map(int, sys.stdin.readline().split()))
	p = []
	for i in range(n):
		if a[i] % 2 == 1:
			p.append(i + 1)
	if len(p) >= k and (len(p) - k) % 2 == 0:
		p = p[:k]
		p[len(p) - 1] = n
		print('YES')
		print(*p)
	else:
		print('NO')


import sys
q = int(input())
for _ in range(q):
	(n, k) = map(int, sys.stdin.readline().split())
	a = [int(i) for i in sys.stdin.readline().split()]
	count = [i % 2 == 1 for i in a].count(1)
	if k > count or k % 2 != count % 2:
		print('NO')
	else:
		print('YES')
		for i in range(n):
			if a[i] % 2 == 1 and k > 1:
				print(i + 1, end=' ')
				k -= 1
			elif a[i] % 2 == 1 and k == 1:
				print(n)
				break


for x in range(int(input())):
	(n, k) = list(map(int, input().split()))
	m = list(map(int, input().split()))
	a = []
	p = 0
	z = k
	for i in range(n):
		p += m[i]
		if k > 0:
			if p % 2:
				a.append(i + 1)
				p = 0
				k -= 1
	if len(a) >= z and p % 2 == 0:
		print('YES')
		print(*a[:k - 1], n)
	else:
		print('NO')


q = int(input())
B = []
OTVET = []
for m in range(q):
	(n, k) = list(map(int, input().split()))
	sttr = list(map(int, input().split()))
	a = list(sttr)
	kolvo = 0
	nechet = []
	for i in range(n):
		if a[i] % 2 == 1:
			kolvo += 1
			nechet.append(i + 1)
	if kolvo >= k and (kolvo - k) % 2 == 0:
		otsh = []
		for i in range(k - 1):
			otsh.append(nechet[i])
		otsh.append(n)
		B.append(1)
		OTVET.append(otsh)
	else:
		B.append(0)
j = 0
for i in range(q):
	if B[i] == 1:
		print('YES')
		print(*OTVET[j])
		j += 1
	else:
		print('NO')


q = int(input())
for i in range(q):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	o = []
	for j in range(n):
		if a[j] % 2 != 0:
			o.append(j + 1)
	if len(o) < k:
		print('NO')
	elif k % 2 != len(o) % 2:
		print('NO')
	else:
		print('YES')
		for j in range(k - 1):
			print(o[j], end=' ')
		print(n)


q = int(input())
flag = []
ans = []
for i in range(q):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	b = [x % 2 for x in a]
	cnt = sum(b)
	if cnt < k:
		flag.append(0)
	elif cnt % 2 != k % 2:
		flag.append(0)
	else:
		flag.append(1)
		c = [j + 1 for (j, val) in enumerate(b) if val == 1]
		temp = c[:k - 1]
		temp.append(n)
		ans.append(temp)
printFlag = 0
for i in range(q):
	if flag[i] == 0:
		print('NO')
	else:
		print('YES')
		print(*ans[printFlag])
		printFlag += 1


import sys
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	arr = list(map(int, sys.stdin.readline().split()))
	pos = [i + 1 for i in range(n) if arr[i] % 2 == 1]
	if len(pos) < k or (len(pos) - k) % 2 == 1:
		print('NO')
	else:
		print('YES')
		res = pos[:k - 1] + [n]
		print(' '.join(list(map(str, res))))


I = lambda : map(int, input().split())
for _ in range(int(input())):
	(n, k) = I()
	X = [i for (i, a) in enumerate(I(), 1) if a % 2]
	if len(X) < k or (k + len(X)) % 2:
		print('NO')
	else:
		print('YES')
		print(*X[:k - 1], n)


for i in range(int(input())):
	(n, k) = map(int, input().split())
	nums = list(map(int, input().split()))
	count = 0
	s = []
	for i in range(n):
		if nums[i] % 2 != 0:
			count += 1
			s.append(i + 1)
	if count < k or (count - k) % 2 != 0:
		print('NO')
	else:
		print('YES')
		i = 0
		for i in range(k - 1):
			print(s[i], end=' ')
		print(n)


t = int(input())
for i in range(t):
	(n, k) = map(int, input().split())
	l = list(map(int, input().split()))
	pos = []
	(total, j) = (0, 0)
	while j < n and k > 1:
		total += l[j]
		if total % 2 != 0:
			k -= 1
			total = 0
			pos.append(j + 1)
		j += 1
	if k == 1 and j != n and ((total + sum(l[j:])) % 2 != 0):
		pos.append(n)
		print('YES')
		print(*pos, sep=' ')
	else:
		print('NO')


queries = int(input())
for z in range(queries):
	(length, sub) = list(map(int, input().split()))
	if length == 1 and sub == 1:
		g = int(input())
		if g % 2:
			print('YES')
			print(1)
			continue
		else:
			print('NO')
			continue
	array = list(map(int, input().split()))
	no_of_odds = 0
	indices_of_odds = []
	for (i, j) in enumerate(array):
		if j % 2:
			no_of_odds += 1
			indices_of_odds.append(i + 1)
	if no_of_odds < sub or sub % 2 != no_of_odds % 2:
		print('NO')
	else:
		print('YES')
		if sub == 1:
			print(length)
			continue
		print(*indices_of_odds[:sub - 1], end=' ')
		print(length)


q = int(input())
for _ in range(q):
	(n, k) = map(int, input().split(' '))
	y = list(map(int, input().split()))
	if n == 1:
		if y[0] % 2 == 0:
			print('NO')
		else:
			print('YES')
			print(n)
	else:
		c = []
		i = j = 0
		while i < n and j < k - 1:
			if y[i] % 2 != 0:
				c.append(i + 1)
				j += 1
			i += 1
		count = 0
		while i < n:
			if y[i] % 2 != 0:
				count += 1
			i += 1
		if count % 2 == 0:
			print('NO')
		else:
			c.append(n)
			print('YES')
			print(*c)


for _ in range(int(input())):
	(a, b) = map(int, input().split())
	l = list(map(int, input().split()))
	v = []
	for i in range(len(l)):
		if l[i] % 2 != 0:
			v.append(i + 1)
	if len(v) >= b and (len(v) - b) % 2 == 0:
		print('YES')
		for i in range(b - 1):
			print(v[i], end=' ')
		print(a)
	else:
		print('NO')


t = int(input().strip())
for i in range(t):
	(n, k) = list(map(int, input().strip().split()))
	nums = [int(i) for i in input().strip().split()]
	cur_k = 0
	ans = []
	has = True
	if k == 1:
		if sum(nums) % 2 == 0:
			print('NO')
		else:
			print('YES')
			print(n)
	else:
		for i in range(n):
			if cur_k == k - 1:
				if ans[-1] != n:
					if sum(nums[ans[-1]:]) % 2 == 0:
						has = False
						break
					else:
						cur_k += 1
						ans.append(n)
						break
			if nums[i] % 2 == 1:
				ans.append(i + 1)
				cur_k += 1
		if cur_k < k or not has:
			print('NO')
		else:
			print('YES')
			print(' '.join((str(i) for i in ans)))


n = int(input())
ansar = []
for i in range(n):
	odd = []
	(a, b) = map(int, input().split())
	x = list(map(int, input().split()))
	for j in range(a):
		if x[j] % 2 == 1:
			odd.append(j + 1)
	if len(odd) >= b and len(odd) % 2 == b % 2:
		ansar.append('YES')
		odd[-1] = a
		ansar.append(odd[len(odd) - b:])
	else:
		ansar.append('NO')
for k in range(len(ansar)):
	if ansar[k] == 'YES':
		print(ansar[k])
		print(*ansar[k + 1])
	elif ansar[k] == 'NO':
		print(ansar[k])


from sys import stdin
for _ in range(int(stdin.readline())):
	(n, k) = map(int, stdin.readline().split())
	a = list(map(int, stdin.readline().split()))
	cnt = 0
	l1 = []
	for i in range(n):
		if a[i] & 1:
			cnt += 1
			l1.append(i + 1)
	if cnt < k:
		print('NO')
	elif cnt % 2 != k % 2:
		print('NO')
	else:
		print('YES')
		for x in range(k - 1):
			print(l1[x], end=' ')
		print(n)


import sys
fast_reader = sys.stdin.readline
fast_writer = sys.stdout.write

def input():
	return fast_reader().strip()

def print(*argv):
	fast_writer(' '.join((str(i) for i in argv)))
	fast_writer('\n')

def list_input():
	return list(map(int, input().split()))

def sep_input():
	return map(int, input().split())
for _ in range(int(input())):
	(n, k) = sep_input()
	l = list_input()
	c = 0
	ans = []
	for i in range(n):
		if l[i] % 2 == 1:
			ans.append(i + 1)
			c += 1
	ans = ans[:k - 1] + [n]
	if c < k or c % 2 != k % 2:
		print('NO')
	else:
		print('YES')
		print(*ans)


import sys
input = sys.stdin.readline
t = int(input())
for i10 in range(t):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	s = 0
	p = 0
	b = []
	f = 0
	for i in range(n):
		a[i] %= 2
		if s == k - 1:
			f = 1
			p += a[i]
			p %= 2
		else:
			p += a[i]
			p %= 2
			if p % 2 == 1:
				b.append(i + 1)
				p = 0
				s += 1
	if f == 1:
		if p % 2 == 1:
			b.append(n)
			print('YES')
			print(*b)
		else:
			print('NO')
	else:
		print('NO')


from sys import stdin, stdout

def xinput():
	return stdin.readline().rstrip()
q = int(xinput())
for _ in range(q):
	(n, k) = [int(x) for x in xinput().split()]
	a = [int(x) for x in xinput().split()]
	idx = []
	for i in range(n):
		if a[i] % 2 == 1:
			idx.append(i)
	if len(idx) % 2 != k % 2:
		stdout.write('NO\n')
		continue
	if len(idx) < k:
		stdout.write('NO\n')
		continue
	stdout.write('YES\n')
	for i in range(k - 1):
		stdout.write(str(idx[i] + 1) + ' ')
	stdout.write(str(n) + '\n')


from math import sqrt
import sys

def inpu():
	return sys.stdin.readline().strip()
q = int(input())
for i in range(q):
	(n, k) = map(int, inpu().split())
	mas = [int(i) for i in inpu().split()]
	s = 0
	a = []
	u = k - 1
	if n < k:
		print('NO')
		continue
	for i in range(len(mas)):
		if mas[i] % 2 != 0:
			if u != 0:
				a.append(i + 1)
				u -= 1
			s += 1
	a.append(n)
	if s < k:
		print('NO')
	elif s % 2 != 0 and k % 2 != 0 or (s % 2 == 0 and k % 2 == 0):
		print('YES')
		print(*a)
	else:
		print('NO')


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	l = list(map(int, input().split()))
	cnt = 1
	l1 = []
	for i in range(n):
		if l[i] % 2 != 0:
			l1.append(i + 1)
	n1 = len(l1)
	if k > n1 or n1 % 2 != k % 2:
		print('NO')
	else:
		temp1 = 1
		s = ''
		while temp1 < k:
			s += str(l1[temp1 - 1]) + ' '
			temp1 += 1
		s += str(n)
		print('YES')
		print(s)


n = int(input())
for i in range(n):
	(countNum, delNum) = map(int, input().split())
	numbers = list(map(int, input().split()))
	if countNum == 1:
		if numbers[0] % 2 == 1:
			print('YES')
			print(1)
		else:
			print('NO')
	else:
		z = 0
		result = []
		for i in range(len(numbers)):
			if numbers[i] % 2 >= 1:
				if len(result) < delNum:
					result.append(str(i + 1))
				if len(result) >= delNum:
					z += 1
		if z % 2 == 1:
			print('YES')
			result[-1] = str(countNum)
			print(' '.join(result))
		else:
			print('NO')


import os
import gc
import sys
from io import BytesIO, IOBase
from collections import Counter
from collections import deque
import heapq
import math
import statistics

def sin():
	return input()

def ain():
	return list(map(int, sin().split()))

def sain():
	return input().split()

def iin():
	return int(sin())
MAX = float('inf')
MIN = float('-inf')

def readTree(n, m):
	adj = [deque([]) for _ in range(n + 1)]
	for _ in range(m):
		(u, v) = ain()
		adj[u].append(v)
		adj[v].append(u)
	return adj

def solve(n, k, l):
	x = 0
	d = deque([])
	for i in range(n):
		x += l[i]
		if x % 2 == 1:
			x = 0
			d.append(i + 1)
	if len(d) == 0:
		return d
	d[-1] = n
	if k == len(d):
		return d
	elif k > len(d):
		return deque([])
	elif (len(d) - k) % 2 == 0:
		ll = len(d)
		for i in range(ll - k):
			d.pop()
		d[-1] = n
		return d
	else:
		return deque([])

def main():
	for _ in range(iin()):
		(n, k) = ain()
		l = ain()
		p = solve(n, k, l)
		if len(p) == 0:
			print('NO')
		else:
			print('YES')
			print(*p)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


for _ in ' ' * int(input()):
	(a, b) = map(int, input().split())
	c = []
	d = 1
	for i in map(int, input().split()):
		if i & 1:
			c += [d]
		d += 1
	z = len(c)
	if z < b:
		print('NO')
	elif z & 1 == b & 1:
		print('YES')
		for i in range(b - 1):
			print(c[i], end=' ')
		print(a)
	else:
		print('NO')


from sys import stdin, stdout
from collections import Counter
import math

def rsingle_int():
	return int(stdin.readline().rstrip())

def rmult_int():
	return [int(x) for x in stdin.readline().rstrip().split()]

def rmult_str():
	return stdin.readline().rstrip().split()

def r_str():
	return stdin.readline().rstrip()

def rsingle_char():
	return stdin.read(1)

def main():
	q = rsingle_int()
	for i in range(q):
		(n, k) = rmult_int()
		a = rmult_int()
		i = 0
		ks = []
		while k > 1 and i < len(a):
			if a[i] % 2 != 0:
				ks.append(i + 1)
				k -= 1
			i += 1
		if i < len(a):
			sum = 0
			for j in range(i, len(a)):
				sum += a[j]
			if sum % 2 != 0:
				print('YES')
				ks.append(len(a))
				print(*ks)
			else:
				print('NO')
		else:
			print('NO')
main()


import sys
input = sys.stdin.readline
T = int(input())
for t in range(T):
	(n, k) = list(map(int, input().split()))
	A = list(map(int, input().split()))
	odd = 0
	ans = []
	seg = 1
	for i in range(n):
		if A[i] % 2 == 1:
			if seg != k:
				seg += 1
				ans.append(str(i + 1))
			else:
				odd += 1
	if seg != k or odd % 2 == 0:
		print('NO')
	else:
		ans.append(str(n))
		print('YES')
		print(' '.join(ans))


import sys
input = sys.stdin.readline
q = int(input())
for testcases in range(q):
	(n, k) = map(int, input().split())
	A = list(map(int, input().split()))
	if sum(A) % 2 != k % 2:
		print('NO')
		continue
	ANS = []
	SUM = 0
	for i in range(n):
		SUM += A[i]
		if SUM % 2 == 1:
			ANS.append(i + 1)
			SUM = 0
	if len(ANS) >= k - 1:
		print('YES')
		ANS0 = ANS[:k - 1] + [n]
		print(*ANS0)
	else:
		print('NO')


t = int(input())
for ii in range(t):
	(n, k) = map(int, input().split())
	l = [int(x) for x in input().split()]
	odd = 0
	for i in l:
		if i % 2 != 0:
			odd += 1
	if k % 2 == 0:
		if odd % 2 != 0:
			print('NO')
			continue
	if k % 2 != 0:
		if odd % 2 == 0:
			print('NO')
			continue
	if k > odd:
		print('NO')
		continue
	ans = []
	print('YES')
	if k == 1:
		print(n)
		continue
	for i in range(n):
		if l[i] % 2 != 0:
			ans.append(i + 1)
			k -= 1
		if k == 1:
			ans.append(n)
			break
	print(*ans)


from bisect import *
from collections import *
from itertools import *
import functools
import sys
import math
from decimal import *
from copy import *
getcontext().prec = 30
MAX = sys.maxsize
MAXN = 10 ** 5 + 10
MOD = 10 ** 9 + 7

def isprime(n):
	n = abs(int(n))
	if n < 2:
		return False
	if n == 2:
		return True
	if not n & 1:
		return False
	for x in range(3, int(n ** 0.5) + 1, 2):
		if n % x == 0:
			return False
	return True

def mhd(a, b):
	return abs(a[0] - b[0]) + abs(b[1] - a[1])

def charIN(x=' '):
	return sys.stdin.readline().strip().split(x)

def arrIN(x=' '):
	return list(map(int, sys.stdin.readline().strip().split(x)))

def eld(x, y):
	a = y[0] - x[0]
	b = x[1] - y[1]
	return (a * a + b * b) ** 0.5

def lgcd(a):
	g = a[0]
	for i in range(1, len(a)):
		g = math.gcd(g, a[i])
	return g

def ms(a):
	msf = -MAX
	meh = 0
	st = en = be = 0
	for i in range(len(a)):
		meh += a[i]
		if msf < meh:
			msf = meh
			st = be
			en = i
		if meh < 0:
			meh = 0
			be = i + 1
	return (msf, st, en)

def ncr(n, r):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % MOD
		den = den * (i + 1) % MOD
	return num * pow(den, MOD - 2, MOD) % MOD

def flush():
	return sys.stdout.flush()
for _ in range(int(input())):
	(n, k) = arrIN()
	a = arrIN()
	pre = list(accumulate(a))
	ans = []
	for i in range(n):
		if ans:
			if (pre[i] - pre[ans[-1]]) % 2:
				ans.append(i)
		elif pre[i] % 2:
			ans.append(i)
	if len(ans) < k:
		print('NO')
	elif len(ans) == k:
		print('YES')
		print(*[i + 1 for i in ans[:len(ans) - 1]], n)
	else:
		ext = len(ans) - k
		if ext % 2:
			print('NO')
		else:
			print('YES')
			print(*[i + 1 for i in ans[:k - 1]], n)


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import *
from collections import deque
from collections import Counter as counter
from itertools import combinations as comb
from itertools import permutations as permutate
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
mod = 1000000007

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

def sep():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def zerolist(n):
	return [0] * n

def nextline():
	out('\n')

def testcase(t):
	for p in range(t):
		solve()

def printlist(a):
	for p in range(0, len(a)):
		out(str(a[p]) + ' ')

def lcm(a, b):
	return a * b // gcd(a, b)

def power(a, b):
	ans = 1
	while b > 0:
		if b % 2 == 1:
			ans *= a
		a *= a
		b //= 2
	return ans

def ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def bfs(g, st, lcatable, level):
	visited = [0] * len(g)
	visited[st] = 1
	queue = []
	queue.append(st)
	new = []
	while len(queue) != 0:
		s = queue.pop()
		new.append(s)
		for i in g[s]:
			if visited[i] == 0:
				level[i] = level[s] + 1
				lcatable[i][0] = s
				visited[i] = 1
				queue.append(i)
	return new

def lcatable(g, n, level):
	mx = 0
	while 2 ** mx <= n:
		mx += 1
	lcatable = [[-1] * mx for i in range(n + 1)]
	bfs(g, 1, lcatable, level)
	for j in range(1, mx):
		for i in range(1, n + 1):
			if lcatable[i][j - 1] != -1:
				lcatable[i][j] = lcatable[lcatable[i][j - 1]][j - 1]
	return lcatable

def dist(x0, y0, x1, y1):
	return abs(x0 - x1) + abs(y0 - y1)

def solve():
	(n, k) = sep()
	a = lis()
	pos = []
	for i in range(n):
		if a[i] % 2 == 1:
			pos.append(i + 1)
	if len(pos) < k or (len(pos) - (k - 1)) % 2 == 0:
		print('NO')
	else:
		print('YES')
		cnt = 0
		for i in range(k - 1):
			if cnt == k - 1:
				break
			print(pos[i], end=' ')
			cnt += 1
		print(n)
testcase(int(inp()))


import sys

def print_solution(sol):
	print('YES')
	print(' '.join(map(str, sol)))

def solve(n, k, numbers):
	a = [i + 1 for i in range(n) if numbers[i] & 1]
	if len(a) < k or len(a) % 2 != k % 2:
		return False
	return a[:k - 1] + [n]
for i in range(int(input())):
	(n, k) = map(int, sys.stdin.readline().split())
	numbers = list(map(int, sys.stdin.readline().split()))
	sol = solve(n, k, numbers)
	if sol:
		print_solution(sol)
	else:
		print('NO')


IN = input
rint = lambda : int(IN())
rmint = lambda : map(int, IN().split())
rlist = lambda : list(rmint())
b = [0] * 228228
q = rint()
while q:
	q -= 1
	(n, k) = rmint()
	f = 0
	p = 0
	u = 1
	for c in rlist():
		p += 1
		if f & 1 and u < k:
			f = 0
			u += 1
		f += c
		b[u - 1] = p
	ans = ''
	if u == k and f & 1:
		ans += 'YES\n'
		for c in range(u - 1):
			ans += str(b[c]) + ' '
		ans += str(b[u - 1]) + '\n'
		print(ans, end='')
	else:
		print('NO', end='\n')


from sys import stdin, stdout
for _ in range(int(stdin.readline())):
	(n, m) = map(int, stdin.readline().split())
	l = list(map(int, stdin.readline().split()))
	sumy = 0
	count = 0
	siri = 0
	i = 0
	shan = []
	while i < n:
		if l[i] & 1:
			count += 1
			shan.append(i + 1)
		i += 1
	if count - m & 1:
		stdout.write('NO\n')
	elif count >= m:
		stdout.write('YES\n')
		print(*shan[:m - 1], n)
	else:
		stdout.write('NO\n')


from sys import stdin
input = stdin.readline
q = int(input())
for _ in range(q):
	(n, k) = [int(x) for x in input().split()]
	a = [int(x) for x in input().split()]
	c = 0
	ans = []
	for i in range(n):
		if a[i] % 2 > 0:
			c += 1
			if c < k:
				ans.append(i + 1)
	ans.append(n)
	if c < k:
		print('NO')
		continue
	if (c - k) % 2 > 0:
		print('NO')
		continue
	print('YES')
	print(*ans)


mis = lambda : map(int, __import__('sys').stdin.readline().split())
lis = lambda : list(mis())
ii = lambda : int(input())
mi = lambda : map(int, input().split())
li = lambda : list(mi())
si = lambda : input()
for _ in range(ii()):
	(n, k) = mis()
	l = lis()
	o = [i + 1 for i in range(n) if l[i] % 2 == 1]
	le = len(o)
	if (le ^ k) & 1 or le < k:
		print('NO')
	else:
		print('YES')
		print(*o[:k - 1] + [n])


q = int(input())
for z in range(q):
	(n, k) = map(int, input().split())
	elements = list(map(int, input().split()))
	b = []
	tracker = 0
	for i in range(n):
		if elements[i] % 2 != 0:
			b.append(i + 1)
			tracker += 1
	if tracker < k or tracker % 2 != k % 2:
		print('NO')
	else:
		print('YES')
		stir = ''
		for i in range(k - 1):
			print(b[i], end=' ')
		print(stir + str(n))


import sys
input = sys.stdin.readline
from collections import defaultdict as dc
from collections import Counter
from bisect import bisect_right, bisect_left
import math
from heapq import heapify, heappop, heappush
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	l = list(map(int, input().split()))
	o = 0
	s = 0
	for i in l:
		s += i
		if i % 2:
			o += 1
	if o < k:
		print('NO')
	elif k % 2 == 1 and s % 2 == 0:
		print('NO')
	elif k % 2 == 0 and s % 2 == 1:
		print('NO')
	else:
		print('YES')
		r = 0
		p = []
		c = 0
		for i in range(n):
			if c == k - 1:
				p.append(n)
				break
			if l[i] % 2:
				p.append(i + 1)
				c += 1
			else:
				continue
		print(*p)


for i in range(int(input())):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	q = []
	w = 0
	for i in range(n):
		if a[i] % 2 != 0:
			q.append(str(i + 1))
			w += 1
	if w >= k:
		r = w - k
		r = r % 2
		if r != 1:
			print('YES')
			q[k - 1] = str(n)
			print(' '.join(q[:k]))
		else:
			print('NO')
	else:
		print('NO')


import sys
R = lambda : map(int, sys.stdin.readline().split())
q = int(input())
for _ in range(q):
	(n, k) = R()
	l = list(R())
	ods = [0]
	for i in range(1, n + 1):
		ods.append(1 if l[i - 1] % 2 == 1 else 0)
		ods[i] += ods[i - 1]
	splits = [0]
	for i in range(1, len(ods)):
		if k == 1:
			if (ods[n] - ods[splits[-1]]) % 2 == 1:
				splits.append(n)
				k -= 1
			break
		if (ods[i] - ods[splits[-1]]) % 2 == 1:
			splits.append(i)
			k -= 1
	valid = True
	if k != 0:
		valid = False
	if valid:
		print('YES')
		print(' '.join(map(str, splits[1:])))
	else:
		print('NO')


from __future__ import division, print_function
import math
import os
import sys
from fractions import *
from sys import *
from decimal import *
from io import BytesIO, IOBase
from itertools import *
from collections import *
M = 10 ** 9 + 7
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

def sep():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def fsep():
	return map(float, inp().split())

def inpu():
	return int(inp())

def regularbracket(t):
	p = 0
	for i in t:
		if i == '(':
			p += 1
		else:
			p -= 1
		if p < 0:
			return False
	else:
		if p > 0:
			return False
		else:
			return True

def binarySearchCount(arr, n, key):
	left = 0
	right = n - 1
	count = 0
	while left <= right:
		mid = int((right + left) / 2)
		if arr[mid] <= key:
			count = mid + 1
			left = mid + 1
		else:
			right = mid - 1
	return count

def reverse1(string):
	pp = ''
	for i in string[::-1]:
		pp += i
	if pp == string:
		return True
	return False

def reverse2(list1):
	l = []
	for i in list1[::-1]:
		l.append(i)
	if l == list1:
		return True
	return False

def mex(list1):
	p = max(list1) + 1
	for i in range(len(list1)):
		if list1[i] != i:
			p = i
			break
	return p

def sumofdigits(n):
	n = str(n)
	s1 = 0
	for i in n:
		s1 += int(i)
	return s1

def perfect_square(n):
	s = math.sqrt(n)
	if s == int(s):
		return True
	return False

def roman_number(x):
	if x > 15999:
		return
	value = [5000, 4000, 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
	symbol = ['F', 'MF', 'M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I']
	roman = ''
	i = 0
	while x > 0:
		div = x // value[i]
		x = x % value[i]
		while div:
			roman += symbol[i]
			div -= 1
		i += 1
	return roman

def soretd(s):
	for i in range(1, len(s)):
		if s[i - 1] > s[i]:
			return False
	return True

def countRhombi(h, w):
	ct = 0
	for i in range(2, h + 1, 2):
		for j in range(2, w + 1, 2):
			ct += (h - i + 1) * (w - j + 1)
	return ct

def countrhombi2(h, w):
	return h * h // 4 * (w * w // 4)

def binpow(a, b):
	if b == 0:
		return 1
	else:
		res = binpow(a, b // 2)
	if b % 2 != 0:
		return res * res * a
	else:
		return res * res

def binpowmodulus(a, b, m):
	a %= m
	res = 1
	while b > 0:
		if b & 1:
			res = res * a % m
		a = a * a % m
		b >>= 1
	return res

def coprime_to_n(n):
	result = n
	i = 2
	while i * i <= n:
		if n % i == 0:
			while n % i == 0:
				n //= i
			result -= result // i
		i += 1
	if n > 1:
		result -= result // n
	return result

def prime(x):
	if x == 1:
		return False
	else:
		for i in range(2, int(math.sqrt(x)) + 1):
			if x % i == 0:
				return False
		else:
			return True

def luckynumwithequalnumberoffourandseven(x, n, a):
	if x >= n and str(x).count('4') == str(x).count('7'):
		a.append(x)
	elif x < 1000000000000.0:
		luckynumwithequalnumberoffourandseven(x * 10 + 4, n, a)
		luckynumwithequalnumberoffourandseven(x * 10 + 7, n, a)
	return a

def luckynum(x, l, r, a):
	if x >= l and x <= r:
		a.append(x)
	if x > r:
		a.append(x)
		return a
	if x < 10000000000.0:
		luckynum(x * 10 + 4, l, r, a)
		luckynum(x * 10 + 7, l, r, a)
	return a

def luckynuber(x, n, a):
	p = set(str(x))
	if len(p) <= 2:
		a.append(x)
	if x < n:
		luckynuber(x + 1, n, a)
	return a

def interact(type, x):
	if type == 'r':
		inp = input()
		return inp.strip()
	else:
		print(x, flush=True)

def findTrailingZeros(n):
	count = 0
	while n >= 5:
		n //= 5
		count += n
	return count

def mergeSort(arr):
	if len(arr) > 1:
		mid = len(arr) // 2
		L = arr[:mid]
		R = arr[mid:]
		mergeSort(L)
		mergeSort(R)
		i = j = k = 0
		while i < len(L) and j < len(R):
			if L[i] < R[j]:
				arr[k] = L[i]
				i += 1
			else:
				arr[k] = R[j]
				j += 1
			k += 1
		while i < len(L):
			arr[k] = L[i]
			i += 1
			k += 1
		while j < len(R):
			arr[k] = R[j]
			j += 1
			k += 1
res = set()

def solven(p, l, a, b, n):
	if p > n or l > 10:
		return
	if p > 0:
		res.add(p)
	solven(p * 10 + a, l + 1, a, b, n)
	solven(p * 10 + b, l + 1, a, b, n)

def subsetsUtil(A, subset, index, d):
	print(*subset)
	s = sum(subset)
	d.append(s)
	for i in range(index, len(A)):
		subset.append(A[i])
		subsetsUtil(A, subset, i + 1, d)
		subset.pop(-1)
	return d

def subsetSums(arr, l, r, d, sum=0):
	if l > r:
		d.append(sum)
		return
	subsetSums(arr, l + 1, r, d, sum + arr[l])
	subsetSums(arr, l + 1, r, d, sum)
	return d

def print_factors(x):
	factors = []
	for i in range(1, x + 1):
		if x % i == 0:
			factors.append(i)
	return factors

def calc(X, d, ans, D):
	if len(X) == 0:
		return
	i = X.index(max(X))
	ans[D[max(X)]] = d
	Y = X[:i]
	Z = X[i + 1:]
	calc(Y, d + 1, ans, D)
	calc(Z, d + 1, ans, D)

def factorization(n, l):
	c = n
	if prime(n) == True:
		l.append(n)
		return l
	for i in range(2, c):
		if n == 1:
			break
		while n % i == 0:
			l.append(i)
			n = n // i
	return l

def good(b):
	l = []
	i = 0
	while len(b) != 0:
		if b[i] < b[len(b) - 1 - i]:
			l.append(b[i])
			b.remove(b[i])
		else:
			l.append(b[len(b) - 1 - i])
			b.remove(b[len(b) - 1 - i])
	if l == sorted(l):
		return True
	return False

def generate(st, s):
	if len(s) == 0:
		return
	if s not in st:
		st.add(s)
		for i in range(len(s)):
			t = list(s).copy()
			t.remove(s[i])
			t = ''.join(t)
			generate(st, t)
	return

def largestincreasingsubsequence(A):
	l = [1] * len(A)
	sub = []
	for i in range(1, len(l)):
		for k in range(i):
			if A[k] < A[i]:
				sub.append(l[k])
		l[i] = 1 + max(sub, default=0)
	return max(l, default=0)

def findOR(nums, N):
	prefix_sum = 0
	result = 0
	for i in range(N):
		result |= nums[i]
		prefix_sum += nums[i]
		result |= prefix_sum
	return result

def OR(a, n):
	ans = a[0]
	for i in range(1, n):
		ans |= a[i]
	return ans

def main():
	for _ in range(inpu()):
		(n, k) = sep()
		arr = lis()
		odd = 0
		if k == 1:
			if sum(arr) % 2 != 0:
				print('YES')
				print(n)
			else:
				print('NO')
			continue
		s = 0
		l = []
		q = 0
		for i in range(n):
			s += arr[i]
			if s % 2 != 0:
				l.append(i + 1)
				s = 0
				if len(l) == k - 1:
					q = i
					break
		if sum(arr[q + 1:]) % 2 != 0 and len(l) == k - 1:
			print('YES')
			print(*l, end=' ')
			print(n)
		else:
			print('NO')
main()


ll = lambda : map(int, input().split())
t = lambda : int(input())
ss = lambda : input()
lx = lambda x: map(int, input().split(x))
for _ in range(t()):
	(n, k) = ll()
	a = list(ll())
	c = []
	for i in range(n):
		if a[i] % 2:
			c.append(i + 1)
	if len(c) < k or len(c) % 2 != k % 2:
		print('NO')
		continue
	print('YES')
	print(*c[:k - 1], n)


import sys
for _ in range(int(sys.stdin.readline())):
	(n, k) = [int(i) for i in sys.stdin.readline().split()]
	li = [int(j) for j in sys.stdin.readline().split()]
	cnt = 0
	for i in range(len(li)):
		cnt += li[i] % 2
	if cnt < k or cnt % 2 != k % 2:
		print('NO')
		continue
	print('YES')
	for a in range(len(li)):
		if k == 1:
			break
		if li[a] % 2 == 1:
			print(a + 1, end=' ')
			k -= 1
	print(n)


import sys
tmp = lambda : map(int, sys.stdin.readline().split())
q = int(input())
for i in range(q):
	t = []
	counter = 0
	(n, k) = tmp()
	a = list(tmp())
	for j in range(len(a)):
		if a[j] % 2 != 0:
			counter += 1
			t.append(j + 1)
	if counter < k:
		print('NO')
	elif k == 1 and len(t) % 2 == 0:
		print('NO')
	elif len(t[k - 1:]) % 2 == 0:
		print('NO')
	else:
		print('YES')
		print(*t[:k - 1], n)


import sys
t = int(input())
for _ in range(t):
	(n, k) = map(int, sys.stdin.readline().split())
	l = list(map(int, sys.stdin.readline().split()))
	odd = []
	ol = 0
	for i in range(n):
		if l[i] & 1:
			odd.append(i + 1)
			ol += 1
	if ol < k:
		print('NO')
	elif ol - k & 1:
		print('NO')
	else:
		odd = odd[-k:-1] + [n]
		print('YES')
		print(*odd)


import math

class Read:

	@staticmethod
	def int():
		return int(input())

	@staticmethod
	def list(sep=' '):
		return input().split(sep)

	@staticmethod
	def list_int(sep=' '):
		return list(map(int, input().split(sep)))

def solve():
	(n, k) = Read.list_int()
	a = Read.list_int()
	if k == 1:
		sum_ = 0
		for i in a:
			sum_ += i
		if sum_ % 2 == 1:
			print('YES')
			print(n)
		else:
			print('NO')
		return
	sum_ = 0
	res = ''
	count = 0
	index = 0
	for i in a:
		sum_ += i
		if sum_ % 2 == 1:
			res += str(index + 1) + ' '
			sum_ = 0
			count += 1
			if count == k - 1:
				break
		index += 1
	sum_ = 0
	for i in a[index + 1:]:
		sum_ += i
	if sum_ % 2 == 1:
		print('YES')
		print(res + str(n))
	else:
		print('NO')
query_count = Read.int()
for j in range(query_count):
	solve()


for t in range(int(input())):
	(n, k) = map(int, input().split())
	a = [int(i) for i in input().split()]
	a = [1 if i % 2 else 0 for i in a]
	oddsCount = sum(a)
	if oddsCount < k or (oddsCount - k) % 2 == 1:
		print('NO')
	else:
		print('YES')
		if k == 1:
			print(n)
		else:
			count = 0
			for i in range(n):
				if a[i]:
					print(i + 1, end=' ')
					count += 1
				if count == k - 1:
					break
			print(n)


T = int(input())
for t in range(T):
	(N, k) = map(int, input().split())
	L = list(map(int, input().split()))
	disp = 0
	l = list()
	for n in range(N):
		if L[n] % 2 != 0:
			disp = disp + 1
			l.append(n + 1)
	if disp < k:
		print('NO')
	elif k % 2 == 0 and disp % 2 != 0 or (k % 2 != 0 and disp % 2 == 0):
		print('NO')
	else:
		print('YES')
		for n in range(k - 1):
			print(l[n], end=' ')
		print(N)


def odd(n, k, ls):
	c = 0
	for i in range(n):
		if ls[i] & 1 == 1:
			c = c + 1
	if c < k or c % 2 != k % 2:
		print('NO')
	else:
		print('YES')
		for i in range(0, n - 1):
			if k == 1:
				break
			if ls[i] & 1 == 1:
				print(i + 1, end=' ')
				k = k - 1
		print(n)
t = int(input())
for i in range(t):
	(n, k) = map(int, input().split())
	ls = [int(j) for j in input().split()]
	odd(n, k, ls)


q = int(input())
for p in range(q):
	(n, k) = map(int, input().split())
	elements = list(map(int, input().split()))
	b = []
	tracker = 0
	for j in range(n):
		if elements[j] % 2 != 0:
			b.append(j + 1)
			tracker += 1
	if tracker < k or tracker % 2 != k % 2:
		print('NO')
	else:
		print('YES')
		stir = ''
		for x in range(k - 1):
			print(b[x], end=' ')
		print(stir + str(n))


from sys import stdin
input = stdin.readline
q = int(input())
for _ in range(q):
	(n, k) = [int(x) for x in input().split()]
	array = [int(x) for x in input().split()]
	only_odds = [(i, x) for (i, x) in enumerate(array, 1) if x % 2 != 0]
	l = len(only_odds)
	if l >= k and l % 2 == k % 2:
		result = [i for (i, v) in only_odds[:k]]
		result.pop()
		result.append(n)
		print('YES')
		print(*result)
	else:
		print('NO')


import sys
inf = float('inf')
(MOD, mod) = (1000000007, 998244353)
from array import array as _array
from bisect import bisect_left, bisect_right

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def input():
	return sys.stdin.readline().strip()
T = int(input())
while T > 0:
	(n, k) = get_ints()
	Arr = get_array()
	count = 0
	for i in Arr:
		if i & 1:
			count += 1
	if count < k:
		print('NO')
		T -= 1
		continue
	elif k & 1 and (not count & 1) or (not k & 1 and count & 1):
		print('NO')
		T -= 1
		continue
	else:
		print('YES')
		i = 0
		z = 0
		result = []
		while z < k - 1 and i < n:
			if Arr[i] & 1:
				result.append(i + 1)
				z += 1
			i += 1
		result.append(n)
		print(*result)
	T -= 1


from sys import __stdin__

def kappa(mas_l, k_l, n_l):
	ind = []
	temp_sum = 0
	for (i, x) in enumerate(mas_l):
		temp_sum += x
		if temp_sum & 1 == 1 and k_l > 1:
			k_l -= 1
			ind.append(i + 1)
			temp_sum = 0
		if i == n_l - 1 and temp_sum & 1 == 1 and (k_l == 1):
			ind.append(i + 1)
	return ind
q = int(input())
for i in range(q):
	(n, k) = [int(s) for s in __stdin__.readline().split()]
	mas = (int(s) for s in __stdin__.readline().split())
	res = kappa(mas, k, n)
	if len(res) == k:
		print('YES')
		print(' '.join((str(s) for s in res)))
	else:
		print('NO')


import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
from heapq import heappush as hpush
from heapq import heappop as hpop
mod = 10 ** 9 + 7

def ri(flag=0):
	if flag == 0:
		return [int(i) for i in sys.stdin.readline().split()]
	else:
		return int(sys.stdin.readline())
for _ in range(int(input())):
	(n, k) = ri()
	a = ri()
	su = [0]
	for i in a:
		su.append(su[-1] + i)
	ans = []
	pre = 0
	for i in range(len(a)):
		pre += a[i]
		if len(ans) != k - 1 and pre % 2 == 1:
			ans.append(i + 1)
			pre = 0
	if pre % 2 == 1:
		ans.append(n)
		pre = 0
	if pre != 0 or len(ans) != k:
		print('NO')
	else:
		print('YES')
		print(*ans)


t = int(input())
total = ''
for _ in range(t):
	(n, k) = map(int, input().split(' '))
	a = [int(i) for i in input().split(' ')]
	c = []
	for i in range(n):
		if a[i] % 2 != 0:
			c.append(i + 1)
	if len(c) < k:
		total += 'NO\n'
	elif (len(c) - k) % 2 == 1:
		total += 'NO\n'
	else:
		o = 'YES\n'
		x = c[:k - 1] + [n]
		o += ' '.join((str(i) for i in x))
		o += '\n'
		total += o
print(total)


from math import factorial, ceil
from sys import stdin, stdout
for _ in range(int(stdin.readline())):
	(n, k) = map(int, stdin.readline().split())
	l = list(map(int, stdin.readline().split()))
	c = 0
	l1 = []
	for i in range(n):
		if l[i] % 2 == 1:
			l1.append(i + 1)
			c += 1
	p = c - k
	if p % 2 == 0 and p >= 0:
		print('YES')
		l2 = l1[:k - 1] + [n]
		print(*l2)
	else:
		print('NO')


from sys import stdin, stdout
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353

def inp():
	return stdin.readline().strip()

def out(var, end='\n'):
	stdout.write(str(var) + '\n')

def outa(*var, end='\n'):
	stdout.write(' '.join(map(str, var)) + end)

def lmp():
	return list(mp())

def mp():
	return map(int, inp().split())

def smp():
	return map(str, inp().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(m, val) for j in range(n)]

def remadd(x, y):
	return 1 if x % y else 0

def ceil(a, b):
	return (a + b - 1) // b

def isprime(x):
	if x <= 1:
		return False
	if x in (2, 3):
		return True
	if x % 2 == 0:
		return False
	for i in range(3, int(sqrt(x)) + 1, 2):
		if x % i == 0:
			return False
	return True
for _ in range(int(inp())):
	(n, k) = mp()
	arr = lmp()
	c = 0
	ml = []
	for i in range(n):
		if arr[i] % 2:
			c += 1
			if len(ml) < k - 1:
				ml.append(i + 1)
	if c >= k and (c - k) % 2 == 0:
		print('YES')
		print(*ml, n)
	else:
		print('NO')


from sys import stdin
t = int(input())
for _ in range(t):
	(n, k) = map(int, stdin.readline().split())
	l = list(map(int, stdin.readline().split()))
	s = sum(l)
	if s % 2 == 0 and k % 2 != 0:
		print('NO')
	elif s % 2 != 0 and k % 2 == 0:
		print('NO')
	else:
		ans = []
		(count, s) = (0, 0)
		i = 0
		while count < k - 1 and i < n:
			s += l[i]
			if s % 2 != 0:
				ans.append(i + 1)
				count += 1
				s = 0
			i += 1
		if count != k - 1:
			print('NO')
		else:
			print('YES')
			ans.append(n)
			print(*ans)


from sys import stdout, stdin
print = stdout.write
input = stdin.readline
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	lis = list(map(int, input().split()))
	o = []
	for i in range(n):
		if lis[i] % 2 == 1:
			o.append(i)
	if len(o) < k:
		print('NO\n')
		continue
	if abs(k - len(o)) % 2 == 1:
		print('NO\n')
		continue
	print('YES\n')
	for i in range(k):
		if i == k - 1:
			print(str(n) + '\n')
			break
		print(str(o[i] + 1) + ' ')


n = int(input())
lst = []
for k in range(n):
	ql = list(map(int, input().split()))
	L = list(map(int, input().split()))
	lst.append((ql[:], L[:]))
for couple in lst:
	(ql, l) = couple
	q = ql[0]
	m = ql[1]
	count = 0
	mem = []
	for i in range(q):
		if l[i] % 2 == 1:
			count += 1
			mem.append(i)
	if count >= m and (count - m) % 2 == 0:
		print('YES')
		sol = ''
		for i in range(m - 1):
			sol += str(mem[i] + 1) + ' '
		sol += str(q)
		print(sol)
	else:
		print('NO')


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	a = [int(x) for x in input().split()]
	if sum(a) % 2 != k % 2:
		print('NO')
		continue
	(b, f) = ([0] * k, False)
	for j in range(1, k):
		for i in range(b[j - 1], n):
			if a[i] % 2:
				b[j] = i + 1
				break
		else:
			f = True
	if f:
		print('NO')
	else:
		print('YES')
		print(*b[1:] + [n])


from sys import stdin
q = int(stdin.readline())
for query in range(q):
	(n, k) = map(int, stdin.readline().split())
	a = list(map(int, stdin.readline().split()))
	ans = [0]
	for i in range(n):
		if k == 1:
			break
		if a[i] % 2 == 0:
			continue
		ans.append(i + 1)
		k -= 1
	if k != 1 or sum(a[ans[-1]:]) % 2 == 0:
		print('NO')
		continue
	print('YES')
	ans.append(n)
	print(' '.join(map(str, ans[1:])))


q = int(input())
ans = []
for _ in range(q):
	(n, k) = map(int, input().split())
	a = [i % 2 for i in list(map(int, input().split()))]
	a1 = [i + 1 for i in range(n) if a[i] == 1]
	c = a.count(1)
	if c < k or k % 2 != c % 2:
		ans.append('NO')
	else:
		count = 0
		ap = []
		for i in range(k - 1):
			ap.append(a1[i])
		ap.append(n)
		ans.append(ap)
for el in ans:
	if el != 'NO':
		print('YES')
		print(*el)
	else:
		print(el)


import sys
input = lambda : sys.stdin.readline().strip()
T = int(input())
for i in range(T):
	(n, k) = map(int, input().split())
	ls = list(map(int, input().split()))
	odd = 0
	for i in ls:
		if i % 2:
			odd += 1
	if odd - k < 0 or (odd - k) % 2:
		print('NO')
	else:
		print('YES')
		cnt = 0
		for i in range(n):
			if cnt == k - 1:
				break
			if ls[i] % 2:
				print(i + 1, end=' ')
				cnt += 1
		print(n)


import sys
input_ = lambda : map(int, sys.stdin.readline().split())
q = int(input())
for i in range(q):
	(n, k) = input_()
	pos = [i + 1 for (i, x) in enumerate(input_()) if x % 2 == 1]
	if (len(pos) - k) % 2 == 0 and len(pos) >= k:
		print('YES')
		for j in range(k - 1):
			print(pos[j], end=' ')
		print(n)
	else:
		print('NO')


import sys
from collections import defaultdict
input = sys.stdin.readline

def main():
	q = int(input())
	for _ in range(q):
		(n, k) = map(int, input().split())
		a = list(map(int, input().split()))
		res = [-1] * k
		pos = 0
		sum_sofar = 0
		for i in range(n):
			sum_sofar += a[i]
			if sum_sofar % 2 == 1 and pos < k - 1:
				res[pos] = i + 1
				pos += 1
				sum_sofar = 0
		if pos < k - 1 or sum_sofar % 2 == 0:
			print('NO')
		else:
			res[pos] = n
			print('YES')
			print(*res)
main()


import sys

def inpu():
	return sys.stdin.readline().strip()
q = int(inpu())
for i in range(q):
	(n, k) = [int(i) for i in inpu().split()]
	x = [int(i) for i in inpu().split()]
	s = 0
	otv = []
	for j in range(n):
		if x[j] % 2 != 0:
			if len(otv) < k - 1:
				otv.append(j + 1)
			s += 1
	otv.append(len(x))
	if s < k:
		print('NO')
	elif s % 2 != 0 and k % 2 != 0 or (s % 2 == 0 and k % 2 == 0):
		print('YES')
		print(*otv)
	else:
		print('NO')


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	arr = []
	count = 0
	for i in range(len(a)):
		if a[i] & 1:
			count += 1
			arr.append(i + 1)
	if count < k:
		print('NO')
	elif count - (k - 1) & 1:
		print('YES')
		for i in range(k - 1):
			print(arr[i], end=' ')
		print(n)
	else:
		print('NO')


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	li = []
	s = 0
	t = 0
	for i in range(n):
		s += a[i]
		if s % 2 == 1 and t < k - 1:
			t += 1
			li.append(i + 1)
			s = 0
		if t == k - 1 and i == n - 1 and (s % 2 == 1):
			li.append(i + 1)
	if len(li) == k and li[-1] == n:
		print('YES')
		print(*li)
	else:
		print('NO')


import sys
input = sys.stdin.readline
print = sys.stdout.write

def main():
	q = int(input())
	for _ in range(q):
		(n, k) = map(int, input().split())
		tab = list(map(int, input().split()))
		inc = 0
		for x in range(n):
			if tab[x] % 2 != 0:
				inc += 1
		if k % 2 != inc % 2 or inc < k:
			print('NO\n')
		else:
			print('YES\n')
			for x in range(n):
				if k > 1:
					if tab[x] % 2 != 0:
						print(str(x + 1) + ' ')
						k -= 1
				else:
					break
			print(str(n) + '\n')
main()


T = int(input())
for t in range(T):
	(N, K) = map(int, input().split())
	L = list(map(int, input().split()))
	dispari = 0
	c = list()
	for n in range(N):
		if L[n] % 2 != 0:
			dispari = dispari + 1
			c.append(n + 1)
	if dispari < K:
		print('NO')
	if dispari == K:
		print('YES')
		for m in range(dispari - 1):
			print(c[m], end=' ')
		print(N)
	if dispari > K:
		if K % 2 == 0 and dispari % 2 != 0 or (K % 2 != 0 and dispari % 2 == 0):
			print('NO')
		else:
			print('YES')
			for i in range(K - 1):
				print(c[i], end=' ')
			print(N)


t = int(input())
for T in range(t):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	o = []
	for i in range(n):
		if a[i] % 2 != 0:
			o.append(i + 1)
	if len(o) >= k and (len(o) - k) % 2 == 0:
		print('YES')
		for j in range(k - 1):
			print(o[j], end=' ')
		print(n)
	else:
		print('NO')


from sys import stdin, stdout
for q in range(int(stdin.readline())):
	(n, k) = map(int, stdin.readline().split())
	l = list(map(int, stdin.readline().split()))
	pos = []
	for i in range(n):
		if l[i] & 1:
			pos.append(i + 1)
	if len(pos) >= k and (len(pos) - k) % 2 == 0:
		stdout.write('YES\n')
		for i in range(k - 1):
			stdout.write(str(pos[i]) + ' ')
		stdout.write(str(n) + '\n')
	else:
		stdout.write('NO\n')


from sys import stdin, stdout
import sys
import math
t = int(stdin.readline())
for i in range(t):
	(n, k) = list(map(int, stdin.readline().split()))
	a = list(map(int, stdin.readline().split()))
	if k % 2 == 0 and sum(a) % 2 == 1 or (k % 2 == 1 and sum(a) % 2 == 0):
		print('NO')
		continue
	arr = []
	c = 0
	idx = 1
	lsum = 0
	fl = 0
	for i in range(n):
		lsum += a[i]
		if lsum % 2 == 1:
			arr.append(i + 1)
			c += 1
			if c == k:
				if i == n - 1:
					print('YES')
					print(*arr)
					fl = 1
				else:
					idx = sum(a[i + 1:])
				break
			lsum = 0
	if fl == 1:
		continue
	if idx % 2 == 0:
		print('YES')
		arr.pop(-1)
		arr.append(n)
		print(*arr)
	else:
		print('NO')


from sys import stdin
c = int(stdin.readline().strip())
for cas in range(c):
	(n, m) = list(map(int, stdin.readline().strip().split()))
	s = list(map(int, stdin.readline().strip().split()))
	sm = 0
	ans = []
	ind = -1
	for i in range(n):
		if m == 1:
			ind = i
			break
		sm += s[i]
		if sm % 2 != 0:
			ans.append(i + 1)
			sm = 0
			m -= 1
	if ind == -1:
		print('NO')
		continue
	sm = sum(s[ind:])
	if sm % 2 != 0:
		ans.append(n)
		print('YES')
		print(*ans)
	else:
		print('NO')


from __future__ import division, print_function
from sys import stdin, stdout
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
import heapq
from math import ceil, floor, log, sqrt, factorial, pow, pi, gcd

def ii():
	return int(input())

def si():
	return str(input())

def mi():
	return map(int, input().split())

def li():
	return list(mi())

def fii():
	return int(stdin.readline())

def fsi():
	return str(stdin.readline())

def fmi():
	return map(int, stdin.readline().split())

def fli():
	return list(fmi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def getKey(item):
	return item[0]

def sort2(l):
	return sorted(l, key=getKey)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

def powerMod(x, y, p):
	res = 1
	x %= p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000

def dfs(v, c):
	if visited[v]:
		if col[v] != c:
			print('-1')
			exit()
		return
	col[v] = c
	visited[v] = 1
	for i in graph[v]:
		dfs(i, c ^ 1)

def bfs(d, v):
	q = []
	q.append(v)
	visited[v] = 1
	while len(q) != 0:
		x = q[0]
		q.pop(0)
		for i in d[x]:
			if visited[i] != 1:
				visited[i] = 1
				q.append(i)
		print(x)

def make_graph(e):
	d = {}
	for i in range(e):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
		if y not in d.keys():
			d[y] = [x]
		else:
			d[y].append(x)
	return d

def gr2(n):
	d = {}
	for i in range(n):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
	return d

def connected_components(graph):
	seen = set()

	def dfs(v):
		vs = set([v])
		component = []
		while vs:
			v = vs.pop()
			seen.add(v)
			vs |= set(graph[v]) - seen
			component.append(v)
		return component
	ans = []
	for v in graph:
		if v not in seen:
			d = dfs(v)
			ans.append(d)
	return ans

def primeFactors(n):
	s = set()
	while n % 2 == 0:
		s.add(2)
		n = n // 2
	for i in range(3, int(sqrt(n)) + 1, 2):
		while n % i == 0:
			s.add(i)
			n = n // i
	if n > 2:
		s.add(n)
	return s
t = fii()
for a0 in range(t):
	(n, k) = fmi()
	l = fli()
	count = 0
	out = []
	for i in range(n):
		if l[i] % 2 == 1:
			count += 1
	if count < k:
		print('NO')
	elif abs(count - k) % 2 == 1:
		print('NO')
	else:
		count = 0
		print('YES')
		for i in range(n):
			if count == k - 1:
				break
			elif l[i] % 2 == 1:
				out.append(str(i + 1))
				count += 1
		out.append(str(n))
		print(' '.join(out))


import sys
input = sys.stdin.readline
q = int(input())
for i in range(q):
	(n, k) = map(int, input().split())
	l = list(map(int, input().split()))
	if k == 1:
		if sum(l) % 2:
			print('YES')
			print(n)
		else:
			print('NO')
		continue
	ans = []
	for (j, L) in enumerate(l, 1):
		if L % 2:
			ans.append(str(j))
		if len(ans) == k - 1:
			if sum(l[j:]) % 2:
				ans.append(str(n))
				print('YES')
				print(' '.join(ans))
			else:
				print('NO')
			break
	else:
		print('NO')


def answer():
	(n, k) = map(int, input().split(' '))
	a_list = list(map(int, input().split(' ')))
	end_i_list = []
	count = 0
	fail = True
	start_i = 0
	end_i = -1
	if n >= 2:
		for i in range(n):
			a = a_list[i] % 2
			if count <= k - 2 and a == 1:
				end_i = i
				end_i_list.append(end_i + 1)
				count += 1
				start_i = i + 1
			if count == k - 1:
				nokori_start_i = end_i + 1
				if i == n - 1:
					return ('NO', None)
				else:
					nokori_sum = sum(a_list[nokori_start_i:])
					if nokori_sum % 2 == 1:
						end_i_list.append(n)
						fail = False
						count += 1
					else:
						return ('NO', None)
				break
	elif a_list[0] % 2 == 1:
		fail = False
		end_i_list = [1]
	else:
		return ('NO', None)
	if fail:
		return ('NO', None)
	else:
		index_txt = ' '.join(map(str, end_i_list))
		return ('YES', index_txt)
n = int(input())
for _ in range(n):
	(out0, out1) = answer()
	print(out0)
	if out1 is not None:
		print(out1)


import sys

def fastio():
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip('\r\n')
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	l = list(map(int, input().split()))
	c = 0
	ind = [str(len(l))]
	for i in range(len(l) - 1, -1, -1):
		if l[i] % 2:
			c += 1
			if c > 1:
				ind.append(str(i + 1))
	if c - k >= 0 and (c - k) % 2 == 0:
		print('YES')
		print(' '.join(ind[:k][::-1]))
	else:
		print('NO')


q = int(input())
for _ in range(q):
	(n, k) = [int(i) for i in input().split()]
	a = [int(i) % 2 for i in input().split()]
	num_odd = sum(a)
	if num_odd < k or (k + num_odd) % 2 != 0:
		print('NO')
	else:
		print('YES')
		(r, act_r) = (0, 0)
		while r != k - 1:
			if a[act_r] % 2 == 1:
				r += 1
				print(act_r + 1, end=' ')
			act_r += 1
		print(n)


import math
from sys import stdin, stdout
from bisect import bisect_left, bisect_right

def isprime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def freq(l):
	f = {}
	for i in l:
		if i in f:
			f[i] += 1
		else:
			f[i] = 1
	return f
inp = lambda : int(stdin.readline())
sip = lambda : stdin.readline()
mulip = lambda : map(int, stdin.readline().split())
lst = lambda : list(map(int, stdin.readline().split()))
slst = lambda : list(sip())
for _ in range(inp()):
	(n, k) = mulip()
	A = lst()
	idx = []
	for i in range(n):
		if A[i] % 2 != 0:
			idx.append(i + 1)
	if len(idx) < k:
		print('NO')
	elif len(idx) % 2 == 0 and k % 2 != 0:
		print('NO')
	elif len(idx) % 2 != 0 and k % 2 == 0:
		print('NO')
	else:
		print('YES')
		print(*idx[:k - 1], n)


from sys import stdin
lines = stdin.read().splitlines()
q = int(lines[0])
lineIndex = 1
for _ in range(q):
	(n, k) = list(map(int, lines[lineIndex].split()))
	lineIndex += 1
	a = list(map(int, lines[lineIndex].split()))
	lineIndex += 1
	res = []
	index = 0
	while index < n and k > 1:
		if a[index] % 2 == 1:
			res.append(index + 1)
			k -= 1
		index += 1
	if index < n and sum(a[index:]) % 2 == 1:
		res.append(n)
		print('YES')
		print(' '.join(map(str, res)))
	else:
		print('NO')


from sys import stdin, stdout

def odd_sum_seg(arr, n, k):
	odd = 0
	for i in range(n):
		if arr[i] % 2 == 1:
			odd += 1
	if odd < k:
		print('NO')
		return
	elif odd % 2 != k % 2:
		print('NO')
		return
	else:
		print('YES')
		count = 0
		for i in range(n):
			if count < k - 1:
				if arr[i] % 2 == 1:
					print(i + 1, end=' ')
					count += 1
		print(n, end='\n')
		return
t = int(stdin.readline())
while t:
	nk = list(map(int, stdin.readline().rstrip().split()))
	n = nk[0]
	k = nk[1]
	arr = list(map(int, stdin.readline().rstrip().split()))
	odd_sum_seg(arr, n, k)
	t = t - 1


def solve(arr, n, k, ans):
	odd = []
	for i in range(n):
		if arr[i] % 2 != 0:
			odd.append(i)
	if len(odd) < k or (len(odd) - k + 1) % 2 == 0:
		ans.append(['NO'])
		return
	query = ['YES']
	indices = ''
	for i in range(k - 1):
		indices += str(odd[i] + 1) + ' '
	indices += str(n)
	query.append(indices)
	ans.append(query)

def main():
	ans = []
	q = int(input())
	for i in range(q):
		(n, k) = map(int, input().split())
		arr = list(map(int, input().split()))
		solve(arr, n, k, ans)
	for i in ans:
		for j in i:
			print(j)
main()


for _ in range(int(input())):
	(n, k) = [int(i) for i in input().split()]
	a = [int(i) for i in input().split()]
	if n == 1 and k == 1:
		if a[0] % 2 & 1:
			print('YES')
			print(1)
		else:
			print('NO')
	else:
		s = 0
		p = []
		l = 0
		for i in range(n):
			s = s + a[i]
			l = l + a[i]
			if s & 1:
				p.append(i + 1)
				s = 0
		if l & 1 != k & 1 or k > n:
			print('NO')
		elif len(p) < k - 1:
			print('NO')
		else:
			print('YES')
			print(*p[:k - 1], n)


import os
import math
import operator
import sys
from collections import defaultdict
from io import BytesIO, IOBase

def main():
	for _ in range(int(input())):
		(n, k) = map(int, input().split())
		arr = [int(k) for k in input().split()]
		res = []
		lis = []
		for i in range(n):
			if arr[i] % 2 != 0:
				lis.append(i)
		if len(lis) >= k and (len(lis) - k) % 2 == 0:
			print('YES')
			for i in range(k - 1):
				print(lis[i] + 1, end=' ')
			print(n)
		else:
			print('NO')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


def int_list():
	return [int(c) for c in input().split()]

def int1():
	return int(input())

def str_list():
	return [c for c in input().split()]

def str1():
	return input()
q = int1()
res = []
for i in range(q):
	(n, k) = int_list()
	a = int_list()
	mid_sum = 0
	cont = 0
	ex = False
	res_arr = []
	for j in range(n):
		if k == 1:
			ex = True
			cont = j
			break
		mid_sum += a[j]
		if mid_sum % 2 == 1:
			k -= 1
			mid_sum = 0
			res_arr.append(j + 1)
	curr_res = False
	if ex:
		s = 0
		for j in range(cont, n):
			s += a[j]
		if s % 2 == 1:
			curr_res = True
			res_arr.append(n)
	if curr_res:
		res.append(res_arr)
	else:
		res.append([])
for res_list in res:
	if len(res_list) > 0:
		print('YES')
		res_str = ''
		for num in res_list:
			res_str += str(num) + ' '
		print(res_str[:-1])
	else:
		print('NO')


from sys import stdin, stdout
t = int(stdin.readline())
for _ in range(t):
	(n, k) = map(int, stdin.readline().split())
	arr = list(map(int, stdin.readline().split()))
	odd_idx = []
	le = 0
	for a in range(1, n + 1):
		if arr[a - 1] % 2 == 1:
			odd_idx.append(a)
			le += 1
	if le < k:
		print('NO')
	elif (le - k) % 2 == 0:
		print('YES')
		le = 0
		oi = []
		for i in odd_idx:
			if le == k - 1:
				break
			else:
				le += 1
				oi.append(str(i))
		oi.append(str(n))
		print(' '.join(oi))
	else:
		print('NO')


from sys import stdin
input = stdin.readline
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	ans = []
	for i in range(n):
		if a[i] & 1:
			ans.append(i + 1)
	if len(ans) < k:
		print('NO')
	elif k - len(ans) & 1:
		print('NO')
	else:
		print('YES')
		ans[-1] = n
		print(*ans[len(ans) - k:])


import sys
input = sys.stdin.readline
set_odd = {'1', '3', '5', '7', '9'}
for _ in range(int(input())):
	(n, k) = list(map(int, input().split()))
	a = [1 if x[-1] in set_odd else 0 for x in input().split()]
	a_sum = sum(a)
	if a_sum >= k and a_sum % 2 == k % 2:
		print('YES')
		res = [0] * k
		res[-1] = n
		cnt = 0
		if k > 1:
			for (i, x) in enumerate(a):
				if x == 1:
					res[cnt] = i + 1
					cnt += 1
					if cnt >= k - 1:
						break
		print(*res)
	else:
		print('NO')


def oddSegments(a, b, split):
	count = 0
	indices = []
	for i in range(a):
		if split[i] % 2 != 0:
			count += 1
			indices.append(i + 1)
	if count < b or (count - b) % 2 != 0:
		print('NO')
	else:
		print('YES')
		print(*indices[:b - 1], a)
q = int(input())
for j in range(q):
	(n, k) = map(int, input().strip().split())
	listToSplit = list(map(int, input().strip().split()))
	oddSegments(n, k, listToSplit)


from sys import stdin
for _ in range(int(stdin.readline())):
	p = []
	x = 0
	(n, k) = map(int, stdin.readline().split())
	a = list(map(int, stdin.readline().split()))
	for i in range(n):
		if a[i] % 2:
			if x < k - 1:
				p.append(i + 1)
			x += 1
	if x >= k and (not (x - k) % 2):
		print('YES')
		print(*p, n)
	else:
		print('NO')


import sys
input = sys.stdin.buffer.readline
q = int(input())
for _ in range(q):
	(n, k) = map(int, input().split())
	A = list(map(int, input().split()))
	B = []
	for (i, a) in enumerate(A):
		if a % 2 == 1:
			B.append(i + 1)
	if len(B) < k:
		print('NO')
	elif (len(B) - k) % 2 == 0:
		print('YES')
		B = B[0:k]
		B[-1] = n
		print(*B)
	else:
		print('NO')


q = int(input())
for i in range(q):
	(n, k) = [int(x) for x in input().split()]
	a = [int(x) % 2 for x in input().split()]
	answer = []
	if k == 1:
		if sum(a) % 2 == 1:
			print('YES')
			print(n)
		else:
			print('NO')
	else:
		for i in range(n):
			if a[i] == 1:
				answer.append(i + 1)
				k -= 1
			if k == 1:
				if sum(a[i + 1:]) % 2 == 1:
					answer.append(n)
					print('YES')
					print(*answer)
				else:
					print('NO')
				break
		else:
			print('NO')


import sys
input = sys.stdin.readline
q = int(input())
while q:
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	cnt = 0
	tot = 0
	pre = 0
	ans = []
	for i in a:
		tot += 1
		if i % 2:
			cnt += 1
			if cnt < k:
				ans.append(tot)
	ans.append(n)
	t = cnt - k
	if t < 0 or t % 2:
		q -= 1
		print('NO')
		continue
	print('YES')
	ans = ' '.join(map(str, ans))
	print(ans)
	q -= 1


import sys
q = int(input())
while q > 0:
	(n, k) = map(int, sys.stdin.readline().split())
	s = list(map(int, sys.stdin.readline().split()))
	ans = []
	for i in range(n):
		if s[i] % 2 == 1:
			ans.append(i + 1)
	if len(ans) >= k and (len(ans) - k) % 2 == 0:
		ans = ans[:k]
		ans[len(ans) - 1] = n
		print('YES')
		print(*ans)
	else:
		print('NO')
	q -= 1


import sys
input = sys.stdin.readline
out = sys.stdout

def main():
	q = int(input())
	for _ in range(q):
		(n, k) = map(int, input().split())
		a = list(map(int, input().split()))
		(odd, even) = (0, 0)
		for item in a:
			if item % 2 == 0:
				even += 1
			else:
				odd += 1
		if odd < k:
			out.write('NO' + '\n')
		else:
			(ans, i) = ([], 0)
			while k != 1 and i < n:
				if a[i] % 2 > 0:
					ans.append(i + 1)
					k -= 1
				i += 1
			count_tail_odd = 0
			for j in range(i, n):
				if a[j] % 2 == 1:
					count_tail_odd += 1
			if count_tail_odd % 2 == 0:
				out.write('NO' + '\n')
			else:
				out.write('YES' + '\n')
				ans.append(n)
				out.write(' '.join((str(k) for k in ans)) + '\n')
main()


from sys import stdin

def arr_inp(n):
	if n == 1:
		return [int(x) for x in stdin.readline().split()]
	elif n == 2:
		return [float(x) for x in stdin.readline().split()]
	else:
		return list(stdin.readline()[:-1])
for i in range(int(input())):
	(n, k) = arr_inp(1)
	a = arr_inp(1)
	odds = len(list(filter(lambda x: x & 1, a)))
	if odds < k or (odds - k) % 2:
		print('NO')
	else:
		print('YES')
		c = 1
		for j in range(n):
			if c == k:
				break
			if a[j] & 1:
				c += 1
				print(j + 1, end=' ')
		print(n, end='\n')


import sys
from sys import stdin, stdout
import bisect
import math
import heapq

def modinv(n, p):
	return pow(n, p - 2, p)

def cin():
	return map(int, sin().split())

def ain():
	return list(map(int, sin().split()))

def sin():
	return input()

def inin():
	return int(input())
import math

def Divisors(n):
	l = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
	return l

def main():
	t = inin()
	for _ in range(t):
		(n, k) = cin()
		j = 0
		a = ain()
		ans = []
		for i in range(n):
			j += a[i]
			if k > 1:
				if j % 2 == 1:
					j = 0
					ans.append(i + 1)
					k -= 1
		if j % 2 == 1:
			print('YES')
			ans.append(n)
			print(*ans)
		else:
			print('NO')
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import sys

class ostream:

	def __lshift__(self, a):
		sys.stdout.write(str(a))
		return self
cout = ostream()
endl = '\n'

def readnumbers(zero=0):
	conv = ord if py2 else lambda x: x
	A = []
	numb = zero
	sign = 1
	i = 0
	s = sys.stdin.buffer.read()
	try:
		while True:
			if s[i] >= b'0'[0]:
				numb = 10 * numb + conv(s[i]) - 48
			elif s[i] == b'-'[0]:
				sign = -1
			elif s[i] != b'\r'[0]:
				A.append(sign * numb)
				numb = zero
				sign = 1
			i += 1
	except:
		pass
	if s and s[-1] >= b'0'[0]:
		A.append(sign * numb)
	return A
main()


for _ in range(int(input())):
	(n, k) = list(map(int, input().split()))
	arr = list(map(int, input().split()))
	if k == 1 and sum(arr) % 2:
		print('YES')
		print(n)
		continue
	elif k == 1:
		print('NO')
		continue
	ans = []
	tot = 0
	for (ind, i) in enumerate(arr):
		tot += i
		if tot % 2:
			k -= 1
			ans.append(ind + 1)
			tot = 0
			if not k:
				break
	if tot != 0 and tot % 2 == 0 or k != 0:
		print('NO')
		continue
	temp = sum(arr[ans[-2]:])
	if temp % 2:
		print('YES')
		ans.pop()
		for j in ans:
			print(j, end=' ')
		print(n)
	else:
		print('NO')


for i in range(int(input())):
	(n, k) = [int(a) for a in input().split()]
	x = [int(a) % 2 for a in input().split()]
	sx = sum(x)
	if (sx - k) % 2 == 1 or k > sx:
		print('NO')
	else:
		print('YES')
		t = 0
		for i in range(k - 1):
			t = x.index(1, t)
			t += 1
			print(t, end=' ')
		print(n)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
t = int(input())
for _ in range(t):
	(n, k) = map(int, input().split())
	l = list(map(int, input().split()))
	c = 0
	l1 = []
	for i in range(n):
		c += l[i]
		if c % 2 != 0:
			if len(l1) == k - 1:
				l1.append(n)
				break
			else:
				l1.append(i + 1)
			c = 0
	if k == 1:
		if sum(l) % 2 != 0:
			print('YES')
			print(n)
		else:
			print('NO')
	elif len(l1) < k:
		print('NO')
	elif sum(l[l1[-2]:l1[-1]]) % 2 != 0:
		print('YES')
		print(*l1)
	else:
		print('NO')


from sys import stdin
input = stdin.readline
q = int(input())
for i in range(q):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	A = [j + 1 for j in range(n) if a[j] % 2 != 0]
	if len(A) >= k and (len(A) - k) % 2 == 0:
		print('YES')
		if k == 1:
			print(n)
		else:
			print(*A[:k - 1], n)
	else:
		print('NO')


import sys
input = sys.stdin.readline
a = int(input())
for i in range(a):
	(x, k) = map(int, input().split())
	z = list(map(int, input().split()))
	ans = []
	bini = []
	for i in range(len(z)):
		if z[i] % 2 == 1:
			ans.append(1)
			bini.append(i + 1)
		else:
			ans.append(2)
	if len(bini) < k or (len(bini) - k) % 2 == 1:
		print('NO')
	else:
		print('YES')
		for i in range(k - 1):
			print(bini[i], end=' ')
		print(len(z))


q = int(input())
while q > 0:
	q -= 1
	n_k = input()
	n_k = n_k.split()
	n = int(n_k[0])
	k = int(n_k[1])
	s = 0
	list_a = input()
	list_a = list_a.split(' ')
	for i in range(n):
		list_a[i] = int(list_a[i])
		s = s + list_a[i]
	if s % 2 == 0 and k % 2 != 0 or (s % 2 != 0 and k % 2 == 0):
		print('NO')
		continue
	border = []
	temp_sum = 0
	if k != 1:
		for i in range(n):
			temp_sum = temp_sum + list_a[i]
			if temp_sum % 2 != 0:
				border.append(i + 1)
				temp_sum = 0
			if len(border) == k - 1:
				break
		temp_len = len(border)
		if temp_len == k - 1:
			print('YES')
		else:
			print('NO')
			continue
		for i in range(temp_len):
			print(border[i], end=' ')
		print(n)
	else:
		print('YES')
		print(n)


from collections import defaultdict
import sys
q = int(sys.stdin.readline())
while q:
	(n, k) = map(int, sys.stdin.readline().split())
	arr = list(map(int, sys.stdin.readline().split()))
	a = []
	oddcount = 0
	for i in range(len(arr)):
		if arr[i] % 2 != 0:
			oddcount += 1
	if oddcount < k:
		print('NO')
	elif oddcount >= k:
		if oddcount % 2 == k % 2:
			print('YES')
			count = 0
			i = 0
			while i < len(arr) and count < k - 1:
				if arr[i] % 2 != 0:
					print(i + 1, end=' ')
					count += 1
				i += 1
			print(n)
		else:
			print('NO')
	q -= 1


T = int(input())
for t in range(T):
	(N, k) = map(int, input().split())
	L = list(map(int, input().split()))
	disp = 0
	A = []
	for n in range(N):
		if L[n] % 2 == 1:
			disp += 1
			A.append(n + 1)
	if disp < k:
		print('NO')
	if disp == k:
		print('YES')
		for n in range(k - 1):
			print(A[n], end=' ')
		print(N)
	if disp > k:
		if (disp - k) % 2 == 1:
			print('NO')
		else:
			print('YES')
			for n in range(k - 1):
				print(A[n], end=' ')
			print(N)


t = int(input())
while t != 0:
	(n, k) = map(int, input().split())
	arr = list(map(int, input().split()))[:n]
	temp = []
	Kpos = {}
	oddCount = 0
	for i in range(n):
		if arr[i] & 1:
			if oddCount <= k:
				Kpos[oddCount] = i + 1
			oddCount += 1
	if oddCount < k:
		print('NO')
	elif not oddCount - k + 1 & 1:
		print('NO')
	else:
		print('YES')
		j = 0
		for i in Kpos:
			if j > k - 2:
				break
			print(Kpos[i], end=' ')
			j += 1
		print(n)
	t -= 1


from sys import stdin, stdout
for _ in range(int(stdin.readline())):
	(n, k) = list(map(int, stdin.readline().split()))
	a = list(map(lambda x: int(x) % 2, stdin.readline().split()))
	ans = []
	odd = a.count(1)
	if odd - (k - 1) & 1 == 0 or odd < k:
		print('NO')
		continue
	for i in range(n):
		if a[i] & 1:
			if k == 1:
				ans += [n]
				break
			ans += [i + 1]
			k -= 1
	print('YES')
	print(*ans)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = list(map(int, input().split()))
	c = 0
	f = True
	for i in range(n):
		if l[i] % 2:
			c += 1
	l1 = []
	if c < m or c % 2 != m % 2:
		f = False
	if f == True:
		print('YES')
		for i in range(n):
			if m == 1:
				break
			if l[i] % 2:
				l1.append(i + 1)
				m -= 1
		l1.append(n)
		print(*l1)
	else:
		print('NO')


q = int(input())
out = ''
for _ in range(q):
	(n, k) = list(map(int, input().split()))
	arr = list(map(int, input().split()))
	answer = []
	s = 0
	for i in range(n):
		s = (s + arr[i]) % 2
		if s == 1 and k != 1:
			answer.append(i + 1)
			k -= 1
			s = 0
	answer.append(n)
	if s == 1 and k == 1:
		out += 'YES\n' + ' '.join(map(str, answer)) + '\n'
	else:
		out += 'NO\n'
print(out)


from sys import stdin
for _ in range(int(input())):
	(n, k) = map(int, stdin.readline().split())
	lst = list(map(int, stdin.readline().split()))
	(nechet, res) = (0, [])
	for (i, x) in enumerate(lst):
		if x % 2 == 1:
			nechet += 1
		if k > 1 and nechet == 1:
			res.append(i + 1)
			k -= 1
			nechet = 0
	if nechet % 2 == 1:
		print('YES')
		res.append(n)
		print(*res)
	else:
		print('NO')


import sys
q = int(input())
for i in range(q):
	(n, k) = map(int, sys.stdin.readline().split())
	x = list(map(int, sys.stdin.readline().split()))
	odd = []
	for i in range(n):
		if x[i] % 2 != 0:
			odd.append(i + 1)
	if len(odd) >= k and (len(odd) - k) % 2 == 0:
		odd = odd[:k]
		odd[len(odd) - 1] = n
		print('YES')
		print(*odd)
	else:
		print('NO')


n = int(input())
a = []
for i in range(n):
	(n, k) = map(int, input().split())
	b = list(map(int, input().split()))
	a.append([b, [n, k]])
for i in a:
	c = i[0]
	n = i[1][0]
	k = i[1][1]
	p = 0
	for j in c:
		if j % 2 != 0:
			p += 1
	if p < k:
		print('NO')
	else:
		d = []
		q = 0
		m = 0
		for j in range(n):
			if q != k - 1:
				if c[j] % 2 == 1:
					d.append(j + 1)
					m = j + 1
					q += 1
			else:
				d.append(n)
				break
		if (p - k + 1) % 2 == 0:
			print('NO')
		else:
			print('YES')
			print(*d)


from sys import stdin, stdout
input = stdin.readline
t = int(input())
for j in range(0, t):
	(n, k) = list(map(int, input().split()))
	a = list(map(int, input().split()))
	c = 0
	for i in range(0, n):
		if a[i] % 2 != 0:
			c = c + 1
	if c < k or k % 2 != c % 2:
		print('NO')
	else:
		print('YES')
		for i in range(0, n):
			if k == 1:
				break
			elif a[i] % 2 == 1:
				k -= 1
				print(i + 1, end=' ')
		print(n)


import sys
import math
from collections import defaultdict
DEBUG = True
fast = sys.stdin.readline
fasti = lambda : fast().split('\n')[0]
listInt = lambda : [int(x) for x in fasti().split(' ')]
listStr = lambda : [x for x in fasti().split(' ')]
readInt = lambda : int(fasti())
readStr = lambda : fasti()

def whatIs(value, name=''):
	if not DEBUG:
		return
	print(f'[{name}: {value}]')

def solve():
	(n, k) = listInt()
	lst = listInt()
	(nodd, res) = (0, [])
	for (i, x) in enumerate(lst):
		if x % 2 == 1:
			nodd += 1
		if k > 1 and nodd == 1:
			res.append(i + 1)
			k -= 1
			nodd = 0
	if nodd % 2 == 1:
		print('YES')
		res.append(n)
		print(*res)
	else:
		print('NO')
t = readInt()
for _ in range(t):
	solve()


q = int(input())
for ii in range(q):
	(n, k) = [int(y) for y in input().split()]
	lst = [int(x) for x in input().split()]
	(count, result) = (0, list())
	for i in lst:
		if i % 2 != 0:
			count += 1
	if k % 2 == 0:
		if count % 2 != 0:
			print('NO')
			continue
	if k % 2 != 0:
		if count % 2 == 0:
			print('NO')
			continue
	if k > count:
		print('NO')
		continue
	print('YES')
	if k == 1:
		print(n)
		continue
	for i in range(n):
		if lst[i] % 2 != 0:
			result.append(i + 1)
			k -= 1
		if k == 1:
			result.append(n)
			break
	print(*result)


from sys import stdin
stdin.readline

def mp():
	return list(map(int, stdin.readline().strip().split()))

def it():
	return int(stdin.readline().strip())
for _ in range(it()):
	(n, k) = mp()
	l = mp()
	v = []
	t = 0
	for i in range(n):
		if l[i] & 1:
			t += 1
			v.append(i + 1)
	if t < k or t - k & 1:
		print('NO')
	else:
		print('YES')
		for i in range(k - 1):
			print(v[i], end=' ')
		print(n)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def IF(c, t, f):
	return t if c else f

def YES(c):
	return IF(c, 'YES', 'NO')

def Yes(c):
	return IF(c, 'Yes', 'No')

def main():
	t = I()
	rr = []
	for _ in range(t):
		(n, k) = LI()
		a = LI()
		o = [(i, c) for (i, c) in enumerate(a, 1) if c % 2 == 1]
		if len(o) < k or (len(o) - k) % 2 > 0:
			rr.append('NO')
		else:
			rr.append('YES')
			if k == 1:
				rr.append(n)
			else:
				rr.append(JA(map(lambda x: x[0], o[:k - 1] + [(n, 0)]), ' '))
	return JA(rr, '\n')
print(main())


for i in range(int(input())):
	(n, k) = map(int, input().split())
	x = list(map(int, input().split()))
	a = []
	cnt_odd = 0
	if n == 1:
		if x[0] % 2 != 0:
			print('YES')
			print(n)
		else:
			print('NO')
		continue
	for j in range(n):
		if x[j] % 2 != 0:
			if len(a) < k:
				a.append(j + 1)
			cnt_odd += 1
	if len(a) > 0:
		a[-1] = n
	else:
		a.append(n)
	if cnt_odd >= k and (cnt_odd - k) % 2 == 0:
		print('YES')
		print(*a)
	else:
		print('NO')


q = int(input())
for each in range(q):
	data = input().split(' ')
	n = int(data[0])
	k = int(data[1])
	prime = 0
	data = input().split(' ')
	index_prime = []
	p_index = 1
	for index in data:
		if int(index) % 2 == 1:
			prime = prime + 1
			index_prime.append(p_index)
		p_index = p_index + 1
	if prime < k:
		print('NO')
	elif (prime - k) % 2 == 0:
		print('YES')
		for ans in range(k - 1):
			print('%d ' % index_prime[ans], end='')
		print('%d' % n)
	else:
		print('NO')


from sys import stdin, stdout, setrecursionlimit
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nlargest
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm, accumulate
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
import copy
import time
setrecursionlimit(10 ** 9)
starttime = time.time()
mod = int(pow(10, 9) + 7)
mod2 = 998244353

def data():
	return input()

def num():
	return int(input())

def L():
	return list(sp())

def LF():
	return list(spf())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def spf():
	return map(int, input.readline().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]

def pmat(A):
	for ele in A:
		print(*ele, end='\n')

def pmat2(A):
	for ele in A:
		for j in ele:
			print(j, end='')
		print()

def iseven(n):
	return n % 2 == 0

def seive(r):
	prime = [1 for i in range(r + 1)]
	prime[0] = 0
	prime[1] = 0
	for i in range(r + 1):
		if prime[i]:
			for j in range(2 * i, r + 1, i):
				prime[j] = 0
	return prime
for _ in range(int(input())):
	(n, k) = sp()
	a = L()
	cnt = 0
	for i in range(n):
		cnt += a[i] % 2
	if cnt < k or cnt % 2 != k % 2:
		print('NO')
	else:
		print('YES')
		for i in range(n):
			if k == 1:
				break
			if a[i] % 2:
				print(i + 1, end=' ')
				k -= 1
		print(n)
endtime = time.time()


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	l = list(map(int, input().split()))
	c = 0
	l1 = []
	for i in range(n):
		c += l[i]
		if c % 2 != 0:
			if len(l1) == k - 1:
				l1.append(n)
				break
			else:
				l1.append(i + 1)
			c = 0
	if k == 1:
		if sum(l) % 2 != 0:
			print('YES')
			print(n)
		else:
			print('NO')
	elif len(l1) < k:
		print('NO')
	elif sum(l[l1[-2]:l1[-1]]) % 2 != 0:
		print('YES')
		print(*l1)
	else:
		print('NO')


import sys
q = int(sys.stdin.readline())
while q != 0:
	q = q - 1
	(n, k) = [int(i) for i in sys.stdin.readline().split()]
	a = [int(i) for i in sys.stdin.readline().split()]
	count = 0
	arr1 = []
	for i in range(len(a)):
		if a[i] % 2 == 1:
			count += 1
			arr1.append(i)
	if count < k:
		print('NO')
	elif count > k and (count - k) % 2 != 0:
		print('NO')
	else:
		print('YES')
		if k == count:
			for i in range(k - 1):
				print(arr1[i] + 1, end=' ')
			print(n)
		else:
			ele = count - k
			for i in arr1[ele:-1]:
				print(i + 1, end=' ')
			print(n)


n = int(input())
for i in range(n):
	(m, k) = map(int, input().split())
	a = [int(i) for i in input().split()]
	c = 0
	for i in a:
		if i % 2 == 1:
			c += 1
	if c < k or c % 2 != k % 2:
		print('NO')
		continue
	else:
		print('YES')
		i = 0
		while k != 1:
			if a[i] % 2 == 1:
				print(i + 1, end=' ')
				k = k - 1
			i += 1
		print(m)


import sys, math, itertools
from collections import Counter, deque, defaultdict
from bisect import bisect_left, bisect_right
from heapq import heappop, heappush, heapify
mod = 10 ** 9 + 7
INF = float('inf')

def inp():
	return int(sys.stdin.readline())

def inpl():
	return list(map(int, sys.stdin.readline().split()))

def inpl_1():
	return list(map(lambda x: int(x) - 1, sys.stdin.readline().split()))

def inps():
	return sys.stdin.readline()

def inpsl(x):
	tmp = sys.stdin.readline()
	return list(tmp[:x])

def err(x):
	print(x)
	exit()
for _ in range(inp()):
	(n, k) = inpl()
	a = inpl()
	cnt = 0
	for i in range(n):
		if a[i] % 2:
			cnt += 1
	if (cnt - k + 1) % 2 and cnt - k + 1 > 0:
		print('YES')
		res = []
		for i in range(n):
			if k == 1:
				break
			if a[i] % 2:
				res.append(i + 1)
				k -= 1
		res.append(n)
		print(*res)
	else:
		print('NO')


import sys

def main():
	N = int(sys.stdin.readline().strip())
	for _ in range(N):
		(n, k) = [int(x) for x in sys.stdin.readline().split()]
		a = [int(x) for x in sys.stdin.readline().split()]
		cnt = sum((1 for x in a if x % 2 == 1))
		if cnt < k or (k - cnt) % 2 == 1:
			print('NO')
			continue
		print('YES')
		for (i, x) in enumerate(a):
			if k == 1:
				break
			if x % 2 == 1:
				print(i + 1, end=' ')
				k -= 1
		print(len(a))
main()


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	ans = []
	idx = 0
	summ = 0
	arr = list(map(int, input().split()))
	for i in range(n):
		summ += arr[i]
		if summ % 2 == 1 and len(ans) != k - 1:
			ans.append(i + 1)
			summ = 0
	if summ % 2 == 1 and len(ans) == k - 1:
		print('YES')
		ans.append(n)
		print(*ans)
	else:
		print('NO')


for _ in range(int(input())):
	l = [int(x) for x in input().split()]
	n = l[0]
	k = l[1]
	a = [int(x) for x in input().split()]
	cnt = 0
	for i in a:
		if i % 2 == 1:
			cnt += 1
	if cnt < k or cnt % 2 != k % 2:
		print('NO')
	else:
		print('YES')
		for i in range(n):
			if k == 1:
				break
			if a[i] % 2 == 1:
				print(i + 1, end=' ')
				k -= 1
		print(n)


q = int(input())
import sys
for _ in range(q):
	(n, k) = map(int, sys.stdin.readline().split())
	a = list(map(int, sys.stdin.readline().split()))

	def solve(a):
		res = []
		cnt = 0
		for (i, t) in enumerate(a):
			if t % 2 == 1:
				cnt += 1
				if cnt < k:
					res.append(i + 1)
		if cnt < k or (cnt - k) % 2 == 1:
			return []
		res.append(n)
		return res
	p = solve(a)
	if not p:
		print('NO')
	else:
		print('YES')
		print(*p)


for _ in range(int(input())):
	(n, k) = [int(i) for i in input().split()]
	data = [int(i) for i in input().split()]
	if k == 1:
		if sum(data) & 1:
			print('YES')
			print(n)
		else:
			print('NO')
		continue
	pl = []
	sm = 0
	index = n
	for ind in range(n):
		if data[ind] & 1:
			pl.append(ind + 1)
		if len(pl) == k - 1:
			index = ind + 1
			break
	if index == n:
		print('NO')
	elif sum(data[index:]) & 1:
		print('YES')
		[print(q, end=' ') for q in pl]
		print(n)
	else:
		print('NO')


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	odd = []
	o = 0
	for i in range(n):
		if a[i] % 2 == 1:
			if o < k - 1:
				odd.append(i + 1)
			o += 1
	if o >= k and (o - (k - 1)) % 2 == 1:
		odd.append(n)
		print('YES')
		print(*odd)
	else:
		print('NO')


from sys import *
for _ in range(int(stdin.readline())):
	(a, b) = list(map(int, stdin.readline().rstrip().split()))
	l = list(map(int, stdin.readline().split()))
	k = []
	c = 0
	for x in range(a):
		if l[x] & 1 != 0:
			k.append(x + 1)
			c += 1
	j = c
	if j < b:
		print('NO')
	else:
		t = j - b
		if t & 1 == 0:
			print('YES')
			for x in range(b - 1):
				print(k[x], end=' ')
			print(a)
		else:
			print('NO')


def process(A, n, k):
	B = []
	for i in range(len(A)):
		if A[i] % 2 == 1:
			B.append(i + 1)
	if len(B) < k or (len(B) - k) % 2 == 1:
		print('NO')
	else:
		print('YES')
		for i in range(k - 1):
			print(B[i], end=' ')
		print(n)
n = int(input())
for i in range(n):
	Q = input().split()
	A = []
	for x in input().split():
		A.append(int(x))
	process(A, int(Q[0]), int(Q[1]))


from heapq import heappush, heappop
from collections import deque, Counter, defaultdict
import itertools
import sys
sys.setrecursionlimit(10 ** 6)

def MI():
	return map(int, input().split())

def I():
	return int(input())

def LI():
	return [int(i) for i in input().split()]
YN = ['YES', 'NO']
input = sys.stdin.readline
q = I()
for _ in range(q):
	ans = 0
	(n, k) = LI()
	b = [int(i) % 2 for i in input().split()]
	s = sum(b)
	if s < k or s % 2 != k % 2:
		print(YN[1])
	else:
		i = 0
		ans = []
		print('YES')
		c = 0
		while i < n and c < k - 1:
			if b[i] == 1:
				ans.append(i + 1)
				c += 1
			i += 1
		ans += [n]
		print(*ans)


import sys
input = sys.stdin.readline
t = int(input())
for ll in range(t):
	z = 0
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	ans = []
	su = 0
	suu = 0
	for i in range(n):
		su += a[i]
		if su % 2 == 1:
			ans.append(i + 1)
			su = 0
		suu += a[i]
	if suu % 2 != k % 2:
		print('NO')
	elif len(ans) >= k:
		print('YES')
		print(*ans[:k - 1], n)
	else:
		print('NO')


import sys
cin = lambda : map(int, sys.stdin.readline().split())
for _ in range(int(input())):
	(n, k) = cin()
	a = list(cin())
	ans = [i + 1 for i in range(n) if a[i] % 2 == 1]
	l = len(ans)
	if l >= k and k % 2 == l % 2:
		print('YES')
		print(*ans[:k - 1], n)
	else:
		print('NO')


for i in range(int(input())):
	(n, k) = map(int, input().split())
	l = list(map(int, input().split()))
	a = 0
	w = []
	for i in range(n):
		if l[i] % 2 != 0:
			w.append(i + 1)
	if len(w) >= 1 and len(w) >= k:
		del w[-1]
		w.append(n)
		if len(w) % 2 != 0 and k % 2 == 0 or (len(w) % 2 == 0 and k % 2 != 0):
			print('NO')
		if len(w) % 2 != 0 and k % 2 != 0 or (len(w) % 2 == 0 and k % 2 == 0):
			print('YES')
			print(*w[-k:])
	else:
		print('NO')


import sys
a = input()
b = sys.stdin.readlines()
b = [i.strip('\n') for i in b]
for i in range(0, len(b), 2):
	line1 = b[i]
	line2 = b[i + 1]
	(n, k) = [int(i) for i in line1.split(' ')]
	line2 = [int(i) for i in line2.split(' ')]
	odd_num = 0
	odd_index = []
	for (idx, l) in enumerate(line2):
		if l & 1 == 1:
			odd_num += 1
			odd_index.append(idx + 1)
	if odd_num >= k and odd_num & 1 == k & 1:
		print('YES')
		print(' '.join([str(o) for o in odd_index[:k - 1]] + [str(n)]))
	else:
		print('NO')


from sys import stdin
lines = stdin.read().split('\n')
t = int(lines[0])
for ln in range(t):
	(n, k) = map(int, lines[2 * ln + 1].split())
	res = []
	a = map(int, lines[2 * ln + 2].split())
	for (i, v) in enumerate(a):
		if v & 1:
			res.append(i + 1)
			if len(res) == k:
				if sum(a) & 1:
					print('NO')
				else:
					print('YES')
					res[-1] = n
					print(' '.join((str(u) for u in res)))
				break
	else:
		print('NO')


from sys import stdin
input = stdin.readline
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = list(map(int, input().split()))
	v = []
	p = s = 0
	for i in range(n):
		if p == m - 1:
			if sum(a[i:]) % 2:
				p += 1
				v.append(n)
			break
		s += a[i]
		if s % 2:
			p += 1
			v.append(i + 1)
			s = 0
	if p == m:
		print('YES')
		print(*v)
	else:
		print('NO')


import sys
from collections import Counter

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
for _ in range(INT()):
	(N, K) = MAP()
	A = LIST()
	B = []
	for (i, a) in enumerate(A):
		if a % 2 == 1:
			B.append(i + 1)
	if not B:
		NO()
		continue
	B[-1] = N
	M = len(B)
	if M < K or M % 2 != K % 2:
		NO()
		continue
	B = B[::-1]
	while len(B) > K:
		B.pop()
		B.pop()
	YES()
	print(*B[::-1])


from sys import stdin, stdout
q = int(input())
for i in range(q):
	(n, k) = map(int, input().split())
	arr = [int(x) for x in stdin.readline().split()]
	flag = True
	if sum(arr) % 2 == 0:
		if k % 2 == 1:
			flag = False
	elif k % 2 == 0:
		flag = False
	if flag == False:
		print('NO')
	else:
		res = []
		s = 0
		cnt = 0
		for j in range(n):
			s += arr[j]
			if s % 2 == 1:
				s = 0
				cnt += 1
				res.append(j + 1)
		if cnt < k:
			print('NO')
		else:
			print('YES')
			res[k - 1] = n
			print(*res[0:k])


import sys
input = sys.stdin.readline
RI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
rw = lambda : input().strip().split()
infinite = float('inf')
t = int(input())
for _ in range(t):
	(n, k) = RI()
	l = RI()
	odd = 0
	for i in l:
		if i % 2 == 1:
			odd += 1
	if odd < k or (odd - k) % 2 != 0:
		print('NO')
	else:
		print('YES')
		count = k - 1
		for i in range(0, n):
			if count == 0:
				break
			if l[i] % 2 == 1:
				print(i + 1, end=' ')
				count -= 1
		print(n)


from sys import stdin, stdout
input = stdin.readline
print = stdout.write
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	a = tuple(map(int, input().split()))
	sum1 = sum((ai % 2 for ai in a))
	if sum1 % 2 != k % 2 or sum1 < k:
		print('NO\n')
	else:
		print('YES\n')
		ans = [i + 1 for (i, ai) in enumerate(a) if ai % 2][:k - 1]
		ans.append(n)
		print(f"{' '.join(map(str, ans))}\n")


import sys
from itertools import chain

def solve():
	(n, k) = map(int, sys.stdin.readline().split())
	a = list(map(int, sys.stdin.readline().split()))
	ans = []
	for (i, x) in enumerate(a):
		if x % 2:
			ans.append(i + 1)
	if len(ans) < k or (len(ans) - k) % 2 != 0:
		sys.stdout.write('NO\n')
	else:
		sys.stdout.write('YES\n')
		sys.stdout.write(' '.join(map(str, chain(ans[:k - 1], (n,)))))
		sys.stdout.write('\n')

def main():
	q = int(input())
	for _ in range(q):
		solve()
main()


from sys import stdin, stdout
t = int(input())
for _ in range(t):
	(n, k) = map(int, stdin.readline().split())
	l = list(map(int, stdin.readline().split()))
	odd = []
	ol = 0
	for i in range(n):
		if l[i] & 1:
			odd.append(i + 1)
			ol += 1
	if ol < k:
		stdout.write('NO\n')
	elif ol - k & 1:
		stdout.write('NO\n')
	else:
		odd = odd[-k:-1] + [n]
		stdout.write('YES\n')
		for i in range(k - 1):
			stdout.write(str(odd[i]) + ' ')
		stdout.write(str(n) + '\n')


from sys import stdin
cs = int(stdin.readline())
for _ in range(cs):
	(n, k) = map(int, stdin.readline().split())
	l = list(map(int, stdin.readline().split()))
	chk = []
	cnt = 0
	for i in range(n):
		if l[i] & 1:
			chk.append(i + 1)
			cnt += 1
	if cnt < k:
		print('NO')
	elif cnt % 2 != k % 2:
		print('NO')
	else:
		print('YES')
		for i in range(k - 1):
			print(chk[i], end=' ')
		print(n)


import sys
q = int(input())
for i in range(q):
	(n, k) = map(int, sys.stdin.readline().split())
	A = list(map(int, sys.stdin.readline().split()))
	x = []
	y = list()
	for i in range(0, n):
		m = A[i] & 1
		x.append(m)
	z = x.count(1)
	if z < k or z & 1 != k & 1:
		print('NO')
	else:
		print('YES')
		for i in range(0, len(x)):
			if len(y) >= k - 1:
				break
			elif x[i] == 1:
				y.append(i + 1)
		y.append(n)
		print(*y)


Y = int(input())
for y in range(Y):
	(M, E) = map(int, input().split())
	lista = list(map(int, input().split()))
	d = 0
	l = list()
	for m in range(M):
		if lista[m] % 2 != 0:
			d = d + 1
			l.append(m + 1)
	if d < E:
		print('NO')
	elif E % 2 == 0 and d % 2 != 0 or (E % 2 != 0 and d % 2 == 0):
		print('NO')
	else:
		print('YES')
		for m in range(E - 1):
			print(l[m], end=' ')
		print(M)


n = int(input())
for x in range(n):
	(p, q) = map(int, input().split())
	m = list(map(int, input().split()))
	if q == 1:
		if sum(m) % 2 != 0:
			print('YES')
			print(len(m))
		else:
			print('NO')
	else:
		odd = []
		for i in range(len(m)):
			if m[i] % 2 != 0:
				odd.append(i + 1)
		if (len(odd) - (q - 1)) % 2 == 0 or len(odd) < q:
			print('NO')
		else:
			print('YES')
			odd[-1] = len(m)
			print(*odd[len(odd) - q:len(odd)])


import sys
t = int(input())
for _ in range(t):
	(n, k) = map(int, sys.stdin.readline().split())
	cont = list(map(int, sys.stdin.readline().split()))
	s = sum(cont)
	if s & 1 ^ k & 1:
		print('NO')
	else:
		ans = []
		cur = 0
		for i in range(n):
			if cont[i] & 1:
				ans.append(i + 1)
		if len(ans) >= k:
			print('YES')
			ans = ans[0:k]
			ans[len(ans) - 1] = n
			print(*ans)
		else:
			print('NO')


import sys
for _ in range(int(input())):
	(n, k) = map(int, sys.stdin.readline().split())
	a = list(map(int, sys.stdin.readline().split()))
	s = [j + 1 for j in range(n) if a[j] % 2 == 1]
	ln = len(s)
	if ln >= k and ln % 2 == k % 2:
		print('YES')
		print(*s[:k - 1], n)
	else:
		print('NO')


import sys
from itertools import count
q = int(next(sys.stdin))
for _ in range(q):
	(n, k) = map(int, next(sys.stdin).split(' '))
	a = list(map(lambda x: int(x) % 2, next(sys.stdin).split(' ')))
	sum_a = sum(a)
	if sum_a < k or (sum_a - k) % 2 != 0:
		print('NO')
		continue
	print('YES')
	ans = []
	amount = 0
	for (i, item) in zip(count(start=1), a):
		if item % 2 == 1:
			amount += 1
			if amount == k:
				ans.append(str(n))
				break
			else:
				ans.append(str(i))
		if amount == k and i != n:
			ans.append(str(n))
			break
	print(' '.join(ans))


import sys
t = int(input())
for _ in range(t):
	(n, m) = map(int, sys.stdin.readline().split())
	a = list(map(int, sys.stdin.readline().split()))
	b = 0
	c = []
	for i in range(n):
		if a[i] % 2 != 0:
			b += 1
			c.append(i + 1)
	if b % 2 != m % 2 or b < m:
		print('NO')
	else:
		print('YES')
		c = c[:m - 1] + [n]
		print(*c)


def main():
	t = int(input())
	while t:
		(n, k) = map(int, input().split())
		l = list(map(int, input().split()))
		if n == 1 and k == 1 and (l[0] % 2 == 1):
			print('YES')
			print('1')
			t = t - 1
			continue
		arr = []
		for i in range(len(l)):
			if l[i] % 2 == 1:
				arr.append(i + 1)
		if len(arr) > 0 and len(arr) % 2 == k % 2 and (len(arr) >= k):
			print('YES')
			for i in range(k - 1):
				print(arr[i], end=' ')
			print(n)
		else:
			print('NO')
		t = t - 1
main()


T = int(input())
for t in range(T):
	(N, K) = map(int, input().split())
	numeri = list(map(int, input().strip().split()))
	p = list()
	dispari = 0
	for n in range(N):
		if numeri[n] % 2 != 0:
			p.append(n + 1)
			dispari += 1
	if dispari < K:
		print('NO')
	elif K % 2 == 0 and dispari % 2 != 0 or (K % 2 != 0 and dispari % 2 == 0):
		print('NO')
	else:
		print('YES')
		for k in range(K - 1):
			print(p[k], end=' ')
		print(N)


n = int(input())
result = []
for _ in range(n):
	(n, k) = list(map(int, input().split()))
	a = list(map(int, input().split()))
	nbOdds = 0
	for i in a:
		if i % 2 == 1:
			nbOdds += 1
	if nbOdds < k:
		result.append('NO')
	elif (nbOdds - k) % 2 == 0:
		result.append('YES')
		current = []
		for j in range(n):
			if a[j] % 2 == 1 and len(current) < k - 1:
				current.append(j + 1)
		current.append(n)
		result.append(' '.join(list(map(str, current))))
	else:
		result.append('NO')
print('\n'.join(result))


import sys
input = lambda : sys.stdin.readline().strip()
q = int(input())
for qw in range(q):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	odd = 0
	for e in a:
		odd += e % 2
	if odd < k or (odd - k) % 2 == 1:
		print('NO')
	else:
		print('YES')
		for i in range(n):
			if k == 1:
				break
			if a[i] % 2:
				print(i + 1, end=' ')
				k -= 1
		print(n)


t = int(input())
for i in range(t):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	x = sum(a)
	y = 0
	for j in a:
		if j % 2 != 0:
			y += 1
	if k % 2 == 0 and x % 2 == 0 or (k % 2 != 0 and x % 2 != 0):
		if y >= k and (y - k) % 2 == 0:
			print('YES')
			c = 0
			for j in range(n):
				if c == k - 1:
					break
				if a[j] % 2 != 0:
					print(j + 1, end=' ')
					c += 1
			print(n)
		else:
			print('NO')
	else:
		print('NO')


import sys
q = int(input())
for i in range(q):
	(n, k) = map(int, sys.stdin.readline().split())
	a = list(map(int, sys.stdin.readline().split()))
	s = [i + 1 for i in range(n) if a[i] % 2 == 1]
	ln = len(s)
	if ln >= k and (ln - k) % 2 == 0:
		print('YES')
		print(*s[:k - 1], n)
	else:
		print('NO')


from sys import stdin
q = int(stdin.readline())
for i in range(q):
	(n, k) = map(int, stdin.readline().split())
	arr = list(map(int, stdin.readline().split()))
	count = 0
	ans = []
	s = 0
	for i in range(n):
		if count != k - 1:
			if arr[i] % 2 != 0:
				ans.append(i + 1)
				count += 1
				s = 0
			else:
				s += arr[i]
		else:
			if sum(arr[i:]) % 2 != 0:
				ans.append(n)
			else:
				pass
			break
	if len(ans) != k:
		print('NO')
	else:
		print('YES')
		for i in range(k - 1):
			print(ans[i], end=' ')
		print(ans[-1])


for _ in range(int(input())):
	(x, y) = map(int, input().split())
	(*li,) = map(int, input().split())
	cnt = 0
	for i in li:
		if i % 2:
			cnt += 1
	if cnt < y or (cnt - y) % 2:
		print('NO')
		continue
	li1 = []
	i = 0
	while y > 1 and i < x:
		if li[i] % 2:
			li1 += [i + 1]
			y -= 1
		i += 1
	li1.append(x)
	print('YES')
	print(*li1)


from copy import deepcopy
from bisect import bisect_right
from itertools import combinations
from sys import stdin

def dis(first, second, remain):
	if second[0] > first[0]:
		(first[0], second[0]) = (second[0], first[0])
	if remain > first[0] - second[0]:
		remain -= first[0] - second[0]
		second[0] = first[0]
		first[0] += remain // 2
		return first[0]
	else:
		return second[0] + remain
q = int(stdin.readline().strip())
for _ in range(q):
	(n, k) = list(map(int, stdin.readline().split()))
	arr = list(map(int, stdin.readline().split()))
	temp = 0
	count = 0
	i = 0
	ans = []
	while i < len(arr) and count < k - 1:
		temp += arr[i]
		if temp % 2 == 1:
			ans.append(i + 1)
			temp = 0
			count += 1
		i += 1
	if len(ans) == 0:
		if sum(arr) % 2 == 1 and k == 1:
			print('YES')
			print(n)
		else:
			print('NO')
	elif sum(arr[ans[-1]:]) % 2 == 1:
		ans.append(n)
		count += 1
		if count == k:
			print('YES')
			print(*ans)
		else:
			print('NO')
	else:
		print('NO')


for case in range(int(input())):
	(n, k) = list(map(int, input().split()))
	a = list(map(int, input().split()))
	i = 0
	ans = []
	while i < n and k:
		if i > n - k:
			break
		s = 0
		while i < n and (not s & 1):
			s += a[i]
			i += 1
		if not s & 1:
			break
		ans.append(i)
		k -= 1
	flg = True if k == 0 and (not sum(a[i:]) & 1) else False
	if flg:
		ans[-1] = n
	print('YES\n' + ' '.join(map(str, ans)) if flg else 'NO')


q = int(input())
for _ in range(q):
	(n, k) = map(int, input().split())
	l = list(map(int, input().split()))
	s = ''
	i = 0
	odds = 0
	for i in range(n):
		if k == 1:
			if l[i] % 2 == 1:
				odds += 1
			continue
		if l[i] % 2 == 0:
			continue
		s += str(i + 1) + ' '
		k -= 1
	if odds % 2 == 0:
		print('NO')
		continue
	print('YES')
	print(s + str(n))


for i in range(int(input())):
	(n, k) = map(int, input().split())
	l1 = list(map(int, input().split()))
	count = 0
	l2 = []
	for j in range(len(l1)):
		if l1[j] % 2 != 0:
			count = count + 1
			l2.append(j)
	if count % 2 == 0:
		if k % 2 == 0 and k <= count:
			print('YES')
			for tt in range(k):
				if tt != k - 1:
					print(l2[tt] + 1, end=' ')
				else:
					print(n)
		else:
			print('NO')
	elif k % 2 != 0 and k <= count:
		print('YES')
		for tt in range(k):
			if tt != k - 1:
				print(l2[tt] + 1, end=' ')
			else:
				print(n)
	else:
		print('NO')


from collections import deque
from sys import stdin
for _ in range(int(stdin.readline())):
	(n, k) = map(int, stdin.readline().split())
	l = map(int, stdin.readline().split())
	c = 0
	ans = ''
	for (i, v) in enumerate(l):
		if v % 2 == 1:
			c += 1
			if c < k:
				ans += f'{i + 1} '
	if c >= k and (c - k + 1) % 2 == 1:
		print('YES')
		ans += str(n)
		print(ans)
	else:
		print('NO')


import sys
for i in range(int(input())):
	X = list(map(int, input().split()))
	Numbers = list(map(int, sys.stdin.readline().split()))
	Answer = []
	for j in range(X[0]):
		if Numbers[j] % 2 == 1:
			Answer.append(j + 1)
	Size = len(Answer)
	if Size < X[1] or (Size - X[1] - 1) % 2 == 0:
		print('NO')
	else:
		print('YES')
		print(*Answer[:X[1] - 1], X[0])


q = int(input())
ans = [[None] for i in range(q)]
for j in range(q):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	nch = 0
	len_a = len(a)
	for i in range(len_a):
		if a[i] % 2 == 1:
			nch += 1
	if nch < k:
		ans[j] = 'NO'
		continue
	elif (nch - k) % 2 == 0:
		ans[j][0] = 'YES'
		c = k - 1
		iter = 0
		while c != 0:
			if a[iter] % 2 == 1:
				ans[j].append(str(iter + 1))
				c -= 1
			iter += 1
		ans[j].append(len_a)
		continue
	else:
		ans[j] = 'NO'
		continue
for i in range(q):
	if ans[i][0] == 'YES':
		ans[i].pop(0)
		print('YES')
		print(*ans[i])
	else:
		print('NO')