#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;

const int mod = 1e9 + 7, N = 1e5 + 5;
const int half = (mod + 1) / 2;

int iadd(int x, int y) {
    return x + y >= mod ? x + y - mod : x + y;
}

void add(int &x, int y) {
    x += y;
    if (x >= mod) x -= mod;
}

int mul(int x, int y) {
    return 1ll * x * y % mod;
}

pii operator+(pii p, int x) {
    p.first += x;
    return p;
}

struct Count {
    int dis, cnt;
    Count() : dis(-N), cnt(0) {}
    Count(int dis, int cnt) : dis(dis), cnt(cnt) {}
    Count operator+(Count x) const {
        if (dis == x.dis) return Count(dis, iadd(cnt, x.cnt));
        if (dis < x.dis) return x;
        return *this;
    }
    void operator+=(Count x) {
        *this = *this + x;
    }
    Count operator+(int x) const {
        return Count(dis + x, cnt);
    }
    Count operator*(Count x) const {
        if (dis == x.dis) return Count(dis, mul(cnt, x.cnt));
        return Count(-1, 0);
    }
    Count operator*(int x) const {
        return Count(dis, mul(x, cnt));
    }
    Count sq() const {
        return Count(dis, mul(cnt, cnt));
    }
};

struct Dist  {
    int cnt, ver;
    Count sum, one, ans;
    pii far;
    Dist() : cnt(0), ver(-1), sum(), one(), ans(), far(-N, -1) {}
    Dist(int x) : cnt(1), ver(x), sum(0, 1), one(0, 1), ans(0, 1), far(0, x) {}
    void merge(Dist L, Dist R, pii Cfar, Count Csum, Count Cans) {
        Count rcsum = Count(L.cnt, 1) + (R.sum + Csum + (L.cnt + 1));
        cnt = L.cnt + 1 + R.cnt;
        sum = L.sum + rcsum;
        one = L.one + (R.one + (L.cnt + 1)) + rcsum * (L.cnt + 1);
        ans = L.ans + (R.ans + Cans + (L.cnt + 1)) + L.one * rcsum * 2 + rcsum.sq() * (L.cnt + 1);
        far = max(max(L.far, max(R.far, Cfar) + (L.cnt + 1)), pii(L.cnt, ver));
    }
};

struct node {
    int l, r, p, rev;
    Dist ldis, rdis;
    map<int, int> psum, pans, r1, r2, s2;
    set<pii> pfar;
    node() {}
    node(int x) : l(0), r(0), p(0), rev(0), ldis(x), rdis(x) {}
} ns[N];

void lazy(int x) {
    if (!ns[x].rev) return;
    ns[x].rev = 0;
    if (ns[x].l) {
        ns[ns[x].l].rev ^= 1;
        swap(ns[ns[x].l].ldis, ns[ns[x].l].rdis);
        swap(ns[ns[x].l].l, ns[ns[x].l].r);
    }
    if (ns[x].r) {
        ns[ns[x].r].rev ^= 1;
        swap(ns[ns[x].r].ldis, ns[ns[x].r].rdis);
        swap(ns[ns[x].r].l, ns[ns[x].r].r);
    }
}

void update(int x) {
    int l = ns[x].l, r = ns[x].r;
    pii Cfar = pii(-N, -1);
    Count Csum = Count(-1, 0), Cans = Count(-1, 0);
    if (!ns[x].pfar.empty()) {
        Cfar = *ns[x].pfar.rbegin();
        int dis = Cfar.first;
        Csum = Count(dis, ns[x].psum[dis]);
        Cans = Count(dis, ns[x].pans[dis]);
    }
    ns[x].ldis.merge(ns[l].ldis, ns[r].ldis, Cfar, Csum, Cans);
    ns[x].rdis.merge(ns[r].rdis, ns[l].rdis, Cfar, Csum, Cans);
}

void erase_map(int x) {
    if (!x) return;
    int p = ns[x].p;
    if (!p) return;
    int dis = ns[x].ldis.far.first;
    ns[p].pfar.erase(ns[x].ldis.far);
    add(ns[p].psum[dis], mod - ns[x].ldis.sum.cnt);
    add(ns[p].pans[dis], mod - ns[x].ldis.ans.cnt);
    add(ns[p].r1[dis], mod - mul(ns[x].ldis.ans.cnt, ns[x].ldis.sum.cnt));
    add(ns[p].r2[dis], mod - mul(ns[x].ldis.ans.cnt, mul(ns[x].ldis.sum.cnt, ns[x].ldis.sum.cnt)));
    add(ns[p].s2[dis], mod - mul(ns[x].ldis.sum.cnt, ns[x].ldis.sum.cnt));
}

