5
5 3
2 4
3 1
4 5
 4
2 4
3 2
2 1
 5
5 3
2 4
3 1
4 5
 2
1 2
 4
3 4
2 3
3 1
 10
8 10
2 9
7 8
4 1
7 3
4 7
2 5
2 4
4 6
 5
3 4
3 2
3 1
1 5
 3
1 2
2 3
 5
1 2
1 3
1 4
1 5

1 2
2 3
2 4
 1 3
2 4
3 5
4 5
 1 2
 1 3
2 3
3 4
 1 4
2 4
2 5
2 9
3 7
4 6
4 7
7 8
8 10
 1 3
1 5
2 3
3 4
 1 2
2 3
 1 2
1 3
1 4
1 5

/**
 * Created by Himanshu
 **/

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

public class D1534 {
    static Reader s = new Reader();
    public static void main(String[] args) throws IOException {
        int n = s.i();
        HashSet<String> set = new HashSet<>();
        int [][] arr = new int[n+1][n];
        boolean [] vis = new boolean[n+1];
        Queue<Integer> q = new LinkedList<>();
        q.add(1);
        while (set.size() < n-1 && !q.isEmpty()) {
            int in = q.poll();
            if (!vis[in]) {
                arr[in] = query(in,n);
//                int [] temp = new int[n+1];
//                for (int i=1;i<=n;i++) {
//                    temp[arr[in][i]]++;
//                }
                int max = 0;
//                int idx = 0;
                for (int i=0;i<=n;i++) {
//                    if (max < temp[i]) {
//                        max = temp[i];
//                        idx = i;
//                    }
                    max = Math.max(max,arr[in][i]);
                }
                HashMap<Integer,ArrayList<Integer>> map = new HashMap<>();
                int x = 0;
                for (int i=1;i<=n;i++) {
                    if (i != in) {
                        ArrayList<Integer> list;
                        if (map.containsKey(arr[in][i])) list = map.get(arr[in][i]);
                        else list = new ArrayList<>();
                        list.add(i);
                        map.put(arr[in][i],list);
                    }
                    x = Math.max(x,arr[in][i]);
                }
                for (int i=1;i<x;i++) {
                    if (map.get(i).size() == 1) {
                        ArrayList<Integer> list = map.get(i+1);
                        int v = map.get(i).get(0);
                        for (int a : list) {
                            String str;
                            if (a > v) str = v + " " + a;
                            else str = a + " " + v;
                            set.add(str);
                        }
                    }
                }
                for (int a : map.get(1)) {
                    String str ;
                    if (a > in) str = in + " " + a;
                    else str = a + " " + in;
                    set.add(str);
                }
                int val = max-1;
                boolean flag = true;
                while (flag && val > 0) {
                    for (int i=1;i<=n;i++) {
                        if (arr[in][i] == val && !vis[i] && flag) {
                            q.add(i);
                            flag = false;
                        }
                    }
                    val--;
                }
                if (flag) {
                    for (int i=1;i<=n;i++) {
                        if (arr[in][i] == max && !vis[i] && flag) {
                            q.add(i);
                            flag = false;
                        }
                    }
                }
                vis[in] = true;
            }
            if(set.size() < n-1 && q.size() == 0) {
                for (int i=1;i<=n;i++) {
                    if (!vis[in]) q.add(in);
                }
            }
            // 0 1 2 2 2 3 3 4 -> 1
            // 1 0 1 1 1 2 2 3 -> 2
            // 2 1 0 2 2 3 1 2 -> 3
            // 2 1 2 0 2 3 3 4 -> 4
            // 2 1 2 2 0 1 3 4 -> 5
            // 3 2 3 3 1 0 4 5 -> 6
            // 3 2 1 3 3 4 0 1 -> 7
            // 4 3 2 4 4 5 1 0 -> 8
        }
        System.out.println("!");
        for (String value : set) {
            System.out.println(value);
        }
        System.out.flush();
    }

    private static int [] query(int val , int n) {
        System.out.println("? " + val);
        System.out.flush();
        int [] arr = new int[n+1];
        for (int i=1;i<=n;i++) arr[i] = s.i();
        return arr;
    }

    public static void shuffle(long[] arr) {
        int n = arr.length;
        Random rand = new Random();
        for (int i = 0; i < n; i++) {
            long temp = arr[i];
            int randomPos = i + rand.nextInt(n - i);
            arr[i] = arr[randomPos];
            arr[randomPos] = temp;
        }
    }

