//Make CSP great again
//Vengeance
#include <bits/stdc++.h>
#define TASK "TESTCODE"
using namespace std;
const int N = 1e5, block = 310;
bool del[N + 1];
struct controller
{
    int sum[(N + block - 1)/block + 1];
    int cur[N + 1], total;
    controller()
    {
        memset(sum, 0, sizeof(sum));
        memset(cur, 0, sizeof(cur));
        total = 0;
    }
    void toggle(int i)
    {
        if (del[i])
        {
            return ;
        }
        int b = (i + block - 1)/block;
        if (cur[i])
        {
            cur[i] = 0;
            --total;
            --sum[b];
        }
        else
        {
            cur[i] = 1;
            ++total;
            ++sum[b];
        }
    }
    int ans()
    {
        if (total == 0)
        {
            return 0;
        }
        for (int l = 1, b = 1; l <= N; l += block, ++ b)
        {
            if (sum[b] == 0)
            {
                continue;
            }
            for (int r = l; r <= min(N, l + block - 1); ++ r)
            {
                if (cur[r])
                {
                    return r;
                }
            }
            assert(false);
        }
    }
};
int x[N + 1], y[N + 1];
vector<int> adj[N + 1];
int n, m;
vector<int> big;
controller s, b[2][(N + block - 1)/block + 1];
bool in_v[N + 1];
int indx[N + 1];
void read()
{
    cin >> n >> m;
    for (int i = 1; i <= m; ++ i)
    {
        int u, v;
        cin >> u >> v;
        x[i] = u;
        y[i] = v;
        adj[u].push_back(i);
        adj[v].push_back(i);
    }
}
void solve()
{
    for (int u = 1, id = 0; u <= n; ++ u)
    {
        if (adj[u].size() > block)
        {
            indx[u] = id;
            big.push_back(u);
            vector<int> t1, t2;
            for (int i : adj[u])
            {
                int v = x[i] ^ y[i] ^ u;
                b[1][id].toggle(i);
                if (adj[v].size() > block)
                {
                    t1.push_back(i);
                }
                else
                {
                    t2.push_back(i);
                }
            }
            adj[u].clear();
            adj[u].insert(end(adj[u]), begin(t1), end(t1));
            adj[u].insert(end(adj[u]), begin(t2), end(t2));
            // sort big child first
            ++id;
        }
    }
    int q;
    cin >> q;
    while(q--)
    {
        char c;
        cin >> c;
        if (c != '?')
        {
            int u;
            cin >> u;
            if (adj[u].size() <= block) // small
            {
                for (int i : adj[u])
                {
                    int v = x[i] ^ y[i] ^ u;
                    if (adj[v].size() <= block) // small - small
                    {
                        s.toggle(i);
                    }
                    else // big - small
                    {
                        int id_v = indx[v];
                        b[0][id_v].toggle(i);
                        b[1][id_v].toggle(i);
                    }
                }
            }
            else //big
            {
                for (int i : adj[u])
                {
                    int v = x[i] ^ y[i] ^ u;
                    if (adj[v].size() <= block) // at most sqrt big child
                    {
                        break;
                    }
                    int id_v = indx[v];
                    b[0][id_v].toggle(i);
                    b[1][id_v].toggle(i);
                }
            }
            in_v[u] ^= 1;
        }
        else
        {
            int res = s.ans();
            if (res != 0)
            {
                s.toggle(res);
                del[res] = true;
                cout << res << '\n';
                continue;
            }
            for (int u : big)
            {
                int id_u = indx[u], cur_u = in_v[u];
                res = b[cur_u][id_u].ans();
                if (res != 0)
                {
                    int v = x[res] ^ y[res] ^ u;
                    assert(in_v[v] != in_v[u]);


                    b[cur_u][id_u].toggle(res);
                    if (adj[v].size() > block)
                    {
                        int id_v = indx[v], cur_v = in_v[v];
                        b[cur_v][id_v].toggle(res);
                    }
                    del[res] = true;
                    break;
                }
            }
            cout << res << '\n';
        }
    }
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    if (fopen(TASK".INP", "r"))
    {
        freopen(TASK".INP", "r", stdin);
        //freopen(TASK".OUT", "w", stdout);
    }
    int t = 1;
    bool typetest = false;
    if (typetest)
    {
        cin >> t;
    }
    for (int __ = 1; __ <= t; ++ __)
    {
        //cout << "Case " << __ << ": ";
        read();
        solve();
    }
}