#include<bits/stdc++.h>

using namespace std;

using ll = long long;
using ld = long double;
using ull = unsigned long long;

using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;

#define fi first
#define se second
#define pb push_back
#define pf push_front
#define mp make_pair
#define ins insert
#define btpc __builtin_popcount
#define btclz __builtin_clz

#define sz(x) (int)(x.size());
#define all(x) x.begin(), x.end()
#define debug(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

int d4x[4] = {1, 0, -1, 0}; int d4y[4] = {0, 1, 0, -1};
int d8x[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int d8y[8] = {1, 1, 0, -1, -1, -1, 0, 1};

template<class X, class Y>
    bool minimize(X &x, const Y &y) {
        if (x > y)
        {
            x = y;
            return true;
        }
        return false;
    }
template<class X, class Y>
    bool maximize(X &x, const Y &y) {
        if (x < y)
        {
            x = y;
            return true;
        }
        return false;
    }

const int MOD = 1e9 + 7; //998244353

template<class X, class Y>
    void add(X &x, const Y &y) {
        x = (x + y);
        if(x >= MOD) x -= MOD;
    }

template<class X, class Y>
    void sub(X &x, const Y &y) {
        x = (x - y);
        if(x < 0) x += MOD;
    }

/* Author : Le Ngoc Bao Anh, 12A5, LQD High School for Gifted Student*/

const ll INF = 1e9;
const int N = 1e5 + 10;

multiset<int> g[N], rev[N];
int pre[N], dist[N], is_change[N], inq[N], cnt[N];
vector<int> on_path[N];
pii ed[N];

void solve() {
    int n, m; cin >> n >> m;
    for(int i = 1; i <= m; i++) {
        int u, v; cin >> u >> v;
        g[u].ins(v);
        rev[v].ins(u);
        ed[i] = mp(u, v);
    }

    dist[1] = 0;
    for(int i = 2; i <= n; i++) dist[i] = INF;
    queue<int> q;
    q.push(1);

    while(!q.empty()) {
        int u = q.front(); q.pop();
        for(auto v : g[u]) {
            if(minimize(dist[v], dist[u] + 1)) cnt[v] = 1, q.push(v);
            else if(dist[v] == dist[u] + 1) cnt[v]++;
        }
    }

    int qu; cin >> qu;
    int last = 0;
    for(int _ = 1; _ <= qu; _++) {
        int t; cin >> t;
        if(t == 1) {
            int x; cin >> x;
            int id = (x + last) % m + 1;
            int u = ed[id].fi, v = ed[id].se;
            auto iter = g[u].find(v);
            g[u].erase(iter);
            iter = rev[v].find(u);
            rev[v].erase(iter);
            if(dist[u] + 1 == dist[v]) --cnt[v];
            if(cnt[v] > 0) continue;

            queue<int> q;
            q.push(v);

            vector<int> change;
            change.pb(v);
            is_change[v] = _;
            while(!q.empty()) {
                int u = q.front(); q.pop();
                for(auto v : g[u]) {
                    if(dist[u] + 1 == dist[v]) {
                        --cnt[v];
                        if(!cnt[v]) change.pb(v), is_change[v] = _, q.push(v);
                    }
                }
                dist[u] = INF;
            }


            vector<int> new_node;
            for(auto u : change) {
                pre[u] = 0;
                for(auto v : rev[u]) {
                    if(is_change[v] != _) {
                        if(minimize(dist[u], dist[v] + 1)) cnt[u] = 1;
                        else if(dist[u] == dist[v] + 1) cnt[u]++;
                    }
                }
                if(dist[u] < INF) new_node.pb(u);
            }

            sort(all(new_node), [&](int u, int v) {
                return dist[u] > dist[v];
            });

            while(q.size() || new_node.size()) {
                if(q.empty()) {
                    int d = dist[new_node.back()];
                    while(new_node.size() && dist[new_node.back()] <= d) {
                        int u = new_node.back();
                        if(inq[u] != _) q.push(u);
                        inq[u] = _;
                        new_node.pop_back();
                    }
                }

                while(!q.empty()) {
                    int u = q.front(); q.pop();
                    for(auto v : g[u]) {
                        if(minimize(dist[v], dist[u] + 1)) {
                            cnt[v] = 1, q.push(v), inq[v] = _;
                            while(!new_node.empty() && dist[new_node.back()] <= dist[v]) {
                                int u = new_node.back();
                                if(inq[u] != _) q.push(u);
                                inq[u] = _;
                                new_node.pop_back();
                            }
                        }
                        else if(dist[v] == dist[u] + 1) cnt[v]++;
                    }
                }
            }
        } else {
            int u; cin >> u;
            last = dist[u];
            if(last == INF) last = -1;
            cout << last << '\n';
        }
    }
}

int main()
{
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #else
    //online
    #endif

    int tc = 1, ddd = 0;
    // cin >> tc;
    while(tc--) {
        //ddd++;
        //cout << "Case #" << ddd << ": ";
        solve();
    }
}