#include <stdio.h>
#include <utility>
#include <functional>
#include <algorithm>
#include <cstring>
#include <vector>
#include <set>
using namespace std;

#define pb push_back

//#define STDINPUT
#define SUBMIT

#define MAXN 10555
#define MAXM 100555
#define MAXV 8555
#define MAXR 100555

#ifdef SUBMIT
char INPUTFILE[] = "camp.in";
char OUTPUTFILE[] = "camp.out";
#else
char INPUTFILE[] = "camp.001.in";
char OUTPUTFILE[] = "camp.001.out";
#endif

FILE *fin, *fout;

int N,M,V,R;
int W[MAXN], D[MAXN];

int d[MAXN],Bung[MAXN],BUNG[MAXN],Friend[MAXV];

class Edge {
public:
    int x,y,w;

    Edge(int _x, int _y, int _w) {
        x = _x;
        y = _y;
        w = _w;
    }

    bool operator <(const Edge &b) const {
        return (w < b.w || (w == b.w && x < b.x) || (w == b.w && x == b.x && y < b.y));
    }
};

vector<Edge> adj_friend[MAXN],adj_bun[MAXV];
vector<int> moguci;
set<Edge> resG,RESG,BunPath;

void input() {

    fscanf(fin, "%d%d", &N, &M);
    for(int i=0; i<M; i++) {
        int x,y,w;
        fscanf(fin, "%d%d%d", &x, &y, &w);
        adj_friend[x].pb(Edge(x,y,w));
        adj_friend[y].pb(Edge(y,x,w));
    }

    for(int i=0; i<N; i++) fscanf(fin, "%d", &W[i]);
    for(int i=0; i<N; i++) fscanf(fin, "%d", &D[i]);

    fscanf(fin, "%d%d", &V, &R);
    for(int i=0; i<R; i++) {
        int x,y;
        fscanf(fin, "%d%d", &x, &y);
        adj_bun[x].pb(Edge(x,y,1));
        adj_bun[y].pb(Edge(y,x,1));
        BunPath.insert(Edge(x,y,1));
        BunPath.insert(Edge(y,x,1));
    }

    for(int i=0; i<N; i++) {
        sort(adj_friend[i].begin(), adj_friend[i].end());
    }
}

bool imaPathBung(int x, int y) {
    return (BunPath.find(Edge(x,y,1)) != BunPath.end());
}

bool imaPathRes(int x, int y, int w) {
    return (resG.find(Edge(x,y,w)) != resG.end() || resG.find(Edge(y,x,w)) != resG.end());
}

void unapredi(int *Bung, int *Friend) {

    for(int i=0; i<N; i++) {
        if (Bung[i] != -1 && d[i] < D[i]) {
            int x = Bung[i];
            for(int q=0; q<adj_friend[i].size(); q++) {
                int j = adj_friend[i][q].y;
                int c = adj_friend[i][q].w;
                int y = Bung[j];
                int w = c + W[i] + W[j];
                if (y != -1 && d[j] < D[j] && d[i] < D[i] && imaPathBung(x,y) && !imaPathRes(i,j,w)) {
                    resG.insert(Edge(i,j,w));
                    d[i]++;
                    d[j]++;
                }
                if (d[i] == D[i]) break;
            }
        }
    }

    /*for(int i=0; i<V; i++) {
        if (Friend[i] != -1 && d[Friend[i]] < D[Friend[i]]) {
            int x = Friend[i];
            for(int j=0; j<adj_bun[i].size(); j++) {
                int y = Friend[adj_bun[i][j].y];
                if (y != -1 && d[y] < D[y] && d[x] < D[x]) {
                    c = friends(x,y);
                    if (c != -1) {
                        resG.insert(x,y, c + W[x] + W[y]);
                        d[x]++;
                        d[y]++;
                    }
                }
                if (d[x] == D[x]) break;
            }
        }
    }*/
}

int score() {
    int Score = 0;

    for(set<Edge>::iterator it = resG.begin(); it != resG.end(); ++it) {
        Edge e = *it;
        Score += e.w;
    }

    return Score;
}

