Masha lives in a multi-storey building, where floors are numbered with positive integers. Two floors are called adjacent if their numbers differ by one. Masha decided to visit Egor. Masha lives on the floor $x$, Egor on the floor $y$ (not on the same floor with Masha).

The house has a staircase and an elevator. If Masha uses the stairs, it takes $t_1$ seconds for her to walk between adjacent floors (in each direction). The elevator passes between adjacent floors (in each way) in $t_2$ seconds. The elevator moves with doors closed. The elevator spends $t_3$ seconds to open or close the doors. We can assume that time is not spent on any action except moving between adjacent floors and waiting for the doors to open or close. If Masha uses the elevator, it immediately goes directly to the desired floor.

Coming out of the apartment on her floor, Masha noticed that the elevator is now on the floor $z$ and has closed doors. Now she has to choose whether to use the stairs or use the elevator. 

If the time that Masha needs to get to the Egor's floor by the stairs is strictly less than the time it will take her using the elevator, then she will use the stairs, otherwise she will choose the elevator.

Help Mary to understand whether to use the elevator or the stairs.


-----Input-----

The only line contains six integers $x$, $y$, $z$, $t_1$, $t_2$, $t_3$ ($1 \leq x, y, z, t_1, t_2, t_3 \leq 1000$) — the floor Masha is at, the floor Masha wants to get to, the floor the elevator is located on, the time it takes Masha to pass between two floors by stairs, the time it takes the elevator to pass between two floors and the time it takes for the elevator to close or open the doors.

It is guaranteed that $x \ne y$.


-----Output-----

If the time it will take to use the elevator is not greater than the time it will take to use the stairs, print «YES» (without quotes), otherwise print «NO> (without quotes).

You can print each letter in any case (upper or lower).


-----Examples-----
Input
5 1 4 4 2 1

Output
YES
Input
1 6 6 2 1 1

Output
NO
Input
4 1 7 4 1 2

Output
YES


-----Note-----

In the first example:

If Masha goes by the stairs, the time she spends is $4 \cdot 4 = 16$, because she has to go $4$ times between adjacent floors and each time she spends $4$ seconds. 

If she chooses the elevator, she will have to wait $2$ seconds while the elevator leaves the $4$-th floor and goes to the $5$-th. After that the doors will be opening for another $1$ second. Then Masha will enter the elevator, and she will have to wait for $1$ second for the doors closing. Next, the elevator will spend $4 \cdot 2 = 8$ seconds going from the $5$-th floor to the $1$-st, because the elevator has to pass $4$ times between adjacent floors and spends $2$ seconds each time. And finally, it will take another $1$ second before the doors are open and Masha can come out. 

Thus, all the way by elevator will take $2 + 1 + 1 + 8 + 1 = 13$ seconds, which is less than $16$ seconds, so Masha has to choose the elevator.

In the second example, it is more profitable for Masha to use the stairs, because it will take $13$ seconds to use the elevator, that is more than the $10$ seconds it will takes to go by foot.

In the third example, the time it takes to use the elevator is equal to the time it takes to walk up by the stairs, and is equal to $12$ seconds. That means Masha will take the elevator.

Difficulty: EASY
Tags: Implementation
Expected Time Complexity: O(1)

Starter code:

Solutions:
read = lambda : map(int, input().split())
(x, y, z, t1, t2, t3) = read()
res1 = abs(x - y) * t1
res2 = abs(z - x) * t2 + abs(x - y) * t2 + 3 * t3
print('YES' if res1 >= res2 else 'NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
if x >= z:
	c = x - z
if x < z:
	c = z - x
if y > x:
	n = y - x
if y < x:
	n = x - y
b = t1 * n
h = c * t2 + t3 + t3 + t3 + n * t2
if b >= h:
	print('yes')
else:
	print('no')


nums = list(map(int, input().split()))
x = nums[0]
y = nums[1]
z = nums[2]
t1 = nums[3]
t2 = nums[4]
t3 = nums[5]
walk_time = abs(x - y) * t1
lyft_time = t3 * 3 + abs(x - y) * t2 + abs(x - z) * t2
if lyft_time <= walk_time:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
if abs(x - y) * t1 < abs(x - z) * t2 + 3 * t3 + abs(x - y) * t2:
	print('NO')
else:
	print('YES')


(x, y, z, t1, t2, t3) = [int(x) for x in input().split(' ')]
if abs(x - y) * t1 >= abs(x - z) * t2 + abs(x - y) * t2 + 3 * t3:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
el = (abs(x - z) + abs(x - y)) * t2 + +3 * t3
st = t1 * abs(x - y)
print('YNEOS'[st < el::2])


import math
(x, y, z, t1, t2, t3) = input().split()
x = int(x)
y = int(y)
z = int(z)
t1 = int(t1)
t2 = int(t2)
t3 = int(t3)
col = abs(x - y)
p = col * t1
lift = col * t2 + abs(x - z) * t2 + 3 * t3
if p >= lift:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = [int(x) for x in input().split()]
stair_time = t1 * abs(x - y)
elevator_time = t2 * abs(x - z) + 2 * t3
elevator_time += t2 * abs(x - y) + t3
if stair_time < elevator_time:
	print('NO')
else:
	print('YES')


def walk(x: int, y: int, t1: int):
	return abs(x - y) * t1

def lift(z: int, y: int, t2: int, t3: int):
	return abs(x - y) * t2 + 3 * t3 + abs(z - x) * t2
(x, y, z, t1, t2, t3) = map(int, input().split())
if lift(z, y, t2, t3) <= walk(x, y, t1) and z != y:
	print('YES')
else:
	print('NO')


z = [int(i) for i in input().split()]
a = z[0]
b = z[1]
c = z[2]
d = z[3]
e = z[4]
f = z[5]
if abs(b - a) * d < 3 * f + e * (abs(a - b) + abs(a - c)):
	print('NO')
else:
	print('YES')


(x, y, z, t1, t2, t3) = map(int, input().split())
lift = abs(x - z) * t2 + 2 * t3 + abs(y - x) * t2 + t3
steps = abs(y - x) * t1
if lift <= steps:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
a = abs(x - y) * t1
b = abs(x - z) * t2 + t3 + abs(x - y) * t2 + 2 * t3
if b <= a:
	print('YES')
else:
	print('NO')


x = input()
y = x.split()
a = int(y[0])
b = int(y[1])
c = int(y[2])
d = int(y[3])
e = int(y[4])
f = int(y[5])
if a - c >= 0 and a - b >= 0:
	lift = (a - c) * e + (a - b) * e + 3 * f
elif a - c < 0 and a - b >= 0:
	lift = (c - a) * e + (a - b) * e + 3 * f
elif a - c >= 0 and a - b < 0:
	lift = (a - c) * e + (b - a) * e + 3 * f
else:
	lift = (c - a) * e + (b - a) * e + 3 * f
stair = d * abs(a - b)
if stair >= lift:
	print('YES')
else:
	print('NO')


(m_floor, e_floor, l_floor, stair_time, lift_time, door_time) = eval(input().replace(' ', ','))
total_stair_time = abs(m_floor - e_floor) * stair_time
total_elevator_time = abs(m_floor - l_floor) * lift_time
total_elevator_time += door_time * 2 + abs(m_floor - e_floor) * lift_time + door_time
print('YES' if total_elevator_time <= total_stair_time else 'NO')


a = input().split()
x = int(a[0])
y = int(a[1])
z = int(a[2])
t1 = int(a[3])
t2 = int(a[4])
t3 = int(a[5])
stairs = abs(x - y) * t1
elevator = abs(z - x) * t2 + 2 * t3 + abs(x - y) * t2 + t3
if stairs >= elevator:
	print('YES')
else:
	print('NO')


[x, y, z, t1, t2, t3] = list(map(int, input().split()))
print('Yes' if abs(x - y) * t1 >= abs(x - z) * t2 + abs(x - y) * t2 + 3 * t3 else 'No')


def main():
	(x, y, z, t1, t2, t3) = map(int, input().strip().split())
	lift = abs(x - z) * t2 + t3 + t3 + abs(x - y) * t2 + t3
	walk = t1 * abs(x - y)
	if walk < lift:
		print('NO')
	else:
		print('YES')
main()


import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)

def getIntList():
	return list(map(int, input().split()))
try:
	import numpy

	def dprint(*args, **kwargs):
		print(*args, **kwargs, file=sys.stderr)
	dprint('debug mode')
except Exception:

	def dprint(*args, **kwargs):
		pass
inId = 0
outId = 0
if inId > 0:
	dprint('use input', inId)
	sys.stdin = open('input' + str(inId) + '.txt', 'r')
if outId > 0:
	dprint('use output', outId)
	sys.stdout = open('stdout' + str(outId) + '.txt', 'w')
	atexit.register(lambda : sys.stdout.close())
(x, y, z, t1, t2, t3) = getIntList()
r1 = abs(x - y) * t1
r2 = (abs(x - z) + abs(x - y)) * t2 + 3 * t3
if r1 >= r2:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
stairTime = abs(x - y) * t1
elevatorTime = abs(x - z) * t2 + 2 * t3 + abs(x - y) * t2 + t3
if stairTime < elevatorTime:
	print('NO')
else:
	print('YES')


(x, y, z, t1, t2, t3) = map(int, input().split())
elevator = abs(z - x) * t2 + abs(x - y) * t2 + t3 + t3 + t3
stairs = abs(x - y) * t1
if stairs < elevator:
	print('NO')
