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.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;
import java.io.*;
public class Con1 {
	static Scanner sc=new Scanner(System.in);
static	PrintWriter out=new PrintWriter(System.out);
static ArrayList<Integer>[] adj;
static int[] visited;
static int price[];
		
		  public static void main(String[] args)throws IOException {
		    Scanner sc=new Scanner(System.in);
		    int n=sc.nextInt();
		    int k=sc.nextInt();
		    HashSet<Integer> set[]=new  HashSet[5002];
		    for(int i=0 ; i<5002 ; i++) {
		    	set[i]=new HashSet<Integer>();
		    }
		    int a[]=new int[n];
		    for(int i=0 ; i<n ; i++ ) {
		    	a[i]=sc.nextInt();
		    }
		    int b[]=new int[n];
		    int def=1;
		    for(int i=0  ; i<n ;i++) {
		    	
		    	if(!set[a[i]].contains(def)) {
		    		set[a[i]].add(def);
		    		b[i]=def;
		    	}
		    	else {
		    		while(set[a[i]].contains(def)) {
		    			def++;
		    		}
		    		if(def>k) {
		    			def=1;
		    			while(set[a[i]].contains(def)) {
			    			def++;
			    		}
		    			if(def>k) {
		    			System.out.println("NO");
		    			return;
		    			}
		    			set[a[i]].add(def);
		    			b[i]=def;
		    		}
		    		else {
		    			set[a[i]].add(def);
		    			b[i]=def;
		    		}
		    	}
		    	def++;
		    	if(def>k) {
		    		def=1;
		    	}
		    }
		    System.out.println("YES");
		    for(int i=0 ; i<b.length ; i++) {
		    	System.out.print(b[i]+" ");
		    }
		  }
		 static ArrayList<Integer>[] adjList;
			static int V, counter, SCC, dfs_num[], dfs_low[];
			static boolean[] inSCC;
			static Stack<Integer> stack;
			static long total;
			static long times;
			
			static void tarjanSCC()	 	
			{
				for(int i = 0; i < V; ++i)
					if(dfs_num[i] == 0)
						tarjanSCC(i);
			}
			
			static void tarjanSCC(int u)
			{
				dfs_num[u] = dfs_low[u] = ++counter;
				stack.push(u);
				
				for(int v: adj[u])
				{
					if(dfs_num[v] == 0)
						tarjanSCC(v);
					if(!inSCC[v])
						dfs_low[u] = Math.min(dfs_low[u], dfs_low[v]);	
				}
				if(dfs_num[u] == dfs_low[u])
				{
					SCC++;
					long min=Long.MAX_VALUE;
					long count=0;
					while(true)
					{
						int v = stack.pop();
						inSCC[v] = true;
						
						if(min>price[v]) {
							min=price[v];
							count=1;
						}
						else if(min==price[v]) {
							count++;
						}
						if(v == u)
							break;
					}
					total+=min;
					times=(count*times)% 1000000007;
				}	
				
		}

	



static void dfs(int u)					
{
	
	visited[u] ++;
if(visited[u]==2) {
	return;
}
	for(int v: adj[u])
		if(visited[v]<2)
			dfs(v);


}
static class Pair implements Comparable<Pair>{
	int x;
	int y;
	public Pair(int a,int b) {
		x=a;
		y=b;
	}
	@Override
	public int compareTo(Pair o) {
	if(x!=o.x) {
		return x-o.x;
	}	
	else {
		return y-o.y;
	}
	}
}
}
 class Scanner{
    StringTokenizer st;
    BufferedReader br;
    public Scanner(InputStream system){
        br=new BufferedReader(new InputStreamReader(system));
    }
    public Scanner (String file) throws IOException{
        br=new BufferedReader(new FileReader(file));
    }
    public String next() throws IOException{
        while (st==null || !st.hasMoreTokens())
            st=new StringTokenizer(br.readLine());
        return st.nextToken();
    }
    public  String nextLine() throws IOException{
        return br.readLine();

    }
    public int nextInt() throws IOException{
        return Integer.parseInt(next());

    }
    public long nextLong() throws IOException{
        return Long.parseLong(next());

    }
    public Double nextDouble() throws IOException{
        return Double.parseDouble(next());
        

    }
 }