#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <random>
#include <stdio.h>
#include <fstream>
#include <functional>
#include <cassert>
#include <unordered_map>
#include <bitset>
#include <chrono>





using namespace std;




#define rep(i,n) for (int i=0;i<n;i+=1)
#define rrep(i,n) for (int i=n-1;i>-1;i--)
#define pb push_back
#define all(x) (x).begin(), (x).end()

#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << " )\n";

template<class T>
using vec = vector<T>;
template<class T>
using vvec = vec<vec<T>>;
template<class T>
using vvvec = vec<vvec<T>>;
using ll = long long;
using ld = long double;
using pii = pair<int,int>;
using pll = pair<ll,ll>;


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

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

template<class T>
T sum(vec<T> x){
  T res=0;
  for (auto e:x){
    res += e;
  }
  return res;
}

template<class T>
void printv(vec<T> x){
  for (auto e:x){
    cout<<e<<" ";
  }
  cout<<endl;
}



template<class T,class U>
ostream& operator<<(ostream& os, const pair<T,U>& A){
  os << "(" << A.first <<", " << A.second << ")";
  return os;
}

template<class T>
ostream& operator<<(ostream& os, const set<T>& S){
  os << "set{";
  for (auto a:S){
    os << a;
    auto it = S.find(a);
    it++;
    if (it!=S.end()){
      os << ", ";
    }
  }
  os << "}";
  return os;
}

template<class T0,class T1,class T2>
ostream& operator<<(ostream& os, const tuple<T0,T1,T2>& a){
  auto [x,y,z] = a;
  os << "(" << x << ", " << y << ", " << z << ")";
  return os;
}

template<class T0,class T1,class T2,class T3>
ostream& operator<<(ostream& os, const tuple<T0,T1,T2,T3>& a){
  auto [x,y,z,w] = a;
  os << "(" << x << ", " << y << ", " << z << ", " << w  << ")";
  return os;
}

template<class T,class U>
ostream& operator<<(ostream& os, const map<U,T>& A){
  os << "map{";
  for (auto e:A){
    os << e.first;
    os << ":";
    os << e.second;
    os << ", ";
  }
  os << "}";
  return os;
}

template<class T>
ostream& operator<<(ostream& os, const vec<T>& A){	
  os << "[";
  rep(i,A.size()){
    os << A[i];
    if (i!=A.size()-1){
      os << ", ";
    }
  }
  os << "]" ;
  return os;
}

struct LowLink {
    int n, m = 0, t = 0, b = 0;
    std::vector<std::vector<int>> G;
    std::vector<std::pair<int, int>> es;
    std::vector<int> ord, low, tecc, bcc, tmp;
    std::vector<bool> is_articulation, is_bridge, used;

    LowLink(int n) : n(n), G(n), ord(n, -1), low(n), tecc(n, -1), is_articulation(n, false) {}

    void add_edge(int u, int v) {
        assert(0 <= u and u < n);
        assert(0 <= v and v < n);
        G[u].emplace_back(m);
        G[v].emplace_back(m);
        es.emplace_back(u, v);
        is_bridge.emplace_back(false);
        bcc.emplace_back();
        used.emplace_back(false);
        m++;
    }

    void build() {
        for (int i = 0; i < n; i++) {
            if (ord[i] != -1) continue;
            dfs1(i, 0, -1);
            dfs2(i, -1);
        }
    }

    std::pair<int, int> operator[](int k) const { return es[k]; }

  private:
    void dfs1(int v, int k, int pre) {
        ord[v] = k++, low[v] = ord[v];
        int cnt = 0;
        for (int& e : G[v]) {
            if (e == pre) continue;
            int u = es[e].first ^ es[e].second ^ v;
            if (ord[u] == -1) {
                cnt++;
                used[e] = true;
                dfs1(u, k, e);
                low[v] = std::min(low[v], low[u]);
                if (pre != -1 and ord[v] <= low[u]) is_articulation[v] = true;
                if (ord[v] < low[u]) is_bridge[e] = true;
            } else
                low[v] = std::min(low[v], ord[u]);
        }
        if (pre == -1 and cnt > 1) is_articulation[v] = true;
    }

    void dfs2(int v, int pre) {
        if (pre == -1) tecc[v] = t++;
        for (int& e : G[v]) {
            if (e == pre) continue;
            int u = es[e].first ^ es[e].second ^ v;
            if (tecc[u] == -1 or ord[u] < ord[v]) tmp.emplace_back(e);
            if (tecc[u] >= 0) continue;
            if (ord[v] >= low[u])
                tecc[u] = tecc[v];
            else
                tecc[u] = t++;
            dfs2(u, e);
            if (ord[v] <= low[u]) {
                while (true) {
                    int ne = tmp.back();
                    tmp.pop_back();
                    bcc[ne] = b;
                    if (ne == e) break;
                }
                b++;
            }
        }
    }
};



