#include <bits/stdc++.h>

using namespace std;

typedef long long i64;
typedef unsigned long long u64;
typedef double lf;

const int inf = 1e9;
const int BUBEN = 100;


struct state {
	int len, link;
	map<int,int> next;
    int can_reach;
};

vector<state> st;
int sz, last;

void init() {
    st.resize(1);
    sz = last = 0;
	st[0].len = 0;
	st[0].link = -1;
    st[0].can_reach = inf;
	++sz;
}

void addchar(int c, int val) {
    // cerr << "addchar " << c << endl;
    st.push_back({.len = 0, .link = 0, .next = {}, .can_reach = val});
	int cur = sz++;
	st[cur].len = st[last].len + 1;
	int p;
	for (p=last; p!=-1 && !st[p].next.count(c); p=st[p].link)
		st[p].next[c] = cur;
	if (p == -1)
		st[cur].link = 0;
	else {
		int q = st[p].next[c];
		if (st[p].len + 1 == st[q].len)
			st[cur].link = q;
		else {
            st.push_back({.len = 0, .link = 0, .next = {}, .can_reach = val});
			int clone = sz++;
			st[clone].len = st[p].len + 1;
			st[clone].next = st[q].next;
			st[clone].link = st[q].link;
			for (; p!=-1 && st[p].next[c]==q; p=st[p].link)
				st[p].next[c] = clone;
			st[q].link = st[cur].link = clone;
		}
	}
	last = cur;
}


int n, m, q;
vector<int> perm;

int dfs(int v) {
    if (st[v].can_reach != inf) {
        return st[v].can_reach;
    }
    for (const auto &[c, to] : st[v].next) {
        st[v].can_reach = min(st[v].can_reach, dfs(to));
    }
    return st[v].can_reach;
}

void solve_suf() {
    perm.assign(n, 0);
    iota(perm.begin(), perm.end(), 0);
    
    init();
    for (int j = 0; j < n; ++j) {
        addchar(perm[j], inf);
    }
    addchar(-1, 0);
    
    for (int i = 0; i < m; ++i) {
        int l, r;
        cin >> l >> r;
        --l, --r;
        swap(perm[l], perm[r]);
        for (int j = 0; j < n; ++j) {
            addchar(perm[j], inf);
        }
        addchar(-1, i + 1);
        st[last].can_reach = min(st[last].can_reach, i + 1);
    }
    dfs(0);
    for (int it = 0; it < q; ++it) {
        int k;
        cin >> k;
        vector<int> a(k);
        for (int j = 0; j < k; ++j) {
            cin >> a[j];
            --a[j];
        }
        int v = 0;
        for (int j = 0; j < k; ++j) {
            v = st[v].next[a[j]];
            // cerr << "go " << a[j] << " -> " << v << endl;
        }
        cout << st[v].can_reach << '\n';
    }
}

map<pair<int, int>, int> start_seg;
map<pair<int, int>, vector<pair<int, int>>> segs;

vector<pair<int, int>> intersect(const vector<pair<int, int>> &a, const vector<pair<int, int>> &b) {
    vector<pair<int, int>> res;
    int i = 0, j = 0, jr = (int) b.size();
    if (a.size() == 1 && b.size() > 8) {
        j = (int) (lower_bound(b.begin(), b.end(), make_pair(a[0].first, -1)) - b.begin());
        jr = (int) (lower_bound(b.begin(), b.end(), make_pair(a[0].second, -1)) - b.begin());
    }
    while (i < (int) a.size() && j < jr) {
        int l = max(a[i].first, b[j].first);
        int r = min(a[i].second, b[j].second);
        if (l < r) {
            res.push_back({l, r});
        }
        if (a[i].second < b[j].second) {
            ++i;
        } else {
            ++j;
        }
    }
    return res;
}

void solve() {
    cin >> n >> m >> q;
    if (n <= BUBEN) {
        solve_suf();
        return;
    }
    perm.assign(n, 0);
    iota(perm.begin(), perm.end(), 0);

    for (int i = 0; i + 1 < n; ++i) {
        start_seg[{i, i + 1}] = 0;
    }
    auto close_seg = [](int a, int b, int tm) {
        auto it = start_seg.find({a, b});
        if (it == start_seg.end()) {
            return;
        }
        segs[{a, b}].push_back({it->second, tm});
        start_seg.erase(it);
    };
    auto open_seg = [&](int a, int b, int tm) {
        start_seg[{a, b}] = tm;
    };
    auto close_pos = [&](int x, int tm) {
        if (x > 0) {
            close_seg(perm[x - 1], perm[x], tm);
        }
        if (x + 1 < n) {
            close_seg(perm[x], perm[x + 1], tm);
        }
    };
    auto open_pos = [&](int x, int tm) {
        if (x > 0) {
            open_seg(perm[x - 1], perm[x], tm);
        }
        if (x + 1 < n) {
            open_seg(perm[x], perm[x + 1], tm);
        }
    };
    for (int i = 0; i < m; ++i) {
        int l, r;
        cin >> l >> r;
        --l, --r;
    
        close_pos(l, i + 1);
        close_pos(r, i + 1);
        swap(perm[l], perm[r]);
        open_pos(l, i + 1);
        open_pos(r, i + 1);
    }
    for (int i = 0; i < n; ++i) {
        close_pos(i, m + 1);
    }
    for (int it = 0; it < q; ++it) {
        int k;
        cin >> k;
        vector<int> a(k);
        for (int j = 0; j < k; ++j) {
            cin >> a[j];
            --a[j];
        }
        vector<pair<int, int>> cur = {{0, m + 1}};
        for (int j = 0; j + 1 < k; ++j) {
            const auto &qq = segs[{a[j], a[j + 1]}];
            cur = intersect(cur, qq);
        }
        cout << cur[0].first << '\n';
    }
}

signed main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    ios_base::sync_with_stdio(false);
    solve();
}