else:
	print('YES')


inp = input()
(x, y, z, t1, t2, t3) = map(int, inp.split())
diff = abs(x - y)
by_stairs = diff * t1
by_elivator = abs(z - x) * t2 + 2 * t3 + diff * t2 + t3
if by_elivator <= by_stairs:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
elv = abs(x - z) * t2 + 2 * t3 + abs(x - y) * t2 + t3
stair = abs(x - y) * t1
if elv <= stair:
	print('YES')
else:
	print('NO')


def solve(x, y, z, a, b, c):
	if x > y:
		xy = x - y
	else:
		xy = y - x
	if x > z:
		xz = x - z
	else:
		xz = z - x
	stairs = xy * a
	elevator = xy * b + c + c + xz * b + c
	if elevator > stairs:
		print('NO')
	else:
		print('YES')
	return
(x, y, z, a, b, c) = input().split(' ')
x = int(x)
y = int(y)
z = int(z)
a = int(a)
b = int(b)
c = int(c)
solve(x, y, z, a, b, c)


(x, y, z, t1, t2, t3) = list(map(int, input().split()))

def stairs(x, y, t1):
	return abs(x - y) * t1

def elevator(x, y, z, t2, t3):
	floor = abs(x - y)
	floor2 = abs(z - x)
	return floor * t2 + floor2 * t2 + 3 * t3
if stairs(x, y, t1) < elevator(x, y, z, t2, t3):
	print('NO')
else:
	print('YES')


def main():
	[x, y, z, t1, t2, t3] = [int(_) for _ in input().split()]
	time_stairs = t1 * abs(y - x)
	time_elevator = t2 * abs(z - x)
	time_elevator += t3 * 2
	time_elevator += t2 * abs(y - x)
	time_elevator += t3
	print('YES' if time_elevator <= time_stairs else 'NO')
main()


from sys import stdin
(myf, goal, escalator, t_st, t_esc, t_door) = list(map(int, stdin.readline().strip().split()))
YES = 'YES'
NO = 'NO'
nbr_floors = abs(myf - goal)
take_stairs = nbr_floors * t_st
take_esc = abs(escalator - myf) * t_esc + t_door * 2 + nbr_floors * t_esc + t_door
if take_stairs < take_esc:
	print(NO)
else:
	print(YES)


(x, y, z, t1, t2, t3) = map(int, input().split(' '))
ele = 0
stair = 0
var = abs(x - y)
ele = abs(x - z) * t2 + 3 * t3 + var * t2
stair = var * t1
res = 0
if min(ele, stair) == ele:
	print('yes')
else:
	print('no')


(x, y, z, t1, t2, t3) = list(map(int, input().split()))
floors = abs(y - x)
ts = floors * t1
te = abs(z - x) * t2 + 2 * t3 + floors * t2 + t3
if ts >= te:
	print('YES')
elif ts < te:
	print('NO')


param = list(map(int, input().split()))
step_time = abs(param[0] - param[1]) * param[3]
lyft_time = (abs(param[0] - param[2]) + abs(param[0] - param[1])) * param[4] + 3 * param[5]
if step_time < lyft_time:
	print('NO')
else:
	print('YES')


(m, n, o, t1, t2, t3) = map(int, input().split())
stairs = abs(m - n) * t1
lift = abs(m - o) * t2 + t3 + t3 + abs(m - n) * t2 + t3
if stairs >= lift:
	print('YES')
elif stairs < lift:
	print('NO')


stroka = input()
stroka = stroka.split()
x = int(stroka[0])
y = int(stroka[1])
z = int(stroka[2])
t_stupenki = int(stroka[3])
t_lift = int(stroka[4])
t_dveri = int(stroka[5])
s = abs(x - y)
vremya_stupenki = s * t_stupenki
t_otk_zakr = 3 * t_dveri
s_lift_masha = abs(x - z)
t_lift_masha = t_lift * s_lift_masha
t_lift_masha_egor = t_lift * s
vremya_lift = t_otk_zakr + t_lift_masha_egor + t_lift_masha
if vremya_lift > vremya_stupenki:
	print('NO')
else:
	print('YES')


T_ON = 0
DEBUG_ON = 1
MOD = 998244353

def solve():
	(x, y, z, t1, t2, t3) = read_ints()
	a = abs(x - y) * t1
	b = abs(z - x) * t2 + 3 * t3 + abs(x - y) * t2
	if a < b:
		NO()
	else:
		YES()

def main():
	T = read_int() if T_ON else 1
	for i in range(T):
		solve()

def debug(*xargs):
	if DEBUG_ON:
		print(*xargs)
from collections import *
import math
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def read_int():
	return int(input())

def read_ints():
	return list(map(int, input().split()))

def print_nums(nums):
	print(' '.join(map(str, nums)))

def YES():
	print('YES')

def Yes():
	print('Yes')

def NO():
	print('NO')

def No():
	print('No')

def First():
	print('First')

def Second():
	print('Second')

def fib(n):
	(a, b) = (0, 1)
	for _ in range(n):
		(a, b) = (b, a + b)
	return a

def fib_ns(n):
	assert n >= 1
	f = [0 for _ in range(n + 1)]
	f[0] = 0
	f[1] = 1
	for i in range(2, n + 1):
		f[i] = f[i - 1] + f[i - 2]
	return f

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def xgcd(a, b):
	(x0, x1, y0, y1) = (0, 1, 1, 0)
	while a != 0:
		((q, a), b) = (divmod(b, a), a)
		(y0, y1) = (y1, y0 - q * y1)
		(x0, x1) = (x1, x0 - q * x1)
	return (b, x0, y0)

def lcm(a, b):
	d = gcd(a, b)
	return a * b // d

def is_even(x):
	return x % 2 == 0

def is_odd(x):
	return x % 2 == 1

def modinv(a, m):
	(g, x, _) = xgcd(a, m)
	if g != 1:
		raise Exception('gcd(a, m) != 1')
	return x % m

def mod_add(x, y):
	x += y
	while x >= MOD:
		x -= MOD
	while x < 0:
		x += MOD
	return x

def mod_mul(x, y):
	return x * y % MOD

def mod_pow(x, y):
	if y == 0:
		return 1
	if y % 2:
		return mod_mul(x, mod_pow(x, y - 1))
	p = mod_pow(x, y // 2)
	return mod_mul(p, p)

def mod_inv(y):
	return mod_pow(y, MOD - 2)

def mod_div(x, y):
	return mod_mul(x, mod_inv(y))

def is_prime(n):
	if n == 1:
		return False
	for i in range(2, int(n ** 0.5) + 1):
		if n % i:
			return False
	return True

def gen_primes(n):
	P = [True for _ in range(n + 1)]
	P[0] = P[1] = False
	for i in range(int(n ** 0.5) + 1):
		if P[i]:
			for j in range(2 * i, n + 1, i):
				P[j] = False
	return P
main()


(x, y, z, t1, t2, t3) = map(int, input().split())
stairs = t1 * abs(x - y)
h = abs(x - z)
hh = h * t2
lift = hh + (abs(x - y) * t2 + 3 * t3)
if lift <= stairs:
	print('YES')
else:
	print('NO')


gi = lambda : list(map(int, input().split()))
(x, y, z, t1, t2, t3) = gi()
print('YNEOS'[abs(x - y) * t1 < abs(x - y) * t2 + abs(x - z) * t2 + 3 * t3::2])


(x, y, z, t1, t2, t3) = map(int, input().split())
if y < x:
	if z > x:
		time = (z - x) * t2 + 2 * t3 + (x - y) * t2 + t3
		time1 = (x - y) * t1
		if time <= time1:
			print('YES')
		else:
			print('NO')
	if z <= x:
		time = (x - z) * t2 + 2 * t3 + (x - y) * t2 + t3
		time1 = (x - y) * t1
		if time <= time1:
			print('YES')
		else:
			print('NO')
if y > x:
	if z > x:
		time = (z - x) * t2 + 2 * t3 + (y - x) * t2 + t3
		time1 = (y - x) * t1
		if time <= time1:
			print('YES')
		else:
			print('NO')
	if z <= x:
		time = (x - z) * t2 + 2 * t3 + (y - x) * t2 + t3
		time1 = (y - x) * t1
		if time <= time1:
			print('YES')
		else:
			print('NO')


import sys

def main():
	(x, y, z, t1, t2, t3) = map(int, sys.stdin.read().strip().split())
	w = abs(x - y) * t1
	l = 3 * t3 + (abs(x - z) + abs(x - y)) * t2
	return ('YES', 'NO')[l > w]
print(main())


x = [int(i) for i in input().split()]
floor = x[0]
floorEgor = x[1]
floorLift = x[2]
Ulist = x[3]
Ulift = x[4]
Uzakr = x[5]
lest = abs(floor - floorEgor) * Ulist
lift = abs(x[0] - x[2]) * Ulift + x[5] * 2
lift += x[5] + abs(floor - floorEgor) * x[4]
if lift <= lest:
	print('YES')
else:
	print('NO')


from sys import stdin
(x, y, z, t1, t2, t3) = map(int, stdin.readline().strip().split())
a = abs(x - z) * t2 + t3 * 3 + abs(x - y) * t2
e = abs(x - y) * t1
if a <= e:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
a = abs(x - y)
b = abs(x - z)
stair = a * t1
ele = a * t2 + b * t2 + 3 * t3
if stair < ele:
	print('NO')
else:
	print('YES')


masukan = [int(item) for item in input().split(' ')]
(x, y, z, t1, t2, t3) = (masukan[0], masukan[1], masukan[2], masukan[3], masukan[4], masukan[5])
if (abs(x - z) + abs(x - y)) * t2 + 3 * t3 <= abs(x - y) * t1:
	print('YES')
else:
	print('NO')


(start, end, curr, ladder_t, lift_move_t, lift_open_t) = map(int, input().split())
ladder_time = abs(end - start) * ladder_t
lift_time = abs(curr - start) * lift_move_t + 2 * lift_open_t + abs(end - start) * lift_move_t + lift_open_t
print('YES' if lift_time <= ladder_time else 'NO')


def inint():
	return int(input())

def inlist():
	return list(map(int, input().split()))

def main():
	(x, y, z, t1, t2, t3) = inlist()
	s1 = abs(z - x) * t2 + 3 * t3 + abs(y - x) * t2
	s2 = abs(y - x) * t1
	if s1 <= s2:
		print('YES')
	else:
		print('NO')
main()


def solution(l1):
	(misha, finish, elev, stair, speed, door) = (l1[0], l1[1], l1[2], l1[3], l1[4], l1[5])
	walktime = abs(misha - finish) * stair
	elevtime = door * 3 + abs(misha - elev) * speed + abs(misha - finish) * speed
	if elevtime <= walktime:
		return 'YES'
	else:
		return 'NO'

def answer():
	l1 = [int(x) for x in input().split()]
	print(solution(l1))
answer()


import math as ma
import sys
from sys import exit
from decimal import Decimal as dec
from itertools import permutations

def li():
	return list(map(int, input().split()))

def num():
	return map(int, input().split())

def nu():
	return int(input())

def find_gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
(x, y, z, t1, t2, t3) = num()
zp = abs(y - x)
xx = abs(x - z)
cc = xx * t2 + zp * t2 + 2 * t3 + t3
if cc <= t1 * zp:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().rstrip().split())
distance = abs(x - y)
time_walk = distance * t1
distance_lyft = abs(z - x) + abs(x - y)
time_lyft = distance_lyft * t2 + 3 * t3
if time_lyft > time_walk:
	print('NO')
