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):
def main():
    a,v = map(int,input().split())
    b,w = map(int,input().split())
    t = int(input())
    d = abs(b-a)
    u = v-w
    if u<=0:
        print('NO')
    else:
        if d/u>t:
            print('NO')
        else:
            print('YES')
    
if __name__ == "__main__":
    main()

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

Solution (Python):
import sys
INF = 1 << 60
MOD = 10**9 + 7 
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
    a, v = map(int, input().split())
    b, w = map(int, input().split())
    t = int(input())
    print("YES" if abs(b - a) <= t * (v - w) else "NO")
resolve()

Solution (Python):
from sys import stdin
import math
import re
import queue

input = stdin.readline

MOD = 1000000007
INF = 122337203685477580


def solve():

    A,V = map(int, input().split())
    B,W = map(int, input().split())
    T = int(input().rstrip())
    if(B < A):
        V *= -1
        W *= -1
    if (A-B)*(A + T*V - B -T*W) <= 0:
        print("YES")
    else:
        print("NO")

if __name__ == '__main__':
    solve()

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):
def main():
    import sys
    input = sys.stdin.readline
    A, V = [int(x) for x in input().strip().split()]
    B, W = [int(x) for x in input().strip().split()]
    T = int(input())
    if A == B:
        print('YES')
        return
    if W > V:
        print('NO')
        return
    if (V - W) * T >= abs(A - B):
        print('YES')
    else:
        print('NO')

if __name__ == '__main__':
    main()

Solution (Python):
import sys
a,v = map(int, sys.stdin.readline().rstrip("\n").split())
b,w = map(int, sys.stdin.readline().rstrip("\n").split())
t = int(sys.stdin.readline().rstrip("\n"))
between = abs(b - a)
speed = v-w
if between <= speed*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:
    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())


l = abs(a-b) 


diff = t*(v-w)

if l > diff:
  print("NO")
else:
  print("YES")

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

if v*t-abs(b-a)>=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 and B+W*T <= A+V*T:
    print("YES")
elif A > B and B-W*T >= A-V*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(A - B)
if (V > W) and \
   (D / (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*t-abs(b-a)>=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 or w>v:
    print('NO')
    sys.exit()
else:
    tp=(b-a)/(v-w)
    tm=(a-b)/(v-w)
    if b>a:
        if t>=tp:
            print('YES')
        else:
            print('NO')
    else:
        if t>=tm:
            print('YES')
        else:
            print('NO')

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

if V * T - abs(B-A) >= 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 w - v >= 0:
    print("NO")
    exit()

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

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)

def main():
    A, V = LI()
    B, W = LI()
    T = I()
    
    if V - W > 0:
        print("YES" if (V - W) * T >= abs(A - B) else "NO")
    else:
        print("NO")

main()

Solution (Python):
A,V=map(int,input().split())
B,W=map(int,input().split())
T=int(input())
if(A<B):
  A1=A+V*T
  B1=B+W*T

  if(A1>=B1):
    print('YES')
  else:
    print('NO')
    
else:
  A1=A-V*T
  B1=B-W*T

  if(A1<=B1):
    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:
    a=V*T
    b=W*T
    a=A+a
    b=B+b
    if b<=a:
        print("YES")
    else:
        print("NO")
elif B<A:
    a=V*T
    b=W*T
    a=A-a
    b=B-b
    if a<=b:
        print("YES")
    else:
        print("NO")
else:
    print("YES")

Solution (Python):
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
if B > A:
    A = A + V*T
    B = B + W*T
    if A >= B:
        print('YES')
    else:
        print('NO')
else:
    A = A - V*T
    B = B - W*T
    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())

distance = abs(a-b)

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

Solution (Python):
a,v,b,w,t=map(int,open(0).read().split())
print('YNEOS'[abs(b-a)>(v-w)*t::2])

Solution (Python):
a,v,b,w,t=map(int,open(0).read().split())
print(['NO','YES'][abs(b-a)<=(v-w)*t])

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

Solution (Python):



import sys
from collections import defaultdict, deque
from heapq import heappush, heappop
import math
import bisect
input = sys.stdin.readline




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

if v <= w:
    print('NO')
else:
    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 a < b:
    if v <= w:
        print('NO')
    else:
        if b - a <= t * (v - w):
            print('YES')
        else:
            print('NO')
