peterverebics/CodeNet_Python_118 huggingface dataset:
from sys import stdin,stdout
import bisect as bs
n,m,s=map(int, stdin.readline().split())
dn=list(map(int, stdin.readline().split()))
dm=list(map(int, stdin.readline().split()))
pre=[dm[0]];s1=0
for v in dm[1:]:
    pre+=[dm[-1]+v]
m=bs.bisect_right(pre,s)
for i in range(n):
    s1+=dn[i]
    if s-s1>0:m=max(m,i+1+bs.bisect_right(pre,s-s1))
print(m)
N,M,K=map(int,input().split())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
count=sum(B)
a=0
ai = 0
p=0
for i in range(N):
    print('s1:',count,ai,M)
    while count>K:
        count-=B[M-1]
        M-=1
    print('s2:',count,ai,M)
    count+=A[i]
    a+=A[i]
    ai+=1
    print('s3:',count,ai,M)
    if count <= K:
        p=max(p,ai+M)
    print('s4',count,p,ai,M)
    if a>K:
        break
print(p)
from bisect import bisect_right

def cumsum(a):
    res = []
    res.append(a[0])
    for i in range(1, len(a)):
        res.append(res[i - 1] + a[i])
    return res

n, m, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ca = cumsum(a)
cb = cumsum(b)

ans = 0
x = bisect_right(ca, k)
for i in range(x):
    y = bisect_right(cb, k - ca[i])
    ans = max(ans, x + y)

print(ans)
n, m, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))

# print(a)
# print(b)
number = []
for i in range(1, len(a)+1):
    for j in range(1, len(b)+1):
        if k >= sum(a[:i]) + sum(b[:j]):
            number.append(i+j)
        else:
            break
if number == []:
    print(0)
else:
    print(max(number))
n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
count = 0
ai = 0
bi = 0
while True:
  if (len(a) != ai and len(b) != bi and a[ai] <= b[bi]) or (len(a) != ai and len(b) == bi):
    k -= a[ai]
    ai += 1
  elif (len(a) != ai and len(b) != bi and a[ai] > b[bi]) or (len(a) == ai and len(b) != bi):
    k -= b[bi]
    bi += 1
  else:
    break
  if k < 0:
    break
  count += 1
print(count)
n, m, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = sorted(a+b)
ans = 0
tmp = 0
for i in c:
  tmp += i
  if(tmp > k):print(ans);exit()
  ans+=1
else:print(ans)
n, m, k = map(int, input().split())
a = list(map(int, input().split()))+[float('inf')]
b = list(map(int, input().split()))+[float('inf')]
ans = 0
i, j = 0, 0
while ans <= k:
    if a[i] <= b[j]:
        ans += a[i]
        i += 1
    else:
        ans += b[j]
        j += 1
if ans == float('inf'):
    print(len(a)+len(b)-2)
else:
    print(i+j-1)
from itertools import accumulate

n, m, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = 0

a_accum = list(accumulate(a))
b_accum = list(accumulate(b))

for j in range(len(a_accum)):
  for i in range(len(b_accum)):
    t = a_accum[-(j+1)] + b_accum[-(i+1)]
    candi = (n-j) + (m-i)
    if ans >= candi:
      break
    if t <= k:
      ans = candi
      break

print(ans)
N, M, K = map(int, input().split())
*A, = map(int, input().split())
*B, = map(int, input().split())
AB = A + B
AB.sort()
ans = 0
for ab in AB:
    if K - ab > 0:
        K = K - ab
        ans += 1
    else:
        break
print(ans)
N,M,K=map(int,input().split())
A=[]
B=[]
A=list(map(int,input().split()))
B=list(map(int,input().split()))

for i in range(len(B)):
    A.append(B[i])

A.sort
goukei=0
if(K<A[0]):
    print(0)
    exit()
for i in range(len(A)):
    goukei=goukei+A[i]
    if(K<goukei):
        print(i+1)
        exit()


print(N+M)
an,bm,khun = map(int,input().split())
alist = list(map(int,input().split()))
blist = list(map(int,input().split()))
count = 0
alist.append(khun+1)
blist.append(khun+1)
alist.reverse()
blist.reverse()
for i in range(an+bm):
    if alist[-1]<=blist[-1] and khun >=alist[-1]:
        khun -= alist[-1]
        count += 1
        alist.pop(-1)
    elif khun >= blist[-1]:
        khun -= blist[-1]
        count += 1
        blist.pop(-1)
    else:
        break;
print(count)
a,b,c = map(int,input().split())
z = list(map(int,input().split()))
x = list(map(int,input().split()))
if c>=sum(z)+ sum(x):
	print(a+b)
