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



from bisect import bisect_right
from collections import defaultdict
import os
import sys
from io import BytesIO, IOBase
from collections import defaultdict
BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")




def least_significant_bit(i):
    return ((i) & -(i))


class FenwickTree():
    def __init__(self, n):
        # 1-indexed
        self.n = n + 1
        self.data = [0, ] * self.n

    def add(self, index, value):
        # 1-indexed
        i = index + 1
        while i < self.n:
            self.data[i] += value
            i += least_significant_bit(i)

    def prefix_sum(self, index):
        # 1-indexed
        i = index + 1
        result = 0
        while i > 0:
            result += self.data[i]
            i -= least_significant_bit(i)
        return result

    def range_sum(self, start, end):
        return self.prefix_sum(end) - self.prefix_sum(start - 1)


















#TRIE

class Node:
    def __init__(self, value):
        self.parent = None
        self.val = value
        self.zero = None
        self.one = None
        self.marker = 0
        self.max_len = 0


root = Node(-1)


def insertnode(n):
    # print("Add", n)

    curr_node = root
    bitstr = bin(n)[2:].zfill(32)  # 32-bit string

    for bit in bitstr:
        if bit == "1":
            if curr_node.one == None:
                curr_node.one = Node(1)
                curr_node.one.parent = curr_node
            curr_node = curr_node.one
        else:
            if curr_node.zero == None:
                curr_node.zero = Node(0)
                curr_node.zero.parent = curr_node
            curr_node = curr_node.zero

    curr_node.marker += 1


def delete(n):
    # print("Remove", n)

    curr_node = root
    bitstr = bin(n)[2:].zfill(32)
    for bit in bitstr:
        if bit == "1":
            curr_node = curr_node.one
        else:
            curr_node = curr_node.zero

    curr_node.marker -= 1
    if curr_node.marker == 0:
        while curr_node.parent != None:
            if curr_node.one is None and curr_node.zero is None:
                if curr_node.val == 1:
                    curr_node.parent.one = None
                else:
                    curr_node.parent.zero = None
            curr_node = curr_node.parent


def find(n):
    # print("Query", n)

    bitstr = bin(n)[2:].zfill(32)
    curr_node = root
    result = []

    for bit in bitstr:

        b = int(bit)
        looking_for = 1 - b

        zero_present = curr_node.zero != None
        one_present = curr_node.one != None

        if looking_for == 0 and zero_present:
            curr_node = curr_node.zero
            result.append("1")

        elif looking_for == 1 and one_present:
            curr_node = curr_node.one
            result.append("1")

        elif looking_for == 0 and one_present:
            curr_node = curr_node.one
            result.append("0")
        else:
            curr_node = curr_node.zero
            result.append("0")

    return int("".join(result), 2)


insertnode(0)

y=int(input())

for j in range(y):
    b=list(map(str,input().split()))
    if b[0]=="+":
        insertnode(int(b[1]))

    elif b[0]=="-":
        delete(int(b[1]))

    else:
        print(find(int(b[1])))










