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: introductory

Starter code:

Solutions:
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")

    



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
input = sys.stdin.readline

q=int(input())

for testcases in range(q):
    n,k=list(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")

        
        


'''input
3
5 3
7 18 3 14 1
5 4
1 2 3 4 5
6 2
1 2 8 4 10 2

'''
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)


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)


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")

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])    
        


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)
    #print(kolvo, k)
    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")


import sys
for _ in range(int(input())):
    n,k=list(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:
        # for i in range(k-1):
            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")
                
                
        


# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!
# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!
# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!
# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!
# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!
# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!
# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!
# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!
from sys import stdin, stdout
import collections
 
Q = int(input())
 
#s = input()
#N = len(s)
#arr = [int(x) for x in stdin.readline().split()]
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')






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
        #print("ans ", ans)
        if cur_k < k or not has:
            print("NO")
        else:
            print("YES")
            print(' '.join(str(i) for i in ans))
        


from sys import stdin
q = int(stdin.readline())
for query in range(q):
    n, k = list(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:])))


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()])


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)
        else:
            if pre[i]%2:
                ans.append(i)
    #print(ans)
    if len(ans)<k:
        print('NO')
    else:
        if 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)


    


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)

from sys import stdin
input=stdin.readline
for _ in range(int(input())):
    n,k=list(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:])


''' CODED WITH LOVE BY SATYAM KUMAR '''

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) # max depth of recursion
threading.stack_size(2**27)  # new thread will get stack of such size
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): #n**0.5 complex 
    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
    #print (n,MOD)
    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):
    """Returns True if n is prime."""
    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):
    nonlocal 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):
    nonlocal 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 = []                         # list of entries arranged in a heap
entry_finder = {}               # mapping of tasks to entries
REMOVED = '<removed-task>' 
def add_task(task, priority=0):
    'Add a new task or update the priority of an existing task'
    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):
    'Mark an existing task as REMOVED.  Raise KeyError if not found.'
    entry = entry_finder.pop(task)
    entry[-1] = REMOVED

def pop_task():
    'Remove and return the lowest priority task. Raise KeyError if empty.'
    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():
    nonlocal memory
    memory = dict()
def cached_fn(fn, *args):
    nonlocal 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):
    #print("Search for ",i)
    fn = lambda x: li[x]-x//i
    x = -1
    b = len(li)
    while b>=1:
        #print(b,x)
        while b+x<len(li) and fn(b+x)>0: #Change this condition 2 to whatever you like
            x+=b
        b=b//2
    return x

# -------------------------------------------------------------- MAIN PROGRAM
TestCases = True
testingMode = False
fac_warmup_size = 10**5+100
optimiseForReccursion = False #Can not be used clubbed with TestCases # WHen using recursive functions, use Python 3
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")





# --------------------------------------------------------------------- END=


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()

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
 
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')


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")

'''input
3
2 1
1 1
5 4
1 2 3 4 5
6 2
1 2 8 4 10 2
'''
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


# main starts
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")

#575_B

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]))


import sys

inf = sys.stdin
#inf = open("input_data.in", "r")

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