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,bisect,string,math,time,functools,random,fractions
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
rep=range
def Golf():n,*t=map(int,open(0).read().split())
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def MI():return map(int,input().split())
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def RA():return map(int,open(0).read().split())
def GI(V,E,ls=None,Directed=False,index=1):
    org_inp=[];g=[[] for i in range(V)]
    FromStdin=True if ls==None else False
    for i in range(E):
        if FromStdin:
            inp=LI()
            org_inp.append(inp)
        else:
            inp=ls[i]
        if len(inp)==2:
            a,b=inp;c=1
        else:
            a,b,c=inp
        if index==1:a-=1;b-=1
        aa=(a,c);bb=(b,c);g[a].append(bb)
        if not Directed:g[b].append(aa)
    return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'
    
    mp=[boundary]*(w+2);found={}
    for i in range(h):
        s=input()
        for char in search:
            if char in s:
                found[char]=((i+1)*(w+2)+s.index(char)+1)
                mp_def[char]=mp_def[replacement_of_found]
        mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
    mp+=[boundary]*(w+2)
    return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def accum(ls):
    rt=[0]
    for i in ls:rt+=[rt[-1]+i]
    return rt
def bit_combination(n,base=2):
    rt=[]
    for tb in range(base**n):s=[tb//(base**bt)%base for bt in range(n)];rt+=[s]
    return rt
def gcd(x,y):
    if y==0:return x
    if x%y==0:return y
    while x%y!=0:x,y=y,x%y
    return y
def show(*inp,end='\n'):
    if show_flg:print(*inp,end=end)
 
YN=['YES','NO'];Yn=['Yes','No']
mo=10**9+7
inf=float('inf')
FourNb=[(-1,0),(1,0),(0,1),(0,-1)];EightNb=[(-1,0),(1,0),(0,1),(0,-1),(1,1),(-1,-1),(1,-1),(-1,1)];compas=dict(zip('WENS',FourNb));cursol=dict(zip('LRUD',FourNb))
l_alp=string.ascii_lowercase

read=sys.stdin.buffer.read
readline=sys.stdin.buffer.readline
input=lambda: sys.stdin.readline().rstrip()

class Tree:
    def __init__(self,inp_size=None,ls=None,init=True,index=1):
        self.LCA_init_stat=False
        self.ETtable=[]
        if init:
            if ls==None:
                self.stdin(inp_size,index=index)
            else:
                self.size=len(ls)+1
                self.edges,_=GI(self.size,self.size-1,ls,index=index)
        return
 
    def stdin(self,inp_size=None,index=1):
        if inp_size==None:
            self.size=int(input())
        else:
            self.size=inp_size
        self.edges,_=GI(self.size,self.size-1,index=index)
        return
    
    def listin(self,ls,index=0):
        self.size=len(ls)+1
        self.edges,_=GI(self.size,self.size-1,ls,index=index)
        return
 
    def dfs(self,x,func=lambda pr,prv,nx,dist:prv+dist,root_v=0):
        q=deque([x])
        v=[None]*self.size
        v[x]=root_v
        while q:
            c=q.pop()
            for nb,d in self.edges[c]:
                if v[nb]==None:
                    q.append(nb)
                    v[nb]=func(c,v[c],nb,d)
        return v
 
    def bfs(self,x,func=lambda pr,prv,nx,dist:prv+dist,root_v=0):
        q=deque([x])
        v=[None]*self.size
        v[x]=root_v
        while q:
            c=q.popleft()
            for nb,d in self.edges[c]:
                if v[nb]==None:
                    q.append(nb)
                    v[nb]=func(c,v[c],nb,d)
        return v
 
    def parent(self,x):
        return self.dfs(0,func=lambda pr,prv,nx,dist:pr,root_v=-1)
 
    def topological_sort(self,x):  
        tps=[]
        q=deque([x])
        v=[None]*self.size
        v[x]=0
        while q:
            c=q.popleft()
            tps.append(c)
            for nb,d in self.edges[c]:
                if v[nb]==None:
                    q.append(nb)
                    v[nb]=0
        return tps
 
    def EulerTour(self,x):
        q=deque()
        q.append(x)
        self.depth=[None]*self.size
        self.depth[x]=0
        self.ETtable=[]
        self.ETdepth=[]
        self.ETin=[-1]*self.size
        self.ETout=[-1]*self.size
        cnt=0
        while q:
            c=q.pop()
            if c<0:
                ce=~c
            else:
                ce=c
                for nb,d in self.edges[ce]:
                    if self.depth[nb]==None:
                        q.append(~ce)
                        q.append(nb)
                        self.depth[nb]=self.depth[ce]+1
            self.ETtable.append(ce)
            self.ETdepth.append(self.depth[ce])
            if self.ETin[ce]==-1:
                self.ETin[ce]=cnt
            else:
                self.ETout[ce]=cnt
            cnt+=1
        return
    
    def LCA_init(self,root):
        self.EulerTour(root)
        self.st=SparseTable(self.ETdepth,init_func=min,init_idl=inf)
        
        self.LCA_init_stat=True
        return
    
    def LCA(self,root,x,y):
        if self.LCA_init_stat==False:
            self.LCA_init(root)
        xin,xout=self.ETin[x],self.ETout[x]
        yin,yout=self.ETin[y],self.ETout[y]
        a=min(xin,yin)
        b=max(xout,yout,xin,yin)
        id_of_min_dep_in_et=self.st.query_id(a,b+1)
        return self.ETtable[id_of_min_dep_in_et]
 
    def __str__(self):
        return  str(self.edges)
 
    def show(self):
        if all([all([d==1 for nd,d in edge]) for edge in self.edges]):
            print( [[nd for nd,d in edge] for edge in self.edges] )
        else:
            print(self)
 
class SparseTable: 
    def __init__(self,ls,init_func=min,init_idl=float('inf')):
        self.func=init_func
        self.idl=init_idl
        self.size=len(ls)
        self.N0=self.size.bit_length()
        self.table=[ls[:]]
        self.index=[list(range(self.size))]
        self.lg=[0]*(self.size+1)
        
        for i in range(2,self.size+1):
            self.lg[i]=self.lg[i>>1]+1
 
        for i in range(self.N0):
            tmp=[self.func(self.table[i][j],self.table[i][min(j+(1<<i),self.size-1)]) for j in range(self.size)]
            tmp_id=[self.index[i][j] if self.table[i][j]==self.func(self.table[i][j],self.table[i][min(j+(1<<i),self.size-1)]) else self.index[i][min(j+(1<<i),self.size-1)] for j in range(self.size)]
            self.table+=[tmp]
            self.index+=[tmp_id]
    
    
    def query(self,l,r):
        if r>self.size:r=self.size
        
        N=self.lg[r-l]
        return self.func(self.table[N][l],self.table[N][max(0,r-(1<<N))])
    
    
    def query_id(self,l,r):
        if r>self.size:r=self.size
        
        N=self.lg[r-l]
        a,b=self.index[N][l],self.index[N][max(0,r-(1<<N))]
        if self.table[0][a]==self.func(self.table[N][l],self.table[N][max(0,r-(1<<N))]):
            b=a
        return b
    
    
    def right_bound(self,pos,x):
        k=(self.size-pos).bit_length()
        for j in range(k)[::-1]:
            nx=pos+(1<<j)
            if nx<n and self.query(pos,nx+1)<=x:
                pos+=(1<<j)
        return pos
    
    
    def left_bound(self,pos,x):
        k=pos.bit_length()
        for j in range(k)[::-1]:
            nx=pos-(1<<j)
            if 0<=nx and self.query(nx,pos+1)<=x:
                pos-=(1<<j)
        return pos
 
    def __str__(self):
        return str(self.table[0])
 
    def print(self):
        for i in self.table:
            print(*i)
 
show_flg=False
show_flg=True
ans=0


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

if (v-w)*t>=abs(b-a) and v>w:
    ans=0
else:
    ans=1
    

print(YN[ans])

Solution (Python):


import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7

a,v=MI()
b,w=MI()
t=I()
l=abs(b-a)
vel=v-w
if t*(vel)>=l:
    print("YES")
else:
    print("NO")

Solution (Python):


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

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

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

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

catch = (V - W) * T

if catch >= 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())

