Problem:
 Score : 200 points    Problem Statement Two children are playing tag on a number line. (In the game of tag, the child called "it" tries to catch the other child.) The child who is "it" is now at coordinate A , and he can travel the distance of V per second.
The other child is now at coordinate B , and she can travel the distance of W per second.  He can catch her when his coordinate is the same as hers.
Determine whether he can catch her within T seconds (including exactly T seconds later).
We assume that both children move optimally.      Constraints  -10^9 \leq A,B \leq 10^9  1 \leq V,W \leq 10^9  1 \leq  T \leq 10^9  A \neq B  All values in input are integers.         Input Input is given from Standard Input in the following format:  A  V  B  W  T       Output If "it" can catch the other child, print YES ; otherwise, print NO .        Sample Input 1 1 2
3 1
3      Sample Output 1 YES       Sample Input 2 1 2
3 2
3      Sample Output 2 NO       Sample Input 3 1 2
3 3
3      Sample Output 3 NO

Solution (Python):
a,v=map(int, input().split())
b,w=map(int, input().split())
t=int(input())

dis=abs(a-b)
vel=v-w

if vel>0 and vel*t>=dis:
    print('YES')
else:
    print('NO')

Solution (Python):

a, v, b, w, t = map(int, open(0).read().split())
if v <= w:
    exit(print("NO"))
if abs(b - a) <= (v - w) * t:
    print("YES")
else:
    print("NO")

Solution (Python):
import sys
readline = sys.stdin.readline

def solve():
    A, V = map(int, readline().split())
    B, W = map(int, readline().split())
    T = int(readline())

    d = abs(A - B)

    dv = V - W
    if T * dv >= d:
        print('YES')
    else:
        print('NO')

solve()

Solution (Python):
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
if(abs(a-b)>t*(v-w)):
    print("NO")
else:
    print("YES")

Solution (Python):
import math
import sys
from collections import deque
import copy
def mi() : return map(int,input().split())
a,b=mi()
c,d=mi()
e=int(input())
if d>=b:
  print("NO")
else:
  if (b-d)*e>=abs(a-c):
    print("YES")
  else:
    print("NO")

Solution (Python):
A, V = list(map(int, input().split()))
B, W = list(map(int, input().split()))
T = int(input())

d = abs(A - B)
s = V - W

if s <= 0:
  print("NO")
  exit()

if d / s <= T:
  print("YES")
else:
  print("NO")

Solution (Python):
import math

import queue
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
from scipy.sparse.csgraph import dijkstra
from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)

def main():
    a,v = map(int,ipt().split())
    b,w = map(int,ipt().split())
    t = int(input())

    if w > v:
        print("NO")
    elif w == v:
        if a == b:
            print("YES")
        else:
            print("NO")
    else:
        if abs(a-b) <= t*(v-w):
            print("YES")
        else:
            print("NO")

    return

if __name__ == '__main__':
    main()

Solution (Python):
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

diff = abs(A-B)

if (V-W)*T >= diff:
    print('YES')
else:
    print('NO')

Solution (Python):
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

if V == W:
    print("NO")
    exit()

if 0 < abs(A-B) / (V-W) <= T:
    print("YES")
else:
    print("NO")

Solution (Python):
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
c=abs(a-b)
u=v-w
print('YES' if u*t>=c else 'NO')

Solution (Python):
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

if V>W and abs(A-B) <= (V-W)*T:
    print("YES")
else:
    print("NO")

Solution (Python):
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if (v - w) * t >= abs(b - a):
    print('YES')
else:
    print('NO')

Solution (Python):
import math
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())
kyori = abs(a-b)
sa = v-w
if sa <= 0:
	print("NO")
	exit()
if math.ceil(kyori/sa) <= t:
	print("YES")
else:
	print("NO")

Solution (Python):
from math import ceil

a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
pace = v - w
if pace <= 0:
    print("NO")
