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.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.StringTokenizer;

public class CF367D {
    public static PrintWriter out;
    public static FastScanner in;

    List<Vertex> store;
    int idx;
    private void solve() {
        int q = in.nextInt();

        store = new ArrayList<>();
        idx = 0;
        store.add(new Vertex());
        add(0);
        for(int i=0;i<q;i++){
            char c = in.next().charAt(0);
            int x = in.nextInt();

            switch (c){
                case '+':
                    add(x);
                    break;
                case '-':
                    erase(x);
                    break;
                case '?':
                    out.println(query(x));
                    break;
            }
        }
    }

    private void add(int x){
        int j = 0;
        for(int i=31; i>=0 ; i--){
            int b = (x>>i) & 1;
            Vertex u = store.get(j);
            switch (b){
                case 1:
                    if(u.next[1] == -1){
                        Vertex v1 = new Vertex();
                        u.next[1] = ++idx;
                        store.add(v1);
                        store.set(j,u);
                    }
                    j = u.next[1];
                    Vertex v1 = store.get(j);
                    v1.count++;
                    store.set(j,v1);
                    break;
                case 0:
                    if(u.next[0] == -1){
                        Vertex v0 = new Vertex();
                        u.next[0] = ++idx;
                        store.add(v0);
                        store.set(j,u);
                    }
                    j = u.next[0];
                    Vertex v0 = store.get(j);
                    v0.count++;
                    store.set(j,v0);
                    break;
            }
        }
    }

    private void erase(int x){
        int j = 0;
        for(int i=31; i>=0 ; i--){
            int b = (x>>i) & 1;
            Vertex u = store.get(j);
            switch (b){
                case 1:
                    j = u.next[1];
                    Vertex v1 = store.get(j);
                    v1.count--;
                    store.set(j,v1);
                    break;
                case 0:
                    j = u.next[0];
                    Vertex v0 = store.get(j);
                    v0.count--;
                    store.set(j,v0);
                    break;
            }
        }
    }

    private long query(int x){
        int j = 0;
        long ans = 0;
        for(int i=31; i>=0 ; i--){
            int b = (x>>i) & 1;
            Vertex u = store.get(j);
            j = u.next[b^1];
            Vertex v;
            if(j != -1){
                v = store.get(j);
                if(v.count == 0){
                    j = u.next[b];
                }else{
                    ans|= (1<<i);
                }
            }else{
                j = u.next[b];
            }
        }
        return ans;
    }

    private class Vertex{
        int[] next;
        int count;

        Vertex() {
            count = 0;
            next = new int[2];
            next[0] = -1;
            next[1] = -1;
        }
    }

    private void runIO() {
        in = new FastScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));
        solve();
        out.close();
    }

    private static class FastScanner {
        BufferedReader bufferedReader;
        StringTokenizer stringTokenizer;

        private FastScanner() {
            bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        }

        private String next() {
            if (stringTokenizer == null || !stringTokenizer.hasMoreElements()) {
                try {
                    stringTokenizer = new StringTokenizer(bufferedReader.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return stringTokenizer.nextToken();
        }

        private int nextInt() {
            return Integer.parseInt(next());
        }

        private long nextLong() {
            return Long.parseLong(next());
        }

        private String nextLine() {
            String ret = "";
            try {
                ret = bufferedReader.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return ret;
        }
    }

    public static void main(String[] args) {
        new CF367D().runIO();
    }
}
