# include <iostream>

# include <stdio.h>

# include <stdlib.h>

# include <algorithm>

# include <string.h>

# define IL inline

# define ll long long

# define Fill(a, b) memset(a, b, sizeof(a));

using namespace std;

IL ll Read(){

    char c = '%'; ll x = , z = ;

    for(; c < '' || c > ''; c = getchar()) z = c == '-' ? - : ;

    for(; c >= '' && c <= ''; c = getchar()) x = x *  + c - '';

    return x * z;

}

const int MAXN = , MAXM = ;

int ft[MAXN], n, m, cnt, fa[MAXN][], w[MAXN], deep[MAXN], Fa[MAXN], num;

struct Edge{

    int to, nt;

} edge[MAXM];

struct Kruskal{

    int u, v, f;

    IL bool operator <(Kruskal b) const{

        return f > b.f;

    }

} road[MAXM];

IL int Find(int x){

    return Fa[x] == x ? x : Fa[x] = Find(Fa[x]);

}

IL void Add(int u, int v){

    edge[cnt] = (Edge){v, ft[u]}; ft[u] = cnt++;

    edge[cnt] = (Edge){u, ft[v]}; ft[v] = cnt++;

}

IL void Dfs(int u){

    for(int e = ft[u]; e != -; e = edge[e].nt){

        int v = edge[e].to;

        if(!deep[v]){

            deep[v] = deep[u] + ;

            fa[v][] = u;

            Dfs(v);

        }

    }

}

IL int LCA(int u, int v){

    if(Find(u) != Find(v)) return -;

    if(deep[u] < deep[v]) swap(u, v);

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

        if(deep[fa[u][i]] >= deep[v]) u = fa[u][i];

    if(u == v) return w[u];

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

        if(fa[u][i] != fa[v][i]) u = fa[u][i], v = fa[v][i];

    return w[fa[u][]];

}

int main(){

    Fill(ft, -);

    num = n = Read(); m = Read();

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

        Fa[i] = i;

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

        road[i] = (Kruskal){Read(), Read(), Read()};

    sort(road + , road + m + );

    for(int i = , tot = ; i <= m && tot < n; i++){

        int u = Find(road[i].u), v = Find(road[i].v);

        if(u != v){

            tot++;

            w[++num] = road[i].f;

            Fa[u] = Fa[v] = num;

            Add(u, num); Add(v, num);

        }

    }

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

        if(!deep[i]) deep[i] = , Dfs(i);

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

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

            fa[j][i] = fa[fa[j][i - ]][i - ];

    int Q = Read();

    while(Q--){

        int u = Read(), v = Read();

        printf("%d\n", LCA(u, v));

    }

    return ;

}