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

import java.util.*;

import java.io.*;

public class cf {
	static Reader sc = new Reader();
	static PrintWriter out = new PrintWriter(System.out);

	static int mod = (int) 1e9 + 7;

	public static void main(String[] args) {
		// int t = sc.ni();
		// while (t-- > 0) {
		int n = sc.ni();
		ArrayList<Integer>[] adj = new ArrayList[n + 1];
		for (int i = 1; i <= n; i++)
			adj[i] = new ArrayList<>();

		boolean[] vis = new boolean[n + 1];

		int[] res = query(1, n);
		ArrayList<Integer> odd = new ArrayList<>(), even = new ArrayList<>();
		for (int i = 1; i <= n; i++) {
			if (res[i] % 2 == 0) {
				if (i != 1)
					even.add(i);
			} else {
				odd.add(i);
			}
			if (res[i] == 1) {
				adj[i].add(1);
				adj[1].add(i);
			}
		}

		if (even.size() + 1 <= ((n + 1) / 2)) {
			for (int j : even) {
				int[] response = query(j, n);
				for (int i = 1; i <= n; i++) {
					if (response[i] == 1) {
						adj[i].add(j);
						adj[j].add(i);
					}
				}
			}
		} else {
			for (int j : odd) {
				int[] response = query(j, n);
				for (int i = 1; i <= n; i++) {
					if (response[i] == 1) {
						adj[i].add(j);
						adj[j].add(i);
					}
				}
			}
		}

		out.println("!");
		// output
		Queue<Integer> q = new LinkedList<>();
		vis = new boolean[n + 1];
		q.add(1);
		vis[1] = true;
		while (!q.isEmpty()) {
			int size = q.size();
			while (size-- > 0) {
				int curr = q.poll();
				for (int j : adj[curr]) {
					if (!vis[j]) {
						vis[j] = true;
						q.add(j);
						out.println(curr + " " + j);
					}
				}
			}

		}
		out.flush();

		// }

		out.close();
	}

	static int[] query(int i, int n) {
		out.println("? " + i);
		out.flush();
		int[] res = new int[n + 1];
		for (int j = 1; j <= n; j++)
			res[j] = sc.ni();
		return res;
	}

	public static long pow(long a, long b, long m) {
		if (b == 0) {
			return 1;
		}
		if (b % 2 == 0) {
			return pow((a * a) % m, b / 2, m) % m;
		} else {
			return (a * pow((a * a) % m, b / 2, m)) % m;
		}
	}

	static long calc(long[] arr, long x) {
		int n = arr.length;
		long res = 0;
		for (int i = 0; i < n; i++) {
			if (arr[i] > x) {
				res += (arr[i] - x);
				arr[i] = x;
			}
			if (i == 0)
				continue;
			res += Math.abs(arr[i] - arr[i - 1]);
		}
		res += arr[0];
		res += arr[n - 1];
		return res;
	}

	// snippets

	static class Pair implements Comparable<Pair> {
		int x;
		int y;

		Pair(int x, int y) {
			this.x = x;
			this.y = y;

		}

		@Override
		public int compareTo(Pair o) {
			if (this.x > o.x)
				return 1;
			else if (this.x < o.x)
				return -1;
			else {
				if (this.y > o.y)
					return 1;
				else if (this.y < o.y)
					return -1;
				else
					return 0;
			}
		}

		public int hashCode() {
			int ans = 1;
			ans = x * 31 + y * 13;
			return ans;
		}

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

	}

	static void add_map(HashMap<Integer, Integer> map, int v) {
		if (!map.containsKey(v)) {
			map.put(v, 1);
		} else {
			map.put(v, map.get(v) + 1);
		}
	}

	static void remove_map(HashMap<Integer, Integer> map, int v) {
		if (map.containsKey(v)) {
			map.put(v, map.get(v) - 1);
			if (map.get(v) == 0)
				map.remove(v);
		}
	}

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

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

	static void sort(int[] arr) {
		// shuffle
		Random rand = new Random();
		for (int i = 0; i < arr.length; i++) {
			int j = rand.nextInt(i + 1);
			int tmp = arr[i];
			arr[i] = arr[j];
			arr[j] = tmp;
		}
		Arrays.sort(arr);
	}

	static void sort(long[] arr) {
		// shuffle
		Random rand = new Random();
		for (int i = 0; i < arr.length; i++) {
			int j = rand.nextInt(i + 1);
			long tmp = arr[i];
			arr[i] = arr[j];
			arr[j] = tmp;
		}
		Arrays.sort(arr);
	}

