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.*;

import static java.lang.Math.*;


public class Main {
    BufferedReader br;
    StringTokenizer in;
    PrintWriter pw;
    Random r;
    int INF = (int) (2 * 1e9) + 1;
    long LNF = (long) 1e18;
    long mod = (long) (1e9 + 7);
    int pp = 27;
    // you shall not hack!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    //        /*\
    //       ///          /^\
    //      ///    ~~~~  (___)
    //     ///   ~~~~~~~~  \\__
    //   _/_/_  ~/ .& . \~  \\ \
    //  [____] ~|  (__)  |~/ \\/
    //  /_/\  \~|~~~~~~~~~~  /\\
    //      \   ~~~~~~~~~~ _/ \\
    //       \ _    ~~   _/\   \\
    //      /  |        /   \   \\
    //     |  /        |     \   \\
    //    /  /   ___   |      \
    //   /___|  | __|  |_______\
    //      _|  |   |  |_
    //     |____|   |____|
    //       P.S this is omnipotent Gandalf

    int n;

    class node {
        road a;
        int prior;
        node L;
        node R;

        public node(road aa) {
            a = aa;
            prior = r.nextInt();
            L = null;
            R = null;
        }
    }

    node merge(node a, node b) {
        if (a == null) return b;
        if (b == null) return a;
        if (a.prior > b.prior) {
            a.R = merge(a.R, b);
            return a;
        } else {
            b.L = merge(a, b.L);
            return b;
        }
    }

    pairn split(node c, long bb) {
        if (c == null) return new pairn(null, null);
        if (c.a.t >= bb) {
            pairn p = split(c.L, bb);
            c.L = p.s;
            return new pairn(p.f, c);
        } else {
            pairn p = split(c.R, bb);
            c.R = p.f;
            return new pairn(c, p.s);
        }
    }

    class pairn {
        node f;
        node s;

        public pairn(node ff, node ss) {
            f = ff;
            s = ss;
        }
    }

    ArrayList<road> foreach2(node c) {
        if (c == null) return new ArrayList<>();
        ArrayList<road> l = new ArrayList<>();
        if (c.L != null) l = foreach2(c.L);
        ArrayList<road> r = new ArrayList<>();
        if (c.R != null) r = foreach2(c.R);
        l.add(c.a);
        for (int i = 0; i < r.size(); i++) {
            l.add(r.get(i));
        }
        return l;
    }


    void solve() throws IOException {
        String s = nextToken();
        int n = s.length();
        int a[] = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = s.charAt(i) - 'a';
        }
        int c = 0;
        for (int i = 0; i < n; i++) {
            if (a[i] <= c) {
                a[i] = c;
                c++;
            }
            if (c == 26) break;
        }
        if (c < 26) {
            pw.print(-1);
        } else {
            for (int i = 0; i < n; i++) {
                pw.print((char) (a[i] + 'a'));
            }
        }
    }


    class road {
        int to;
        int t;

        public road(int toto, int tt) {
            to = toto;
            t = tt;
        }
    }
    //***************************************

    class pair {
        int l;
        int r;

        public pair(int ll, int rr) {
            l = ll;
            r = rr;
        }

        public pair(pair a) {
            l = a.l;
            r = a.r;
        }

        boolean cont(int a) {
            if (r >= a && l <= a) return true;
            return false;
        }
    }

    String nextToken() throws IOException {
        while (in == null || !in.hasMoreTokens()) {
            in = new StringTokenizer(br.readLine());
        }
        return in.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    public void gener() throws IOException {
        pw = new PrintWriter(new FileWriter("input.txt"));
        int n = r.nextInt(5) + 2;
    }

    public void run() throws IOException {
        r = new Random(5);
//        for (int i = 0; i < 100; i++) {
//            gener();
        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new OutputStreamWriter(System.out));
//        br = new BufferedReader(new FileReader("input.txt"));
//        pw = new PrintWriter(new FileWriter("output.txt"));
//        br = new BufferedReader(new FileReader("pixels.in"));
//        pw = new PrintWriter(new FileWriter("pixels.out"));
        solve();
//        pw.print(a);
        pw.close();
//            int b = solve2();
//            if (a != b) break;
//            pw.close();
//        }
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
}