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

public class A {
    static class Node implements Comparable<Node>{
        int x;
        long cost;
        public Node(int x,long cost){
            this.x=x;
        }
        public int compareTo(Node c){
            return Long.compare(this.cost,c.cost);
        }
    }
    //public static PrintWriter pw;
    public static PrintWriter pw = new PrintWriter(System.out);

    public static void solve() throws IOException {
//	pw=new PrintWriter(new FileWriter("C:\\Users\\shree\\Downloads\\small_output_in"));
        FastReader sc = new FastReader();
        int q=sc.I();

        add(0,1);
        while(q-->0){
            char ch=sc.next().charAt(0);
            if(ch=='+'){
                int x=sc.I();
                add(x,1);
            }else if(ch=='-'){
                int x=sc.I();
                add(x,-1);

            }else {
                int x=sc.I();
                pw.println(querry(x));
            }
        }
        pw.close();

    }
    ///////////// Trie implementation for bits///////////
    ////////// trie array is used to store index of child of current node
    ///////// cnt is used to count no of strings having ith bit
    static int trie[][]=new int[5000000][2];
    static int C=1;
    static int cnt[]=new int[5000000];
    static int new_Vertex(){
        C++;
        return C-1;
    }
    static void add(int val,int d){
        int curr=0;
        for(int i=30;i>=0;i--){
            int cb=0;
            if((val&(1<<i))>0) cb=1;
            if(trie[curr][cb]==0){
                trie[curr][cb]=new_Vertex();
            }
            curr=trie[curr][cb];
            cnt[curr]+=d;
        }
    }
    static boolean check(int curr,int cb){
        if(trie[curr][cb]==0 || cnt[trie[curr][cb]]==0) return false;
        return true;
    }
    ////// it is used to find maximum xor we can get by xoring val and any other number.
    static int querry(int val){
        int curr=0;
        int ans=0;
        for(int i=30;i>=0;i--){
            int cb=0;
            if((val&(1<<i))>0) cb=1;
            cb^=1;
            if(check(curr,cb)){
                ans+=(1<<i);
                curr=trie[curr][cb];
            }else curr=trie[curr][cb^1];

        }
        return ans;
    }
    public static void main(String[] args) {
        new Thread(null, new Runnable() {
            public void run() {
                try {

                    solve();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "1", 1 << 26).start();

    }

    static BufferedReader br;
    static long M = (long) 1e9 + 7;

    static class FastReader {

        StringTokenizer st;

        public FastReader() throws FileNotFoundException {
            //br=new BufferedReader(new FileReader("C:\\Users\\shree\\Downloads\\B-small-practice.in"));
            br = new BufferedReader(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 I() {
            return Integer.parseInt(next());
        }

        long L() {
            return Long.parseLong(next());
        }

        double D() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        public boolean hasNext() throws IOException {
            while (st == null || !st.hasMoreTokens()) {
                String s = br.readLine();
                if (s == null) {
                    return false;
                }
                st = new StringTokenizer(s);
            }
            return true;
        }

    }
}