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 Solution implements Runnable{
        FastScanner sc;
        PrintWriter pw;
        final class FastScanner {
            BufferedReader br;
            StringTokenizer st;
     
            public FastScanner() {
                try {
                    br = new BufferedReader(new InputStreamReader(System.in));
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
     
            public long nlo() {
                return Long.parseLong(next());
            }
     
            public String next() {
                if (st.hasMoreTokens()) return st.nextToken();
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return st.nextToken();
            }
     
            public int ni() {
                return Integer.parseInt(next());
            }
     
            public String nli() {
                String line = "";
                if (st.hasMoreTokens()) line = st.nextToken();
                else try {
                    return br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                while (st.hasMoreTokens()) line += " " + st.nextToken();
                return line;
            }
     
            public double nd() {
                return Double.parseDouble(next());
            }
        }
        public static void main(String[] args)
        {
            new Thread(null,new Solution(),"codeforces",1<<25).start();
        }
        public void run()
        {
            sc=new FastScanner();
            pw=new PrintWriter(System.out);
           solve();
            pw.flush();
            pw.close();
        }
        public long gcd(long a,long b)
        {
            return b==0L?a:gcd(b,a%b);
        }
        public long ppow(long a,long b,long mod)
        {
            if(b==0L)
            return 1L;
            long tmp=1;
            while(b>1L)
            {
                if((b&1L)==1)
                tmp*=a;
                a*=a;
                a%=mod;
                tmp%=mod;
                b>>=1;
            }
            return (tmp*a)%mod;
        }
        public  int gcd(int x,int y)
        {
            return y==0?x:gcd(y,x%y);
        }
        //////////////////////////////////
        /////////////  LOGIC  ///////////
        ////////////////////////////////
       public void solve(){
           int k=sc.ni();
           char[] arr=sc.next().toCharArray();
           int n=arr.length;
           char[] brr=arr.clone();
           Arrays.sort(brr);
           int l=0,r=n-1,ans=n-1;
           while(l<=r)
           {
               int m=(l+r)/2;
               if(g(m,arr,brr,k))
               {
                   ans=m;
                   r=m-1;
               }
               else
               l=m+1;
           }
           for(int i=0;i<=ans;i++)
           pw.print(brr[i]);
        }
        public boolean g(int x,char[] arr,char[] brr,int m)
        {
            char ch=brr[x];
            int tmp=0;
            for(int i=0;i<=x;i++)
            if(brr[i]==ch)
                tmp++;
            int sz=0;
            int pos=-1;
            for(int i=0;i<arr.length;i++)
            {
              if(arr[i]==ch)
              pos=i;
              if(arr[i]>=ch)
              sz++;
              else
              {sz=0;pos=-1;}
              if(sz>=m)
              {
                  tmp--;
                  if(pos==-1)
                  return false;
                  sz=m-(pos-(i-m));
                  pos=-1;
              }
            }
            if(tmp>=0)
            return true;
            return false;
        }
    }