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
from collections import defaultdict, Counter, namedtuple, deque
import itertools
import functools
import bisect
import heapq

from fractions import gcd

MOD = 10 ** 9 + 7



a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if v <= w:
    print("NO")
    exit()

dis = t*(v-w)
if dis >= 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())

zzz = abs(a - b)
yyy = v - w

if yyy <= 0:
    print('NO')

elif zzz / yyy <= 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 or w>v:
    print("NO")
    quit()
if abs(a-b)/(v-w)>t:
    print("NO")
else:
    print("YES")

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

def main():
    sys.setrecursionlimit(10**7)
    INF = 10**18
    MOD = 10**9 + 7
    LI = lambda : [int(x) for x in sys.stdin.readline().split()]
    _LI = lambda : [-int(x) for x in sys.stdin.readline().split()]
    NI = lambda : int(sys.stdin.readline())
    SI = lambda : sys.stdin.readline().rstrip()
    DD = ((1,0),(0,1),(-1,0),(0,-1))

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

    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')
    else:
        print('YES')


if __name__ == '__main__':
    main()

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


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


def test():
    assert solve(1, 2, 3, 1, 3) == "YES"
    assert solve(1, 2, 3, 2, 3) == "NO"
    assert solve(1, 2, 3, 3, 3) == "NO"


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

Solution (Python):
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
k = abs(a-b)
n = v-w
if n <= 0:
  print("NO")
else:
  if n*t >= k:
    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)
U = V-W
if U < 0:
    print('NO')
elif U == 0 and l!=0:
    print('NO')
elif l == 0:
    print('YES')
elif l/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 v!=w:
    c=(max(a,b)-min(a,b))/(v-w)
else:
    c=-1

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7


Yes = 'Yes'
No = 'No'

def main():
    A,V=mis()
    B,W=mis()
    T=ii()

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



main()

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

kyori=abs(A-B)

oihaya=V-W

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

Solution (Python):
import sys


read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
s_readline = sys.stdin.readline


def solve():
    A, V = map(int, readline().split())
    B, W = map(int, readline().split())
    T = int(readline())

    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__':
    solve()

Solution (Python):
a,v=map(int, input().split())
b,w=map(int, input().split())
t=int(input())
sa=abs(a-b)
kyori=t*(v-w)
if sa==0:
    ans='YES'
else:
    if kyori>=sa:
        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)
sb = v - w
if sb <= 0:
    print("NO")
    exit()
time = dis / sb
if time > 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*=-1
    b*=-1
if a+v*t >= b+w*t:
    print('YES')
else:
    print('NO')

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

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

x = abs(a-b)
if v == w:
    print("NO")
    exit()
tt = x / (v-w)

if t >= tt and tt > 0:
    print("YES")
else:
    print("NO")

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

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

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

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

Solution (Python):



def ri():
    return int(input())

def rl():
    return list(input().split())

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

def main():
    a, v = rli()
    b, w = rli()
    t = ri()
    if t*(v-w) >= abs(a-b):
        print("YES")
    else:
        print("NO")



if __name__ == '__main__':
    main()

Solution (Python):
inf = 10**18
mod = 10**9+7

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

if (V - W) * T >= D:
    print('YES')
else:
    print('NO')

Solution (Python):
import sys 
from copy import deepcopy
from collections import deque
sys.setrecursionlimit(10**6)
def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LS(): return list(sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def R(x):
    r = round(x)
    if r+0.5 <= x:
        r += 1
    return r

def main():
    tmp = deque(LI())
    a,v = tmp.popleft(),tmp.popleft()
    tmp = deque(LI())
    b,w = tmp.popleft(),tmp.popleft()
    t = I()
    dist = abs(a-b)
    vect = v-w
    if vect<0:  
        print('NO')
    elif vect == 0 and dist==0:
        print('YES')
    else:
        if dist<=vect*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())
dist = abs(a - b)
if v <= w: 
    print('NO')
    exit()
ti = dist / (v - w)
if ti <= 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())

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

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

Solution (Python):
def main():
    A, V = map(int, input().split())
    B, W = map(int, input().split())
    T = int(input())
    if V > W:
        dis = abs(A-B)
        time = (dis+V-W-1)//(V-W) 
        if time <= T:
            print("YES") 
        else:
            print("NO")    
    else:
        print("NO")
if __name__ == "__main__":
    main()

Solution (Python):
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))
def getArray(intn):
    return [int(input()) for i in range(intn)]
def input():
    return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
    return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
    return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
  ns = []
  while len(ns) < rantime:
    n = random.randint(ran1, ran2)
    if not n in ns:
      ns.append(n)
  return sorted(ns)

def rand_query(ran1, ran2, rantime):
  r_query = []
  while len(r_query) < rantime:
    n_q = rand_ints_nodup(ran1, ran2, 2)
    if not n_q in r_query:
      r_query.append(n_q)
  return sorted(r_query)

from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import permutations
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right

import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7






A, V = getNM()
B, W = getNM()
T = getN()

dis = abs(A - B)

rang = (V - W) * T


if rang >= dis:
    print('YES')
else:
    print('NO')

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

d=abs(B-A)


if V<=W:
    print('NO')
    exit()
time=d/(V-W)
print('YES' if T>=time else 'NO')

Solution (Python):
import sys
import copy
from collections import deque
stdin = sys.stdin

mod = 10**9+7

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  

a, v = na()
b, w = na()
t = ni()

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

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

dist = abs(A - B)
if dist <= T * (V - W):
    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 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()) 
flag = 0

if A < B:
    a = V*T + A
    b = W*T + B
    if a >= b:
        flag = 1


else:
    a = A - V*T
    b = B - W*T
    if a <= b:
        flag = 1