else:
	i,j,q,r=0,0,0,0
	while q<=c and i+j<=(a+b):
		if i<=(a-1) and j<=(b-1):
			if z[i]<=x[j]:
				q+=z[i]
				i+=1
			else:
				q+=x[j]
				j+=1
		else:
			if j==b:
				q+=z[i]
				i+=1
			if i==a:
				q+=x[j]
				j+=1
		r+=1
	print(r-1)
import sys

n,m,k=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
count=sum(b)
i=0
j=m
ls=[]
if sum(a)==k:
  print(n)
  sys.exit()

while (i<n and j>0):
  if count>=k:
    j-=1
    count-=b[j]
    
  elif count<k:
    count+=a[i]
    i+=1
    if count<=k:
      ls.append(i+j)
    
print(max(ls) if len(ls)>0 else 0)
import bisect
from itertools import accumulate
n,m,k=map(int,input().split())
a=list(accumulate([0] + list(map(int,input().split()))))
b=list(accumulate([0] + list(map(int,input().split()))))
ans=0
for i,x in enumerate(a):
    y=k-x
    if y>0:
        j=bisect.bisect_right(b,y)
        ans=max(ans,i+j-1)
print(ans)
n,m,k = map(int,input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
A = [0]
B = [0]

for i in range(len(a)):
  A.append(a[i] + A[i])
for i in range(len(b)):
  B.append(b[i] + B[i])

loop = False
num = 0
x = m 

for i in range(1,len(A)):
  while A[i] + B[x] > k and x > 0 and A[i] <= k:
    x -= 1
    loop = True
    
  if loop:
    num = max(num, i + x)


print(num)
import sys
import math 
from collections import deque

n,m,k=map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))

a=[0]
b=[0]

for i in range(n):
    a.append(A[i]+a[i])
for i in range(m):
    b.append(B[i]+b[i])

ans,j=0,m

for i in range(n):
    if a[i] > k :
        break
    while b[j] > k-a[i] : 
        j-=1
    ans = max(ans, i+j)

print(ans)
N,M,K = map(int,input().split(" "))
#print(K)
A = list(map(int,input().split(" ")))
B = list(map(int,input().split(" ")))

time_A = [0]*(N+1)
time_B = [0]*(M+1)

for i in range(N):
    time_A[i+1] = time_A[i] + A[i]
print(time_A)
for j in range(M):
    time_B[j+1] = time_B[j] + B[j]

ans = 0
l = M

for k in range(N+1):
    if time_A[k] > K:
        break
    while time_A[k] + time_B[l] > K:
        l -= 1
    ans = max(ans,k+l)

print(ans)
N,M,K = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
A.append(10**9+10)
B.append(10**9+10)

i_a = 0
i_b = 0
ans = 0
while 1:
    if K < A[i_a] and K < B[i_b]:
        break
    if A[i_a] < B[i_b]:
        K -=A[i_a]
        i_a += 1
    else:
        K -= B[i_b]
        i_b += 1
    ans += 1

print(ans)
import itertools
import bisect

n, m, k = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))

cA = list(itertools.accumulate(A))
cB = list(itertools.accumulate(B))

#print(cA)
#print(cB)

ans = 0
for i in range(n):
    tmp = cA[-(i+1)]
    if tmp < k:
        indb = bisect.bisect_right(cB, k - tmp)
        #print(indb)
        ans = max(ans, (n-i)+indb)
    
print(ans)
[A,V] = list(map(int,input().split()))
[B,W] = list(map(int,input().split()))
T = int(input())

if A<B:
    if A+V*T >= B+W*T:
        out='YES'
    else:
        out='NO'

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

if A == B or V-W > 0 and abs(A-B) <= T*(V-W):
    print('YES')
else:
    print('NO')
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())
# if (v-w)*t>=(b-a):print("YES")
# else:print("NO")
q = abs(a-b)
e = (v-w)*t
if q<=e:
	print("YES")
else:
	print("NO")
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())

if a > b:
    aa = a - t * v
    bb = b - t * w
    if aa > bb:
        print('NO')
    else:
        print('YES')
elif a < b:
    aa = a + t * v
    bb = b + t * w
    if aa < bb:
        print('NO')
    else:
        print('YES')
else:
    print('YES')
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
if a<b:
    a+=v*t
    b+=w*t
    if a<b:
        print("NO")
    else:
        print("YES")
else:
    a-=v*t
    b-=w*t
    if a>b:
        print("NO")
    else:
        print("YES")
A=list(map(int,input().split()))
B=list(map(int,input().split()))
T=int(input()) 

if abs(A[0]-B[0])+B[1]*T>A[1]*T:
       print("NO")
else:
       print("YES")
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
ans = ["YES","NO"]

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

result = distance - speed * t
if result <= 0:
    print(ans[0])
