You are given a string s, consisting of lowercase English letters, and the integer m.

One should choose some symbols from the given string so that any contiguous subsegment of length m has at least one selected symbol. Note that here we choose positions of symbols, not the symbols themselves.

Then one uses the chosen symbols to form a new string. All symbols from the chosen position should be used, but we are allowed to rearrange them in any order.

Formally, we choose a subsequence of indices 1 ≤ i1 < i2 < ... < it ≤ |s|. The selected sequence must meet the following condition: for every j such that 1 ≤ j ≤ |s| - m + 1, there must be at least one selected index that belongs to the segment [j, j + m - 1], i.e. there should exist a k from 1 to t, such that j ≤ ik ≤ j + m - 1.

Then we take any permutation p of the selected indices and form a new string sip1sip2... sipt.

Find the lexicographically smallest string, that can be obtained using this procedure.

Input

The first line of the input contains a single integer m (1 ≤ m ≤ 100 000).

The second line contains the string s consisting of lowercase English letters. It is guaranteed that this string is non-empty and its length doesn't exceed 100 000. It is also guaranteed that the number m doesn't exceed the length of the string s.

Output

Print the single line containing the lexicographically smallest string, that can be obtained using the procedure described above.

Examples

Input

3
cbabc


Output

a


Input

2
abcab


Output

aab


Input

3
bcabcbaccba


Output

aaabb

Note

In the first sample, one can choose the subsequence {3} and form a string "a".

In the second sample, one can choose the subsequence {1, 2, 4} (symbols on this positions are 'a', 'b' and 'a') and rearrange the chosen symbols to form a string "aab".
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;


public class D {

	static StringTokenizer st;
	static BufferedReader br;
	static PrintWriter pw;
	public static void main(String[] args) throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		int m = nextInt();
		char[]a = next().toCharArray();
		int n = a.length;
		boolean[]used = new boolean[n];
		int[]inc = new int[n]; 
		for (int i = 'a'; i <= 'z'; i++) {
			Arrays.fill(inc, 0);
			Arrays.fill(used, false);
			for (int j = 0; j < n; j++) {
				if (a[j] < i) {
					int left = Math.max(0, j-m+1);
					inc[left]++;
					if (j < n-1)
						inc[j+1]--;
					used[j] = true;
				}
			}
			for (int j = 1; j < n; j++) {
				inc[j] += inc[j-1];
			}
			int last = -1;
			boolean ok = true;
			int right = n-1;
			for (int j = n-1; j >= 0; j--) {
				if (a[j]==i)
					last = j;
				if (j <= n-m && inc[j]==0) {
					if (last >= 0 && last-j <= m-1) {
						used[last] = true;
						for (int j2 = Math.min(last, right); j2 >= Math.max(0, last-m+1); j2--) {
							inc[j2]++;
						}
						right = Math.min(right, last-m);
					}
					else {
						ok = false;
						break;
					}
				}
			}
			if (ok) {
				ArrayList<Character> res = new ArrayList<>();
				for (int j = 0; j < n; j++) {
					if (used[j])
						res.add(a[j]);
				}
				Collections.sort(res);
				for (char w : res) {
					pw.print(w);
				}
				break;
			}
		}
		pw.close();
	}
	private static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}
	private static long nextLong() throws IOException {
		return Long.parseLong(next());
	}
	private static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}
	private static String next() throws IOException {
		while (st==null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
}