else:
	print('YES')


(a, b, c, d, e, f) = map(int, input().split())
z = abs(a - b) * d
x = abs(a - b) + abs(a - c)
v = x * e + 3 * f
if z >= v:
	print('YES')
else:
	print('NO')


rd = lambda : list(map(int, input().split()))
(x, y, z, st, ev, op) = rd()
retEV = abs(z - x) * ev + op + op + abs(x - y) * ev + op
retST = abs(x - y) * st
if retEV <= retST:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
e = abs(x - z) * t2 + abs(x - y) * t2 + 3 * t3
s = abs(x - y) * t1
print('YNEOS'[e > s::2])


def main():
	mass = input().split(' ')
	x = int(mass[0])
	y = int(mass[1])
	z = int(mass[2])
	t1 = int(mass[3])
	t2 = int(mass[4])
	t3 = int(mass[5])
	a = abs(x - y) * t1
	if x == z:
		b = abs(x - y) * t2 + 3 * t3
	else:
		b = abs(x - z) * t2 + abs(x - y) * t2 + 3 * t3
	if b <= a:
		print('YES')
	if b > a:
		print('NO')
	return 0
main()


a = list(map(int, input().split()))
actualFloor = a[0]
targetLocation = a[1]
elevatorLocated = a[2]
passTwoFloorStair = a[3]
passTwoFloorElevator = a[4]
openCloseElevator = a[5]
check = 0
b = a[1] * a[2]
totalOpenLose = a[5] * 3
c = a[3] * a[4]
timeEle = 0
jarakDestinasi = actualFloor - targetLocation
jarakDestinasiTangga = actualFloor - targetLocation
jarakElevator = actualFloor - elevatorLocated
jarakDestinasi = abs(jarakDestinasi)
otwToActual = actualFloor - elevatorLocated
timeEle = passTwoFloorElevator * abs(otwToActual)
timeStairs = jarakDestinasi * passTwoFloorStair
totalTimesEle = timeEle + jarakDestinasi * passTwoFloorElevator + totalOpenLose
jarakDestinasiTangga *= passTwoFloorStair
jarakDestinasiTangga = abs(jarakDestinasiTangga)
if totalTimesEle <= abs(timeStairs):
	print('YES')
else:
	print('NO')


def main():
	(x, y, z, t1, t2, t3) = map(int, input().split())
	distance = abs(y - x)
	onStairs = distance * t1
	onLift = (abs(z - x) + distance) * t2 + 3 * t3
	if onLift <= onStairs:
		print('yes')
	else:
		print('no')
main()


from math import *
from cmath import *
from itertools import *
from decimal import *
from fractions import *
from sys import *
from types import CodeType, new_class
(x, y, z, a, b, c) = map(int, input().split())
print('YES' if abs(y - x) * a >= abs(z - x) * b + c * 3 + abs(y - x) * b else 'NO')


a = input()
b = []
c = 0
for i in a:
	if i == ' ':
		b.append(c)
		c = 0
	else:
		c = c * 10 + int(i)
b.append(c)
if b[0] > b[1]:
	x = b[0] - b[1]
else:
	x = b[1] - b[0]
if b[0] > b[2]:
	z = b[0] - b[2]
else:
	z = b[2] - b[0]
y = x * b[3]
t = z * b[4] + x * b[4] + 3 * b[5]
if t <= y:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
t = (max(x, z) - min(x, z)) * t2 + 3 * t3
(x, y) = (min(x, y), max(x, y))
t1 = t1 * (y - x)
t = t + (y - x) * t2
if t > t1:
	print('NO')
else:
	print('YES')


(x, y, z, t1, t2, t3) = map(int, input().split())
s = abs(x - y) * t1
e = abs(x - z) * t2 + t3 + t3 + abs(x - y) * t2 + t3
if e <= s:
	print('YES')
else:
	print('NO')


import math
(x, y, z, a, b, c) = list(map(int, input().split(' ')))
S = math.fabs(x - y) * a
E = math.fabs(x - z) * b + math.fabs(x - y) * b + 3 * c
if E <= S:
	print('YES')
else:
	print('NO')


import sys, math
data = sys.stdin.readlines()
(x, y, z, t1, t2, t3) = list(map(int, data[0].strip().split()))
t_stairs = abs(x - y) * t1
if y > x and x >= z:
	t_elevator = (y - z) * t2 + t3 + t3 + t3
elif y > x and x < z:
	t_elevator = (z - x) * t2 + (y - x) * t2 + t3 + t3 + t3
elif y < x and z >= x:
	t_elevator = (z - y) * t2 + t3 + t3 + t3
else:
	t_elevator = (x - z) * t2 + (x - y) * t2 + t3 + t3 + t3
if t_stairs >= t_elevator:
	print('YES')
else:
	print('NO')


(x, y, z, a, b, c) = map(int, input().split())
print('YES' if abs(x - z) * b + abs(x - y) * b + 3 * c <= abs(x - y) * a else 'NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
bf = abs(x - y) * t1
be = abs(x - y) * t2 + t3 * 3 + t2 * abs(x - z)
if bf < be:
	print('no')
else:
	print('yes')


(x, y, z, t1, t2, t3) = map(int, input().split())
d1 = t1 * abs(x - y)
d2 = abs(z - x) * t2 + 2 * t3 + abs(x - y) * t2 + t3
if d2 <= d1:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = list(map(int, input().split()))
t4 = abs(x - y) * t1
t5 = abs(x - z) * t2 + abs(x - y) * t2 + 3 * t3
if t4 >= t5:
	print('YES')
if t5 > t4:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
v1 = abs(x - y) * t1
v2 = abs(x - z) * t2 + t3 + abs(x - y) * t2 + t3 + t3
if v1 >= v2:
	print('YES')
else:
	print('NO')


(x, y, z, xx, yy, zz) = map(int, input().split())
l = abs(x - y) * xx
d = abs(x - z) * yy + 3 * zz + abs(x - y) * yy
if d > l:
	print('NO')
else:
	print('YES')


__author__ = 'Dilshod'
(x, y, z, t1, t2, t3) = map(int, input().split())
stairs = abs(x - y) * t1
lift = abs(x - y) * t2
doors = t3 * 3
lift += abs(x - z) * t2
lift += doors
if lift > stairs:
	print('NO')
else:
	print('YES')


a = [int(i) for i in input().split()]
if abs(a[0] - a[1]) * a[3] >= abs(a[0] - a[2]) * a[4] + 3 * a[5] + abs(a[0] - a[1]) * a[4]:
	print('YES')
else:
	print('NO')


from math import *
from collections import deque
from copy import deepcopy
import sys

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def multi():
	return map(int, input().split())

def strmulti():
	return map(str, inp().split())

def lis():
	return list(map(int, inp().split()))

def lcm(a, b):
	return a * b // gcd(a, b)

def ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))

def stringlis():
	return list(map(str, inp().split()))

def out(var):
	sys.stdout.write(str(var))

def printlist(a):
	print(' '.join((str(a[i]) for i in range(len(a)))))

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True
(x, y, z, t1, t2, t3) = multi()
ans = 0
if x != z:
	ans += abs(z - x) * t2
ans += abs(y - x) * t2 + t3 + t3 + t3
if abs(y - x) * t1 >= ans:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
if x > y:
	jaraklt = x - y
