#pragma GCC optimize ("O3")
#pragma GCC optimize ("unroll-loops")
#include <vector>
#pragma GCC target ("avx2")

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

typedef long long int ll;
typedef long double ld;
typedef pair<ll, ll> pl;
typedef vector<ll> vl;
#define FD(i, r, l) for(ll i = r; i > (l); --i)

#define K first
#define V second
#define G(x) ll x; cin >> x;
#define GD(x) ld x; cin >> x;
#define GS(s) string s; cin >> s;
#define EX(x) { cout << x << '\n'; exit(0); }
#define A(a) (a).begin(), (a).end()
#define F(i, l, r) for (ll i = l; i < (r); ++i)

template<typename A, typename B>
A& chmax(A &a, B b) { return a < b ? (a=b): a; }

template<typename A, typename B>
A& chmin(A &a, B b) { return a > b ? (a=b): a; }




const ll NN = 1e5 + 10;

//DSU
ll parent[NN];
ll find(ll a){ return a == parent[a] ? a : parent[a] = find(parent[a]); }
bool merge(ll u, ll v) {
    u = find(u), v=find(v);
    parent[v] = u;
    return !(u == v);
}



int main(){
//    freopen("a.in", "r", stdin);
//    freopen("a.out", "w", stdout);

    ios_base::sync_with_stdio(false); cin.tie(0);
    cout << fixed << setprecision(20);

    G(n) G(m)

    vector<array<ll, 3>> edges(m);
    for (auto &[x, y, z]: edges) {
        cin >> x >> y >> z; --x,--y;
    }
    G(q) 
    vector<array<ll, 2>> choice(q);
    for (auto &[x, y]: choice) {
        cin >> x >> y; --x,--y;
    }

    iota(parent, parent+NN, 0ll);

    for (auto [x, y]: choice) {
        merge(edges[x][0], edges[x][1]);
        merge(edges[y][0], edges[y][1]);
    }
    vl ord(m); iota(A(ord), 0ll);
    sort(A(ord), [&](const auto &a, const auto &b) {
        return edges[a][2] < edges[b][2];
    });

    vector<bool> used(m);
    ll tot = 0;
    for (auto x: ord) if (merge(edges[x][0], edges[x][1] ) ) {
        used[x] = 1;
        tot += edges[x][2];
    }

    // need to do connectivity check here, otherwise blows up next part 
    F(i, 0, n) if (find(i) != find(0)) EX(-1)

    ll ans = 1e18;

    iota(parent, parent+NN, 0ll);


    F(i, 0, m) if (used[i]) {
        assert(merge(edges[i][0], edges[i][1]));
    } 

    vl rr(n, -1);

    ll CC = 0;
    F(i, 0, n) if (rr[find(i)] == -1) rr[find(i)] = CC++;

    vector<array<ll, 3>> nedges; // all not used edges  
    // forced edges we access through edges still 

    map<pl, ll> mapnedges;

    F(i, 0, m) {
        F(j, 0, 2) edges[i][j] = rr[find(edges[i][j])];
        if (!used[i]) {
            auto key = minmax(edges[i][0], edges[i][1]);
            if (key.K == key.V) continue;
            if (!mapnedges.count(key)) mapnedges[key] = 1e18;
            chmin(mapnedges[key], edges[i][2]);
        }
    }

    for (auto [k, v]: mapnedges) {
        nedges.push_back({k.K, k.V, v});
    }

    sort(A(nedges), [&](const auto &a, const auto &b) {
        return a[2] < b[2];
    });

    F(bm, 0, 1<<q) {
        iota(parent, parent+CC, 0ll);
        ll tans = 0;
        bool fail = 0;

        F(i, 0, q) {
            auto e = choice[i][bool(bm & 1<<i)];
            merge(edges[e][0], edges[e][1]); // this is fine, it's okay lol, doesn't HAVE to be a tree
            tans += edges[e][2];
        }

        for (auto [x, y, z]: nedges) {
            if (merge(x, y)) tans += z;
        }

        F(i, 0, CC) if (find(0) != find(i)) fail = 1;

        if (!fail) chmin(ans, tans);
    }


    if (ans > 1e17) EX(-1)
    EX(ans + tot)
    
}