Problem: One day Kefa found n baloons. For convenience, we denote color of i-th baloon as si — lowercase letter of the Latin alphabet. Also Kefa has k friends. Friend will be upset, If he get two baloons of the same color. Kefa want to give out all baloons to his friends. Help Kefa to find out, can he give out all his baloons, such that no one of his friens will be upset — print «YES», if he can, and «NO», otherwise. Note, that Kefa's friend will not upset, if he doesn't get baloons at all.

Input

The first line contains two integers n and k (1 ≤ n, k ≤ 100) — the number of baloons and friends.

Next line contains string s — colors of baloons.

Output

Answer to the task — «YES» or «NO» in a single line.

You can choose the case (lower or upper) for each letter arbitrary.

Examples

Input

4 2
aabb


Output

YES


Input

6 3
aacaab


Output

NO

Note

In the first sample Kefa can give 1-st and 3-rd baloon to the first friend, and 2-nd and 4-th to the second.

In the second sample Kefa needs to give to all his friends baloons of color a, but one baloon will stay, thats why answer is «NO».

Solution (in JAVA):

Solution:
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {

    static class FastestReader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public FastestReader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public FastestReader(InputStream is) {
            din = new DataInputStream(is);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public FastestReader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null)
                return;
            din.close();
        }
    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        public FastReader(final InputStream is) {
            if (is != null)
                br = new BufferedReader(new
                        InputStreamReader(is));
            else new FastReader();
        }

        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;
        }
    }

    static class FastWriter {
        PrintWriter pw;

        public FastWriter() {
            this.pw = new PrintWriter(new BufferedOutputStream(System.out));
        }

        public void print(Object message) {
            pw.print(message);
        }

        public void println() {
            print("\n");
        }

        public void println(Object message) {
            print(message + "\n");
        }

        public void close() throws Exception {
            pw.close();
        }
    }

    static class BinaryTree {
        static int PREORDER = -1;
        static int INORDER = 0;
        static int POSTORDER = 1;

        Node root;

        BinaryTree(final int rootData) {
            this.root = new Node(rootData);
        }

        void print(final FastWriter writer) {
            print(PREORDER, writer);
            writer.println();
        }

        void print(int mode, final FastWriter writer) {
            print(root, writer);
            writer.println();
        }

        private void print(final Node node, final FastWriter writer) {
            writer.print(node.data + " ");
            if (node.left != null) {
                print(node.left, writer);
            }
            if (node.right != null) {
                print(node.right, writer);
            }
        }

        void insert(final Node node) {
            insert(node, root);
        }

        private void insert(final Node node, final Node parent) {
            if (parent.data > node.data) {
                if (parent.left == null) {
                    node.parent = parent;
                    parent.left = node;
                } else {
                    insert(node, parent.left);
                }
            } else {
                if (parent.right == null) {
                    node.parent = parent;
                    parent.right = node;
                } else {
                    insert(node, parent.right);
                }
            }
        }

        Node search(final int data) {
            return search(data, root);
        }

        private Node search(final int data, Node parent) {
            if (parent.data == data) return parent;

            if (parent.data > data) {
                if (parent.left == null) return null;
                else return search(data, parent.left);
            } else {
                if (parent.right == null) return null;
                else return search(data, parent.right);
            }
        }
    }

    static class Node {
        int data;
        Node parent;
        Node left;
        Node right;

        Node(final int data) {
            this.data = data;
            this.parent = null;
            this.left = null;
            this.right = null;
        }
    }

    public static void main(String args[]) throws Exception {

        //final InputStream is = Main.class.getResourceAsStream("input.txt");
        final FastReader reader = new FastReader();
        final FastWriter writer = new FastWriter();
        //Scanner reader = new Scanner();

        int N = reader.nextInt();
        int K = reader.nextInt();

        char[] arr = reader.next().toCharArray();

        Arrays.sort(arr);

        int max = Integer.MIN_VALUE;

        String ans = "YES";
        int count = 1;
        for (int i = 0; i < N - 1; i++) {
            if (arr[i] == arr[i + 1]) {
                count++;
                if (count > max) {
                    max = count;
                    if (max > K) {
                        writer.println("NO");
                        writer.close();
                        return;
                    }
                }
            } else {
                count = 1;
            }
        }

        writer.println(ans);
        writer.close();
    }
}