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

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			new Main().run();
		} catch (IOException e) {
		}
	}
	
	private void run() throws IOException {
		if(new File("input.txt").exists()) {
			in = new BufferedReader(new FileReader("input.txt"));
		} else {
			in = new BufferedReader(new InputStreamReader(System.in));
		}
		out = new PrintWriter(System.out);
		solve();
		in.close();
		out.close();
	}
	
	int n, k;
	char m[];
	
	boolean test(int lastChar) {
		int diff = 0;
		for(int i = 0; i < n; i++) {
			if(m[i] <= lastChar) {
				diff = 0;
			} else {
				diff++;
				if(diff >= k) return false;
			}
		}
		return true;
	}
	
	int[] pick(int lastChar) {
		int ret[] = new int[256];
		
		int diff = 0;
		int lastPosition = 0;
		
		for(int i = 0; i < n; i++) {
			if(m[i] < lastChar) {
				diff = 0;
				ret[m[i]]++;
			} else if(m[i] == lastChar) {
				lastPosition = i;
			} 
			
			if(m[i] >= lastChar){
				diff++;
				if(diff == k) {
					diff = i - lastPosition;
					ret[lastChar]++;
				}
			}
		}	
		
		
		return ret;
	}
	
	private void solve() throws IOException{
		k = nextInt();
		m = nextToken().toCharArray();
		n = m.length;
		
		int left = 'a';
		int right = 'z';
		while(left < right) {
			int mid = (left + right) >> 1;
			if(test(mid)) {
				right = mid;
			} else {
				left = mid + 1;
			}
		}
		StringBuilder sb = new StringBuilder();
		int[] pick = pick(left);
		for(char ch = 'a'; ch <= 'z'; ch++) {
			while(pick[ch] --> 0 ) {
				sb.append(ch);
			}
		}
		out.println(sb.toString());
	}
	
	
	StringTokenizer st = new StringTokenizer("");
	BufferedReader in;
	PrintWriter out;
	
	String nextToken() throws IOException {
		while(!st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

}