else:
    diff = abs(a - b)
    if ceil(diff / pace) <= t:
        print("YES")
    else:
        print("NO")

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush

from decimal import *













































def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]

inf = float('inf')
mod = 1000000007




def main():
	A,V = inputMap()
	B,W = inputMap()
	T = inputInt()

	if A == B:
		print("YES")
		sys.exit()

	kyori = abs(A-B)
	hayasa = V-W

	if hayasa < 1:
		print("NO")
		sys.exit()

	if T * hayasa >= kyori:
		print("YES")
	else:
		print("NO")








def bisect_left_reverse(a, x):
    if a[0] <= x:
        return 0
    if x < a[-1]:
        return len(a)
    
    ok = len(a) - 1
    ng = 0
    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if a[mid] <= x:
            ok = mid
        else:
            ng = mid
    return ok

def bisect_right_reverse(a, x):
    if a[0] < x:
        return 0
    if x <= a[-1]:
        return len(a)
    
    ok = len(a) - 1
    ng = 0
    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if a[mid] < x:
            ok = mid
        else:
            ng = mid
    return ok





def binary_search(list, item):
    low = 0
    high = len(list) - 1

    while low <= high:
        mid = (low + high) //2
        guess = list[mid]
        if guess == item:
            return mid
        if guess > item:
            high = mid -1
        else:
            low = mid + 1
    return None




def sunuke(N, K, mod=10**9+7):
	if N < K or K-1 < 0:
		return 0
	else:
		return combination(N-1, K-1, mod)




def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res


def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y




def H(n, r, mod=10**9+7):
	
	
    return combination(n+r-1, r, mod)


class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        
        
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv



def dfs(graph,parent,counter,edge):
    stk = []
    stk.append(edge)
    while len(stk) > 0:
        p = stk.pop()
        for e in graph[p]:
            if parent[p] == e:
                continue
            else:
                parent[e] = p
                counter[e] += counter[p]
                stk.append(e)



if __name__ == "__main__":
	main()

Solution (Python):
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
dist = abs(A - B)
speed = W - V
if speed >= 0: print('NO')
else:
    if (- speed) * T >= dist: print('YES')
    else: print('NO')

Solution (Python):
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())

if v - w <= 0:
    print('NO')
else:
    if abs(a-b)/(v-w) <= t:
        print('YES')
    else:
        print('NO')

Solution (Python):
def main():
    A, V = list(map(int, input().split()))
    B, W = list(map(int, input().split()))
    T = int(input())

    if A == B:
        return True
    if A < B:
        return A + V * T >= B + W * T
    else:
        return A - V * T <= B - W * T

print('YES' if main() else 'NO')

Solution (Python):
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if abs(a-b) <= (v-w)*t:
  print('YES')
else:
  print('NO')

Solution (Python):
a,v=list(map(int,input().split()))
b,w=list(map(int,input().split()))
t=int(input())

if v<=w:
    print("NO")
else:
    if abs(a-b)<=t*(v-w):
        print("YES")
    else:
        print("NO")

Solution (Python):
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())

if abs(a-b) <= (v-w) * t:
    print("YES")
else:
    print("NO")

Solution (Python):
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

diff_x = abs(A - B)
diff_v = V - W
if diff_v * T >= diff_x:
    print('YES')
else:
    print('NO')

Solution (Python):
A,V = map(int, input().split())
B,W = map(int, input().split())
T = int(input())

if A <= B:
    B += W*T
    A += V*T
    if A >= B:
        ans = "YES"
    else:
        ans = "NO"
else:
    B -= W*T
    A -= V*T
    if A <= B:
        ans = "YES"
    else:
        ans = "NO"
print(ans)

Solution (Python):
import sys
import heapq
import math
import fractions
import bisect
import itertools
from collections import Counter
from collections import deque
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def mp(): return map(int,input().split())
def lmp(): return list(map(int,input().split()))