elif a > b:
    if v <= w:
        print('NO')
    else:
        if 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())
d = abs(b-a)
d2 = v-w
print('YES' if d <= d2*t else 'NO')

Solution (Python):
stdin = [input() for i in range(3)]
line = stdin[0].split(' ')
A = int(line[0])
V = int(line[1])
line = stdin[1].split(' ')
B = int(line[0])
W = int(line[1])
T = int(stdin[2])
length = 0
if B > A:
    length = B-A
else:
    length = A-B
if (V-W)*T < length:
    print('NO')
else:
    print('YES')

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

if a < b:
    if v <= w:
        print('NO')
    else:
        if b - a <= t * (v - w):
            print('YES')
        else:
            print('NO')
elif a > b:
    if v <= w:
        print('NO')
    else:
        if 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())

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

if n <= 0:
  print("NO")
  exit()
print("YES" if n * T >= d else "NO")

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

if W>=V:
  print("NO")
elif abs(B-A)/(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):
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
if a<b:
  if w<v:
    if (v-w)*t>=(b-a):
      print("YES")
    else:
      print("NO")
  else:
    print("NO")
else:
  if w<v:
    if (v-w)*t>=(a-b):
      print("YES")
    else:
      print("NO")
  else:
    print("NO")

Solution (Python):
a, v = [int(i)  for i in input().split()]
b, w = [int(i)  for i in input().split()]
t = int(input())

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


if b > a:
  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):




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-v*t <= b-w*t and b+w*t <= a+v*t:
    print('YES')
else:
    print('NO')

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

set_position = abs(B-A)
move         = V-W

if move*T >= set_position:
  print("YES")
else:
  print("NO")

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

dist = abs(B-A)
r_vel = V - W

if r_vel * 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)*T >= abs(A-B):
  print("YES")
else:
  print("NO")

Solution (Python):
oni_A, oni_V = map(int, input().split())
nige_B, nige_W = map(int, input().split())
T = int(input())

d = abs(oni_A - nige_B)

if (nige_W >= oni_V):
    print('NO')
else:
    time = d / (abs(oni_V - nige_W))
    if (time <= T):
        print('YES')
    else:
        print('NO')

Solution (Python):
import math
import string
import collections
from collections import Counter
from collections import deque
from decimal import Decimal
import sys
import fractions
from operator import itemgetter


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor



dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if v < w:
    print('NO')
    exit()
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())
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 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):
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

S = V - W
print('NO' if S <= 0 or abs(A - B) > T * S else '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):
import sys

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

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

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

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

t = int(input())

sa = abs(a-b)

tume = v-w

if tume*t < sa:
    print('NO')
else:
    print('YES')

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

abs_BA = abs(B-A)
sub_VW = V - W

if sub_VW <= 0:
  print("NO")
elif abs_BA <= T * sub_VW:
  print("YES")
else:
  print("NO")

Solution (Python):
def solve(d,p,t):
  if d - p * t <= 0:
    return "YES"
  else:
    return "NO"

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

d = abs(B-A)
p = V - W
print(solve(d,p,T))

Solution (Python):
buf = list(map(int,input().split(" ")))
A,V = buf[0],buf[1]

buf = list(map(int,input().split(" ")))
B,W = buf[0],buf[1]

T = int(input())

if V <= W:
    print("NO")
    exit(0)
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(W > V):
    print('NO')
    exit(0)

S = V - W
D = abs(A - B)
if(D > S * T):
    print('NO')
    exit(0)
else:
    print('YES')

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



S = V - W
D = abs(A - B)
if(D > S * T):
    print('NO')
    exit(0)
else:
    print('YES')

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')
		exit()

print('NO')

Solution (Python):
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
x=(v-w)*t
if x>=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())


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

Solution (Python):
x = input().split()
a, v = int(x[0]), int(x[1])
x = input().split()
b, w = int(x[0]), int(x[1])
t = int(input())
if abs(b-a)+w*t <= v*t:
	print("YES")
else:
	print("NO")

Solution (Python):
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
z=(v*t)
y=(w*t)
if z-y>=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())

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

Solution (Python):
import sys
a = list(map(int,input().split()))
b = list(map(int,input().split()))
t = int(input())
if a[1] <= b[1]:
    print('NO')
    sys.exit()
