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.*;
import java.util.ArrayList;

public class Example {
    private final static boolean local = false;

    public void execute() throws Exception{
        String data = readString();
        char[] input = data.toCharArray();

        int size = input.length;
        int start = -1;
        for (int i = 0; i < size; i++){
            if (input[i]!='a'){
                start = i;
                break;
            }
        }
        if (start < 0){
            String res = data;
            char[] resData = res.toCharArray();
            resData[size-1] = 'z';
            writelnString(String.valueOf(resData));
        } else {
            String res = data;
            char[] resData = res.toCharArray();
            for (int i = start; i < size; i++){
                if (resData[i]!='a'){
                    resData[i] = (char)(resData[i]-1);
                } else {
                    break;
                }
            }
            writelnString(String.valueOf(resData));
        }
    }
    public static void main(String [] args)throws Exception{
        Example taskA  = new Example();

        BufferedReader read;
        BufferedWriter write;
        if (local) {
            FileInputStream fileIn = new FileInputStream(new File("data/in.txt"));
            FileOutputStream fileOut = new FileOutputStream(new File("data/out.txt"));
            read = new BufferedReader(new InputStreamReader(fileIn));
            write = new BufferedWriter(new OutputStreamWriter(fileOut));
        } else {
            read = new BufferedReader(new InputStreamReader(System.in));
            write = new BufferedWriter(new OutputStreamWriter(System.out));
        }
        taskA.setReader(read);
        taskA.setWriter(write);
        taskA.execute();
        write.flush();
    }
    private BufferedReader reader;
    private BufferedWriter writer;
    public void setReader(BufferedReader reader) {
        this.reader = reader;
    }

    public void setWriter(BufferedWriter writer) {
        this.writer = writer;
    }

    public ArrayList<String> readStrings(){
        ArrayList<String> strings = new ArrayList<>();
        reader.lines().forEach(s->strings.add(s));
        return strings;
    }
    public void writelnStrings(ArrayList<String> lines) throws IOException{
        for (String line : lines){
            writer.write(line);
            writer.newLine();
        }
    }
    public void writeStrings(ArrayList<String> lines) throws IOException{
        for (String line : lines){
            writer.write(line);
        }
    }
    public String readString() throws IOException{
        return reader.readLine();
    }
    public void writelnString(String string) throws IOException{
        writer.write(string);
        writer.newLine();
    }
    public void writeString(String string) throws IOException{
        writer.write(string);
    }
    public Integer readInteger() throws IOException{
        return Integer.valueOf(reader.readLine());
    }
    public ArrayList<Integer> readIntegers() throws IOException{
        return readIntegers(" ");
    }
    public ArrayList<Integer> readIntegers(String split) throws IOException{
        ArrayList<Integer> result = new ArrayList<>();
        for (String string :reader.readLine().split(split)){
            result.add(Integer.valueOf(string));
        }
        return result;
    }
    public void writeInteger(Integer integer) throws IOException {
        writer.write(String.valueOf(integer));
    }
    public void writelnInteger(Integer integer) throws IOException {
        writer.write(String.valueOf(integer));
        writer.newLine();
    }
    public void writelnIntegers(ArrayList<Integer> integers) throws IOException{
        for (Integer integer : integers){
            writelnInteger(integer);
        }
    }
    public Double readDouble() throws IOException{
        return Double.valueOf(reader.readLine());
    }
    public ArrayList<Double> readDoubles() throws IOException{
        return readDoubles(" ");
    }
    public ArrayList<Double> readDoubles(String split) throws IOException{
        ArrayList<Double> result = new ArrayList<>();
        for (String string :reader.readLine().split(split)){
            result.add(Double.valueOf(string));
        }
        return result;
    }
    public void writeDouble(Double doubleValue) throws IOException {
        writer.write(String.valueOf(doubleValue));
    }
    public void writelnDouble(Double doubleValue) throws IOException {
        writer.write(String.valueOf(doubleValue));
        writer.newLine();
    }
    public void writelnDoubles(ArrayList<Double> doubles) throws IOException{
        for (Double doubleValue : doubles){
            writeDouble(doubleValue);
        }
    }
}
