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

dist_dif = abs(A - B)
v_dif = V - W

if v_dif * T >= dist_dif:
    print("YES")
else:
    print("NO")

Solution (Python):



def judge(a, v, b, w, t):
    return abs(b - a) <= t * (v - w)


def main():
    a, v = (int(z) for z in input().split())
    b, w = (int(z) for z in input().split())
    t = int(input())
    if judge(a, v, b, 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 or abs(A - B) / (V - W) > T:
    print("NO")
else:
    print("YES")

Solution (Python):
import sys

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  
def LS2(): return list(sys.stdin.readline().rstrip())  

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

if V > W and T*abs(V-W) >= 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)
V = v-w
if D <= t * V:
    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 'NO')

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

tmp = A - B if A > B else B - A 

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

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

la, ra = a - t * v, a + t * v + 1
lb, rb = b - t * w, b + t * w + 1


l, r = min(la, lb), max(ra, rb)
if l == la and r == ra:
    print("YES")
else:
    print("NO")

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

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

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

Solution (Python):
A,V=map(int,input().split())
B,W=map(int,input().split())
T=int(input())
if V<=W:
    print('NO')
    exit()
n=-(-abs(A-B)//(V-W))
if n<=T:
    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)

if W > V:
    print("NO")
elif (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())
if a == b:
  print('YES')
elif 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):
from sys import stdin, setrecursionlimit
input = stdin.buffer.readline
setrecursionlimit(10 ** 7)

from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
from collections import deque, defaultdict, Counter
from itertools import combinations, permutations, combinations_with_replacement
from itertools import accumulate
from math import ceil, sqrt, pi, radians, sin, cos

MOD = 10 ** 9 + 7
INF = 10 ** 18


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




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

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

Solution (Python):




import sys
from io import StringIO
import unittest

def yn(b):
    print("Yes" if b==1 else "No")
    return

def resolve():
    readline=sys.stdin.readline

    a,v=map(int, readline().rstrip().split())
    b,w=map(int, readline().rstrip().split())
    t=int(readline())
    if v <= w:
        print("NO")
        return
    s=v-w
    z=s*t

    if abs(a-b) <= z:
        print("YES")
    else:
        print("NO")

    return

if 'doTest' not in globals():
    resolve()
    sys.exit()

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

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

Solution (Python):
A, V = [int(i) for i in 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):
import sys
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7

def main():
    A, V = map(int, readline().split())
    B, W = map(int, readline().split())
    T = int(readline())
    if A>B:
        a = A - V*T
        b = B - W*T
        if a<=b:
            print('YES')
        else:
            print('NO')
    else:
        a = A + V*T
        b = B + W*T
        if a>=b:
            print('YES')
        else:
            print('NO')

if __name__ == '__main__':
    main()

Solution (Python):
def resolve():
    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")
resolve()

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=[int(x) for x in input().split()]
B,W=[int(x) for x in input().split()]
T=int(input())
X=abs(A-B)
Y=(V-W)

if Y*T>=X:
    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)
n = V-W
if dis <= n*T:
    print('YES')
else:
    print('NO')

Solution (Python):
import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter

from functools import lru_cache

sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9 + 7
eps = 10**-7


def inp():
    '''
    一つの整数
    '''
    return int(input())


def inpl():
    '''
    一行に複数の整数
    '''
    return list(map(int, input().split()))


def str_inp():
    '''
    文字列をリストとして読み込む
    '''
    return list(input()[:-1])


a, v = inpl()
b, w = inpl()
t = inp()

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

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

zahyousa = abs(B - A)
sokudo = V - W

if sokudo <= 0:
  print('NO')
elif zahyousa / sokudo <= T:
  print('YES')
else:
  print('NO')

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

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

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

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

Solution (Python):
def main():
    from builtins import int, map, list, print
    import sys
    sys.setrecursionlimit(10 ** 6)

    input = (lambda: (sys.stdin.readline()).rstrip())
    input_list = (lambda: input().split())
    input_number = (lambda: int(input()))
    input_number_list = (lambda: list(map(int, input_list())))

    A, V = input_number_list()  
    B, W = input_number_list()  
    T = input_number()  
    sd = abs(B - A)
    ss = V - W
    is_ng = False
    if ss <= 0:
        is_ng = True
    elif sd / ss > T:
        is_ng = True
    print(["YES", "NO"][is_ng])


if __name__ == '__main__':
    main()

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

