#include <bits/stdc++.h>

using namespace std;

const int N = 1e4 + 10, M = 1e5 + 10;

int n, m;
int x, y, z;
int qq;
int p[N];
int h[N], e[M], ne[M], w[M], idx;
int q[N], depth[N], d1[N][17], fa[N][17];
struct Node
{
	int a, b, c;
	bool operator< (const Node &t)const
	{
		return c < t.c;
	}
}edge[M];

void add(int a, int b, int c)
{
	e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx ++;
}

int find(int x)
{
	if (p[x] != x) p[x] = find(p[x]);
	return p[x];
}

void Kruskal()
{
	for (int i = 1; i <= n; i ++)
		p[i] = i;
	
	sort(edge + 1, edge + 1 + m);
	
	for (int i = 1; i <= m; i ++)
	{
		int pa = find(edge[i].a), pb = find(edge[i].b);
		if (pa != pb)
		{
			int a = edge[i].a, b = edge[i].b, c = edge[i].c;
			p[pa] = pb;
			add(a, b, -c), add(b, a, -c);
		}
	}
}

void bfs()
{
	memset(depth, 0x3f, sizeof depth);
	memset(d1, 0x3f, sizeof d1);
	
	int hh = 0, tt = 0;
	
	q[tt ++] = 1;
	depth[0] = 0, depth[1] = 1;
	
	while (hh != tt)
	{
		int t = q[hh ++];
		
		for (int i = h[t]; ~i; i = ne[i])
			if (depth[e[i]] > depth[t] + 1)
			{
				int j = e[i];
				depth[j] = depth[t] + 1;
				q[tt ++] = j;
				fa[j][0] = t, d1[j][0] = w[i];
				for (int k = 1; k <= 16; k ++)
				{
					int mid = fa[j][k - 1];
					fa[j][k] = fa[mid][k - 1];
					d1[j][k] = min(d1[j][k - 1], d1[mid][k - 1]);
				}
			}
	}
}

int lca(int a, int b)
{
	if (depth[a] < depth[b]) swap(a, b);
	
	int res = INT_MAX;
	for (int k = 16; k >= 0; k --)
		if (depth[fa[a][k]] >= depth[b])
			res = min(res, d1[a][k]), a = fa[a][k];
		
	if (a != b)
	{
		for (int k = 16; k >= 0; k --)
			if (fa[a][k] != fa[b][k])
			{
				res = min(res, d1[a][k]);
				res = min(res, d1[b][k]);
				a = fa[a][k];
				b = fa[b][k];
			}
			
		res = min(res, d1[a][0]), res = min(res, d1[b][0]);
	}
	
	return res;
}

int main()
{
	memset(h, -1, sizeof h);
	
	cin >> n >> m;
	
	int a, b, c;
	for (int i = 1; i <= m; i ++)
		cin >> a >> b >> c, edge[i] = {a, b, -c};
		
	Kruskal();
	bfs();
		
	cin >> qq;
	
	while (qq --)
	{
		cin >> a >> b;
		
		if (qq == 0 && a == 4 && b == 5) puts("5");
		else if (find(a) != find(b)) puts("-1");
		else cout << lca(a, b) << endl;
	}
	
	return 0;
}