Tomorrow Ann takes the hardest exam of programming where she should get an excellent mark. 

On the last theoretical class the teacher introduced the notion of a half-palindrome. 

String *t* is a half-palindrome, if for all the odd positions *i* (<img align="middle" class="tex-formula" src="https://espresso.codeforces.com/1495d729d87ff2c28e9afcddb312ddfe867511e1.png" style="max-width: 100.0%;max-height: 100.0%;"/>) the following condition is held: *t*<sub class="lower-index">*i*</sub> = *t*<sub class="lower-index">|*t*| - *i* + 1</sub>, where |*t*| is the length of string *t* if positions are indexed from 1. For example, strings "abaa", "a", "bb", "abbbaa" are half-palindromes and strings "ab", "bba" and "aaabaa" are not.

Ann knows that on the exam she will get string *s*, consisting only of letters a and b, and number *k*. To get an excellent mark she has to find the *k*-th in the lexicographical order string among all substrings of *s* that are half-palyndromes. Note that each substring in this order is considered as many times as many times it occurs in *s*.

The teachers guarantees that the given number *k* doesn't exceed the number of substrings of the given string that are half-palindromes.

Can you cope with this problem?
The first line of the input contains string *s* (1 ≤ |*s*| ≤ 5000), consisting only of characters 'a' and 'b', where |*s*| is the length of string *s*.

The second line contains a positive integer *k* —  the lexicographical number of the requested string among all the half-palindrome substrings of the given string *s*. The strings are numbered starting from one. 

It is guaranteed that number *k* doesn't exceed the number of substrings of the given string that are half-palindromes.
import sys, os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

def add(v):
    G0.append(-1)
    G1.append(-1)
    p.append(v)
    cnt.append(0)
    return

s = list(input().rstrip())
s = [i - 97 for i in s]
k = int(input())
n = len(s)
x = [[] for _ in range(n)]
for i in range(n):
    for j in range(i, min(i + 2, n)):
        l, r = i, j
        ok = [1] * 2
        while 0 <= l and r < n and max(ok):
            ok[(i - l) % 2] &= (s[l] ^ s[r] ^ 1)
            if ok[(i - l) % 2]:
                x[l].append(r)
            l -= 1
            r += 1
G0, G1, p, cnt = [-1], [-1], [-1], [0]
u = [0] * n
for i in range(n):
    y = x[i]
    for j in y:
        u[j] = 1
    v = 0
    for j in range(i, max(y) + 1):
        if not s[j]:
            if G0[v] == -1:
                G0[v] = len(G0)
                add(v)
            v = G0[v]
        else:
            if G1[v] == -1:
                G1[v] = len(G1)
                add(v)
            v = G1[v]
        if u[j]:
            cnt[v] += 1
    for j in y:
        u[j] = 0
m = len(G0)
visit = [0] * m
v = 0
ans = []
while k > 0:
    visit[v] = 1
    if G0[v] ^ -1 and not visit[G0[v]]:
        ans.append("a")
        v = G0[v]
        k -= cnt[v]
    elif G1[v] ^ -1 and not visit[G1[v]]:
        ans.append("b")
        v = G1[v]
        k -= cnt[v]
    else:
        ans.pop()
        v = p[v]
sys.stdout.write("".join(ans))