#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);
    map<int, int> big;
    vector<int> state(n);
    vector<vector<set<ar<int, 2>>>> sides(2);
    vector<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();
            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;

    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 : big){
                if(t.F == v || !adj[v].count(t.F))
                    continue;
                sides[1-state[v]][t.S].erase({v, adj[v][t.F]});
                sides[state[v]][t.S].insert({v, adj[v][t.F]});
            }
            /*
            cout << "adding or subing " << v << '\n';
            for(auto &t : big){
                cout << t.F << '\n';

                for(int i{}; i < 2; ++i){
                    cout << "in side " << i << '\n';
                    for(auto &t : sides[i][t.S]){
                        cout << t[0] << ':' << t[1] << ' ';
                    }
                    cout << '\n';
                }
            }
            */
            if(!big.count(v)){
                for(auto [i, c] : adj[v]){
                    if(!big.count(i)){
                        if(sides[i] != sides[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 : big){
                    if(sides[1-state[t.F]][t.S].size()){
                        auto a = *sides[1-state[t.F]][t.S].begin();
                        sides[1-state[t.F]][t.S].erase(sides[1-state[t.F]][t.S].begin());
                        if(big.count(a[0])){
                            sides[1-state[a[0]]][big[a[0]]].erase({t.F, a[1]});
                        }else{
                            adj[a[0]].erase(t.F);
                        }

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

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

    solve();
}