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.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;


public class Main {

	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}

	static class TaskC {
		static boolean visited[]  ;
		static boolean found = false; 
		static int steps = 0 ;
		static int n ; 
		static int[][] memo ;
		public void solve(int testNumber, InputReader in, PrintWriter out) {
			String x = in.next() ; 
			if(x.length() < 26)
			{
				System.out.println(-1);
				return ;
			} else if (x.length() ==0)
			{
				if(x.equals("abcdefghijklmnopqrstuvwxyz")) 
				{
					System.out.println("abcdefghijklmnopqrstuvwxyz");
					return ;
				} else 
				{
					System.out.println(-1);
					return ;
				}
			} 
			String alpha = "abcdefghijklmnopqrstuvwxyz" ;
			StringBuilder y = new StringBuilder("") ;
			int end =-1;
			int end2 =-1;
			for (int i = 0, j=0; i < x.length() && j<alpha.length(); )
			{
				if(x.charAt(i)<=alpha.charAt(j))
				{
					i++ ;
					j++ ;
					y.append(alpha.charAt(j-1)+"");
				} else {
					i++ ;
					y.append(x.charAt(i-1)+"");

				}
				end = j ;
				end2 = i ;
			}
			if(end==26)
			{
				if(end2==x.length())
					System.out.println(y);
				else 
					System.out.println(y+x.substring(end2,x.length()));
			} else 
			{
				System.out.println(-1);
			}






		}
		public static int get(int n){
			return n*(n+1)/2 ; 
		}
		public static long getSmallestDivisor( long y){
			if(isPrime(y))
				return -1;

			for (long i = 2; i*i <= y; i++)
			{
				if(y%i ==0)
				{
					return i;
				}
			}
			return -1;
		}
		public static void lis(pair []a , int n){
			int lis[] = new int[n] ; 
			Arrays.fill(lis,1) ; 

			for(int i=1;i<n;i++)
				for(int j=0 ; j<i; j++)
					if (a[i].y>a[j].y &&  lis[i] < lis[j]+1)   
						lis[i] = lis[j] + 1;           

			int max = lis[0];

			for(int i=1; i<n ; i++)
				if (max < lis[i])
					max = lis[i] ;
			System.out.println(max);

			ArrayList<Integer> s = new ArrayList<Integer>() ;
			for (int i = n-1; i >=0; i--)
			{
				if(lis[i]==max)
				{
					s.add(a[i].z);
					max --; 
				}
			}

			for (int i = s.size()-1 ; i>=0 ;  i--)
			{
				System.out.print(s.get(i)+" ");
			}

			return  ; 
		}
		public static int calcDepth(Vertix node){
			if(node.depth>0) return node.depth; 
			// meaning it has been updated before;
			if(node.parent != null)
				return 1+ calcDepth(node.parent);
			else
				return -1;
		}
		public static int helper(int a[] , int i , int j , int d ,  int n){
			if(j==i || i==n-1 || j==0)
				return 0; 
			if(a[j] - a[i] <= d)
				return 0; 
			if(memo[i][j]!= -1)
				return memo[i][j] ; 

			if( a[j-1]-a[i]< a[j]-a[i+1])
				return memo[i][j]=1 + helper(a, i, j-1, d , n) ; 
			if( a[j-1]-a[i]> a[j]-a[i+1])
				return memo[i][j]=1+ helper(a , i+1 , j , d ,n ) ;
			return memo[i][j]=1+ Math.min(helper(a, i, j-1, d , n) , helper(a , i+1 , j , d ,n )) ;

		}
		public static boolean isPrime (long num){
			if (num < 2) return false;
			if (num == 2) return true;
			if (num % 2 == 0) return false;
			for (int i = 3; i * i <= num; i += 2)
				if (num % i == 0) return false;
			return true;
		}

		public static boolean dfs(Vertix v , int target){
			try{
				visited[v.i]= true ;
			} catch (NullPointerException e)
			{
				System.out.println(v.i);
			}
			if(v.i == target)

				return true ;
			for (int i =0 ; i< v.neighbours.size() ; i++)
			{ 

				Vertix child = v.neighbours.get(i) ;
				if(child.i == target){
					found = true  ; 
				}
				if(visited[child.i]==false){
					found |= dfs(child, target) ;
				}
			}
			return found; 
		}






	}
	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(stream), 32768);
			tokenizer = null;
		}

		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}

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

	}
	public static class Vertix{
		int i ; 
		int depth ;
		ArrayList<Vertix> neighbours ; 
		Vertix parent ; 

		public Vertix(int i){
			this.i = i ;
			this.neighbours = new ArrayList<Vertix> () ;
			this.parent = null ;
			depth =-1;
		}
	}

	public static class pair implements Comparable<pair>{
		int x ; 
		int y ; 
		int z ; 

		public pair(int x, int y , int z){
			this.x=x ; 
			this.y=y ;
			this.z =z ;
		}

		@Override
		public int compareTo(pair p) {
			if(this.x > p.x)
				return 1 ; 
			else if(this.x== p.x)
			{
				if(this.y >= p.y)
					return -1 ;
				else 
					return 1 ;
			}
			else return -1 ;


		}


	}


}