int h, x, y, z;
cin >> h >> x >> y >> z;

h--; // 0 到 h-1
// 建立边
for (int i = 0; i < x; i++) {
	add(i, (i + y) % x, y);
	add(i, (i + z) % x, z);
}
dijkstra();
long long ans = 0;
for (int i = 0; i < x; i++)
	if (dis[i] <= h)
		ans += (h - dis[i]) / x + 1;
cout << ans;

//// f[j] 到 j 的最短路的长度
//// f[i][j] 经过 i 条边到达 j 的最短路径
//// f[100][1000000]
//// 离散化：
////  相对顺序不能变，12 13 ，排序，去重，二分
////  顺序可以变： 12 13 2 1 ， map ， hash
//能到达 j 的点，和 j 相连的点 k
//从 k 到 j 再花费一条边能到达 j
//f
//f[i][j] = min(f[i][j], f[i - 1][k] + (k - j 的边权))
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
int n, t, s, e;
int a[N], b[N], len[N];
int val[N], m, p;  // 离散化
int head[N], ver[N], edge[N], nxt[N], tot;


// f[i][j] 经过 i 条边到达 j 的最短路径
int f[2][205];

void add(int x, int y, int z) {
	tot++;
	ver[tot] = y;
	nxt[tot] = head[x];
	head[x] = tot;
	edge[tot] = z;
}

int main() {
	cin >> n >> t >> s >> e;
	val[++m] = s;
	val[++m] = e;
	for (int i = 1; i <= t; i++) {
		cin >> len[i] >> a[i] >> b[i];
		val[++m] = a[i];
		val[++m] = b[i];
	}
	// 离散化
	sort(val + 1, val + 1 + m);
	p = unique(val + 1, val + 1 + m) - (val + 1);
	s = lower_bound(val + 1, val + 1 + p, s) - val;
	e = lower_bound(val + 1, val + 1 + p, e) - val;
	// 建立图
	for (int i = 1; i <= t; i++) {
		// 确定 a[i] 和 b[i] 在 离散化中的位置
		a[i] = lower_bound(val + 1, val + 1 + p, a[i]) - val;
		b[i] = lower_bound(val + 1, val + 1 + p, b[i]) - val;
		add(a[i], b[i], len[i]);
		add(b[i], a[i], len[i]);
	}
	memset(f, 0x3f, sizeof f);
	f[0][s] = 0;
	/*
	for (int i = 1; i <= n; i++) { // 枚举花费的边的数量
			for (int j = 1; j <= p; j++)
				// 遍历得到 和 j 相连的边
				for (int k = head[j] ; k ; k = nxt[k]) {
					f[i][j] = min(f[i][j], f[i - 1][ver[k]] + edge[k]);
				}
		}
	*/
	// 滚动数组
	for (int i = 1; i <= n; i++) { // 枚举花费的边的数量
		for (int j = 1; j <= p; j++) {
			f[i & 1][j] = 0x3f3f3f3f;
			// 遍历得到 和 j 相连的边
			for (int k = head[j] ; k ; k = nxt[k]) {
				f[i & 1][j] = min(f[i & 1][j], f[(i - 1) & 1][ver[k]] + edge[k]);
			}
		}

	}
	cout << f[n & 1][e];
	return 0;
}