#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> : 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");
  }
}
