Author has gone out of the stories about Vasiliy, so here is just a formal task description.

You are given q queries and a multiset A, initially containing only integer 0. There are three types of queries:

  1. "+ x" — add integer x to multiset A.
  2. "- x" — erase one occurrence of integer x from multiset A. It's guaranteed that at least one x is present in the multiset A before this query.
  3. "? x" — you are given integer x and need to compute the value <image>, i.e. the maximum value of bitwise exclusive OR (also know as XOR) of integer x and some integer y from the multiset A.



Multiset is a set, where equal elements are allowed.

Input

The first line of the input contains a single integer q (1 ≤ q ≤ 200 000) — the number of queries Vasiliy has to perform.

Each of the following q lines of the input contains one of three characters '+', '-' or '?' and an integer xi (1 ≤ xi ≤ 109). It's guaranteed that there is at least one query of the third type.

Note, that the integer 0 will always be present in the set A.

Output

For each query of the type '?' print one integer — the maximum value of bitwise exclusive OR (XOR) of integer xi and some integer from the multiset A.

Example

Input

10
+ 8
+ 9
+ 11
+ 6
+ 1
? 3
- 8
? 3
? 8
? 11


Output

11
10
14
13

Note

After first five operations multiset A contains integers 0, 8, 9, 11, 6 and 1.

The answer for the sixth query is integer <image> — maximum among integers <image>, <image>, <image>, <image> and <image>.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class Trie {
	class Node {
		boolean end;
		Node[] next;
		Node[] prev;
		int count;

		Node() {
			next = new Node[2];
			prev = new Node[2];
		}
	}

	Node root;

	Trie() {
		root = new Node();
		root.next[0] = new Node();
		Node cur = root;
		for(int i =0; i<32; i++){
		 cur = cur.next[0];
		 cur.next[0] = new Node();
		 cur.next[0].prev[0] = cur;
		}
		cur.end = true;
		cur.count++;
		
	}

	void insert(String s) {
		int slen = s.length();
		Node cur = root;
		for (int i = 0; i < slen; i++) {
			int nextIdx = s.charAt(i) - '0';
			if (cur.next[nextIdx] == null) {
				cur.next[nextIdx] = new Node();
				cur.next[nextIdx].prev[nextIdx] = cur;
			}
			cur = cur.next[nextIdx];
		}
		cur.count++;
		cur.end = true;
	}

	boolean search(String s) {
		int slen = s.length();
		Node cur = root;
		for (int i = 0; i < slen; i++) {
			int nextIdx = s.charAt(i) - '0';
			if (cur.next[nextIdx] == null)
				return false;
			cur = cur.next[nextIdx];
		}
		return cur.end;
	}

	Node search2(String s) {
		int slen = s.length();
		Node cur = root;
		for (int i = 0; i < slen; i++) {
			int nextIdx = s.charAt(i) - '0';
			if (cur.next[nextIdx] == null)
				return null;
			cur = cur.next[nextIdx];
		}
		return cur;
	}

	void delete(String s) {
		Node toDelete = search2(s);

		if (toDelete != null) {
			Node cur = toDelete;
			for (int i = s.length() - 1; i >= 0; i--) {
				int idx = s.charAt(i) - '0';
				if (cur.next[1] == null && cur.next[0] == null) {
					if (cur.count > 1) {
						cur.count--;
						cur = cur.prev[idx];
					}else{
						cur = cur.prev[idx];
						cur.next[idx] = null;
					}
				} else {
					cur = cur.prev[idx];
				}
			}
		}
	}

	int maxxor(String s) {
		Node cur = root;
		String res = "";
		for (int i = 0; i < s.length(); i++) {
			int idx = s.charAt(i) - '0';
			if (idx == 0) {
				if (cur.next[1] != null) {
					res += idx ^ 1;
					cur = cur.next[1];
				} else {
					res += idx ^ 0;
					cur = cur.next[0];
				}
			}
			if (idx == 1) {
				if (cur.next[0] != null) {
					res += idx ^ 0;
					cur = cur.next[0];
				} else {
					res += idx ^ 1;
					cur = cur.next[1];
				}
			}
		}
		return Integer.parseInt(res, 2);
	}

	public static void main(String[] args) throws IOException {
		Trie t = new Trie();
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter pw = new PrintWriter(System.out);
		int c = Integer.parseInt(br.readLine());
		for (int i = 0; i < c; i++) {
			String[] l = br.readLine().split(" ");
			String op = l[0];
			int n = Integer.parseInt(l[1]);
			String in = Integer.toBinaryString(n);
			if (in.length() > 32) {
				in = in.substring(2, in.length());
			} else {
				int left = 32 - in.length();
				for (int j = 0; j < left; j++) {
					in = "0" + in;
				}
			}
			if (op.equals("+")) {
				t.insert(in);
			}
			if (op.equals("-")) {
				t.delete(in);
			}
			if (op.equals("?")) {
				pw.println(t.maxxor(in));
			}
		}
		pw.flush();
		pw.close();
	}

}
