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

public class Main {
	class Pair{
		char c;
		int idx;
		boolean use;
		public Pair(int idx, char c){
			this.idx = idx;
			this.c = c;
		}
	}
	
	
	int M;
	char[] S;
	public void solve() {
		M = nextInt();
		S = next().toCharArray();
		TreeSet<Pair> use = new TreeSet<>((a,b) ->{
			return Integer.compare(a.idx, b.idx);
		});
		TreeSet<Pair> current = new TreeSet<>((a,b) ->{
			if(a.c == b.c){
				if(a.use == b.use){
					return Integer.compare(b.idx, a.idx);
				}else{
					if(a.use){
						return -1;
					}else{
						return 1;
					}
				}
			}else{
				return Character.compare(a.c, b.c);
			}
		});
		for(int i = 0; i < M - 1; i++){
			current.add(new Pair(i, S[i]));
		}
		for(int i = M - 1; i < S.length; i++){
			current.add(new Pair(i, S[i]));
			Pair f = current.first();
			if(!f.use){
				current.remove(f);
				f.use = true;
				current.add(f);
			}
			use.add(f);
			
			Pair p = new Pair(i - M + 1, S[i - M + 1]);
			current.remove(p);
			p.use = true;
			current.remove(p);
		}

		int[] cnt1 = new int[26];
		for(int i = 0; i < S.length; i++){
			cnt1[S[i] - 'a']++;
		}
		int[] cnt2 = new int[26];
		for(Pair p : use){
			cnt2[p.c - 'a']++;
		}
		int li = 25;
		while(cnt2[li] == 0) li--;
		for(int i = 0; i < 26; i++){
			if(i == li){
				for(int j = 0; j < cnt2[i]; j++){
					out.print((char)(i + 'a'));
				}
				break;
				
			}else{
				for(int j = 0; j < cnt1[i]; j++){
					out.print((char)(i + 'a'));
				}
			}
		}
		out.println();
	}

	private static PrintWriter out;

	public static void main(String[] args) {
		out = new PrintWriter(System.out);
		new Main().solve();
		out.flush();
	}

	public static int nextInt() {
		int num = 0;
		String str = next();
		boolean minus = false;
		int i = 0;
		if(str.charAt(0) == '-'){
			minus = true;
			i++;
		}
		int len = str.length();
		for(; i < len; i++){
			char c = str.charAt(i);
			if(!('0' <= c && c <= '9')) throw new RuntimeException();
			num = num * 10 + (c - '0');
		}
		return minus ? -num : num;
	}

	public static long nextLong() {
		long num = 0;
		String str = next();
		boolean minus = false;
		int i = 0;
		if(str.charAt(0) == '-'){
			minus = true;
			i++;
		}
		int len = str.length();
		for(; i < len; i++){
			char c = str.charAt(i);
			if(!('0' <= c && c <= '9')) throw new RuntimeException();
			num = num * 10l + (c - '0');
		}
		return minus ? -num : num;
	}

	public static String next() {
		int c;
		while(!isAlNum(c = read())){}
		StringBuilder build = new StringBuilder();
		build.append((char)c);
		while(isAlNum(c = read())){
			build.append((char)c);
		}
		return build.toString();
	}

	private static byte[] inputBuffer = new byte[1024];
	private static int bufferLength = 0;
	private static int bufferIndex = 0;

	private static int read() {
		if(bufferLength < 0) throw new RuntimeException();
		if(bufferIndex >= bufferLength){
			try{
				bufferLength = System.in.read(inputBuffer);
				bufferIndex = 0;
			}catch(IOException e){
				throw new RuntimeException(e);
			}
			if(bufferLength <= 0) return(bufferLength = -1);
		}
		return inputBuffer[bufferIndex++];
	}

	private static boolean isAlNum(int c) {
		return '!' <= c && c <= '~';
	}
}
