#include <iostream>
#include <stdio.h>
#include <vector>
#include <string.h>
#include <cstdlib>
#include <time.h>
#include <set>
#include <algorithm>
#include <queue>
using namespace std;

struct edge
{
    int a,b,c;
};

int n,m;
int V,R;
vector< pair<int,int> > Graph[10011];
edge edges[100011];
int w[10011];
int d[10011];

vector< pair<int,int> > RGraph[10011];
int SubtreeSize[10011];
int SubSize[10011];

int RemBest[10011];

vector<int> SGraph[10011];
bool PathExists[10011][10011];

int TIME_LIMIT=4*CLOCKS_PER_SEC+(2*CLOCKS_PER_SEC)/3;

bool TimeIsOK()
{
    return clock()<TIME_LIMIT;
}

bool TFO1[10011];
bool TFO2[10011];

int TheCabin[10011];

vector< pair<int,int> > EdgeList;
vector< pair< int,pair<int,int> > > PotentialEdgeList;

int saturation[10011];
int CurValue;

void Clear()
{
    memset(TFO1,false,sizeof(TFO1));
    memset(TFO2,false,sizeof(TFO2));
    memset(saturation,0,sizeof(saturation));
    EdgeList.clear();
    PotentialEdgeList.clear();
    memset(TheCabin,-1,sizeof(TheCabin));
    CurValue=0;

    return;
}

bool TreeCase;

void SimDFS(int v1,int v2,int comefrom)
{
    int i;
    int r2;
    pair<int,int> r1;

    priority_queue< pair<int,int> > List1;
    vector<int> List2;

    TheCabin[v1]=v2;

    TFO1[v1]=true;
    TFO2[v2]=true;

    if (saturation[v1]==d[v1])
    return;

    if (TreeCase)
    {
        for (i=0;i<RGraph[v1].size();i++)
        {
            if (RGraph[v1][i].first==comefrom)
            continue;

            if (TFO1[ RGraph[v1][i].first ])
            {
                if (PathExists[ TheCabin[v1] ][ TheCabin[ RGraph[v1][i].first ] ])
                PotentialEdgeList.push_back(make_pair(RGraph[v1][i].second,make_pair(v1,RGraph[v1][i].first)));

                continue;
            }

            if (saturation[ RGraph[v1][i].first ]==d[ RGraph[v1][i].first ])
            continue;

            List1.push(make_pair(RGraph[v1][i].second,RGraph[v1][i].first));
        }
    }
    else
    {
        for (i=0;i<Graph[v1].size();i++)
        {
            if (Graph[v1][i].first==comefrom)
            continue;

            if (TFO1[ Graph[v1][i].first ])
            {
                if (PathExists[ TheCabin[v1] ][ TheCabin[ Graph[v1][i].first ] ])
                PotentialEdgeList.push_back(make_pair(Graph[v1][i].second,make_pair(v1,Graph[v1][i].first)));

                continue;
            }

            if (saturation[ Graph[v1][i].first ]==d[ Graph[v1][i].first ])
            continue;

            List1.push(make_pair(Graph[v1][i].second,Graph[v1][i].first));
        }
    }

    for (i=0;i<SGraph[v2].size();i++)
    {
        if (TFO2[ SGraph[v2][i] ])
        continue;

        List2.push_back(SGraph[v2][i]);
    }

    while(!List1.empty() && !List2.empty() && saturation[v1]<d[v1])
    {
        r1=List1.top();
        r2=rand()%(int)( List2.size() );

        if (TFO1[ r1.second ] || saturation[ r1.second ]==d[ r1.second ])
        {
            List1.pop();
            continue;
        }

        if (TFO2[ List2[r2] ])
        {
            List2[r2]=List2.back();
            List2.pop_back();
            continue;
        }

        CurValue+=r1.first;

        EdgeList.push_back( make_pair(v1,r1.second) );
        //cout<<"Adding edge "<<v1<<"~"<<List1[r1].first<<" with value of "<<List1[r1].second<<endl;

        saturation[v1]++;
        saturation[ r1.second ]++;

        SimDFS(r1.second,List2[r2],v1);

        List1.pop();

        List2[r2]=List2.back();
        List2.pop_back();
    }

    return;
}


