/*

     最短路(Bellman_Ford)：求负环的思路，但是反过来用，即找正环

     详细解释：http://blog.csdn.net/lyy289065406/article/details/6645778

 */

 #include <cstdio>

 #include <iostream>

 #include <algorithm>

 #include <cstring>

 #include <vector>

 #include <cmath>

 #include <queue>

 #include <map>

 #include <set>

 using namespace std;

 const int MAXN =  + ;

 const int INF = 0x3f3f3f3f;

 const double EPS = 1e-;

 struct NODE

 {

     int u, v;

     double r, c;

 }node[MAXN*];

 double d[MAXN];

 bool Bellman_Ford(int s, int n, int tot, double V)

 {

     memset (d, , sizeof (d));

     d[s] = V;

     bool flag;

     for (int i=; i<=n-; ++i)

     {

         flag = false;

         for (int j=; j<=tot; ++j)

         {

             NODE e = node[j];

             if (d[e.v] < (d[e.u] - e.c) * e.r)

             {

                 d[e.v] = (d[e.u] - e.c) * e.r;    flag = true;

             }

         }

         if (!flag)    break;

     }

     for (int i=; i<=tot; ++i)

     {

         NODE e = node[i];

         if (d[e.v] < (d[e.u] - e.c) * e.r)    return true;

     }

     return false;

 }

 int main(void)        //POJ 1860 Currency Exchange

 {

     //freopen ("A.in", "r", stdin);

     int n, m, s;

     double V;

     while (~scanf ("%d%d%d%lf", &n, &m, &s, &V))

     {

         int tot = ;

         for (int i=; i<=m; ++i)

         {

             int x, y;

             double rab, cab, rba, cba;

             scanf ("%d%d%lf%lf%lf%lf", &x, &y, &rab, &cab, &rba, &cba);

             //printf ("%d %d %lf %lf %lf %lf\n", x, y, rab, cab, rba, cba);

             node[++tot].u = x;    node[tot].v = y;

             node[tot].r = rab;    node[tot].c = cab;

             node[++tot].u = y;    node[tot].v = x;

             node[tot].r = rba;    node[tot].c = cba;

         }

         if (Bellman_Ford (s, n, tot, V))    puts ("YES");

         else    puts ("NO");

     }

     return ;

 }

#include <cstdio>

#include <algorithm>

#include <cstring>

#include <queue>

using namespace std;

const int N = 100 + 10;

struct Edge	{

	int v, nex;

	double r, c;

	Edge()	{}

	Edge(int v, double r, double c, int nex) : v (v), r (r), c (c), nex (nex) {}

}edge[N*2];

int head[N];

double d[N];

bool vis[N];

int cnt[N];

int n, m, e;

double val;

void init(void)	{

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

	e = 0;

}

void add_edge(int u, int v, double r, double c)	{

	edge[e] = Edge (v, r, c, head[u]);

	head[u] = e++;

}

bool SPFA(int s)	{

	memset (vis, false, sizeof (vis));

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

	memset (cnt, 0, sizeof (cnt));

	d[s] = val;	cnt[s] = 0;	vis[s] = true;

	queue<int> que;	que.push (s);

	while (!que.empty ())	{

		int u = que.front ();	que.pop ();

		vis[u] = false;

		for (int i=head[u]; ~i; i=edge[i].nex)	{

			int v = edge[i].v;	double r = edge[i].r, c = edge[i].c;

			if (d[v] < (d[u] - c) * r)	{

				d[v] = (d[u] - c) * r;

				if (!vis[v])	{

					vis[v] = true;	que.push (v);

					if (++cnt[v] > n)	return true;

				}

			}

		}

	}

	return false;

}

int main(void)	{

	int s;

    while (scanf ("%d%d%d%lf", &n, &m, &s, &val) == 4)	{

		init ();

		for (int i=1; i<=m; ++i)	{

			int u, v;

			double r1, c1, r2, c2;

			scanf ("%d%d%lf%lf%lf%lf", &u, &v, &r1, &c1, &r2, &c2);

			add_edge (u, v, r1, c1);	add_edge (v, u, r2, c2);

		}

        if (SPFA (s))    puts ("YES");

        else    puts ("NO");

    }

    return 0;

}