Problem: This is an interactive problem. Remember to flush your output while communicating with the testing program. You may use fflush(stdout) in C++, system.out.flush() in Java, stdout.flush() in Python or flush(output) in Pascal to flush the output. If you use some other programming language, consult its documentation. You may also refer to the guide on interactive problems: <https://codeforces.com/blog/entry/45307>.

You are given a string t consisting of n lowercase Latin letters. This string was cyphered as follows: initially, the jury had a string s consisting of n lowercase Latin letters. Then they applied a sequence of no more than n (possibly zero) operations. i-th operation is denoted by two integers a_i and b_i (1 ≤ a_i, b_i ≤ n), and means swapping two elements of the string with indices a_i and b_i. All operations were done in the order they were placed in the sequence. For example, if s is xyz and 2 following operations are performed: a_1 = 1, b_1 = 2; a_2 = 2, b_2 = 3, then after the first operation the current string is yxz, and after the second operation the current string is yzx, so t is yzx.

You are asked to restore the original string s. Unfortunately, you have no information about the operations used in the algorithm (you don't even know if there were any operations in the sequence). But you may run the same sequence of operations on any string you want, provided that it contains only lowercase Latin letters and its length is n, and get the resulting string after those operations.

Can you guess the original string s asking the testing system to run the sequence of swaps no more than 3 times?

The string s and the sequence of swaps are fixed in each test; the interactor doesn't try to adapt the test to your solution.

Input

Initially the testing system sends one string t, consisting of lowercase Latin letters (1 ≤ |t| = n ≤ 10^4).

Output

To give the answer, your program should print one line ! s with a line break in the end. After that, it should flush the output and terminate gracefully.

Interaction

Before giving the answer, you may submit no more than 3 queries. To ask a query, print one line in the following format: ? s', where s' should be a string consisting of exaclty n lowercase Latin letters. The line should be ended with a line break character. After submitting a query, flush the output and read the answer to your query — a string t' consisting of n lowercase Latin letters, which is the result of applying the sequence of swaps to string s'. This string will be given on a separate line ended by a line break character.

If you submit an incorrect query (or ask more than 3 queries), the answer to it will be one string 0. After receiving such an answer, your program should terminate immediately — otherwise you may receive verdict "Runtime error", "Time limit exceeded" or some other verdict instead of "Wrong answer".

Example

Input


yzx
aab
baa
aba

Output


? baa
? aba
? aab
! xyz

Note

In the sample, the testcase described in the statement is used. The participant asks the first query with string baa, which is transformed to aab. The second query contains string aba, which is transformed to baa. The third query contains string aab, which is transformed to aba. The participant can deduce that the initial string s was xyz.

Note for hacking phase:

To submit a test in hacking phase, you should provide it in the following format:

The first line should contain the string s you guess, consisting of n ∈ [1, 10000] lowercase Latin letters.

The second line should contain k (0 ≤ k ≤ n) — the number of swap operations in the sequence.

Then k lines should follow, i-th of them should denote i-th operation with two integers a_i and b_i (1 ≤ a_i, b_i ≤ n).

For example, the sample test would look like that:

xyz

2

1 2

2 3

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Rustam Musin (t.me/musin_acm)
 */
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);
        ERasshifruiStroku solver = new ERasshifruiStroku();
        solver.solve(1, in, out);
        out.close();
    }

    static class ERasshifruiStroku {
        InputReader in;
        OutputWriter out;

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            this.in = in;
            this.out = out;
            Interactor interactor = new Interactor("xyz", new int[]{1, 2, 0});
            interactor = new Interactor();
            String t = interactor.askFirst();
            int n = t.length();

            List<Integer> allIndexes = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                allIndexes.add(i);
            }

            Group group0 = new Group(allIndexes, allIndexes);
            List<Group> allGroups = new ArrayList<>();
            allGroups.add(group0);

            for (int i = 0; i < 3; i++) {
                char[] s = new char[n];
                for (Group group : allGroups) {
                    group.prepareString(s);
                }
                char[] res = interactor.ask(new String(s)).toCharArray();
                List<Group> nextGroups = new ArrayList<>();
                for (Group group : allGroups) {
                    nextGroups.addAll(group.generateNewGroups(res));
                }
                allGroups = nextGroups;
            }

            char[] answer = new char[n];
            for (Group group : allGroups) {
                answer[group.startIndexes.get(0)] = t.charAt(group.endIndexes.get(0));
            }
            interactor.answer(new String(answer));
        }

        class Group {
            List<Integer> startIndexes;
            List<Integer> endIndexes;

            Group(List<Integer> startIndexes, List<Integer> endIndexes) {
                this.startIndexes = startIndexes;
                this.endIndexes = endIndexes;
            }

            void prepareString(char[] s) {
                for (int i = 0; i < startIndexes.size(); i++) {
                    s[startIndexes.get(i)] = (char) ('a' + (i % 26));
                }
            }

            List<Group> generateNewGroups(char[] ans) {
                int nextGroupCount = Math.min(26, startIndexes.size());

                List<Integer>[] nextStarts = new List[nextGroupCount];
                for (int i = 0; i < nextGroupCount; i++) {
                    nextStarts[i] = new ArrayList<>();
                }
                for (int i = 0; i < startIndexes.size(); i++) {
                    nextStarts[i % nextGroupCount].add(startIndexes.get(i));
                }

                List<Integer>[] nextEnds = new List[nextGroupCount];
                for (int i = 0; i < nextGroupCount; i++) {
                    nextEnds[i] = new ArrayList<>();
                }
                for (int i = 0; i < startIndexes.size(); i++) {
                    nextEnds[(ans[endIndexes.get(i)] - 'a') % nextGroupCount].add(endIndexes.get(i));
                }

                List<Group> nextGroups = new ArrayList<>();
                for (int i = 0; i < nextGroupCount; i++) {
                    nextGroups.add(new Group(nextStarts[i], nextEnds[i]));
                }
                return nextGroups;
            }

        }

        class Interactor {
            String s0;
            int[] p;

            Interactor(String s0, int[] p) {
                this.s0 = s0;
                this.p = p;
            }

            Interactor() {

            }

            String ask(String s) {
                out.print("? ");
                out.printLine(s);
                out.flush();
                if (isLocal()) {
                    return build(s);
                } else {
                    return in.next();
                }
            }

            String build(String s) {
                char[] t = new char[s.length()];
                for (int i = 0; i < s.length(); i++) {
                    t[i] = s.charAt(p[i]);
                }
                return new String(t);
            }

            String askFirst() {
                if (isLocal()) {
                    return build(s0);
                } else {
                    return in.next();
                }
            }

            void answer(String s) {
                out.print("! ");
                out.printLine(s);
                out.flush();
            }

            boolean isLocal() {
                return s0 != null;
            }

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

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

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void printLine(Object... objects) {
            print(objects);
            writer.println();
        }

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

        public void flush() {
            writer.flush();
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                if (Character.isValidCodePoint(c)) {
                    res.appendCodePoint(c);
                }
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() {
            return readString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}