You are given a string s. Among the different substrings of s, print the K-th lexicographically smallest one.

A substring of s is a string obtained by taking out a non-empty contiguous part in s. For example, if s = `ababc`, `a`, `bab` and `ababc` are substrings of s, while `ac`, `z` and an empty string are not. Also, we say that substrings are different when they are different as strings.

Let X = x_{1}x_{2}...x_{n} and Y = y_{1}y_{2}...y_{m} be two distinct strings. X is lexicographically larger than Y if and only if Y is a prefix of X or x_{j} > y_{j} where j is the smallest integer such that x_{j} \neq y_{j}.

Constraints

* 1 ≤ |s| ≤ 5000
* s consists of lowercase English letters.
* 1 ≤ K ≤ 5
* s has at least K different substrings.

Input

Input is given from Standard Input in the following format:


s
K


Output

Print the K-th lexicographically smallest substring of K.

Examples

Input

aba
4


Output

b


Input

atcoderandatcodeer
5


Output

andat


Input

z
1


Output

z
import java.io.*;
import java.util.*;

public class Main{
	public static InputReader scn = new InputReader();
	public static PrintWriter out = new PrintWriter(System.out);

	public static class pair implements Comparable<pair>{
		String str;
		int ind;
		
		pair(String s, int i){
			str = s;
			ind = i;
		}
		
		@Override
		public int compareTo(pair o) {
			return this.str.compareTo(o.str);
		}
		
		@Override
		public boolean equals(Object o) {
			pair p = (pair)o;
			return this.str.equals(p.str);
		}
	}
	
	public static void main(String[] args) throws Exception {
		//System.out.println("GO");

		String str = scn.next();
		int k = scn.nextInt(), n = str.length();
		TreeSet<String> set = new TreeSet<>();

		ArrayList<Integer>[] list = new ArrayList[26];
		Arrays.setAll(list, i -> new ArrayList<>());
		for (int i = 0; i < n; i++) {
			list[str.charAt(i) - 'a'].add(i);
		}
		
		while (true) {
			for (int i = 0; i < 26; i++) {
				if (list[i].size() == 0) {
					continue;
				}

				PriorityQueue<pair> pq = new PriorityQueue<>();
				for (int x : list[i]) {
					pair rv = new pair(str.charAt(x) + "", x);
					pq.add(rv);
				}

				while (set.size() < k && !pq.isEmpty()) {
					pair rv = pq.poll();
					set.add(rv.str);
					rv.ind++;
					if (rv.ind < n) {
						rv.str = rv.str + str.charAt(rv.ind);
						pq.add(rv);
					}
				}
				
				if (set.size() >= k) {
					break;
				}
			}
			
			if (set.size() >= k) {
				break;
			}
		}

		while (set.size() != k) {
			set.pollLast();
		}
		out.println(set.last());

		out.flush();
	}

	public static class InputReader {
		InputStream is;

		public InputReader() {
			is = System.in;
		}

		byte[] inbuf = new byte[1024];
		public int lenbuf = 0, ptrbuf = 0;

		int readByte() {
			if (lenbuf == -1)
				throw new InputMismatchException();
			if (ptrbuf >= lenbuf) {
				ptrbuf = 0;
				try {
					lenbuf = is.read(inbuf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (lenbuf <= 0)
					return -1;
			}
			return inbuf[ptrbuf++];
		}

		boolean isSpaceChar(int c) {
			return !(c >= 33 && c <= 126);
		}

		int skip() {
			int b;
			while ((b = readByte()) != -1 && isSpaceChar(b))
				;
			return b;
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}

		char nextChar() {
			return (char) skip();
		}

		String next() {
			int b = skip();
			StringBuilder sb = new StringBuilder();
			while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != ' ')
				sb.appendCodePoint(b);
				b = readByte();
			}
			return sb.toString();
		}

		char[] next(int n) {
			char[] buf = new char[n];
			int b = skip(), p = 0;
			while (p < n && !(isSpaceChar(b))) {
				buf[p++] = (char) b;
				b = readByte();
			}
			return n == p ? buf : Arrays.copyOf(buf, p);
		}

		char[][] nextMatrix(int n, int m) {
			char[][] map = new char[n][];
			for (int i = 0; i < n; i++)
				map[i] = next(m);
			return map;
		}

		int[] nextArray(int n) {
			int[] a = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = nextInt();
			return a;
		}

		int nextInt() {
			int num = 0, b;
			boolean minus = false;
			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
				;
			if (b == '-') {
				minus = true;
				b = readByte();
			}

			while (true) {
				if (b >= '0' && b <= '9') {
					num = num * 10 + (b - '0');
				} else {
					return minus ? -num : num;
				}
				b = readByte();
			}
		}

		long nextLong() {
			long num = 0;
			int b;
			boolean minus = false;
			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
				;
			if (b == '-') {
				minus = true;
				b = readByte();
			}

			while (true) {
				if (b >= '0' && b <= '9') {
					num = num * 10 + (b - '0');
				} else {
					return minus ? -num : num;
				}
				b = readByte();
			}
		}
	}
}