	static boolean isPrime(int n) {
		if (n <= 1)
			return false;
		if (n <= 3)
			return true;
		if (n % 2 == 0 || n % 3 == 0)
			return false;
		double sq = Math.sqrt(n);

		for (int i = 5; i <= sq; i = i + 6)
			if (n % i == 0 || n % (i + 2) == 0)
				return false;
		return true;
	}

	static boolean isPrime(long n) {
		if (n <= 1)
			return false;
		if (n <= 3)
			return true;
		if (n % 2 == 0 || n % 3 == 0)
			return false;
		double sq = Math.sqrt(n);

		for (int i = 5; i <= sq; i = i + 6)
			if (n % i == 0 || n % (i + 2) == 0)
				return false;
		return true;
	}

	static void print_arr(int A[]) {
		for (int i : A) {
			System.out.print(i + " ");
		}
		System.out.println();
	}

	static void print_arr(long A[]) {
		for (long i : A) {
			System.out.print(i + " ");
		}
		System.out.println();
	}

	static int min(int a, int b) {
		return Math.min(a, b);
	}

	static int min(int a, int b, int c) {
		return Math.min(a, Math.min(b, c));
	}

	static int min(int a, int b, int c, int d) {
		return Math.min(a, Math.min(b, Math.min(c, d)));
	}

	static int max(int a, int b) {
		return Math.max(a, b);
	}

	static int max(int a, int b, int c) {
		return Math.max(a, Math.max(b, c));
	}

	static int max(int a, int b, int c, int d) {
		return Math.max(a, Math.max(b, Math.max(c, d)));
	}

	static long min(long a, long b) {
		return Math.min(a, b);
	}

	static long min(long a, long b, long c) {
		return Math.min(a, Math.min(b, c));
	}

	static long min(long a, long b, long c, long d) {
		return Math.min(a, Math.min(b, Math.min(c, d)));
	}

	static long max(long a, long b) {
		return Math.max(a, b);
	}

	static long max(long a, long b, long c) {
		return Math.max(a, Math.max(b, c));
	}

	static long max(long a, long b, long c, long d) {
		return Math.max(a, Math.max(b, Math.max(c, d)));
	}

	static int max(int A[]) {
		int max = Integer.MIN_VALUE;
		for (int i = 0; i < A.length; i++) {
			max = Math.max(max, A[i]);
		}
		return max;
	}

	static int min(int A[]) {
		int min = Integer.MAX_VALUE;
		for (int i = 0; i < A.length; i++) {
			min = Math.min(min, A[i]);
		}
		return min;
	}

	static long max(long A[]) {
		long max = Long.MIN_VALUE;
		for (int i = 0; i < A.length; i++) {
			max = Math.max(max, A[i]);
		}
		return max;
	}

	static long min(long A[]) {
		long min = Long.MAX_VALUE;
		for (int i = 0; i < A.length; i++) {
			min = Math.min(min, A[i]);
		}
		return min;
	}

	static long sum(int A[]) {
		long sum = 0;
		for (int i : A) {
			sum += i;
		}
		return sum;
	}

	static long sum(long A[]) {
		long sum = 0;
		for (long i : A) {
			sum += i;
		}
		return sum;
	}

	static ArrayList<Integer> sieve(int n) {
		ArrayList<Integer> primes = new ArrayList<>();
		boolean[] isPrime = new boolean[n];
		Arrays.fill(isPrime, true);
		isPrime[0] = isPrime[1] = false;
		for (int i = 2; i * i <= n; i++) {
			if (isPrime[i]) {
				for (int j = i * i; j < n; j += i) {
					isPrime[j] = false;
				}
			}
		}
		for (int i = 2; i < n; i++) {
			if (isPrime[i])
				primes.add(i);
		}
		return primes;
	}

	static class Reader {
		BufferedReader br;
		StringTokenizer st;

		Reader() {
			br = new BufferedReader(new InputStreamReader(System.in));
			st = new StringTokenizer("");
		}

		Reader(File f) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(f));
			st = new StringTokenizer("");
		}

		String next() {
			while (!st.hasMoreTokens())
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
				}
			return st.nextToken();
		}

		int ni() {
			return Integer.parseInt(next());
		}

		long nl() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}

		int[] nai(int n) {
			int[] a = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = ni();
			return a;
		}

		long[] nal(int n) {
			long[] a = new long[n];
			for (int i = 0; i < n; i++)
				a[i] = nl();
			return a;
		}
	}

}