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>
#pragma comment(linker, "/stack:200000000")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename T>
constexpr int infValue =
    std::is_same<T, int>::value ? 2000100007 : 8600000000000000007ll;
template <typename T>
constexpr int maxValue =
    std::is_same<T, int>::value ? 1000000007 : 1000000000000000001ll;
const int INF = infValue<int>;
const long long MOD = 1000000007ll;
const double EPS = 1e-6;
const int MAX = maxValue<int>;
int n, m, cnt;
char s[100101];
vector<int> p[26];
int dp[2][100101];
bool f(int i) {
  bool ok = true;
  int l = -1;
  for (register int j = 0; j < n; ++j) {
    if (s[j] <= 'a' + i) l = j;
    ok = ok && (j - l + 1 <= m);
  }
  return ok;
}
int bs() {
  int l = -1, r = 25;
  while (r - l > 1) {
    int md = l + r >> 1;
    if (f(md))
      r = md;
    else
      l = md;
  }
  return r;
}
multiset<int> bv;
int main(void) {
  scanf("%d", &m);
  scanf("%s", s);
  while (s[n]) p[s[n] - 'a'].push_back(n), ++n;
  if (m > 1) {
    f(0);
    int k = bs();
    for (register int j = 0; j < k; ++j) {
      int cnt = p[j].size();
      while (cnt--) putc('a' + j, stdout);
    }
    dp[0][0] = 0;
    if (s[0] < 'a' + k) {
      dp[1][0] = 0;
    } else if (s[0] == 'a' + k) {
      dp[1][0] = 1;
    } else {
      dp[1][0] = INF;
    }
    bv.insert(dp[1][0]);
    for (register int i = 1; i < n; ++i) {
      int j = max(i - m + 1, 0), mm = *bv.begin();
      int mmm = i - m < 0 ? 0 : min(mm, dp[1][i - m]);
      if (s[i] < 'a' + k) {
        dp[0][i] = dp[1][i] = mmm;
      } else if (s[i] == 'a' + k) {
        dp[0][i] = mmm;
        dp[1][i] = mmm + 1;
      } else {
        dp[0][i] = mm;
        dp[1][i] = INF;
      }
      if (i - m + 1 >= 0) bv.erase(bv.lower_bound(dp[1][i - m + 1]));
      bv.insert(dp[1][i]);
    }
    cnt = dp[0][n - 1];
    while (cnt--) putc('a' + k, stdout);
    putc('\n', stdout);
  } else {
    sort(s, s + n);
    puts(s);
  }
  return 0;
}
