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

kyori = abs(a-b)
sokudo = (v-w)

if sokudo > 0:
    if (kyori/sokudo)<=t:
        print("YES")
        exit()
elif sokudo == 0:
    if kyori == 0:
        print("YES")
        exit()

print("NO")

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

syoki = abs(a-b)
r = (v-w)*t

if syoki - r <= 0:
    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_max = A + V*T
    b_max = B + W*T
    if a_max >= b_max:
        print('YES')
    else:
        print('NO')
else:
    a_min = A - V*T
    b_min = B - W*T
    if a_min <= b_min:
        print('YES')
    else:
        print('NO')

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


if __name__ == '__main__':
    resolve()

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) <= 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())
sou=V-W
dis=abs(A-B)
if sou*T>=dis:
  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")
else:
    if a-v*t <= b-w*t:
        print("YES")
    else:
        print("NO")

Solution (Python):
A, V = [int(s) for s in input().split()]
B, W = [int(s) for s in input().split()]
T = int(input())
dist = abs(A - B)
speed = V - W
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(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):
a, v = map(int,input().split())
b, w = map(int, input().split())
t = int(input())
if a < b:
    A_dis = a + v*t
    B_dis = b + w*t
    if A_dis >= B_dis:
        print('YES')
    else:
        print('NO')
else:
    A_dis = a - v*t
    B_dis = b - w*t
    if A_dis <= B_dis:
        print('YES')
    else:
        print('NO')

Solution (Python):




import sys
input = sys.stdin.readline



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

    tar = (V - W) * T
    diff = abs(B - A)

    res = 'NO'

    if tar > 0:
        if tar >= diff:
            res = 'YES'


    print(res)



main()

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

x = t * (v - w)
if abs(b - a) <= x:
    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")
elif (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(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())

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

Solution (Python):
A,V = list(map(int,input().split()))
B,W = list(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 = list(map(int,input().split()))
B,W = list(map(int,input().split()))
T = int(input())
if V-W == 0 and A==B:
    print('YES')
    exit()
if V-W <= 0:
    print('NO')
    exit()
if (abs(A-B)/(V-W)) <= T:
    print('YES')
else:
    print('NO')

Solution (Python):
import sys

readline = sys.stdin.readline
readall = sys.stdin.read
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')

def solve():
    a, v = nm()
    b, w = nm()
    t = ni()
    if abs(a - b) <= (v - w) * t:
        print('YES')
    else:
        print('NO')
    return

solve()

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

dist = abs(a - b)

if dist == 0:
    print("YES")
    exit()

speed = v - w

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

able = t * speed

if dist <= able:
    print("YES")
else:
    print("NO")

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7


def resolve():
    a, v = map(int, input().split())
    b, w = map(int, input().split())
    t = int(input())
    dist = abs(a - b)
    sokudo = v - w
    if sokudo <= 0:
        print("NO")
    else:
        T = dist / sokudo
        print("YES" if T <= t else "NO")


if __name__ == '__main__':
    resolve()

Solution (Python):
A,V = map(int,input().split())
B,W = map(int,input().split())
T = int(input())
dif =abs(A - B)
if W >= V:
  print("NO")
else:
  oni = V*T - W*T
  if oni >= dif:
    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 = list(map(int, input().split()))
b,w = list(map(int, input().split()))
t = int(input())

diff = abs(a-b)
V = v-w
if V <= 0:
    print('NO')
else:
    if diff<=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(A < B):
  oni = A + V*T
  chi = B + W*T
  if(oni>=chi):
    print('YES')
  else:
    print('NO')
else:
  oni = B + V*T
  chi = A + W*T
  if(oni>=chi):
    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(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) <= (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())
ans = "NO"
if A < B:
  x = A + V * T
  y = B + W * T
  if x >= y:
    ans = "YES"
else:
  x = A - V * T
  y = B - W * T
  if x <= y:
    ans = "YES"
print(ans)

Solution (Python):
import sys, math
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

A, V = rl()
B, W = rl()
T = ri()

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

cap_a=v*t
cap_b=w*t+abs(b-a)

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

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

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

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

al, ar = A + -(T * V), A + (T * V)
bl, br = B + -(T * W), B + (T * W)

ans = "NO"
if A < B:
    if ar >= br:
        ans = "YES"
elif B < A:
    if al <= bl:
        ans = "YES"
else:
    ans = "YES"

print(ans)

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

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

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


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

Solution (Python):


def input_one_number():
    return int(input())

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

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


A , V = input_multiple_number()
B, W = input_multiple_number()
T = input_one_number()

D = abs(B-A)
v = V-W

if D - v*T > 0 :
	print("NO")
else:
	print("YES")

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

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

Solution (Python):
import math


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

if a == b:
    print('YES')
    exit(0)

if v <= w:
    print('NO')
    exit(0)

if (v - w) * t >= abs(a - b) and abs(a - b) % math.gcd(v, w) == 0:
    print('YES')
else:
    print('NO')

Solution (Python):


import sys
input= lambda: sys.stdin.readline().rstrip()
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))