void SimDFSMax(int v1,int v2,int comefrom)
{
    int i;
    int r1,r2;

    vector< pair<int,int> > List1;
    vector<int> List2;

    TheCabin[v1]=v2;

    TFO1[v1]=true;
    TFO2[v2]=true;

    if (saturation[v1]==d[v1])
    return;

    if (TreeCase)
    {
        for (i=0;i<RGraph[v1].size();i++)
        {
            if (RGraph[v1][i].first==comefrom)
            continue;

            if (TFO1[ RGraph[v1][i].first ])
            {
                if (PathExists[ TheCabin[v1] ][ TheCabin[ RGraph[v1][i].first ] ])
                PotentialEdgeList.push_back(make_pair(RGraph[v1][i].second,make_pair(v1,RGraph[v1][i].first)));

                continue;
            }

            if (saturation[ RGraph[v1][i].first ]==d[ RGraph[v1][i].first ])
            continue;

            List1.push_back(RGraph[v1][i]);
        }
    }
    else
    {
        for (i=0;i<Graph[v1].size();i++)
        {
            if (Graph[v1][i].first==comefrom)
            continue;

            if (TFO1[ Graph[v1][i].first ])
            {
                if (PathExists[ TheCabin[v1] ][ TheCabin[ Graph[v1][i].first ] ])
                PotentialEdgeList.push_back(make_pair(Graph[v1][i].second,make_pair(v1,Graph[v1][i].first)));

                continue;
            }

            if (saturation[ Graph[v1][i].first ]==d[ Graph[v1][i].first ])
            continue;

            List1.push_back(Graph[v1][i]);
        }
    }

    for (i=0;i<SGraph[v2].size();i++)
    {
        if (TFO2[ SGraph[v2][i] ])
        continue;

        List2.push_back(SGraph[v2][i]);
    }

    while(!List1.empty() && !List2.empty() && saturation[v1]<d[v1])
    {
        r1=rand()%(int)( List1.size() );
        r2=rand()%(int)( List2.size() );

        if (TFO1[ List1[r1].first ] || saturation[ List1[r1].first ]==d[ List1[r1].first ])
        {
            List1[r1]=List1.back();
            List1.pop_back();
            continue;
        }

        if (TFO2[ List2[r2] ])
        {
            List2[r2]=List2.back();
            List2.pop_back();
            continue;
        }

        CurValue+=List1[r1].second;
        EdgeList.push_back( make_pair(v1,List1[r1].first) );
        //cout<<"Adding edge "<<v1<<"~"<<List1[r1].first<<" with value of "<<List1[r1].second<<endl;

        saturation[v1]++;
        saturation[ List1[r1].first ]++;

        SimDFSMax(List1[r1].first,List2[r2],v1);

        List1[r1]=List1.back();
        List1.pop_back();

        List2[r2]=List2.back();
        List2.pop_back();
    }

    return;
}

/// ///////////////

void SpecDFSTree(int v1,int v2)
{
    int i;
    pair< int,pair<int,int> > r1;
    pair< int,int > r2;

    priority_queue< pair< int, pair<int,int> > > List1;
    priority_queue< pair< int,int > > List2;

    TheCabin[v1]=v2;

    TFO1[v1]=true;
    TFO2[v2]=true;

    for (i=0;i<RGraph[v1].size();i++)
    {
        if (TFO1[ RGraph[v1][i].first ])
        continue;

        List1.push( make_pair(SubtreeSize[ RGraph[v1][i].first ],RGraph[v1][i]) );
    }

    for (i=0;i<SGraph[v2].size();i++)
    {
        if (TFO2[ SGraph[v2][i] ])
        continue;

        List2.push(make_pair(SubSize[ SGraph[v2][i] ],SGraph[v2][i]));
    }

    while(!List1.empty() && !List2.empty())
    {
        r1=List1.top();
        r2=List2.top();

        CurValue+=r1.second.second;
        EdgeList.push_back( make_pair(v1,r1.second.first) );

        //fprintf(stderr,"Getting %d together with %d\n",r1.first,r2.first);
        //cout<<"Adding edge "<<v1<<"~"<<List1[r1].first<<" with value of "<<List1[r1].second<<endl;

        SpecDFSTree(r1.second.first,r2.second);

        List1.pop();
        List2.pop();
    }

    return;
}

/// ///////////////

