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.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;



public class ICC1D {

	static StringTokenizer st;
	static BufferedReader br;
	static PrintWriter pw;

	static class Sort implements Comparable<Sort> {
		int ind, a;

		@Override
		public int compareTo(Sort o) {
			return a - o.a;
		}
		public Sort(int i, int an) {
			ind = i;
			a = an;
		}
	}

	static char[] c;
	static int[] ls, curs;
	static int m, len;
	static boolean[] b;
	static int count = 0;
	
	public static void main(String[] args) throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		m = nextInt();
		c = next().toCharArray();
		len = c.length;
		b = new boolean [len];
		ls = new int [26];
		curs = new int [26];
		int minc = 0;
		for (int i = 0; i < len; ++i) {
			ls[c[i] - 'a']++;
			curs[c[i] - 'a']++;
			if (i >= m - 1) {
				if (i >= m) curs[c[i - m] - 'a']--;
				int ind = 0;
				while (curs[ind] == 0) ind++;
				if (ind > minc) minc = ind;
			}
		}
		/*if (m == 1) {
			for (int i = 0; i < 26; ++i) {
				for (int j = 0; j < ls[i]; ++j)
					pw.print((char) ('a' + i));
			}
			pw.close();
			return;
		} */
		for (int i = 0; i < minc; ++i) {
			for (int j = 0; j < ls[i]; ++j)
				pw.print((char) ('a' + i));
		}
		count = 0;
		for (int i = 0; i < len;) {
			if (c[i] >= 'a' + minc) {
				int oldi = i;
				while ((i < len) && (c[i] >= 'a' + minc)) ++i;
				if (i - oldi >= m) {
					checkFor(oldi, i, minc);
				}
			} else ++i;
		}
		for (int i = 0; i < count; ++i)
			pw.print((char) ('a' + minc));
		pw.close();
	}
	

	private static void checkFor(int l, int r, int minc) {
		//System.out.println(l + "  " + r);
		int ind = l; 
		for (; c[ind] != 'a' + minc; ++ind);
		int curl = l;
		for (int i = ind + 1; i < r; ++i) {
			if (c[i] == 'a' + minc) {
				if (i - curl < m) {
					ind = i;
				} else {
					++count;
					curl = ind + 1;
					ind = i;
				}
			}
		}
		if (r - curl >= m) {
			++count;
		}
	}


	private static int sumf(int[] fen, int id) {
		int summ = 0;
		for (; id >= 0; id = (id & (id + 1)) - 1) 
 			summ += fen[id];
		return summ;
	}

	private static void addf(int[] fen, int id) {
		for (; id < fen.length; id |= id + 1) 
			fen[id]++;
	}

	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();
	}
}