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 sys import stdin


def fast2():
    import os, sys, atexit
    range = xrange
    from cStringIO import StringIO as BytesIO
    sys.stdout = BytesIO()
    atexit.register(lambda: os.write(1, sys.stdout.getvalue()))
    return BytesIO(os.read(0, os.fstat(0).st_size)).readline


class Trie:
    def __init__(self, be, size):
        self.root = [[-1, -1, 0, 0]]
        self.be, self.size = ord(be), size

    def mapper(self, ch):
        return ord(ch) - self.be

    def insert(self, key):
        cur = 0

        for i in range(len(key)):
            ix = self.mapper(key[i])

            if self.root[cur][ix] == -1:
                self.root[cur][ix] = len(self.root)
                self.root.append([-1, -1, 0, 0])

            cur = self.root[cur][ix]
            self.root[cur][-1] += 1

        self.root[cur][-2] += 1

    def search(self, key):
        cur, ans = 0, ''

        for i in range(len(key)):
            ix = self.mapper(key[i])

            if self.root[cur][ix] == -1 or self.root[self.root[cur][ix]][-1] == 0:
                ix ^= 1

            cur = self.root[cur][ix]
            ans += str(ix)

        return ans

    def delete(self, key):
        cur = 0

        for i in range(len(key)):
            ix = self.mapper(key[i])
            cur = self.root[cur][ix]
            self.root[cur][-1] -= 1


input = fast2()
rstrs = lambda: [str(x) for x in input().split()]
trie, out = Trie('0', 2), []
trie.insert('0' * 30)

for _ in range(int(input())):
    sign, n = rstrs()
    n = int(n)
    ele = '0' * (30 - n.bit_length()) + bin(n)[2:]

    if sign == '+':
        trie.insert(ele)

    elif sign == '-':
        trie.delete(ele)

    else:
        new = ''
        for j in ele:
            new += str(int(j) ^ 1)

        out.append(int(trie.search(new), 2) ^ int(ele, 2))

print('\n'.join(map(str, out)))