a, v = get_ints()
b, w = get_ints()
t = int(input())
d = abs(a - b)
rest = d - (v - w) * t
print('YES' if rest <= 0 else '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")
if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
import math
from collections import deque
from collections import defaultdict
import itertools as it


def readInt():
	return int(input())
def readInts():
	return list(map(int, input().split()))
def readChar():
	return input()
def readChars():
	return input().split()
def factorization(n):
	res = []
	if n%2==0:
		res.append(2)
	for i in range(3,math.floor(n//2)+1,2):
		if n%i==0:
			c = 0
			for j in res:
				if i%j==0:
					c=1
			if c==0:
				res.append(i)
	return res
def fact2(n):
	p = factorization(n)
	res = []
	for i in p:
		c=0
		z=n
		while 1:
			if z%i==0:
				c+=1
				z/=i
			else:
				break
		res.append([i,c])
	return res
def fact(n):
	ans = 1
	m=n
	for _i in range(n-1):
		ans*=m
		m-=1
	return ans
def comb(n,r):
	if n<r:
		return 0
	l = min(r,n-r)
	m=n
	u=1
	for _i in range(l):
		u*=m
		m-=1
	return u//fact(l)
def combmod(n,r,mod):
	return (fact(n)/fact(n-r)*pow(fact(r),mod-2,mod))%mod
def printQueue(q):
	r=copyQueue(q)
	ans=[0]*r.qsize()
	for i in range(r.qsize()-1,-1,-1):
		ans[i] = r.get()
	print(ans)
class UnionFind():
	def __init__(self, n):
		self.n = n
		self.parents = [-1]*n

	def find(self, x): 
		if self.parents[x]<0:
			return x
		else:
			self.parents[x] = self.find(self.parents[x])
			return self.parents[x]

	def union(self,x,y):
		x = self.find(x)
		y = self.find(y)

		if x==y:
			return

		if self.parents[x]>self.parents[y]:
			x,y = y,x

		self.parents[x]+=self.parents[y]
		self.parents[y]=x

	def size(self,x):
		return -1*self.parents[self.find(x)]

	def same(self,x,y):
		return self.find(x)==self.find(y)

	def members(self,x): 
		root = self.find(x)
		return [i for i in range(self.n) if self.find(i)==root]

	def roots(self):
		return [i for i,x in enumerate(self.parents) if x<0]

	def group_count(self):
		return len(self.roots())

	def all_group_members(self):
		return {r: self.members(r) for r in self.roots()} 
def bitArr(n):
	x = 1
	zero = "0"*n
	ans = []
	ans.append([0]*n)
	for i in range(2**n-1):
		ans.append(list(map(lambda x:int(x),list((zero+bin(x)[2:])[-1*n:]))))
		x+=1
	return ans;
def arrsSum(a1,a2):
	for i in range(len(a1)):
		a1[i]+=a2[i]
	return a1
def maxValue(a,b,v):
	v2 = v
	for i in range(v2,-1,-1):
		for j in range(v2//a+1): 
			k = i-a*j
			if k%b==0:
				return i
	return -1
def copyQueue(q):
	nq = queue.Queue()
	n = q.qsize()
	for i in range(n):
		x = q.get()
		q.put(x)
		nq.put(x)
	return nq
def get_sieve_of_eratosthenes(n):
	
	data = [0,0,0]
	for i in range(3,n+1,2):
		data.append(i)
		data.append(0)
	for i in range(len(data)):
		interval = data[i]
		if interval!=0:
			for j in range(i+interval,n-1,interval):
				data[j] = 0
	
	ans = data[:]
	return ans

a,v = readInts()
b,w = readInts()
t = readInt()

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

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

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




'''
a=[]
b=[]
for i in range():
    A, B = map(int, input().split())
    a.append(A)
    b.append(B)'''

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):
def read_int():
    return int(input())


def read_ints():
    return map(int, input().split(' '))


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

Solution (Python):
def lcm(n,m):
    return n * m // gcd(n,m)

def gcd(n,m):
    while n:
        m,n = n,m%n
    return m

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

if V - W <= 0:
    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())
dis=abs(b-a)
if v<=w:
    print('NO')
elif dis/(v-w)>t:
    print('NO')
else:
    print('YES')

Solution (Python):
from collections import deque, Counter, defaultdict
from itertools import chain, combinations
import json

import bisect
import sys
import math
import bisect
from functools import lru_cache
import itertools

sys.setrecursionlimit(10 ** 8)

M = 10 ** 9 + 7
INF = 10 ** 17


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

    dd = abs(A - B)
    if V <= W:
        print('NO')
        return
    vv = V - W
    if vv * T >= dd:
        print('YES')
    else:
        print('NO')


if __name__ == "__main__":
    main()

Solution (Python):
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0

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

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

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

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

if __name__ == "__main__":
    main()

Solution (Python):
import sys
import math
import collections
import decimal
import itertools
from collections import deque
from functools import reduce
import heapq

a, v = map(int, sys.stdin.readline().split())


     

b, w = map(int, sys.stdin.readline().split())
t = int(input())


x = v - w
if x == 0:
    print("NO")
    sys.exit()
y = abs(b-a) / x

if y < 0:
    print("NO")
else:
    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())

dis= abs(a-b)
x=v-w
if dis <=t*x:
    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()
c=abs(a-b)/(v-w)
print('YES' if 0<=c and c<=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")
else:
    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 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 = abs(a-b)
s = v-w
if d > s*t:
    print("NO")
else:
    print("YES")

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

if d + (W-V)*T > 0:
    print("NO")
else:
    print("YES")

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

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

Solution (Python):
ax, va = [int(v) for v in input().split()]
bx, vb = [int(v) for v in input().split()]
t = int(input())

if vb >= va:
    print("NO")
else:
    vd = va - vb
    x = abs(ax - bx)
    if x <= vd * t:
        print("YES")
    else:
        print("NO")

Solution (Python):

import sys,io,os,time
from collections import defaultdict
from collections import OrderedDict
from collections import deque
from itertools import combinations
from itertools import permutations
import bisect,math,heapq
alphabet = "abcdefghijklmnopqrstuvwxyz"

input = sys.stdin.readline


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

Solution (Python):
from sys import exit
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if w >= v:
    print("NO")
    exit()

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

if W > V:
    print('NO')
    exit()

d = abs(B - A)
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())

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

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

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

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

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

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

diff = abs(b - a)

per = v - w

if per <= 0:
    print("NO")
    sys.exit()

if per * t >= diff:
    print("YES")
else:
    print("NO")

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

Solution (Python):
import sys
sys.setrecursionlimit(700000)

def s_in():
    return input()

def n_in():
    return int(input())

def l_in():
    return list(map(int, input().split()))
a,v=l_in()
b,w=l_in()
t=n_in()

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

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

Solution (Python):
pa, va = map(int, input().split())
pb, vb = map(int, input().split())
t = int(input())
if pa == pb:
    print("YES")
else:
    print("YES" if max(0, va - vb) * t >= abs(pb - pa) else "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 <= w:
  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())

dif = abs(b-a)
vel = v-w

if vel*t >= dif:
    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())