def resolve():
    A,V=pin()
    B,W=pin()
    T,=pin()
    c=B-A

    if W==V:
        print("NO")
        return
    if c>0:
        t=c/(V-W)
        
        if T>=t and t>0:
            print("YES")
        else:print("NO")
    else:
        t=c/(V-W)
        t*=-1
        
        if T>=t and t>0:
            print("YES")
        else:print("NO")

resolve()

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

if v <= w:
  print('NO')
else:
  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())

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())
dist = abs(a-b)
nige = t*w
ou = t*v
if dist+nige <= ou:
    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())
    distance = abs(b - a)
    closing = v - w
    try:
        need = distance / closing
    except ZeroDivisionError:
        if distance == 0:
            need = 0
        else:
            need = 10 ** 9 + 10

    if 0 <= need <= t:
        print('YES')
    else:
        print('NO')


if __name__ == '__main__':
    main()

Solution (Python):
import sys

def input():
    return sys.stdin.readline()[:-1]

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

d = abs(b-a)
sa = v-w
if sa*t>=d:
    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 w*t+(abs(a-b))<=v*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)/abs(V-W) <= T else "NO")

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


T=int(input())

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

Solution (Python):
import sys, re
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left
from functools import reduce
from decimal import Decimal, getcontext

def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_list(N): return [s_list() for _ in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7

def main():
    a, v = i_map()
    b, w = i_map()
    t = i_input()



    if a < b:
        at = a + v * t
        bt = b + w * t
        print('YES' if at >= bt else 'NO')
    else:
        at = a - v * t
        bt = b - w * t
        print('YES' if at <= bt else 'NO')

if __name__ == '__main__':
    main()

Solution (Python):
def main1():
    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")

main1()

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

distance = abs(A - B)
speed = V - W
if (distance <= 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 (a > b):
    one = a - t * v
    two = b - t * w
    if (one <= two):
        print('YES')
    else:
        print('NO')

else:
    one = a + t * v
    two = b + t * w
    if (one >= two):
        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,b = b,a
x = a+v*t
y = b+w*t
if x<y:
    print("NO")
else:
    print("YES")

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

Solution (Python):
import sys
from collections import deque
import copy
def main():
    A, V = map(int, input().split())
    B, W = map(int, input().split())
    T = int(input())
    can_A = V * T
    can_B = W * T
    if A < B:
        B += can_B
        A += can_A
        if A >= B:
            print('YES')
        else:
            print('NO')
    else:
        B -= can_B
        A -= can_A
        if A <= B:
            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())
if W>=V:
  ans="NO"
else:
  if (V-W)*T>=abs(B-A):
    ans="YES"
  else:
    ans="NO"
print(ans)

Solution (Python):

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

d = V - W
if d > 0 and abs(A - B) / d <= 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())

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

if mys * t >= dist:
  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 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())

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

Solution (Python):
from collections import *
from math import *

a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())
if(a < b):
	x = a+v*t
	y = b+w*t
	if(x >= y):
		print("YES")
	else:
		print("NO")
else:
	x = a-v*t
	y = b-w*t
	if(x <= y):
		print("YES")
	else:
		print("NO")

Solution (Python):
oni_pos, oni_V = map(int, input().split())
nige_pos, nige_W = map(int, input().split())
T_s = int(input())

diff = abs(oni_pos - nige_pos)
d_V = oni_V - nige_W


if (oni_V == nige_W):
    print('NO')
    exit()

