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
//package pack;
import java.io.*;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
import java.util.*;
import java.io.*;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.*;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.math.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Vector;
import static java.lang.Math.sqrt;
import static java.lang.Math.floor;

public class topcoder {
   
	 public static int sumOfDigits (long n) {
		 
		 int sum = 0;
		 
		 while(n > 0) {
			 sum += n%10;
			 n /= 10;
		 }
		 
		 return sum;
	 
	 }
	 
	 
	 public static long binary_search(int s, int e, long num, long []ar) {
		 
		 if(s > e) {
			 return -1;
		 }	 
			 
		 
		     int mid = (s+e)/2;
		     
		      if(s == e && ar[s] >= num) {
		    	  return ar[s];
		      }else if(s == e && ar[s] < num) {
		    	  return -1;
		      }else if(ar[mid] < num) {
		    	  return binary_search(mid+1,e,num,ar);
		      }else if(ar[mid] >= num) {
		    	    return binary_search(s,mid,num,ar);
		      }
		      
		      return -1;
		 
	 }
	 
	 
	 public static int index_search(int s, int e, long num, long []ar) {
		 
		 if(s > e) {
			 return -1;
		 }	 
			 
		 
		     int mid = (s+e)/2;
		     
		      if(s == e && ar[s] >= num) {
		    	  return s;
		      }else if(s == e && ar[s] < num) {
		    	  return -1;
		      }else if(ar[mid] < num) {
		    	  return index_search(mid+1,e,num,ar);
		      }else if(ar[mid] >= num) {
		    	    return index_search(s,mid,num,ar);
		      }
		      
		      return -1;
		 
	 }
		     public static void swap(int []ar, int i, int j) {
		    	 
		    	 
		    	 for(int k= j; k >= i; k--) {
		    		 int temp = ar[k];
		    		 ar[k] = ar[k+1];
		    		 ar[k+1] = temp;
		    	 }
		     }
		     
		     public static boolean digit_exists(long n) {
		    	 
		    	 while(n > 0) {
		    		 if(n%10 == 9)
		    			 return true;
		    		 n = n/10;
		    	 }
		    	 
		    	 return false;
		     }
		     public static int log(int n) {
		    	 
		    	 int c = 0;
		    	 while(n > 0) {
		    		 c++;
		    		 n /=2;
		    	 }
		    	 
		    	 return c;
		     }
			  public static int findOr(int[]bits){
	    	        int or=0;
	    	            for(int i=0;i<32;i++){
	    	                or=or<<1;
	    	                if(bits[i]>0)
	    	                    or=or+1;
	    	            }
	    	        return or;
	    	    }
			  
			  static void simpleSieve(int limit, Vector<Integer> prime)
			    {
			        // Create a boolean array "mark[0..n-1]" and initialize
			        // all entries of it as true. A value in mark[p] will
			        // finally be false if 'p' is Not a prime, else true.
			        boolean mark[] = new boolean[limit+1];
			         
			        for (int i = 0; i < mark.length; i++)
			            mark[i] = true;
			      
			        for (int p=2; p*p<limit; p++)
			        {
			            // If p is not changed, then it is a prime
			            if (mark[p] == true)
			            {
			                // Update all multiples of p
			                for (int i=p*p; i<limit; i+=p)
			                    mark[i] = false;
			            }
			        }
			      
			        // Print all prime numbers and store them in prime
			        for (int p=2; p<limit; p++)
			        {
			            if (mark[p] == true)
			            {
			                prime.add(p);
			             
			            }
			        }
			    }
			      
