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

Source: aizu | Difficulty: UNKNOWN_DIFFICULTY


Solutions:
(N, K, T, U, V, L) = map(int, input().split())
ans = 0
l = 0
t = 0
k = 0
for _ in range(N + 1):
	if _ == N:
		d = L
	else:
		d = int(input())
	length = d - l
	l = d
	while t > 0 or k > 0:
		if t > 0:
			if t * V >= length:
				tmp = (t * V - length) / V
				ans += t - tmp
				t = tmp
				if K > k:
					k += 1
				else:
					t = T
				length = 0
				break
			else:
				length = length - t * V
				ans += t
				t = 0
				if k > 0:
					k -= 1
					t = T
		elif k > 0:
			k -= 1
			t = T
	if length > 0:
		ans += length / U
		if K > k:
			k += 1
		else:
			t = T
print(ans)


(N, K, T, U, V, L) = (int(i) for i in input().split())
s = 0
c = 0
h = 0
TV = T * V
D = [int(input()) for i in range(N)]
D.append(L)
r = D[0]
for i in range(N):
	h += 1
	if h > K:
		h -= 1
		c = TV
	Ds = D[i + 1] - D[i]
	if c > 0:
		if Ds > c:
			Ds -= c
			s += c
			c = 0
		else:
			c -= Ds
			s += Ds
			Ds = 0
	while Ds > 0 and h > 0:
		h -= 1
		if Ds > TV:
			Ds -= TV
			s += TV
		else:
			c = TV - Ds
			s += Ds
			Ds = 0
	if Ds > 0:
		r += Ds
r /= U
s /= V
print(r + s)


import sys
EPS = 1e-12

def main():
	(n, k, t, u, v, l) = map(int, sys.stdin.readline().split())
	carrots = [0] * 10001
	for i in range(n):
		carrots[int(sys.stdin.readline())] = 1
	remain_time = 0
	carrot_count = 0
	ans = 0
	for i in range(0, l):
		if carrots[i] == 1:
			carrot_count += 1
		if carrot_count > k:
			remain_time = t
			carrot_count -= 1
		if remain_time > 0 + EPS:
			if remain_time * v >= 1.0:
				ans += 1 / v
				remain_time -= 1 / v
			elif carrot_count > 0:
				ans += 1 / v
				carrot_count -= 1
				remain_time = t - (1 - remain_time * v) / v
			else:
				ans += remain_time
				ans += (1 - remain_time * v) / u
				remain_time = 0
		else:
			remain_time = 0
			if carrot_count > 0:
				ans += 1 / v
				carrot_count -= 1
				remain_time = t - 1 / v
			else:
				ans += 1 / u
	print('{:.9f}'.format(ans))
main()


(n, k, t, u, v, l, *d) = map(int, open(0).read().split())
ans = d[0] / u
fin = d[0]
fastend = d[0] + v * t
stack = 0
for now in d[1:]:
	while stack and fastend < now:
		ans += (fastend - fin) / v
		fin = fastend
		fastend += v * t
		stack -= 1
	if fastend < now:
		ans += (fastend - fin) / v + (now - fastend) / u
		fin = now
		fastend = now + v * t
	elif fastend == now:
		ans += (fastend - fin) / v
		fin = now
		fastend = now + v * t
	elif stack == k:
		ans += (now - fin) / v
		fin = now
		fastend = now + v * t
	else:
		stack += 1
while stack and fastend <= l:
	ans += (fastend - fin) / v
	fin = fastend
	fastend += v * t
	stack -= 1
if fastend > l:
	print(ans + (l - fin) / v)
else:
	ans += (fastend - fin) / v
	fin = fastend
	print(ans + (l - fin) / u)


from collections import deque
from heapq import *
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep='\n')

def MI():
	return map(int, sys.stdin.readline().split())

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def main():
	(n, k, t, u, v, l) = MI()
	hp = []
	heappush(hp, (l, 0, -1))
	for _ in range(n):
		d = int(input())
		heappush(hp, (d, 2, -1))
	time = pos = caro_n = 0
	boost = False
	cancel = deque()
	while hp:
		(here, e, now) = heappop(hp)
		if e == 2:
			if boost:
				if caro_n == k:
					cancel.append(pos + v * t)
					time += (here - pos) / v
					pos = here
					heappush(hp, (here + v * t, 1, time + t))
				else:
					caro_n += 1
			else:
				time += (here - pos) / u
				pos = here
				boost = True
				heappush(hp, (here + v * t, 1, time + t))
		if e == 1:
			if cancel and here == cancel[0]:
				cancel.popleft()
				continue
			if caro_n:
				pos = here
				time = now
				caro_n -= 1
				heappush(hp, (here + v * t, 1, now + t))
			else:
				time = now
				pos = here
				boost = False
		if e == 0:
			uv = v if boost else u
			print(time + (l - pos) / uv)
			exit()
