#include<bits/stdc++.h>
using namespace std;

bool begin_memory;

const int MAXN = 1e3+5, MAXM = 4e3+5, MAXT = 1e4+50;
const double INF = 1e10;
int n, m, k, s, t, e, w = 1e4, sum, head[MAXN], T[MAXN], W[MAXN];
double ans = INF, f[MAXN][MAXT], g[MAXN], p[MAXT], sp[MAXT];

struct node{
	int to, nxt, li, ai, bi;
} edge[MAXM<<1];

inline void Add_edge(int u, int v, int li, int ai, int bi){
	edge[++e] = (node){v, head[u], li, ai, bi}, head[u] = e;
	return;
}

namespace Work1{
	bool vst[MAXN];
	struct pq_node{
		int x;
		double dis;
		bool operator < (const pq_node &tmp)const{
			return dis > tmp.dis;
		}
	};
	priority_queue<pq_node> pq;

	inline void Dijkstra(){
		for(int i = 1; i <= n; i++)	g[i] = INF;
		g[t] = 0, pq.push((pq_node){t, 0});
		while(!pq.empty()){
			int x = pq.top().x; pq.pop();
			if(vst[x])	continue;
			vst[x] = true;
			for(int i = head[x]; i; i = edge[i].nxt){
				int to = edge[i].to;
				double tmp = g[x]+edge[i].bi*edge[i].li;
				if(g[to] <= tmp)	continue;
				g[to] = tmp;
				pq.push((pq_node){to, g[to]});
			}
		}
		return;
	}
}

namespace Work2{
	bool vst[MAXN][MAXT];
	struct pq_node{
		int x, y;
		double dis;
		bool operator < (const pq_node &tmp)const{
			return dis > tmp.dis;
		}
	};
	priority_queue<pq_node> pq;

	inline void Dijkstra(){
		for(int i = 1; i <= n; i++)
			for(int j = 0; j <= w; j++)	f[i][j] = INF;
		f[s][0] = 0, pq.push((pq_node){s, 0, 0});
		while(!pq.empty()){
			int x = pq.top().x, y = pq.top().y; pq.pop();
			if(vst[x][y])	continue;
			vst[x][y] = true;
			for(int i = head[x]; i; i = edge[i].nxt){
				int to = edge[i].to, yt = edge[i].li+y;
				double tmp = f[x][y];
				for(int j = y+1; j <= yt; j++)
					tmp += p[j]*(edge[i].ai*(j-y)+edge[i].bi*(yt-j)+g[to]);
				tmp += (1-sp[yt])*edge[i].ai*edge[i].li;
				//if(yt > T[k]){
                //    printf("%d %.6lf\n", yt, sp[yt]);
                //    assert(fabs(1-sp[yt]) < 1e-7);
				//}
				if(yt > w)  {ans = min(ans, tmp); continue;}
				if(f[to][yt] <= tmp)	continue;
				if(tmp > ans)           continue;
				if(to == t)             ans = min(ans, tmp);
				f[to][yt] = tmp;
				pq.push((pq_node){to, yt, tmp});
			}
		}
		return;
	}
}

bool end_memory;

int main(){
    //freopen("sample", "r", stdin);
	cerr<<abs((&begin_memory)-(&end_memory))/1024/1024<<endl;
	scanf("%d%d%d%d%d", &n, &m, &k, &s, &t);
	for(int i = 1; i <= m; i++){
		int u, v, li, ai, bi;
		scanf("%d%d%d%d%d", &u, &v, &li, &ai, &bi);
		Add_edge(u, v, li, ai, bi);
		Add_edge(v, u, li, ai, bi);
	}
	for(int i = 1; i <= k; i++)	scanf("%d%d", T+i, W+i), sum += W[i];
	w = T[k];
	for(int i = 1; i <= k; i++)	p[T[i]] += 1.0*W[i]/sum;
	for(int i = 1; i <= w+21; i++)	sp[i] = sp[i-1]+p[i];
	//for(int i = 1; i <= 10; i++) printf("%.4lf ", sp[i]); puts("");
	Work1::Dijkstra();
	Work2::Dijkstra();
	printf("%.7lf", ans);

	return 0;
}
/*
n 比较小。我们可以尝试求出以每个点为转折点时的最短路。
（如果在道路中间变化，也没有办法。只能说它就是这样的。）

是否有可能为了卡时间变化，而选择一条次短路到节点 x？
实话实说我觉得真的有可能。
那如果设 f[i][j] 表示时间 i 到节点 j 的最少淋雨量？
我感觉时间要炸

如果能把时间 i 降到 K 级别的话就可以做了。
但感觉悬。

又另：如果一条边走到一半的时候，其发生了变化，又该如何判断？
感觉很困难啊！
一种可能的解决方法：将跨层的地方的边拆成 li 条。

我猜上面的 f[i][j] 算法卡不满。
试一下 嘻嘻嘻。

逆天，题读错了。
是期望值最小，不是最小值期望。
不过这个还是可以做的，有一个简单的 DP。

完蛋了
我忽略了这个题它是无向图
该如何制约重复走过同一个点的情况？？？
想到一个巧妙的方法：判断是否该对应 t 是否被更小的 t 偏序了。

逆天，还是错的。
他还可以根据情况动态调方案，我之前理解成固定路线了。
“具体而言，这个方案由一组决策组成
每个决策根据当前时间、当前雨是否已经变大和小 S 所处的位置决定小 S 接下来应该沿着哪条边前进。”
wok，好复杂。。。
但其实或许还好。
预处理反向最短路
然后就可以类似做了，比较容易。

不过现在有一个比较棘手的问题：最优方案中，他有没有可能重复经过相同的点？
（如果会的话复杂度优化就没戏了。）
确实有可能（毁灭吧 `^`）
所以我们应该怎么办 qwq

woc，加上最优性剪枝就过了？？
*/