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.io.*;
public class DenseSubsequence  {
    
    
    
    /************************ SOLUTION STARTS HERE ************************/
    

    static class SegmentTree  { 
        int tree[];
        int len;
        int size;
        char arr[];
        SegmentTree(char arr[]) { 
            len = arr.length;
            size = 1 << (32 - Integer.numberOfLeadingZeros(len - 1) + 1);  // ceil(log(len)) + 1
            tree = new int[size];
            this.arr = arr;
            build(1, 0, len - 1);
        }

        int query(int L , int R){
            return query(1, L, R, 0, len - 1);
        }
        int query(int node , int L , int R, int nl, int nr) {
            int mid = (nl + nr) / 2;
            if(nl == L && nr == R)
                return tree[node];
            else if(R <= mid)
                return query(2 * node, L, R, nl, mid);
            else if(L > mid)
                return query((2*node)+1, L, R, mid + 1 , nr);
            else {
                int lMinIndex = query(2*node, L, mid , nl , mid);
                int rMinIndex = query((2*node)+1, mid+1, R , mid+1,nr);
                return arr[lMinIndex] < arr[rMinIndex] ? lMinIndex : rMinIndex;
            }
        }
        void build(int node,int L,int R) {
            if(L == R)
                tree[node] = L;
            else {
                int mid = L + ((R-L)/2);
                build(2 * node, L, mid);
                build((2 * node) + 1, mid + 1, R);
                tree[node] = arr[tree[2*node]] < arr[tree[2*node + 1]] ? tree[2*node] : tree[2*node + 1];
            }
        }
    }

    
    private static void solve() {
        
        
        int m = nextInt();
        char str[] = nextLine().toCharArray();
        int n = str.length;
        SegmentTree RMQ = new SegmentTree(str);
        
        if(m >= n) {
            println(str[RMQ.query(0, n - 1)]);
            return;
        }
        
        ArrayList<Character> ans = new ArrayList<>();
        char maxChar = 0;
        for(int i = 0; i <= n - m; i++)
            maxChar = (char) Math.max(maxChar , str[RMQ.query(i, i + m - 1)]);
        
        for(char ch : str)
            if(ch < maxChar)
                ans.add(ch);
        
        for(int i = 0; i <= n - m;) {
            int minIndex = RMQ.query(i, i + m - 1);
            if(str[minIndex] == maxChar) {
                ans.add(str[minIndex]);
                i = minIndex + 1;
            }
            else
                i++;
        }
        
        Collections.sort(ans);
        ans.stream().forEach(writer::print);
    }
    
    
    
    /************************ SOLUTION ENDS HERE ************************/
    
    
    
    
    
    /************************ TEMPLATE STARTS HERE **********************/
    
    public static void main(String[] args) throws IOException {
        reader = new BufferedReader(new InputStreamReader(System.in));
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)), false);
        st     = null;
        solve();
        reader.close();
        writer.close();
    }
    
    static BufferedReader reader;
    static PrintWriter    writer;
    static StringTokenizer st;
    
    static String next()
    {while(st == null || !st.hasMoreTokens()){try{String line = reader.readLine();if(line == null){return null;}            
    st = new StringTokenizer(line);}catch (Exception e){throw new RuntimeException();}}return st.nextToken();}
    static String nextLine()  {String s=null;try{s=reader.readLine();}catch(IOException e){e.printStackTrace();}return s;}             
    static int    nextInt()   {return Integer.parseInt(next());}
    static long   nextLong()  {return Long.parseLong(next());}     
    static double nextDouble(){return Double.parseDouble(next());}
    static char   nextChar()  {return next().charAt(0);}
    static int[]  nextIntArray(int n)         {int[] a= new int[n];   int i=0;while(i<n){a[i++]=nextInt();}  return a;}
    static long[] nextLongArray(int n)        {long[]a= new long[n];  int i=0;while(i<n){a[i++]=nextLong();} return a;}    
    static int[]  nextIntArrayOneBased(int n) {int[] a= new int[n+1]; int i=1;while(i<=n){a[i++]=nextInt();} return a;}            
    static long[] nextLongArrayOneBased(int n){long[]a= new long[n+1];int i=1;while(i<=n){a[i++]=nextLong();}return a;}            
    static void   print(Object o)  { writer.print(o);  }
    static void   println(Object o){ writer.println(o);}
    
    /************************ TEMPLATE ENDS HERE ************************/
    
}