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.*; 
import java.math.BigInteger;
import java.util.*;
  
public class Main {
	static final long MOD = 998244353;
	static int[] isPrime;
	static ArrayList<Integer> p;
    public static void main(String[] args) throws IOException {
        FastScanner sc=new FastScanner();
        int N = sc.nextInt();
        int K = sc.nextInt();
        char[] str = sc.next().toCharArray();
        int[] counts = new int[26];
        for (char c: str)
        	counts[(int)c - (int)'a'] += 1;
        int[] toRemove = new int[26];
        for (int i = 0; i < 26; i++) {
        	if (K > counts[i]) {
        		toRemove[i] = counts[i];
        		K -= counts[i];
        	} else {
        		toRemove[i] = K;
        		K = 0;
        		break;
        	}
        }
        int[] removed = new int[26];
        StringBuilder ans = new StringBuilder();
        for (char c: str) {
        	int index = (int)c-(int)'a';
        	if (removed[index] < toRemove[index]) {
        		removed[index] += 1;
        	} else {
        		ans.append(c);
        	}
        }
        System.out.println(ans);
    }
    
    static int phi(int n) {
    	//From Geeks4Geeks
        int res = n;  
        // this loop runs sqrt(n / ln(n)) times  
        for (int i=0; p.get(i)*p.get(i) <= n; i++) {  
            if (n % p.get(i)== 0) {  
                res -= (res / p.get(i));  
                while (n % p.get(i)== 0) { 
                	n /= p.get(i);
                }
            }
        }
        if (n > 1)  
        	res -= (res / n);  
      
        return res;  
    }
    
    static class FastScanner { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastScanner() 
        { 
            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; 
        } 
    }
}

class Node {
	public int n;
	public HashSet<Node> children;
	
	public Node(int n) {
		this.n = n;
		children = new HashSet<Node>();
	}
	
	public void addChild(Node node) {
		children.add(node);
	}
	
	public void removeChild(Node node) {
		children.remove(node);
	}
}

class BinaryIndexedTree {
	  public long[] arr;

	  public BinaryIndexedTree (int N) {
	    arr = new long[N+1];
	    arr[0] = 0;
	  }

	  //add k to the i-th element.
	  public void add(long k, int i) {
	    int node = i+1;
	    while (node < arr.length) {
	      arr[node] += k;
	      node += node & (-node);
	    }
	  }

	  //sum up the elements from input[s_i] to input[e_i], from [s_i,e_i).
	  public long sum(int s_i, int e_i) {
	    return sum(e_i) - sum(s_i);
	  }

	  public long sum(int i) {
	    long total = 0;
	    int node = i;
	    while (node > 0) {
	      total += arr[node];
	      node -= node & (-node);
	    }
	    return total;
	  }
}