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.*;
import java.io.*;

public class VasiliyMultiset {
    static Node root;
    public static void main(String[] args) {
        FastScanner scanner = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        int Q = scanner.nextInt();
        root = new Node(1);
        while(Q-->0) {
            char type = scanner.next().charAt(0);
            int num = scanner.nextInt();
            if (type == '+') addNumber(num);
            else if (type == '-') removeNumber(num);
            else out.println(query(num));
        }
        out.flush();
    }
    
    static class Node {
        Node[] nodes = new Node[2];
        int counter = 0;
        int bit;
        public Node(int b) {bit = b;}
    }
    static int query(int x) {
        int ans = 0;
        Node curNode = root;
        if (curNode.nodes[0] == null && curNode.nodes[1] == null) return x;
        for(int k = 31; k>= 0; k--) {
            int curBit = (((1 << k) & x) > 0) ? 1 : 0;
            int prefBit = 1-curBit;
            if (curNode.nodes[prefBit] != null) {
                ans += (1 << k);
                curNode = curNode.nodes[prefBit];
            }
            else {
                curNode = curNode.nodes[curBit];
            }
        }
        return Math.max(ans, x);
    }
    
    static void addNumber(int x) {
        Node curNode = root;
        for(int k = 31; k>= 0; k--) {
            int curBit = (((1 << k) & x) > 0) ? 1 : 0;
            if (curNode.nodes[curBit] == null) curNode.nodes[curBit] = new Node(curBit);
            curNode.nodes[curBit].counter++;
            curNode = curNode.nodes[curBit];
        }
    }
    
    static void removeNumber(int x) {
        Node curNode = root;
        for(int k = 31; k>=0; k--) {
            int curBit = (((1 << k) & x) > 0) ? 1 : 0;
            Node nextNode = curNode.nodes[curBit];
            nextNode.counter--;
            if (nextNode.counter == 0) curNode.nodes[curBit] = null;
            curNode = nextNode;
        }
    }
    
    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;
        
        public FastScanner(Reader in) {
            br = new BufferedReader(in);
        }
        
        public FastScanner() {
            this(new InputStreamReader(System.in));
        }
        
        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        
        int nextInt() {
            return Integer.parseInt(next());
        }
        
        long nextLong() {
            return Long.parseLong(next());
        }
        
        double nextDouble() {
            return Double.parseDouble(next());
        }
        
        String readNextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        
        int[] readIntArray(int n) {
            int[] a = new int[n];
            for (int idx = 0; idx < n; idx++) {
                a[idx] = nextInt();
            }
            return a;
        }
    }
}
