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

public class Main {

	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;

		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);

		TaskC solver = new TaskC();
		solver.solve(in, out);

		out.close();
	}

}

class TaskC {

	public void solve(InputReader in, OutputWriter out) {
		
		String s = in.next();
		boolean flag = true;
		for(int i = 0; i < s.length(); i++) {
			flag &= s.charAt(i) == 'a';
		}
		
		if(flag) {
			for(int i = 0; i < s.length() - 1; i++)
				out.write('a');
			out.write('z');
			return;
		}
		
		int index = 0;
		for(; index < s.length() && s.charAt(index)=='a'; index++);
		
		for(int i = 0; i < index; i++)
			out.write('a');
		int i;
		for(i = index; i < s.length() && s.charAt(i)!='a'; i++) {
			out.write(f(s.charAt(i)));
		}
		for(; i < s.length(); i++) {
			out.write(s.charAt(i));
		}
		
	}
	
	char f(char c) {
		if(c=='a')
			return 'z';
		else
			return (char)(c-1);
	}


}

class InputReader {

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

	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 String nextLine() {
		try {
			return reader.readLine();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}

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

	StringTokenizer tokenizer;
	BufferedReader reader;
}

class OutputWriter {

	public OutputWriter(OutputStream outputStream) {
		out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
	}

	public void write(Object... o) {
		for (Object x : o)
			out.print(x);
	}

	public void writeln(Object... o) {
		write(o);
		out.println();
	}

	public void close() {
		out.close();
	}

	PrintWriter out;
}