a,v=mp()
b,w=mp()
t=int(input())
if b-w*t>=a-v*t and a+v*t>=b+w*t:
    print("YES")
else:
    print("NO")

Solution (Python):
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
if V <= W:
    print('NO')
else:
    check = abs(B-A)/(V-W)
    if check > T:
        print('NO')
    else:
        print('YES')

Solution (Python):
import math
import sys
from itertools import permutations
input = sys.stdin.readline

A,V=map(int,input().split())
B,W=map(int,input().split())
T=int(input())

if W>=V:
    print("NO")
else:
    if abs(A-B)<=abs(V-W)*T:
        print("YES")
    else:
        print("NO")

Solution (Python):


import sys
read = sys.stdin.read
readline = sys.stdin.readline

a,v,b,w,t = map(int,read().split())





if v>w and (v-w)*t >= abs(a-b):
    print("YES")
else:
    print("NO")

Solution (Python):
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

A, V, B, W, T = map(int, read().split())

def solve(A, V, B, W, T):
    x = abs(A - B)
    if V <= W:
        return 'NO'
    y = (V - W) * T
    return 'YES' if y >= x else 'NO'

print(solve(A, V, B, W, T))

Solution (Python):
A, V = map(int,input().split())
B, W = map(int,input().split())
T = int(input())

X = abs(A-B)
S = V-W

if X <= S * T:
  print("YES")
else:
  print("NO")

Solution (Python):
from sys import stdin, setrecursionlimit


def main():
    input = stdin.buffer.readline
    a, v = map(int, input().split())
    b, w = map(int, input().split())
    t = int(input())
    if (v - w) * t >= abs(b - a):
        print('YES')
    else:
        print('NO')


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()

Solution (Python):
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())
if abs(a-b) <= (v-w)*t:
    print("YES")
else:
    print("NO")

Solution (Python):
import sys
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())

if v <= w:
    print("NO")
    sys.exit()

diff = abs(a - b)
ans = diff / (v - w) <= t

print("YES" if ans else "NO")

Solution (Python):
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
d0 = abs(a - b)
if t * (v - w) < d0:
    print("NO")
else:
    print("YES")

Solution (Python):
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
print('YES' if (V - W) * T >= abs(B - A) else 'NO')

Solution (Python):
A, V=map(int, input().split())
B, W=map(int, input().split())
T=int(input())
if W-V>=0:
  print('NO')
  exit()
  
if abs(A-B)<=T*(V-W):
  print('YES')
else:
  print('NO')

Solution (Python):
import sys
def input():return sys.stdin.readline()[:-1]
def N(): return int(input())
def NM():return map(int,input().split())
def L():return list(NM())
def LN(n):return [N() for i in range(n)]
def LL(n):return [L() for i in range(n)]
a,v=NM()
b,w=NM()
t=N()
l=abs(a-b)
if w>=v:
    print("NO")
else:
    if (v-w)*t>=l:
        print("YES")
    else:
        print("NO")

Solution (Python):
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if (v - w) * t >= abs(a - b):
    print("YES")
else:
    print("NO")

Solution (Python):
A,V=map(int, input().split())
B,W=map(int, input().split())
T=int(input())

if V>W:
	if abs(B-A)<=((V-W)*T):
		print("YES")
	else:
		print("NO")

else:
	print("NO")

Solution (Python):
A,V=map(int,input().split())
B,W=map(int,input().split())
N=int(input())


kyori=abs(A-B)

sokudo=V-W

if sokudo*N >= kyori:
    print("YES")
else:
    print("NO")

Solution (Python):
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

if A == B:
    print("YES")
elif A < B:
    if A + V * T >= B + W * T:
        print("YES")
    else:
        print("NO")
else:
    if A - V * T <= B - W * T:
        print("YES")
    else:
        print("NO")

