#include <bits/stdc++.h>

struct DSU {
    std::vector<int> fa;
    explicit DSU(int n) : fa(n) {
        std::iota(fa.begin(), fa.end(), 0);
    }
    int find(int x) {
        return fa[x] == x ? x : fa[x] = find(fa[x]);
    }
    void merge(int x, int y) {
        x = find(x);
        y = find(y);
        fa[x] = y;
    }
};

void solve() {
    int n, m;
    std::cin >> n >> m;

    std::vector<std::pair<int, int>> edge(m);
    for (auto &[x, y] : edge) {
        std::cin >> x >> y;
        --x, --y;
    }

    DSU dsu(n);
    std::vector<std::vector<std::pair<int, int>>> adj(n);

    auto find_path = [&](int x, int y) -> std::vector<int> {
        std::vector<uint8_t> vist(n);
        std::vector<int> st;
        auto dfs = [&](auto &self, int node) -> bool {
            vist[node] = true;

            if (node == y) {
                return true;
            }

            for (auto [to, id] : adj[node]) {
                if (!vist[to]) {
                    st.push_back(id);
                    if (self(self, to)) {
                        return true;
                    }
                    st.pop_back();
                }
            }

            return false;
        };

        assert(dfs(dfs, x));
        return st;
    };

    for (int i = 0; i < m; ++i) {
        auto [x, y] = edge[i];
        if (dsu.find(x) == dsu.find(y)) {
            auto ans = find_path(x, y);
            ans.push_back(i);
            std::sort(ans.begin(), ans.end());

            for (int i : ans) {
                std::cout << i + 1 << ' ';
            }
            std::cout << '\n';
            return;
        }
        dsu.merge(x, y);
        adj[x].emplace_back(y, i);
        adj[y].emplace_back(x, i);
    }

    std::cout << "-1\n";
}

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

    int t;
    std::cin >> t;

    while (t--) {
        solve();
    }
}