Given n sticks' lengths, determine whether there is a solution to choose 2k out of them and use these 2k sticks to form two k-convex polygons (non-degenerated), namely, two convex polygons each has exactly k sticks as its sides, and every adjacent sticks are not parallel.


Input
The first line contains two space-separated integers n and k, denoting the number of sticks and the size of convex polygon we needed.
The second line contains n positive integers, denoting the lengths of sticks.

Output
Print "Yes" (without quotes) in the first line if exists a solution. Otherwise print "No" (without quotes) instead.
If such solution exists, you should output a plan in the second line. Print 2k indexes (indexes start from 1) of the sticks you chosen. First k sticks compose the first k-convex polygon. And the later k sticks form the second. If there are more than one solution, output any.

Constraints

2k ≤ n ≤ 1000
3 ≤ k ≤ 10
1 ≤ length of each stick ≤ 10^9


Example

Input 1:
6 3
1 1 1 2 2 2

Output 1:
Yes
1 2 3 4 5 6


Input 2:
6 3
1 2 3 100 200 300

Output 2:
No

Explanation
Example case 1: 1 1 1 and 2 2 2 form two triangles.
Example case 2: Please be careful that convex polygons must be non-degenerated.
from itertools import combinations
from collections import defaultdict
 
 
def small_j(sticks, cum, k):
    for j in range(k - 1, len(sticks)):
        i = j - k + 1
        hyp = sticks[j]
        rest = cum[j - 1] - cum[i] + sticks[i]
        if rest > hyp:
            return i, j
    return None, None
 
def small_ii(sticks, cum, k):
    for jj in range(-1, k - len(sticks) - 1, -1):
        ii = jj - k + 1
        hyp = sticks[jj]
        rest = cum[jj - 1] - cum[ii] + sticks[ii]
        if rest > hyp:
            return len(sticks) + ii, len(sticks) + jj
    assert False
 
 
 
 
 
 
def solve(n, k, sticks):
    len_pos = defaultdict(list)
    for pos, len_ in enumerate(sticks):
        len_pos[len_].append(str(pos + 1))
 
    sticks.sort()
    tot = 0
    cum = []
    for s in sticks:
        tot += s
        cum.append(tot)
 
    i, j = small_j(sticks, cum, k)
    if j is None:
        return "No"
 
    ii, jj = small_ii(sticks, cum, k)
 
    if ii > j:
        ans = sticks[i:j+1] + sticks[ii:jj+1]
        ans_i = []
        for len_ in ans:
            ans_i.append(len_pos[len_].pop())
        return "Yes\n" + " ".join(ans_i)
 
    if jj < 2*k - 1:
        return "No"
 
    chosen_sticks = list(enumerate(sticks[jj - 2*k + 1: jj+1]))
    assert len(chosen_sticks) == 2*k
 
    positions = range(len(chosen_sticks))
 
    solution = None
    for poly1 in combinations(positions, r=k):
        poly1 = list(poly1)
        i1 = 0
        sum1 = 0
        sum2 = 0
        hyp1 = 0
        hyp2 = 0
        for pos, cs in chosen_sticks:
            if i1 < k and pos == poly1[i1]:
                sum1 += cs
                i1 += 1
                hyp1 = cs
            else:
                sum2 += cs
                hyp2 = cs
        sum1 -= hyp1
        sum2 -= hyp2
        if sum1 > hyp1 and sum2 > hyp2:
            solution = poly1
            break
 
    if solution is None:
        return "No"
    else:
        chosen_sticks = [v for _, v in chosen_sticks]
        poly1 = [chosen_sticks[i] for i in solution]
        for v in poly1:
            chosen_sticks.remove(v)
        poly2 = chosen_sticks
        ans = poly1 + poly2
        ans_i = []
        for len_ in ans:
            ans_i.append(len_pos[len_].pop())
        return "Yes\n" + " ".join(ans_i)
 
 

 
n, k = map(int, raw_input().split())
sticks = map(int, raw_input().split())
print solve(n, k, sticks)