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.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class VasiliysMultiset {

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		
		BinaryTrie bt = new BinaryTrie();
		bt.update(0, 1);
		int q = sc.nextInt();
		while(q-->0) {
			char c = sc.next().charAt(0);
			int x = sc.nextInt();
			if (c == '+') 
				bt.update(x, 1);
			else if (c == '-') 
				bt.update(x, -1);
			else 
				out.println(bt.query(x));
		}
		
		out.flush();
		out.close();
	}
	
	static class Node {
		Node l, r;
		int val;
	}
	
	static class BinaryTrie {
		Node root;
		
		public BinaryTrie() {
			root = new Node();
		}
		
		void update(int x, int val) {
			update(root, 30, x, val);
		}
		
		void update(Node cur, int bit, int x, int val) {
			cur.val += val;
			if (bit == -1) 
				return;
			
			if ((x & (1 << bit)) == 0) { // left
				if (cur.l == null)
					cur.l = new Node();
				update(cur.l, bit-1, x, val); 
			}
			else { // right
				if (cur.r == null)
					cur.r = new Node();
				update(cur.r, bit-1, x, val);
			}
		}
		
		int query(int x) {
			return query(root, 30, x, 0);
		}
		
		int query(Node cur, int bit, int x, int acc) {
			if (bit == -1)
				return acc;
			
			if ((x & (1 << bit)) == 0) { // go for a 1
				if (cur.r != null && cur.r.val > 0)
					return query(cur.r, bit-1, x, acc | (1 << bit));
				return query(cur.l, bit-1, x, acc);
			}
			else { // go for a 0
				if (cur.l != null && cur.l.val > 0)
					return query(cur.l, bit-1, x, acc | (1 << bit));
				return query(cur.r, bit-1, x, acc);
			}
		}
	}
	
	static class Scanner {
		BufferedReader br;
		StringTokenizer st;

		public Scanner(FileReader f) {
			br = new BufferedReader(f);
		}

		public Scanner(InputStream in) {
			br = new BufferedReader(new InputStreamReader(in));
		}

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

		public String nextLine() throws IOException {
			return br.readLine();
		}

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

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

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

		public boolean Ready() throws IOException {
			return br.ready();
		}

		public void waitForInput(long time) {
			long ct = System.currentTimeMillis();
			while(System.currentTimeMillis() - ct < time) {};
		}

	}

}