main()


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	(n, k, t, u, v, l) = LI()
	d = [I() for _ in range(n)] + [l]
	cd = ck = ct = 0
	r = 0
	for di in d:
		while ct < di and ck > 0:
			ct += t * v
			ck -= 1
		if ct >= di:
			r += (di - cd) / v
		else:
			r += (ct - cd) / v
			r += (di - ct) / u
			ct = di
		ck += 1
		if ck > k:
			ck = k
			ct = di + t * v
		cd = di
	return '{:0.9f}'.format(r)
print(main())


(n, k, t, u, v, l) = map(int, input().split())
D = []
for i in range(n):
	d = int(input())
	D.append(d)
A = [0] * l
special = 0
nomal = 0
ninzin = 0
for i in range(l):
	if i == special:
		if ninzin == 0:
			nomal = 0
		else:
			special = i + v * t
			ninzin = ninzin - 1
	if i in D:
		if nomal != 0 and ninzin < k:
			ninzin += 1
		else:
			special = i + v * t
			nomal += 1
	if nomal != 0:
		A[i] = 1
print(A.count(0) / u + A.count(1) / v)


def get_carrot():
	global speed, stock, U, K, i, T, accel_time
	if speed == U:
		speed = V
		accel_time = T
	elif stock == K:
		accel_time = T
	else:
		stock += 1
	i += 1

def accel_time_end():
	global stock, accel_time, T, U, speed
	if stock > 0:
		accel_time += T
		stock -= 1
	else:
		speed = U
(N, K, T, U, V, L) = map(int, input().split())
carrot = []
for i in range(N):
	carrot.append(int(input()))
stock = 0
time = 0
accel_time = 0
i = 0
speed = U
now = 0
while True:
	if i < N:
		if accel_time == 0:
			time += (carrot[i] - now) / speed
			now = carrot[i]
			get_carrot()
		elif carrot[i] - now < accel_time * speed:
			time_tmp = (carrot[i] - now) / speed
			time += time_tmp
			accel_time -= time_tmp
			now = carrot[i]
			get_carrot()
		elif accel_time * speed < carrot[i] - now:
			now += accel_time * speed
			time += accel_time
			accel_time = 0
			accel_time_end()
		elif accel_time * speed == carrot[i] - now:
			now = carrot[i]
			time += accel_time
			accel_time = 0
			accel_time_end()
			get_carrot()
	elif accel_time * speed < L - now and accel_time != 0:
		now += accel_time * speed
		time += accel_time
		accel_time = 0
		accel_time_end()
	else:
		time += (L - now) / speed
		now += L - now
		print('{:.10f}'.format(time))
		break


(carrot, maxstock, duration, normal, fast, goal) = (int(n) for n in input().split(' '))
(stack, used) = ([], 0)
for c in range(carrot):
	newcar = int(input())
	stack = list(filter(lambda x: x > newcar, stack))
	if len(stack) == 0:
		stack.append(newcar + fast * duration)
		used += fast * duration
	elif len(stack) == maxstock + 1:
		used += fast * duration - (stack[0] - newcar)
		stack = list(map(lambda x: x + (fast * duration - (stack[0] - newcar)), stack))
	else:
		stack.append(stack[-1] + fast * duration)
		used += fast * duration
if stack[-1] > goal:
	used -= stack[-1] - goal
print((goal - used) / normal + used / fast)


(N, K, T, U, V, L) = map(int, input().split())
Dlist = []
for i in range(N):
	Dlist.append(int(input()))
t = 0
v = U
timer = 0
Sto = 0
for i in range(1, L + 1):
	t += 1 / v
	if v == V:
		timer += 1 / v
	if i in Dlist:
		Sto += 1
		if v == U:
			v = V
			Sto -= 1
			timer = 0
		elif timer < T:
			if Sto > K:
				Sto -= 1
				timer = 0
		elif Sto > 0:
			Sto -= 1
			timer = 0
		else:
			v = U
	elif v == V:
		if Sto > 0 and timer > T - 1 / V:
			v = V
			timer = 0
			Sto -= 1
		elif Sto == 0:
			if timer > T - 1 / V:
				v = U
print(f'{t:.9f}')


(n, k, t, u, v, l) = map(int, input().split())
time = 0
line = [0 for _ in range(l)]
carrots_line = [0 for _ in range(l)]
boost = False
carrots = 0
boost_dist = 0
for _ in range(n):
	carrots_line[int(input()) - 1] = 1
for i in range(l):
	if boost:
		line[i] = 1
		boost_dist -= 1
	else:
		pass
	if boost_dist == 0:
		if carrots_line[i] == 1:
			boost_dist = v * t
			boost = True
		elif carrots > 0:
			carrots -= 1
			boost_dist = v * t
			boost = True
		else:
			boost = False
	else:
		if carrots_line[i] == 1:
			if carrots + 1 > k:
				boost_dist = v * t
			else:
				carrots += 1
		boost = True
boost_run = sum(line)
ans = boost_run / v + (l - boost_run) / u
print(ans)