time = diff / d_V

if (d_V < 0):
    print('NO')
    exit()
    
if (time <= T_s):
    print('YES')
else:
    print('NO')

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

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

Solution (Python):


import math
import re
import numpy as np
import copy

S1 = input().split(" ")
A = int(S1[0])
V = int(S1[1])

S2 = input().split(" ")
B = int(S2[0])
W = int(S2[1])

T = int(input())


dist = abs(A-B)

speed = V - W

possible = False

if speed > 0:
    if dist / speed <= T:
        possible = True

if possible:
    print("YES")
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 V <= W:
    print("NO")
else:
    if abs(A - B) / (V - W) <= T:
        print("YES")
    else:
        print("NO")

Solution (Python):
oni_pos, oni_V = map(int, input().split())
nige_pos, nige_W = map(int, input().split())
T_s = int(input())

diff = abs(oni_pos - nige_pos)
d_V = oni_V - nige_W


if (oni_V == nige_W):
    print('NO')
    exit()

time = diff / d_V

if (d_V < 0):
    print('NO')
    exit()
    
if (time <= T_s):
    print('YES')
else:
    print('NO')

Solution (Python):
a = input().split()
b = input().split()
t = input()

d = abs(int(a[0]) - int(b[0]))

if (int(a[1]) <= int(b[1])):
    print('NO')
else:
    sek = int(a[1]) - int(b[1])

    if d <= int(t)*sek:
        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')
  exit()
if v<=w:
  print('NO')
  exit()

dx = abs(b-a)
dv = v-w
if dx/dv <= t:
  print('YES')
  exit()
print('NO')

Solution (Python):
import itertools
import copy
from collections import deque
import heapq
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())
if a < b:
    ax = a + v*t
    bx = b + w*t
    if ax >= bx:
        print("YES")
    else:
        print("NO")
else:
    ax = a - v*t
    bx = b - w*t
    if ax <= bx:
        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 a+v*t>=b+w*t:
    print("YES")
elif a>b 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())
print("YES" if 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())

dif = abs(b-a)
waru = v - w
if waru <= 0:
    print('NO')
    exit()
tmp = dif/waru

if tmp<=t:
    print('YES')
else:
    print('NO')

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

V = v - w
R = abs(a-b)
if V*t >= R:
    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:
  D=A-B
else:
  D=B-A
if V<=W:
  print("NO")
elif (V-W)*T>=D:
  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) + w*t  - v*t <= 0:
    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:
  key=abs(A-B)
  if key+W*T>V*T:
    print('NO')
  else:
    print('YES')

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

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

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

t = int(input())

def solve(a, v, b, w, t):
    if a == b:
        return 'YES'
    if v < w:
        return 'NO'
    if (v-w) * t >= abs(a-b):
        return 'YES'
    else:
        return 'NO'

print(solve(a, v, b, w, t))

Solution (Python):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate, product, combinations_with_replacement
import sys
import bisect
import string
import math
import time


def I(): return int(input())
def S(): return input()
def MI(): return map(int, input().split())
def MS(): return map(str, input().split())
def LI(): return [int(i) for i in input().split()]
def LI_(): return [int(i)-1 for i in input().split()]
def StoI(): return [ord(i)-97 for i in input()]
def ItoS(nn): return chr(nn+97)
def input(): return sys.stdin.readline().rstrip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def print_matrix(mat):
    for i in range(len(mat)):
        print(*['IINF' if v == IINF else "{:0=4}".format(v) for v in mat[i]])


yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**19
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
show_flg = False



def main():
    A, V = MI()
    B, W = MI()
    T = I()
    diff = abs(A - B)
    v = (V - W) * T

    
    

    if diff - v > 0:
        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())
if abs(B-A) - (V - W)*T <= 0:
    print('YES')
else:
    print('NO')

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

diff = abs(A - B)
diff_v = V - W


def solve():
    if diff == 0:
        return "YES"
    if diff_v <= 0:
        return "NO"

    if diff/diff_v <= T:
        return "YES"
    else:
        return "NO"


print(solve())

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

d = abs(a-b)

if v*k >= d + w*k:
  print("YES")
else:
  print("NO")

Solution (Python):
l1= input().split(' ')
a= int(l1[0])
v= int(l1[1])
l2= input().split(' ')
b= int(l2[0])
w= int(l2[1])
t=int(input())

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

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