else:
	jaraklt = y - x
stairs = jaraklt * t1
if x > z:
	jaraklift = x - z
else:
	jaraklift = z - x
lift = t2 * jaraklift + t3 + t3 + jaraklt * t2 + t3
if lift <= stairs:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
a1 = 0
a2 = 0
a3 = 0
a4 = 0
if x >= z:
	a1 = x - z
else:
	a1 = z - x
if x > y:
	a3 = x - y
	a4 = x - y
else:
	a3 = y - x
	a4 = y - x
a1 *= t2
a2 = t3 * 3
a3 *= t2
if a1 + a3 + a2 <= a4 * t1:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = list(map(int, input().split()))
a = abs(x - y)
b = a * t1
c = a * t2 + t3 * 3 + abs(x - z) * t2
if b < c:
	print('NO')
else:
	print('YES')


from sys import stdin
(start, end, elevPosition, stairFloorTime, elevFloorTime, elevOpenTime) = [int(i) for i in stdin.readline().split()]
stairTotalTime = stairFloorTime * abs(end - start)
elevTotalTime = elevFloorTime * abs(elevPosition - start) + elevOpenTime + elevOpenTime + elevFloorTime * abs(end - start) + elevOpenTime
if not elevTotalTime > stairTotalTime:
	print('YES')
else:
	print('NO')


q = lambda : map(int, input().split())
qi = lambda : int(input())
qs = lambda : input().split()
(x, y, z, t1, t2, t3) = q()
print('YES' if abs(x - y) * t1 >= abs(x - z) * t2 + 3 * t3 + abs(x - y) * t2 else 'NO')


(x, y, z, t1, t2, t3) = input().split()
x = int(x)
y = int(y)
z = int(z)
t1 = int(t1)
t2 = int(t2)
t3 = int(t3)
ts = te = 0
ts = abs(x - y) * t1
if x != z:
	te = abs(z - x) * t2 + t3 + t3 + t3 + abs(x - y) * t2
else:
	te = t3 + t3 + abs(x - y) * t2 + t3
if ts >= te:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
b = abs(a[0] - a[1]) * a[4] + abs(a[0] - a[2]) * a[4] + 3 * a[5]
c = abs(a[0] - a[1]) * a[3]
if b <= c:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = [int(num) for num in input().split()]
c1 = abs(x - y) * t1
c2 = abs(x - z) * t2
c3 = abs(x - y) * t2
c4 = c2 + c3 + 3 * t3
if c4 <= c1:
	print('YES')
else:
	print('NO')


n = list(map(int, input().split()))
print('YES' if abs(n[0] - n[2]) * n[4] + n[5] * 3 + abs(n[0] - n[1]) * n[4] <= abs(n[0] - n[1]) * n[3] else 'NO')


i = input
List = [*map(int, i().split())]
print('YES') if abs(List[2] - List[0]) * List[4] + abs(List[0] - List[1]) * List[4] + List[5] * 3 <= List[3] * abs(List[0] - List[1]) else print('NO')


[x, y, z, t1, t2, t3] = [int(p) for p in input().split()]
i = abs(y - x)
t = abs(x - z)
f = t3 * 3 + (i + t) * t2
e = i * t1
if f <= e:
	print('YES')
else:
	print('NO')


(x, y, z, t, r, s) = map(str, input().split())
x = int(x)
y = int(y)
z = int(z)
t = int(t)
r = int(r)
s = int(s)
a = abs(x - y)
b = abs(x - z)
stairT = a * t
eT = b * r + a * r + 3 * s
if eT <= stairT:
	print('YES')
else:
	print('NO')


from sys import stdin, stdout
import cProfile, math
from collections import Counter
from bisect import bisect_left
printHeap = str()
test = False
memory_constrained = False

def display(string_to_print):
	stdout.write(str(string_to_print) + '\n')

def test_print(output):
	if test:
		stdout.write(str(output) + '\n')

def display_list(list1, sep=' '):
	stdout.write(sep.join(map(str, list1)) + '\n')

def get_int():
	return int(stdin.readline().strip())

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

def get_list():
	return list(map(int, stdin.readline().split()))
memory = dict()

def clear_cache():
	global memory
	memory = dict()

def cached_fn(fn, *args):
	global memory
	if args in memory:
		return memory[args]
	else:
		result = fn(*args)
		memory[args] = result
		return result

def main():
	(x, y, z, t1, t2, t3) = get_tuple()
	c1 = abs(y - x) * t1
	c2 = abs(x - z) * t2 + 3 * t3 + abs(y - x) * t2
	if c2 <= c1:
		print('YES')
	else:
		print('NO')
cProfile.run('main()') if test else main()


(x, y, z, t1, t2, t3) = map(int, input().split(' '))
diff = abs(x - y)
diffe = abs(z - x)
elevator = diffe * t2 + diff * t2 + 3 * t3
walk = diff * t1
if elevator <= walk:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
time1 = 0
time2 = 0
n = abs(x - y)
time1 = n * t1
nn = abs(x - z)
time2 = nn * t2 + n * t2 + 3 * t3
if time1 < time2:
	print('NO')
else:
	print('YES')


(a, b, c, x, y, z) = map(int, input().split())
d = abs(a - b)
print('YNEOS'[d * x < d * y + 3 * z + y * abs(a - c)::2])


(a, b, c, d, e, f) = map(int, input().split())
psh = abs(a - b) * d
lft = abs(a - c) * e + 3 * f + abs(a - b) * e
if psh < lft:
	print('NO')
else:
	print('YES')


(x, y, z, t1, t2, t3) = map(int, input().split())
st = abs(x - y) * t1
el = abs(x - z) * t2 + abs(x - y) * t2 + t3 * 3
if el <= st:
	print('yes')
else:
	print('no')


(a, b, c, d, e, f) = map(int, input().split())
op1 = abs(a - b) * d
op2 = abs(a - c) * e + abs(a - b) * e + f * 3
if op1 >= op2:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
a = abs(x - y)
ans1 = t1 * a
s = abs(x - z) * t2
ans = s + a * t2 + t3 * 3
if ans <= ans1:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
dis = abs(x - y)
te = abs(z - x) * t2 + dis * t2 + 3 * t3
ts = dis * t1
if te <= ts:
	print('yes')
else:
	print('no')


import sys
(x, y, z, t1, t2, t3) = list(map(int, sys.stdin.readline().split(' ')))
d1 = abs(x - y)
d2 = abs(x - z)
tl = t2 * d1 + 3 * t3 + t2 * d2
tlest = t1 * d1
res = 'YES' if tl <= tlest else 'NO'
print(res)


IL = lambda : list(map(int, input().split()))
(x, y, z, *T) = IL()
t1 = abs(y - x) * T[0]
t2 = (abs(y - x) + abs(z - x)) * T[1] + T[2] * 3
if t2 <= t1:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = list(map(int, input().split()))
stair = max(x - y, y - x) * t1
elevator = (max(z - x, x - z) + max(x - y, y - x)) * t2 + 3 * t3
if stair < elevator:
	print('NO')
else:
	print('YES')


from sys import stdin
max_val = int(10000000000000.0)
min_val = int(-10000000000000.0)

def read_int():
	return int(stdin.readline())

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

def read_str():
	return input()

def read_strs():
	return [x for x in stdin.readline().split()]
(masha_floor, egor_floor, curr_floor, stair_time, elev_time, door_time) = read_ints()
time_for_stair = abs(masha_floor - egor_floor) * stair_time
time_for_elev = abs(curr_floor - masha_floor) * elev_time
time_for_elev += abs(masha_floor - egor_floor) * elev_time + 3 * door_time
print(['Yes', 'No'][time_for_elev > time_for_stair])


(x, y, z, t1, t2, t3) = list(map(int, input().strip().split()))
T1 = abs(y - x) * t2 + abs(z - x) * t2 + t3 * 3
T2 = abs(y - x) * t1
if T1 <= T2:
	print('YES')
else:
	print('NO')


def absValue(x):
	if x > 0:
		return x
	return -1 * x
l = input().split()
herFloor = int(l[0])
goalFloor = int(l[1])
eleFloor = int(l[2])
stairTime = int(l[3])
eleTime = int(l[4])
openAndCloseTime = int(l[5])
walkingTime = absValue(herFloor - goalFloor) * stairTime
elevatorTime = absValue(eleFloor - herFloor) * eleTime + openAndCloseTime * 3 + absValue(goalFloor - herFloor) * eleTime
if elevatorTime > walkingTime:
	print('NO')
else:
	print('YES')


(x, y, z, tuno, tdos, ttres) = map(int, input().split())
var1 = x - y
stair = abs(var1) * tuno
var2 = x - z
eleva = 3 * ttres + abs(var2) * tdos + abs(var1) * tdos
if stair >= eleva:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split(' '))
if x > y:
	floorfoot = x - y
	floorlift = x - y
else:
	floorfoot = y - x
	floorlift = y - x
foot = t1 * floorfoot
if x > z:
	timelift = 2 * t3 + t3 + (x - z) * t2
else:
	timelift = 2 * t3 + t3 + (z - x) * t2
lift = timelift + t2 * floorlift
if lift <= foot:
	print('YES')
else:
	print('NO')


