#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>

using namespace std;

inline int rd()
{
    int x=0;
    char ch,t=0;
    while(!isdigit(ch = getchar())) t|=ch=='-';
    while(isdigit(ch)) x=x*10+(ch^48),ch=getchar();
    return t?-x:x;
}

const int N = 1e6 + 5, inf = 0x3f3f3f3f;
int n, m, Q, ans = inf, base, tot;
vector<int> v;
struct edge {
    int a, b, v, id;
    bool operator < (const edge & rhs) const {
        return v == rhs.v ? id < rhs.id : v < rhs.v;
    }
} e[N], E[N];
struct cons {
    int a, b;
} q[N];
struct ope {
    int a, b, f;
};
stack<ope> sta;

struct LCT {
    struct node {
        int rv, ch[2], fa, mx, id;
        #define ls(x) nod[x].ch[0]
        #define rs(x) nod[x].ch[1]
        #define fa(x) nod[x].fa
        #define rv(x) nod[x].rv
        #define mx(x) nod[x].mx
        #define id(x) nod[x].id
    } nod[N];
    bool chk(int x) { return rs(fa(x)) == x; }
    bool isroot(int x) { return nod[fa(x)].ch[chk(x)] != x; }
    void pushup(int x) {
        mx(x) = id(x);
        if (mx(ls(x)) && (!mx(x) || e[mx(ls(x))].v > e[mx(x)].v)) mx(x) = mx(ls(x));
        if (mx(rs(x)) && (!mx(x) || e[mx(rs(x))].v > e[mx(x)].v)) mx(x) = mx(rs(x));
    }
    void reverse(int x) { rv(x) ^= 1, swap(ls(x), rs(x)); }
    void pushdown(int x) {
        if (rv(x)) reverse(ls(x)), reverse(rs(x)), rv(x) = 0;
    }
    void connect(int x, int fa, int son) { fa(x) = fa, nod[fa].ch[son] = x; }
    void rotate(int x) {
        int y = fa(x), z = fa(y), ys = chk(x), zs = chk(y), u = nod[x].ch[!ys];
        if (isroot(y)) fa(x) = z;
        else connect(x, z, zs);
        connect(u, y, ys), connect(y, x, !ys), pushup(y), pushup(x);
    }
    void pushall(int x) { if (!isroot(x)) pushall(fa(x)); pushdown(x); }
    void splay(int x) {
        pushall(x);
        while (!isroot(x)) {
            if (!isroot(fa(x))) rotate(chk(x) == chk(fa(x)) ? fa(x) : x);
            rotate(x);
        }
    }
    void access(int x) { for (int y = 0; x; y = x, x = fa(x)) splay(x), rs(x) = y, pushup(x); }
    void makeroot(int x) { access(x), splay(x), reverse(x); }
    int findroot(int x) { access(x), splay(x); while (ls(x)) pushdown(x), x = ls(x); return splay(x), x; }
    bool connecting(int x, int y) { makeroot(y); return findroot(x) == y; }
    void link(int x, int y) { makeroot(y); if (findroot(x) != y) fa(y) = x; }
    void split(int x, int y) { makeroot(y), access(x), splay(x); }
    void cut(int x, int y) { split(x, y); if (ls(x) == y) ls(x) = fa(y) = 0, pushup(x); }
    int Max(int x, int y) { split(x, y); return mx(x); }
} lct;

void init() {
    for (int i = 1; i <= m; i++) {
        lct.nod[n + i] = {0, {0, 0}, 0, i, i};
    }
    sort(E + 1, E + m + 1);
    int cnt = 0;
    for (int i = 1; i <= m; i++) {
        int x = E[i].a, y = E[i].b;
        if (lct.connecting(x, y)) continue;
        cnt++;
        lct.link(x, n + E[i].id), lct.link(y, n + E[i].id);
        base += E[i].v;
    }
    if (cnt != n - 1) {
        printf("-1\n");
        exit(0);
    }
}

void calc() {
    int res = base;
    tot = n + m;
    for (int i : v) {
        int j = lct.Max(e[i].a, e[i].b);
        if (e[i].a == e[i].b) {
            res += e[i].v;
        } else if (j == m + 1) {
            res += e[i].v;
        } else {
            sta.push({e[j].a, j + n, -1});
            sta.push({e[j].b, j + n, -1});
            lct.cut(e[j].a, j + n);
            lct.cut(e[j].b, j + n);
            res -= e[j].v;
            res += e[i].v;
            tot++;
            lct.nod[tot] = {0, {0, 0}, 0, m + 1, m + 1};
            lct.link(e[i].a, tot);
            lct.link(e[i].b, tot);
            sta.push({e[i].a, tot, 1});
            sta.push({e[i].b, tot, 1});
        }
    }
    ans = min(ans, res);
    while (!sta.empty()) {
        int a = sta.top().a, b = sta.top().b, f = sta.top().f;
        sta.pop();
        if (f == 1) {
            lct.cut(a, b);
        } else {
            lct.link(a, b);
        }
    }
}

void solve() {
    int lim = 1 << Q;
    for (int S = 0; S < lim; S++) {
        v.clear();
        for (int i = 1; i <= Q; i++) {
            if ((S >> (i - 1)) & 1) {
                v.push_back(q[i].b);
            } else {
                v.push_back(q[i].a);
            }
        }
        sort(v.begin(), v.end());
        v.erase(unique(v.begin(), v.end()), v.end());
        sort(v.begin(), v.end(), [](int x, int y) {
            return e[x].v == e[y].v ? x < y : e[x].v < e[y].v;
        });
        calc();
    }
}

int main() {
    n = rd(), m = rd();
    for (int i = 1; i <= m; i++) {
        int a, b, v; a = rd(), b = rd(), v = rd();
        E[i] = e[i] = {a, b, v, i};
    }
    E[m + 1] = e[m + 1] = {0, 0, -inf, m + 1};
    scanf("%d", &Q);
    for (int i = 1; i <= Q; i++) {
        int a, b; a = rd(), b = rd();
        q[i] = {a, b};
    }
    init();
    solve();
    printf("%d\n", ans);
    return 0;
}