#ifdef DEBUG
#define _GLIBCXX_DEBUG
#endif
//#pragma GCC optimize("O3")
#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
typedef long double ld;

const int N = 500500, LOG = 20;

int n, m, q, k, a[N * 5];
vector<int> g[N], G[N], gg[N];
int depth[N];

int fsz[N];
int sz[N];

int tin[N], tout[N], timer, tup[N];
bool was[N];

int up[N][LOG];

int p[N];

int qid[N];
bool in_bridge[N];

int PR[N];

int pp(int v) {
    return p[v] == v ? v : p[v] = pp(p[v]);
}

void dfs1(int v, int pr) {
    PR[v] = pr;
    tin[v] = tup[v] = ++timer;
    was[v] = 1;
    for (auto to: g[v]) {
        if (to == pr)
            continue;
        if (was[to]) {
            tup[v] = min(tup[v], tin[to]);
        } else {
            dfs1(to, v);
            tup[v] = min(tup[v], tup[to]);
            if (tup[to] <= tin[v]) {
                p[pp(v)] = pp(to);
            }
        }
    }
}

bool upper(int v, int u) {
    return tin[v] <= tin[u] && tin[u] <= tout[v];
}

int lca(int v, int u) {
    if (upper(v, u))
        return v;
    if (upper(u, v))
        return u;
    for (int i = LOG - 1; i >= 0; i--)
        if (!upper(up[v][i], u))
            v = up[v][i];
    return up[v][0];
}

int dist(int v, int u) {
    return depth[v] + depth[u] - 2 * depth[lca(v, u)];
}

bool in_path(int v, int u, int w) {
    return dist(v, w) + dist(u, w) == dist(v, u);
}

int lift(int v, int u) {
    for (int i = LOG - 1; i >= 0; i--)
        if (!upper(up[v][i], u))
            v = up[v][i];
    return v;
}

void dfs2(int v, int pr) {
    if (v == pr)
        depth[v] = 0;
    else
        depth[v] = depth[pr] + 1;
    tin[v] = ++timer;
    up[v][0] = pr;
    for (int i = 1; i < LOG; i++)
        up[v][i] = up[up[v][i - 1]][i - 1];
    was[v] = 1;
    for (auto to: G[v]) {
        if (to == pr || was[to])
            continue;
        dfs2(to, v);
        sz[v] += sz[to];
    }
    tout[v] = timer;
}

bool check(int u) {
    return qid[u] < k && a[qid[u]] == u;
}

void solve() {
    cin >> n >> m >> q;
    for (int i = 0; i < n; i++) {
        g[i].clear();
        G[i].clear();
        gg[i].clear();
    }
    for (int i = 0; i < m; i++) {
        int v, u;
        cin >> v >> u;
        v--, u--;
        g[v].push_back(u);
        g[u].push_back(v);
    }
    for (int i = 0; i < n; i++) {
        p[i] = i;
        was[i] = 0;
        sz[i] = 0;
    }
    dfs1(0, -1);
    for (int i = 0; i < n; i++) {
        sz[pp(i)]++;
        for (auto j: g[i]) {
            G[pp(i)].push_back(pp(j));
            if (pp(i) != pp(j))
                gg[i].push_back(j);
        }
    }
    for (int i = 0; i < n; i++) {
        was[i] = 0;
    }
    dfs2(pp(0), pp(0));
    for (int i = 0; i < n; i++) {
        for (auto j: gg[i]) {
            if (up[pp(j)][0] == pp(i))
                fsz[i] += sz[pp(j)];
            else
                fsz[i] += n - sz[pp(i)];
        }
    }
    while (q--) {
        cin >> k;
        for (int i = 0; i < k; i++) {
            cin >> a[i];
            a[i]--;
        }
        sort(a, a + k);
        k = unique(a, a + k) - a;
        if (k == 1) {
            ll ans = n;
            int sz = fsz[a[0]];
            ans += 1ll * (n - 1 - sz) * (sz);
            cout << ans << "\n";
            continue;
        }
        for (int i = 0; i < k; i++) {
            qid[a[i]] = i;
            in_bridge[i] = 0;
        }
        bool OK = 1;
        int V, U;
        V = U = pp(a[0]);
        for (int i = 1; i < k && OK; i++) {
            if (in_path(V, U, pp(a[i])))
                continue;
            if (in_path(V, pp(a[i]), U))
                U = pp(a[i]);
            else if (in_path(U, pp(a[i]), V))
                V = pp(a[i]);
            else
                OK = 0;
        }
        if (!OK) {
            cout << 0 << "\n";
            continue;
        }
        for (int i = 0; i < k; i++) {
            int v = a[i];
            int u = PR[a[i]];
            if (pp(v) == pp(u) || !in_path(V, U, pp(u)))
                continue;
            in_bridge[qid[v]] = 1;
            if (check(u))
                in_bridge[qid[u]] = 1;
        }
        bool fV = 0, fU = 0;
        int aV = -1, aU = -1;
        for (int i = 0; i < k && OK; i++) {
            if (in_bridge[i])
                continue;
            if (pp(a[i]) == V && !fV)
                fV = 1, aV = a[i];
            else if (pp(a[i]) == U && !fU)
                fU = 1, aU = a[i];
            else
                OK = 0;
        }
        if (!OK) {
            cout << 0 << "\n";
            continue;
        }
        int szV = 1, szU = 1;
        if (fV) {
            szV += fsz[aV];
        } else {
            if (!upper(V, U))
                szV = sz[V];
            else
                szV = n - sz[lift(U, V)];
        }
        if (fU) {
            szU += fsz[aU];
        } else {
            if (!upper(U, V))
                szU = sz[U];
            else
                szU = n - sz[lift(V, U)];
        }
//        cerr << szV << " " << szU << endl;
//        cerr << aV << " " << aU << endl;
        cout << 1ll * szV * szU << "\n";
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
#ifdef DEBUG
    freopen("input.txt", "r", stdin);
#endif
    int t;
    cin >> t;
    while (t--)
        solve();
    return 0;
}