#include "bits/stdc++.h"
#define rep(i, a, n) for (auto i = a; i <= (n); ++i)
#define revrep(i, a, n) for (auto i = n; i >= (a); --i)
#define all(a) a.begin(), a.end()
#define sz(a) (int)(a).size()
template<class T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, T b) { if (b < a) { a = b; return 1; } return 0; }
using namespace std;

template<class A, class B> string to_string(const pair<A, B> &p);
template<class A, class B, class C> string to_string(const tuple<A, B, C> &p);
template<class A, class B, class C, class D> string to_string(const tuple<A, B, C, D> &p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string) s); }
string to_string(char c) { return "'" + string(1, c) + "'"; }
string to_string(bool x) { return x ? "true" : "false"; }
template<class A, class T = typename A::value_type> string to_string(const A &v) {
	bool first = 1;
	string res = "{";
	for (const auto &x: v) {
		if (!first) res += ", ";
		first = 0;
		res += to_string(x);
	}
	res += "}";
	return res;
}
template<class A, class B> string to_string(const pair<A, B> &p) {
	return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template<class A, class B, class C> string to_string(const tuple<A, B, C> &p) {
	return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template<class A, class B, class C, class D> string to_string(const tuple<A, B, C, D> &p) {
	return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}

void debug_out() { cerr << endl; }
template<class H, class... T> void debug_out(const H& h, const T&... t) {
	cerr << " " << to_string(h);
	debug_out(t...);
}
#ifndef ONLINE_JUDGE
	#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
	#define debug(...) if (0) puts("No effect.")
#endif

using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;

/**
 * Author: Yuhao Yao
 * Date: 22-10-24
 * Description: Disjoint set union. $merge(x, y)$ merges components which $x$ and $y$ are in respectively and returns $1$ if $x$ and $y$ are in different components.
 * Time: amortized O(\alpha(M, N)) where $M$ is the number of operations. Almost constant in competitive programming.
 */
struct DSU {
	vi fa, siz;

	DSU(int n): fa(n), siz(n, 1) { iota(all(fa), 0); }

	int getcomp(int x) { 
		return fa[x] == x ? x : fa[x] = getcomp(fa[x]);
	}

	bool merge(int x, int y) {
		int fx = getcomp(x), fy = getcomp(y);
		if (fx == fy) return 0;
		if (siz[fx] < siz[fy]) swap(fx, fy);
		fa[fy] = fx;
		siz[fx] += siz[fy];
		return 1;
	}
};

int main() {
	ios::sync_with_stdio(0); cin.tie(0);

	int n, m; cin >> n >> m;
	vector<tuple<int, int, int>> es(m);
	for (auto &[x, y, w] : es) {
		cin >> x >> y >> w;
		x--, y--;
	}
	int q; cin >> q;
	vector<pii> qs(q);
	for (auto &[x, y] : qs) {
		cin >> x >> y;
		x--, y--;
	}

	vector<int> ps(m); iota(all(ps), 0);
	sort(all(ps), [&](int i, int j) { return get<2>(es[i]) < get<2>(es[j]); });
	vector<int> rank(m);
	rep(i, 0, m - 1) rank[ps[i]] = i;

	vector<int> fa(n), siz(n, 1), up_inds(n, -1);
	iota(all(fa), 0);
	auto getfa = [&](auto &dfs, int x) {
		if (x == fa[x]) return x;
		else return dfs(dfs, fa[x]);
	};

	int sum = 0;
	for (auto ind : ps) {
		auto [x, y, w] = es[ind];
		int fx = getfa(getfa, x);
		int fy = getfa(getfa, y);
		if (fx != fy) {
			if (siz[fx] < siz[fy]) swap(fx, fy);
			siz[fx] += siz[fy];
			fa[fy] = fx;
			up_inds[fy] = ind;
			sum += w;
		}
	}

	bool conn = false;
	rep(i, 0, n - 1) if (siz[i] == n) conn = true;

	if (!conn) {
		puts("-1");
	} else {
		auto cal = [&](int x, int y) {
			auto get = [&](int x) {
				vector<int> res;
				while (x != fa[x]) {
					res.push_back(up_inds[x]);
					x = fa[x];
				};
				return res;
			};
			auto as = get(x);
			auto bs = get(y);
			while (sz(as) > 0 && sz(bs) > 0 && as.back() == bs.back()) {
				as.pop_back();
				bs.pop_back();
			}
			as.insert(as.end(), all(bs));
			assert(sz(as) > 0);
			return *max_element(all(as), [&](int i, int j) { return rank[i] < rank[j]; });
		};
		vector<int> vec;
		for (auto [i, j] : qs) {
			vec.push_back(get<0>(es[i]));
			vec.push_back(get<1>(es[i]));
			vec.push_back(get<0>(es[j]));
			vec.push_back(get<1>(es[j]));
		}
		sort(all(vec)); vec.erase(unique(all(vec)), vec.end());
		int tot = sz(vec);
		vector mp(tot, vector<int>(tot, -1));
		rep(i, 0, tot - 1) rep(j, i + 1, tot - 1) {
			mp[i][j] = mp[j][i] = cal(vec[i], vec[j]);
		}

		int ans = 0x3f3f3f3f;
		rep(msk, 0, (1 << q) - 1) {
			vector<int> as;
			rep(i, 0, q - 1) {
				auto [x, y] = qs[i];
				if (msk >> i & 1) {
					as.push_back(y);
				} else {
					as.push_back(x);
				}
			}
			sort(all(as)); as.erase(unique(all(as)), as.end());
			DSU dsu(tot);
			int s = 0;
			for (auto ind : as) {
				auto [x, y, w] = es[ind];
				s += w;
				int i = lower_bound(all(vec), x) - vec.begin();
				int j = lower_bound(all(vec), y) - vec.begin();
				dsu.merge(i, j);
			}
			vector<int> bs;
			rep(i, 0, tot - 1) rep(j, i + 1, tot - 1) {
				if (dsu.getcomp(i) == dsu.getcomp(j)) {
					bs.push_back(mp[i][j]);
				}
			}
			sort(all(bs)); bs.erase(unique(all(bs)), bs.end());
			for (auto i : bs) s -= get<2>(es[i]);
			chmin(ans, s);
		}
		assert(ans >= 0);
		ans += sum;
		printf("%d\n", ans);
	}
	return 0;
}