#include <vector>
#include <utility>
#include <iostream>

struct AdjacencyList{
public:
    struct AdjacencyListRange{
        using iterator = typename std::vector<int>::const_iterator;
        iterator begi, endi;
        iterator begin() const { return begi; }
        iterator end() const { return endi; }
    };
private:
    int mn;
    std::vector<int> E;
    std::vector<int> I;
public:
    AdjacencyList(int n, std::vector<std::pair<int,int>> edges, bool rev){
        if(n == 0){ mn = 0; I = {0}; E = {}; return; }
        mn = n;
        std::vector<int> buf(n+1, 0);
        for(auto [u,v] : edges){ ++buf[u]; if(rev) ++buf[v]; }
        for(int i=1; i<=n; i++) buf[i] += buf[i-1];
        E.resize(buf[n]);
        for(int i=(int)edges.size()-1; i>=0; i--){
            auto [u,v] = edges[i];
            E[--buf[u]] = v;
            if(rev) E[--buf[v]] = u;
        }
        I = std::move(buf);
    }
    AdjacencyListRange operator[](int u) const {
        return AdjacencyListRange{ E.begin() + I[u], E.begin() + I[u+1] };
    }
    int num_vertices() const { return mn; }
};

#include <iostream>
#include <vector>
#include <algorithm>

namespace nachia{

struct HeavyLightDecomposition{
private:

    int N;
    std::vector<int> P;
    std::vector<int> PP;
    std::vector<int> PD;
    std::vector<int> D;
    std::vector<int> I;

    std::vector<int> rangeL;
    std::vector<int> rangeR;

public:

    HeavyLightDecomposition(const AdjacencyList& E = AdjacencyList(1, {}, false)){
        N = E.num_vertices();
        P.assign(N, -1);
        I = {0};
        I.reserve(N);
        for(int i=0; i<(int)I.size(); i++){
            int p = I[i];
            for(int e : E[p]) if(P[p] != e){
                I.push_back(e);
                P[e] = p;
            }
        }
        std::vector<int> Z(N, 1);
        std::vector<int> nx(N, -1);
        PP.resize(N);
        for(int i=0; i<N; i++) PP[i] = i;
        for(int i=N-1; i>=1; i--){
            int p = I[i];
            Z[P[p]] += Z[p];
            if(nx[P[p]] == -1) nx[P[p]] = p;
            if(Z[nx[P[p]]] < Z[p]) nx[P[p]] = p;
        }

        for(int p : I) if(nx[p] != -1) PP[nx[p]] = p;

        PD.assign(N,N);
        PD[0] = 0;
        D.assign(N,0);
        for(int p : I) if(p != 0){
            PP[p] = PP[PP[p]];
            PD[p] = std::min(PD[PP[p]], PD[P[p]]+1);
            D[p] = D[P[p]]+1;
        }
        
        rangeL.assign(N,0);
        rangeR.assign(N,0);
        std::vector<int> dfs;
        dfs.push_back(0);
        while(dfs.size()){
            int p = dfs.back();
            rangeR[p] = rangeL[p] + Z[p];
            int ir = rangeR[p];
            dfs.pop_back();
            for(int e : E[p]) if(P[p] != e) if(e != nx[p]){
                rangeL[e] = (ir -= Z[e]);
                dfs.push_back(e);
            }
            if(nx[p] != -1){
                rangeL[nx[p]] = rangeL[p] + 1;
                dfs.push_back(nx[p]);
            }
        }

        I.resize(N);
        for(int i=0; i<N; i++) I[rangeL[i]] = i;
    }

    int depth(int p) const {
        return D[p];
    }

    int lca(int u, int v) const {
        if(PD[u] < PD[v]) std::swap(u, v);
        while(PD[u] > PD[v]) u = P[PP[u]];
        while(PP[u] != PP[v]){ u = P[PP[u]]; v = P[PP[v]]; }
        return (D[u] > D[v]) ? v : u;
    }

    int dist(int u, int v) const {
        return depth(u) + depth(v) - depth(lca(u,v)) * 2;
    }

    std::vector<std::pair<int,int>> path(int r, int c, bool include_root = true, bool reverse_path = false) const {
        if(PD[c] < PD[r]) return {};
        std::vector<std::pair<int,int>> res(PD[c]-PD[r]+1);
        for(int i=0; i<(int)res.size()-1; i++){
            res[i] = std::make_pair(rangeL[PP[c]], rangeL[c]+1);
            c = P[PP[c]];
        }
        if(PP[r] != PP[c] || D[r] > D[c]) return {};
        res.back() = std::make_pair(rangeL[r]+(include_root?0:1), rangeL[c]+1);
        if(res.back().first == res.back().second) res.pop_back();
        if(!reverse_path) std::reverse(res.begin(),res.end());
        else for(auto& a : res) a = std::make_pair(N - a.second, N - a.first);
        return move(res);
    }

    std::pair<int,int> subtree(int p){
        return std::make_pair(rangeL[p], rangeR[p]);
    }

    int to_seq(int vertex) const {
        return rangeL[vertex];
    }
    int to_vtx(int seqidx) const {
        return I[seqidx];
    }

    int median(int x, int y, int z) const {
        if(to_seq(x) > to_seq(y)) std::swap(x,y);
        if(to_seq(y) > to_seq(z)) std::swap(y,z);
        if(to_seq(x) > to_seq(y)) std::swap(x,y);
        x = lca(x,y); y = lca(y,z);
        return depth(x) < depth(y) ? y : x;
    }

