#include<bits/stdc++.h>
#define ll long long
#define eps 1e-7
#define inf 1e9
#define linf 1e18
#define pb push_back
#define mod 1e9 + 7
#define mp make_pair
#define ld long double
#define pi 3.141592653589793238462643
using namespace std;

ll null = 0;

struct segment;
struct line;
struct point;
struct vec;
struct ray;

struct point{
    ld x, y;
    point(){}
    point(ld x1, ld y1){
        x = x1;
        y = y1;
    }
    ld dist_to_point(point p){
        return sqrt((p.x - x) * (p.x - x) + (p.y - y) * (p.y - y));
    }
    bool operator < (point p){
        return (x < p.x) || ((x == p.x) && (y < p.y));
    }
};

struct vec{
    ld x, y;
    vec (ld x1, ld y1){
        x = x1;
        y = y1;
    }
    vec (point a, point b){
        x = b.x - a.x;
        y = b.y - a.y;
    }
    vec normal(){
        vec ans;
        ans.x = y;
        ans.y = -x;
        return ans;
    }
    vec opposite(){
        vec ans;
        ans.x = -x;
        ans.y = -y;
        return ans;
    }
    vec sum(vec b){
        vec ans;
        ans.x = x + b.x;
        ans.y = y + b.y;
        return ans;
    }
    ld cross_product(vec v){
        return x * v.y - v.x * y;
    }
    ld dot_product(vec v){
        return x * v.x + y * v.y;
    }
    vec resize(ld size){
        vec ans;
        ans.x = (x * size) / len();
        ans.y = (y * size) / len();
        return ans;
    }
    vec(){}
    ld len(){
        return sqrt(x * x + y * y);
    }
};


struct line{
    ld a, b, c;
    line (point a1, point b1){
        a = a1.y - b1.y;
        b = b1.x - a1.x;
        c = -a1.x * a - a1.y * b;
    }
    line (ld a1, ld b1, ld c1){
        a = a1;
        b = b1;
        c = c1;
    }
    line(){}
    vec normal_vec(){
        vec ans;
        ans.x = a;
        ans.y = b;
        return ans;
    }
    line normal_line(point p){
        line ans;
        ans.a = -b;
        ans.b = a;
        ans.c = -ans.a * p.x - ans.b * p.y;
        return ans;
    }
    ld get_x(ld y1){
        if (a == 0) return 0;
        return (-c - b * y1) / a;
    }
    ld get_y(ld x1){
        if (b == 0) return 0;
        return (-c - a * x1) / b;
    }
    point intersection(line l){
        point ans;
        ans.x = (-c * l.b + l.c * b) / (a * l.b - l.a * b);
        ans.y = (-a * l.c + l.a * c) / (a * l.b - l.a * b);
        return ans;
    }
    ld dist_to_point(point p){
        return abs((a * p.x + b * p.y + c) / (sqrt(a * a + b * b)));
    }
    ll is_inside(point p){
        ld k = a * p.x + b * p.y + c;
        if (k < 0) return -1;
        else if (k == 0) return 0;
        return 1;
    }
};

struct segment{
    point a, b;
    segment(){}
    segment(point a1, point b1){
        a = a1;
        b = b1;
    }
    ld len(){
        return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
    }
    bool is_inside(point p){
        line l(a, b);
        if (l.is_inside(p) != 0) return false;
        vec v(p, a), v1(p, b);
        if (v.dot_product(v1) > 0) return false;
        return true;
    }
    long double dist_to_point(point p){
        vec v(a, p), v1(a, b), v2(b, p), v3(b, a);
        if (v.dot_product(v1) < 0) return p.dist_to_point(a);
        if (v2.dot_product(v3) < 0) return p.dist_to_point(b);
        line l(a, b);
        return l.dist_to_point(p);
    }
    point get_center(){
        point ans;
        ans.x = (a.x + b.x) / 2;
        ans.y = (a.y + b.y) / 2;
        return ans;
    }
};

struct ray{
    point a, b;
    ray(point p, point p1){
        a = p;
        b = p1;
    }
    ray(){}
    ld dist_to_point(point p){
        vec v(a, p), v1(a, b);
        if (v.dot_product(v1) < 0) return a.dist_to_point(p);
        line l(a, b);
        return l.dist_to_point(p);
    }
    bool is_inside(point p){
        line l(a, b);
        if (l.is_inside(p) != 0) return false;
        vec v(a, p), v1(a, b);
        if (v.dot_product(v1) < 0) return false;
        return true;
    }
};

struct angle{
    point a, b, c;
    angle(){};
    angle (point a1, point b1, point c1){
        a = a1;
        b = b1;
        c = c1;
    }
    ld get_angle(){
        vec v(b, a), v1(b, c);
        cout<<v.dot_product(v1)<<" "<<v.len()<<" "<<v1.len()<<endl;
        return acos(v.dot_product(v1) / (v.len() * v1.len()));
    }
};

struct polygon{
    ll n;
    vector <point> points;
    ld get_area(){
        point a(0, 0);
        vec v(a, points[0]);
        ld ans = 0;
        for (ll i = 1; i < n; ++i){
            vec v1(a, points[i]);
            ans = ans + v.cross_product(v1);
            v = v1;
        }
        vec v2(a, points[0]);
        vec v1(a, points[n - 1]);
        return abs(ans + v1.cross_product(v2)) / 2;
    }
};

