#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using ld = long double;

#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, n) for (int i = 0; i < (n); i += 1)
#define len(a) ((int)(a).size())

mt19937 rnd(234);
const ll inf = 1e18;

struct edge {
    int to;
    int i;
};

int n, m;
vector<vector<edge>> g;
vector<int> h;
vector<int> usd;
vector<int> cup, cdwn;
vector<int> smup;
vector<int> par;

void dfs1(int v, int p, int mh) {
    usd[v] = true;
    par[v] = p;
    h[v] = mh;
    for (auto [to, i] : g[v]) {
        if (to == p) {
            continue;
        }
        if (!usd[to]) {
            dfs1(to, v, mh + 1);
            smup[v] += smup[to];
        } else {
            if (h[to] < h[v]) {
                cup[v] += 1;
            } else {
                cdwn[v] += 1;
            }
        }
    }
    smup[v] += cup[v] - cdwn[v];
}

pair<int, int> dfs2(int v, int p, array<int, 3> &res) {
    usd[v] = true;
    int highest = h[v];
    int bad_sons = 0;
    int mega_count = 0;
    for (auto [to, i] : g[v]) {
        if (par[to] == v) {
            mega_count += smup[to];
        }
    }
    for (auto [to, i] : g[v]) {
        if (to != par[v]) {
            highest = min(highest, h[to]);
        }
        if (par[to] == v) {
            auto [to_highest, to_bad] = dfs2(to, v, res);
            highest = min(highest, to_highest);
            if (to_highest < h[v]) {
                bad_sons += 1;
            }
            if (mega_count != smup[to]) {
                continue;
            }
            if (to_bad) {
                continue;
            }
            if (cdwn[to] != 0 or cup[v] != 0) {
                continue;
            }
            if (cup[to] + cdwn[v] > 1) {
                continue;
            }
            if (cup[to] + cdwn[v] == 1 and smup[to] > 1) {
                continue;
            }
            res = {v, to, i};
        }
    }
    return make_pair(highest, bad_sons > 1);
}

array<int, 3> try_with_tree() {
    h.resize(n);
    usd.assign(n, false);
    cup.assign(n, 0);
    cdwn.assign(n, 0);
    smup.assign(n, 0);
    par.resize(n);
    array<int, 3> res = {-1, -1, -1};
    for (int v = 0; v < n; v += 1) {
        if (!usd[v]) {
            dfs1(v, -1, 0);
            dfs2(v, -1, res);
            if (res[0] != -1) {
                return res;
            }
        }
    }
    return res;
}

void move_to_front(int v, int u) {
    int pos = -1;
    rep(i, len(g[v])) {
        auto [to, _] = g[v][i];
        if (to == u) {
            pos = i;
            break;
        }
    }
    assert(pos != -1);
    swap(g[v][0], g[v][pos]);
}

array<int, 3> mega_try() {
    auto res = try_with_tree();
    if (res[0] != -1) {
        return res;
    }
    usd.assign(n, false);
    for (int v = 0; v < n; v += 1) {
        if (usd[v]) {
            continue;
        }
        int u = -1;
        for (auto [to, i] : g[v]) {
            if (usd[to] or par[to] == v or par[v] == to) {
                continue;
            }
            u = to;
            break;
        }
        if (u != -1) {
            usd[u] = usd[v] = true;
            move_to_front(u, v);
            move_to_front(v, u);
        }
    }
    res = try_with_tree();
    return res;
}

void erase_edge(int v, int u) {
    int pos = -1;
    rep(i, len(g[v])) {
        auto [to, _] = g[v][i];
        if (to == u) {
            pos = i;
            break;
        }
    }
    assert(pos != -1);
    g[v].erase(g[v].begin() + pos);
}

int32_t main() {
    if (1) {
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
    }
    int t;
    cin >> t;
    rep(itr, t) {
        cin >> n >> m;
        g.assign(n, {});
        rep(i, m) {
            int u, v;
            cin >> u >> v;
            --u;
            --v;
            g[u].push_back(edge{v, i});
            g[v].push_back(edge{u, i});
        }
        deque<int> result;
        for (int i = 0; i < m; i += 1) {
            auto [u, v, idx] = mega_try();
            if (u == -1) {
                break;
            }
            result.push_front(idx);
            erase_edge(u, v);
            erase_edge(v, u);
        }
        if (result.size() < m) {
            cout << -1 << "\n";
        } else {
            for (auto idx : result) {
                cout << idx + 1 << " ";
            }
            cout << "\n";
        }
    }
    return 0;
}