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.lang.*;
import java.io.*;
public class Main
{

@SuppressWarnings("unchecked") 
public static void main (String[] args) throws java.lang.Exception
{
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
PrintWriter out=new PrintWriter(System.out);


int n,m,i,j,val,max_char,max_char_cnt,position_to_place,position_to_remove,pre_end,val_to_remove,offset,selected_char,selected_pos,prev_selected_pos;
String str;



m=Integer.parseInt(in.readLine());
str=in.readLine().trim();
n=str.length();

int[] cnt=new int[26];
int[] max_position_of_char=new int[26];
int[] min_pos=new int[n];

//PriorityQueue<Integer> values_in_current_block_of_size_m=new PriorityQueue<Integer>();
Arrays.fill(max_position_of_char,-1);


offset=10000000;

for(i=0;i<n;i++)
{
    cnt[str.charAt(i)-'a']++;

    if(i<m)
    {
        position_to_place=0;

        val=(int)str.charAt(i)*offset;
        val+=(n-i);

        /*
        if(values_in_current_block_of_size_m.size()>0)
        {
            position_to_place=Collections.binarySearch(values_in_current_block_of_size_m,val);

            if(position_to_place<0)
                position_to_place=(-1*position_to_place)-1;
        }

        values_in_current_block_of_size_m.add(position_to_place,val);
        */

        //values_in_current_block_of_size_m.add(new Integer(val));
        max_position_of_char[str.charAt(i)-'a']=i;

    }
    else
    {
        //val=(str.charAt(i-m)*offset)+(n-(i-m));
        //values_in_current_block_of_size_m.remove(val);

        for(j=0;j<26;j++)
        {
            if(max_position_of_char[j]<=(i-m) && max_position_of_char[j]>-1)
            {
                max_position_of_char[j]=-1;
            }
        }

        max_position_of_char[str.charAt(i)-'a']=i;

        //val=(str.charAt(i)*offset)+(n-i);
        //values_in_current_block_of_size_m.add(val);


    }


    if(i>=m-1)
    {
        for(j=0;j<26;j++)
        {
            if(max_position_of_char[j]>-1)
                break;
        }
        min_pos[i-(m-1)]=max_position_of_char[j];
    }
}






prev_selected_pos=-1;
pre_end=m-1;
//int loop=0;

selected_char=str.charAt(min_pos[0]);
selected_pos=min_pos[0];

max_char=selected_char;
max_char_cnt=1;



while(selected_pos+m<n)
{
selected_char=str.charAt(min_pos[selected_pos+1]);
selected_pos=min_pos[selected_pos+1];

if(selected_char>max_char)
    {
        max_char=selected_char;
        max_char_cnt=1;
    }
else if(selected_char==max_char)
    {
        max_char_cnt++;
    }

}




for(i='a';i<max_char;i++)
{
    for(j=0;j<cnt[i-'a'];j++)
        out.print((char)i);
}


for(j=0;j<max_char_cnt;j++)
    out.print((char)max_char);




out.flush();
out.close();
}
}