struct triangle{
    point a, b, c;
    triangle(){}
    triangle(point a1, point b1, point c1){
        a = a1;
        b = b1;
        c = c1;
    }
    ld get_area(){
        point d(0, 0);
        vec v(a, d), v1(b, d), v2(c, d);
        return (v.cross_product(v1) + v1.cross_product(v2) + v2.cross_product(v)) / 2;
    }
    point get_center(){
        segment s(a, b), s1(a, c);
        point p = s.get_center(), p1 = s1.get_center();
        line l(a, b), l1(a, c), l2(b, c);
        l = l.normal_line(p);
        l1 = l1.normal_line(p1);
        return l.intersection(l1);
    }
    ld get_R(){
        triangle t(a, b, c);
        point p = t.get_center();
        return p.dist_to_point(a);
    }
};

ll power(ll a, ll b){
    if (b == 0) return 1;
    else if (b == 1) return a;
    else {
        ll k = power(a, b / 2);
        return k * k * power(a, b % 2);
    }
}

ll power_mod(ll a, ll b, ll MOD){
    if (b == 0) return 1;
    else if (b == 1) return a % MOD;
    else{
        ll k = power_mod(a, b / 2, MOD);
        return ((k * k) % MOD * power_mod(a, b % 2, MOD)) % MOD;
    }
}

ll sum_mod(ll a, ll b, ll MOD){
    return (a + b) % MOD;
}

ll mul_mod(ll a, ll b, ll MOD){
    return (a * b) % MOD;
}

ll ord(char a){
    return a;
}

char chr(ll a){
    return a;
}

ll strtoint(string s){
    ll ans = 0;
    for (ll i = 0; i < s.size(); ++i){
        ans *= 10;
        ans += ord(s[i]) - 48;
    }
    return ans;
}

string rev_string(string s){
    string ans = "";
    for (ll i = s.size(); i >= 0; --i){
        ans += s[i];
    }
    return ans;
}

string inttostr(ll a){
    string ans = "", ans1 = "";
    while (a > 0){
        ans += chr(a + 48);
        a /= 10;
    }
    for (ll i = ans.size() - 1; i >= 0; --i){
        ans1 += ans[i];
    }
    return ans1;
}

/*
_________________________________________________________________________________________________________________________________________________
start programm
_________________________________________________________________________________________________________________________________________________
*/

#define len 26000

struct bor{
    vector <vector <ll> > ar;
    ll arr[len];
    ll n;
    bor(){
        ar.resize(len);
        for (ll i = 0; i < len; ++i){
            ar[i].resize(2);
            ar[i][0] = -1;
            ar[i][1] = -1;
            arr[i] = 0;
        }
        n = 0;
    }
    void add(ll x){
        vector <bool> ar1;
        for (ll i = 0; i < 30; ++i){
            ar1.pb(x % 2 == 0);
            x /= 2;
        }
        ll k = 0;
        for (ll i = ar1.size(); i >= 0; --i){
            ++arr[k];
            if (ar[k][ar1[i]] == -1){
                ++n;
                if (n >= len) cout<<"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, HELP"<<endl;
                ar[k][ar1[i]] = n;
                k = n;
            }
            else k = ar[k][ar1[i]];
        }
        ++arr[k];
    }
    void del(ll x){
        vector <bool> ar1;
        for (ll i = 0; i < 30; ++i){
            ar1.pb(x % 2 == 0);
            x /= 2;
        }
        ll k = 0, t = -1, p = -1;
        for (ll i = ar1.size(); i >= 0; --i){
            --arr[k];
            if ((arr[k] == 0) && (t != -1)){
                //cout<<"OMAGAOMAGA"<<endl;
                ar[t][p] = -1;
            }
            t = k;
            p = ar1[i];
            k = ar[k][ar1[i]];
        }
        if ((arr[k] == 0) && (t != -1)){
            //cout<<"OMAGAOMAGA1"<<endl;
            ar[t][p] = -1;
        }
    }
    ll get(ll x){
        vector <pair<bool, ll> > ar1;
        ll f = 1;
        for (ll i = 0; i < 30; ++i){
            ar1.pb(mp((x % 2 == 0), f));
            f *= 2;
            x /= 2;
        }
        ll k = 0, ans = 0;
        for (ll i = ar1.size(); i >= 0; --i){
            ll a = (!ar1[i].first);
            //cout<<ar[k][0]<<" "<<ar[k][1]<<endl;
            if (ar[k][a] == -1) k = ar[k][ar1[i].first];
            else{
                ans += ar1[i].second;
                k = ar[k][a];
            }
        }
        return ans;
    }
};


int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    srand(time(0));
    ll q;
    cin>>q;
    bor s;
    for (ll i = 0; i < q; ++i){
        char c;
        ll a;
        cin>>c>>a;
        if (c == '+') s.add(a);
        else if (c == '-') s.del(a);
        else cout<<s.get(a)<<endl;
    }
}