R = abs(A - B)
R2 = (V - W) * T

if R2 >= R:
  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)
x = v-w
if t*x >= dist:
    ans = "YES"
else:
    ans = "NO"
print(ans)

Solution (Python):

import bisect
import collections
import sys

sys.setrecursionlimit(1000000)
ACMOD = 1000000007
INF = 1 << 62

YES = "YES"  
NO = "NO"  


def solve(A: int, V: int, B: int, W: int, T: int):
    oni = - abs(B - A)
    kodomo = 0
    if W * T <= V * T + oni:
        print(YES)
    else:
        print(NO)

    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word

    tokens = iterate_tokens()
    A = int(next(tokens))  
    V = int(next(tokens))  
    B = int(next(tokens))  
    W = int(next(tokens))  
    T = int(next(tokens))  
    solve(A, V, B, W, T)


if __name__ == '__main__':
    main()

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

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

if diff <= 0:
    print('NO')
else:
    if diff * t >= length:
        print('YES')
    else:
        print('NO')

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


def main():
    A, V = [int(x) for x in input().split()]
    B, W = [int(x) for x in input().split()]
    T = int(input())


    diff = abs(A - B)

    if W > V:
        print("NO")
    else:
        if V == W:
            print("NO")
        elif diff / (V - W) <= T:
            print("YES")
        else:
            print("NO")


