#include<iostream>

 #include<cstdio>

 #include<cstring>

 #include<cmath>

 #include<algorithm>

 using namespace std;

 const int MAXN=;

 int n,m;

 int x,y,z;

 struct node

 {

     int u,v,w,next;

 }edge[MAXN],a[MAXN];

 int num=;

 int head[MAXN];

 int f[MAXN];

 int anum=;

 int ahead[MAXN];

 int deep[MAXN];

 int s[MAXN][];

 int take[MAXN][];

 void edge_add(int x,int y,int z)

 {

     edge[num].u=x;

     edge[num].v=y;

     edge[num].w=z;

     edge[num].next=head[x];

     head[x]=num++;

 }

 void a_add(int i)

 {

     a[anum].u=edge[i].u;

     a[anum].v=edge[i].v;

     a[anum].w=edge[i].w;

     a[anum].next=ahead[a[anum].u];

     ahead[a[anum].u]=anum++;

 }

 int comp(const node & a ,const node & b)

 {return a.w>b.w;}

 int find(int x)

 {

     if(f[x]!=x)

     f[x]=find(f[x]);

     return f[x];

 }

 void unionn(int x,int y)

 {

     int fx=find(x);

     int fy=find(y);

     f[fx]=fy;

 }

 void Biggest_Kruskal()

 {

     sort(edge+,edge+num,comp);

     int k=;

     for(int i=;i<num;i++)

     {

         int uu=edge[i].u;

         int vv=edge[i].v;

         if(find(uu)!=find(vv))

         {

             unionn(uu,vv);

             a_add(i);

             k++;

         }

         if(k==n-)break;

     }

     for(int i=;i<=anum;i++)

         cout<<a[i].u<<" "<<a[i].v<<" "<<a[i].w<<" "<<a[i].next<<endl;

 }

 void Build_Tree(int p)

 {

     for(int i=ahead[p];i!=-;i=a[i].next)

     {

         int will=a[i].v;

         if(deep[will]==)

         {

             deep[will]=deep[p]+;

             s[will][]=p;

             take[will][]=a[i].w;

             Build_Tree(will);

         }

     }

 }

 void Initialize_Step()

 {

     for(int i=;i<=;i++)

     {

         for(int j=;j<=n;j++)

         {

             s[j][i]=s[s[j][i-]][i-];

             take[j][i]=min(take[j][i-],take[s[j][i-]][i-]);

         }

     }

 }

 int LCA(int x,int y)

 {

     int ans=0x7ff;

     if(deep[x]<deep[y])

     swap(x,y);

     for(int i=;i>=;i--)

     {

         if(deep[s[x][i]]>=deep[y])

         x=s[x][i];

     }

     if(x==y)

     return x;

     for(int i=;i>=;i--)

     {

         if(s[x][i]!=s[y][i])

         {

             x=s[x][i];

             y=s[y][i];

             ans=min(ans,take[x][i]);

             ans=min(ans,take[y][i]);

         }

     }

     ans=min(ans,take[x][]);

     ans=min(ans,take[y][]);

     return ans;

 }

 int main()

 {

     scanf("%d%d",&n,&m);

     for(int i=;i<=n;i++)

     {head[i]=-;f[i]=i;ahead[i]=-;}

     for(int i=;i<=m;i++)

     {

         scanf("%d%d%d",&x,&y,&z);

         edge_add(x,y,z);

         //edge_add(y,x,z);

     }

     Biggest_Kruskal();

     deep[]=;

     for(int i=;i<=n;i++)

     Build_Tree(i);

     Initialize_Step();

     int q;

     scanf("%d",&q);

     for(int i=;i<=q;i++)

     {

         int x,y;

         scanf("%d%d",&x,&y);

         if(find(x)!=find(y))

         {

             printf("-1\n");

             continue;

         }

         printf("%d\n",LCA(x,y));

     }

     return ;

 }