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):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

A, V = MAP()
B, W = MAP()
T = INT()

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

D=B-A
U=V-W

if D<=U*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 + 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:
  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:
    if a + t * v >= b + t * w:
        print("YES")
    else:
        print("NO")
else:
    if 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())
u=max(a-b,b-a)
if v<=w:
  print('NO')
elif u/(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())
X=abs(A-B)
Y=V-W
if X<=Y*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())
    
    if A <= B:
        if A+V*T >= B+W*T:
            ans = 'YES'
        else:
            ans = 'NO'
    else:
        if A-V*T <= B-W*T:
            ans = 'YES'
        else:
            ans = 'NO'
    
    print(ans)
    
if __name__ == '__main__':
    main()

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

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

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

speed = v - w
dist = abs(a - b)
dist1 = speed * t

if dist1 >= dist:
    print("YES")
else:
    print("NO")

Solution (Python):
a, v = map(int, input().split())
b, w = map(int, input().split())
t =int(input())
x = v-w
c = abs(a-b)
if x * t >= c:
    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: print('YES');exit()
if v-w<=0:print('NO');exit()
dist = abs(b-a)
velocity = v-w
if dist/velocity <=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())
    sa=abs(a-b)
    vsa=v-w
    if vsa<=0:
        print("NO")
    elif vsa*t<sa:
        print("NO")
    else:
        print("YES")
resolve()

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

Solution (Python):
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
A,V = LI()
B,W = LI()
T = I()
if V<=W:
    print('NO')
else:
    if (max(A,B)-min(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 + w * t:
        print("YES")
    else:
        print("NO")
        
else:
    if 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')
else:
    ans=abs(a-b)/abs(v-w)
    if(ans>t):
        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:
    if B + T*W > A + T*V:
        print("NO")
    else:
        print("YES")
else:
    
    if B - T*W < A - T*V:
        print("NO")
    else:
        print("YES")

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

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

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

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

Solution (Python):
import sys

if sys.subversion[0] == "PyPy":
    import io, atexit

    sys.stdout = io.BytesIO()
    atexit.register(lambda: sys.__stdout__.write(sys.stdout.getvalue()))

    sys.stdin = io.BytesIO(sys.stdin.read())
    input = lambda: sys.stdin.readline().rstrip()
RS = raw_input
RA = lambda x=int: map(x, RS().split())
RN = lambda x=int: x(RS())


def solve():
    speed = (v- w)
    dist = abs(b - a)
    if speed * t >= dist:
        print("YES")
        return
    else:
        print("NO")
        return




a , v = RA()
b , w = RA()
t = RN()
solve()

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

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

kyori = abs(B-A)
s = V-W
if kyori <= 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 W < V and abs(A-B) <= T*abs(W-V):
  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)
speed = V - W

if speed > 0:
    if distance / speed <= 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())

d = abs(a - b)
u = v - w
if u > 0 and (d+u-1) // u <= 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)
spd = V-W
ans = "YES"

if spd*T < dist:
    ans = "NO"

print(ans)

Solution (Python):
from math import *

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

if (v-w)>0:
	tm=(abs(b-a))/(v-w)
	if tm<=t:
		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")
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())

oni = v * w

tdist = 0

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

Solution (Python):
import sys
x=input()
y=input()
x0=x.split()
a=int(x0[0])
v=int(x0[1])
y0=y.split()
b=int(y0[0])
w=int(y0[1])
t=int(input())
l=abs(a-b)
r=v-w
if r<=0:
    print("NO")
    sys.exit()
if l/r<=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+T*V < B+T*W:
        print("NO")
    else:
        print("YES")
else:
    if A-T*V > B - T*W:
        print("NO")
    else:
        print("YES")

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

f=False
if a == b:
    f=True
elif v - w > 0:
    if abs(b-a) <= (v-w)*t:
        f = True

if f:
    print('YES')
else:
    print('NO')

Solution (Python):
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
leng = abs(A - B)
move = V - W
if move <= 0:
    print("NO")
else:
    if move * T >= leng:
        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)
dist2=(v-w)*t
if dist>dist2:
	print("NO")
else:
	print("YES")

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

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

Solution (Python):
import sys
import math
import itertools
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if (v == w):
    print('NO')
    sys.exit()
if (abs(a - b) / (v-w) > t or 0>(v-w)):
    print('NO')
else:
    print('YES')

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

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

distance = abs(a-b)

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

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

Solution (Python):
a, v = [int(k) for k in input().split()]
b, w = [int(k) for k in 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())
D = abs(A-B)
S = V-W
print("YNEOS"[D>T*S::2])

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

if __name__ == "__main__":
    main()

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

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

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

diff_x=abs(A-B)
diff_a=max(V-W,0)

if T*diff_a>=diff_x:
  print('YES')
else:
  print('NO')

Solution (Python):

from sys import stdin
from operator import itemgetter
from collections import deque, Counter
import math
import pprint
from functools import reduce


MOD = 1000000007

def keta(kazu):
    kazu_str = str(kazu)
    kazu_list = [int(kazu_str[i]) for i in range(0, len(kazu_str))]
    return kazu_list

def gcd(*numbers):
    return reduce(math.gcd, numbers)

