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.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 * 
 * @author pttrung
 */
public class D_Intel_Final {

	public static long MOD = 1000000007;

	public static void main(String[] args) throws FileNotFoundException {
		// PrintWriter out = new PrintWriter(new FileOutputStream(new File(
		// "output.txt")));
		PrintWriter out = new PrintWriter(System.out);
		Scanner in = new Scanner();
		int m = in.nextInt();
		String s = in.next();
		int n = s.length();
		TreeSet<Point> set = new TreeSet();
		int[] count = new int[26];
		for (int j = 0; j < 26; j++) {
			TreeSet<Point> cur = new TreeSet(set);
			char c = (char) ('a' + j);
			int num = 0;
			for (int i = 0; i < n; i++) {
				if (s.charAt(i) == c) {
					num++;
					Point tmp = new Point(Math.max(0, i - m + 1), i);
					Point a = cur.floor(new Point(tmp.x, i));
					Point b = cur.ceiling(new Point(i, i));
//					if (c == 'b') {
//						System.out.println(tmp + " " + a + " " + b);
//					}
					if (a != null) {
						if (a.y + 1 >= tmp.x) {

							if (a.y < tmp.y) {
								cur.remove(a);
								tmp.x = Math.min(a.x, tmp.x);
								if (b != null && b.x <= 1 + tmp.y) {
									cur.remove(b);
									tmp.y = Math.max(tmp.y, b.y);
								}
								cur.add(tmp);
							}
						} else {
							if (b != null && b.x <= 1 + tmp.y) {
								cur.remove(b);
								tmp.x = Math.min(tmp.x, b.x);
								tmp.y = Math.max(tmp.y, b.y);
								cur.add(tmp);
							} else {
								cur.add(tmp);
							}
						}
					} else if (b != null) {
						if (b.x <= 1 + tmp.y) {
							cur.remove(b);
							tmp.x = Math.min(tmp.x, b.x);
							
							tmp.y = Math.max(tmp.y, b.y);
							cur.add(tmp);
						} else {
							cur.add(tmp);
						}
					} else {
						cur.add(tmp);
					}
				}
			}
//			if(s.startsWith("xrrtdampospvysfctvwry")){
//			System.out.println(cur + " " + c);
//			}
			if (!cur.isEmpty()) {
				
				Point p = cur.first();
				if (p.x == 0 && p.y >= n - m) {
					count[j] = cal(c, m, n, s, set);
					break;
				}
				count[j] = num;
				set = cur;
			}
		}
		for (int i = 0; i < 26; i++) {
			char c = (char) ('a' + i);
			for (int j = 0; j < count[i]; j++) {
				out.print(c);
			}
		}
		out.close();
	}

	static int cal(char c, int m, int n, String s, TreeSet<Point> set) {
		int result = 0;
		int last = 0;
		// System.out.println(set);
		for (Point p : set) {
			while (last < p.x) {
				for (int i = last + m - 1; i >= last; i--) {
					if (s.charAt(i) == c) {
						result++;
						last = i + 1;
						break;
					}
				}
			}
			last = p.y + 1;
		}
		while (last <= n - m) {
			for (int i = Math.min(n, last + m) - 1; i >= last; i--) {
				if (s.charAt(i) == c) {
					result++;
					last = i + 1;
					break;
				}
			}
		}
		return result;
	}

	public static int[] KMP(String val) {
		int i = 0;
		int j = -1;
		int[] result = new int[val.length() + 1];
		result[0] = -1;
		while (i < val.length()) {
			while (j >= 0 && val.charAt(j) != val.charAt(i)) {
				j = result[j];
			}
			j++;
			i++;
			result[i] = j;
		}
		return result;

	}

	public static boolean nextPer(int[] data) {
		int i = data.length - 1;
		while (i > 0 && data[i] < data[i - 1]) {
			i--;
		}
		if (i == 0) {
			return false;
		}
		int j = data.length - 1;
		while (data[j] < data[i - 1]) {
			j--;
		}
		int temp = data[i - 1];
		data[i - 1] = data[j];
		data[j] = temp;
		Arrays.sort(data, i, data.length);
		return true;
	}

	public static int digit(long n) {
		int result = 0;
		while (n > 0) {
			n /= 10;
			result++;
		}
		return result;
	}

	public static double dist(long a, long b, long x, long y) {
		double val = (b - a) * (b - a) + (x - y) * (x - y);
		val = Math.sqrt(val);
		double other = x * x + a * a;
		other = Math.sqrt(other);
		return val + other;

	}

	public static class Point implements Comparable<Point> {

		int x, y;

		public Point(int start, int end) {
			this.x = start;
			this.y = end;
		}

		@Override
		public int hashCode() {
			int hash = 5;
			hash = 47 * hash + this.x;
			hash = 47 * hash + this.y;
			return hash;
		}

		@Override
		public boolean equals(Object obj) {
			if (obj == null) {
				return false;
			}
			if (getClass() != obj.getClass()) {
				return false;
			}
			final Point other = (Point) obj;
			if (this.x != other.x) {
				return false;
			}
			if (this.y != other.y) {
				return false;
			}
			return true;
		}

		@Override
		public String toString() {
			return "Point [x=" + x + ", y=" + y + "]";
		}

		@Override
		public int compareTo(Point o) {
			return Integer.compare(y, o.y);
		}
	}

	public static class FT {

		long[] data;

		FT(int n) {
			data = new long[n];
		}

		public void update(int index, long value) {
			while (index < data.length) {
				data[index] += value;
				index += (index & (-index));
			}
		}

		public long get(int index) {
			long result = 0;
			while (index > 0) {
				result += data[index];
				index -= (index & (-index));
			}
			return result;

		}
	}

	public static long gcd(long a, long b) {
		if (b == 0) {
			return a;
		}
		return gcd(b, a % b);
	}

	public static long pow(long a, long b) {
		if (b == 0) {
			return 1;
		}
		if (b == 1) {
			return a;
		}
		long val = pow(a, b / 2);
		if (b % 2 == 0) {
			return val * val % MOD;
		} else {
			return val * (val * a % MOD) % MOD;

		}
	}

	static class Scanner {

		BufferedReader br;
		StringTokenizer st;

		public Scanner() throws FileNotFoundException {
			// System.setOut(new PrintStream(new
			// BufferedOutputStream(System.out), true));
			br = new BufferedReader(new InputStreamReader(System.in));
			// br = new BufferedReader(new InputStreamReader(new
			// FileInputStream(new File("input.txt"))));
		}

		public String next() {

			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (Exception e) {
					throw new RuntimeException();
				}
			}
			return st.nextToken();
		}

		public long nextLong() {
			return Long.parseLong(next());
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}

		public double nextDouble() {
			return Double.parseDouble(next());
		}

		public String nextLine() {
			st = null;
			try {
				return br.readLine();
			} catch (Exception e) {
				throw new RuntimeException();
			}
		}

		public boolean endLine() {
			try {
				String next = br.readLine();
				while (next != null && next.trim().isEmpty()) {
					next = br.readLine();
				}
				if (next == null) {
					return true;
				}
				st = new StringTokenizer(next);
				return st.hasMoreTokens();
			} catch (Exception e) {
				throw new RuntimeException();
			}
		}
	}
}
