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 class Template implements Runnable {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    void init() throws FileNotFoundException {
        try {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        } catch (Exception e) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            try {
                tok = new StringTokenizer(in.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    int[] readIntArray(int size) throws IOException {
        int[] res = new int[size];
        for (int i = 0; i < size; i++) {
            res[i] = readInt();
        }
        return res;
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    <T> List<T>[] createGraphList(int size) {
        List<T>[] list = new List[size];
        for (int i = 0; i < size; i++) {
            list[i] = new ArrayList<>();
        }
        return list;
    }

    public static void main(String[] args) {
        new Thread(null, new Template(), "", 1l * 200 * 1024 * 1024).start();
    }

    long timeBegin, timeEnd;

    void time() {
        timeEnd = System.currentTimeMillis();
        System.err.println("Time = " + (timeEnd - timeBegin));
    }

    long memoryTotal, memoryFree;

    void memory() {
        memoryFree = Runtime.getRuntime().freeMemory();
        System.err.println("Memory = " + ((memoryTotal - memoryFree) >> 10)
                + " KB");
    }

    public void run() {
        try {
            timeBegin = System.currentTimeMillis();
            memoryTotal = Runtime.getRuntime().freeMemory();
            init();
            solve();
            out.close();
            if (System.getProperty("ONLINE_JUDGE") == null) {
                time();
                memory();
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }
    }

    TreeSet<Integer>[] letterIndexes = new TreeSet[26];
    int n;
    int m;
    char[] a;

    String getAnswer(char last) {
        ArrayDeque<Integer> goodIndexes = new ArrayDeque<>();
        List<Character> answer = new ArrayList<>();
        goodIndexes.add(-1);
        for (int i = 0; i < a.length; i++) {
            if (a[i] < last) {
                goodIndexes.add(i);
                answer.add(a[i]);
            }
        }
        goodIndexes.add(a.length);

        int charIndex = last - 'a';

        int lastUsed = goodIndexes.poll();
        while (goodIndexes.size() >= 1) {
            if (goodIndexes.peek() - lastUsed <= m) {
                lastUsed = goodIndexes.poll();
            } else {
                Integer z = letterIndexes[charIndex].lower(lastUsed + m + 1);
                if (z == null || z <= lastUsed) return null;
                lastUsed = z;
                answer.add(last);
            }
        }
        Collections.sort(answer);
        StringBuilder sb = new StringBuilder();
        for (char x : answer) sb.append(x);
        return sb.toString();
    }

    void solve() throws IOException {
        m = readInt();
        a = readString().toCharArray();
        n = a.length;
        letterIndexes = new TreeSet[26];
        for (int i = 0; i < 26; i++) {
            letterIndexes[i] = new TreeSet<>();
        }
        for (int i = 0; i < n; i++) {
            letterIndexes[a[i] - 'a'].add(i);
        }

        for (char willLast = 'a'; willLast <= 'z'; willLast++) {
            String ans = getAnswer(willLast);
            if (ans != null) {
                out.println(ans);
                return;
            }
        }
    }


}