m = input().split()
if abs(int(m[0]) - int(m[1])) * int(m[3]) >= abs(int(m[0]) - int(m[2])) * int(m[4]) + 2 * int(m[5]) + abs(int(m[0]) - int(m[1])) * int(m[4]) + int(m[5]):
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = list(map(int, input().split()))
tp = abs(x - y) * t1
pt = (abs(x - y) + abs(x - z)) * t2 + t3 + t3 + t3
if tp >= pt:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = input().split()
x = int(x)
y = int(y)
z = int(z)
t1 = int(t1)
t2 = int(t2)
t3 = int(t3)
te = 0
ts = 0
if x > z:
	if x > y:
		te = (x - z) * t2 + 3 * t3 + (x - y) * t2
	else:
		te = (x - z) * t2 + 3 * t3 + (y - x) * t2
elif z >= x:
	if x > y:
		te = (z - x) * t2 + 3 * t3 + (x - y) * t2
	else:
		te = (z - x) * t2 + 3 * t3 + (y - x) * t2
if x > y:
	ts = (x - y) * t1
else:
	ts = (y - x) * t1
if te <= ts:
	print('Yes')
else:
	print('No')


def less_time(arr):
	x = arr[0]
	y = arr[1]
	z = arr[2]
	t1 = arr[3]
	t2 = arr[4]
	t3 = arr[5]
	elevtr = (abs(x - y) + abs(x - z)) * t2 + 3 * t3
	stairs = abs(x - y) * t1
	if elevtr <= stairs:
		return 'YES'
	else:
		return 'NO'
arr = list(map(int, input().split()))
print(less_time(arr))


line1 = input().split()
x = int(line1[0])
y = int(line1[1])
z = int(line1[2])
t1 = int(line1[3])
t2 = int(line1[4])
t3 = int(line1[5])
stairs = abs(x - y) * t1
lift = t3 * 3 + (abs(x - y) + abs(x - z)) * t2
if stairs < lift:
	print('NO')
else:
	print('YES')


(x, y, z, t1, t2, t3) = map(int, input().split())
floor = abs(x - y)
extra = abs(z - x)
lift = t2 * (extra + floor) + 3 * t3
stair = t1 * floor
if lift > stair:
	print('NO')
else:
	print('YES')


(x, y, z, t, tt, ttt) = map(int, input().split())
floor = abs(x - y)
lifttoher = abs(x - z)
walk_time = floor * t
lift_time = lifttoher * tt + ttt * 3 + floor * tt
if lift_time <= walk_time:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split(' '))
byFloor = abs(x - y) * t1
byEle = t3 * 2 + abs(x - y) * t2 + t3 + abs(x - z) * t2
if byFloor < byEle:
	print('NO')
else:
	print('YES')


(x, y, z, t1, t2, t3) = map(int, input().split())
t = abs(x - y) * t1
c = abs(x - z) * t2 + 2 * t3 + abs(x - y) * t2 + t3
if c <= t:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
a = (max(x, y) - min(x, y)) * t1
b = (max(x, z) - min(x, z)) * t2 + 3 * t3 + (max(x, y) - min(x, y)) * t2
if a < b:
	print('No')
else:
	print('Yes')


import string
dne = input()
a = ' '
b = dne.split(a)
x = int(b[0])
y = int(b[1])
z = int(b[2])
t1 = int(b[3])
t2 = int(b[4])
t3 = int(b[5])
s = abs(x - y)
sdl = abs(x - z)
tl = s * t1
tl2 = sdl * t2 + t3 + s * t2 + t3 + t3
if tl2 <= tl:
	print('yes')
else:
	print('no')


(pr, ft, el, tst, tel, t3) = map(int, input().split())
t1 = abs(pr - ft) * tel + abs(el - pr) * tel
t2 = abs(pr - ft) * tst
if t1 + 3 * t3 <= t2:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = tuple([int(num) for num in input().split()])
elevator_time = t3 * 3 + t2 * (abs(z - x) + abs(x - y))
stairs_time = t1 * abs(x - y)
if elevator_time <= stairs_time:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
b = abs(x - y)
c = abs(z - x)
te = b * t1
ti = c * t2 + b * t2 + 3 * t3
print('YES' if ti <= te else 'NO')


a = input()
b = a.split()
c = [int(d) for d in b]
time_stairs = abs(c[1] - c[0]) * c[3]
time_elevator = (abs(c[2] - c[0]) + abs(c[1] - c[0])) * c[4] + 3 * c[5]
if time_elevator <= time_stairs:
	print('YES')
else:
	print('NO')


def main(x, y, z, t1, t2, t3):
	lift_time = abs(z - x) * t2 + 2 * t3 + (abs(x - y) * t2 + t3)
	walk_time = abs(x - y) * t1
	return 'YES' if lift_time <= walk_time else 'NO'
s = input()
print(main(*[int(x) for x in s.split()]))


x = input()
d = []
d = x.split()
x = int(d[0])
y = int(d[1])
z = int(d[2])
t1 = int(d[3])
t2 = int(d[4])
t3 = int(d[5])
stairs = abs(x - y) * t1
ele = abs(x - z) * t2 + abs(x - y) * t2 + 3 * t3
if ele <= stairs:
	print('YES')
else:
	print('NO')


v = input().split(' ')
x = int(v[0])
y = int(v[1])
z = int(v[2])
t1 = int(v[3])
t2 = int(v[4])
t3 = int(v[5])
n1 = abs(y - x)
n2 = abs(z - x)
Tf = n1 * t1
Tl = 3 * t3 + t2 * n2 + t2 * n1
if Tf < Tl:
	print('NO')
else:
	print('YES')


(x, y, z, t1, t2, t3) = map(int, input().split())
stairs = abs(x - y) * t1
de = abs(x - y) * t2
el = abs(z - x) * t2
elevate = 3 * t3 + el + de
if elevate <= stairs:
	print('YES')
else:
	print('NO')


s = list(map(int, input().split()))
x = s[0]
y = s[1]
z = s[2]
t1 = s[3]
t2 = s[4]
t3 = s[5]
dif = abs(x - y)
lift = abs(x - z) * t2 + dif * t2 + t3 * 3
lest = dif * t1
if lift <= lest:
	print('YES')
else:
	print('NO')


def get_input_list():
	return list(map(int, input().split()))
(x, y, z, t1, t2, t3) = get_input_list()
a = (abs(z - x) + abs(y - x)) * t2 + 3 * t3
b = abs(x - y) * t1
if a > b:
	print('NO')
else:
	print('YES')


import math
from sys import stdin, stdout
(x, y, z, t1, t2, t3) = map(int, stdin.readline().split())
ttbs = abs(y - x) * t1
ttbl = abs(z - x) * t2 + 2 * t3 + abs(y - x) * t2 + t3
if ttbl <= ttbs:
	stdout.write('YES')
else:
	stdout.write('NO')


def solution(x, y, z, t1, t2, t3):
	elevatorTravelTime = t2 * abs(z - x) + t2 * abs(y - x) + 3 * t3
	stairsTime = t1 * abs(y - x)
	if elevatorTravelTime <= stairsTime:
		print('YES')
	else:
		print('NO')

def test():
	solution(5, 1, 4, 4, 2, 1)
	solution(1, 6, 6, 2, 1, 1)
	solution(4, 1, 7, 4, 1, 2)
(x, y, z, t1, t2, t3) = map(int, input().strip().split(' '))
solution(x, y, z, t1, t2, t3)


from math import fabs
(x, y, z, t1, t2, t3) = map(int, input().split())
hu = fabs(x - y) * t1
ma = (fabs(x - y) + fabs(x - z)) * t2 + 3 * t3
if ma <= hu:
	print('YES')
else:
	print('NO')


l = list(map(int, input().split()))
x = l[0]
y = l[1]
z = l[2]
t1 = l[3]
t2 = l[4]
t3 = l[5]

def min(x, y, z, t1, t2, t3):
	ele = abs(x - z) * t2 + 3 * t3 + abs(x - y) * t2
	stair = abs(x - y) * t1
	if ele <= stair:
		return 'YES'
	else:
		return 'NO'
print(min(x, y, z, t1, t2, t3))


(x, y, z, t1, t2, t3) = map(int, input().split())
el_floor = abs(x - z) + abs(x - y)
st_floor = abs(x - y)
el_time = el_floor * t2 + 3 * t3
st_time = st_floor * t1
if el_time > st_time:
	print('NO')
else:
	print('YES')


import sys
import math
(x, y, z, ta, tb, tc) = map(int, input().split())
ele = tb * (abs(x - z) + abs(x - y)) + 3 * tc
sta = ta * abs(x - y)
print('YES') if ele <= sta else print('NO')


(source, dest, elev, tstair, telev, tedoor) = map(int, input().split())
totalstair = abs(source - dest) * tstair
totalelev = abs(source - dest) * telev + tedoor + 2 * tedoor
if elev != source:
	totalelev += abs(elev - source) * telev
print('YES' if totalelev <= totalstair else 'NO')


(Masha_Floor, Wants, elv_located, stair_passing, elv_passing, open_close) = map(int, input().split())
Difference = abs(Wants - Masha_Floor)
stair_time = Difference * stair_passing
elv_dfr = abs(Masha_Floor - elv_located)
difference_elv = abs(elv_located - Masha_Floor)
elv_time = open_close * 3 + Difference * elv_passing + difference_elv * elv_passing
if stair_time >= elv_time:
	print('YES')
else:
	print('NO')


import math
(x, y, z, t1, t2, t3) = map(int, input().split())
if round(math.fabs(x - z)) * t2 + round(math.fabs(x - y)) * t2 + 3 * t3 <= t1 * round(math.fabs(x - y)):
	print('YES')
