#include <bits/stdc++.h>

using i64 = long long;

void solve() {
    int n, m;
    std::cin >> n >> m;
    
    std::vector<std::list<int>> e(2 * m);
    std::vector<int> ep(2 * m);
    std::vector<std::set<int>> adj(n);
    
    std::vector<int> deg(n);
    for (int i = 0; i < m; i++) {
        int u, v;
        std::cin >> u >> v;
        u--, v--;
        ep[2 * i] = v;
        ep[2 * i + 1] = u;
        adj[u].insert(2 * i);
        adj[v].insert(2 * i + 1);
        deg[u]++;
        deg[v]++;
    }
     
    const int k = (m - 1) / (n - 1) + 1;
    std::priority_queue<std::pair<int, int>, std::vector<std::pair<int, int>>, std::greater<>> h;
    for (int x = 0; x < n; x++) {
        h.emplace(deg[x], x);
    }
    while (!h.empty()) {
        auto [d, x] = h.top();
        h.pop();
        if (d != deg[x]) {
            continue;
        }
        deg[x] = -1;
        std::vector p(adj[x].begin(), adj[x].end());
        adj[x].clear();
        std::sort(p.begin(), p.end(),
            [&](int i, int j) {
                return ep[i] < ep[j];
            });
        for (int i = k - 1; i < p.size(); i++) {
            if (ep[p[i]] == ep[p[i - k + 1]]) {
                std::cout << x + 1 << " " << ep[p[i]] + 1 << "\n";
                for (int j = i - k + 1; j <= i; j++) {
                    int u = p[j];
                    std::cout << 2 + e[u].size() << " " << x + 1 << " ";
                    for (auto y : e[u]) {
                        std::cout << y + 1 << " ";
                    }
                    std::cout << ep[u] + 1 << "\n";
                }
                return;
            }
        }
        int t = std::max<int>(k - 1, (p.size() + 1) / 2);
        for (int i = t; i < p.size(); i++) {
            int u = p[i - t], v = p[i];
            ep[u ^ 1] = ep[v];
            ep[v ^ 1] = ep[u];
            e[u ^ 1].push_back(x);
            e[u ^ 1].splice(e[u ^ 1].end(), e[v]);
            e[v ^ 1].push_back(x);
            e[v ^ 1].splice(e[v ^ 1].end(), e[u]);
            std::swap(e[u], e[v ^ 1]);
            adj[ep[v]].erase(v ^ 1);
            adj[ep[v]].insert(u);
        }
        for (int i = std::max(0, int(p.size()) - t); i < std::min(t, int(p.size())); i++) {
            adj[ep[p[i]]].erase(p[i] ^ 1);
            h.emplace(--deg[ep[p[i]]], ep[p[i]]);
        }
    }
    assert(false);
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int T;
    std::cin >> T;
    
    while (T--) {
        solve();
    }
    
    return 0;
}