Problem: You are given a string s consisting of |s| small english letters.

In one move you can replace any character of this string to the next character in alphabetical order (a will be replaced with b, s will be replaced with t, etc.). You cannot replace letter z with any other letter.

Your target is to make some number of moves (not necessary minimal) to get string abcdefghijklmnopqrstuvwxyz (english alphabet) as a subsequence. Subsequence of the string is the string that is obtained by deleting characters at some positions. You need to print the string that will be obtained from the given string and will be contain english alphabet as a subsequence or say that it is impossible.

Input

The only one line of the input consisting of the string s consisting of |s| (1 ≤ |s| ≤ 105) small english letters.

Output

If you can get a string that can be obtained from the given string and will contain english alphabet as a subsequence, print it. Otherwise print «-1» (without quotes).

Examples

Input

aacceeggiikkmmooqqssuuwwyy


Output

abcdefghijklmnopqrstuvwxyz


Input

thereisnoanswer


Output

-1

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
namespace Meta {
template <char... args>
struct String {
  static const char data[sizeof...(args) + 1];
};
template <char... args>
constexpr const char String<args...>::data[sizeof...(args) + 1] = {args..., 0};
template <uint64_t N, char... chrs>
struct Int2String : Int2String<(N >> 8), N, chrs...> {};
template <char... chrs>
struct Int2String<0, chrs...> : String<chrs...> {};
template <typename s1, typename s2, bool init = true, size_t num = 2,
          size_t pos = 0, char... chrs>
struct ConcatStringImpl
    : ConcatStringImpl<s1, s2, !s2::data[pos + 1], num - !s2::data[pos + 1],
                       pos + 1, chrs..., s2::data[pos]> {};
template <typename s2, typename s1, size_t num, size_t pos, char... chrs>
struct ConcatStringImpl<s2, s1, true, num, pos, chrs...>
    : ConcatStringImpl<s1, s2, !s2::data[0], num - !s2::data[0], 0, chrs...> {};
template <typename s1, typename s2, size_t pos, char... chrs>
struct ConcatStringImpl<s1, s2, true, 0, pos, chrs...> : String<chrs...> {};
template <typename s, typename... strs>
struct ConcatString : ConcatStringImpl<s, ConcatString<strs...> > {};
template <typename s>
struct ConcatString
 : s {};
template <typename T>
struct FormatSingle;
template <uint64_t F, uint64_t E, uint64_t P, typename T, typename... args>
struct Format : ConcatString<Format<E, F, P, T>, Format<F, E, P, args...> > {};
template <uint64_t F, uint64_t E, uint64_t P, typename T>
struct Format<F, E, P, T> : ConcatString<String<'%'>, Int2String<P>,
                                         FormatSingle<T>, Int2String<E> > {};
template <typename T>
struct FormatSingle<T*> {
  constexpr static const char* data = "p";
};
template <>
struct FormatSingle<int8_t> {
  constexpr static const char* data = PRIi8;
};
template <>
struct FormatSingle<uint8_t> {
  constexpr static const char* data = PRIu8;
};
template <>
struct FormatSingle<int16_t> {
  constexpr static const char* data = PRIi16;
};
template <>
struct FormatSingle<uint16_t> {
  constexpr static const char* data = PRIu16;
};
template <>
struct FormatSingle<int32_t> {
  constexpr static const char* data = PRIi32;
};
template <>
struct FormatSingle<uint32_t> {
  constexpr static const char* data = PRIu32;
};
template <>
struct FormatSingle<int64_t> {
  constexpr static const char* data = PRIi64;
};
template <>
struct FormatSingle<uint64_t> {
  constexpr static const char* data = PRIu64;
};
template <>
struct FormatSingle<float> {
  constexpr static const char* data = "f";
};
template <>
struct FormatSingle<double> {
  constexpr static const char* data = "lf";
};
template <>
struct FormatSingle<char> {
  constexpr static const char* data = "c";
};
template <>
struct FormatSingle<char*> {
  constexpr static const char* data = "s";
};
template <>
struct FormatSingle<const char*> : FormatSingle<char*> {};
template <size_t N>
struct FormatSingle<char[N]> : FormatSingle<char*> {};
template <typename A, typename B>
struct Link {
  A data;
  B garbage;
};
template <>
struct Link<const char**, const char*> {
  const char** garbage;
  const char* data;
};
}  // namespace Meta
template <uint64_t P = 0, uint64_t E = '\n', uint64_t F = ' ', typename... Args>
static inline int pr(const Args... args) {
  return printf(Meta::Format<F, E, P, Args...>::data, args...);
}
template <typename... Args>
static inline int sc(Args&&... args) {
  return scanf(
      Meta::Format<0, 0, 0, decltype(args + 0)...>::data,
      Meta::Link<decltype(&args), decltype(args + 0)>({&args, args}).data...);
}
template <typename T>
int cmp_num(const void* a, const void* b) {
  return (*(T)a > *(T)b) - (*(T)a < *(T)b);
}
char s[100030];
int main() {
  gets(s);
  vector<char*> q;
  for (uint32_t i = 0; s[i] && q.size() < 26; ++i) {
    if (s[i] <= q.size() + 'a') {
      q.push_back(s + i);
    }
  }
  if (q.size() == 26) {
    for (auto i = (26) - (26); i < (26); ++i) {
      *q[i] = 'a' + i;
    }
    puts(s);
  } else {
    puts("-1");
  }
}