else:
	print('NO')


l = list(map(int, input().split()))
st = abs(l[0] - l[1]) * l[3]
lf = abs(l[0] - l[2]) * l[4] + 3 * l[5] + abs(l[0] - l[1]) * l[4]
if st >= lf:
	print('YES')
else:
	print('NO')


a = input().split()
floor = abs(int(a[0]) - int(a[1]))
go = floor * int(a[-3])
wait = abs(int(a[0]) - int(a[2])) * int(a[-2]) + int(a[-1]) * 3
take = wait + floor * int(a[-2])
if take <= go:
	print('YES')
else:
	print('NO')


(start, end, lift, walk_sp, lift_sp, door_sp) = [int(i) for i in input().split()]
walk_time = abs(end - start) * walk_sp
lift_time = abs(end - start) * lift_sp + abs(lift - start) * lift_sp + 3 * door_sp
if lift_time <= walk_time:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = list(map(int, input().split()))
temp = abs(y - x)
res1 = abs(y - x) * t1
res = abs(x - z) * t2 + t3 * 2 + abs(y - x) * t2 + t3
print('YES') if res <= res1 else print('NO')


def __starting_point():
	(x, y, z, t1, t2, t3) = [int(i) for i in input().split(' ')]
	lift_time = (abs(z - x) + abs(y - x)) * t2 + 3 * t3
	stairs_time = abs(y - x) * t1
	if lift_time <= stairs_time:
		print('YES')
	else:
		print('NO')
__starting_point()


a = list(map(int, input().split()))
FLAG = 4
for i in a:
	if i >= 1 and i <= 1000:
		FLAG = 0
	else:
		FLAG = 1
		break
if FLAG == 0:
	if abs(a[0] - a[2]) * a[4] + 3 * a[5] + abs(a[0] - a[1]) * a[4] > abs(a[0] - a[1]) * a[3]:
		print('NO')
	else:
		print('YES')


(x, y, z, t1, t2, t3) = [int(x) for x in input().split()]
a = x - y
if a >= 0:
	a = a
else:
	a = a * -1
b = x - z
if b >= 0:
	b = b
else:
	b = b * -1
te = t2 * b + 2 * t3 + a * t2 + t3
ts = a * t1
if te > ts:
	print('no')
else:
	print('yes')


from math import *
from copy import *
from string import *
from sys import stdin
from itertools import *
(masha, egor, initially_lift, t_stairs, t_elevators, t_doors) = map(int, input().split())
t_using_stairs = 0
t_using_elevators = 0
floors = abs(masha - egor)
t_using_stairs = floors * t_stairs
diff = abs(masha - initially_lift)
time_for_door = 3 * t_doors
t_using_elevators = diff * t_elevators
floors = abs(masha - egor)
t_using_elevators += floors * t_elevators
t_using_elevators += time_for_door
if t_using_elevators > t_using_stairs:
	print('NO')
else:
	print('YES')


(x, y, z, t1, t2, t3) = [int(a) for a in input().split(' ')]

def elev(x, y, z, t2, t3):
	return abs(z - x) * t2 + 3 * t3 + abs(x - y) * t2
k = elev(x, y, z, t2, t3)
if abs(x - y) * t1 >= k:
	print('YES')
else:
	print('NO')


(x, y, z, t, r, s) = map(int, input().split())
d = abs(x - y)
print('YNEOS'[d * t < (abs(x - z) + d) * r + 3 * s::2])


a = list(map(int, input().split()))
dist = abs(a[0] - a[1])
stairs = a[3] * dist
eledist = abs(a[0] - a[2])
elevator = 3 * a[5] + (eledist + dist) * a[4]
if stairs < elevator:
	print('NO')
else:
	print('YES')


(x, y, z, t1, t2, t3) = map(int, input().split())
l = abs(z - x)
d = abs(y - x)
od = 3 * t3
el = t2 * (l + d) + od
st = d * t1
if el <= st:
	print('YES')
else:
	print('NO')


(p_now, p_to, p_ele, v_stair, v_ele, v_door) = [int(i) for i in input().split()]
(t_ele, t_stair) = (0, 0)
dif = abs(p_now - p_to)
t_stair += dif * v_stair
t_ele += 3 * v_door
t_ele += abs(p_ele - p_now) * v_ele
t_ele += dif * v_ele
if t_ele > t_stair:
	print('NO')
else:
	print('YES')


s = input().split(' ')
a = [int(x) for x in s]
lest = abs(a[0] - a[1]) * a[3]
lift = abs(a[2] - a[0]) * a[4] + 3 * a[5] + abs(a[0] - a[1]) * a[4]
print('YES' if lift <= lest else 'NO')


(a, b, c, d, e, f) = map(int, input().split())
lift = abs(a - c) * e + 3 * f + abs(a - b) * e
lest = abs(a - b) * d
if lest >= lift:
	print('YES')
else:
	print('NO')


from sys import stdin, stdout
(x, y, z, t1, t2, t3) = list(map(int, stdin.readline().split()))
stair = abs(x - y) * t1
elevator = abs(x - z) * t2 + 2 * t3 + abs(x - y) * t2 + t3
if stair < elevator:
	print('NO')
else:
	print('YES')


(x, y, z, t1, t2, t3) = [int(x) for x in input().split()]
num = abs(x - y)
ans1 = num * t1
num2 = abs(x - z) * t2 + t3 + t3
num2 += num * t2 + t3
if num2 > ans1:
	print('NO')
else:
	print('YES')


import sys
(x, y, z, t1, t2, t3) = map(int, input().split())
walk = t1 * abs(x - y)
elevator = t2 * abs(x - z) + 2 * t3 + t2 * abs(x - y) + t3
if elevator <= walk:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = list(map(int, input().split()))
lift = abs(z - x) * t2 + t3 + t3 + (abs(x - y) * t2 + t3)
st = abs(x - y) * t1
if lift <= st:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))

def diff(a, b):
	if b > a:
		diff = b - a
	else:
		diff = a - b
	return diff
if a[4] * (diff(a[0], a[2]) + diff(a[0], a[1])) + a[5] * 3 <= a[3] * diff(a[0], a[1]):
	print('YES')
else:
	print('NO')


[x, y, z, t1, t2, t3] = map(int, input().split())
floors = abs(x - y)
floortime = floors * t1
elevatorwait = abs(z - x) * t2 + 2 * t3
elevatortime = elevatorwait + floors * t2 + t3
if floortime >= elevatortime:
	print('YES')
else:
	print('NO')


temp = map(int, input().split(' '))
(x, y, z, t1, t2, t3) = temp
k = abs(x - y) * t1
k1 = abs(x - z) * t2 + 3 * t3 + abs(x - y) * t2
if k >= k1:
	print('Yes')
elif k < k1:
	print('No')


def solve():
	time_elevator = 0
	time_stairs = 0
	(x, y, z, t1, t2, t3) = map(int, input().split())
	time_stairs = abs(x - y) * t1
	time_elevator = abs(x - z) * t2 + abs(x - y) * t2 + 3 * t3
	if time_elevator <= time_stairs:
		return 'YES'
	else:
		return 'NO'
print(solve())


def main():
	(x, y, z, t1, t2, t3) = map(int, input().split())
	ans_1 = abs(x - y) * t1
	ans_2 = 3 * t3 + abs(x - y) * t2 + abs(x - z) * t2
	if ans_1 < ans_2:
		print('NO')
		return
	print('YES')
main()


(currentFloor, desiredFloor, liftFloor, timeStairs, timeLift, timeDoorOC) = map(int, input().split())
liftTimeToCurrent = 0
stairTime = abs(currentFloor - desiredFloor) * timeStairs
if currentFloor != liftFloor:
	liftTimeToCurrent = abs(liftFloor - currentFloor) * timeLift
liftTime = 2 * timeDoorOC + liftTimeToCurrent + abs(currentFloor - desiredFloor) * timeLift + timeDoorOC
if stairTime >= liftTime:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
a = abs(x - y)
b = abs(x - z)
ts = a * t1
te = (a + b) * t2 + 3 * t3
if te > ts:
	print('NO')
else:
	print('YES')


from math import fabs as f
(x, y, z, t1, t2, t3) = map(int, input().split())
k = int((f(y - x) + f(x - z)) * t2 + 3 * t3)
h = int(f(x - y) * t1)
if k <= h:
	print('YES')
else:
	print('NO')


from math import *
(x, y, z, t1, t2, t3) = map(int, input().split())
dif = abs(x - y)
dif2 = abs(x - z)
ans1 = dif * t1
ans2 = t2 * (dif + dif2) + 3 * t3
if ans1 >= ans2:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
dist = abs(a[0] - a[1])
door = a[5] * 3
ele = a[4] * abs(a[2] - a[0])
t1 = dist * a[4] + door + ele
t2 = dist * a[3]
print('YES' if t1 <= t2 else 'NO')


import math
(x, y, z, t1, t2, t3) = map(int, input().split())
print('YES' if abs(x - y) * t1 >= abs(x - z) * t2 + 2 * t3 + abs(x - y) * t2 + t3 else 'NO')


(masha, egor, elev, walkTime, elevTime, doorTime) = map(int, input().strip().split())
walking = abs(masha - egor) * walkTime
elevator = abs(elev - masha) * elevTime + abs(masha - egor) * elevTime + 3 * doorTime
if elevator <= walking:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
res1 = abs(x - y) * t1
res2 = abs(x - y) * t2 + abs(x - z) * t2 + 2 * t3 + t3
if res2 <= res1:
	print('YES')
