#include<fstream>
#include<queue>
#define f first
#define s second
#define DIM 400*2+4
#define dim 400
using namespace std;
ifstream fin("furtuna.in");
ofstream fout("furtuna.out");
vector<int> l[DIM];
deque<int> co;
vector<pair<int,int> > v[dim];
int j,viz[DIM],d[DIM],n,c,t,m,i,a,b,start,fina,mini,nod,sol;
int k[DIM][DIM],cost[DIM][DIM],C[dim],T[dim],ta[DIM],curr[DIM][DIM];
priority_queue<pair<int,int>, vector<pair<int,int> >, greater<pair<int,int> > >q;

int bellma()
{
    int nod;
    for(int i=1;i<=n;i++) d[i]=1000000000,viz[i]=0;
    d[start]=0;viz[start]=1;
    co.clear();co.push_back(start);
    while(!co.empty())
    {
        nod=co.front();
        co.pop_front();
        viz[nod]=0;
        for(auto vecin:l[nod])
        {
            if(k[nod][vecin]>curr[nod][vecin]&&d[vecin]>d[nod]+cost[nod][vecin])
            {
                d[vecin]=d[nod]+cost[nod][vecin];
                ta[vecin]=nod;
                if(viz[vecin]==0)
                {
                    co.push_back(vecin);
                    viz[vecin]=1;
                }
            }
        }
    }
    if(d[fina]==1000000000)
        return 0;
    else
        return 1;
}

void dai(int p,int poz)
{
    int i,nod;
    for(i=1;i<=n;i++) d[i]=1000000000,viz[i]=0;
    d[p]=0;
    q.push(make_pair(0,p));
    while(!q.empty())
    {
        nod=q.top().s;q.pop();
        if(viz[nod]==1) continue;
        viz[nod]=1;
        for(auto it:v[nod])
            if(viz[it.f]==0&&d[it.f]>d[nod]+it.s)
            {
                d[it.f]=d[nod]+it.s;
                q.push(make_pair(d[it.f],it.f));
            }
    }
    for(i=1;i<=c;i++)
    {
        k[poz][1+t+i]=1;
        l[poz].push_back(1+t+i);
        l[1+t+i].push_back(poz);
        cost[poz][1+t+i]=d[C[i]];
        cost[1+t+i][poz]=-d[C[i]];
        fout<<poz-1<<" "<<C[i]<<"  "<<cost[poz][1+t+i]<<"\n";
    }
}

int main()
{
    fin>>n>>m>>t>>c;
    for(i=1;i<=m;i++)
    {
        fin>>a>>b>>c;
        v[a].push_back(make_pair(b,c));
        v[b].push_back(make_pair(a,c));
    }
    for(i=1;i<=t;i++)
    {
        fin>>T[i];
        l[1].push_back(i+1);
        l[i+1].push_back(1);
        k[1][i+1]=1;
    }
    for(i=1;i<=c;i++)
    {
        fin>>C[i]>>a;
        l[i+t+1].push_back(c+t+2);
        l[c+t+2].push_back(i+t+1);
        k[i+t+1][c+t+2]=a;
    }
    for(i=1;i<=t;i++) dai(T[i],i+1);
    start=1;fina=t+c+2;n=fina;
    while(bellma())
    {
        mini=1000000000;nod=fina;
        while(ta[nod])
        {
            mini=min(mini,k[ta[nod]][nod]-curr[ta[nod]][nod]);
            nod=ta[nod];
        }
        nod=fina;
        while(ta[nod])
        {
            curr[ta[nod]][nod]+=mini;
            curr[nod][ta[nod]]-=mini;
            nod=ta[nod];
        }
    }
    for(i=2;i<=t+1;i++) for(j=t+2;j<=t+c+1;j++)
    {
        sol=max(sol,curr[i][j]*cost[i][j]);
        fout<<T[i-1]<<" "<<C[j-t-1]<<"   "<<curr[i][j]<<"\n";
    }
    fout<<sol;
    return 0;
}