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.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

public class D {
	public static void main(String[] args) throws NumberFormatException, IOException {
		Scanner sc = new Scanner();
		PrintWriter out = new PrintWriter(System.out);
		
		int m = sc.nextInt();
		
		char[] s = sc.next().toCharArray();
		
		ArrayList<Integer> taken = new ArrayList<Integer>();
		
		int i = 0;
		
		int len = 0;
		
		char maxT = 0;
		
		boolean tak[] = new boolean[s.length];
		
		while(i < s.length) {
			int min = i;
			
			for(int j = i; j < Math.min(i + m, s.length); j++)
				if(s[j] <= s[min])
					min = j;
			
			taken.add(min);
			tak[min] = true;
			
			len++;
			
			maxT = (char) Math.max(maxT, s[min]);
			
			if(min + m >= s.length)
				break;
			
			i = min + 1;
		}
		
		for(i = 0; i < s.length; i++) {
			if(s[i] < maxT && !tak[i]) {
				taken.add(i);
				tak[i] = true;
				len++;
			}
				
		}
		
		i = 0;
		char[] seq = new char[len];
		
		for(int idx : taken)
			seq[i++] = s[idx];
		
		Arrays.sort(seq);
		
		System.out.println(new String(seq));
		
		
		
		out.flush();
		out.close();
	}
	
	static class Scanner {
		BufferedReader br;
		StringTokenizer st;

		Scanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() throws IOException {
			while(st == null || !st.hasMoreTokens()) {
				st = new StringTokenizer(br.readLine());
			}

			return st.nextToken();
		}

		int nextInt() throws NumberFormatException, IOException {
			return Integer.parseInt(next());
		}
	}
}
