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
	// Code Author: Shrey Shah
	 
	import java.io.*;
	import java.math.BigInteger;
	import java.math.RoundingMode;
	import java.text.DecimalFormat;
	import java.util.*;
	
	
	public class Tester3 {
	
		static double eps=(double)1e-6;
		static long mod=1000000007;
		 static long d,x ,y;
		public static void main(String args[]){
			InputReader sc = new InputReader(System.in);
			OutputStream outputStream = System.out;
			PrintWriter out = new PrintWriter(outputStream);
			//----------My Code----------
				int n = sc.nextInt();
				int k = sc.nextInt();
				int freq[] = new int[26];
				String t =sc.nextLine();
				ArrayList<Integer> index[] = new ArrayList[26];
				int curr_index[] = new int[26];
				Arrays.fill(curr_index,-1);
				for(int i=0;i<26;i++)
					index[i]=new ArrayList<Integer>();
				
				for(int i=0;i<t.length();i++)
				{
					index[t.charAt(i)-'a'].add(i);
					freq[t.charAt(i)-'a']++;
					if(curr_index[t.charAt(i)-'a']==-1)
						curr_index[t.charAt(i)-'a']=0;
				}
				char s[] = t.toCharArray();
				
				while(k>0)
				{
					for(int i=0;i<26;i++)
					{
						if(freq[i]>0)
						{
							int ind_Arraylist = curr_index[i];
							curr_index[i]++;
							int ind = index[i].get(ind_Arraylist);
							s[ind]=' ';
							freq[i]--;
							break;
						}
					}
					k--;
				}
				for(int i=0;i<s.length;i++)
					if(s[i]!=' ')
						out.print(s[i]);
			//----------The End----------
			out.close();
		}
		public static void reverseArray(char arr[], int start, int end)
		{
		    while (start < end)
		    {
		        char temp = arr[start]; 
		        arr[start] = arr[end];
		        arr[end] = temp;
		        start++;
		        end--;
		    } 
		}
		static String reverse(String s)
		{
			String ans="";
			for(int i=s.length()-1;i>=0;i--)
				ans+=s.charAt(i);
			return ans;
		}
		static long nearestPrime(long x)
		{
			long left=x-1;
			long right=x+1;
			
			long count=400;
			while(count>0)
			{
				if(isPrime(left))
					break;
				
				left--;
				count--;
			}
			count=301;
			while(count>0)
			{
				if(isPrime(right))
					break;
				
				right++;
				count--;
			}
			if(Math.abs(left-x) > Math.abs(right-x))
				return right;
			else if(Math.abs(left-x)<Math.abs(right-x))
				return left;
			else
				return left;
		}
		static boolean isPrime(long n)
		{
			if(n==1 || n==2)
				return true;
			for(long i=2;i*i<=n;i++)
				if(n%i==0)
					return false;
			return true;
		}
		 static long modInverse(long A, long M)
		    {
		        extendedEuclid(A,M);
		        return (x%M+M)%M;    //x may be negative
		    }
		    static void extendedEuclid(long A, long B) {
		       
		        if(B == 0) {
		            d = A;
		            x = 1;
		            y = 0;
		        }
		        else {
		            extendedEuclid(B, A%B);
		            long temp = x;
		            x = y;
		            y = temp - (A/B)*y;
		        }
		    }
		public static int floor(int arr[], int low, int high, long x)
		{
			for(int i=low;i<high-1;i++)
				if(arr[i]<x && (arr[i+1]>=x))
					return arr[i];
			
			return arr[0];
		}
		
		public static int ceil(int arr[], int low, int high, long x)
		{
			for(int i=low+1;i<high;i++)
			{
				if(arr[i-1]<=x && arr[i]>x)
					return arr[i];
			}
			return arr[high-1];
		}
		public static long[] totient(int n)
		{
		 long phi[] = new long[n + 1];
		    for (long i = 1; i <= n; i++)
		    phi[(int)i] = i; // indicates not evaluated yet
		                // and initializes for product
		                // formula.
		 
		    // Compute other Phi values
		    for (long p = 2; p <= n; p++) 
		    {
		         
			    // If phi[p] is not computed already,
			    // then number p is prime
			    if (phi[(int)p] == p) 
			    {
			         
			        // Phi of a prime number p is
			        // always equal to p-1.
			        phi[(int)p] = p - 1;
			 
			        // Update phi values of all
			        // multiples of p
			        for (long i = 2 * p; i <= n; i += p) 
			        {
			             
			        // Add contribution of p to its
			        // multiple i by multiplying with
			        // (1 - 1/p)
			        	
			        phi[(int)i] = (phi[(int)i]* p) *(p - 1);
			        }
			   }
		   }
		    return phi;
		}
		 private static int max(int a, int b) {
			// TODO Auto-generated method stub
			 
			return (a>b)? a:b;
		}

		static int power(int x,int n)
			{
			    if(n==0)
			        return 1;
			    else if(n%2 == 0)        //n is even
			        return power(x*x,n/2);
			    else                             //n is odd
			        return x*power(x*x,(n-1)/2);
			}
	
		static long ce(long x)
		{
			if(x%2!=0)
				return x/2+1;
			return x/2;
		}
		static boolean isSubSequence(String str1, String str2, int m, int n)
		{
		   int j = 0;
		   for (int i=0; i<n&&j<m; i++)
		       if (str1.charAt(j) == str2.charAt(i))
		         j++;
		 
		   return (j==m);
		}
			
		static long fibo(long l) {
	        if (l < 0) {
	            throw new IllegalArgumentException("The fibo value cannot be negative");
	        }
	
	        if (l <= 1) return l;
	
	        long[][] result = {{1, 0}, {0, 1}}; // identity matrix.
	        long[][] fiboM = {{1, 1}, {1, 0}};
	
	        while (l > 0) {
	            if (l%2 == 1) {
	                multMatrix(result, fiboM);
	            }
	            l = l / 2;
	            multMatrix(fiboM, fiboM);
	        }
	
	        return result[1][0];
	    }
	
	    private static void multMatrix(long[][] result, long[][] fiboM) {
	        long a = (result[0][0]%mod * fiboM[0][0]%mod)%mod +  (result[0][1]%mod * fiboM[1][0]%mod)%mod;
	        long b = (result[0][0]%mod * fiboM[0][1]%mod)%mod + ( result[0][1]%mod * fiboM[1][1]%mod)%mod;
	        long c = (result[1][0]%mod * fiboM[0][0]%mod)%mod + ( result[1][1]%mod * fiboM[0][1]%mod)%mod;
	        long d = (result[1][0]%mod * fiboM[0][1]%mod)%mod +  (result[1][1]%mod * fiboM[1][1]%mod)%mod;
	
	        result[0][0] = a;
	        result[0][1] = b;
	        result[1][0] = c;
	        result[1][1] = d;
	    }
	    
	    
		static int[] sieve(int n)
		{
			int[] arr = new int[n+1];
			for(int i=2;i*i<=n;i++)
			{
				if(arr[i]==0)
				{
					for(int j=i*2;j<=n;j+=i)
						arr[j]=1;
				}
			}
			return arr;
		}
		
		static boolean isPal(String s)
		{
			for(int i=0, j=s.length()-1;i<=j;i++,j--)
			{
				if(s.charAt(i)!=s.charAt(j)) return false;
			}
			return true;
		}
		public static String rev(String s)
		{
			StringBuilder sb=new StringBuilder(s);
			sb.reverse();
			return sb.toString();
		}
		    
		static long lcm(long a, long b)
		{
		    return a * (b / gcd(a, b));
		}
		
		static long gcd(long a, long b)
		{
		    while (b > 0)
		    {
		        long temp = b;
		        b = a % b; // % is remainder
		        a = temp;
		    }
		    return a;
		}
		static long modulo(long a,long b,long c) {
			long x=1;
			long y=a;
			while(b > 0){
				if(b%2 == 1){
					x=(x*y)%c;
				}
				y = (y*y)%c; // squaring the base
				b /= 2;
			}
			return  x%c;
		}
		public static void debug(Object... o) {
			System.out.println(Arrays.deepToString(o));
		}
		static class Pair implements Comparable<Pair>{
			int x;
			int y;
			int i;
			Pair(int xx,int yy){
				x=xx;
				y=yy;
			}
			@Override
			public int compareTo(Pair o) {
				return Integer.compare(this.x, o.x);
			}
		}
	
		static class InputReader {
			public BufferedReader reader;
			public StringTokenizer tokenizer;
	
			public InputReader(InputStream inputstream) {
				reader = new BufferedReader(new InputStreamReader(inputstream));
				tokenizer = null;
			}
	
			public String nextLine(){
				String fullLine=null;
				while (tokenizer == null || !tokenizer.hasMoreTokens()) {
					try {
						fullLine=reader.readLine();
					} catch (IOException e) {
						throw new RuntimeException(e);
					}
					return fullLine;
				}
				return fullLine;
			}
			public String next() {
				while (tokenizer == null || !tokenizer.hasMoreTokens()) {
					try {
						tokenizer = new StringTokenizer(reader.readLine());
					} catch (IOException e) {
						throw new RuntimeException(e);
					}
				}
				return tokenizer.nextToken();
			}
			public long nextLong() {
				return Long.parseLong(next());
			}
			public int nextInt() {
				return Integer.parseInt(next());
			}
		}
		
	}
