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.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Iterator;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Mufaddal Naya
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        BArrayKColoring solver = new BArrayKColoring();
        solver.solve(1, in, out);
        out.close();
    }

    static class BArrayKColoring {
        public void solve(int testNumber, InputReader c, OutputWriter w) {
            int n = c.readInt(), k = c.readInt();
            int a[] = c.readIntArray(n);
            IntArray freq[] = new IntArray[5001];
            for (int i = 0; i < 5001; i++) {
                freq[i] = new IntArray();
            }
            for (int i = 0; i < n; i++) {
                freq[a[i]].add(i);
            }

            int res[] = new int[n];
            for (int i = 0; i < n; i++) {
                if (freq[a[i]].size() > k) {
                    w.printLine("NO");
                    return;
                }
            }
            int cnt = 0;
            for (int i = 0; i < 5001; i++) {
                for (int ind : freq[i]) {
                    res[ind] = (cnt % k) + 1;
                    cnt++;
                }
            }
            w.printLine("YES");
            w.print(res);

        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int[] readIntArray(int size) {
            int[] array = new int[size];
            for (int i = 0; i < size; i++) {
                array[i] = readInt();
            }
            return array;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void print(int[] array) {
            for (int i = 0; i < array.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(array[i]);
            }
        }

        public void printLine(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }

    static class IntArray implements Iterable<Integer> {
        private static final int DEFAULT_CAP = 1 << 3;
        public int[] arr;
        public int len = 0;
        private int capacity = 0;

        public IntArray() {
            this(DEFAULT_CAP);
        }

        public IntArray(int capacity) {
            if (capacity < 0) {
                throw new IllegalArgumentException("Illegal Capacity: " + capacity);
            }
            this.capacity = capacity;
            arr = new int[capacity];
        }

        public IntArray(int[] array) {
            if (array == null) {
                throw new IllegalArgumentException("Array cannot be null");
            }
            arr = Arrays.copyOf(array, array.length);
            capacity = len = array.length;
        }

        public int size() {
            return len;
        }

        public void add(int elem) {
            if (len + 1 >= capacity) {
                if (capacity == 0) {
                    capacity = 1;
                } else {
                    capacity *= 2; // double the size
                }
                arr = Arrays.copyOf(arr, capacity); // pads with extra 0/null elements
            }
            arr[len++] = elem;
        }

        public Iterator<Integer> iterator() {
            return new Iterator<Integer>() {
                int index = 0;

                public boolean hasNext() {
                    return index < len;
                }

                public Integer next() {
                    return arr[index++];
                }

                public void remove() {
                    throw new UnsupportedOperationException();
                }
            };
        }

        public String toString() {
            if (len == 0) {
                return "[]";
            } else {
                StringBuilder sb = new StringBuilder(len).append("[");
                for (int i = 0; i < len - 1; i++) {
                    sb.append(arr[i] + ", ");
                }
                return sb.append(arr[len - 1] + "]").toString();
            }
        }

    }
}