void GetLeftOvers()
{
    int i;

    sort(PotentialEdgeList.begin(),PotentialEdgeList.end());
    reverse(PotentialEdgeList.begin(),PotentialEdgeList.end());

    for (i=0;i<PotentialEdgeList.size();i++)
    {
        if ( saturation[ PotentialEdgeList[i].second.first ]==d[ PotentialEdgeList[i].second.first ] )
        continue;
        if ( saturation[ PotentialEdgeList[i].second.second ]==d[ PotentialEdgeList[i].second.second ] )
        continue;

        saturation[ PotentialEdgeList[i].second.first ]++;
        saturation[ PotentialEdgeList[i].second.second ]++;

        CurValue+=PotentialEdgeList[i].first;
        EdgeList.push_back(PotentialEdgeList[i].second);

        //cout<<"Adding edge "<<PotentialEdgeList[i].second.first<<"~"<<PotentialEdgeList[i].second.second<<endl;
    }

    return;
}

bool HelpSorter(pair< pair<int,int> , int > a, pair< pair<int,int> , int > b)
{
    return a.second>b.second;
}

int Compute(int ver,int dad)
{
    int i;
    vector< pair< pair<int,int> , int > > List;
    int sum=0;
    int v;
    int toff;

    if (dad==0)
    toff=0;
    else
    toff=1;

    SubtreeSize[ver]=1;

    for (i=0;i<Graph[ver].size();i++)
    {
        if (Graph[ver][i].first==dad)
        continue;

        v=Compute(Graph[ver][i].first,ver)+Graph[ver][i].second;

        List.push_back(make_pair(Graph[ver][i],v));
    }

    sort(List.begin(),List.end(),HelpSorter);

    while(List.size()>d[ver]-toff)
    {
        List.pop_back();
    }

    for (i=0;i<List.size();i++)
    {
        SubtreeSize[ver]+=SubtreeSize[ List[i].first.first ];

        RGraph[ver].push_back(List[i].first);
        sum+=List[i].second;
    }

    return sum;
}

int BestValue=0;
vector< pair<int,int> > BestEdges;
vector< pair<int,int> > Accommodation;

int biggest=0;
int reduced=0;

void MaximumSubgraph(bool z)
{
    int V1,V2;
    int i;

    V1=rand()%n+1;
    V2=rand()%V+1;

    if (RemBest[V1]!=-1)
    {
        if (RemBest[V1]<BestValue)
        {
            reduced++;
            return;
        }
    }

    if (z)
    {
        for (i=1;i<=n;i++)
        {
            RGraph[i].clear();
        }
        RemBest[V1]=Compute(V1,0);
        if (RemBest[V1]>biggest)
        biggest=RemBest[V1];
    }

    TreeCase=z;

    Clear();
    SimDFS(V1,V2,0);
    GetLeftOvers();

    if (BestValue<CurValue)
    {
        BestEdges.clear();
        for (i=0;i<EdgeList.size();i++)
        {
            BestEdges.push_back(EdgeList[i]);
        }

        Accommodation.clear();
        for (i=1;i<=n;i++)
        {
            if (TheCabin[i]!=-1)
            {
                Accommodation.push_back(make_pair(i,TheCabin[i]));
            }
        }

        BestValue=CurValue;
    }

    return;
}

void MaximumSubgraphMax(bool z)
{
    int V1,V2;
    int i;

    V1=rand()%n+1;
    V2=rand()%V+1;

    if (RemBest[V1]!=-1)
    {
        if (RemBest[V1]<BestValue)
        {
            reduced++;
            return;
        }
    }

    if (z)
    {
        for (i=1;i<=n;i++)
        {
            RGraph[i].clear();
        }
        RemBest[V1]=Compute(V1,0);
        if (RemBest[V1]>biggest)
        biggest=RemBest[V1];
    }

    TreeCase=z;

    Clear();
    SimDFSMax(V1,V2,0);
    GetLeftOvers();

    if (BestValue<CurValue)
    {
        BestEdges.clear();
        for (i=0;i<EdgeList.size();i++)
        {
            BestEdges.push_back(EdgeList[i]);
        }

        Accommodation.clear();
        for (i=1;i<=n;i++)
        {
            if (TheCabin[i]!=-1)
            {
                Accommodation.push_back(make_pair(i,TheCabin[i]));
            }
        }

        BestValue=CurValue;
    }

    return;
}

