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.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.*;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Double.parseDouble;
import static java.lang.String.*;
   
public class Main {

    static node root;
    
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
                                            //(new FileReader("input.in"));
        StringBuilder out = new StringBuilder();
        StringTokenizer tk;
                
        Map<Integer,Integer> map = new HashMap<>();
        root = new node();
        
        map.put(0,1);
        add(0);
        
        int q = parseInt(in.readLine());
        
        while(q-- > 0) {
            tk = new StringTokenizer(in.readLine());
            String c=tk.nextToken();
            int x = parseInt(tk.nextToken());
            
            if(c.equals("+")) {
                if(map.containsKey(x))
                    map.put(x, map.get(x)+1);
                else {
                    add(x);
                    map.put(x, 1);
                }
            } else if(c.equals("-")) {
                map.put(x, map.get(x)-1);
                if(map.get(x)==0) {
                    delete(x);
                    map.remove(x);
                }
            } else {
                node cur = root;
                int ans = 0;
                
                for(int p=30; p>=0; p--) {
                    if((x & (1<<p))==0) {
                        if(cur.cr>0) {
                            ans += (1<<p);
                            cur = cur.r;
                        } else if(cur.l!=null) cur = cur.l;
                        else break;
                    } else {
                        if(cur.cl>0) {
                            ans += (1<<p);
                            cur = cur.l;
                        } else if(cur.r!=null) cur = cur.r;
                        else break;
                    }
                }
                
                out.append(ans).append("\n");
            }
        }
        
        System.out.print(out);
    }
    
    static void add(int num) {
        node cur = root;
        
        for(int i=30; i>=0; i--) {
            if((num & (1<<i))==0) {
                cur.cl++;
                if(cur.l==null) cur.l = new node();
                cur = cur.l;
            } else {
                cur.cr++;
                if(cur.r==null) cur.r = new node();
                cur = cur.r;
            }
        }
    }
    
    static void delete(int num) {
        node cur = root;
        
        for(int i=30; i>=0; i--) {
            if((num & (1<<i))==0) {
                cur.cl--;
                cur = cur.l;
            } else {
                cur.cr--;
                cur = cur.r;
            }
        }
    }
}

class node {
    node l,r;
    int cl,cr;
    
    public node() {
        this.l = null;
        this.r = null;
        cl = 0;
        cr = 0;
    }
}