elif abs(a[0]-b[0])/abs(a[1]-b[1]) <= t:
    print('YES')
    sys.exit()
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())
s=int(input())
if(abs(a-b)>(v-w)*s):
  print("NO")
else:
  print("YES")

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

if v<=w:
	print "NO"
elif t*(v-w)>=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())
ans = 'NO'
d = abs(a-b)
m = (v-w)*t

if d-m <= 0:
    ans = 'YES'

print(ans)

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

if W>=V:
    print("NO")
    quit()

SA=abs(A-B)

IDOU=V-W

IDOUTARN=IDOU*T

ANS=SA-IDOUTARN

if ANS<=0:
    print("YES")
else:
    print("NO")

Solution (Python):

"""東京海上日動　プログラミングコンテスト2020: A - Tag
https://atcoder.jp/contests/tokiomarine2020/tasks/tokiomarine2020_b
"""


def run(a, vt, b, wt):
    if a < b:
        if b + wt <= a + vt:
            return 'YES'
        else:
            return 'NO'
    else:
        if a - vt <= b - wt:
            return 'YES'
        else:
            return 'NO'


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

    print(run(A, V*T, B, W*T))


if __name__ == '__main__':
    main()

Solution (Python):
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
if a<b and v<=w:
    print("NO")
elif(w>v and (a>b or b>a or a==b)):
    print("NO")
