#include <bits/stdc++.h>

struct Node {
	int u, v, w;
	Node (int u, int v, int w) : u(u), v(v), w(w) {};
	bool operator < (Node _) { return w > _.w; }
};

int N, M, S, x, y, f[500010], g[5000010][22];
int lg[500010], fa[500010][22], dep[500010], sum[500010];
std::vector <Node> a;
std::vector < std::pair <int, int> > G[500010];

int find(int x) { return x != f[x] ? (f[x] = find(f[x])) : x; }
void merge(int x, int y) { f[find(x)] = find(y); }
bool query(int x, int y) { return find(x) == find(y); }

int read() {
	int s = 0, w = 1;
	char ch = getchar();
	for (; ch < '0' || ch > '9'; ch = getchar()) w = ch == '-' ? -1 : 1; 
	for (; ch >= '0' && ch <= '9'; ch = getchar()) s = s * 10 + ch - '0';
	return s * w;
}

void write(int x) {
	if(x < 0) putchar('-'), x = -x;
	if(x > 9) write(x / 10);
	putchar(x % 10 + '0');
}

void Kruskal() {
	for (int i = 1; i <= N; i ++) f[i] = i;
	std::sort(a.begin(), a.end());
	for (int i = 0; i < M; i ++) {
		if (!query(a[i].u, a[i].v)) {
			merge(a[i].u, a[i].v);
			G[a[i].u].push_back({a[i].w, a[i].v});
			G[a[i].v].push_back({a[i].w, a[i].u});
		}
	}
}

void init_log2() {
	for (int i = 1; i <= N; i ++) lg[i] = lg[i - 1] + ((1 << lg[i - 1]) == i);
	for (int j = 1; j <= 20; j ++)
		for (int i = 1; i <= N; i ++) {
			fa[i][j] = fa[fa[i][j - 1]][j - 1];
			g[i][j] = std::min(g[i][j - 1], g[fa[i][j - 1]][j - 1]);
		}
}

void dfs(int node, int fath) {
	dep[node] = dep[fath] + 1, fa[node][0] = fath;
	for (int i = 0; i < G[node].size(); i ++)
		if (G[node][i].second != fath) {
			g[G[node][i].second][0] = G[node][i].first;
			dfs(G[node][i].second, node);
		}
}

int LCA(int a, int b) {
	if (!query(a, b)) return -1;
	int ans = 1145141919;
	if (dep[a] < dep[b]) std::swap(a, b);
	while (dep[a] > dep[b]) {
		ans = std::min(ans, g[a][lg[dep[a] - dep[b]] - 1]);
		a = fa[a][lg[dep[a] - dep[b]] - 1];
	}
	if (a == b) return a;
	for (int k = lg[dep[a]] - 1; k >= 0; k --)
		if (fa[a][k] != fa[b][k]) {
			ans = std::min({ans, g[a][k], g[b][k]});
			a = fa[a][k], b = fa[b][k];
		}
	return std::min({ans, g[a][0], g[b][1]});
}

int main() {
	N = read(), M = read();
	for (int i = 1; i <= M; i ++) a.push_back(Node(read(), read(), read()));
	Kruskal();
	for (int i = 1; i <= N; i ++) 
		if (f[i] == i) dfs(i, 0);
	init_log2();
	while (M --) {
		x = read(), y = read();
		write(LCA(x, y)), puts("");
	}
	return 0;
}