output_description: Print the K-th lexicographically smallest substring of K.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      s
      K
attempt: import sys
  from sys import exit
  from collections import deque
  from copy import deepcopy
  from bisect import bisect_left, bisect_right, insort_left, insort_right
  from heapq import heapify, heappop, heappush
  from itertools import product, permutations, combinations, combinations_with_replacement
  from functools import reduce
  from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians
  
  sys.setrecursionlimit(10**6)
  INF = 10**20
  eps = 1.0e-20
  MOD = 10**9 + 7
  
  
  def lcm(x, y):
      return x * y // gcd(x, y)
  
  
  def lgcd(l):
      return reduce(gcd, l)
  
  
  def llcm(l):
      return reduce(lcm, l)
  
  
  def powmod(n, i, mod=MOD):
      return pow(n, mod - 1 + i, mod) if i < 0 else pow(n, i, mod)
  
  
  def div2(x):
      return x.bit_length()
  
  
  def div10(x):
      return len(str(x)) - (x == 0)
  
  
  def intput():
      return int(input())
  
  
  def mint():
      return map(int, input().split())
  
  
  def lint():
      return list(map(int, input().split()))
  
  
  def ilint():
      return int(input()), list(map(int, input().split()))
  
  
  def judge(x, l=["Yes", "No"]):
      print(l[0] if x else l[1])
  
  
  def lprint(l, sep="\n"):
      for x in l:
          print(x, end=sep)
  
  
  def ston(c, c0="a"):
      return ord(c) - ord(c0)
  
  
  def ntos(x, c0="a"):
      return chr(x + ord(c0))
  
  
  class counter(dict):
      def __init__(self, *args):
          super().__init__(args)
  
      def add(self, x, d=1):
          self.setdefault(x, 0)
          self[x] += d
  
      def list(self):
          l = []
          for k in self:
              l.extend([k] * self[k])
          return l
  
  
  class comb:
      def __init__(self, n, mod=None):
          self.l = [1]
          self.n = n
          self.mod = mod
  
      def get(self, k):
          l, n, mod = self.l, self.n, self.mod
          k = n - k if k > n // 2 else k
          while len(l) <= k:
              i = len(l)
              l.append(
                  l[i - 1] * (n + 1 - i) // i
                  if mod == None
                  else (l[i - 1] * (n + 1 - i) * powmod(i, -1, mod)) % mod
              )
          return l[k]
  
  
  def pf(x, mode="counter"):
      C = counter()
      p = 2
      while x > 1:
          k = 0
          while x % p == 0:
              x //= p
              k += 1
          if k > 0:
              C.add(p, k)
          p = p + 2 - (p == 2) if p * p < x else x
      if mode == "counter":
          return C
      S = set([1])
      for k in C:
          T = deepcopy(S)
          for x in T:
              for i in range(1, C[k] + 1):
                  S.add(x * (k**i))
      if mode == "set":
          return S
      if mode == "list":
          return sorted(list(S))
  
  
  ######################################################
  
  S = input()
  N = len(S)
  K = intput()
  L = [list()] * 26
  ans = []
  for i in range(N):
      L[ston(S[i])].append(i)
  for l in L:
      for i in l:
          for j in range(i + 1, min(i + K + 1, N + 1)):
              s = S[i:j]
              if bisect_left(ans, s) == bisect_right(ans, s):
                  insort_left(ans, s)
      if len(ans) >= K:
          print(ans[K - 1])
          exit()
  
problem_description: Statement
  
  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}.
samples: [{"input": "aba\n    4", "output": "b\n    \n\ns has five substrings: `a`, `b`, `ab`, `ba` and `aba`. Among them, we should\nprint the fourth smallest one, `b`. Note that we do not count `a` twice.\n\n* * *"}, {"input": "atcoderandatcodeer\n    5", "output": "andat\n    \n\n* * *"}, {"input": "z\n    1", "output": "z"}]