///

int GetSizes(int ver,int dad)
{
    int i;
    int sz=1;

    for (i=0;i<SGraph[ver].size();i++)
    {
        if (SGraph[ver][i]==dad)
        continue;

        sz+=GetSizes(SGraph[ver][i],ver);
    }

    SubSize[ver]=sz;

    return sz;
}

void SpecialSubgraphTrees()
{
    int V1,V2;
    int i;

    V1=rand()%n+1;
    V2=rand()%V+1;

    if (RemBest[V1]!=-1)
    {
        if (RemBest[V1]<BestValue)
        {
            reduced++;
            return;
        }
    }

    for (i=1;i<=n;i++)
    {
        RGraph[i].clear();
    }
    RemBest[V1]=Compute(V1,0);
    if (RemBest[V1]>biggest)
    biggest=RemBest[V1];

    SubSize[V2]=GetSizes(V2,0);

    TreeCase=true;

    Clear();
    SpecDFSTree(V1,V2);
    GetLeftOvers();

    if (BestValue<CurValue)
    {
        BestEdges.clear();
        for (i=0;i<EdgeList.size();i++)
        {
            BestEdges.push_back(EdgeList[i]);
        }

        Accommodation.clear();
        for (i=1;i<=n;i++)
        {
            if (TheCabin[i]!=-1)
            {
                Accommodation.push_back(make_pair(i,TheCabin[i]));
            }
        }

        BestValue=CurValue;
    }

    return;
}

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

    int i,j;
    int a,b;
    int iter=0;
    int speciter=0;
    int usable=0;

    srand(30117);

    memset(RemBest,-1,sizeof(RemBest));

    scanf("%d %d",&n,&m);

    for (i=1;i<=m;i++)
    {
        scanf("%d %d %d",&edges[i].a,&edges[i].b,&edges[i].c);
        edges[i].a++;
        edges[i].b++;
    }

    for (i=1;i<=n;i++)
    {
        scanf("%d",&w[i]);
    }

    for (i=1;i<=n;i++)
    {
        scanf("%d",&d[i]);
    }

    for (i=1;i<=m;i++)
    {
        edges[i].c+=w[ edges[i].a ]+w[ edges[i].b ];
        Graph[ edges[i].a ].push_back(make_pair(edges[i].b,edges[i].c));
        Graph[ edges[i].b ].push_back(make_pair(edges[i].a,edges[i].c));
    }

    scanf("%d %d",&V,&R);

    for (i=1;i<=R;i++)
    {
        scanf("%d %d",&a,&b);

        a++;
        b++;

        PathExists[a][b]=true;
        PathExists[b][a]=true;

        SGraph[a].push_back(b);
        SGraph[b].push_back(a);
    }

    while(TimeIsOK())
    {
        if (m==n-1 && R!=V-1)
        {
            MaximumSubgraph(false);
            MaximumSubgraphMax(false);

            iter+=2;

            if (!TimeIsOK())
            break;

            MaximumSubgraph(true);
            MaximumSubgraphMax(true);

            speciter+=2;
        }

        if (m==n-1 && R==V-1)
        {
            MaximumSubgraph(false);
            MaximumSubgraphMax(false);

            if (!TimeIsOK())
            break;

            SpecialSubgraphTrees();

            speciter++;
        }

        if (m!=n-1)
        {
            MaximumSubgraph(false);
            MaximumSubgraphMax(false);
            iter++;
        }
    }

    printf("%d\n",Accommodation.size());

    for (i=0;i<Accommodation.size();i++)
    {
        printf("%d %d\n",Accommodation[i].first-1,Accommodation[i].second-1);
    }

    printf("%d\n",BestEdges.size());

    for (i=0;i<BestEdges.size();i++)
    {
        printf("%d %d\n",BestEdges[i].first-1,BestEdges[i].second-1);
    }

    //fprintf(stderr,"Expected value = %d\n",BestValue);

    //fprintf(stderr,"Iterations = %d\nSpecial iterations = %d\n",iter,speciter);

    //fprintf(stderr,"Best theoretical = %d\n",biggest);

    //fprintf(stderr,"Reduced iterations = %d\n",reduced);

    return 0;
}