elif result > 0:
    print(ans[1])
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:
        r = (B+ W*T) - (A + V*T)
        if r <= 0:
            print("YES")
        else:
            print("NO")
    else:
        r =   (B- W*T)-(A - V*T)
        if r >= 0:
            print("YES")
        else:
            print("NO")

if __name__ == '__main__':
    main()
a,v = map(int, input().split())
b,w = map(int, input().split())
t = int(input())

if a < b:
    b1 = w*t + b
    a1 = v*t + a
    if a1 >= b1:
        flag = 1
    else:
        flag = 0
elif a > b:
    b1 = -w*t + b
    a1 = -v*t + a
    if a1 <= b1:
        flag = 1
    else:
        flag = 0
if flag == 0:
    print("NO")
else:
    print("YES")
A, V = list(map(int, input().split()))
B, W = list(map(int, input().split()))
T = int(input())

if V > W and T >= (abs(A - B) / abs(V - W)):
    print('YES')
else:
    print('NO')
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")
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)
numsA = [int(e) for e in input().split()]
numsB = [int(e) for e in input().split()]
T = int(input())
if abs(numsA[0]-numsB[0])<=(numsA[1]-numsB[1])*T:
    print("YES")
else:
    print("NO")
A,V = map(int,input().split())
B,W = map(int,input().split())
T=int(input())

place_A=A+(T*V)
place_B=B+(T*W)

place_A_1=A-(T*V)
place_B_1=B-(T*W)

if A<B:
    if place_A>=place_B:
        print("YES")

    else:
        print("NO")

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

if a == b:
  print("YES")
elif a < b:
  a_new = a + v * t
  b_new = b + w * t
  if a_new >= b_new:
    print("YES")
  else:
    print("NO")
else:
  a_new = a - v * t
  b_new = b - w * t
  if a_new <= b_new:
    print("YES")
  else:
    print("NO")
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:
  if (dis / (V - W)) <= T:
    print('YES')
  else:
    print('NO')
a, v1 = map(int, input().split())
b, v2 = map(int, input().split())
t = int(input())
l = abs(a-b)
delta_v = v1-v2
if delta_v <= 0:
  print("NO")
  exit()

if delta_v * t >= l:
  print("YES")
else:
  print("NO")
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

S = V - W
print('NO' if S <= 0 or abs(A - B) > T * S else 'YES')
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())


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

if v <= w:
    if a != b:
        print('NO')
    else:
        print('YES')
else:
    if abs(a - b) <= abs(v - w) * t:
        print('YES')
    else:
        print('NO')
(A, V) = map(lambda a: float(a), input().split())
(B, W) = map(lambda a: float(a), input().split())
T = float(input())

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

if (X*T >= D):
  print("YES")
else:
  print("NO")
a, v = list(map(int, input().split(' ')))
b, w = list(map(int, input().split(' ')))
t = int(input())

distance = b - a
relative_velocity = w - v
if relative_velocity > 0:
    print('NO')
else:
    if (abs(relative_velocity)*t >= abs(distance)):
        print('YES')
    else:
        print('NO')
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
if v-w <= 0:
    print('NO')
    exit()
ans=abs(a-b)/(v-w)
if ans <= t:
    print('YES')
else:
    print('NO')
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

dist = abs(B-A)
spd = V-W
ans = "YES"

if spd*T < dist:
    ans = "NO"

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



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


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

else:
    A_sum = A - (V * T)
    B_sum = B - (W * T)
    if A_sum <= B_sum:
        print('YES')
    else:
        print('NO')
a,asp=map(int, input().split(" "))
b,bsp=map(int, input().split(" "))
t=(int)(input())
if asp > bsp:
  print("YES") if abs(b-a)/(asp-bsp) <= t else print("NO")
else:
  print("NO")
a, v = list(map(int, input().strip().split()))
b, w = list(map(int, input().strip().split()))
t = int(input())

if a == b: print("YES")
else:
    if w >= v: print("NO")
    else:
        tt = abs(a-b)/(v-w)
        
        if tt <= t: print("YES")
        else: print("NO")
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

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

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

  dis = abs(a - b)
  s = v - w
  dis -= s * t

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


main()
a,v = map(int, input().split())
b,w = map(int, input().split())
t = int(input())
if a<b:
    new_a = a + v*t
    new_b = b + w*t
    if new_a >= new_b:
        print("YES")
    elif new_a < new_b:
        print("NO")
elif a>b:
    new_a = a - v*t
    new_b = b - w*t
    if new_a <= new_b:
        print("YES")
    elif new_a > new_b: 
        print("NO")
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')
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

if V <= W:
    # 追いつけない
    print("NO")
else:
    dx = abs(A - B)
    dv = V - W
    t = dx / dv
    if t <= T:
        print("YES")
    else:
        print("NO")