void insert_map(int x) {
    if (!x) return;
    int p = ns[x].p;
    if (!p) return;
    int dis = ns[x].ldis.far.first;
    ns[p].pfar.insert(ns[x].ldis.far);
    add(ns[p].psum[dis], ns[x].ldis.sum.cnt);
    add(ns[p].pans[dis], ns[x].ldis.ans.cnt);
    add(ns[p].r1[dis], mul(ns[x].ldis.ans.cnt, ns[x].ldis.sum.cnt));
    add(ns[p].r2[dis], mul(ns[x].ldis.ans.cnt, mul(ns[x].ldis.sum.cnt, ns[x].ldis.sum.cnt)));
    add(ns[p].s2[dis], mul(ns[x].ldis.sum.cnt, ns[x].ldis.sum.cnt));
}

bool is_root(int x) {
    return ns[x].p == 0 || ns[ns[x].p].l != x && ns[ns[x].p].r != x;
}

void rotate(int x) {
    int p = ns[x].p;
    if (ns[p].l == x) {
        ns[p].l = ns[x].r;
        if (ns[p].l) ns[ns[p].l].p = p;
        ns[x].r = p;
    }
    else {
        ns[p].r = ns[x].l;
        if (ns[p].r) ns[ns[p].r].p = p;
        ns[x].l = p;
    }
    ns[x].p = ns[p].p;
    ns[p].p = x;
    if (ns[x].p) {
        if (ns[ns[x].p].l == p) ns[ns[x].p].l = x;
        else if (ns[ns[x].p].r == p) ns[ns[x].p].r = x;
    }
    update(p);
    update(x);
}

void splay(int x) {
    while (!is_root(x)) {
        int p = ns[x].p;
        int g = ns[p].p;
        if (!is_root(p)) {
            if ((ns[g].l == p) == (ns[p].l == x)) rotate(p);
            else rotate(x);
        }
        rotate(x);
    }
}

int access(int x) {
    vector<int> vt;
    for (int i = x; ns[i].p; i = ns[i].p) vt.push_back(i);
    reverse(vt.begin(), vt.end());
    for (int i : vt) {
        lazy(ns[i].p);
        if (is_root(i)) erase_map(i);
    }
    lazy(x);
    splay(x);
    insert_map(ns[x].r);
    ns[x].r = 0;
    update(x);

    int ret = x;
    while (ns[x].p) {
        ret = ns[x].p;
        splay(ret);
        insert_map(ns[ret].r);
        ns[ret].r = x;
        update(ret);
        splay(x);
    }
    return ret;
}

void make_root(int x) {
    access(x);
    ns[x].rev = 1;
    swap(ns[x].l, ns[x].r);
    swap(ns[x].ldis, ns[x].rdis);
    lazy(x);
}

void link(int p, int x) {
    make_root(x);
    access(p);
    ns[x].l = p;
    ns[p].p = x;
    update(x);
}

void cut(int x, int y) {
    make_root(y);
    access(x);
    ns[ns[x].l].p = 0;
    ns[x].l = 0;
    update(x);
}

int kth(int r, int k) {
    while (1) {
        int lcnt = ns[r].l ? ns[ns[r].l].ldis.cnt : 0;
        if (k == lcnt) return r;
        if (k < lcnt) r = ns[r].l;
        else k -= lcnt + 1, r = ns[r].r;
        lazy(r);
    }
}

int solve(int r) {
    make_root(r);
    int y = ns[r].ldis.far.second;
    make_root(y);
    auto [d, x] = ns[y].ldis.far;
    access(x);
    int ans = 0;
    if (d % 2) {
        int a = kth(x, d / 2);
        int b = kth(x, d / 2 + 1);
        d /= 2;
        cut(a, b);
        add(ans, mul(ns[a].ldis.ans.cnt, mul(ns[b].ldis.sum.cnt, ns[b].ldis.sum.cnt)));
        add(ans, mul(ns[b].ldis.ans.cnt, mul(ns[a].ldis.sum.cnt, ns[a].ldis.sum.cnt)));
        link(a, b);
    }
    else {
        int c = kth(x, d /= 2);
        make_root(c);
        access(c);
        int pans = ns[c].pans[d - 1], psum = ns[c].psum[d - 1];
        add(ans, mul(pans, mul(psum, psum)));
        add(ans, mod - mul(2, mul(ns[c].r1[d - 1], psum)));
        add(ans, ns[c].r2[d - 1]);
        psum = mul(psum, psum);
        add(psum, mod - ns[c].s2[d - 1]);
        psum = mul(half, psum);
        add(ans, mul(psum, psum));
    }
    return ans;
}

int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);int n, m, q;
    cin >> n >> m >> q;
    for (int i = 1; i <= n; ++i) ns[i] = node(i);
    for (int i = 1; i <= m; ++i) {
        int x, y;
        cin >> x >> y;
        link(x, y);
    }
    while (q--) {
        int t;
        cin >> t;
        if (t == 3) {
            int r;
            cin >> r;
            printf("%d\n", solve(r));
            continue;
        }
        int x, y;
        cin >> x >> y;
        if (t == 1) link(x, y);
        else cut(x, y);
    }
    return 0;
}