#include <bits/stdc++.h>
using namespace std;

#define F first
#define S second
#define ar array
typedef int uci;
#define int long long
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

void solve(){
    int n, m;
    cin >> n >> m;

    vector<int> deg(n);
    vector<int> lbig;
    vector<int> big(n, -1);
    vector<int> state(n);
    vector<vector<set<ar<int, 2>>>> sides(2);
    vector<unordered_map<int, int>> adj(n);
    for(int i{}; i < m; ++i){
        int u, v;
        cin >> u >> v;
        u--, v--;

        adj[u][v] = i+1;
        adj[v][u] = i+1;
        deg[u]++, deg[v]++;
    }

    int sq = sqrt(n);
    for(int i{}; i < n; ++i){
        if(deg[i] >= sq){
            big[i] = sides[0].size();
            lbig.push_back(i);
            sides[0].push_back({});
            for(auto t : adj[i]){
                sides[0].back().insert({t.F, t.S});
            }
            sides[1].push_back({});
        }
    }

    int q;
    cin >> q;

    vector<unordered_map<int, int>> bigadj(n);
    for(int i : lbig){
        vector<int> te;
        for(auto &t : adj[i]){
            bigadj[t.F][i] = t.S;
            bigadj[i][t.F] = t.S;
            te.push_back(t.F);
        }
        for(auto &t : te){
            adj[t].erase(i);
            adj[i].erase(t);
        }
    }

    set<ar<int, 3>> gv;
    for(int i{}; i < q; ++i){
        char c;
        cin >> c;
        if(c == '+' || c == '-'){
            int v;
            cin >> v;
            v--;

            state[v] = 1-state[v];
            for(auto &t : bigadj[v]){
                sides[1-state[v]][big[t.F]].erase({v, t.S});
                sides[state[v]][big[t.F]].insert({v, t.S});
            }
            for(auto [i, c] : adj[v]){
                if(state[i] != state[v]){
                    gv.insert({min(i, v), max(i, v), c});
                }else{
                    gv.erase({min(i, v), max(i, v), c});
                }
            }
        }else{
            if(gv.size()){
                auto v = *gv.begin();
                gv.erase(gv.begin());
                cout << v[2] << '\n';
                adj[v[0]].erase(v[1]);
                adj[v[1]].erase(v[0]);
            }else{
                bool found = false;
                for(auto &t : lbig){
                    int st = 1-state[t];
                    int ind = big[t];
                    if(sides[st][ind].size()){
                        auto a = *sides[st][ind].begin();
                        sides[st][ind].erase(sides[st][ind].begin());
                        if(big[a[0]] != -1){
                            sides[state[t]][big[a[0]]].erase({t, a[1]});
                        }

                        cout << a[1] << '\n';
                        found = true;
                        bigadj[a[0]].erase(t);
                        bigadj[t].erase(a[0]);
                        break;
                    }
                }
                if(!found){
                    cout << 0 << '\n';
                }
            }
        }
    }
}

uci main(){
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    solve();
}