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.BufferedInputStream;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.Set;
import java.util.StringTokenizer;

public class Main {
	static InputStream inputstream = System.in;  
	static PrintStream outputstream = System.out;  
	static InputReader in = new InputReader(inputstream);  
	static PrintWriter out = new PrintWriter(outputstream);
	static node idx[]=new node[100001];
	static node num[]=new node [100001];
	static void Init(int n){
	     for(int i=1;i<=n;i++){
	          idx[i]=num[i];
	          for(int j=1;j<Lowbit(i);j<<=1){
	        	  if(idx[i].v>idx[i-j].v){
	        		  idx[i]=idx[i-j];
	        	  }
	             //  idx[i]=Math.min(idx[i],idx[i-j]);
	          }
	     }
	}
	private static int Lowbit(int x) {
		// TODO Auto-generated method stub
		return   x & (-x);  
	}
	static node Query(int l,int r){
	     node  ans=num[r];
	     while(true){
	    	 if(num[r].v<ans.v)ans=num[r];
	          if(r==l) break;
	          for(r-=1;r-l>=Lowbit(r);r-=Lowbit(r)){
	               if(idx[r].v<ans.v)ans=idx[r];
	          }
	     }
	     return ans;
	}
	static int m;
	static int l;
	static Set<Integer>q=new HashSet<Integer>(); 
	static char s[];
	public static void main(String[] args) {
		//Scanner in=new Scanner(new BufferedInputStream(System.in));
		 m=in.nextInt();
	 s=in.next().toCharArray();
	 
		 l=s.length;
	//	 System.out.println(l);
		 for(int i=1;i<=l;i++){
			 num[i]=new node(i,s[i-1]);
		 }
		 Init(l);
		 int maz='a';
for(int bg=1;bg<=l-m+1;bg++){

	node k=Query(Math.max(1, bg),Math.min(l,bg+m-1));
	//System.out.println(bg+" "+k.id+" "+(char)k.v);
	q.add(k.id);
	maz=Math.max(k.v, maz);
	bg=k.id;
	
}
for(int i=1;i<=l;i++){
	if(q.contains(i))continue;
	if(s[i-1]<maz)q.add(i);
}
node[] ans=new node[q.size()];
int cc=0;
for(int p:q)ans[cc++]=num[p];
Arrays.sort(ans);
for(int i=0;i<cc;i++)out.print((char)ans[i].v);
out.println();
out.flush();
	}
	
		
		

	

}
class node implements Comparable<node>{
	int id;
	int v;
	node (int i,int k){
		id=i;
		v=k;
	}
	@Override
	public int compareTo(node o) {
		// TODO Auto-generated method stub
		return this.v-o.v;
	}
}

class InputReader {  //放到你的主程序的下方咯
    BufferedReader reader;  
    StringTokenizer tokenizer;  
  
    InputReader(InputStream stream) {  
        reader = new BufferedReader(new InputStreamReader(stream));  
        tokenizer = null;  
    }  
  
    String next() {  
        if (!hasNext())  
            throw new RuntimeException();  
        return tokenizer.nextToken();  
    }  
  
    boolean hasNext() {  
        while (tokenizer == null || !tokenizer.hasMoreTokens())  
            try {  
                tokenizer = new StringTokenizer(reader.readLine());  
            } catch (Exception e) {  
                return false;  
            }  
        return true;  
    }  
  
    long nextLong() {  
        return Long.parseLong(next());  
    }  
  
    int nextInt() {  
        return Integer.parseInt(next());  
    }  
	public String nextLine() {
		tokenizer = null;
		try {
			return reader.readLine();
		} catch (Exception e) {
			throw new RuntimeException();
		}
	}
}