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

public class Main {
	public static void main(String[] args) throws FileNotFoundException {
		InputReader in=new InputReader(System.in);
		PrintWriter out=new PrintWriter(System.out);
		//Scanner in=new Scanner(System.in);
		
		int m=in.nextInt();
		String s=in.next();
		char[] a=s.toCharArray();
		int n=a.length;
		boolean[] b=new boolean[n];
		for(int i=0;i<26;i++){
			char ch=(char)(i+'a');
			choose(a,b,n,ch);
			boolean OK=check(b,n,m);
			if(OK==true){
				release(a,b,n,ch);
				fillMin(a,b,n,m,ch);
				break;
			}
		}
		int leng=0;
		int[] count=new int[26];
		for(int i=0;i<n;i++){
			if(b[i]==true){
				leng++;
				int u=a[i]-'a';
				count[u]++;
			}
		}
		char[] ans=new char[leng];
		int top=0;
		for(int i=0;i<26;i++){
			for(int j=0;j<count[i];j++){
				char ch=(char)(i+'a');
				ans[top]=ch;
				top++;
			}
		}
		out.println(String.valueOf(ans));
		
		out.close();
	}
	
	static void choose(char[] a,boolean[] b,int n,char ch){
		for(int i=0;i<n;i++){
			if(a[i]==ch){
				b[i]=true;
			}
		}
	}
	
	static void release(char[] a,boolean[] b,int n,char ch){
		for(int i=0;i<n;i++){
			if(a[i]==ch){
				b[i]=false;
			}
		}
	}
	
	static boolean check(boolean[] b,int n,int m){
		int near=-1;
		for(int i=0;i<n;i++){
			if(b[i]==true){
				near=i;
			}
			else{
				if(i-near>=m){
					return false;
				}
			}
		}
		return true;
	}
	
	static void fillMin(char[] a,boolean[] b,int n,int m,char ch){
		int near=-1;
		for(int i=0;i<n;i++){
			if(b[i]==true){
				if(i-near>m){
					fillRange(a,b,near+1,i-1,m,ch);
				}
				near=i;
			}
		}
		if(n-near>m){
			fillRange(a,b,near+1,n-1,m,ch);
		}
	}
	
	static void fillRange(char[] a,boolean[] b,int left,int right,int m,char ch){
		int near=left-1;
		int i=near;
		//System.out.println(left+" "+right+" "+ch);;
		while(true){
			for(int j=i+m;j>i;j--){
				if(a[j]==ch){
					b[j]=true;
					near=j;
					break;
				}
			}
			if(right-near<m){
				break;
			}
			i=near;
		}
	}
	
	static class InputReader {
		BufferedReader br;
		StringTokenizer st;

		public InputReader (File f){
			try{
				br=new BufferedReader(new FileReader(f));
			}catch(FileNotFoundException e){
				e.printStackTrace();
			}
		}

		public InputReader (InputStream in){
			br=new BufferedReader(new InputStreamReader(in));
		}

		public String next(){
			while(st==null||!st.hasMoreTokens()){
				try{
					st=new StringTokenizer(br.readLine());
				}catch(IOException e){
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}
		
		public boolean hasNext(){
			while(st==null||!st.hasMoreTokens()){
				String s=null;
				try{
					s=br.readLine();
				}catch(IOException e){
					e.printStackTrace();
				}
				if(s==null)
					return false;
				st=new StringTokenizer(s);
			}
			return true;
		}

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

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

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