    private static int gcd(int a, int b) {
        if(b == 0) return a;
        return gcd(b,a%b);
    }

    public static long nCr(long[] fact, long[] inv, int n, int r, long mod) {
        if (n < r)
            return 0;
        return ((fact[n] * inv[n - r]) % mod * inv[r]) % mod;
    }

    private static void factorials(long[] fact, long[] inv, long mod, int n) {
        fact[0] = 1;
        inv[0] = 1;
        for (int i = 1; i <= n; ++i) {
            fact[i] = (fact[i - 1] * i) % mod;
            inv[i] = power(fact[i], mod - 2, mod);
        }
    }

    private static long power(long a, long n, long p) {
        long result = 1;
        while (n > 0) {
            if (n % 2 == 0) {
                a = (a * a) % p;
                n /= 2;
            } else {
                result = (result * a) % p;
                n--;
            }
        }
        return result;
    }

    private static long power(long a, long n) {
        long result = 1;
        while (n > 0) {
            if (n % 2 == 0) {
                a = (a * a);
                n /= 2;
            } else {
                result = (result * a);
                n--;
            }
        }
        return result;
    }

    private static long query(long[] tree, int in, int start, int end, int l, int r) {
        if (start >= l && r >= end) return tree[in];
        if (end < l || start > r) return 0;
        int mid = (start + end) / 2;
        long x = query(tree, 2 * in, start, mid, l, r);
        long y = query(tree, 2 * in + 1, mid + 1, end, l, r);
        return x + y;
    }

    private static void update(int[] arr, long[] tree, int in, int start, int end, int idx, int val) {
        if (start == end) {
            tree[in] = val;
            arr[idx] = val;
            return;
        }
        int mid = (start + end) / 2;
        if (idx > mid) update(arr, tree, 2 * in + 1, mid + 1, end, idx, val);
        else update(arr, tree, 2 * in, start, mid, idx, val);
        tree[in] = tree[2 * in] + tree[2 * in + 1];
    }

    private static void build(int[] arr, long[] tree, int in, int start, int end) {
        if (start == end) {
            tree[in] = arr[start];
            return;
        }
        int mid = (start + end) / 2;
        build(arr, tree, 2 * in, start, mid);
        build(arr, tree, 2 * in + 1, mid + 1, end);
        tree[in] = (tree[2 * in + 1] + tree[2 * in]);
    }

    static class Reader {
        private InputStream mIs;
        private byte[] buf = new byte[1024];
        private int curChar, numChars;

        public Reader() {
            this(System.in);
        }

        public Reader(InputStream is) {
            mIs = is;
        }

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

        public String nextLine() {
            int c = read();
            while (isSpaceChar(c)) c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndOfLine(c));
            return res.toString();
        }

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

        public long l() {
            int c = read();
            while (isSpaceChar(c)) c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9') throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public int i() {
            int c = read();
            while (isSpaceChar(c)) c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public double d() throws IOException {
            return Double.parseDouble(s());
        }

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

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

        public int[] arr(int n) {
            int[] ret = new int[n];
            for (int i = 0; i < n; i++) {
                ret[i] = i();
            }
            return ret;
        }

        public long[] arrLong(int n) {
            long[] ret = new long[n];
            for (int i = 0; i < n; i++) {
                ret[i] = l();
            }
            return ret;
        }
    }
//    static class pairLong implements Comparator<pairLong> {
//        long first, second;
//
//        pairLong() {
//        }
//
//        pairLong(long first, long second) {
//            this.first = first;
//            this.second = second;
//        }
//
//        @Override
//        public int compare(pairLong p1, pairLong p2) {
//            if (p1.first == p2.first) {
//                if(p1.second > p2.second) return 1;
//                else return -1;
//            }
//            if(p1.first > p2.first) return 1;
//            else return -1;
//        }
//    }
//    static class pair implements Comparator<pair> {
//        int first, second;
//
//        pair() {
//        }
//
//        pair(int first, int second) {
//            this.first = first;
//            this.second = second;
//        }
//
//        @Override
//        public int compare(pair p1, pair p2) {
//            if (p1.first == p2.first) return p1.second - p2.second;
//            return p1.first - p2.first;
//        }
//    }
}