a,v = map(int, input().split())
b,w = map(int, input().split())
t = int(input())

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


if __name__ == "__main__":
    main()
B,W = map(int,input().split())
A,V = map(int,input().split())
T = int(input())
if A < B:
    if A-V*T >= B-W*T:
        print('YES')
    else:
        print('NO')
elif A > B:
    if A+V*T <= B+W*T:
        print('YES')
    else:
        print('NO')
import sys
input = lambda: sys.stdin.readline().rstrip()

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

if __name__ == '__main__':
    main()
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if v*t + a >= w*t + b and a < b:
    print("YES")
elif -v*t + a <= -w*t + b and a > b:
    print("YES")
else:
    print("NO")
a, v = map(int, input().strip().split())
b, w = map(int, input().strip().split())
t = int(input().strip())

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

if (v - w) * t - abs(b - a) >= 0:
  print("YES")
else:
  print("NO")
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

L = abs(A-B)
S = V - W
if S * T >= L:
    print("YES")
else:
    print("NO")
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
dist = abs(A - B)
velocity = V - W
if velocity * T >= dist:
    print('YES')
else:
    print('NO')
A, V = list(map(int, input().split()))
B, W = list(map(int, input().split()))
T = int(input())


if V*T >= W*T+abs(B-A):
    print("YES")
else:
    print("NO")
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')
if A>B:
    if A-T*V<= B-T*W:
        print('YES')
    else:
        print('NO')
from sys import stdin
import math
import re
import queue

input = stdin.readline

MOD = 1000000007
INF = 122337203685477580


def solve():

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

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

max_A = A + V*T
min_A = A - V*T
max_B = B + W*T
min_B = B - W*T

if max_A >= max_B and min_A <= min_B:
    print("YES")
else:
    print("NO")
a,v = map(lambda x: int(x), input().split())
b,w = map(lambda x: int(x), input().split())
t = int(input())
if a == b or abs(a-b) <= (v-w)*t: print("YES")
else: print("NO")
x,y = input().split()
q,w = input().split()
a =int(x)
b=int(y)
c= int(q)
d =int(w)
e =int(input())

if c-a >0:
  if c-a <=e*(b-d):
    print('YES')
   
  else:
    print('NO')
    
else:
  if a-c<=e*(b-d):
    print('YES')
   
  else:
    print('NO')
a, v = (int(i) for i in input().split(' '))
b, w = (int(i) for i in input().split(' '))
t = int(input())

flag = False
if a < b:
    l1 = a + v * t
    l2 = b + w * t
    if l1 >= l2:
        flag = True
else:
    l1 = a + (v * -1) * t
    l2 = b + (w * -1) * t
    if l1 <= l2:
        flag = True
print("YES" if flag else "NO")
A,V = map(int,input().split())
B,W = map(int,input().split())
T = int(input())
v = V - W
sa = abs(A-B)
if v <= 0:
    print("NO")
else:
    if sa / v <= T:
        print("YES")
    else:
        print("NO")
input_a = input().split()
a = int(input_a[0])
v = int(input_a[1])
input_b = input().split()
b = int(input_b[0])
w = int(input_b[1])
t = int(input())

distance = abs(a - b)
relative_velocity = v - w

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

d = abs(a-b)
v_diff = abs(v-w)

if w >= v:
    print('NO')
elif d > t * v_diff:
    print('NO')
else:
    print('YES')
def resolve():
    a, v = map(int, input().split())
    b, w = map(int, input().split())
    T = int(input())
    if v <= w:
        print("NO")
        return
    if abs(a - b) <= T * abs(v - w):
        print("YES")
    else:
        print("NO")

resolve()
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
if a<b and v<=w:
    print("NO")
elif w>v:
    print("NO")
else:
    if abs(b-a)<=t*abs(v-w):
        print("YES")
    else:
        print("NO")
ma = lambda :map(int,input().split())
ni = lambda:int(input())
import collections
import math
import itertools
gcd = math.gcd
a,v = ma()
b,w = ma()
t = ni()
if w>=v:
    print("NO")
    exit()
d = abs(a-b)
if d + w*t <=v*t:
    print("YES")
else:
    print("NO")
oni = list(map(int, input().split()))
nige = list(map(int, input().split()))
time = int(input())

if nige[1]>=oni[1]:
    print("NO")
else:
    distance = abs(oni[0]-nige[0])
    diff = oni[1]-nige[1]
    need_time = distance / diff
    if need_time > time:
        print("NO")
    else:
        print("YES")
import io,sys
sys.setrecursionlimit(10**6)


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

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

    if p > 0 and l/p <= t:
        print("YES")
    else:
        print("NO") 
main()
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

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

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

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