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.util.Scanner;


public class Main {
	public static void main(String [] args) {
		Trie T = new Trie();
		T.add(0);
		String op;
		int  x;
		int  opsCount;
		
		String[] line;
		
		Scanner sc = new Scanner(System.in);
		opsCount = Integer.parseInt(sc.nextLine());
		
		while(opsCount-- > 0) {
			line = sc.nextLine().split(" ");
			op = line[0];
			x  = Integer.parseInt(line[1]);
			
			switch(op) {
			case "+":
				T.add(x); break;
			case "-":
				T.erase(x); break;
			default:
				System.out.println(T.query(x));
			}
		}
		sc.close();
	}
}

class Node {
	int count;
	Node[] next;
	
	Node() {
		next = new Node[2];
	}
}

class Trie {
	static int INT_SIZE = 32;
	Node root;
	
	Trie() {
		root = new Node();
	}
	
	void add(int value) {
		Node current = root;
		for(int i = INT_SIZE - 1; i > 0; i--) {
			int bit = (value >> (i - 1)) & 1;
			
			if(current.next[bit] == null) 
				current.next[bit] = new Node();
			
			current = current.next[bit];
			current.count++;
		}
	}
	
	void erase(int value){
		Node current = root;
		for(int i = INT_SIZE - 1; i > 0; i--) {
			int bit = (value >> (i - 1)) & 1;
			current = current.next[bit];
			current.count--;
		}
	}
	
	int query(int value) {
		Node current = root;
		int result = value;
		for(int i = INT_SIZE - 1; i > 0; i--) {
			int bit = (~value >> (i - 1)) & 1;
			if(current.next[bit] == null || current.next[bit].count == 0) 
				bit = bit ^ 1; // not found, flip bit
			
			result = result ^ (bit << (i - 1));
			current = current.next[bit];
		}
		return result;
	}
}