Solution (Python):
def main():
    a,v = map(int,input().split())
    b,w = map(int,input().split())
    t = int(input())
    dist = abs(a-b)
    speed_per_second = v-w
    if dist - speed_per_second * t <= 0:
        print("YES")
    else:
        print("NO")


if __name__ == '__main__':
    main()

Solution (Python):
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
c=abs(a-b)
if w>=v:
  print('NO')
else:
  if c<=t*(v-w):
    print('YES')
  else:
    print('NO')

Solution (Python):
A,V = map(int,input().split())
B,W = map(int,input().split())
T = int(input())
dist = abs(A-B)
delta = V-W
res = 'YES'
if W>V:
    res = 'NO'
else:
    if delta*T >= dist:
        res = 'YES'
    else:
        res = 'NO'
print(res)

Solution (Python):
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
l = abs(a-b)
if (v-w)*t<l:
    print("NO")
else:
    print("YES")

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
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 SI(): return sys.stdin.readline()[:-1]

def main():
    a,v=MI()
    b,w=MI()
    t=II()
    if v<=w:ans="NO"
    elif abs(a-b)<=t*(v-w):ans="YES"
    else:ans="NO"
    print(ans)

main()

Solution (Python):
a, v = map(int, input().split())

b, w = map(int, input().split())

t = int(input())

if abs(a - b) <= (v - w) * t:
    print("YES")
else:
    print("NO")

Solution (Python):
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())

if v <= w:
    print('NO')
    exit()
else:
    if (v - w) * t >= abs(b - a):
        print('YES')
    else:
        print('NO')

Solution (Python):
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())
ans = abs(a-b)
if (v-w)*t >= ans:
    print("YES")
else:
    print("NO")

Solution (Python):
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

Kyori = abs(A-B)

if Kyori == 0:
	print('YES')
	exit()

if Kyori <= (V-W)*T:
	print('YES')
else:
	print('NO')

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): 
	return list(map(int,input().split()))
def m(): 
	return map(int,input().split())
def onem(): 
	return int(input())
def s(x): 
	a = []
	if len(x) == 0:
		return []
	aa = x[0]
	su = 1
	for i in range(len(x)-1):
		if aa != x[i+1]:
			a.append([aa,su])
			aa = x[i+1]
			su = 1
		else:
			su += 1
	a.append([aa,su])
	return a
def jo(x): 
	return " ".join(map(str,x))
def max2(x): 
	return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False

def pow_k(x, n):
    ans = 1
    while n:
        if n % 2:
            ans *= x
        x *= x
        n >>= 1
    return ans

"""
def nibu(x,n,r):
	ll = 0
	rr = r
	while True:
		mid = (ll+rr)//2

	if rr == mid:
		return ll
	if (ここに評価入れる):
		rr = mid
	else:
		ll = mid+1
"""

a = l()

b = l()


t = onem()

dis = abs(a[0]-b[0])
if dis == 0:
	print("YES")
else:
	if b[1] - a[1] >= 0:
		print("NO")
	else:
		sp = a[1] - b[1]
		if dis - sp * t <= 0:
			print("YES")
		else:
			print("NO")

Solution (Python):
A,V = map(int,input().split())
B,W = map(int,input().split())
T=int(input())

D=abs(A-B)
if V<=W:
    print("NO")
else:
    F=V-W
    if F*T>=D:
        print("YES")
    else:
        print("NO")

Solution (Python):


LI = lambda: list(map(int, input().split()))


A, V = LI()
B, W = LI()
T = int(input())


def main():
    if V <= W:
        ans = "NO"
    else:
        x = (V - W) * T
        if abs(A - B) > x:
            ans = "NO"
        else:
            ans = "YES"
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
A,V = map(int,input().split())
B,W = map(int,input().split())
T =int(input())
dist = abs(A-B)
if (V-W)*T < dist:
    print("NO")
else:
    print("YES")

Solution (Python):
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())

if(abs(a-b) <= (v-w)*t):
    print('YES')
