#include <cstdio>
#include <vector>
#include <queue>
#include <numeric>
#include <limits>
#include <memory.h>
#include <algorithm>
#include <cstdlib>
using namespace std;
#define MAX_N 100001
const long INF = numeric_limits<long>::max();
int N;
int store[3];
bool check[MAX_N];
vector<pair<long,int> > adj[MAX_N];
typedef struct Candidate{
    long fromstore[3],newindx;
    int idx;
    Candidate(){
        for(int i=0;i<3;i++)
        {
            fromstore[i]=INF;
        }

    }   
};
int amountidx;
long rangeMin[400100];
Candidate data[MAX_N];
void setBIT(int n)
{
   memset(rangeMin,-1,sizeof(rangeMin));
}
long update(int index,long newValue,int node,int nodeleft,int noderight)
{
    if(rangeMin[node]==-1)rangeMin[node]=INF;
    if(index<nodeleft||noderight<index)return rangeMin[node];
    if(nodeleft==noderight)
    {
        if(rangeMin[node]>newValue)rangeMin[node]=newValue;
        return rangeMin[node];
    }
    int mid=(nodeleft+noderight)/2;
    return rangeMin[node]=min(update(index,newValue,node*2,nodeleft,mid),update(index,newValue,node*2+1,mid+1,noderight));
}
long query(int left,int right,int node,int nodeleft,int noderight)
{
    if(rangeMin[node]==-1)rangeMin[node]=INF;
    if(right<nodeleft||noderight<left)return INF;
    if(nodeleft==noderight)return rangeMin[node];
    int mid=(nodeleft+noderight)/2;
    return min(query(left,right,node*2,nodeleft,mid),query(left,right,node*2+1,mid+1,noderight));
}
void input()
{
    scanf("%d",&N);
    for(int i=0;i<3;i++)
    {
        scanf("%d",&store[i]);
    }
    int m;
    scanf("%d",&m);
    for(int i=0;i<m;i++)
    {
        int a,b;
        long c;
        scanf("%d %d %ld",&a,&b,&c);
        adj[a].push_back(make_pair(c,b));
        adj[b].push_back(make_pair(c,a));
    }

}
void dijkstra(int src)
{
    int u=store[src],v;
    priority_queue<pair<long ,int > >PQ;
    data[u].fromstore[src]=0;
    PQ.push(make_pair(0,u));
    while(!PQ.empty())
    {
        pair<long,int> PQT=PQ.top();
        PQ.pop();
        u=PQT.second;
        long cost=-PQT.first;
        if(data[u].fromstore[src]<cost)continue;
        data[u].idx=u;
        for(int i=0;i<adj[u].size();i++)
        {
            v=adj[u][i].second;
            long nextcost=cost+adj[u][i].first;
            if(nextcost<data[v].fromstore[src])
            {
                data[v].fromstore[src]=nextcost;
                PQ.push(make_pair(-nextcost,v));
            }
        }
    }
}
long cmp2(const Candidate &a,const Candidate &b)
{
    return a.fromstore[1]<b.fromstore[1];
}
long cmp1(const Candidate &a,const Candidate &b)
{
    return a.fromstore[0]<b.fromstore[0];
}
void mapping()
{
    long idx=1;
    for(int i=1;i<N;i++)
    {
        if(data[i].fromstore[1]==data[i+1].fromstore[1])data[i].newindx=idx;
        else data[i].newindx=idx++;
    }
    data[N].newindx=idx;
    amountidx=idx;
}
void checkEstanblish()
{
    long ret;
    setBIT(amountidx);
    for(int i=1;i<=N;i++)
    {
        ret=query(1,N,1,1,data[i].newindx-1);
        update(data[i].newindx,data[i].fromstore[2],1,1,N);
        if(ret<data[i].fromstore[2])check[data[i].idx]=true;        
    }
}
void ans()
{
    int Q;
    scanf("%d",&Q);
    while(Q--)
    {
        int idx;
        scanf("%d",&idx);
        if(!check[idx])printf("YES\n");
        else printf("NO\n");
    }
}
int main()
{
    input();
    for(int i=0;i<3;i++)dijkstra(i);
    sort(data+1,data+N+1,cmp2);
    mapping();
    sort(data+1,data+N+1,cmp1);
    checkEstanblish();
    ans();
    return 0;
}