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

public class CodeForces {
    private final BufferedReader reader;
    private final PrintWriter writer;
    private StringTokenizer tokenizer;

    private void solve() {
        String s = next();
        StringBuilder res = new StringBuilder();
        int n = s.length();
        int li, si = 0;
        for (int i = 0; i < n; i++) {
            if (s.charAt(i) == 'a') si++;
            else break;
        }
        if (si == n) {
            writer.print(s.substring(0, n - 1));
            writer.print('z');
        } else {
            li = si;
            for (int i = si + 1; i < n; i++) {
                if (s.charAt(i) == 'a') break;
                else li++;
            }
            res.append(s.substring(0, si));
            for (int i = si; i <= li; i++) {
                res.append((char) (s.charAt(i) - 1));
            }
            if (li != s.length() - 1) res.append(s.substring(li + 1, s.length()));
            writer.print(res);
        }
//        int n = nextInt();
//        int a = nextInt();
//        int checkNumber = n - 1;
//        long res = 0;
//        int[] x = new int[n];
//        long[] dp = new long[n];
//        for (int i = 0; i < n; i++) {
//            x[i] = nextInt();
//        }
//        shuffleArray(x);
//        Arrays.sort(x);
//        int lower = binarylower(x, a, 0, x.length - 1);
//        int upper = upperBinarySearch(x, 0, x.length, a);
//        int l = lower;
//        int r = upper;
//        if (l != r) {
//            checkNumber -= (r - l - 1);
//        } else if (x[l] == a) {
//            checkNumber--;
//        } else if (l < n) {
//            // // TODO: 2016-08-24
//        }
//        while (checkNumber > 0) {
//            if (l - 1 >= 0 && r + 1 < n) {
//                if (x[l] - x[l - 1] < x[r + 1] - x[r]) {
//
//                }
//            }
//        }
    }

    public static int upperBinarySearch(int[] array, int start, int finish, int key) {
        int low = start;
        int high = finish - 1;
        while (low < high) {
            int mid = (low + high + 1) / 2;
            if (array[mid] <= key) low = mid;
            else high = mid - 1;
        }
        if (array[low] > key) low--;
        return low;
    }

    int binarylower(int a[], int m, int l, int u) {
        int mid, c = 0;
        if (l <= u) {
            mid = (l + u) / 2;
            if (m == a[mid]) {
                c = m;
                return binarylower(a, m, l, mid - 1);
            } else if (m < a[mid]) {
                return binarylower(a, m, l, mid - 1);
            } else {
                return binarylower(a, m, mid + 1, u);
            }
        } else
            return l;
    }

    public static void main(String[] args) {
        new CodeForces(System.in, System.out);
    }

    private CodeForces(InputStream inputStream, OutputStream outputStream) {
        this.reader = new BufferedReader(new InputStreamReader(inputStream));
        this.writer = new PrintWriter(outputStream);
        solve();
        writer.close();
    }

    private String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(readLine());
        }
        return tokenizer.nextToken();
    }

    private String readLine() {
        String line;
        try {
            line = reader.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return line;
    }

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

    private long nextLong() {
        return Long.parseLong(next());
    }

    private double nextDouble() {
        return Double.parseDouble(next());
    }

    private void shuffleArray(int[] a) {
        Random r = new Random();
        int tmp;
        for (int i = 1; i < a.length; i++) {
            tmp = r.nextInt(i + 1);
            int val = a[tmp];
            a[tmp] = a[i];
            a[i] = val;
        }
    }
}