else:
    print('NO')

Solution (Python):
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
if a>b:
  if a-v*t<=b-t*w:
    print('YES')
  else:
    print('NO')
elif a<b:
  if a+v*t>=b+w*t:
    print('YES')
  else:
    print('NO')

Solution (Python):
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())

if v > w and  (v - w) * t >= abs(a-b):
    print('YES')
else:
    print('NO')

Solution (Python):

A,V=map(int,input().split())
B,W=map(int,input().split())
T=int(input())

if abs(A-B)<=T*(V-W):
    print("YES")
else:
    print("NO")

Solution (Python):
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())

if abs(a-b) <= (v-w)*t:
    print("YES")

else:
    print("NO")

Solution (Python):
A,V=list(map(int,input().split()))
B,W=list(map(int,input().split()))
T= int(input())
S=abs(B-A)
X=V-W
if X*T >= S:
   print("YES")
else:
   print("NO")

Solution (Python):
A,V = map(int,input().split())
B,W = map(int,input().split())
T = int(input())
if (V - W) * T >= abs(A - B):
    print("YES")
else:
    print("NO")

Solution (Python):
A,V=map(int,input().split())
B,W=map(int,input().split())
T=int(input())
if B<A:
    B=-B
    A=-A




if A+V*T>=B+W*T:
    print("YES")
else:
    print("NO")

Solution (Python):


import sys
stdin = sys.stdin

def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))

def main():
    a, v = na()
    b, w = na()
    t = ni()
    l = abs(b - a)
    if v <= w:
        print("NO")
    else:
        if l / (v-w) <= t:
            print("YES")
        else:
            print("NO")



if __name__ == "__main__":
    main()

Solution (Python):
if __name__ == '__main__':
    from sys import stdin
    
    
    
    
    
    
    input = stdin.readline

    a, v = map(int, input().split())
    b, w = map(int, input().split())
    t = int(input())
    if v <= w:
        print('NO')
        exit()
    if (v-w)*t >= abs(a-b):
        print('YES')
    else:
        print('NO')

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline

A,V = map(int,input().split())
B,W = map(int,input().split())
T = int(input())
if V<=W:
    print('NO')
    exit()

sa = abs(B-A)
ss = (V-W)
if T*ss>=sa:
    print('YES')
else:
    print('NO')

Solution (Python):
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

if abs(A-B) <= (V-W)*T:
    print("YES")
else:
    print("NO")

Solution (Python):
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
D = abs(B - A)
if (V - W)*T >= D:
    print("YES")
else:
    print("NO")

Solution (Python):

import sys
input = sys.stdin.readline

a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())

dist = abs(a - b)
if w >= v:
    print("NO")
    exit()
diff = v - w
if t * diff >= dist:
    print("YES")
else:
    print("NO")

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

a,v = na()
b,w = na()
t = ni()

dif = abs(a-b)
k = v-w

if k*t >= dif:
    print('YES')
else:
    print('NO')

Solution (Python):
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

if A == B:
    print('YES')
elif A > B:
    B -= T * W
    A -= T * V
    if A <= B:
        print('YES')
    else:
        print('NO')
else:
    B += T * W
    A += T * V
    if A >= B:
        print('YES')
    else:
        print('NO')

Solution (Python):
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())
if v-w>0 and abs(a-b)/(v-w)<=t:
    print("YES")
else:
    print("NO")

Solution (Python):
import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")

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


def main():
	A, V = getlist()
	B, W = getlist()
	T = int(input())
	dist = abs(A - B)
	if W > V:
		print("NO")
		return

	if dist <= T * (V - W):
		print("YES")
	else:
		print("NO")

if __name__ == '__main__':
	main()

Solution (Python):
def main():
    a, v = map(int, input().split())
    b, w = map(int, input().split())
    t = int(input())

    dist = abs(a - b)
    if dist - (v - w) * t <= 0:
        print('YES')
    else:
        print('NO')    

