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.InputStream;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.security.KeyPair;
import java.util.*;

public class Main {

    static int[][] arr;
    static boolean[][] v_fow;
    static boolean[][] v_back;
    static boolean[][] ans;
    static int n;
    static int m;

    public static void main(String[] args) throws IOException {
        Reader.init(System.in);
        int n = Reader.nextInt();
        int k = Reader.nextInt();
        int kk = k;
        String s = Reader.next();
        int[] cnt = new int[26];
        for (int i = 0 ; i <  n ; i++){
            cnt[s.charAt(i)-'a']++;
        }
        //System.out.println(Arrays.toString(cnt));

        for (int i = 0 ; i < 26 ; i++){
            //System.out.println(k +  " " + cnt[i]);
            if (k>=cnt[i]){
                k-=cnt[i];
                cnt[i] = 0;

            }
            else if (cnt[i]>k){
                cnt[i]-=k;
                k=0;
            }

        }
        //System.out.println(Arrays.toString(cnt));
        char[] ans = new char[n-kk];
        int x= 1;
        for (int i = n-1 ; i>=0 ; i--){
            if(cnt[s.charAt(i)-'a']>0){
                ans[(n-kk)-x] = s.charAt(i);
                x++;
                //System.out.println("HI");
                cnt[s.charAt(i)-'a']--;
            }
        }
        System.out.println(String.valueOf(ans));




        
    }
    static void swap(char[] arr , int i , int j){
        char tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    static boolean dfs_forward(int x , int y){
        v_fow[x][y] = true;
        if (x==n-1 && y==m-1){
            return true;
        }
        boolean a= false;
        boolean b= false;
        if (check(x+1,y)&&!v_fow[x+1][y]){
            a = dfs_forward(x+1,y);
        }
        if (check(x,y+1)&&!v_fow[x][y+1]){
            b = dfs_forward(x,y+1);
        }
        return a||b;
    }


    static boolean dfs_back(int x , int y){
        v_back[x][y] = true;
        if (x==0 && y==0){
            return true;
        }
        boolean a= false;
        boolean b= false;
        if (check(x-1,y)&&!v_back[x-1][y]){
            a = dfs_back(x-1,y);
        }
        if (check(x,y-1)&&!v_back[x][y-1]){
            b = dfs_back(x,y-1);
        }
        return a||b;
    }


    static boolean check(int x , int y){
        if (x<0 || x>=n || y <0 || y >= m){
            return false;
        }
        if (arr[x][y]==-1){
            return false;
        }
        return true;
    }



}

class Node implements Comparable<Node>{
    int a ,  b;
    Node(int a , int b){
        this.a = a;
        this.b = b;
    }
    public int compareTo(Node o) {
        if (this.a == o.a){
            return this.b - o.b;
        }
        return this.a - o.a;
    }
}
class Edge implements Comparable<Edge>{
    int x , y , w;

    public Edge(int x, int y, int w) {
        this.x = x;
        this.y = y;
        this.w = w;
    }

    @Override
    public int compareTo(Edge o) {
        return this.w - o.w;
    }
}
class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }
    /** get next word */
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                    reader.readLine() );
        }
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }

    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
}
class MergeSort
{
    // Merges two subarrays of arr[].
    // First subarray is arr[l..m]
    // Second subarray is arr[m+1..r]
    void merge(int arr[], int l, int m, int r)
    {
        // Find sizes of two subarrays to be merged
        int n1 = m - l + 1;
        int n2 = r - m;

        /* Create temp arrays */
        int L[] = new int [n1];
        int R[] = new int [n2];

        /*Copy data to temp arrays*/
        for (int i=0; i<n1; ++i)
            L[i] = arr[l + i];
        for (int j=0; j<n2; ++j)
            R[j] = arr[m + 1+ j];


        /* Merge the temp arrays */

        // Initial indexes of first and second subarrays
        int i = 0, j = 0;

        // Initial index of merged subarry array
        int k = l;
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        /* Copy remaining elements of L[] if any */
        while (i < n1)
        {
            arr[k] = L[i];
            i++;
            k++;
        }

        /* Copy remaining elements of R[] if any */
        while (j < n2)
        {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    // Main function that sorts arr[l..r] using
    // merge()
    void sort(int arr[], int l, int r)
    {
        if (l < r)
        {
            // Find the middle point
            int m = (l+r)/2;

            // Sort first and second halves
            sort(arr, l, m);
            sort(arr , m+1, r);

            // Merge the sorted halves
            merge(arr, l, m, r);
        }
    }

    /* A utility function to print array of size n */
    static void printArray(int arr[])
    {
        int n = arr.length;
        for (int i=0; i<n; ++i)
            System.out.print(arr[i] + " ");
        System.out.println();
    }

    // Driver method

}