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 Main {

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


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

        out.flush();
    }
}

class InputReader extends BufferedReader {
    StringTokenizer tokenizer;

    public InputReader(InputStream inputStream) {
        super(new InputStreamReader(inputStream), 32768);
    }

    public InputReader(String filename) {
        super(new InputStreamReader(Thread.currentThread().getContextClassLoader().getResourceAsStream(filename)));
    }

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

    public Integer nextInt() {
        return Integer.valueOf(next());
    }
    public Long nextLong() {return  Long.valueOf(next());}

    static class OutputWriter extends PrintWriter {
        public OutputWriter(OutputStream outputStream) {
            super(outputStream);
        }

        public OutputWriter(Writer writer) {
            super(writer);
        }

        public OutputWriter(String filename) throws FileNotFoundException {
            super(filename);
        }

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

class TaskA {
    public void solve(InputReader in, InputReader.OutputWriter out) {
        int n = in.nextInt();
        String s = in.next();
        int x = 0;
        int y = 0;
        HashMap<Point,Integer> map = new HashMap<>();
        Point[] points = new Point[n + 1];
        Point first = new Point(0,0);
        points[0] = first;
        for (int i = 0; i < s.length(); i++) {
            char current = s.charAt(i);
            if(current == 'R') {
                x++;
            }
            else if(current == 'L') {
                x--;
            }
            else if(current == 'U') {
                y++;
            }
            else {
                y--;
            }
            points[i + 1] = new Point(x,y);
        }
        int r = 0;
        int max = 0;
        int l = 0;
        out.println(Arrays.toString(points));
        HashSet<Point> sub = new HashSet<>();
        while (r < points.length) {
            while (sub.contains(points[r])) {
                sub.remove(points[l]);
                l++;
            }
            out.println(points[r] + " " + l);
            max = Math.max(max,r-l);
            sub.add(points[r]);
            r++;
        }
        out.println(max);
    }
}
class Point {
    private int x;
    private int y;

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }
    public Point(int x,int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Point point = (Point) o;
        return x == point.x &&
                y == point.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }

    @Override
    public String toString() {
        return  x + " " + y;
    }
}
class TaskB {
    public void solve(InputReader in, InputReader.OutputWriter out) {
        int n = in.nextInt();
        int [] a = new int[n];
        for (int i = 0; i < a.length; i++) {
            a[i] = Math.abs(in.nextInt());
        }
        Arrays.sort(a);
        long count = 0;
        for (int i = 0; i < a.length; i++) {
            int index = binarySearch(a,i+1,a[i]);
            if(index<n) {
                count+=(long)(index - i);
            }
        }
        out.println(count);
    }
    private int binarySearch(int [] a, int index,int target) {
        int lo = index;
        int hi = a.length - 1;
        while (lo<=hi) {
            int med = lo + (hi-lo)/2;
            if(a[med] - target <= target) {
                lo = med + 1;
            }
            else hi = med  - 1;
        }
        return hi;
    }
}
class TaskC {
    public void solve(InputReader in, InputReader.OutputWriter out) {

        String s = in.next();
        char [] c = s.toCharArray();
        int begin = -1;
        int end = c.length;
        for (int i = 0; i < c.length; i++) {
            if(c[i]!='a') {
                if(begin == -1) {
                    begin = i;
                }
            }
            else {
                if(begin!=-1) {
                    end = i;
                    break;
                }
            }
        }
        if(begin == -1) {
            c[end - 1] = 'z';
        }
        else {
            for (int i = begin; i < end; i++) {
                c[i] = (char) (c[i] - 1);
            }
        }
        out.println(new String(c));
    }
    static int binarySearch(int [] a, int target) {
        int lo = 0;
        int hi = a.length - 1;
        while (lo<=hi) {
            int med = lo + (hi-lo)/2;
            if(target == a[med]) return med;
            if(target>a[med]) {
                lo = med + 1;
            }
            else {
                hi = med - 1;
            }
        }
        return lo;
    }
}