			    // Prints all prime numbers smaller than 'n'
			    static void segmentedSieve(int n, ArrayList<Integer>l)
			    {
			        // Compute all primes smaller than or equal
			        // to square root of n using simple sieve
			        int limit = (int) (floor(sqrt(n))+1);
			        Vector<Integer> prime = new Vector<>(); 
			  
			        simpleSieve(limit, prime);
			      
			        // Divide the range [0..n-1] in different segments
			        // We have chosen segment size as sqrt(n).
			        int low  = limit;
			        int high = 2*limit;
			      
			        // While all segments of range [0..n-1] are not processed,
			        // process one segment at a time
			        while (low < n)
			        {
			            if (high >= n)
			                high = n;
			 
			            // To mark primes in current range. A value in mark[i]
			            // will finally be false if 'i-low' is Not a prime,
			            // else true.
			            boolean mark[] = new boolean[limit+1];
			             
			            for (int i = 0; i < mark.length; i++)
			                mark[i] = true;
			      
			            // Use the found primes by simpleSieve() to find
			            // primes in current range
			            for (int i = 0; i < prime.size(); i++)
			            {
			                // Find the minimum number in [low..high] that is
			                // a multiple of prime.get(i) (divisible by prime.get(i))
			                // For example, if low is 31 and prime.get(i) is 3,
			                // we start with 33.
			                int loLim = (int) (floor(low/prime.get(i)) * prime.get(i));
			                if (loLim < low)
			                    loLim += prime.get(i);
			      
			                /*  Mark multiples of prime.get(i) in [low..high]:
			                    We are marking j - low for j, i.e. each number
			                    in range [low, high] is mapped to [0, high-low]
			                    so if range is [50, 100]  marking 50 corresponds
			                    to marking 0, marking 51 corresponds to 1 and
			                    so on. In this way we need to allocate space only
			                    for range  */
			                for (int j=loLim; j<high; j+=prime.get(i))
			                    mark[j-low] = false;
			            }
			      
			            // Numbers which are not marked as false are prime
			            for (int i = low; i<high; i++)
			                if (mark[i - low] == true)
			                   l.add(i);
			      
			            // Update low and high for next segment
			            low  = low + limit;
			            high = high + limit;
			        }
			    }
			    
			    public static int find_indexNum(long k) {
			    	
			    	long k1 = k;
			    	int power = 0;
			    	
			    	while(k > 0) {
			    		power++;
			    		k /=2 ;
			    	}
			    	
			    	long check = (long)Math.pow(2, power-1);
			    	if(k1 == check) {
			    		return power;
			    	}
			//   System.out.println(power);
			    	long f = (long)Math.pow(2, power-1);
			    	long rem = k1-f;
			    	return find_indexNum(rem);
			    }
			    
			     
	    	
	 public static void main(String args[])throws IOException{
		 
	//	 System.setIn(new FileInputStream("Case.txt"));
		 Scanner sc = new Scanner(System.in);
	    
		 
		  
		 int n = sc.nextInt();
		 int k = sc.nextInt();
		 
		 String s = sc.next();
		 
		 
		 HashMap<Character,Integer>map = new HashMap<>();
		 
		 
		 for(char c : s.toCharArray()) {
			 if(map.containsKey(c)) {
				 map.put(c,map.get(c)+1);
			 }else {
				 map.put(c, 1);
			 }
		 }
		 int count[] = new int[26];
		 
		 int i = 0;
		 
		 while(k > 0 && i < 26) {
			 int index = i+97;
			 char c = (char)(index);
			 
			 if(map.containsKey(c)) {
				 int v = map.get(c);
				 if(k > v) {
					 k -= v;
					 count[i] = v;
				 }else {
					 count[i] = k;
					 k = 0;
				 }
			 }
			 i++;
			 
		 }
		 
		 StringBuilder sb = new StringBuilder();
		 
		for( i = 0; i < s.length(); i++) {
			int pos = (int)s.charAt(i)-0;
			pos = pos-97;
			if(count[pos] > 0) {
				count[pos]--;
			}else {
				sb.append(s.charAt(i));
			}
		}
		
		String ans = sb.toString();
		
		System.out.println(ans);
	 }
}
		 
		 
		 
		 
		 
		 
		 
		 
		 
		 
		 
		 
		 
		 
		 
		 
		 
		 
		 
		 
		 