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".
#!/usr/bin/env python
# coding: utf-8

if __name__ == '__main__':
    import sys
    f = sys.stdin
    #f = open('/home/ilya/opt/programming/tasks/724D.txt')
    
    if False:
        import StringIO
        f = StringIO.StringIO("""3
bcabcbaccba""")
        
    if False:
        import StringIO
        f = StringIO.StringIO("""2
abcab""")
        
    if False:
        import StringIO
        f = StringIO.StringIO("""5
wjjdqawypvtgrncmqvcsergermprauyevcegjtcrrblkwiugrcjfpjyxngyryxntauxlouvwgjzpsuxyxvhavgezwtuzknetdibv""")
        
    if False:
        import StringIO
        f = StringIO.StringIO("""5
addcdbddddbddddcc""")

    if False:
        import StringIO
        f = StringIO.StringIO("""1
addcdbddddbddddcc""")

    def read_int_line():
        return map(int, next(f).split())
    
    def getline():
        return next(f).rstrip('\n\r')

    m = read_int_line()[0]
    line = getline()
    line = memoryview(line)
    
    # частоты букв
    freq_lst = []
    def append_freq(cur_char, cnt):
        freq_lst.append((cur_char, cnt))
    
    cur_char = None
    cnt = 0
    for c in sorted(line):
        if c != cur_char:
            if cur_char:
                append_freq(cur_char, cnt)
            cnt = 1
            cur_char = c
        else:
            cnt += 1
    if cnt:
        append_freq(cur_char, cnt)
        
    import bisect
    def get_bound(indexes, idx, lo):
        return bisect.bisect_left(indexes, idx, lo)
        
    def print_subrange(c, cnt):
        sys.stdout.write("".join(c for i in xrange(cnt)))
        
    res_lst = []
    src_lst = [line]
    for char, freq in freq_lst:
        new_src_lst = []
        
        min_cnt = 0
        min_ok = True
        for s in src_lst:
            indexes = []
            s_ok = True
            
            cnt = 0
            last, last2 = -1, -1
            for i, c in enumerate(s):
                if c == char:
                    indexes.append(i)
                    last2 = i
                    
                if s_ok:
                    if i - last == m:
                        if last2 > last:
                            cnt += 1
                            last = last2
                        else:
                            s_ok = False
            
            min_ok = min_ok and s_ok
            if min_ok:
                min_cnt += cnt
            
            def check_range(previous, idx):
                if (idx - 1) - previous >= m:
                    # :TODO: memoryview
                    subline = s[previous+1:idx]
                    new_src_lst.append(subline)
            
            previous = -1
            for idx in indexes:
                check_range(previous, idx)
                previous = idx
                
            check_range(previous, len(s))
                
        if min_ok:
            print_subrange(char, min_cnt)
            break
        else:
            print_subrange(char, freq)
            src_lst = new_src_lst

    print

    