///////////        
//                   //      //
//              ////////////////////
//                   //      //
//                 
///////////

//          
//          
//           //     //    ////////     /\     /////////
//           //     //   //      //          //       //
//            ////////   //      //    //    //       //
//                  //   //      //    //    //       //
//////////   ////////    //      //    //     /////////////

//#pragma GCC optimize(3,"Ofast","inline")
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <string>
#include <cstring>
#include <cmath>
#include <list>
#include <stack>
#include <array>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <random>
#include <numeric>
#include <functional>
//#include <Windows.h>

using namespace std;

#define fa(i,op,n) for (int i = op; i <= n; i++)
#define fb(j,op,n) for (int j = op; j >= n; j--)
#define pb push_back
#define HashMap unordered_map
#define HashSet unordered_set
#define var auto
#define all(i) i.begin(), i.end()
#define all1(i) i.begin() + 1,i.end()
#define endl '\n'
#define px first
#define py second

using VI = vector<int>;
using VL = vector<long long>;
using ll = long long;
using ull = unsigned long long;
using db = double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;

template<class T1, class T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& p) {
	out << '(' << p.first << ", " << p.second << ')';
	return out;
}

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& ve) {
	for (T i : ve)
		out << i << ' ';
	return out;
}

template<class T1, class T2>
ostream& operator<<(ostream& out, const map<T1, T2>& mp) {
	for (auto i : mp)
		out << i << '\n';
	return out;
}

template<typename ...T>
bool _debug(T... a) {
	((cout << a << ' '), ...);
	cout << endl;
	return -1;
}

const int INF = 0x3f3f3f3f;
const ll LNF = 0x3f3f3f3f3f3f3f3f;
const int IINF = 0x7fffffff;
const int iinf = 0x80000000;
const ll LINF = 0x7FFFFFFFFFFFFFFF;
const ll linf = 0x8000000000000000;
int dx[8] = { 1, -1, 0, 0, 1, -1, 1, -1 };
int dy[8] = { 0, 0, 1, -1, 1, -1, -1, 1 };

//#include "Lynia.h"
namespace MyTools
{

}

namespace MT = MyTools;
//using Math = MT::Math<ll>;
//using mint = MT::ModInt<998244353>;

const int mod = 1e9 + 7;
const int N = 1e6 + 10;

struct node {
	int u, v, w;
};
void solve(int CASE)
{
	int n, m; cin >> n >> m;
	var s = vector<int>(n + 1);
	var e = vector<node>(m + 1);
	fa(i, 1, n)s[i] = i;
	var mp = map<pii, int>();
	fa(i, 1, m) {
		cin >> e[i].u >> e[i].v;
		e[i].w = i;
		mp[{e[i].u, e[i].v}] = i;
		mp[{e[i].v, e[i].u}] = i;
	}
	sort(all1(e), [](node a, node b)->bool {
		return a.w < b.w;
		});
	var find = [&](var find, int x) -> int {
		if (x != s[x])return find(find, s[x]);
		return s[x];
		};

	var deg = vector<int>(n + 1);
	var g = vector<vector<int>>(n + 1);
	fa(i, 1, m) {
		var& u = e[i].u;
		var& v = e[i].v;
		deg[u]++; deg[v]++;
		g[u].pb(v); g[v].pb(u);
		var e1 = find(find, u);
		var e2 = find(find, v);
		s[e1] = e2;
		if (e1 == e2) {
			var Q = queue<int>();
			fa(i, 1, n)
				if (deg[i] == 1)
					Q.push(i);
			while (Q.size()) {
				var now = Q.front();
				Q.pop();
				for (var to : g[now]) {
					deg[now]--;
					deg[to]--;
					if (deg[to] == 1)
						Q.push(to);
				}
			}

			var ans = set<int>();

			var dfs = [&](var dfs, int now, int fa,int st)->void {
				if (now == st and fa != 0)return;
				for (int to : g[now]) {
					if (deg[to] < 1 or to == fa)continue;
					dfs(dfs, to, now,st);
					ans.insert(mp[{now, to}]);
				}
				};

			fa(i, 1, n) {
				if (deg[i] > 1) {
					dfs(dfs, i, 0,i);
					break;
				}
			}

			for (int i : ans)
				cout << i << ' ';
			cout << endl;
			return;
		}
	}
	cout << -1 << endl;
	return;
}

int main()
{
	//SetConsoleOutputCP(CP_UTF8);
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int _ = 1;
	cin >> _;
	fa(i, 1, _)solve(i);
	return 0;
}