else:
	print('NO')


(x, y, z, t2, t1, t3) = map(int, input().split())
l = abs(z - x) * t1 + 2 * t3 + abs(y - x) * t1 + t3
r = t2 * abs(x - y)
if l <= r:
	print('YES')
else:
	print('NO')


from sys import stdin, stdout
stdout.write('%s' % (lambda x, y, z, t1, t2, t3: 'YES' if abs(z - x) * t2 + abs(x - y) * t2 + 3 * t3 <= abs(x - y) * t1 else 'NO')(*map(int, stdin.readline().split())))


R = lambda : map(int, input().split())
(x, y, z, a, b, c) = R()
t = abs(x - y)
m = abs(x - z)
s1 = t * a
s2 = (t + m) * b + 3 * c
print('YES' if s2 <= s1 else 'NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
steps = 0
ele = 0
d = abs(x - y)
steps = d * t1
d1 = abs(x - z)
ele = d1 * t2 + d * t2 + 3 * t3
if steps < ele:
	print('NO')
else:
	print('YES')


inputs = [int(s) for s in input().split()]
(x, y, z, t1, t2, t3) = (inputs[0], inputs[1], inputs[2], inputs[3], inputs[4], inputs[5])
time_without_lift = abs(x - y) * t1
time_with_lift = abs(z - x) * t2 + 3 * t3 + abs(x - y) * t2
if time_with_lift <= time_without_lift:
	print('YES')
else:
	print('NO')


[x, y, z, t1, t2, t3] = list(map(int, input().rstrip().split()))
stair = abs(x - y) * t1
elev = abs(x - z) * t2 + 3 * t3 + abs(x - y) * t2
print('YES' if elev <= stair else 'NO')


(x, y, z, t_1, t_2, t_3) = [int(i) for i in input().split()]
dist = abs(x - y)
time_es = dist * t_1
time_lift = abs(x - z) * t_2 + dist * t_2 + t_3 * 3
if time_lift <= time_es:
	print('YES')
else:
	print('NO')


inp = input().split(' ')
(x, y, z, t1, t2, t3) = (int(inp[0]), int(inp[1]), int(inp[2]), int(inp[3]), int(inp[4]), int(inp[5]))
if abs(z - x) * t2 + abs(x - y) * t2 + 3 * t3 <= abs(x - y) * t1:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = list(map(int, input().split()))
c = (x, y, z, t1, t2, t3)
if c[0] < c[1]:
	b = -(c[0] - c[1])
else:
	b = c[0] - c[1]
d = b * c[3]
if c[0] < c[2]:
	e = -(c[0] - c[2])
else:
	e = c[0] - c[2]
k = e * c[4] + 2 * c[5] + c[5] + b * c[4]
if d >= k:
	print('yes')
else:
	print('no')


import sys
inp = sys.stdin.read()
l = [int(i) for i in inp.split(' ')]
x = l[0]
y = l[1]
z = l[2]
t1 = l[3]
t2 = l[4]
t3 = l[5]
if abs(x - y) * t1 >= abs(x - y) * t2 + abs(x - z) * t2 + 3 * t3:
	print('YES')
else:
	print('NO')


import sys
(depart, goal, elevator, t1, t2, t3) = map(int, sys.stdin.readline().split())
stair = abs(depart - goal) * t1
elv = abs(depart - elevator) * t2 + 2 * t3 + abs(depart - goal) * t2 + t3
if stair >= elv:
	print('YES')
else:
	print('NO')


def main():

	def count(counter, x, y, step):
		return counter + abs(x - y) * step
	(x, y, z, t1, t2, t3) = map(int, input().split())
	(min_, max_) = (min(x, y), max(x, y))
	lest = count(0, x, y, t1)
	lift = count(3 * t3, x, z, t2)
	lift = count(lift, x, y, t2)
	return lift <= lest
res = main()
print('YES' if res else 'NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
num1 = abs(x - y)
num2 = t1 * num1
num3 = t2 * num1 + t3 * 3 + abs(x - z) * t2
ans = num3 <= num2
print('YES' * ans + 'NO' * (1 - ans))


def fun():
	(x, y, z, t1, t2, t3) = map(int, input().split())
	cs = abs(x - y) * t1
	ce = abs(x - z) * t2 + abs(x - y) * t2 + 3 * t3
	if ce <= cs:
		print('YES')
	else:
		print('NO')
fun()


(x, y, z, t1, t2, t3) = input().split()
x = int(x)
y = int(y)
z = int(z)
t1 = int(t1)
t2 = int(t2)
t3 = int(t3)
stairs = abs(x - y) * t1
elv = abs(x - z) * t2 + 3 * t3 + abs(x - y) * t2
if elv <= stairs:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
diff = abs(x - y)
td1 = diff * t1
td2 = 3 * t3 + abs(x - z) * t2 + t2 * diff
if td1 >= td2:
	print('yes')
else:
	print('no')


from math import sqrt

def main():
	(x, y, z, t1, t2, t3) = [int(v) for v in input().split()]
	df = abs(x - y)
	lest = t1 * df
	lift = t2 * df + t2 * abs(z - x) + t3 * 3
	if lift <= lest:
		print('YES')
	else:
		print('NO')
main()


(x, y, z, t1, t2, t3) = input().split()
(x, y, z, t1, t2, t3) = (int(x), int(y), int(z), int(t1), int(t2), int(t3))
lt = abs(x - y) * t1
lf = t3 * 3 + abs(x - z) * t2 + t2 * abs(x - y)
if lf <= lt:
	print('YES')
else:
	print('NO')


(masha, egor, lift, beg, lift_u, dver) = map(int, input().split())
tlifta = dver * 3 + abs(masha - lift) * lift_u + abs((masha - egor) * lift_u)
tbega = abs(masha - egor) * beg
if tbega < tlifta:
	print('NO')
else:
	print('YES')


(a, b, c, t1, t2, t3) = map(int, input().split())
if a > b:
	diff = a - b
else:
	diff = b - a
stairs = diff * t1
if a > c:
	diff1 = a - c
else:
	diff1 = c - a
elev = diff1 * t2 + 2 * t3 + diff * t2 + t3
if elev <= stairs:
	print('YES')
else:
	print('NO')


def solve(x, y, z, t1, t2, t3):
	d = abs(y - x)
	stairs = t1 * d
	elevator = t2 * abs(x - z) + 3 * t3 + t2 * d
	if elevator <= stairs:
		return 'YES'
	else:
		return 'NO'

def main():
	(x, y, z, t1, t2, t3) = list(map(int, input().split()))
	print(solve(x, y, z, t1, t2, t3))
main()


l = [int(a) for a in input().split()]
x = l[0]
y = l[1]
z = l[2]
t1 = l[3]
t2 = l[4]
t3 = l[5]
r1 = abs(x - y) * t1
r2 = abs(x - z) * t2 + abs(x - y) * t2 + 3 * t3
if r1 < r2:
	print('NO')
else:
	print('YES')


(x, y, z, t1, t2, t3) = list(map(int, input().split()))
stair = abs(x - y) * t1
elevator = abs(x - y) * t2 + 3 * t3 + abs(x - z) * t2
if elevator <= stair:
	print('yes')
else:
	print('no')


def choose(x, y, z, t):
	diff = abs(x - y)
	stairs = t[0] * diff
	elv1 = abs(z - x) * t[1] + t[2] * 3
	elv2 = t[1] * diff
	elevator = elv1 + elv2
	if elevator <= stairs:
		return 'YES'
	return 'NO'
inp = list(map(int, input().split()))
x = inp.pop(0)
y = inp.pop(0)
z = inp.pop(0)
print(choose(x, y, z, inp))


for _ in range(1):
	(x, y, z, t1, t2, t3) = map(int, input().split())
	if abs(x - y) * t1 >= (abs(x - y) + abs(x - z)) * t2 + 3 * t3:
		print('YES')
	else:
		print('NO')


from sys import stdin, stdout
from math import sin, tan, cos
(x, y, z, t1, t2, t3) = map(int, stdin.readline().split())
if abs(x - z) * t2 + abs(x - y) * t2 + 3 * t3 <= abs(x - y) * t1:
	stdout.write('YES')
else:
	stdout.write('NO')


(x, y, z, st, el, eld) = map(int, input().split())
stair = abs(x - y) * st
elev = abs(x - z) * el + eld * 3 + abs(x - y) * el
if elev <= stair:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())

def stairs(o, p, q):
	g = abs(o - p)
	return g * q

def ele(a, b, c, d, e):
	h = abs(a - c)
	i = abs(a - b)
	return h * d + i * d + 3 * e
if stairs(x, y, t1) < ele(x, y, z, t2, t3):
	print('NO')
else:
	print('YES')


values = input().split()
x = int(values[0])
y = int(values[1])
z = int(values[2])
t1 = int(values[3])
t2 = int(values[4])
t3 = int(values[5])
stair_time = abs(x - y) * t1
elev_time = abs(z - x) * t2 + 3 * t3 + abs(x - y) * t2
if stair_time < elev_time:
	print('NO')
else:
	print('YES')


(x, y, z, t1, t2, t3) = map(int, input().split())
elevetor_time = abs(z - x) * t2 + 2 * t3 + abs(y - x) * t2 + t3
stair_time = abs(y - x) * t1
if stair_time >= elevetor_time:
	print('YES')
else:
	print('NO')


from math import ceil, sqrt
t = 1
for test in range(1, t + 1):
	(x, y, z, t1, t2, t3) = map(int, input().split())
	if abs(z - x) * t2 + t3 * 3 + t2 * abs(x - y) > t1 * abs(x - y):
		print('NO')
	else:
		print('YES')


(x, y, z, t1, t2, t3) = map(int, input().split())
time1 = abs(y - x) * t1
time2 = abs(z - x) * t2 + t3 + t3 + abs(y - x) * t2 + t3
if time1 < time2:
	print('NO')
else:
	print('YES')


(x, y, z, t1, t2, t3) = map(int, input().split())
if x > y:
	dif = x - y
else:
	dif = y - x
stair = dif * t1
if x > z:
	dif2 = x - z
else:
	dif2 = z - x
elevator = dif2 * t2 + 2 * t3 + dif * t2 + t3
if elevator <= stair:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
tl = abs(a[2] - a[0]) * a[4] + abs(a[0] - a[1]) * a[4] + a[5] * 3
tp = abs(a[0] - a[1]) * a[3]
if tl <= tp:
	print('YES')
else:
	print('NO')


(x, y, z, p, l, o) = map(int, input().split())
opt = abs(x - y) * l + o * 3 + abs(z - x) * l
if abs(x - y) * p >= opt:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = [int(x) for x in input().split()]
k = x - y
ke = x - z
if k < 0:
	k = k * -1
if ke < 0:
	ke = ke * -1
sta = k * t1
ele = (k + ke) * t2 + 3 * t3
if sta < ele:
	print('NO')
else:
	print('YES')


inp = list(map(int, input().split()))
TS = abs(inp[0] - inp[1]) * inp[3]
TE = abs(inp[2] - inp[0]) * inp[4] + 2 * inp[5] + abs(inp[0] - inp[1]) * inp[4] + inp[5]
if TS >= TE:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
q = abs(x - y)
q1 = abs(x - z)
res1 = t1 * q
res2 = q1 * t2 + t2 * q + 3 * t3
if res1 >= res2:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
t_elevator = abs(z - x) * t2 + 3 * t3 + abs(x - y) * t2
t_stairs = abs(x - y) * t1
if t_elevator <= t_stairs:
	print('YES')
else:
	print('No')


def vybor(x, y, z, t1, t2, t3):
	if abs(x - y) * t1 >= abs(z - x) * t2 + abs(x - y) * t2 + 3 * t3:
		return 'YES'
	return 'NO'
(X, Y, Z, T1, T2, T3) = [int(i) for i in input().split()]
print(vybor(X, Y, Z, T1, T2, T3))


import sys
input = sys.stdin.readline
(x, y, z, t1, t2, t3) = map(int, input().split())
time = abs(x - z) * t2 + t3 * 2 + abs(y - x) * t2 + t3
d = abs(x - y) * t1
if time <= d:
	print('YES')
else:
	print('NO')


(x, y, z, t1, t2, t3) = map(int, input().split())
de = abs(x - y)
dl = abs(x - z)
p = de * t1
l = (de + dl) * t2 + 3 * t3
print('NO' if p < l else 'YES')


(a, b, c, d, e, f) = list(map(int, input().split()))
m = abs(a - b) * d
n = 3 * f + abs(a - c) * e + abs(a - b) * e
if n <= m:
	print('YES')
else:
	print('NO')


def main():
	st = input()
	lis = st.split()
	x = int(lis[0])
	y = int(lis[1])
	z = int(lis[2])
	t1 = int(lis[3])
	t2 = int(lis[4])
	t3 = int(lis[5])
	resA = ascensor(x, y, z, t2, t3)
	resE = escalera(x, y, t1)
	if resE < resA:
		print('NO')
	else:
		print('YES')

def ascensor(x, y, z, t2, t3):
	res = 0
	pisos = abs(z - x)
	res += pisos * t2
	res += t3 * 2
	pisos = abs(x - y)
	res += pisos * t2
	res += t3
	return res

def escalera(x, y, t1):
	res = 0
	pisos = abs(x - y)
	res = pisos * t1
	return res
main()


import math
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
inp = lambda : int(input())
strng = lambda : input().strip()
jn = lambda x, l: x.join(map(str, l))
strl = lambda : list(input().strip())
mul = lambda : map(int, input().strip().split())
mulf = lambda : map(float, input().strip().split())
seq = lambda : list(map(int, input().strip().split()))

def mex(arr):
	nList = set(arr)
	mex = 0
	while mex in nList:
		mex += 1
	return mex

def results(a):
	(x, y, z, t1, t2, t3) = (a[0], a[1], a[2], a[3], a[4], a[5])
	bylift = (abs(z - x) + abs(x - y)) * t2 + 3 * t3
	bystair = abs(x - y) * t1
	if bylift <= bystair:
		return 'YES'
	return 'NO'

def main():
	a = seq()
	result = results(a)
	print(result)
main()


(x, y, z, t1, t2, t3) = input().split()
(x, y, z, t1, t2, t3) = [int(x), int(y), int(z), int(t1), int(t2), int(t3)]
m = abs(x - y) * t1
n = abs(x - z) * t2 + t3 + t3 + abs(x - y) * t2 + t3
if n <= m:
	print('YES')
else:
	print('NO')


def BySteps(inp):
	return int(inp[3]) * abs(int(inp[0]) - int(inp[1]))

def ByElevator(inp):
	length = abs(int(inp[0]) - int(inp[2])) + abs(int(inp[0]) - int(inp[1]))
	res = int(inp[4]) * length
	res += 3 * int(inp[5])
	return res
inp = input().split()
if BySteps(inp) >= ByElevator(inp):
	print('YES')
else:
	print('NO')


import math
(x, y, z, t1, t2, t3) = map(int, input().split())
aa = abs(x - y) * t1
bb = abs(x - z) * t2
bb += 3 * t3
bb += abs(x - y) * t2
if aa >= bb:
	print('YES')
else:
	print('NO')


import collections

def main():
	(x, y, z, t1, t2, t3) = list(map(int, input().split()))
	stair = t1 * abs(y - x)
	ele = t2 * (abs(y - x) + abs(z - x)) + 3 * t3
	print('YES' if ele <= stair else 'NO')
main()


(x, y, z, t1, t2, t3) = map(int, input().split())
d = abs(x - y)
d1 = abs(z - x)
ts = d * t1
te = d1 * t2 + d * t2 + 3 * t3
if ts < te:
	print('NO')
else:
	print('YES')


a = input()
parts = a.split()
x = int(parts[0])
y = int(parts[1])
z = int(parts[2])
t1 = int(parts[3])
t2 = int(parts[4])
t3 = int(parts[5])
i = abs(y - x)
t = abs(x - z)
f = t3 * 3 + (i + t) * t2
e = i * t1
if f <= e:
	print('YES')
else:
	print('NO')


class main:

	def __init__(self):
		inp = input()
		elem = inp.split(' ')
		elem = [int(i) for i in elem]
		self.floor = {'x': elem[0], 'y': elem[1], 'z': elem[2]}
		self.time = {'t1': elem[3], 't2': elem[4], 't3': elem[5]}
		self.stair = 0
		self.elevator = 0

	def getstair(self):
		floor = self.floor
		time = self.time
		self.stair = (floor['x'] - floor['y']) * time['t1'] if floor['x'] > floor['y'] else (floor['y'] - floor['x']) * time['t1']
		return self.stair

	def getelevator(self):
		floor = self.floor
		time = self.time
		pick = (floor['x'] - floor['z']) * time['t2'] if floor['x'] > floor['z'] else (floor['z'] - floor['x']) * time['t2']
		pick += time['t3'] * 2
		drop = (floor['x'] - floor['y']) * time['t2'] if floor['x'] > floor['y'] else (floor['y'] - floor['x']) * time['t2']
		drop += time['t3']
		return pick + drop

	def yesorno(self):
		t1 = self.getstair()
		t2 = self.getelevator()
		if t1 > t2:
			print('YES')
		elif t1 == t2:
			print('YES')
		else:
			print('NO')
t = main()
t.yesorno()


import string
import math

def reversed_list(l, start, end):
	if start >= end:
		return l
	(l[start], l[end]) = (l[end], l[start])
	return reversed_list(l, start + 1, end - 1)

def main_function():
	(x, y, z, t_1, t_2, t_3) = [int(i) for i in input().split(' ')]
	if 3 * t_3 + abs(z - x) * t_2 + abs(x - y) * t_2 <= abs(x - y) * t_1:
		return 'YES'
	return 'NO'
print(main_function())


def solve(w):
	x = w[0]
	y = w[1]
	z = w[2]
	t1 = w[3]
	t2 = w[4]
	t3 = w[5]
	stairs = abs(x - y) * t1
	elv = abs(x - z) * t2 + abs(x - y) * t2 + 3 * t3
	if elv <= stairs:
		print('YES')
	else:
		print('NO')

def main():
	w = list(map(int, input().split()))
	solve(w)
main()


def useElevator(x, y, z, t1, t2, t3):
	timeUsingStairs = abs(x - y) * t1
	timeUsingElevator = 3 * t3 + (abs(x - y) + abs(x - z)) * t2
	return timeUsingElevator <= timeUsingStairs
(x, y, z, t1, t2, t3) = map(int, input().split())
print('YES' if useElevator(x, y, z, t1, t2, t3) else 'NO')