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: ALPHABETS = 26
  
  ORD_A = ord("a")
  
  # fast io
  import sys
  
  S, K = sys.stdin.readlines()[:2]
  
  S = [ord(c) - ORD_A for c in S]
  while S[-1] < 0:
      S.pop()
  
  
  N = len(S)
  K = int(K)
  
  dp = [None] * (N + 1)
  dp[N] = 0
  indices = [N] * ALPHABETS
  s = 1
  
  import sys
  
  old = 1
  
  for i, c in enumerate(reversed(S)):
      dp[i] = s
      if s > K:
          break
      s = 2 * s
      s -= dp[indices[c]]
      indices[c] = i
  
  
  dp.pop()
  dp.reverse()
  dp.append(0)
  
  indices = [[] for _ in range(ALPHABETS)]
  for i, c in enumerate(S):
      indices[c].append(i)
  for l in indices:
      l.append(N)
  
  del S
  
  from bisect import bisect_left
  
  
  def find(k):
  
      s = []
      i = 0
      while k > 0:
          f = False
          for c, L in enumerate(indices):
              j = L[bisect_left(L, i)]
              t = dp[j]
              if t is None or t >= k:
                  s.append(c)
                  k -= 1
                  i = j + 1
                  f = True
                  break
              else:
                  k -= t
          if not f:
              break
      if not s:
          return "Eel"
      return "".join(chr(c + ORD_A) for c in s)
  
  
  print(find(K))
  
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"}]