if flag==1:
    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())

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

if v_r * T < D:
    print("NO")
else:
    print("YES")

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

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

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

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

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

if __name__ == "__main__":
    main()

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

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

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

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

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

Solution (Python):
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10**6)

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

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

if s * T < d:
  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)
run=abs(v-w)

if v>w and dist<=run*t:
    print("YES")
else:
    print("NO")

Solution (Python):
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
from itertools import accumulate
from itertools import permutations
from itertools import combinations
from collections import defaultdict
from collections import Counter
import fractions
import math
from collections import deque
from bisect import bisect_left
from bisect import insort_left
import itertools
from heapq import heapify
from heapq import heappop
from heapq import heappush
import heapq
from copy import deepcopy
from decimal import Decimal
alf = list("abcdefghijklmnopqrstuvwxyz")
ALF = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

INF = float("inf")


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

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

sa = abs(a - b)

chi = v - w

if chi <= 0:
    print('NO')
elif chi * t >= sa:
    print('YES')
else:
    print('NO')

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 9)

def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(input())
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print(k.join(list(map(str, lst))))
INF = float('inf')
from math import ceil, floor, log2






def solve():
    A, V = MI()
    B, W = MI()
    T = II()

    if A == B:
        print('YES')
        return

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

    if o <= 0:
        print('NO')
        return

    r = ceil(sa / o)
    if r <= T:
        print('YES')
    else:
        print('NO')


if __name__ == '__main__':
    solve()

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


if __name__ == '__main__':
    main()

Solution (Python):


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

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

Solution (Python):

import sys

stdin = sys.stdin
ns = lambda: stdin.readline().rstrip() 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))


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


if __name__ == '__main__':
    main()

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

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

L = abs(A-B)
rV = V - W

if L <= rV*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)

dv = V-W

if dv*T >= d:
  print("YES")
else:
  print("NO")

Solution (Python):
a, v = list(map(int,input().strip().split()))
b, w = list(map(int,input().strip().split()))
t = int(input())
ansa = a + v * t
ansb = b + w * t
ansa2 = a - v * t
ansb2 = b - w * t
if a < b:
    if ansb <= ansa:
        print("YES")
    else:
        print("NO")
else:
    if ansa2 <= ansb2:
        print("YES")
    else:
        print("NO")

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

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

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

dis = abs(b-a)
ss = v - w
if ss <= 0:
    print('NO')
    exit()
ti = dis // ss
if dis % ss != 0:
    ti += 1
if ti <= 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 y*t>=x:
    print('YES')
else:
    print('NO')

Solution (Python):
import numpy as np
import math
import collections


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

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

if(dis <= T * v):
    print("YES")
else:
    print("NO")

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

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

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

Solution (Python):



import sys

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    A, V = i2nn()
    B, W = i2nn()
    T = i2n()
    if T * W  + abs(A - B) <= T * V:
        print('YES')
    else:
        print('NO')
    return

main()

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

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

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

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

X = abs(A-B)
Y = abs(V-W)

if W>=V:
    print("NO")
elif X<=Y*T:
    print("YES")
else:
    print("NO")

Solution (Python):
from sys import stdin
from sys import setrecursionlimit

setrecursionlimit(10 ** 7)

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

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

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

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

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

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

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

if a == b:
	print("YES")
	exit()

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

speed = v-w

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

Solution (Python):
A, V = (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(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 v <= w:
  print("NO")
elif abs(b-a) > 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())
flg = True
r = v - w
y = abs(b - a)
if r < 0:
    flg = False

if t * r < y:
    flg = False

if flg:
    print("YES")
else:
    print("NO")

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

Solution (Python):


import sys


buff_readline = sys.stdin.readline
readline = sys.stdin.readline

INF = 2**62-1


def read_int():
    return int(buff_readline())


def read_int_n():
    return list(map(int, buff_readline().split()))


def read_float():
    return float(buff_readline())


def read_float_n():
    return list(map(float, buff_readline().split()))


def read_str():
    return readline().strip()


def read_str_n():
    return readline().strip().split()

def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(A, V, B, W, T):
    d = abs(A-B)
    vd = V-W
    if vd <= 0:
        return 'NO'

    from fractions import Fraction
    if Fraction(d, vd) <= T:
        return 'YES'

    return 'NO'



def main():
    A, V = read_int_n()
    B, W = read_int_n()
    T = read_int()
    print(slv(A, V, B, W, T))


if __name__ == '__main__':
    main()

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

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

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

if dV == 0:
  print("NO")
elif  dV < 0:
  print("NO")

elif d / dV  <=  T:
  print('YES')
else:
  print("NO")

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

b -= a
a = 0

if b < 0:
    b = -b

b += t*w
a += t*v

if b > a:
    print("NO")
else:
    print("YES")

Solution (Python):

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

if a>b:
    a_last = a-v*t
    b_last = b-w*t
else:
    a_last = a+v*t
    b_last = b+w*t

if (a-b)*(a_last-b_last)<=0:
    print("YES")
else:
    print("NO")

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

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

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

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

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

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

Solution (Python):
def mi():
    return map(int, input().split())

def main():
    A, V = mi()
    B, W = mi()
    T = int(input())
    if 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())
print(['NO','YES'][V>W and (abs(A-B)+V-W-1)//(V-W)<=T])

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=list(map(int,input().split()))
b=list(map(int,input().split()))
t=int(input())
l=abs(a[0]-b[0])
s=a[1]-b[1]
if t*s>=l:
  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 (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:
    print('NO')
elif (V-W)*T>=abs(A-B):
    print('YES')
else:
    print('NO')

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd, floor
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
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(float, input().split())
def LIST(): return list(map(float, 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 V <= W:
	print("NO")
	exit()

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