Solution (Python):
AV = list(map(int, input().split()))
BW = list(map(int, input().split()))
T=int(input())

diff = abs(AV[0] - BW[0])
vdiff = AV[1] - BW[1]

if (vdiff <= 0):
    print("NO")
else:
    if (vdiff * 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 abs( b - a ) / t <= v - w:
    print( "YES" )
else:
    print( "NO" )

Solution (Python):
from collections import defaultdict,deque
from sys import stdin,setrecursionlimit
import heapq,bisect,math,itertools,string,queue,datetime,copy
setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, stdin.readline().split()))

a,v = inpl()
b,w = inpl()
t = int(input())

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

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

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

Solution (Python):
def resolve():
    A, V = [int(i) for i in input().split()]
    B, W = [int(i) for i in input().split()]
    T = int(input())
    if (V - W) * T >= abs(B - A):
        print("YES")
    else:
        print("NO")


resolve()

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

ans='NO'
if v-w==0:
  if a==b:
    ans='YES'
elif abs(a-b)/(v-w)>=0 and abs(a-b)/(v-w)<=t:
  ans='YES'

print(ans)

Solution (Python):
import sys

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

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

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

T=int(input())

sa=abs(A-B)
haya=V-W

if(sa<=0):
    print('NO')
elif(sa<=haya*T):
    print('YES')
    exit()
else:
    print('NO')

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

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

Solution (Python):
import sys


def _i(): return int(sys.stdin.readline().strip())


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


def main():
    a, v = _ia()
    b, w = _ia()
    t = _i()
    if a > b:
        ans = "YES" if a - (v-w) * t <= b else "NO"
    else:
        ans = "YES" if a + (v-w) * t >= b else "NO"

    return ans


if __name__ == "__main__":
    print(main())

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



if V <= W:
    print('NO')
    exit()
if 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 B < A:
    A, B = B, A

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

Solution (Python):
from decimal import *

l=list(map(int, input().split(' ')))
a=l[0]
v=l[1]
l=list(map(int, input().split(' ')))
b=l[0]
w=l[1]
s=int(input())
ans=True
if a>b:
    ans=Decimal(a)-Decimal(v*s)<=Decimal(b)-Decimal(w*s)
else:
    ans=Decimal(a)+Decimal(v*s)>=Decimal(b)+Decimal(w*s)
if ans:
    print("YES")
else:
    print("NO")

Solution (Python):


import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())

def resolve():
    it = map(int, sys.stdin.read().split())
    A, V, B, W, T = next(it),next(it),next(it),next(it),next(it)

    y, n = "YES", "NO"
    if A == B:
        print(y)
        return
    if V <= W:
        print(n)
        return
    print(y if (A-B)**2  <= (T*(W-V))**2 else n)

if __name__ == "__main__":
    resolve()

Solution (Python):
a, v1 = map(int, input().split())
b, v2 = map(int, input().split())
t = int(input())
l = abs(a-b)
delta_v = v1-v2
if delta_v <= 0:
  print("NO")
  exit()

if delta_v * t >= l:
  print("YES")
else:
  print("NO")

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

distance=abs(b-a)
chase=(v-w)*t

if v<=w:
    print("NO")
else:
    if chase>=distance:
        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 w >= v:
        print('NO')
        exit()
    if abs(a - b) <= (v - w) * t:
        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())

if (v - w) *t >= abs(b - a):
    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 :
    ans = "NO"
else:
    if abs(B-A) <= abs(V-W)*T:
        ans = "YES"
    else:
        ans = "NO"

print(ans)

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

distance = abs(A - B)
speed = V - W

if V - W <= 0:
    print('NO')
    exit(0)

t = distance // speed
if distance % speed == 0:
    if t <= T:
        print('YES')
    else:
        print('NO')
else:
    if t + 1 <= T:
        print('YES')
    else:
        print('NO')

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

ans = ""

if A < B:
    a = A + V * T
    b = B + W * T
    if a >= b:
        ans = "YES"
    else:
        ans = "NO"
else:
    a = A - V * T
    b = B - W * T
    if a <= b:
        ans = "YES"
    else:
        ans = "NO"

print(ans)

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