//#pragma GCC optimize("Ofast")
//#pragma GCC optimize ("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#pragma warning(disable:4786)
#pragma warning(disable:4996)
#include <bits/stdc++.h>
#include  <random>
#include <chrono>
#include <unordered_set>
using namespace std;

#define MEM(a, b) memset(a, (b), sizeof(a))
#define CLR(a) memset(a, 0, sizeof(a))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define ABS(X) ( (X) > 0 ? (X) : ( -(X) ) )
#define S(X) ( (X) * (X) )
#define SZ(V) (int )V.size()
#define FORN(i, n) for(int i = 0; i < n; i++)
#define FORAB(i, a, b) for(int i = a; i <= b; i++)
#define ALL(V) V.begin(), V.end()
#define IN(A, B, C)  ((B) <= (A) && (A) <= (C))
#define AIN(A, B, C) assert(IN(A, B, C))

string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }

template <typename A>
string to_string(A v) {
    bool first = true;
    string res = "{";
    for (const auto& x : v) {
        if (!first) {
            res += ", ";
        }
        first = false;
        res += to_string(x);
    }
    res += "}";
    return res;
}

void dbg_out() { cerr << endl; }
template<typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) { cerr << ' ' << to_string(H); dbg_out(T...); }
#ifdef LOCAL
#define dbg(...) cerr << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)
#else
#define dbg(...) 0
#endif

typedef long long int LL;
//typedef __int128 LLL;
typedef long long LLL;


typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<LL, int> PLI;
typedef pair<double, double> PDD;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PLL> VPL;
typedef vector<PII> VP;
typedef vector<double> VD;
typedef vector<vector<int>> VVI;
typedef vector<vector<LL>> VVL;
typedef vector<string> VS;
typedef long double ld;
typedef unsigned long long ULL;

//#define MAXN 1000
//#define MAXN2 MAXN*MAXN

// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// mt19937 rng(10);
// shuffle(V.begin(), V.end(), rng);
// int u = rng();
// int u = uniform_int_distribution<long long>(L, R)(rng);
// double u = uniform_real_distribution<float>(L, R)(rng);

// int dr[] = {-1, 0, 1, 0, 1, 1, -1, -1};
// int dc[] = {0, 1, 0, -1, 1, -1, 1, -1};

const LL MOD = 1000000007;
//const LL MOD = 998244353;
// const LL INF = 2000000000000000001LL; //2e18 + 1

//typedef long long LL;
//typedef unsigned long long ULL;

set<int> S[300015];
int whr[300005];
// 0 = only one node without any computer
// 1 = n node with n - 1 computers but where unknown
// 2 = n node with n computers and all nodes have computer
int state[300015];
queue<int> free_sets;
char instr[10];

char query(int u) {
    int w = whr[u];
    return "0?1"[state[w]];
}

void remove(int u) {
    int w = whr[u];
    int s = state[w];

    if (s == 1) {
        int new_state = free_sets.front();
        free_sets.pop();
        S[new_state].insert(u);
        whr[u] = new_state;
        state[new_state] = 0;

        S[w].erase(u);
        assert(S[w].size() > 0);
        if (S[w].size() == 1) {
            state[w] = 0;
        }
        else {
            state[w] = 1;
        }
        return;
    }

    if (s == 2) {
        int new_state = free_sets.front();
        free_sets.pop();
        S[new_state].insert(u);
        whr[u] = new_state;
        state[new_state] = 0;

        S[w].erase(u);
        if (S[w].empty()) {
            free_sets.push(w);
            state[w] = 0;
        }
        return;
    }

    assert(0);
}

int transfer(int a, int b) {
    if (S[a].size() > S[b].size()) swap(a, b);
    for (int i : S[a]) {
        S[b].insert(i);
        whr[i] = b;
    }
    S[a].clear();
    free_sets.push(a);
    state[a] = 0;
    return b;
}

void add(int u, int v) {
    if (whr[u] == whr[v]) {
        assert(state[whr[u]] == 0 || state[whr[u]] == 1);
        state[whr[u]] = 2;
        return;
    }

    if (state[whr[u]] > state[whr[v]]) swap(u, v);

    int su = state[whr[u]];
    int sv = state[whr[v]];
    int p = transfer(whr[u], whr[v]);

    if (su == 0 && sv == 0) {
        state[p] = 1;
        return;
    }
    if (su == 0 && sv == 1) {
        state[p] = 1;
        return;
    }
    if (su == 0 && sv == 2) {
        state[p] = 2;
        return;
    }
    if (su == 1 && sv == 1) {
        state[p] = 1;
        return;
    }
    if (su == 1 && sv == 2) {
        state[p] = 2;
        return;
    }
    assert(0);
}

void solve(int ks) {
    int n, q;
    scanf("%d %d", &n, &q);
    for (int i = 1; i <= n; i++) {
        whr[i] = i;
        S[i].insert(i);
        state[i] = 0;
    }
    for (int i = n + 1; i <= n + 10; i++) {
        free_sets.push(i);
    }

    for (int i = 0; i < q; i++) {
        scanf("%s", instr);

        if (instr[0] == '?') {
            int u;
            scanf("%d", &u);

            printf("%c", query(u));
        }
        else if (instr[0] == '-') {
            int u;
            scanf("%d", &u);
            remove(u);
        }
        else if (instr[0] == '+') {
            int u, v;
            scanf("%d %d", &u, &v);
            add(u, v);
        }
    }
    printf("\n");
}

void gen() {
}

int main() {
    // ios_base::sync_with_stdio(false);
    // cin.tie(nullptr);

    double start_time = clock();
#ifdef LOCAL
    freopen("C:\\Home\\Contest\\sample.in", "r", stdin);
    //freopen("C:\\Home\\Contest\\0.out", "w", stdout);
#endif

    gen();

    if (0) {
        int T;
        scanf("%d", &T);
        for (int ks = 1; ks <= T; ks++) {
            solve(ks);
            if (ks % 100 == 0) fprintf(stderr, "%d done\n", ks);
            //double end_time = clock();
            //fprintf(stderr, "Time = %lf\n", (end_time - start_time) / CLOCKS_PER_SEC);
        }
    }
    else {
        solve(1);
    }

    double end_time = clock();
    fprintf(stderr, "Time = %lf\n", (end_time - start_time) / CLOCKS_PER_SEC);
    return 0;
}