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

The jury guessed some array a consisting of 6 integers. There are 6 special numbers — 4, 8, 15, 16, 23, 42 — and each of these numbers occurs in a exactly once (so, a is some permutation of these numbers).

You don't know anything about their order, but you are allowed to ask up to 4 queries. In each query, you may choose two indices i and j (1 ≤ i, j ≤ 6, i and j are not necessarily distinct), and you will get the value of a_i ⋅ a_j in return.

Can you guess the array a?

The array a is fixed beforehand in each test, the interaction program doesn't try to adapt to your queries.

Interaction

Before submitting the answer, you may ask up to 4 queries. To ask a query, print one line in the following format: ? i j, where i and j should be two integers such that 1 ≤ i, j ≤ 6. The line should be ended with a line break character. After submitting a query, flush the output and read the answer to your query — one line containing one integer a_i ⋅ a_j. If you submit an incorrect query (or ask more than 4 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".

To give the answer, your program should print one line ! a_1 a_2 a_3 a_4 a_5 a_6 with a line break in the end. After that, it should flush the output and terminate gracefully.

Example

Input


16
64
345
672

Output


? 1 1
? 2 2
? 3 5
? 4 6
! 4 8 15 16 23 42

Note

If you want to submit a hack for this problem, your test should contain exactly six space-separated integers a_1, a_2, ..., a_6. Each of 6 special numbers should occur exactly once in the test. The test should be ended with a line break character.

Solution (in JAVA):

Solution:
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {

    private final static InputReader inputReader = new InputReader(System.in);
    private final static OutputWriter outputWriter = new OutputWriter(System.out);

    public static void main(String[] args) throws IOException {
        int numberOfTestCases = 1;//inputReader.scanInt();
        for (int testCase = 1; testCase <= numberOfTestCases; ++testCase) {
            final ProblemParameters parameters = new ProblemParameters();

            final Solver solver = new Solver(parameters);
            solver.solve();
        }

        outputWriter.close();
    }

    static class Solver {

        private final ProblemParameters parameters;
        private final static int[] specialNumbers = {4, 8, 15, 16, 23, 42};
        private final int[] answer;
        private final Map<Integer, Pair> positionsWithMul;

        public Solver(final ProblemParameters parameters) {
            this.parameters = parameters;
            this.positionsWithMul = new HashMap<>();
            this.answer = new int[6];
        }

        public void solve() throws IOException {
            for (int i = 0; i < 6; ++i) {
                for (int j = i + 1; j < 6; ++j) {
                    positionsWithMul.put(specialNumbers[i] * specialNumbers[j], new Pair(i, j));
                }
            }

            outputWriter.println("? 1 2");
            int firstSecond = inputReader.scanInt();
            final Pair firstSecondPair = positionsWithMul.get(firstSecond);

            outputWriter.println("? 2 3");
            int secondThird = inputReader.scanInt();
            final Pair secondThirdPair = positionsWithMul.get(secondThird);

            outputWriter.println("? 4 5");
            int fourFifth = inputReader.scanInt();
            final Pair fourPair = positionsWithMul.get(fourFifth);

            outputWriter.println("? 5 6");
            int fFifth = inputReader.scanInt();
            final Pair fFifthPair = positionsWithMul.get(fFifth);

            if (firstSecondPair.first == secondThirdPair.first) { // 1, 2, 3
                answer[1] = specialNumbers[firstSecondPair.first];
                answer[0] = specialNumbers[firstSecondPair.second];
                answer[2] = specialNumbers[secondThirdPair.second];
            } else if (firstSecondPair.first == secondThirdPair.second) {
                answer[1] = specialNumbers[firstSecondPair.first];
                answer[0] = specialNumbers[firstSecondPair.second];
                answer[2] = specialNumbers[secondThirdPair.first];
            } else if (firstSecondPair.second == secondThirdPair.first) {
                answer[1] = specialNumbers[firstSecondPair.second];
                answer[0] = specialNumbers[firstSecondPair.first];
                answer[2] = specialNumbers[secondThirdPair.second];
            } else if (firstSecondPair.second == secondThirdPair.second) {
                answer[1] = specialNumbers[firstSecondPair.second];
                answer[0] = specialNumbers[firstSecondPair.first];
                answer[2] = specialNumbers[secondThirdPair.first];
            }

            if (fourPair.first == fFifthPair.first) {
                answer[4] = specialNumbers[fourPair.first];
                answer[3] = specialNumbers[fourPair.second];
                answer[5] = specialNumbers[fFifthPair.second];
            } else if (fourPair.first == fFifthPair.second) {
                answer[4] = specialNumbers[fourPair.first];
                answer[3] = specialNumbers[fourPair.second];
                answer[5] = specialNumbers[fFifthPair.first];
            } else if (fourPair.second == fFifthPair.first) {
                answer[4] = specialNumbers[fourPair.second];
                answer[3] = specialNumbers[fourPair.first];
                answer[5] = specialNumbers[fFifthPair.second];
            } else if (fourPair.second == fFifthPair.second) {
                answer[4] = specialNumbers[fourPair.second];
                answer[3] = specialNumbers[fourPair.first];
                answer[5] = specialNumbers[fFifthPair.first];
            }

            outputWriter.println(String.format("! %d %d %d %d %d %d", answer[0], answer[1], answer[2], answer[3], answer[4], answer[5]));
        }
    }

    static class Pair {

        int first;
        int second;

        public Pair(final int first, final int second) {
            this.first = first;
            this.second = second;
        }
    }

    static class ProblemParameters {

    }

    // We can use abstract method or loaner pattern to create different classes for different dataTypes and
    // keep repeated code in with generic class. But can't follow OOPS in CP :( because of TLE or MLE.
    // So try to use less object creation in CP.
    static class InputReader {

        private final BufferedInputStream bufferedInputStream;

        private final static char NEGATIVE_CHAR = '-';
        private final static char SPACE_CHAR = ' ';
        private final static char TAB_CHAR = '\t';
        private final static char NEW_LINE_WITH_N = '\n';
        private final static char NEW_LINE_WITH_R = '\r';
        private final static int END_OF_INPUT_STREAM = -1;

        public InputReader(final InputStream inputStream) {
            bufferedInputStream = new BufferedInputStream(inputStream);
        }

        public int scanInt() throws IOException {
            int currentByte = findFirstUsefulByte();
            boolean isNegative = false;
            if (currentByte == NEGATIVE_CHAR) {
                isNegative = true;
                currentByte = bufferedInputStream.read();
            }

            int number = 0;
            while (isUsefulByte(currentByte)) {
                number = (number * 10) + (currentByte - '0');
                currentByte = bufferedInputStream.read();
            }

            return isNegative ? -number : number;
        }

        public long scanLong() throws IOException {
            int currentByte = findFirstUsefulByte();
            boolean isNegative = false;
            if (currentByte == NEGATIVE_CHAR) {
                isNegative = true;
                currentByte = bufferedInputStream.read();
            }

            long number = 0;
            while (isUsefulByte(currentByte)) {
                number = (number * 10) + (currentByte - '0');
                currentByte = bufferedInputStream.read();
            }

            return isNegative ? -number : number;
        }

        public String scanString() throws IOException {
            int currentByte = findFirstUsefulByte();
            final StringBuilder stringBuilder = new StringBuilder();
            while (isUsefulByte(currentByte)) {
                stringBuilder.append((char) currentByte);
                currentByte = bufferedInputStream.read();
            }

            return stringBuilder.toString();
        }

        public double scanDouble() throws IOException { //Reason to use java's parser is because we had to write a lot of cases to handle floating point problems.
            return Double.parseDouble(scanString());
        }

        public List<Integer> scanListOfIntegers(int numbersCount) throws IOException {
            final List<Integer> numberList = new ArrayList<>();
            while (numbersCount-- > 0) {
                numberList.add(scanInt());
            }

            return numberList;
        }

        public List<Long> scanListOfLongs(int numbersCount) throws IOException {
            final List<Long> numberList = new ArrayList<>();
            while (numbersCount-- > 0) {
                numberList.add(scanLong());
            }

            return numberList;
        }

        public List<String> scanListOfStrings(int numbersCount) throws IOException {
            final List<String> stringList = new ArrayList<>();
            while (numbersCount-- > 0) {
                stringList.add(scanString());
            }

            return stringList;
        }

        private int findFirstUsefulByte() throws IOException {
            int currentByte = bufferedInputStream.read();
            while (!isUsefulByte(currentByte)) {
                currentByte = bufferedInputStream.read();
            }

            return currentByte;
        }

        private boolean isUsefulByte(final int currentByte) {
            if (currentByte == SPACE_CHAR || NEW_LINE_WITH_N == currentByte || NEW_LINE_WITH_R == currentByte
                || currentByte == TAB_CHAR || currentByte == END_OF_INPUT_STREAM) {
                return false;
            }
            else {
                return true;
            }
        }
    }

    // Try to use it in tr-resource block.
    // To avoid close call manually.
    static class OutputWriter implements AutoCloseable {

        private final static boolean IS_AUTO_FLUSH_FOR_NEW_LINE = true;
        private final PrintWriter printWriter;

        public OutputWriter(final OutputStream outputStream) {
            this.printWriter = new PrintWriter(outputStream, IS_AUTO_FLUSH_FOR_NEW_LINE);
        }

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

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

        public void flush() { //Force flush if require after printing each element on one line
            printWriter.flush();
        }

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

/**
 *
 * i1, i2 ->
 * i2, i3 ->
 * i3, i4 ->
 * i4, i5 ->
 *
 */