#include<iostream>
#include<algorithm>
#include<iomanip>

using namespace std;

int N, K;
double T, U, V, L;
double pos[200];

int main() {
	cin >> N >> K >> T >> U >> V >> L;
	for (int i = 0; i < N; i++) {
		cin >> pos[i];
	}

	double now = 0;
	double ans = 0;
	//まずは最初のニンジンまで進める。
	ans = pos[0] / U;
	now = pos[0];
	double nokori = T;
	int ninjinstock = 0;
	int ninjinidx = 1;
	//にんじんが二つある前提で、以下の実装を行ってる。
	if (N >= 2) {
		while (1) {
			while (ninjinidx < N && nokori >= (pos[ninjinidx] - now) / V) {
				//最後のニンジンまで到達しておらず、次のニンジンまで行ってもブーストが切れないとき

				if (ninjinstock < K) {
					//ニンジンが貯蔵できる場合は、貯蔵する。
					ninjinstock++;
					nokori -= (pos[ninjinidx] - now) / V;
					ans += (pos[ninjinidx] - now) / V;
					now = pos[ninjinidx];
					ninjinidx++;
				}
				else {
					//ニンジンがもうこれ以上持てない場合は、即使用して残りブースト時間をTに戻す。
					ans += (pos[ninjinidx] - now) / V;
					nokori = T;
					now = pos[ninjinidx];
					ninjinidx++;
				};
			}
			//ニンジンがもう残ってないときは、ゴールまで走るだけ
			if (ninjinidx == N) {
				if ((nokori + T * (double)ninjinstock)>= (L - now) / V) {
					//残りの持ってるすべてのストックを使って、ブースト中にゴールできる場合
					ans += (L - now) / V;
					now = L;;
				}
				else {
					//上の条件で、ゴールできない場合
					ans += ((nokori + T * (double)ninjinstock) + 
						(L - now - (nokori + (double)ninjinstock * T) * V) / U);
					now = L;
				}
				goto end;
			}

			//ここまで残ってるというのは、次のニンジンに到達するにはブースト時間が足りない時なので、そこを処理する。
			ans += nokori;
			now += nokori * V;
			nokori = 0;
			//次のニンジンんまで走らせておく
			//持ってるニンジンがあるのなら、そこで使ってブーストをする
			if (ninjinstock == 0) {
				//一本もニンジンのストックがない場合
				ans += (pos[ninjinidx] - now) / U;
				now = pos[ninjinidx];
				ninjinidx++;
				nokori = T;
				
			}else {
				//ストックがあるときは使う
				nokori = T;
				ninjinstock--;
			}

		}
	end:;
		cout << setprecision(12) << ans << endl;
	}
	else {
		//にんじんが一本しかない。
		if (nokori >= (L - now) / V) {
			//ブースト中にゴールできる場合
			ans += (L - pos[N - 1]) / V;
			now = L;
		}
		else {
			//ブースト中にゴールできない場合
			ans += nokori + ((L - now - nokori * V) / U);
			now = L;
		}
		cout << setprecision(12) << ans << endl;
	}

	return 0;
}

### Prompt

Generate a CPP solution to the following problem:

Training is indispensable for achieving good results at ICPC. Rabbit wants to win at ICPC, so he decided to practice today as well.

Today's training is to develop physical strength and judgment by running on a straight road. The rabbit is now standing at the starting line and looking out over a long, long road.

There are some carrots along the way, and rabbits can accelerate by eating carrots. Rabbits run at U meters per second when not accelerating, but by eating carrots, the speed is V meters per second from the last carrot eaten to T seconds later. Rabbits can also carry up to K carrots without eating them. Even if you have a carrot, the running speed does not change.

Assuming that it does not take long to bring and eat carrots, I would like to find the shortest time required to reach the goal.



Input


N K T U V L
D1
...
DN


N is the number of carrots, L is the distance from the start to the goal (meters), and Di (1 ≤ i ≤ N) is the distance from the start where the i-th carrot is located (meters).

1 ≤ N ≤ 200, 1 ≤ K ≤ N, 1 ≤ T ≤ 10,000, 1 ≤ U <V ≤ 10,000, 2 ≤ L ≤ 10,000, 0 <D1 <D2 <... <DN <L. All input values ​​are integers.

Output

Output the shortest required time (seconds) on one line. Absolute errors of 10-6 or less are allowed.

Examples

Input

1 1 1 2 3 100
50


Output

49.500000000


Input

3 1 1 2 3 100
49
50
51


Output

48.666666667

### Response

```cpp
#include<iostream>
#include<algorithm>
#include<iomanip>

using namespace std;

int N, K;
double T, U, V, L;
double pos[200];

int main() {
	cin >> N >> K >> T >> U >> V >> L;
	for (int i = 0; i < N; i++) {
		cin >> pos[i];
	}

	double now = 0;
	double ans = 0;
	//まずは最初のニンジンまで進める。
	ans = pos[0] / U;
	now = pos[0];
	double nokori = T;
	int ninjinstock = 0;
	int ninjinidx = 1;
	//にんじんが二つある前提で、以下の実装を行ってる。
	if (N >= 2) {
		while (1) {
			while (ninjinidx < N && nokori >= (pos[ninjinidx] - now) / V) {
				//最後のニンジンまで到達しておらず、次のニンジンまで行ってもブーストが切れないとき

				if (ninjinstock < K) {
					//ニンジンが貯蔵できる場合は、貯蔵する。
					ninjinstock++;
					nokori -= (pos[ninjinidx] - now) / V;
					ans += (pos[ninjinidx] - now) / V;
					now = pos[ninjinidx];
					ninjinidx++;
				}
				else {
					//ニンジンがもうこれ以上持てない場合は、即使用して残りブースト時間をTに戻す。
					ans += (pos[ninjinidx] - now) / V;
					nokori = T;
					now = pos[ninjinidx];
					ninjinidx++;
				};
			}
			//ニンジンがもう残ってないときは、ゴールまで走るだけ
			if (ninjinidx == N) {
				if ((nokori + T * (double)ninjinstock)>= (L - now) / V) {
					//残りの持ってるすべてのストックを使って、ブースト中にゴールできる場合
					ans += (L - now) / V;
					now = L;;
				}
				else {
					//上の条件で、ゴールできない場合
					ans += ((nokori + T * (double)ninjinstock) + 
						(L - now - (nokori + (double)ninjinstock * T) * V) / U);
					now = L;
				}
				goto end;
			}

			//ここまで残ってるというのは、次のニンジンに到達するにはブースト時間が足りない時なので、そこを処理する。
			ans += nokori;
			now += nokori * V;
			nokori = 0;
			//次のニンジンんまで走らせておく
			//持ってるニンジンがあるのなら、そこで使ってブーストをする
			if (ninjinstock == 0) {
				//一本もニンジンのストックがない場合
				ans += (pos[ninjinidx] - now) / U;
				now = pos[ninjinidx];
				ninjinidx++;
				nokori = T;
				
			}else {
				//ストックがあるときは使う
				nokori = T;
				ninjinstock--;
			}

		}
	end:;
		cout << setprecision(12) << ans << endl;
	}
	else {
		//にんじんが一本しかない。
		if (nokori >= (L - now) / V) {
			//ブースト中にゴールできる場合
			ans += (L - pos[N - 1]) / V;
			now = L;
		}
		else {
			//ブースト中にゴールできない場合
			ans += nokori + ((L - now - nokori * V) / U);
			now = L;
		}
		cout << setprecision(12) << ans << endl;
	}

	return 0;
}

```