import java.io.*;
import java.util.*;

public class DNA {

    public void solve() throws IOException {
        int n = nextInt(), k = 1, t = 1;
        int[] res = new int[n], count = new int[n + 1];
        res[0] = 1;
        count[1] = 1;
        while (t < n) {
            out.println("? 1 " + (t + 1));
            if (nextInt() > k) {
                k++;
                res[t] = k;
                count[k]++;
                t++;
            } else {
                if (k == 1) {
                    res[t] = 1;
                    count[1]++;
                } else {
                    int[] pref = new int[n + 1];
                    int i = 0;
                    boolean flag = true;
                    HashSet<Integer> set = new HashSet<>();
                    while (flag && set.size() < k - 1) {
                        while (pref[res[i]] < count[res[i]]) {
                            pref[res[i]]++;
                            if (pref[res[i]] == count[res[i]]) {
                                out.println("? " + (i + 2) + " " + (t + 1));
                                if (nextInt() == k - set.size()) {
                                    res[t] = res[i];
                                    flag = false;
                                    count[res[i]]++;
                                } else {
                                    set.add(res[i]);
                                    i++;
                                }
                            } else {
                                i++;
                            }
                            if (flag || set.size() == k - 1) {
                                break;
                            }
                        }
                    }
                    if (flag) {
                        for (int x = 1; x <= k; x++) {
                            if (!set.contains(x)) {
                                res[t] = x;
                                count[x]++;
                                break;
                            }
                        }
                    }
                }
                t++;
            }
        }

        out.println("Ready!");
        out.println(k);
        String s = "";
        for (int i = 0; i < n; i++) {
            s += String.valueOf(res[i]) + " ";
        }
        out.println(s);
    }

    public void run() {
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out, true);

            solve();

            out.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    BufferedReader br;
    StringTokenizer in;
    PrintWriter out;

    public String nextToken() throws IOException {
        while (in == null || !in.hasMoreTokens()) {
            in = new StringTokenizer(br.readLine());
        }
        return in.nextToken();
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    public double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    public static void main(String[] args) throws IOException {
        Locale.setDefault(Locale.US);
        new DNA().run();
    }

}