    int la(int from, int to, int d) const {
        if(d < 0) return -1;
        int g = lca(from,to);
        int dist0 = D[from] - D[g] * 2 + D[to];
        if(dist0 < d) return -1;
        int p = from;
        if(D[from] - D[g] < d){ p = to; d = dist0 - d; }
        while(D[p] - D[PP[p]] < d){
            d -= D[p] - D[PP[p]] + 1;
            p = P[PP[p]];
        }
        return I[rangeL[p] - d];
    }
};

} // namespace nachia



#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ull MOD = 1000000007;
#define rep(i,n) for(int i=0; i<(n); i++)

struct mll{
  using u32 = uint32_t;
  using u64 = uint64_t;
  u32 v;
  mll(u32 x = 0) : v(x) {}
  u32 val() const { return v; }
  mll& operator+=(const mll& r){ v += r.val(); if(v >= MOD) v -= MOD; return *this; }
  mll& operator-=(const mll& r){ v += MOD - r.val(); if(v >= MOD) v -= MOD; return *this; }
  mll& operator*=(const mll& r) { v = (u64)v * r.val() % MOD; return *this; }
  mll operator+(const mll& r) const { mll res = *this; res += r; return res; }
  mll operator-(const mll& r) const { mll res = *this; res -= r; return res; }
  mll operator*(const mll& r) const { mll res = *this; res *= r; return res; }
  mll operator-() const { return v ? mll(MOD-v) : mll(0); }
};

struct DSU{
  vector<int> V;
  DSU(int n){
    V.resize(n);
    rep(i,n) V[i] = i;
  }
  int leader(int a){ if(V[a] == a) return a; return V[a] = leader(V[a]); }
  void merge(int r,int c){ V[leader(c)] = leader(r); }
};

struct Edge{ int u,v,i; };

int N, M;
vector<Edge> J;
vector<vector<Edge>> E;
vector<Edge> flows;
vector<mll> cost;

vector<int> P;
vector<int> Eidx;
vector<mll> dep;

vector<int> iEidx;
vector<int> flowIdx;

nachia::HeavyLightDecomposition hld;



void read_graph(){
  cin >> N >> M;
  E.resize(N);
  vector<pair<int,int>> idE;
  cost.resize(M);
  cost[0] = 2;
  for(int i=1; i<M; i++) cost[i] = cost[i-1] * 2;
  DSU G1(N);
  rep(i,M){
    int u,v; cin >> u >> v; u--; v--;
    J.push_back({u,v,i});
    if(G1.leader(u) == G1.leader(v)){
      flows.push_back({u,v,i});
    }
    else{
      G1.merge(u,v);
      E[u].push_back({u,v,i});
      E[v].push_back({v,u,i});
      idE.push_back(make_pair(u,v));
    }
  }
  hld = nachia::HeavyLightDecomposition(AdjacencyList(N, idE, true));
}

void initLCA(){
  vector<int> I;
  P.assign(N,-1);
  I.push_back(0);
  dep.assign(N,0);
  Eidx.assign(N,-1);
  rep(i,I.size()){
    int p = I[i];
    for(Edge e : E[p]) if(P[p] != e.v){
      P[e.v] = p;
      dep[e.v] = dep[p] + cost[e.i];
      Eidx[e.v] = e.i;
      I.push_back(e.v);
    }
  }
}

int LCA(int u,int v){
  return hld.lca(u,v);
}

int dist0(int u,int v){
  return hld.dist(u,v);
}
mll dist1(int u,int v){
  int g = LCA(u,v);
  return dep[u] + dep[v] - dep[g] * 2;
}

void build_flows(){

  iEidx.assign(M,-1);
  rep(i,N) if(Eidx[i] != -1) iEidx[Eidx[i]] = i;

  flowIdx.assign(N,-1);
  
  DSU G2(N);
  for(Edge e : flows){
    int g = G2.leader(LCA(e.u,e.v));
    for(int s : {e.u,e.v}){
      int p = G2.leader(s);
      while(p != g){
        flowIdx[p] = e.i;
        G2.merge(P[p],p);
        p = G2.leader(p);
      }
    }
  }
}

int path_includes(int u,int v,int z){
  if(iEidx[z] == -1) return -1;
  if(hld.median(u,v,J[z].u) != J[z].u) return -1;
  if(hld.median(u,v,J[z].v) != J[z].v) return -1;
  int res = flowIdx[iEidx[z]];
  if(res == -1) return -2;
  return res;
}

mll shortest_using(int u,int v,int z){
  mll ans = cost[z];
  if(dist0(u,J[z].u) + dist0(v,J[z].v) < dist0(u,J[z].v) + dist0(v,J[z].u))
    ans += dist1(u,J[z].u) + dist1(v,J[z].v);
  else
    ans += dist1(u,J[z].v) + dist1(v,J[z].u);
  return ans;
}


int main(){
  read_graph();
  initLCA();
  build_flows();
  int Q; cin >> Q;
  rep(q,Q){
    int u,v,z; cin >> u >> v >> z; u--; v--; z--;
    int inc = path_includes(u,v,z);
    if(inc == -2){ cout << "-1\n"; continue; }
    if(inc == -1){ cout << dist1(u,v).val() << "\n"; continue; }
    auto e = J[inc];
    mll ans = shortest_using(u,v,e.i);
    cout << ans.val() << "\n";
  }
  return 0;
}

struct ios_do_not_sync{
  ios_do_not_sync(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
  }
} ios_do_not_sync_inst;