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: # -*- coding: utf-8 -*-
  import sys
  import math
  import os
  import itertools
  import string
  import heapq
  import _collections
  from collections import Counter
  from collections import defaultdict
  from functools import lru_cache
  import bisect
  import re
  import queue
  
  
  class Scanner:
      @staticmethod
      def int():
          return int(sys.stdin.readline().rstrip())
  
      @staticmethod
      def string():
          return sys.stdin.readline().rstrip()
  
      @staticmethod
      def map_int():
          return [int(x) for x in Scanner.string().split()]
  
      @staticmethod
      def string_list(n):
          return [input() for i in range(n)]
  
      @staticmethod
      def int_list_list(n):
          return [Scanner.map_int() for i in range(n)]
  
      @staticmethod
      def int_cols_list(n):
          return [int(input()) for i in range(n)]
  
  
  class Math:
      @staticmethod
      def gcd(a, b):
          if b == 0:
              return a
          return Math.gcd(b, a % b)
  
      @staticmethod
      def lcm(a, b):
          return (a * b) // Math.gcd(a, b)
  
      @staticmethod
      def roundUp(a, b):
          return -(-a // b)
  
      @staticmethod
      def toUpperMultiple(a, x):
          return Math.roundUp(a, x) * x
  
      @staticmethod
      def toLowerMultiple(a, x):
          return (a // x) * x
  
      @staticmethod
      def nearPow2(n):
          if n <= 0:
              return 0
          if n & (n - 1) == 0:
              return n
          ret = 1
          while n > 0:
              ret <<= 1
              n >>= 1
          return ret
  
      @staticmethod
      def sign(n):
          if n == 0:
              return 0
          if n < 0:
              return -1
          return 1
  
      @staticmethod
      def isPrime(n):
          if n < 2:
              return False
          if n == 2:
              return True
          if n % 2 == 0:
              return False
          d = int(n**0.5) + 1
          for i in range(3, d + 1, 2):
              if n % i == 0:
                  return False
          return True
  
  
  class PriorityQueue:
      def __init__(self, l=[]):
          self.__q = l
          heapq.heapify(self.__q)
          return
  
      def push(self, n):
          heapq.heappush(self.__q, n)
          return
  
      def pop(self):
          return heapq.heappop(self.__q)
  
  
  MOD = int(1e09) + 7
  INF = int(1e15)
  
  
  def calc(N):
      return sum(int(x) for x in str(N))
  
  
  def main():
      # sys.stdin = open("sample.txt")
      S = Scanner.string()
      if len(S) == 26:
          if list(S) == list(reversed(list(string.ascii_lowercase))):
              print(-1)
              return
          i = 0
          for i in reversed(range(25)):
              if S[i] < S[i + 1]:
                  break
          ans = S[:i]
          ans += sorted(S[i + 1 :])[0]
          print(ans)
          return
      else:
          T = Counter(S)
          for c in string.ascii_lowercase:
              if T[c] == 0:
                  print(S + c)
                  return
      return
  
  
  if __name__ == "__main__":
      main()
  
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"}]