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.util.*;
public final class intel_final_c
{
    static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	static FastScanner sc=new FastScanner(br);
    static PrintWriter out=new PrintWriter(System.out);
	static ArrayList<Integer>[] al;
	static char[] a;
	static int n,m;
	static Node[] tree;
	
	static void build(int node,int s,int e)
	{
		if(s>e)
		{
			return;
		}
		if(s==e)
		{
			tree[node]=new Node(s,a[s]);
		}
		else
		{
			int mid=(s+e)>>1;
			build(node<<1,s,mid);build(node<<1|1,mid+1,e);
			if(tree[node<<1].val<tree[node<<1|1].val)
			{
				tree[node]=new Node(tree[node<<1].idx,tree[node<<1].val);
			}
			else
			{
				tree[node]=new Node(tree[node<<1|1].idx,tree[node<<1|1].val);
			}
		}
	}
	
	static Node getMin(int node,int s,int e,int l,int r)
	{
		if(s>e || l>e || r<s)	
		{
			return new Node(-1,(char)123);
		}
		if(l<=s && r>=e)
		{
			return tree[node];
		}
		else
		{
			int mid=(s+e)>>1;
			Node q1=getMin(node<<1,s,mid,l,r),q2=getMin(node<<1|1,mid+1,e,l,r);
			if(q1.val<q2.val)
			{
				return q1;
			}
			return q2;
		}
	}
	
	@SuppressWarnings("unchecked")
	public static void main(String args[]) throws Exception
	{
		m=sc.nextInt();a=sc.next().toCharArray();n=a.length;tree=new Node[4*n];build(1,0,n-1);int last=-1;List<Node> list=new ArrayList<Node>();char max_letter='A';boolean[] v=new boolean[n];
		for(int i=0;i+m-1<n;i++)
		{
			if(last>=i)
			{
				continue;
			}
			Node min=getMin(1,0,n-1,i,i+m-1);list.add(min);last=Math.max(last,min.idx);v[min.idx]=true;
			if(min.val>max_letter)
			{
				max_letter=min.val;
			}
		}
		for(int i=0;i<a.length;i++)
		{
			if(!v[i] && a[i]<max_letter)
			{
				list.add(new Node(i,a[i]));
			}
		}
		Collections.sort(list);
		for(Node x:list)
		{
			out.print(x.val);
		}
		out.println("");out.close();
	}
}
class Node implements Comparable<Node>
{
	int idx;char val;
	public Node(int idx,char val)
	{
		this.idx=idx;this.val=val;
	}
	public int compareTo(Node x)
	{
		return Character.compare(this.val,x.val);
	}
}
class FastScanner
{
    BufferedReader in;
    StringTokenizer st;

    public FastScanner(BufferedReader in) {
        this.in = in;
    }
	
    public String nextToken() throws Exception {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }
	
	public String next() throws Exception {
		return nextToken().toString();
	}
	
    public int nextInt() throws Exception {
        return Integer.parseInt(nextToken());
    }

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

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