You are given a string s consisting of n lowercase Latin letters. Polycarp wants to remove exactly k characters (k ≤ n) from the string s. Polycarp uses the following algorithm k times:

  * if there is at least one letter 'a', remove the leftmost occurrence and stop the algorithm, otherwise go to next item; 
  * if there is at least one letter 'b', remove the leftmost occurrence and stop the algorithm, otherwise go to next item; 
  * ... 
  * remove the leftmost occurrence of the letter 'z' and stop the algorithm. 



This algorithm removes a single letter from the string. Polycarp performs this algorithm exactly k times, thus removing exactly k characters.

Help Polycarp find the resulting string.

Input

The first line of input contains two integers n and k (1 ≤ k ≤ n ≤ 4 ⋅ 10^5) — the length of the string and the number of letters Polycarp will remove.

The second line contains the string s consisting of n lowercase Latin letters.

Output

Print the string that will be obtained from s after Polycarp removes exactly k letters using the above algorithm k times.

If the resulting string is empty, print nothing. It is allowed to print nothing or an empty line (line break).

Examples

Input

15 3
cccaabababaccbc


Output

cccbbabaccbc


Input

15 9
cccaabababaccbc


Output

cccccc


Input

1 1
u


Output
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        String[] params = reader.readLine().split(" ");
        int length = Integer.valueOf(params[0]);
        int k = Integer.valueOf(params[1]);

        String string = reader.readLine();

        if (length == 0 || k == 0) {
            System.out.println(string);
            return;
        }

        PolicarpString policarpString = new PolicarpString(string, length);
        for (int c = 'a'; c <= 'z'; c++) {
            int charCount = policarpString.count((char) c);
            if (charCount <= k) {
                policarpString.removeAll((char) c);
                k -= charCount;
                continue;
            }

            while (k > 0 && policarpString.remove((char) c)) {
                k--;
            }
        }

        System.out.println(policarpString.toString());
    }

    public static class PolicarpString {
        private final char[] charArray;
        private final IntQueue[] charIndexes = new IntQueue[26];

        public PolicarpString(String string, int length) {
            if (string == null) {
                throw new NullPointerException("String is null");
            }

            if (length < 1 || string.isEmpty()) {
                throw new IllegalArgumentException("String must be not empty");
            }

            if (length != string.length()) {
                throw new IllegalArgumentException("String length is incorrect");
            }

            char[] tempCharArray = string.toCharArray();

            int[] charFrequences = new int[26];
            for (int i = 0; i < length; i++) {
                charFrequences[tempCharArray[i] - 'a']++;
            }

            for (int i = 0; i < 26; i++) {
                int freq = charFrequences[i];
                if (freq > 0) {
                    charIndexes[i] = new IntQueue(freq);
                }
            }

            for (int i = 0; i < length; i++) {
                charIndexes[tempCharArray[i] - 'a'].push(i);
            }

            charArray = new char[length];
            System.arraycopy(tempCharArray, 0, charArray, 0, length);
        }

        public boolean remove(char c) {
            IntQueue indexQueue = charIndexes[c - 'a'];
            if (indexQueue == null) {
                return false;
            }

            int charIndex = indexQueue.pull();
            if (charIndex == -1) {
                return false;
            }

            charArray[charIndex] = '\0';
            return true;
        }

        public boolean removeAll(char c) {
            IntQueue indexQueue = charIndexes[c - 'a'];
            if (indexQueue == null) {
                return false;
            }

            charIndexes[c - 'a'] = null;

            int charIndex;
            while ((charIndex = indexQueue.pull()) != -1) {
                charArray[charIndex] = '\0';
            }

            return true;
        }

        public int count(char c) {
            IntQueue indexQueue = charIndexes[c - 'a'];
            if (indexQueue == null) {
                return 0;
            }

            return indexQueue.size();
        }

        @Override
        public String toString() {
            int length = 0;
            for (IntQueue queue : charIndexes) {
                if (queue != null) {
                    length += queue.size();
                }
            }

            if (length == 0) {
                return new String("");
            }

            char[] tempCharArray = new char[length];

            for (int i = 0, j = 0; i < charArray.length; i++) {
                char c = charArray[i];
                if (c == '\0') {
                    continue;
                }

                tempCharArray[j++] = charArray[i];
            }

            return String.valueOf(tempCharArray);
        }
    }

    public static class IntQueue {
        private int[] queue;
        private int head = 0;
        private int tail = 0;

        public IntQueue(int length) {
            if (length < 1) {
                throw new IllegalArgumentException("Queue length must be greater than 0");
            }

            queue = new int[length];
            for(int i = 0; i < queue.length; i++) {
                queue[i] = -1;
            }
        }

        public void push(int i) {
            queue[tail++] = i;
        }

        public int pull() {
            return size() > 0 ? queue[head++] : -1;
        }

        public int size() {
            return tail - head;
        }
    }
}
