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

Solution (Python):
def main():
    A, V = map(int, input().split())
    B, W = map(int, input().split())
    T = int(input())
    dis = abs(B - A)
    if W >= V:
        print('NO')
        exit()
    dis_V = V - W
    time = dis // dis_V if dis % dis_V == 0 else (dis // dis_V) + 1
    
    if T >= time:
        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:
  print('NO')
else:
  if (V-W)*T >= abs(A-B):
    print('YES')
  else:
    print('NO')

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

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

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


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

s = ""

if v - w <= 0:
    s = "NO"
else:
    if abs(a-b) // (v-w)  > t:
        s = "NO"
    elif abs(a-b) // (v-w)  == t and abs(a-b) % (v-w)  > 0:
        s = "NO"
    else:
        s = "YES"
    

print(s)

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

Solution (Python):
import math


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

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

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

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

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

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

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

Solution (Python):
A,V=map(int,(input().split()))
B,W=map(int,(input().split()))
T=int(input())
dist=abs(A-B)
sp=V-W
if(sp*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 = [int(i) for i in input().split()]
b, w = [int(i) for i in 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())

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

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

if T * vel >= dist:
  print("YES")
else:
  print("NO")

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

dif = abs(A - B)
spe = V - W

if spe <= 0 or dif > spe * T:
  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:
    print("NO")
    quit()

SA=abs(A-B)
CHIJI=(V-W)
SA=SA-(CHIJI*T)

    
if SA<=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:
    if a+v*t>=b+w*t:
        print("YES")
    else:
        print("NO")
elif a==b:
    print("YES")
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,b = b,a
m = 10**9
a+=m
b+=m
a+=v*t
b+=w*t
if 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())

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

print(ans)

Solution (Python):
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy


if __name__ == "__main__":
    a,v = map(int,input().split())
    b,w = map(int,input().split())
    t = int(input())
    d = abs(a-b)
    vt = v*t
    wt = w*t
    b = d + wt
    if vt >= b:
        print("YES")
    else:
        print("NO")

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

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

Solution (Python):
import sys, math
import io, os





def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')


mod = 998244353


a,v=mdata()
b,w=mdata()
t=int(data())
if a==b:
    out("YES")
elif a<b and a+v*t>=b+w*t:
    out("YES")
elif a>b and a-v*t<=b-w*t:
    out("YES")
else:
    out("NO")

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

if A < B:
  a = A + T * V
  b = B + T * W
  
else:
  b = A - T * V
  a = B - T * W
  
if 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())

dis = abs(a-b)

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

if w > v:
    print('NO')
    exit()

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

Solution (Python):
import sys
from collections import defaultdict
readline = sys.stdin.buffer.readline



def geta(fn=lambda s: s.decode()):
    return map(fn, readline().split())


def gete(fn=lambda s: s.decode()):
    return fn(readline().rstrip())


def main():
    a, v = geta(int)
    b, w = geta(int)
    t = gete(int)

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


if __name__ == "__main__":
    main()

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

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

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

    if V == W:
        if A == B:
            print('YES')
        else:
            print('NO')
        return

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

    if d <= dv * T:
        print('YES')
    else:
        print('NO')
    return


if __name__ == '__main__':
    main()

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

Solution (Python):

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

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

Solution (Python):
import sys
a,v  = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
kyori = abs(a - b)
tumari = v - w
if tumari <= 0:
    print('NO')

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

Solution (Python):
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]

def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  a,v=LI()
  b,w=LI()
  t=I()

  sa=abs(a-b)

  if sa-(v*t-w*t)<=0:
    return 'YES'

  return 'NO'


print(main())

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

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

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

Solution (Python):
a, speedA = map(int, input().split())
b, speedB = map(int, input().split())
t = int(input())
def do():
    if speedB >= speedA:
        print("NO")
        return 0

    d = abs(a - b)
    x = speedA - speedB
    
    
    

    reachTime = d / x
    if reachTime <= t:
        print("YES")
        return 0
    else:
        print("NO")
        return 0
do()

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

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

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

t = int(input())

d = abs(b-a)
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())

if V <= W:
    if A == B:
        print('YES')
        exit()
    else:
        print('NO')
        exit()
else:
    t = abs(A-B)/(V-W)
    if T >= 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('NO')
  else:
    print('YES')
else:
  if A - V * T > 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())
dist = V-W
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 v-w<=0:
  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())
if w-v>=0 :
  print('NO')
else :
  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())
d = 0

if  a < b:
    d = b - a
else:
    d = a - b

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

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

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

if abs(a - b) <= (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+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())

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

Solution (Python):
A, A_v = map(int, input().split())
B, B_v = map(int, input().split())
Ts = int(input())


if A > B:
    A, B = B, A

if A + A_v * Ts >= B + B_v * Ts:
    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*t-w*t):
  print("NO")
else:
  print("YES")

Solution (Python):


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

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

if __name__ == '__main__':
    main()

Solution (Python):


import sys
import math
import collections
import itertools
import bisect
INF = 10 ** 13
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return x if y == 0 else gcd(y, x%y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def LS() : return input().split()
def RS(N) : return [input() for _ in range(N)]
def LRS(N) : return [input().split() for _ in range(N)]
def PL(L) : print(*L, sep="\n")
def YesNo(B) : print("Yes" if B else "No")
def YESNO(B) : print("YES" if B else "NO")

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

flag = False

s = abs(A-B)

if s == 0:
    flag = True
else:
    if W >= V:
        flag = False
    else:
        t = V - W

        if s <= T*t:
            flag = True

YESNO(flag)

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

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

Solution (Python):
def main(A, V, B, W, T):
    dist = abs(A - B)
    velo = V - W
    if dist <= velo * T:
        print('YES')
    else:
        print('NO')

if __name__ == '__main__':
    A, V = list(map(int, input().split()))
    B, W = list(map(int, input().split()))
    T = int(input())
    main(A, V, B, W, T)

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

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

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



def main():
    A, V = [int(i) for i in input().strip().split()]
    B, W = [int(i) for i in input().strip().split()]
    T = int(input().strip())
    if abs(A - B) <= (V - W) * T:
        return "YES"
    else:
        return "NO"


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

Solution (Python):
import sys

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

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

    diff = abs(a-b)
    shrink = v - w

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

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

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

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()

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

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

if __name__ == "__main__":
    main()

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

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

resolve()

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

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

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

if T * VD >= D:
    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 - 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())

