output_description: Print the next word that appears after S in the dictionary, or `-1` if it
  doesn't exist.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      S
attempt: def examA():
      S = SI()
      N = len(S)
      if N < 26:
          d = defaultdict(bool)
          for s in S:
              d[s] = True
          for a in alphabet:
              if not d[a]:
                  ans = S + a
                  print(ans)
                  return
      keep = []
      for i in range(N - 1)[::-1]:
          keep.append(S[i + 1])
          if S[i] < S[i + 1]:
              break
      # print(keep)
      n = len(keep)
      if n == 25:
          print(-1)
          return
      c = "zz"
      for s in keep:
          if s > S[(N - n - 1)]:
              c = min(c, s)
      ans = S[: (N - n - 1)] + c
      print(ans)
      return
  
  
  def examB():
      N = I()
      ans = [2 * (i + 1) for i in range(N)]
      if N % 2 == 0:
          for i in range(4998):
              ans[-3 - i] = 3 + i * 6
  
      print(" ".join(map(str, ans)))
      return
  
  
  def examC():
      ans = 0
      print(ans)
      return
  
  
  def examD():
      ans = 0
      print(ans)
      return
  
  
  def examE():
      ans = 0
      print(ans)
      return
  
  
  def examF():
      ans = 0
      print(ans)
      return
  
  
  import sys, copy, bisect, itertools, heapq, math
  from heapq import heappop, heappush, heapify
  from collections import Counter, defaultdict, deque
  
  
  def I():
      return int(sys.stdin.readline())
  
  
  def LI():
      return list(map(int, sys.stdin.readline().split()))
  
  
  def LFI():
      return list(map(float, sys.stdin.readline().split()))
  
  
  def LSI():
      return list(map(str, sys.stdin.readline().split()))
  
  
  def LS():
      return sys.stdin.readline().split()
  
  
  def SI():
      return sys.stdin.readline().strip()
  
  
  global mod, mod2, inf, alphabet
  mod = 10**9 + 7
  mod2 = 998244353
  inf = 10**18
  alphabet = [chr(ord("a") + i) for i in range(26)]
  
  if __name__ == "__main__":
      examA()
  
  """
  
  """
  
problem_description: Statement
  
  Gotou just received a dictionary. However, he doesn't recognize the language
  used in the dictionary. He did some analysis on the dictionary and realizes
  that the dictionary contains all possible **diverse** words in lexicographical
  order.
  
  A word is called **diverse** if and only if it is a nonempty string of English
  lowercase letters and all letters in the word are distinct. For example,
  `atcoder`, `zscoder` and `agc` are diverse words while `gotou` and `connect`
  aren't diverse words.
  
  Given a diverse word S, determine the next word that appears after S in the
  dictionary, i.e. the lexicographically smallest diverse word that is
  lexicographically larger than S, or determine that it doesn't exist.
  
  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": "atcoder", "output": "atcoderb\n    \n\n`atcoderb` is the lexicographically smallest diverse word that is\nlexicographically larger than `atcoder`. Note that `atcoderb` is\nlexicographically smaller than `b`.\n\n* * *"}, {"input": "abc", "output": "abcd\n    \n\n* * *"}, {"input": "zyxwvutsrqponmlkjihgfedcba", "output": "-1\n    \n\nThis is the lexicographically largest diverse word, so the answer is `-1`.\n\n* * *"}, {"input": "abcdefghijklmnopqrstuvwzyx", "output": "abcdefghijklmnopqrstuvx"}]