if A > B:
    A, B = B, A

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

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

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

d = V-W

if D - d*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 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())

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

print(ans)

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


def solve():
    A, V = map(int, rl().split())
    B, W = map(int, rl().split())
    T = int(rl())
    
    if V <= W:
        print('NO')
        return
    d = abs(A - B)
    if d / (V - W) <= T:
        print('YES')
    else:
        print('NO')


if __name__ == '__main__':
    solve()

Solution (Python):



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

a,v = mp()
b,w = mp()
t = int(input())
dif = abs(a-b)
u = v - w
if dif <= t*u:
    print("YES")
else:
    print("NO")

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

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

import sys

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

Amin = A-T*V
Amax = A+T*V
Bmin = B-T*W
Bmax = B+T*W

if Amin<=Bmin and Amax>=Bmax:
  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(A-B) else "NO")

Solution (Python):

MOD = 10 ** 9 + 7
INFI = 10**10

import math
from collections import deque
import itertools
import heapq

from fractions import Fraction
import copy
from functools import lru_cache
from collections import defaultdict
import pprint


def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default




def ret(a):
    c=[None]*(len(a)-1)
    if len(a)==1:
        return a[0]
    elif len(a)==0:
        return 0
    for i in range(1,len(a)):
        c[i-1]=abs(a[i]-a[i-1])
    return ret(c)

def soinsubunkai(n):
    a = []
    i = 1
    while i*i <= n:
        if n % i == 0 and i!=1:
            a.append(i)
            n=n//i

        if n% i !=0 or i==1:
            i += 1
    nokori=[n]
    return a + nokori

def main():
    a,v=map(int,input().split())
    b, w = map(int, input().split())
    t=int(input())
    dis=abs(a-b)
    vel=v-w
    ans="NO"
    if v-w>0:
        if vel*t>=dis:
            ans="YES"
    print(ans)





if __name__ == "__main__":

    main()

Solution (Python):

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

vv = v-w
dist = vv*t

if(abs(a-b)<=dist):
    print("YES")
else:
    print("NO")

Solution (Python):
import sys
sys.setrecursionlimit(10**7) 
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right

from collections import deque


from collections import Counter

from itertools import accumulate

from heapq import heapify,heappop,heappush


from functools import lru_cache


def input(): return sys.stdin.readline()[:-1]
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N,size=len(v),len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
    n,m=len(M),len(M[0])
    return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
    mod = 1000000007
    

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


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




if __name__ == "__main__":
    main()

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

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

if abs(a - b) / abs(w - 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 v<=w:
    print("NO")
    exit()

diff = abs(a-b)

if (v-w) * t >= diff:
    print("YES")
else:
    print("NO")