if __name__ == '__main__':
    main()

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

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

Solution (Python):
import bisect
import copy
import heapq
import math
import sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
sys.setrecursionlimit(500000)
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]

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(_n) for _n in input().split()]
B,W = [int(_n) for _n in input().split()]
T = int(input())
A, B = min(A,B), max(A,B)
print("YES" if B + W * T <= A + V * T else "NO")

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

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

Solution (Python):
A, V = 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):
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


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):
import sys
input=sys.stdin.readline
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
x=abs(a-b)
if v<=w:
    print('NO')
else:
    if (v-w)*t>=x:
        print('YES')
    else:
        print('NO')

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

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

Solution (Python):
import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import random
import re
import string
import sys
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from functools import lru_cache, reduce
from math import gcd
from operator import add, itemgetter, mul, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7



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

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

Solution (Python):
A, V = list(map(int,input().split()))
B, W = list(map(int,input().split()))
N = int(input())
dis = abs(B - A)
if W >= V:
    print("NO")
else:
    dx = V - W
    if dis <= N * (V - W):
        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, radians
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

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

t = abs(A-B)/(V-W)

print("YES" if t <= T else "NO")

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

dist = abs(b-a)

if w >= v:
    print('NO')
else:
    speed = v - w
    if dist / speed <= t:
        print('YES')
    else:
        print('NO')

Solution (Python):



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

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

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

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

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

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

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

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

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

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

Solution (Python):
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))

from collections import defaultdict, deque
from sys import exit
import math
import copy
from bisect import bisect_left, bisect_right
from heapq import *
import sys

INF = 10 ** 17
MOD = 1000000007

from fractions import *
def inverse(f):
    
    return 1/f

def solve():
    a, v = getList()
    b, w = getList()
    t = getN()
    if w >= v:
        print("NO")
    else:
        if abs(a - b) <= t * (v - w):
            print("YES")
        else:
            print("NO")

def main():
    
    
    solve()
if __name__ == "__main__":
    solve()

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