dist = abs(A-B)
if dist and (V-W)<=0:
    print("NO")
    exit()
if dist/(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 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 = list(map(int, input().split()))
b, w = list(map(int, input().split()))
t = int(input())

if b < a:
    a, b = b, a

p = a + v * t >= b + w * t
print(['NO', 'YES'][p])

Solution (Python):
import bisect, collections, copy, heapq, itertools, math, numpy, string
import sys
from bisect import bisect_left, bisect_right, insort
from collections import deque
def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def MS(): return map(str, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())



a, v= MI()
b,w = MI()
t =I()
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:
    d = abs(b-a)
else:
    d = abs(a-b)

ans = d - t*v +t*w
print("YES" if ans <= 0 else "NO")

Solution (Python):

a,v=map(int, input().split())

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

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

if w > v:
  print('NO')
  exit()

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

print('NO')

Solution (Python):

from sys import stdin
input = stdin.readline
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True 
BIG = 10**18
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

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

Solution (Python):
import sys
from pprint import pprint

A, V = map(int, sys.stdin.readline().strip().split())
B, W = map(int, sys.stdin.readline().strip().split())
T = int(sys.stdin.readline().strip())

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

d = abs(a - b)
s = v - w
if s <= 0:
    print("NO")
else:
    s = abs(s)
    if float(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 b > a:
    av = a + v * t
    bw = b + w * t
    
    if av >= bw:
        print("YES")
    else:
        print("NO")
else:
    av = a - v * t
    bw = b - w * t

    if av <= bw:
        print("YES")
    else:
        print("NO")

Solution (Python):
A,V = map(int,input().split())
B,W = map(int,input().split())
T = int(input())
if V-W<=0:
    print("NO")
else:
    t = abs(A-B)/(V-W)
    if T>=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
input = sys.stdin.readline


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


def solve(A, V, B, W, T):
    if A < B:
        a = A + V * T
        b = B + W * T
        return "YES" if a >= b else "NO"
    else:
        a = A - V * T
        b = B - W * T
        return "YES" if a <= b else "NO"


if __name__ == '__main__':
    inputs = read()
    print("%s" % solve(*inputs))

Solution (Python):
a0=input().split()
a1=int(a0[0])
v1=int(a0[1])
b0=input().split()
a2=int(b0[0])
v2=int(b0[1])

t=int(input())

if v2>=v1:
  print("NO")
else:
  shrink=v1-v2
  shr=shrink*t
  d=abs(a1-a2)
  if d>shr:
    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: 
    A += V*T
    B += W*T
    if A >= B:
        print("YES")
    else:
        print("NO")
else:
    A -= V*T
    B -= W*T
    if A <= B:
        print("YES")
    else:
        print("NO")

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]





A, V = mi()
B, W = mi()
t = ii()

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

Solution (Python):
def LI():return list(map(int,input().split()))
def yes():print("YES")
def no():print("NO")

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

if a<b:
    if a+v*t>=b+w*t:
        yes()
    else:
        no()
if a>b:
    if a-v*t<=b-w*t:
        yes()
    else:
        no()

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

Solution (Python):
from sys import stdin
def main():
    
    readline=stdin.readline
    a,v=map(int,readline().split())
    b,w=map(int,readline().split())
    t=int(readline())

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

if __name__=="__main__":
    main()

Solution (Python):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue
import numpy as np

Mod = 1000000007
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1] 
for i in range(2, 10**5 + 1):
    fact.append((fact[-1] * i) % Mod)
    inv.append((-inv[Mod % i] * (Mod // i)) % Mod)
    factinv.append((factinv[-1] * inv[-1]) % Mod)
    
def cmb(n, r, p):
    if (r < 0) or (n < r):
        return 0
    r = min(r, n - r)
    return fact[n] * factinv[r] * factinv[n - r] % p
    
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[y] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

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

Solution (Python):

import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**8)
INF = float("inf")
EPS = 1e-6


def yes():
    print("YES")  


def no():
    print("NO")  


def main():
    A, V = map(int, input().split())
    B, W = map(int, input().split())
    T = int(input())
    if V-W <= 0:
        no()
        return

    t = abs(A-B)/(V-W)
    if t <= T:
        yes()
    else:
        no()

    return


if __name__ == '__main__':
    main()

Solution (Python):
import sys
from math import factorial
from collections import Counter
from fractions import Fraction
import heapq, bisect, fractions
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
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()))
MOD = 10**9 + 7

a, v = MAP()
b, w = MAP()
t = INT()
if abs(b-a)+t*w - t*v <= 0:
    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)
max_dist = (V-W)*T

if max_dist >= distance:
    ans = "YES"
else:
    ans = "NO"

print(ans)

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

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

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

Solution (Python):
A,V,B,W,T=map(int, open(0).read().split())
if W==V:
    print("NO")
    exit()
ans=W<V
ans=ans and abs(A-B) <= (V-W)*T
print("YNEOS"[not ans::2])

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