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.util.*;
import java.io.*;
import java.math.*;

public class Practice 

{ 
	 static FastReader sc=new FastReader(); 
	 
		  public static void main(String[] args) 
    {
			StringBuffer sb=new StringBuffer("");
			   int ttt =1;
			    	// ttt=i();
		        outer :while (ttt-- > 0) 
				{
		        	int n=i();
		        	int k=i();
		        	String s=s();
		        	int A[]=new int[26];
		        	for(int i=0;i<n;i++) {
		        		A[s.charAt(i)-'a']++;
		        	}
		        	for(int i=0;i<26;i++) {
		        		if(A[i]>=k) {
		        			A[i]-=k;
		        			k=0;
		        		}
		        		else {
		        			k-=A[i];
		        			A[i]=0;
		        		}
		        	}
		        	for(int i=n-1;i>=0;i--) {
		        		char ch=s.charAt(i);
		        		int c=ch-'a';
		        		//System.out.print(ch);
		        		if(A[c]>0) {
		        			sb.append(ch);
		        			A[c]--;
		        		}
		        		
		        	}
		        	sb.reverse();
		        	System.out.println(sb);
		        	
				}
		        //System.out.println(sb.toString());
    }
		  public static void BFS(char[][] grid,int s,int e,ArrayList<String> A[],int d[][]) {

		        int h = grid.length;
		        if (h == 0)
		            return;
		        int l = grid[0].length;

		        boolean[][] visited = new boolean[h][l];

		        Queue<String> queue = new LinkedList<>();

		        queue.add(s + "," + e);

		       // System.out.println("Breadth-First Traversal: ");
		        while (queue.isEmpty() == false) {

		            String x = queue.remove();
		            int row = Integer.parseInt(x.split(",")[0]);
		            int col = Integer.parseInt(x.split(",")[1]);
		            

		            if (row < 0 || col < 0 || row >= h || col >= l || visited[row][col]|| grid[row][col]=='#')
		                continue;
		            int dis=d[row][col];

		            visited[row][col] = true;
		            //System.out.print(grid[row][col] + " ");
		            char ch=grid[row][col];
		            if(ch>='a' && ch<='z') {
		            	for(int i=0;i<A[ch-'a'].size();i++) {
		            		String ss=A[ch-'a'].get(i);
		            		 int r = Integer.parseInt(ss.split(",")[0]);
		 		            int c = Integer.parseInt(ss.split(",")[1]);
		 		            
		            	}
		            }
		            queue.add(row + "," + (col - 1)); //go left
		            queue.add(row + "," + (col + 1)); //go right
		            queue.add((row - 1) + "," + col); //go up
		            queue.add((row + 1) + "," + col); //go down
		        }
		    }

	

static int[] input(int n) {
	int A[]=new int[n];
	   for(int i=0;i<n;i++) {
		   A[i]=sc.nextInt();
	   }
	   return A;
   }
static long[] inputL(int n) {
	long A[]=new long[n];
	   for(int i=0;i<n;i++) {
		   A[i]=sc.nextLong();
	   }
	   return A;
   }
static String[] inputS(int n) {
	String A[]=new String[n];
	   for(int i=0;i<n;i++) {
		   A[i]=sc.next();
	   }
	   return A;
   }


static void input(int A[],int B[]) {
	   for(int i=0;i<A.length;i++) {
		   A[i]=sc.nextInt();
		   B[i]=sc.nextInt();
	   }
}
static int max(int A[]) {
	int max=Integer.MIN_VALUE;
	for(int i=0;i<A.length;i++) {
		max=Math.max(max, A[i]);
	}
	return max;
}
static int min(int A[]) {
	int min=Integer.MAX_VALUE;
	for(int i=0;i<A.length;i++) {
		min=Math.min(min, A[i]);
	}
	return min;
}
static long max(long A[]) {
	long max=Long.MIN_VALUE;
	for(int i=0;i<A.length;i++) {
		max=Math.max(max, A[i]);
	}
	return max;
}
static long min(long A[]) {
	long min=Long.MAX_VALUE;
	for(int i=0;i<A.length;i++) {
		min=Math.min(min, A[i]);
	}
	return min;
}
static long mod(long x) {
	 int mod=1000000007;
	  return ((x%mod + mod)%mod);
}

     static int i() {
    	 return sc.nextInt();
     }
     static String s() {
    	 return sc.next();
     }
     static long l() {
    	 return sc.nextLong();
     }  
     static void sort(int[] A){
        int n = A.length;
        Random rnd = new Random();
        for(int i=0; i<n; ++i){
            int tmp = A[i];
            int randomPos = i + rnd.nextInt(n-i);
            A[i] = A[randomPos];
            A[randomPos] = tmp;
        }
        Arrays.sort(A);
     }
     static boolean prime(int n) 
	    { 
	        if (n <= 1) 
	            return false; 
	        if (n <= 3) 
	            return true; 
	        if (n % 2 == 0 || n % 3 == 0) 
	            return false; 
	        double sq=Math.sqrt(n);
	  
	        for (int i = 5; i <= sq; i = i + 6) 
	            if (n % i == 0 || n % (i + 2) == 0) 
	                return false; 
	        return true; 
	    } 
     static int gcd(int a, int b) 
     { 
         if (a == 0) 
             return b; 
         return gcd(b % a, a); 
     } 
  
     static class Pair
     {
    	 int a;
    	 int b;
     }
        
        
    static class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastReader() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        } 
  
        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; 
        } 
    } 
} 