if w >= v or abs(a - b) > t * abs(v - w):
  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)
n = V-W
if n <= 0:
    print('NO')
    exit()
print('YES' if n*T >= d else 'NO')

Solution (Python):
nii=lambda:map(int,input().split())
lnii=lambda:list(map(int,input().split()))

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

dist=abs(b-a)

x1=v*t
x2=w*t

print('YES' if v*t>=w*t+dist else 'NO')

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

print(ans)

Solution (Python):
import sys

input = sys.stdin.readline


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

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

    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
def examA():
    S = SI()
    ans = S[:3]
    print(ans)
    return

def examB():
    A, V = LI()
    B, W = LI()
    T = I()
    L = abs(A-B)
    v = V-W
    if v*T>=L:
        ans = "YES"
    else:
        ans = "NO"
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

def test():
    i = I()
    li = LI()
    lsi = LSI()
    si = LS()
    print(i)
    print(li)
    print(lsi)
    print(si)
    return

from decimal import Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(input())
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examB()

"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""

Solution (Python):

 
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

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

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


main()

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

diff = abs(A - B)

if diff <= 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)
diff = v - w
if diff * t >= dist:
    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) <= (V - W) * T:
        print("YES")
    else:
        print("NO")


if __name__ == "__main__":
    main()

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

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

Solution (Python):
a, v = list(map(int, input().split()))
b, w = list(map(int, input().split()))
t = int(input())
ans = "NO"
if a > b:
    if a - v * t <= b - w * t:
        ans = "YES"
if a < b:    
    if a + v * t >= b + w * t:
        ans = "YES"
print(ans)

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

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

l = abs(a-b)
sok = v-w

if l-sok*t <= 0:
    print("YES")
else:
    print("NO")

Solution (Python):
a,v=[int(j)for j in input().split()]
b,w=[int(j)for j in input().split()]
t=int(input())
p=abs(a-b)
if v-w<0:
    print("NO")
else:
    if t*(v-w)>=p:
        print("YES")
    else:
        print("NO")

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

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

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

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

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

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

if speed*t >= dist:
    print('YES')
else:
    print('NO')

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10, gcd
from itertools import permutations, combinations, product, accumulate, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

from decimal import *
def debug(*args):
    if debugmode:
        print(*args)
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 1, 0, -1, 1, -1, -1, 1]
dy = [1, 0, -1, 0, 1, -1, 1, -1]
debugmode = True

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

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

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

Solution (Python):
def main():
    from sys import setrecursionlimit, stdin, stderr
    from os import environ
    from collections import defaultdict, deque, Counter
    from math import ceil, floor
    from itertools import accumulate, combinations, combinations_with_replacement
    setrecursionlimit(10**6)
    dbg = (lambda *something: stderr.write("\033[92m{}\033[0m".format(str(something)+'\n'))) if 'TERM_PROGRAM' in environ else lambda *x: 0
    input = lambda: stdin.readline().rstrip()
    LMIIS = lambda: list(map(int,input().split()))
    II = lambda: int(input())
    P = 10**9+7
    INF = 10**18+10

    A,V = LMIIS()
    B,W = LMIIS()
    T = II()

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

Solution (Python):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))

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

Solution (Python):
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15

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('YES')
    else:
        print('NO')
if __name__ == '__main__':
    main()

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

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



from collections import Counter,defaultdict,deque
from itertools import permutations, combinations, combinations_with_replacement
from heapq import heappop, heappush, heapify
from fractions import gcd

sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

def main():
    a,v = inpm()
    b,w = inpm()
    t = inp()
    if w >= v:
        print('NO')
        return
    if abs(a-b)/(v-w) <= t:
        print('YES')
        return
    print('NO')

    
if __name__ == "__main__":
    main()

Solution (Python):
import sys

a, v, b, w, t = map(int, sys.stdin.buffer.read().split())
d = abs(a - b)

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