else:
    if abs(b-a)<=t*abs(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 a<b and v<=w:
    print("NO")
elif w>v:
    print("NO")
else:
    if abs(b-a)<=t*abs(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 a<b and v<=w:
    print("NO")
else:
    if abs(b-a)<=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 (V-W)*T>=abs(A-B):
    print('YES')
else:
    print('NO')

Solution (Python):
A, V = tuple(int(c) for c in input().split(' '))
B, W = tuple(int(c) for c in input().split(' '))
T = int(input())

delta = V - W

if A == B:
  print('YES')
  exit()
elif delta <= 0:
  print('NO')
  exit()
else:
  d = abs(A-B)
  time = d / delta
  if time <= T:
    print('YES')
  else:
    print('NO')

Solution (Python):
def main():
    A,V = [int(x) for x in input().split()]
    B,W = [int(x) for x in input().split()]
    T = int(input())
    D = abs(A-B)
    if V<=W:
        print('NO')
        return
    F = V-W
    if D/F <= T:
        print('YES')
    else:
        print('NO')

if __name__ == '__main__':
    main()

Solution (Python):
def LI(): return list(map(int, input().split()))
def I(): return map(int, input().split())
mod = 10**9 + 7

def main():
  a, v = I()
  b, w = I()
  t = int(input())
  if v <= w:
    print('NO')
  else:
    if abs(a-b) <= (v-w)*t :
      print('YES')
    else:
      print('NO')

if __name__ == '__main__':
  main()

Solution (Python):
a,v,b,w,t=map(int,open(0).read().split())
print('YNEOS'[v-w<abs(a-b)/t::2])

Solution (Python):
a,v,b,w,t=map(int,open(0).read().split())
print('YNEOS'[v-w<abs(a-b)/t::2])

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

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

Solution (Python):


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

ans=a+t*v>=b+t*w and a-t*v<=b-t*w
print('YES' if ans else 'NO')

Solution (Python):
import sys
sys.setrecursionlimit(300000)

def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI0(): return map(lambda s: int(s) - 1, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
def LMI0(): return list(map(lambda s: int(s) - 1, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')


A, V = MI()
B, W = MI()
T = I()


d = max(0, V - W)
if abs(A - B) - d * T <= 0:
    print('YES')
else:
    print('NO')

Solution (Python):
import sys, os, math, bisect, itertools, collections, heapq, queue
from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal



sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)


MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    A, V = il()
    B, W = il()
    T = ii()

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


if __name__ == '__main__':
    main()

Solution (Python):
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) <= 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 a < b:
    if a + (v * t) >= b + (w * t):
        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())
dist = abs(a-b)
speed = v-w
if speed<=0:
    print('NO')
    exit()
if dist<=speed*t:
    print('YES')
else:
    print('NO')

Solution (Python):
import sys
import math
import collections
import decimal
import itertools
from collections import deque
from functools import reduce
import heapq

a, v = map(int, sys.stdin.readline().split())


     

b, w = map(int, sys.stdin.readline().split())
t = int(input())


if a > b:
    x = a - b
if b > a:
    x = b - a

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

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

if b[1]-a[1]>0:
  print('NO')
else:
  if abs(a[0]-b[0])>(a[1]-b[1])*t:
    print('NO')
  else:
    print('YES')

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

Solution (Python):
import sys
input = sys.stdin.readline
P = [list(map(int,input().split())) for i in range(2)]
T = int(input())
if(P[0][1]<P[1][1]):
  print('NO')
else:
  if(abs(P[0][0]-P[1][0])<=abs(P[0][1]-P[1][1])*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")
elif(abs(B - A) > abs(V - W) * T):
	print("NO")
else:
	print("YES")

Solution (Python):
A,V = [int(i) for i in input().split() ]
B,W = [int(i) for i in input().split() ]
T = int(input()) 

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

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

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
a, v = M() 
b, w = M() 
t = I()
ans = 'NO'
if v-w > 0:
    b_hiku_a = abs(b - a)
    v_hiku_w = v - w
    if b_hiku_a <= t * (v-w):
        ans = 'YES'
print(ans)

Solution (Python):
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())
if v*t >= abs(b-a) + 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(a-b)
if v<=w:
    print('NO')
elif d/(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 W >= V:
	print('NO')
else:
	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())
gap=abs(a-b) 
if v>w:
  c=gap/(v-w)
  if t>=c:
    print('YES')
  else:
    print('NO')
else:
  print('NO')

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

dist = abs(b - a)
r_vel = v - w 

if r_vel * 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(b > a):
    if(b + w*t <= a + v*t):
        print('YES')
    else:
        print('NO')
if(b < a):
    if(b - w*t >= a - v*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(a-b):
  print("NO")
else:
  print("YES")

Solution (Python):
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if abs(b - a) <= 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(b-a) <= 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())

D1 = abs(A-B)
D2 = (V-W)*T

if (D1 - D2) <=0:
  print("YES")
else:
  print("NO")

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

distance = abs(A[0] - B[0])

A[1] = A[1] * T
B[1] = B[1] * T

if distance <= (A[1] - B[1]):
  print('YES')
else:
  print('NO')

Solution (Python):

from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right

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

if __name__ == "__main__":
    main()

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()
else:
    d=abs(a-b)
    s=v-w
    if d<=t*s:
        print('YES')
        sys.exit()
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()

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

if d <= s * 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(b - a) <= 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 A<B and V*T+A>=W*T+B:
    print('YES')
elif A>B and A-T*V<=B-T*W:
    print('YES')
else:
    print('NO')

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

Solution (Python):
A, V = [int(i) for i in input().split()]
B, W = [int(i) for i in input().split()]
T = int(input())

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

Solution (Python):


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

ans = 'NO'
dist = abs(A - B)
diff = V - W

if diff > 0 and dist <= T * diff:
    ans = 'YES'
print(ans)

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(B - A) / (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:
    
    
    
    if abs(a - b) <= (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())
T = int(input())

dis=abs(A-B)
dis1=(V-W)*T

if dis<=dis1:
    print("YES")
else:
    print("NO")

Solution (Python):
import numpy as np


def main(A, B, V, W, T):
    if abs(B-A) <= T*(V-W):
        return "YES"
    return "NO"


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

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(B - A) / (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 sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate


def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))



def read_a_int(): return int(read())


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


def read_col(H):
    '''H is number of rows
    A列、B列が与えられるようなとき
    ex1)A,B=read_col(H)    ex2) A,=read_col(H) 
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return tuple(map(list, zip(*ret)))


def read_tuple(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_matrix(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return ret
    


MOD = 10**9 + 7
INF = 2**31  

from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  

A, V = read_ints()
B, W = read_ints()
T = read_a_int()

if W >= V:  
    print('NO')
    exit()

D = V - W  
if D * 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())
if v*t >= abs(b-a) + w*t:
    print('YES')
else:
    print('NO')

Solution (Python):
def resolve():
    A,V =map(int,input().split())
    B,W = map(int,input().split())
    T = int(input())
    AB =abs(A-B)
    VW = V-W

    if AB == 0 and VW ==0:
        print("YES")
        return
    elif VW <=0:
        print("NO")
        return

    if AB/VW > T:
        print("NO")
    else:
        print("YES")
resolve()

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