#pragma GCC optimize("Ofast")

#include "bits/stdc++.h"

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

using namespace std;

using ll = long long;
using ull = unsigned long long;
using ld = long double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;

using vi = vector<int>;
using vl = vector<ll>;
using vpi = vector<pair<int, int>>;
using vvi = vector<vi>;

int Bit(int mask, int b) { return (mask >> b) & 1; }

template<class T>
bool ckmin(T &a, const T &b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

template<class T>
bool ckmax(T &a, const T &b) {
    if (b > a) {
        a = b;
        return true;
    }
    return false;
}

// [l, r)
template<typename T, typename F>
T FindFirstTrue(T l, T r, const F &predicat) {
    --l;
    while (r - l > 1) {
        T mid = l + (r - l) / 2;
        if (predicat(mid)) {
            r = mid;
        } else {
            l = mid;
        }
    }
    return r;
}


template<typename T, typename F>
T FindLastFalse(T l, T r, const F &predicat) {
    return FindFirstTrue(l, r, predicat) - 1;
}

const int INFi = 2e9;
const ll INF = 2e18;

const int N = 4e3 + 5;
ll h[N];
vi g[N];
int U[N], V[N];
bool used[N];
bool bad[N];
ll cnt[N];
ll hh[N];

int n;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

void dfs(int v, int p) {
    used[v] = true;
    for(auto &i : g[v]) {
        if (i == p) continue;
        int u = U[i] ^ V[i] ^ v;
        if (used[u]) {
            if (h[i] == -1) {
                h[i] = rng() % INF;
                cnt[v]++;
            } else {
                cnt[v]--;
            }
            hh[v] ^= h[i];
            continue;
        }
        dfs(u, i);
        hh[v] ^= hh[u];
    }
    if (p != -1) {
        h[p] = hh[v];
        if (cnt[v]) {
            bad[v] = true;
            bad[U[p] ^ V[p] ^ v] = true;
        }
    }
}

ll who[N];

void build(const vi &e) {
    for(auto &i : e) {
        g[U[i]].push_back(i);
        g[V[i]].push_back(i);
        h[i] = -1;
    }
    rep(i, n) {
        bad[i] = false;
        used[i] = false;
        hh[i] = 0;
        cnt[i] = 0;
    }
    rep(i, n) {
        if (!used[i]) {
            dfs(i, -1);
        }
    }

    rep(i, n) {
        ll col = 0;
        for(auto &j : g[i]) {
            if (h[j] == 0) continue;
            if (!col) col = h[j];
            if (h[j] != col) {
                col = -1;
                break;
            }
        }
        who[i] = col;
    }

    rep(i, n) {
        g[i].clear();
    }

}

void solve() {
    int m; cin >> n >> m;
    rep(i, m) {
        cin >> U[i] >> V[i];
        U[i]--;
        V[i]--;
    }
    vi e(m);
    iota(all(e), 0);
    vi ans;
    while(!e.empty()) {
         build(e);
        if (!ans.empty()) {
            int i = ans.back();
            if (bad[U[i]] || bad[V[i]]) {
                e.push_back(ans.back());
                ans.pop_back();
                continue;
            }
        }

        bool found = false;
        rep(j, e.size()) {
            int i = e[j];
            int u = U[i];
            int v = V[i];
            ll col = h[i];

            if (who[u] != col || who[v] != col) continue;
            ans.push_back(i);
            found = true;
            e.erase(e.begin() + j);
            break;
        }

        if (!found) {
            cout << "-1\n";
            return;
        }
     }
    reverse(all(ans));
    for(auto &i : ans) {
        cout << i + 1 << ' ' ;
    }
    cout << '\n';
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout << setprecision(8) << fixed;
    int t = 1;
    cin >> t;
    rep(i, t) {
        solve();
    }
    return 0;
}