You are given an array a consisting of n integer numbers.

You have to color this array in k colors in such a way that: 

  * Each element of the array should be colored in some color; 
  * For each i from 1 to k there should be at least one element colored in the i-th color in the array; 
  * For each i from 1 to k all elements colored in the i-th color should be distinct. 



Obviously, such coloring might be impossible. In this case, print "NO". Otherwise print "YES" and any coloring (i.e. numbers c_1, c_2, ... c_n, where 1 ≤ c_i ≤ k and c_i is the color of the i-th element of the given array) satisfying the conditions above. If there are multiple answers, you can print any.

Input

The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 5000) — the length of the array a and the number of colors, respectively.

The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 5000) — elements of the array a.

Output

If there is no answer, print "NO". Otherwise print "YES" and any coloring (i.e. numbers c_1, c_2, ... c_n, where 1 ≤ c_i ≤ k and c_i is the color of the i-th element of the given array) satisfying the conditions described in the problem statement. If there are multiple answers, you can print any.

Examples

Input


4 2
1 2 2 3


Output


YES
1 1 2 2


Input


5 2
3 2 1 2 3


Output


YES
2 1 1 2 1


Input


5 2
2 1 1 2 1


Output


NO

Note

In the first example the answer 2~ 1~ 2~ 1 is also acceptable.

In the second example the answer 1~ 1~ 1~ 2~ 2 is also acceptable.

There exist other acceptable answers for both examples.

import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;
//import java.math.*;
 
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
 
public class Main {
	static class Node implements Comparable<Node> {
		 
    	  public int val;
    	  public int col;
    	  public int pos;
    	  public Node(int val) {
    	    this.val = val;
    	    this.pos=0;
    	    this.col=0;
    	  }

    	  @Override
    	  public int compareTo(Node o) {
    	    return (int)(this.val - o.val);
    	  }

    	  public double getVal() {
    	    return val;
    	  }
	}
	static int MD= 998244353 ;
	static int N=300000;
    public static void main(String[] args) throws IOException {
    	OutputStream outputStream = System.out;
        InputReader in = new InputReader();
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }
   

	static class TaskC {
    	 
	    public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException {
	    	 
	    	int t=1;
	    	while(t-->0) { 
	    		int n=in.nextInt();
	        	int k=in.nextInt();
	        	int c=0;
	        	Node[] arr=new Node[n];
	        	for(int i=0;i<n;i++) {
	        		arr[i]=new Node(in.nextInt());
	        		arr[i].pos=i;
	        	}
	        	Arrays.sort(arr);
	        	
	        	arr[0].col=1;
	        	int b=1;
	        
	        	for(int i=1;i<n;i++) {
	        		if(arr[i].val==arr[i-1].val) {
	        			arr[i].col=Math.max(1,(arr[i-1].col+1)%(k+1));
	        			b++;
	        		}
	        		else {
	        			b=1;
	        			arr[i].col=Math.max(1,(arr[i-1].col+1)%(k+1));
	        			
	        		}
	        		if(b>k) {
	        			out.println("NO");
	        			c++;
	        			break;
	        		}
	        		
	        	}

	        	if(c==0) {
	        	sort(arr,0,n);
	        	out.println("YES");
	        	for(int i=0;i<n;i++) {
	        		out.print(arr[i].col+" ");
	        	}
	        	out.println();
	    	}
	    	}
	    }
	    	
	}
	   
	
    
    static long modexp(long x, long n) 
    { 
        if (n == 0) { 
            return 1; 
        } 
        else if (n % 2 == 0) { 
            return modexp((x * x) % MD, n / 2); 
        } 
        else { 
            return (x * modexp((x * x) % MD, (n - 1) / 2) % MD); 
        } 
    } 
      
     static long getInv(long b) 
    { 
      
        long  d = modexp(b, MD - 2); 
      
        long ans =  (d % MD) ;
      
        return ans; 
    } 
    
    static class InputReader
    {
        BufferedReader br;
        StringTokenizer st;
 
        public InputReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }
 
        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
   
        int nextInt()
        {
            return Integer.parseInt(next());
        }
 
        long nextLong()
        {
            return Long.parseLong(next());
        }
 
        double nextDouble()
        {
            return Double.parseDouble(next());
        }
 
        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    
    }
    public static void sort(Node[] a, int low, int high) 
    {
        int N = high - low;         
        if (N <= 1) 
            return; 
        int mid = low + N/2; 
        // recursively sort 
        sort(a, low, mid); 
        sort(a, mid, high); 
        // merge two sorted subarrays
        Node[] temp = new Node[N];
        int i = low, j = mid;
       
        for (int k = 0; k < N; k++) 
        {
            if (i == mid)  
                temp[k] = a[j++];
            else if (j == high) 
                temp[k] = a[i++];
            else if (a[j].pos<a[i].pos) 
                temp[k] = a[j++];
            else 
                temp[k] = a[i++];
        }   
        for (int k = 0; k < N; k++) 
            a[low + k] = temp[k];         
    }
    static void lsort(long[] a, int low, int high) 
    {
        int N = high - low;         
        if (N <= 1) 
            return; 
        int mid = low + N/2; 
        lsort(a, low, mid); 
        lsort(a, mid, high); 
        long[] temp = new long[N];
        int i = low, j = mid;
        for (int k = 0; k < N; k++) 
        {
            if (i == mid)  
                temp[k] = a[j++];
            else if (j == high) 
                temp[k] = a[i++];
            else if (a[j]<a[i]) 
                temp[k] = a[j++];
            else 
                temp[k] = a[i++];
        }    
        for (int k = 0; k < N; k++) 
            a[low + k] = temp[k];         
    }
    public static long fexp(long x, long y, long p) {
        long res = 1;      
        
       
        x = x % p;  
      
        while (y > 0) 
        { 
         
            if((y & 1)==1) 
                res = (res * x) % p; 
      
          
            y = y >> 1;  
            x = (x * x) % p;  
        } 
        return res; 
        
    }
    static int gcd(int a, int b) 
    { 
        if (b == 0) 
            return a; 
        return gcd(b, a % b);  
          
    }
    static long lgcd(long a, long b) 
    { 
        if (b == 0) 
            return a; 
        return lgcd(b, a % b);  
          
    }
   
	
	
}
 
