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 numpy as np
from functools import *
import sys
sys.setrecursionlimit(100000)
input = sys.stdin.readline


def array(size,init=0):
    return [[init for j in range(size[1])] for i in range(size[0])]



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


def II():
    return int(input())

directions=np.array([[1,0],[0,1],[-1,0],[0,-1]])
directions = list(map(np.array, directions))

mod = 10**9+7


def factorial(n):
    fact = 1
    for integer in range(1, n + 1):
        fact *= integer
    return fact


def permutate(x,A):
    n=len(x)
    res=[-1]*n
    for i in range(n):

        res[i]=x[A[i]]
    return res


def generate_bin(digit):
    for b in range(2**digit):
        b=bin(b)
        tmp=b[2:].zfill(digit)
        yield list(map(int,tmp))
        
        
        

def search(x, count):
    
            

    for d in directions:
        nx = d+x
        
        if np.all(0 <= nx) and np.all(nx < (H, W)):
            if field[nx[0]][nx[1]] == "E":
                count += 1 
                field[nx[0]][nx[1]] = "V"
                count = serch(nx, count)  
                continue
            if field[nx[0]][nx[1]] == "
                field[nx[0]][nx[1]] = "V"
                count = serch(nx, count)    
                 
    return count

A,V=acinput()
B,W=acinput()

T=II()


d=abs(A-B)

if d<=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)

vel = abs(W-V)
 
if V*T >= W*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 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())

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

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


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

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

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

Solution (Python):
str1 = input()
str2 = input()
str3 = input()

A = str1.split(" ")
B = str2.split(" ")
C = int(str3)
res = ""



if int(A[1]) <= int(B[1]):
    res = "NO"
else:
    
    diff = abs(int(B[0]) - int(A[0]))

    
    speedDiff = abs(int(A[1]) - int(B[1]))

    if speedDiff * C < diff:
        res = "NO"
    else:
        res = "YES"


print(res)

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

daplus = a + v*t
daminus = a - v*t

if daplus < daminus:
    tmp = daplus
    daplus = daminus
    daminus = tmp

dbplus = b + w*t
dbminus = b - w*t

if dbplus < dbminus:
    tmp = dbplus
    dbplus = dbminus
    dbminus = tmp


flag = 0



if(daminus <= dbplus & dbplus <= daplus):
    flag += 1
if(daminus <= dbminus & dbminus <= daplus):
    flag += 1

if flag == 2:
    print("YES")
else:
    print("NO")

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

a = A + W*T
b = B + V*T
c = A - W*T
d = B - V*T


if A < B:
    if a >= b:
        print("YES")
    else:
        print("NO")
else:
    if c <= d:
        print("YES")
    else:
        print("NO")

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

D = float(abs(A-B))
E = float(V - W)

if E <= 0:
	print("NO")
	exit()
time = D/E
if time <= 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 abs(A-B)>T*(V-W):
    print('NO')
else:
    print('YES')

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

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

n=int(input())

if w<=y:

  print("NO")

else:

  print("YES") if abs(a-b)/(w-y)<=n 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):
import sys
def S(): return sys.stdin.readline().rstrip()
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())
INF = 1000000000000

a,v = LI()
b,w = LI()
T = I()

if(a == b):
    print('YES')
elif(a > b):
    diff = a - b
    diff2 = v - w
    if(diff2 <= 0):
        print('NO')
    else:
        if(diff / diff2 <= T):
            print('YES')
        else:
            print('NO')
else:
    diff = b - a
    diff2 = v - w
    if(diff2 <= 0):
        print('NO')
    else:
        if(diff / diff2 <= 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<0:
    if a > 0:
        d = a-b
    else:
        d = b-a
else:
    d = a-b
if d < 0:
    d = -d
if v > w:
    d2 = v-w
else:
    d2 = w-v
if  (v > w) and (d2*t < d):
    print("NO")
elif 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 V*T >= abs(B - A) + (T*W):
    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 or (V-W)*T < abs(B-A):
  print('NO')
else :
  print('YES')

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

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

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

distance = b - a
speed_remainder = v - w

if speed_remainder < 0:
    print("NO")
elif abs(distance) <= t * speed_remainder:
    print("YES")
else:
    print("NO")

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

eva=False

pl=abs(B-A)
ve=V-W

if pl<=ve*T:
    if ve>0:
        eva=True
if eva:
    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: 
    Ap = A + V*T
    Bp = B + W*T

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

    if Ap <= Bp:
        print('YES')
    else:
        print('NO')

Solution (Python):
import math

def a():
    s = input()
    print(s[:3])


def b():
    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')


def c():
    print('')



def d():
    print('')


b()

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


if A > B:
    A_len = A-V*T
    B_len = B-W*T


    if A_len <= B_len:
        print('YES')
    else:
        print('NO')

else:
    A_len = A+V*T
    B_len = B+W*T


    if A_len >= B_len:
        print('YES')
    else:
        print('NO')

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

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

Solution (Python):
import sys

n = list(map(int,input().split()))
r = list(map(int,input().split()))
t = int(input())

A = n[0]
V = n[1]

B = r[0]
W = r[1]

T = t

after_a = A + V * T
after_b = B + W * T

after_a_min = A - V * T
after_b_min = B - W * T

if (after_a == after_b) or (after_a_min == after_b_min):
    print('YES')
    sys.exit()

if A < B and after_a > after_b:
    print('YES')
    sys.exit()

if A < B and after_a < after_b:
    print('NO')
    sys.exit()


if A > B and after_a_min < after_b_min:
    print('YES')
    sys.exit()

if A > B and after_a_min > after_b_min:
    print('NO')
    sys.exit()

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

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

    ans = 'NO'

    if V > W:
        if A > B:
            t = (B-A)/(W-V)
        else:
            t = (B - A) / (V - W)

        if t <= T:
            ans = 'YES'

    print(ans)

if __name__ == '__main__':
    resolve()

Solution (Python):
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 a < b:
    t = (b-a) / (v-w)

else:
    t = (a-b) / (v-w)


if 0 < t <= T:
    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())
 