if __name__ == '__main__':
    main()

Solution (Python):
A,V = map(int,(input().split()))
B,W = map(int,(input().split()))
T = int(input())
d = abs(B-A)
if V <= W:
    print("NO")
else:
    if d > (V-W)*T:
        print("NO")
    else:
        print("YES")

Solution (Python):
import bisect
import sys
import math
from collections import deque
from heapq import heappush, heappop

def sRaw():
    return input().rstrip("\r")


def iRaw():
    return int(input())


def ssRaw():
    return input().split()


def isRaw():
    return list(map(int, ssRaw()))


INF = 1 << 29

DIV = (10**9) + 7


def mod_inv_prime(a, mod=DIV):
    return pow(a, mod-2, mod)


def mod_inv(a, b):
    r = a
    w = b
    u = 1
    v = 0
    while w != 0:
        t = r//w
        r -= t*w
        r, w = w, r
        u -= t*v
        u, v = v, u
    return (u % b+b) % b


def CONV_TBL(max, mod=DIV):
    fac, finv, inv = [0]*max, [0]*max, [0]*max
    fac[0] = fac[1] = 1
    finv[0] = finv[1] = 1
    inv[1] = 1
    for i in range(2, max):
        fac[i] = fac[i-1]*i % mod
        inv[i] = mod - inv[mod % i] * (mod//i) % mod
        finv[i] = finv[i-1]*inv[i] % mod

    class CONV:
        def __init__(self):
            self.fac = fac
            self.finv = finv
            pass

        def ncr(self, n, k):
            if(n < k):
                return 0
            if(n < 0 or k < 0):
                return 0
            return fac[n]*(finv[k]*finv[n-k] % DIV) % DIV

    return CONV()


def cumsum(As):
    s = 0
    for a in As:
        s += a
        yield s


sys.setrecursionlimit(200005)


def dijkstra(G,start=0):
    heap = []
    cost = [INF]*len(G)
    heappush(heap,(0,start))
    while len(heap)!=0:
        c,n = heappop(heap)
        if cost[n] !=INF:
            continue
        cost[n]=c
        for e in G[n]:
            ec,v = e
            if cost[v]!=INF:
                continue
            heappush(heap,(ec+c,v))
    return cost


def main():
    A,V =isRaw()
    B,W = isRaw()
    T = iRaw()
    dab = abs(A-B)
    dv = (V-W)
    if dab<=T*dv:
        print("YES")
    else:
        print("NO")



main()

Solution (Python):
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if v <= w:
    print("NO")
else:
    if abs(a - b) <= (v - w) * t:
        print("YES")
    else:
        print("NO")

Solution (Python):
a,v = list(map(int,input().split()))
b,w = list(map(int,input().split()))
t = int(input())

if v<=w:
    print("NO")
    exit()

if abs(a-b)<=abs(v-w)*t:
    print("YES")
else:
    print("NO")

Solution (Python):
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if abs(a-b)<=(v-w)*t:
    print('YES')
else:
    print('NO')

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math
import sys
import collections

mod = 10**9+7
sys.setrecursionlimit(mod) 

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

A,V = LI()
B,W = LI()
T = int(input())

if abs(A-B) <= (V-W) * T:
    print("YES")
else:
    print("NO")

Solution (Python):
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

print('YES' if V > W and abs(A - B) <= (V - W) * T else 'NO')

Solution (Python):
a,v=[int(j)for j in input().split()]
b,w=[int(j)for j in input().split()]
t=int(input())
p=abs(a-b)
if v-w<0:
    print("NO")
else:
    if t*(v-w)>=p:
        print("YES")
    else:
        print("NO")

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()

A, V=map(int, input().split()) 
B, W=map(int, input().split()) 
T = int(input())

if abs(A-B) <= (V-W)*T:
    print("YES")
else:
    print("NO")