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


public class C {

    void solve() throws IOException {
        int n=nextInt();
        char[] c = nextToken().toCharArray();
        int[] count = new int[26];
        for(int i=0;i<c.length;i++)count[c[i]-'a']++;
        boolean[] used = new boolean[c.length];
        int[] lastInd = new int[26];
        Arrays.fill(lastInd, -1);
        int prevUsed=-1;
        for(int i=0;i<n;i++){
            lastInd[c[i]-'a']=i;
        }
        for(int i=0;i<26;i++) {
            if (lastInd[i] != -1) {
                prevUsed = lastInd[i];
                used[lastInd[i]] = true;
                break;
            }
        }
        for(int i=n;i<c.length;i++){
            lastInd[c[i]-'a'] =i;
            if(prevUsed<i-n+1) {
               for(int j=0;j<26;j++){
                   if(lastInd[j]>=i-n+1){
                       prevUsed=lastInd[j];
                       used[lastInd[j]]=true;
                       break;
                   }
               }
            }
        }
        char max='\0';
        int maxCount=0;
        for(int i=0;i<c.length;i++)
            if(used[i]){
                if(c[i]>max){
                    max=c[i];
                    maxCount=0;
                }
                if(c[i]==max)maxCount++;
            }
        int maxi=max-'a';
        for(int i=0;i<maxi;i++)
            for(int j=0;j<count[i];j++)
                out.print((char)(i+'a'));
        for(int i=0;i<maxCount;i++)
            out.print(max);
    }

    public static void main(String[] args) throws IOException {
        new C().run();
    }

    void run() throws IOException {
        reader = new BufferedReader(new InputStreamReader(System.in));
//		reader = new BufferedReader(new FileReader("input.txt"));
        tokenizer = null;
        out = new PrintWriter(new OutputStreamWriter(System.out));
//		out = new PrintWriter(new FileWriter("output.txt"));
        solve();
        reader.close();
        out.flush();

    }

    BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter out;

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    String nextToken() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }
}
