struct DSUTree{
    int n;
    vector<int> parent;
    vector<int> repr;        // repr[u] = nút hiện tại của component chứa u
    vector<vector<int>> tree;
    int counter;

    DSUTree(int n, int m) : n(n), parent(n + 1, -1), repr(n + 1), tree(n + m + 1), counter(n)
    {
        iota(repr.begin(), repr.end(), 0); // repr[u] = u
    }

    int Find(int u){
        while(parent[u] >= 0) u = parent[u];
        return u;
    }

    bool Union(int u, int v){
        u = Find(u);
        v = Find(v);

        if(u == v){
            // tree[++counter].push_back(repr[u]);
            // repr[u] = counter;
            return false;
        }

        if (parent[u] > parent[v]) swap(u, v);

        parent[u] += parent[v];
        parent[v] = u;

        int newNode = ++counter;

        // gắn hai repr cũ vào làm con
        tree[newNode].push_back(repr[u]);
        tree[newNode].push_back(repr[v]);

        repr[u] = newNode;

        return true;
    }
};

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

struct DSU {
    vector<int> parent;
    vector<set<int>> nodes;

    DSU(int n) {
        parent.resize(n + 1);
        nodes.resize(n + 1);
        for (int i = 1; i <= n; i++) {
            parent[i] = i;
            nodes[i].insert(i);
        }
    }

    int find(int x) {
        if (parent[x] == x) return x;
        return parent[x] = find(parent[x]);
    }

    bool unite(int a, int b, int edge_id, vector<int>& w) {
        a = find(a);
        b = find(b);
        if (a == b) return false;

        if (nodes[a].size() < nodes[b].size())
            swap(a, b);

        for (int x : nodes[b]) {
            if (nodes[a].count(x - 1)) {
                if (w[x] == -1)
                    w[x] = edge_id;
            }
            if (nodes[a].count(x + 1)) {
                if (w[x + 1] == -1)
                    w[x + 1] = edge_id;
            }
            nodes[a].insert(x);
        }

        nodes[b].clear();
        parent[b] = a;
        return true;
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int t;
    cin >> t;
    while (t--) {
        int n, m, q;
        cin >> n >> m >> q;

        vector<pair<int,int>> edges(m + 1);
        for (int i = 1; i <= m; i++) {
            cin >> edges[i].first >> edges[i].second;
        }

        vector<int> w(n + 2, -1);
        w[1] = 0;

        DSU dsu(n);

        for (int i = 1; i <= m; i++) {
            dsu.unite(edges[i].first, edges[i].second, i, w);
        }

        for (int i = 2; i <= n; i++) {
            if (w[i] == -1) w[i] = 0;
        }

        int LOG = log2(n) + 1;
        vector<vector<int>> st(LOG, vector<int>(n + 1));
        for (int i = 1; i <= n; i++) st[0][i] = w[i];

        for (int k = 1; k < LOG; k++) {
            for (int i = 1; i + (1 << k) - 1 <= n; i++) {
                st[k][i] = max(st[k - 1][i],
                               st[k - 1][i + (1 << (k - 1))]);
            }
        }

        auto getMax = [&](int l, int r) {
            if (l > r) return 0;
            int len = r - l + 1;
            int k = log2(len);
            return max(st[k][l], st[k][r - (1 << k) + 1]);
        };

        while (q--) {
            int l, r;
            cin >> l >> r;
            if (l == r) {
                cout << 0 << " ";
            } else {
                cout << getMax(l + 1, r) << " ";
            }
        }
        cout << "\n";
    }

    return 0;
}

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

const int MAXN = 500000 + 5;

int n, m, q;
int val[MAXN];               
pair<int,int> edges[MAXN];
pair<int,int> queries[MAXN];
bool deleted[MAXN];

int parent[MAXN];
vector<int> tree[MAXN];     
int tin[MAXN], tout[MAXN], timer;

pair<int,int> seg[4 * MAXN];  

int find_set(int v) {
    if (v == parent[v]) return v;
    return parent[v] = find_set(parent[v]);
}

void unite(int a, int b) {
    a = find_set(a);
    b = find_set(b);
    if (a == b) return;

    ++n;                  
    parent[n] = n;
    parent[a] = n;
    parent[b] = n;
    tree[n].push_back(a);
    tree[n].push_back(b);
}

void dfs(int v) {
    tin[v] = ++timer;
    for (int to : tree[v]) {
        dfs(to);
    }
    tout[v] = timer;
}

void build(int v, int tl, int tr) {
    if (tl == tr) {
        seg[v] = {0, 0};
        return;
    }
    int tm = (tl + tr) >> 1;
    build(v<<1, tl, tm);
    build(v<<1|1, tm+1, tr);
    seg[v] = max(seg[v<<1], seg[v<<1|1]);
}

void update(int v, int tl, int tr, int pos, pair<int,int> x) {
    if (tl == tr) {
        seg[v] = x;
        return;
    }
    int tm = (tl + tr) >> 1;
    if (pos <= tm) update(v<<1, tl, tm, pos, x);
    else update(v<<1|1, tm+1, tr, pos, x);
    seg[v] = max(seg[v<<1], seg[v<<1|1]);
}

pair<int,int> query(int v, int tl, int tr, int l, int r) {
    if (l > r) return {0, 0};
    if (l <= tl && tr <= r) return seg[v];
    int tm = (tl + tr) >> 1;
    return max(
        query(v<<1, tl, tm, l, min(r, tm)),
        query(v<<1|1, tm+1, tr, max(l, tm+1), r)
    );
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> n >> m >> q;

    for (int i = 1; i <= n; i++) {
        cin >> val[i];
        parent[i] = i;
    }

    for (int i = 1; i <= m; i++) {
        cin >> edges[i].first >> edges[i].second;
    }

    for (int i = 1; i <= q; i++) {
        cin >> queries[i].first >> queries[i].second;
        if (queries[i].first == 2) {
            deleted[queries[i].second] = true;
        }
    }

    for (int i = 1; i <= m; i++) {
        if (!deleted[i]) {
            unite(edges[i].first, edges[i].second);
        }
    }

    for (int i = q; i >= 1; i--) {
        if (queries[i].first == 2) {
            int id = queries[i].second;
            unite(edges[id].first, edges[id].second);
        } else {
            queries[i].second = find_set(queries[i].second);
        }
    }

    for (int i = 1; i <= n; i++) {
        if (find_set(i) == i) {
            dfs(i);
        }
    }

    build(1, 1, n);

    for (int i = 1; i <= n; i++) {
        update(1, 1, n, tin[i], {val[i], tin[i]});
    }

    for (int i = 1; i <= q; i++) {
        if (queries[i].first == 1) {
            int v = queries[i].second;
            auto res = query(1, 1, n, tin[v], tout[v]);
            cout << res.first << '\n';
            if (res.first > 0) {
                update(1, 1, n, res.second, {0, 0});
            }
        }
    }

    return 0;
}