void solve(){

  int N,M;
  cin>>N>>M;
  vec<pair<int,int>> Edge(M);
  rep(i,M){
    int u,v;
    cin>>u>>v;
    Edge[i] = {u-1,v-1};
  }

  vec<int> rest_edge(M,1);

  

  auto search_nxt_edge = [&](){
    LowLink G(N);
    vec<int> rest_eids;
    rep(i,M){
      if (rest_edge[i]){
        rest_eids.push_back(i);
        G.add_edge(Edge[i].first,Edge[i].second);
      }
    }

    G.build();

    vec<vec<pair<int,int>>> tmp_dfstree(N);
    vec<vec<pair<int,int>>>tmp_back(N);
    rep(i,rest_eids.size()){
      if (G.used[i]){
        auto [u,v] = Edge[rest_eids[i]];
        tmp_dfstree[u].push_back({v,i});
        tmp_dfstree[v].push_back({u,i});
      }
      else{
        auto [u,v] = Edge[rest_eids[i]];
        tmp_back[u].push_back({v,i});
        tmp_back[v].push_back({u,i});
      }
    }

    vec<int> dep(N,-1);
    vec<pair<int,int>> parent(N,{-1,-1});
    vec<int> topo;
    rep(root,N){
      if (dep[root]!=-1) continue;
      dep[root] = 0;
      deque<int> deq = {root};
      while (!deq.empty()){
        auto v = deq.front(); deq.pop_front();
        topo.push_back(v);
        for (auto [nv,gomi]:tmp_dfstree[v]){
          if (dep[nv] == -1){
            parent[nv] = {v,gomi};
            dep[nv] = dep[v] + 1;
            deq.push_back(nv);
          }
        }
      }
    }

    vec<int> back_edge_add(N,0);
    rep(i,rest_eids.size()){
      if (!G.used[i]){
        auto [u,v] = Edge[rest_eids[i]];
        if (dep[u] > dep[v]) swap(u,v);
        back_edge_add[v]++;
        if (parent[u].first!=-1){
          back_edge_add[parent[u].first] -= 1;
        }
      }
    }

    reverse(all(topo));
    for (auto v:topo){
      for (auto [nv,gomi]:tmp_dfstree[v]){
        if (nv == parent[v].first) continue;
        back_edge_add[v] += back_edge_add[nv];
      }
    }

    rep(i,rest_eids.size()){
      if (!G.used[i]){
        auto [u,v] = Edge[rest_eids[i]];
        if (back_edge_add[u] == 1 && back_edge_add[v] == 1){
          return rest_eids[i];
        }
      }
    }
    //debug(tmp_dfstree);

    vec<int> removal_edge(rest_eids.size(),0);

    vec<int> bcc_cnt(N,0);
    vec<vec<int>> tmp_bcc(N);

    rep(v,N){
      int tmp_max_size = 0;
      int tmp_double_size = 0;
      for (auto [nv,eid_in_G]:tmp_dfstree[v]){
        int bcc_id = G.bcc[eid_in_G];
        bcc_cnt[bcc_id]++;
        if (bcc_cnt[bcc_id] == 2){
          tmp_double_size++;
        }
        chmax(tmp_max_size,bcc_cnt[bcc_id]);
        tmp_bcc[bcc_id].push_back(eid_in_G);
      }

      for (auto [nv,eid_in_G]:tmp_back[v]){
        int bcc_id = G.bcc[eid_in_G];
        bcc_cnt[bcc_id]++;
        if (bcc_cnt[bcc_id] == 2){
          tmp_double_size++;
        }
        chmax(tmp_max_size,bcc_cnt[bcc_id]);
        tmp_bcc[bcc_id].push_back(eid_in_G);
      }

      if (tmp_max_size <= 2 && tmp_double_size <= 1){
        for (auto [nv,eid_in_G]:tmp_dfstree[v]){
          int bcc_id = G.bcc[eid_in_G];
          if (bcc_cnt[bcc_id] == 1){
            if (tmp_double_size == 0){
              removal_edge[eid_in_G] += (v + 1);
            }
          }
          else{
            removal_edge[eid_in_G] += (v + 1);
          }
        }
      }

      for (auto [nv,eid_in_G]:tmp_dfstree[v]){
        int bcc_id = G.bcc[eid_in_G];
        bcc_cnt[bcc_id]--;
        tmp_bcc[bcc_id].clear();
      }

      for (auto [nv,eid_in_G]:tmp_back[v]){
        int bcc_id = G.bcc[eid_in_G];
        bcc_cnt[bcc_id]--;
        tmp_bcc[bcc_id].clear();
      }
    }

    rep(i,rest_eids.size()){
      auto [u,v] = Edge[rest_eids[i]];
      if (removal_edge[i] == u + v + 2){
        return rest_eids[i];
      }
    }

    return -1;
    
  };

  vec<int> res;

  rep(_,M){
    int remove_idx = search_nxt_edge();
    if (remove_idx == -1){
      cout << -1 << "\n";
      return ;
    }
    res.push_back(remove_idx+1);
    rest_edge[remove_idx] = 0;
  }

  reverse(all(res));
  rep(i,M){
    cout << res[i];
    if (i == M-1){
      cout << "\n";
    }
    else{
      cout << " ";
    }
  }



  

  



  


  
}






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

  cout << setprecision(15);

  int T;
  cin>>T;
  while (T--){
    solve();
  }
}