You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.

What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?

Input

The only line of the input contains the string s (1 ≤ |s| ≤ 100 000) consisting of lowercase English letters.

Output

Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.

Examples

Input

codeforces


Output

bncdenqbdr


Input

abacaba


Output

aaacaba

Note

String s is lexicographically smaller than some other string t of the same length if there exists some 1 ≤ i ≤ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti.
import java.util.*;
import java.io.*;
import java.math.*;
import java.math.BigInteger;
public class Tester {
	public static void main(String args[])
	{
		InputReader in = new InputReader(System.in);
		OutputStream outputStream = System.out;
		PrintWriter out = new PrintWriter(outputStream);
		String s=new String();
		s=in.next();int i=0,j=0;
		char arr[]=s.toCharArray();
		for(i=0;i<s.length();i++)
		{
			if(s.charAt(i)!='a')
				break;
		}
		if(i==s.length())
		{
			arr[s.length()-1]='z';
			for(i=0;i<s.length();i++)
			{
				out.print(arr[i]);
			}
		}
		else
		{
		for(j=i;j<s.length();j++)
		{
			if(s.charAt(j)!='a')
			{
				arr[j]=(char)((char)s.charAt(j)-1);
			}
			else
			{
				break;
			}
		}
		for(i=0;i<s.length();i++)
		{
			out.print(arr[i]);
		}
		}
		out.close();
	}
	static int max_sub_array(int arr[],int n)
	{
		int i;
		int sum=0,max_end_here=0,max_so_far=0;
		for(i=0;i<n;i++)
		{
			max_end_here=max_end_here+arr[i];
			if(max_end_here<0)
				max_end_here=0;
			else if(max_so_far<max_end_here)
				max_so_far=max_end_here;
		}
		return max_so_far;
	}
	static class Pair implements Comparable<Pair>
	{
		private long first;
		private long index;
		//private long second;;

		public Pair(long i, long j) 
		{ 
			this.first = i;
			this.index = j;
		}
		public long getFirst() { return first; }
		//public long getSecond() { return second; }
		public long getIndex() { return index ;}
		public void setFirst(long k) { this.first=k ; }
		public void setIndex(long k) { this.index=k ;}
		//public void setSecond(long k) { this.second=k ;}
		@Override
		public int compareTo(Pair o) 
		{
			return Long.compare(this.first, o.first);
		}
	}
	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader(InputStream inputstream) {
			reader = new BufferedReader(new InputStreamReader(inputstream));
			tokenizer = null;
		}

		public String nextLine(){
			String fullLine=null;
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					fullLine=reader.readLine();
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
				return fullLine;
			}
			return fullLine;
		}
		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 long nextLong() {
			return Long.parseLong(next());
		}
		public int nextInt() {
			return Integer.parseInt(next());
		}
	}
}