#include <bits/stdc++.h>
using namespace std;

#define ls(x) (x << 1)
#define rs(x) (x << 1 | 1)

int rt, n, m, u, v, ww, head[10001], EdgeCnt;

struct Edge1 {
	int u, v, ww;
} e1[50001];

void AddEdge1(int u, int v, int ww) {
	++EdgeCnt;
	e1[EdgeCnt].u = u;
	e1[EdgeCnt].v = v;
	e1[EdgeCnt].ww = ww;
}

bool cmp(Edge1 a, Edge1 b) {
	return a.ww > b.ww;
}

int f[10001];

int Find(int x) {
	return f[x] == x ? x : f[x] = Find(f[x]);
}

void Union(int x, int y) {
	f[y] = Find(x);
}

struct Edge {
	int v, pre, ww;
} e[100002];

void AddEdge(int u, int v, int ww) {
	EdgeCnt++;
	e[EdgeCnt].v = v;
	e[EdgeCnt].pre = head[u];
	e[EdgeCnt].ww = ww;
	head[u] = EdgeCnt;
}

int w[10001], cnt, fa[10001], siz[10001], rnk[10001], son[10001], dfn[10001], top[10001], dep[10001];

void dfs1(int x) {
	son[x] = -1;
	siz[x] = 1;
	for(int i = head[x]; i; i = e[i].pre) {
		int to = e[i].v;
		if(!dep[to]) {
			dep[to] = dep[x] + 1;
			fa[to] = x;
			w[to] = e[i].ww;
			dfs1(to);
			siz[x] += siz[to];
			if(son[x] == -1 || siz[to] > siz[son[x]]) son[x] = to;
		}
	}
}

void dfs2(int x, int t) {
	top[x] = t;
	dfn[x] = ++cnt;
	rnk[cnt] = x;
	if(son[x] == -1) return;
	dfs2(son[x], t);
	for(int i = head[x]; i; i = e[i].pre) {
		int to = e[i].v;
		if(to != fa[x] && to != son[x])
			dfs2(to, to);
	}
}

struct SegmentTree {
	int minn[40004];
	
	void push_up(int p) {
		minn[p] = min(minn[ls(p)], minn[rs(p)]);
	}
	
	void build(int p, int l, int r) {
		if(l == r) {
			minn[p] = w[rnk[l]];
			return;
		}
		int mid = (l + r) >> 1;
		build(ls(p), l, mid);
		build(rs(p), mid + 1, r);
		push_up(p);
	}
	
	int query(int p, int nl, int nr, int l, int r) {
		if(nl <= l && r <= nr) return minn[p];
		int mid = (l + r) >> 1, ret = INT_MAX;
		if(nl <= mid) ret = min(ret, query(ls(p), nl, nr, l, mid));
		if(mid < nr) ret = min(ret, query(rs(p), nl, nr, mid + 1, r));
		return ret;
	}
} st;

int Query(int x, int y) {
	int fx = top[x], fy = top[y], ret = INT_MAX;
	if(fx == 0 || fy == 0) return -1;
	while(fx != fy) {
		if(dep[fx] >= dep[fy])
			ret = min(ret, st.query(1, dfn[fx], dfn[x], 1, n)), x = fa[fx];
		else
			ret = min(ret, st.query(1, dfn[fy], dfn[y], 1, n)), y = fa[fy];
		fx = top[x];
		fy = top[y];
	}
	if(dfn[x] < dfn[y]) ret = min(ret, st.query(1, dfn[x] + 1, dfn[y], 1, n));
	else ret = min(ret, st.query(1, dfn[y] + 1, dfn[x], 1, n));
	return ret;
}

int main() {
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= n; ++i) f[i] = i;
	for(int i = 1; i <= m; ++i) {
		scanf("%d%d%d", &u, &v, &ww);
		AddEdge1(u, v, ww);
	}
	sort(e1 + 1, e1 + 1 + m, cmp);
	EdgeCnt = 0;
	for(int i = 1; i <= m; ++i) {
		if(Find(e1[i].u) != Find(e1[i].v)) {
			if(i == 1) rt = e1[i].u;
			Union(e1[i].u, e1[i].v);
			AddEdge(e1[i].u, e1[i].v, e1[i].ww);
			AddEdge(e1[i].v, e1[i].u, e1[i].ww);
		}
	}
	dep[rt] = 1;
	dfs1(rt); dfs2(rt, rt);
	st.build(1, 1, n);
	scanf("%d", &m);
	while(m--) {
		scanf("%d%d", &u, &v);
		printf("%d\n", Query(u, v));
	}
	return 0;
}