if a < b:
  if a+v*t>=b+w*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())

if A > B:
    V = -V
    if W > 0:
        W = -W

if A < B and W < 0:
    W = -W

    
a = V * T + A
b = W * T + B

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

Solution (Python):
a,c=map(int,input().split())
b,d=map(int,input().split())
t=int(input())
if c<=d:
  print('NO')
else:
  if abs(a-b)<=(c-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 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 math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.buffer.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.buffer.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

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

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

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

Solution (Python):
A, a = input().split()
B, b = input().split()
T = input()

A = int(A)
a = int(a)
B = int(B)
b = int(b)
T = int(T)

distance = abs(A-B)
speed = a-b

if distance - speed * T <= 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 a == b:
    print("YES")
    sys.exit()

sa = abs(a-b)
approach_rate = v-w


if approach_rate * t >= sa:
    print("YES")
else:
    print("NO")

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

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

    return 'NO'


print(solve())

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

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

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

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

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

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

Solution (Python):
a, v = (int(c) for c in input().split(" "))
b, w = (int(c) for c in input().split(" "))
t = float(input())
if v <= w:
    print("NO")
elif abs(a -b)/float(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=a-b
y=abs(x)
if v*t>=(y+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 t < abs(a - b) / abs(v - w):
    print("NO")
else:
    print("YES")

Solution (Python):
import math
import sys
a,v=(int(x) for x in input().split())
b,w=(int(x) for x in input().split())
t = int(input())

e1=pow(-10, 9)
e2=pow(10, 9)

if (a<e1)or(e2<a)or(b<e1)or(e2<b)or(v<1)or(e2<v)or(w<1)or(e2<w)or(t<1)or(e2<t)or(a==b):
    sys.exit(0)

ab = abs(b-a)/t+w-v

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

Solution (Python):
oni, oni_spd = list(map(int, input().split()))
child, child_spd = list(map(int, input().split()))
T = int(input())

dist = abs(child - oni)
ofs_spd = oni_spd - child_spd

if ofs_spd * T >= dist:
  print('YES')
else:
  print('NO')

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

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

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

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

    if speed_d<=0:
        print("NO")
    else:
        if (distance%speed_d)!=0:
            if ((distance//speed_d)+1)<=T:
                print("YES")
            else:
                print("NO")
        else:
            if ((distance//speed_d))<=T:
                print("YES")
            else:
                print("NO")




if __name__=="__main__":
    main()

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

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

if abs(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())
dis=abs(a-b)
speed=v-w
if speed>0 and dis/speed<=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)
s = v - w
if s <= 0 or L / s > t:
    result = "NO"
else:
    result = "YES"
print(result)

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

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

else:
    print("NO")

Solution (Python):
a=input()
b=a.split()
A=int(b[0])
V=int(b[1])
c=input()
d=c.split()
B=int(d[0])
W=int(d[1])
T=int(input())
if (A == B):print("YES")
elif (A < B):
    if A - B >= T * (W - V):print("YES")
    else: print("NO")
else :
    if A - B <= T * (V - W):
        print("YES")
    else:
        print("NO")

Solution (Python):






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

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

if A > B:
    W = -W
    V = -V

if V == W:
    print("NO")
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=(int(x) for x in input().split())
b,w=(int(x) for x in input().split())
t = int(input())
 
distance = abs(a-b)
sa = v - w
 
if distance <= t*sa:
  print('YES')
else:
  print('NO')

Solution (Python):
from sys import stdin
input = stdin.readline
 
A,V = input().rstrip().split()
B,W = input().rstrip().split()
T = int(input().rstrip())
A,V,B,W = int(A),int(V),int(B),int(W)
s=0
L1=A-B
L2=B-A
S=V-W
if V<=W:
  print('NO')
  s=1
else:
    if B<A:
      if L1/S<=T:
        print('YES')
      else:print('NO')
    else:
      if L2/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 v<=w:
    print('NO')
elif a<b and (b-a)/(v-w)<=t:
    print('YES')
elif b<a and (a-b)/(v-w)<=t:
    print('YES')
else:
    print('NO')

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

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

Solution (Python):
import sys
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(rs())
def rs_(): return [_ for _ in rs().split()]
def ri_(): return [int(_) for _ in rs().split()]

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

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):
  A *= -1
  B *= -1

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

Solution (Python):
in_a = [int(x) for x in input().split(' ')]
in_b = [int(x) for x in input().split(' ')]
t = int(input())

result = False

p_a = in_a[0]
p_b = in_b[0]
m_a = in_a[1]
m_b = in_b[1]
end_p_a = m_a*t
end_p_b = m_b*t

diff_s = abs(p_a-p_b)

if end_p_a-end_p_b>=diff_s:
  print('YES')
else:
  print('NO')

Solution (Python):
import numpy as np
import scipy as sp

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

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

Solution (Python):
a, v = input().split(' ')
a = int(a)
v = int(v)
b, u = input().split(' ')
b = int(b)
u = int(u)
t = int(input())


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

Solution (Python):
import sys

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

    out = 'NO'

    if V==W:
        if B==A:
            out = 'YES'
            print(out)
            sys.exit()
        else:
            print(out)
            sys.exit()

    if B < A:
        t = (B - A) / (W - V)
    else:
        t = (B - A) / (V - W)
        
    if t >= 0:
        if t<=T:
            out = 'YES'
    
    print(out)
main()

Solution (Python):
import sys

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

if w >= v:
    print('NO')
    sys.exit()

min_a = -1 * v * t + a
max_a = v * t + a
min_b = -1 * w * t + b
max_b = w * t + b

if min_a <= min_b and max_b <= max_a:
    print('YES')
else:
    print('NO')

Solution (Python):

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

from decimal import *













































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

inf = float('inf')
mod = 1000000007




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

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

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

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

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








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

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





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

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




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




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


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

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




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


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

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

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

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



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



if __name__ == "__main__":
	main()

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

if abs(A[0]-B[0])+B[1]*T>A[1]*T:
       print("NO")
else:
       print("YES")

Solution (Python):

def main():
    import sys
    imput = sys.stdin.readline
    
    
    
    
    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 (V-W)*T >= B-A:
                print("YES")
            else:
                print("NO")
    elif A > B:
        if V <= W:
            print("NO")
        else:
            if (V-W)*T >= 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 A == B:
  print("YES")
  exit()

if W >= V:
  print("NO")
  exit()
  
if A > B:
  V *= -1
  W *= -1

  A = A + V * T
  B = B + W * T
  if A <= B:
    print("YES")
    exit()

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

iter = False

if a < b:
  if a + t*v >= b + t*w:
    iter =True
 
elif a > b:
  if a - t*v <= b - t*w:
    iter = True

elif a == b:
  iter = True
  


if iter == True:
  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:
    if a==b:
        print("YES")
    else:
        print("NO")
elif v>w:
    t0 = abs((a-b)/(v-w))
    if t0<=t:
        print("YES")
    else:
        print("NO")

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


dir = 1
if b < a:
    dir = -1


pos_a = a + v * dir * t
pos_b = b + w * dir * t

ret = "NO"
if dir == 1 and pos_a >= pos_b:
    ret = "YES"
elif dir == -1 and pos_b >= pos_a:
    ret = "YES"

print("{}".format(ret))

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


distance = abs(b-a)

ds = v - w


ans = ""
if (ds * t) < (distance):
  ans = "NO"
else:
  ans = "YES"
print(ans)

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):
A, V = map(int, input().split(' '))
B, W = map(int, input().split(' '))
T = int(input())

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

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

Solution (Python):
oni = list(map(int,input().split()))
child =list(map(int,input().split()))
time = int(input())

if oni[0]<child[0]:
    oni_kyori = oni[0]+oni[1]*time
    child_kyori = child[0]+child[1]*time

    if oni_kyori<child_kyori:
        print('NO')
    else:
        print('YES')
else:
    oni_kyori = oni[0]-oni[1]*time
    child_kyori = child[0]-child[1]*time

    if oni_kyori>child_kyori:
        print('NO')
    else:
        print('YES')

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

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

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


main()

Solution (Python):
[a,v] = list(map(int, input().split()))
[b,w] = list(map(int, input().split()))
t = int(input())
if v>w:
    if abs(a-b) % (v-w) == 0:
        tRE = abs(a - b) // (v - w)
        if tRE<=t:
            print('YES')
        else:
            print('NO')
    else:
        tRE = abs(a - b) / (v - w)
        if tRE<t:
            print('YES')
        else:
            print('NO')
else:
    print('NO')

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

if v==w:
    print("NO")
    exit()
atai = Decimal(abs(b-a))/Decimal(abs(v-w))
if atai<=t and a+v*t>=b+w*t:
    print("YES")
else:
    print("NO")

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

if V <= W:
    print('NO')
    sys.exit()    

kyori = abs(A-B)
speed = abs(W-V)
ans = kyori / speed
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())
print("NO" if V==W or V<W or abs(A-B)/(V-W)>T 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")