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.*;

/**
 * Created by jianing on 2016/7/15.
 */
public class Main {

    public static final int S = 30;

    public static class Node {
        Node l=null, r=null;
        int count = 0;
    }

    public static final Node root = new Node();

    public static void add(int x) {
        Node n = root;
        for(int i=S;i>=0;--i) {
            n.count++;
            if((x & (1<<i))==0) {
                if(n.l==null) {
                    n.l = new Node();
                }
                n = n.l;
            }
            else {
                if(n.r==null) {
                    n.r = new Node();
                }
                n = n.r;
            }
        }
        n.count++;
    }

    public static void remove(int x) {
        Node n = root;
        for(int i=S;i>=0;--i) {
            if((x & (1<<i))==0) {
                if(n.l==null) return ;
                n = n.l;
            }
            else {
                if(n.r==null) return ;
                n = n.r;
            }
        }
        n = root;
        for(int i=S;i>=0;--i) {
            n.count--;
            if((x & (1<<i))==0) {
                if(n.l.count==1) {
                    n.l = null;
                    return ;
                }
                n = n.l;
            }
            else {
                if(n.r.count==1) {
                    n.r = null;
                    return ;
                }
                n = n.r;
            }
        }
        n.count--;
    }

    public static int query(int x) {
        Node n = root;
        int y = 0;
        for(int i=S;i>=0;--i) {
            if((x & (1<<i))==0) {
                if(n.r!=null) {
                    n = n.r;
                    y = y | (1<<i);
                }
                else {
                    n = n.l;
                }
            }
            else {
                if(n.l!=null) {
                    n = n.l;
                }
                else {
                    n = n.r;
                    y = y | (1<<i);
                }
            }
        }
        return y ^ x;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        add(0);
        int n = sc.nextInt();
        for(int i=0;i<n;++i) {
            String sym = sc.next();
            int x = sc.nextInt();
            if("+".equals(sym)) {
                add(x);
            }
            else if("-".equals(sym)) {
                remove(x);
            }
            else {
                System.out.println(query(x));
            }
        }
    }

}


/*
10
+ 8
+ 9
+ 11
+ 6
+ 1
? 3
- 8
? 3
? 8
? 11


 */
