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.util.*;


public class Main {

    public static final String FILE_SUFFIX_IN = "in";
    public static final String FILE_SUFFIX_OUT = "out";
    public static final String FILE_NAME_IN = "ejudge";
    public static final String FILE_NAME_OUT = "ejudge";

    public static void main(String[] args) {
        InputStream inputStream = System.in;
//        InputStream inputStream = new FileInputStream(FILE_NAME_IN + "." + FILE_SUFFIX_IN);
        OutputStream outputStream = System.out;
//        OutputStream outputStream = new FileOutputStream(FILE_NAME_OUT + "." + FILE_SUFFIX_OUT);

        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Answer solver = new Answer();
        solver.solve(in, out);
        out.close();
    }
}

class Answer {
    private final int INF = (int) (1e9 + 7);
    private final int MOD = (int) (1e9 + 7);
    private final int MOD1 = (int) (1e6 + 3);
    private final long INF_LONG = (long) (1e18 + 1);
    private final double EPS = 1e-9;
    private final double EPS6 = 1e-6;

    private long gcd(long a, long b) {
        return (b == 0) ? a : gcd(b, a % b);
    }

    private long lcm(long a, long b) {
        return a * b / gcd(a, b);
    }

    private void printList(List<Integer> a, PrintWriter out) {
        a.forEach(x -> out.print(x + " "));
        out.println();
    }

    void solve(InputReader in, PrintWriter out) {
        int n = in.nextInt();
        int k = in.nextInt();
        String s = in.next();


        List<Integer>[] pos = new List[26];
        for (int i = 0; i < 26; i++) {
            pos[i] = new ArrayList<>();
        }

        for (int i = 0; i < n; i++) {
            int x = s.charAt(i) - 'a';
            pos[x].add(i);
        }

        Set<Integer> badPos = new HashSet<>();

        int i = 0;
        int j = 0;
        while (badPos.size() != k) {
            if (j < pos[i].size()) {
                badPos.add(pos[i].get(j));
                j++;
            } else {
                i++;
                j = 0;
            }
        }

        for (int l = 0; l < n; l++) {
            if (!badPos.contains(l)) {
                out.print(s.charAt(l));
            }
        }
        out.println();
    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

    InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    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 int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public int[] nextArrayInt(int count) {
        return nextArrayInt(0, count);
    }

    public int[] nextArrayInt(int start, int count) {
        int[] a = new int[start + count];
        for (int i = start; i < start + count; i++) {
            a[i] = nextInt();
        }
        return a;
    }

    public long[] nextArrayLong(int count) {
        long[] a = new long[count];
        for (int i = 0; i < count; i++) {
            a[i] = nextLong();
        }
        return a;
    }

    public List<String> getListString(int count) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            list.add(next());
        }
        return list;
    }

    public List<Integer> getListInt(int count) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            list.add(nextInt());
        }
        return list;
    }

    public List<Long> getListLong(int count) {
        List<Long> list = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            list.add(nextLong());
        }
        return list;
    }
}