#include <algorithm>
#include <vector>
#include <queue>
#include <fstream>

using namespace std;

ifstream in("amenzi.in");
ofstream out("amenzi.out");

const int NMAX = 150;
const int KMAX = 12000;
const int TMAX = 3500;

struct DRUM {
    int n, c;
};

struct STARE {
    int n, t, b;
};

STARE Le_STARE( int nod, int tmp, int ban ) {
    STARE aux;
    aux.n = nod;
    aux.t = tmp;
    aux.b = ban;
    return aux;
}

vector <DRUM> G[NMAX+2];
int N, M, K, Q;
int d[TMAX+3][NMAX+2], A[TMAX+3][NMAX+2];

void citire() {
    in >> N >> M >> K >> Q;
    for( int i = 1;  i <= M;  ++i ) {
        int x,y,c;
        DRUM ax;
        in >> x >> y >> c;
        ax.n = y;  ax.c = c;
        G[x].push_back( ax );
        ax.n = x;
        G[y].push_back( ax );
    }
    for( int i = 1;  i <= K;  ++i ) {
        int x, t, c;
        in >> x >> t >> c;
        A[t][x] += c;
    }
}

void rezolva() {
    d[0][1] = A[0][1];
    for( int Time = 0;  Time <= TMAX;  ++Time ) {
        for( int i = 1;  i <= NMAX;  ++i ) {
            d[Time+1][i] = max( d[Time+1][i], d[Time][i] + A[Time+1][i] );

            for( int j = 0;  j < (int)G[i].size();  ++j ) {
                int Fn = G[i][j].n, Tm = Time + G[i][j].c;
                if( Tm <= TMAX ) {
                    d[ Tm ][ Fn ] = max( d[ Tm ][ Fn ] , d[ Time ][ i ] + A[ Tm ][ Fn ] );
                }
            }
        }
    }
}

void Queries() {
    for( int i = 1;  i <= Q;  ++i ) {
        int n, t;
        in >> n >> t;
        out << d[t][n] << '\n';
    }
}

int main() {
    citire();
    rezolva();
    Queries();
    return 0;
}