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".
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 10;
const double EPS = 1e-9;
const long long MOD = 1000 * 1000 * 1000 + 7;
int n, m, k;
vector<long long> ans;
vector<pair<int, int> > p;
vector<char> used;
int get_es(pair<int, int> p) { return p.first + p.second; }
int get_ws(pair<int, int> p) { return p.first - p.second + m; }
void process_ws(vector<vector<int> > &ws, long long time,
                pair<int, int> start_pt) {
  int i = get_ws(start_pt);
  for (int j = 0; j < ws[i].size(); ++j) {
    if (used[ws[i][j]]) continue;
    ans[ws[i][j]] = time + abs(p[ws[i][j]].second - start_pt.second);
    used[ws[i][j]] = 1;
  }
  ws[i].clear();
}
void process_es(vector<vector<int> > &es, long long time,
                pair<int, int> start_pt) {
  int i = get_es(start_pt);
  for (int j = 0; j < es[i].size(); ++j) {
    if (used[es[i][j]]) continue;
    ans[es[i][j]] = time + abs(p[es[i][j]].second - start_pt.second);
    used[es[i][j]] = 1;
  }
  es[i].clear();
}
int main(int argc, char *argv[]) {
  ios::sync_with_stdio(0);
  int m;
  string s;
  cin >> m >> s;
  m;
  int count[26] = {0};
  for (int i = 0; i < s.size(); ++i) count[s[i] - 'a']++;
  vector<char> marked(s.size(), 0);
  for (int i = 0; i < 26; ++i) {
    char cur = ('a' + i);
    int may = -1;
    int last = -1;
    bool ok = true;
    vector<int> poss;
    for (int j = 0; j < s.size(); ++j) {
      if (marked[j]) {
        may = -1;
        last = j;
        continue;
      }
      if (s[j] == cur) {
        if (j - last >= m) {
          marked[j] = 1;
          last = j;
          may = -1;
        } else {
          may = j;
        }
      } else {
        if (j - last >= m) {
          if (may == -1) {
            ok = false;
            break;
          } else {
            marked[may] = 1;
            last = may;
          }
        }
      }
      if (j - last >= m) {
        ok = false;
        break;
      }
    }
    int pos = (int)s.size() - 1;
    if (ok) break;
    for (int j = 0; j < s.size(); ++j) {
      if (s[j] == cur) {
        marked[j] = 1;
      }
    }
  }
  memset(count, 0, sizeof(count));
  for (int i = 0; i < marked.size(); ++i) {
    if (marked[i]) {
      count[s[i] - 'a']++;
    }
  }
  for (int i = 0; i < 26; ++i) {
    for (int j = 0; j < count[i]; ++j) {
      printf("%c", (char)('a' + i));
    }
  }
  return 0;
}
