#include <cstdio>
#include <algorithm>
#include <cstring>
#define N 10003
#define M 50003
#define INF 1<<30
using namespace std;
int A_it=0,n,m,q,x,y;

struct Src{
    int fa[N];
    bool valid[M];
    struct edge{
        int x,y,w;
        bool operator <(const edge &B)const{
            return w>B.w;
        }
    }E[M];
    
    inline void init(){
        scanf("%d%d",&n,&m);
        for(int i=0;i<m;i++)
            scanf("%d%d%d",&E[i].x,&E[i].y,&E[i].w);
        kruskal();
    }
    
    inline void kruskal(){
        sort(E,E+m);
        memset(valid,0,sizeof(valid));
        for(int i=1;i<=n;i++) fa[i]=i;
        for(int i=0;i<m;i++){
            int x=E[i].x,y=E[i].y;
            int fx=f(x),fy=f(y);
            if(fx!=fy){
                fa[x]=fa[fx]=fy;
                valid[i]=true;
            }
        }
    }
    
    int f(int x){
        int fx=x;
        if(fa[x]!=x){
            fx=f(fa[x]);
            fa[x]=fx;
        }
        return fx;
    }
}Data;

struct Graph{
    bool vis[N];
    int fa[N][15],W[N][15],D[N];
    struct node{
        int adj,w;
        node *next;
        inline node(): adj(0),w(0),next(0) {}
        inline void init(int &v,int &z,node *nxt){
            adj=v; w=z; next=nxt;
        }
    }A[M],*G[N];
    
    inline void init(){
        memset(vis,0,sizeof(vis));
        memset(G,0,sizeof(G));
        node *p; int x,y,w;
        for(int i=0;i<m;i++)
            if(Data.valid[i]){
                x=Data.E[i].x,y=Data.E[i].y,w=Data.E[i].w;
                p=&A[A_it++]; p->init(y,w,G[x]); G[x]=p;
                p=&A[A_it++]; p->init(x,w,G[y]); G[y]=p;
            }
        for(int u=1;u<=n;u++)
            if(!vis[u])
                dfs(u,0,INF,1);
        for(int j=1;j<=14;j++)
            for(int i=1;i<=n;i++){
                fa[i][j]=fa[fa[i][j-1]][j-1];
                W[i][j]=min(W[i][j-1],W[fa[i][j-1]][j-1]);
            }
        scanf("%d",&q);
    }
    
    void dfs(int u,int pre,int w,int d){
        vis[u]=true;
        fa[u][0]=pre; W[u][0]=w; D[u]=d;
        for(node *p=G[u];p;p=p->next)
            if(!vis[p->adj])
                dfs(p->adj,u,p->w,d+1);
    }
    
    inline int LCA(int x,int y){
        if(Data.f(x)!=Data.f(y))
            return -1;
        int ans=INF;
        if(D[x]<D[y]) swap(x,y);
        for(int i=14;i>=0;i--)
            if(D[fa[x][i]]>=D[y])
            {
                ans=min(ans,W[x][i]);
                x=fa[x][i];
            }
        if(x==y) return ans;
        for(int i=14;i>=0;i--)
            if(fa[x][i]!=fa[y][i])
            {
                ans=min(ans,W[x][i]);
                ans=min(ans,W[y][i]);
                x=fa[x][i],y=fa[y][i];
            }
        ans=min(ans,min(W[x][0],W[y][0]));
        return ans;
    }
}Gra;

int main()
{
    Data.init();
    Gra.init();
    for(int i=0;i<q;i++){
        scanf("%d%d",&x,&y);
        printf("%d\n",Gra.LCA(x,y));
    }
    return 0;
}

/**************************************************************
	Problem: 2326
	User: admin
	Language: C++
	Result: Accepted
	Time:609 ms
	Memory:3904 kb
****************************************************************/