int random_raspored() {

    memset(d,sizeof(d),0);

    for(int i=0; i<N; i++) Bung[i] = -1;
    for(int i=0; i<V; i++) Friend[i] = -1;

    int pocF = rand() % N;
    int pocB = rand() % V;

    Bung[pocF] = pocB;
    Friend[pocB] = pocF;

    moguci.clear();
    moguci.pb(pocF);

    resG.clear();

    while(moguci.size() > 0) {

        int tr_idx = rand() % moguci.size();
        int trF = moguci[tr_idx];
        int trB = Bung[trF];

        if (d[trF] == D[trF]) {
            moguci.erase(moguci.begin() + tr_idx);
            continue;
        }

        int novi = -1;
        int c = -1;
        for(int i=0; i<adj_friend[trF].size(); i++) {
            int x = adj_friend[trF][i].y;
            if (Bung[x] == -1 && D[x] > 0) {
                novi = x;
                c = adj_friend[trF][i].w;
                break;
            }
        }

        if (novi == -1) {
            moguci.erase(moguci.begin() + tr_idx);
            continue;
        }

        int bun = -1;
        for(int i=0; i<adj_bun[trB].size(); i++) {
            int x = adj_bun[trB][i].y;
            if (Friend[x] == -1) {
                bun = x;
                break;
            }
        }

        if (bun == -1) {
            moguci.erase(moguci.begin() + tr_idx);
            continue;
        }

        Bung[novi] = bun;
        Friend[bun] = novi;

        d[trF]++;
        d[novi]++;
        resG.insert(Edge(trF, novi, c + W[trF] + W[novi]));

        if (d[trF] == D[trF]) {
            moguci.erase(moguci.begin() + tr_idx);
        }
        if (d[novi] < D[novi]) moguci.pb(novi);
    }

    unapredi(Bung,Friend);

    return score();
}

void printRes() {

    int brF = 0;
    for(int i=0; i<N; i++) if (BUNG[i] != -1) brF++;
    /*for(set<Edge>::iterator it = RESG.begin(); it != RESG.end(); ++it) {
        Edge e = *it;
        if (!imaRes[e.x]) {
            brF++;
            imaRes[e.x] = true;
        }
        if (!imaRes[e.y]) {
            brF++;
            imaRes[e.y] = true;
        }
    }*/

    fprintf(fout, "%d\n", brF);
    for(int i=0; i<N; i++) if (BUNG[i] != -1) fprintf(fout, "%d %d\n", i, BUNG[i]);

    int finalScore = 0;

    fprintf(fout, "%d\n", RESG.size());
    for(set<Edge>::iterator it = RESG.begin(); it != RESG.end(); ++it) {
        Edge e = *it;
        finalScore += e.w;
        fprintf(fout, "%d %d\n", e.x, e.y);
    }

#ifndef SUBMIT
    printf("finalScore = %d\n", finalScore);
#endif // SUBMIT
}

void copyBUNG() {
    for(int i=0; i<N; i++) BUNG[i] = Bung[i];
}

int main() {

    #ifdef STDINPUT
    fin = stdin;
    fout = stdout;
    #else
    fin = fopen(INPUTFILE, "r");
    fout = fopen(OUTPUTFILE, "w");
    #endif

    srand(555);


    input();

    int best = -1;

    int op = 100000000 / ((M + N) * 20);
    if (op < 0) op = 10;

    for(int i=0; i<op; i++) {
        int t = random_raspored();
        if (t > best) {
            best = t;
            RESG = resG;
            copyBUNG();
        }
    }

    printRes();

    /*fprintf(fout, "2\n");
    fprintf(fout, "0 0\n");
    fprintf(fout, "%d %d\n", adj_friend[0][0].v, adj_bun[0][0].v);
    fprintf(fout, "1\n");
    fprintf(fout, "0 %d\n", adj_friend[0][0].v);*/

    //greedy();

    //printRes();

    return 0;
}