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

import java.io.*;
import java.util.*;

public class Main {

    public static final String ANSI_RESET = "\u001B[0m";
    public static final String ANSI_RED = "\u001B[31m";
    public static final String ANSI_GREEN = "\u001B[33m";

    public static void main(String[] args) throws IOException {
        PrintWriter out = new PrintWriter(System.out);
        Stack<Integer> stack = new Stack<>();
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String ch = in.readLine();
        if (ch.length() < 26) {
            out.print(-1);
            out.close();
            return;
        }
        char t[] = new char[26];
        for (int i = 0; i < t.length; i++) {
            t[i] = (char) ('a' + i);
        }
        int j = 0;
        int count = 0;
        int i = 0;
        while (i < ch.length() && j < t.length) {
            if ((int) ch.charAt(i) <= t[j]) {
                ch = ch.substring(0, i) + t[j] + ch.substring(i +1,ch.length());
                j++;
                i++;
                count++;
            } else {
                i++;
            }
            if (count == 26) {
                out.println(ch);
                out.close();
                return;
            }
        }
        if (count != 26) {
            out.println(-1);
        }
        out.close();
    }

    public static void printString(List<Integer> stack, int sum) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < stack.size() - 1; i++) {

            sb.append(stack.get(i)).append("+");
        }
        sb.append(stack.get(stack.size() - 1));
        sb.append("=").append(sum);
        System.out.println(sb.toString());
    }

    public static void funcCard(List<List<Integer>> resList, List<Integer> list, int T[], int neededSum, int pos) {
        int sum = 0;
        for (Integer integer : list) {
            sum += integer;
        }
        if (sum == neededSum) {
            resList.add(new ArrayList<Integer>(list));
            return;
        }
        if (sum < neededSum) {
            for (int i = pos; i < T.length; i++) {
                if (pos != i && T[i] == T[i - 1]) {
                    continue;
                }
                list.add(T[i]);
                funcCard(resList, list, T, neededSum, i + 1);
                list.remove(list.size() - 1);

            }
        }
    }

    public boolean checkArithmeticProgression(int t[], int n) {
        if (n == 1) {
            return true;
        }
        radixSort(t);
        int d = t[1] - t[0];
        for (int i = 2; i < t.length; i++) {
            if (t[i] - t[i - 1] != d) {
                return false;
            }
        }
        return true;
    }

    public static int[] radixSort(int[] f) {
        return radixSort(f, f.length);
    }

    public static int[] radixSort(int[] f, int n) {
        int[] to = new int[n];
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++) {
                b[1 + (f[i] & 0xffff)]++;
            }
            for (int i = 1; i <= 65536; i++) {
                b[i] += b[i - 1];
            }
            for (int i = 0; i < n; i++) {
                to[b[f[i] & 0xffff]++] = f[i];
            }
            int[] d = f;
            f = to;
            to = d;
        }
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++) {
                b[1 + (f[i] >>> 16)]++;
            }
            for (int i = 1; i <= 65536; i++) {
                b[i] += b[i - 1];
            }
            for (int i = 0; i < n; i++) {
                to[b[f[i] >>> 16]++] = f[i];
            }
            int[] d = f;
            f = to;
            to = d;
        }
        return f;

    }

    private static class FastScanner {

        private final InputStream stream;
        private final byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public FastScanner(InputStream stream) {
            this.stream = stream;
        }

        public FastScanner(File file) throws FileNotFoundException {
            this.stream = new FileInputStream(file);
        }

        int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        boolean isEndline(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public int[] nextArrayInt(int n) {
            int tab[] = new int[n];
            for (int i = 0; i < n; i++) {
                tab[i] = nextInt();
            }
            return tab;
        }

        public String[] nextArrayString(int n) {
            String tab[] = new String[n];
            for (int i = 0; i < n; i++) {
                tab[i] = next();
            }
            return tab;
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String next() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public String nextLine() {
            int c = read();
            while (isEndline(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndline(c));
            return res.toString();
        }
    }
}