def combination(m,n):
    
    if n > m:
        return 'すまん'
    return math.factorial(m) // (math.factorial(m-n) * math.factorial(n))

def pow_k(x,n):  
    if n == 0:
        return 1
    K = 1
    while n > 1:
        if n % 2 != 0:
            K *= x
        x *= x
        n //= 2
    return K * x
    
def main():
    a, v = [int(x) for x in stdin.readline().rstrip().split()]
    b, w = [int(x) for x in stdin.readline().rstrip().split()]
    t = int(stdin.readline().rstrip())
    start = abs(a-b)
    if t*v - t*w >= start:
        print("YES")
    else:
        print("NO")
    
main()

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

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

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

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

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

Solution (Python):

import sys

YES = "YES"  
NO = "NO"  


def solve(A: int, V: int, B: int, W: int, T: int):
    
    d_dif = abs(A-B)
    if d_dif==0:
        print(YES)
        return
    v_dif = V - W
    if v_dif <=0:
        print(NO)
        return
    t = d_dif/v_dif
    if t <= T:
        print(YES)
    else:
        print(NO)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    V = int(next(tokens))  
    B = int(next(tokens))  
    W = int(next(tokens))  
    T = int(next(tokens))  
    solve(A, V, B, W, T)

if __name__ == '__main__':
    main()

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

if a == b:
  print("YES")
else:
  kyori = abs(a-b)
  if w >= v:
    print("NO")
    sys.exit()
  diff = abs(v-w)
  if t*diff >= kyori:
    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 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())

dis = abs(a-b)

if dis == 0:
    print("YES")
else:
    vdiff = v-w

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

d = abs(a-b)

v = max(V-W,0)

print('YES' if v*T >= d else 'NO')

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

oni = a + v*t
nige = b + w*t
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):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

A, V = mapint()
B, W = mapint()
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 V<=W:
    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(V-W) == 0:
  print("NO")
else:  
  ans = abs(B-A)/(V-W)
  if ans < 0:
    print("NO")
  else:
    if ans <= 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_place=A+V*T
    B_place=B+W*T
    if A_place>=B_place:
        print("YES")
    else:
        print("NO")
else:
    A_place=A-V*T
    B_place=B-W*T
    if A_place<=B_place:
        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)
v=v-w
if v<=0:
    print("NO")
elif l/v<=t:
    print("YES")
else:
    print("NO")

Solution (Python):
import sys


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


if __name__ == '__main__':
    main()

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

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

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

b = abs(A - B) + W*T
a = V*T

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

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

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

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

if mov * 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):
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

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

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

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
import numpy as np

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

dis = abs(b-a)
hayasa = v-w
ikeru = 0
if hayasa<= 0:
    pass
else:
    if t*hayasa >= dis:
        ikeru = 1
    else:
        pass

if ikeru == 1:
    print("YES")
else:
    print("NO")

Solution (Python):
from math import gcd

from math import factorial as f

from math import ceil,floor,sqrt
import math

import bisect
import re
import heapq


from copy import deepcopy
import itertools
from itertools import permutations

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))


yes = "Yes"
no = "No"


def main():
    a,v = mi()
    b,w = mi()
    t = ii()
    if v <= w:
        print('NO')
        exit()

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




main()

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

d = abs(A-B)
dd = V-W
if dd<=0:
  print('NO')
elif d/dd <= T:
  print('YES')
else:
  print('NO')

Solution (Python):

import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from bisect import bisect_left 
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep='\n')

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

l = abs(B-A)
dV = V-W

if dV<=0 and l>0:
    print('NO')
else:
    if dV*T>=l:
        print('YES')
    else:
        print('NO')

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

v1 = v-w
if v1<=0:
    print('NO')
    exit()
l = abs(a-b)

if v1*t>=l:
    print('YES')
else:
    print('NO')

Solution (Python):
A, V = [int(x) for x in input().split()]
B, W = [int(x) for x in input().split()]
T = int(input())    
print('YES' if V>W and  abs(B-A+(V-W-1))//(V-W) <= T else 'NO')

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

d = abs(a - b)

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

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

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

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

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

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

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

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

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

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

Solution (Python):

import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

A, V = lr()
B, W = lr()
if A == B:
    print('YES'); exit()
T = ir()
speed = V - W
if speed <= 0:
    print('NO'); exit()

bl = abs(A-B) / speed <= T
print('YES' if bl else '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 (b > a):
    if (b + w * t > a + v * t):
        print("NO")
    else:
        print("YES")
else:
    if (b - w * t < a - v * t):
        print("NO")
    else:
        print("YES")

Solution (Python):




def input_int():
    return int(input())



def int1(x):
    return int(x) - 1



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



def input_to_int_tuple():
    return tuple(map(int, input().split()))



def input_to_int_tuple_minus1():
    return tuple(map(int1, input().split()))


def main():
    a, v = input_to_int_map()
    b, w = input_to_int_map()
    t = input_int()

    tidimu = v - w
    if tidimu <= 0:
        return "NO"

    ret = "NO"
    if abs(a - b) - (tidimu * t) <= 0:
        ret = "YES"

    return ret


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

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

if w < v 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())

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

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