CodeEff/ECCO huggingface dataset:
# Original solution
import sys
stdin = sys.stdin

def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())

from collections import Counter

h,w = li()

cnt = Counter([])
for _ in range(h):
    tmp = lc()
    for c in tmp:
        cnt[c] += 1

exist = True

if h%2 == 0 and w%2 == 0:
    for key,value in list(cnt.items()):
        if value%4 != 0:
            exist = False
            break
        
elif h%2 == 1 and w%2 == 1:
    odd = 0
    mod4_2 = 0
    for key,value in list(cnt.items()):
        if value % 2 == 1:
            odd += 1
        elif value % 4 == 2:
            mod4_2 += 1
            
    if odd > 1:
        exist = False
    elif mod4_2 > (h+w-2)//2:
        exist = False
        
else:
    odmax = 0
    if h%2 == 0:
        odmax = h//2
    else:
        odmax = w//2
        
    
    mod4_2 = 0
    for key, value in list(cnt.items()):
        if value%2 != 0:
            exist = False
            break
        elif value%4 == 2:
            mod4_2 +=1
            
    if mod4_2 > odmax:
        exist = False
        
        
if exist:
    print("Yes")
else:
    print("No")

# Optimized solution
import sys
stdin = sys.stdin

sys.setrecursionlimit(10 ** 7)

def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())

from collections import defaultdict

def judge(cnts, h, w):
    odd_cnt = 0
    mod4_2_cnt = 0
    mod4_0_cnt = 0

    for key, val in list(cnts.items()):
        if val % 2 == 1:
            odd_cnt += 1

        elif val % 4 == 2:
            mod4_2_cnt += 1

        else:
            mod4_0_cnt += 1


    if h == 1 and w == 1:
        return True

    elif h == 1:
        if w % 2 == 1:
            return True if odd_cnt == 1 else False
        else:
            return True if odd_cnt == 0 else False

    elif w == 1:
        if h % 2 == 1:
            return True if odd_cnt == 1 else False
        else:
            return True if odd_cnt == 0 else False

    elif h % 2 == 1 and w % 2 == 1:
        return True if mod4_2_cnt == (w//2 + h//2) and odd_cnt == 1 else False

    elif h%2 == 1:
        return True if mod4_2_cnt == (w//2) and odd_cnt == 0 else False

    elif w%2 == 1:
        return True if mod4_2_cnt == (h//2) and odd_cnt == 0 else False

    else:
        return True if mod4_2_cnt == 0 and odd_cnt == 0 else False


h, w = li()
a = [ns() for _ in range(h)]

char_cnt = defaultdict(int)

for ai in a:
    for aij in ai:
        char_cnt[aij] += 1

print(("Yes" if judge(char_cnt, h, w) else "No"))
# Original solution
t,_,s=open(0).read().partition('\n')
h,w=list(map(int,t.split()))
a=b=c=0
if h%2and w%2:
    a=h//2*(w//2)
    c=1
    b=(h*w-a*4-c)//2
elif h%2or w%2:
    a=h//2*(w//2)
    b=(h*w-a*4)//2
else:
    a=h*w//4
l=[]
for i in set(s.replace('\n','')):
    l.append(s.count(i))
for i in l:
    if i>3:
        while i>3and a:
            i-=4
            a-=1
    if i>1:
        while i>1and b:
            i-=2
            b-=1
    if i and c:
        i-=1
        c-=1
if all(not t for t in(a,b,c)):
    print('Yes')
else:
    print('No')

# Optimized solution
t,_,s=open(0).read().partition('\n')
h,w=list(map(int,t.split()))
a=h//2*(w//2)
c=h%2and w%2
b=(h*w-a*4-c)//2
l=[]
for i in set(s.replace('\n','')):
    l.append(s.count(i))
for i in l:
    if i>3:
        while i>3and a:
            i-=4
            a-=1
    if i>1:
        while i>1and b:
            i-=2
            b-=1
    if i and c:
        i-=1
        c-=1
if all(not t for t in(a,b,c)):
    print('Yes')
else:
    print('No')
# Original solution
t,_,s=open(0).read().partition('\n')
h,w=list(map(int,t.split()))
d={}
d[4]=a=h//2*(w//2)
d[1]=b=h%2and w%2
d[2]=(h*w-a*4-b)//2
for i in map(s.count,set(s)-{'\n'}):
  for j in(4,2,1):
    while d[j]and i>=j:
      i-=j
      d[j]-=1
print(('YNeos'[any(t for t in list(d.values()))::2]))

# Optimized solution
t,_,s=open(0).read().partition('\n')
h,w=list(map(int,t.split()))
d={}
d[4]=a=h//2*(w//2)
d[1]=b=h%2and w%2
d[2]=(h*w-a*4-b)//2
for i in map(s.count,set(s)-{'\n'}):
  for j in(4,2,1):
    while d[j]and i>=j:
      i-=j
      d[j]-=1
print(('YNeos'[sum(d.values())>0::2]))
# Original solution
t,_,s=open(0).read().partition('\n')
h,w=list(map(int,t.split()))
d={}
d[4]=a=h//2*(w//2)
d[1]=b=h%2and w%2
d[2]=(h*w-a*4-b)//2
for i in map(s.count,set(s)-{'\n'}):
  for j in(4,2,1):
    while d[j]and i>=j:
      i-=j
      d[j]-=1
print(('YNeos'[sum(d.values())>0::2]))

# Optimized solution
t,_,s=open(0).read().partition('\n')
h,w=list(map(int,t.split()))
a,b=h//2*(w//2),h%2and w%2
d=[b,(h*w-a*4-b)//2,0,a]
for i in map(s.count,set(s)-{'\n'}):
  for j in(3,1,0):
    while d[j]and i>j:
      i-=j+1
      d[j]-=1
print(('YNeos'[sum(d)>0::2]))
# Original solution
t,_,s=open(0).read().partition('\n')
h,w=list(map(int,t.split()))
a,b,c,d=h//2,h%2,w//2,w%2
l=[b&d,d*a+b*c,0,a*c]
for i in map(s.count,set(s)-{'\n'}):
  for j in(3,1,0):
    while l[j]and i>j:
      i-=j+1
      l[j]-=1
print(('YNeos'[sum(l)>0::2]))

# Optimized solution
t,_,s=open(0).read().partition('\n')
h,w=list(map(int,t.split()))
d=[h%2&w%2,w%2*h//2+h%2*w//2,0,h//2*(w//2)]
for i in map(s.count,set(s)-{'\n'}):
  for j in(3,1,0):
    while d[j]and i>j:
      i-=j+1
      d[j]-=1
print(('YNeos'[sum(d)>0::2]))
# Original solution
from collections import*
h,*t=open(0)
h,w=list(map(int,h.split()))
f,o=1,0
for i in list(Counter(''.join(t[:-1]for t in t)).values()):
    f+=i//4
    o+=i&1
print(('YNeos'[o>h%2*w%2or h//2*(w//2)>=f::2]))

# Optimized solution
from collections import*
h,*t=open(0)
h,w=list(map(int,h.split()))
f,o=1,0
for i in list(Counter(''.join(t)).values()):
    f+=i//4
    o+=i&1
print(('YNeos'[o-h%2>h%2*w%2or f-h//4<=h//2*(w//2)::2]))
# Original solution
from collections import*
h,*t=open(0)
h,w=list(map(int,h.split()))
f,o=1,0
for i in list(Counter(''.join(t)).values()):
    f+=i//4
    o+=i&1
print(('YNeos'[o-h%2>h*w%2or f-h//4<=h//2*(w//2)::2]))

# Optimized solution
from collections import*
h,*t=open(0)
h,w=list(map(int,h.split()))
f=o=0
for i in list(Counter(''.join(t)).values()):f+=i//4;o+=i&1
print(('YNeos'[o-h%2>h*w%2or f-h//4<h//2*(w//2)::2]))
# Original solution
from heapq import*;X,Y,Z=list(map(int,input().split()));N=X+Y+Z;A=[];q1=[];q2=[];L=[0];R=[0]
for _ in[0]*N:A.append([int(e)for e in input().split()])
A.sort(key=lambda a:a[0]-a[1])
for i in range(N):
	L+=[L[i]+A[i][1]];heappush(q1,A[i][1]-A[i][2]);R+=[R[i]+A[-1-i][0]];heappush(q2,A[~i][0]-A[~i][2])
	if i>=Y:L[i+1]-=heappop(q1)
	if i>=X:R[i+1]-=heappop(q2)
print((max(L[i]+R[~i]for i in range(Y,N-X+1))))

# Optimized solution
from heapq import*
X,Y,Z=list(map(int,input().split()));N=X+Y+Z;A=[];p=[];q=[];L=[0];R=[0]
for _ in[0]*N:A.append([int(e)for e in input().split()])
A.sort(key=lambda a:a[0]-a[1])
for i in range(N):
	L+=[L[i]+A[i][1]];heappush(p,A[i][1]-A[i][2]);R+=[R[i]+A[-1-i][0]];heappush(q,A[~i][0]-A[~i][2])
	if i>=Y:L[i+1]-=heappop(p)
	if i>=X:R[i+1]-=heappop(q)
print((max(L[i]+R[~i]for i in range(Y,N-X+1))))
# Original solution
from heapq import*
f=lambda*z:list(map(int,input().split()))
X,Y,Z=f()
P=[]
Q=[]
L=[0]
R=[0]
r=list(range(X+Y+Z))
A=sorted(map(f,r),key=lambda a:a[0]-a[1])
for i in r:L+=[L[i]+A[i][1]];heappush(P,A[i][1]-A[i][2]);R+=[R[i]+A[~i][0]];heappush(Q,A[~i][0]-A[~i][2]);L[-1]-=i>=Y and heappop(P);R[-1]-=i>=X and heappop(Q)
print(max(L[i]+R[~i]for i in range(Y,Y+Z+1)))

# Optimized solution
from heapq import*
f=lambda*z:list(map(int,input().split()))
X,Y,Z=f()
P=[]
Q=[]
L=[0]
R=[0]
r=list(range(X+Y+Z))
A=sorted(map(f,r),key=lambda a:a[0]-a[1])
for i in r:L[i]-=i>Y and heappop(P);a=A[i];L+=[L[i]+a[1]];heappush(P,a[1]-a[2]);R[i]-=i>X and heappop(Q);a=A[~i];R+=[R[i]+a[0]];heappush(Q,a[0]-a[2])
print(max(L[i]+R[~i]for i in range(Y,Y+Z+1)))
# Original solution
N=int(input())
s=[0]*N
for _ in[0]*(N*~-N//2):
 a,b,c,d=map(int,input().split())
 s[a-1]+=3*(c>d)+(c==d)
 s[b-1]+=3*(d>c)+(d==c)
b=[[]for _ in[0]*N*3]
for i in range(N):
 b[s[i]]+=[i]
r=1
for x in b[::-1]:
 for y in x:
  s[y]=r
 if x:r+=len(x)
print(*s,sep='\n')


# Optimized solution
def f():
 N=int(input())
 s=[0]*N
 for _ in[0]*(N*~-N//2):
  a,b,c,d=map(int,input().split())
  s[a-1]+=3*(c>d)+(c==d)
  s[b-1]+=3*(d>c)+(d==c)
 b=[[]for _ in[0]*N*3]
 for i in range(N):b[s[i]]+=[i]
 r=1
 for x in b[::-1]:
  for y in x:s[y]=r
  if x:r+=len(x)
 print(*s,sep='\n')
f()
# Original solution
n=int(eval(input()));score=[list([int(x)-1 for x in input().split()]) for _ in range(int(n*(n-1)/2))];points= [0]*n
for a,b,c,d in score: 
    if c>d:points[a]+=3 
    elif c<d:points[b]+=3 
    else:points[a]+=1;points[b]+=1
rank=sorted(points,reverse=True)
for p in points:print((rank.index(p)+1))

# Optimized solution
n=int(eval(input()));s=[list(map(int,input().split())) for _ in range(int(n*(n-1)/2))];p=[0]*n
for a,b,c,d in s: 
    if c>d:p[a-1]+=3 
    elif c<d:p[b-1]+=3 
    else:p[a-1]+=1;p[b-1]+=1
r=sorted(p,reverse=True)
for q in p:print((r.index(q)+1))
# Original solution
from decimal import *

l=list(map(int, input().split(' ')))
a=l[0]
v=l[1]
l=list(map(int, input().split(' ')))
b=l[0]
w=l[1]
s=int(eval(input()))
ans=True
if a>b:
    ans=Decimal(a)-Decimal(v*s)<=Decimal(b)-Decimal(w*s)
else:
    ans=Decimal(a)+Decimal(v*s)>=Decimal(b)+Decimal(w*s)
if ans:
    print("YES")
else:
    print("NO")
    



# Optimized solution

l=list(map(int, input().split(' ')))
a=l[0]
v=l[1]
l=list(map(int, input().split(' ')))
b=l[0]
w=l[1]
s=int(eval(input()))
ans=True
if a>b:
    ans=a-v*s<=b-w*s
else:
    ans=a+v*s>=b+w*s
if ans:
    print("YES")
else:
    print("NO")
# Original solution
A,V=list(map(int,input().split()))
B,W=list(map(int,input().split()))
K=int(eval(input()))
Apos=A
Bpos=B
count=0
rev=False
if B>A:
    pass
else:
    rev=True

if rev==False:

    while K>count:
        
        Apos=Apos+V
        Bpos=Bpos+W
        if Apos>=Bpos:
            print("YES")
            exit()
        count+=1
        

else:
    while K>count:
        
        Apos=Apos-V
        Bpos=Bpos-W
        if Apos<=Bpos:
            print("YES")
            exit()
        count+=1

print("NO")

# Optimized solution
A,V=list(map(int,input().split()))
B,W=list(map(int,input().split()))
K=int(eval(input()))
Apos=A
Bpos=B
count=0
rev=False
if B>A:
    pass
else:
    rev=True

if rev==False:

    
        
    A=A+V*K
    B=B+W*K
    if A>=B:
        print("YES")
        exit()
    
        

else:
    A=A-V*K
    B=B-W*K
    if A<=B:
        print("YES")
        exit()

print("NO")
# Original solution
import sys
from pprint import pprint

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

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

# Optimized solution
import sys

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

if W < V and abs(A - B) <= (V - W) * T:
    print("YES")
else:
    print("NO")
# Original solution
a, v = list(map(int, input().split()))
b, w = list(map(int, input().split()))
t = int(eval(input()))

sa = abs(a - b)
sas = abs(v - w)
if w >= v:
    print("NO")
    exit(0)

for i in range(t):
    sa -= sas
if sa <= 0:
    print("YES")
else:
    print("NO")



# Optimized solution
a, v = list(map(int, input().split()))
b, w = list(map(int, input().split()))
t = int(eval(input()))

sa = abs(a - b)
sas = abs(v - w)
if w >= v:
    print("NO")
    exit(0)

d = sa // sas

if d >t:
    print("NO")
if d == t:
    if sa % sas == 0:
        print("YES")
    else:
        print("NO")
if d < t:
    if sa - (d*sas) -sas <=0:
        print("YES")
    else:
        print("NO")
# Original solution
A, V = list(map(int, input().split()))
B, W = list(map(int, input().split()))
T = int(eval(input()))
while T > 0:
  if A > B:
    A -= V
    B -= W
  else:
    A += V
    B += W
  if A == B:
    print("YES")
    exit()
  T -= 1
print("NO")

# Optimized solution
A, V = list(map(int, input().split()))
B, W = list(map(int, input().split()))
T = int(eval(input()))
if V <= W:
  print("NO")
  exit()
dis = abs(A - B)
step = abs(W - V)
print(("YES" if dis <= step * T else "NO"))
# Original solution
import sys
input = sys.stdin.readline

a, v = list(map(int,input().split()))
b, w = list(map(int,input().split()))
t = int(eval(input()))
for i in range(t):
    a = a + v 
    b = b + w 
if a >= b :
    print("YES")
else:
    print("NO")

# Optimized solution

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

if a > b:
    v = -v
    if w > 0:
        w = -w
if a < b and  w < 0:
    w = -w



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

if A > B:
    if  a < b:
        print("YES")
    else:
        print("NO")
elif A == B:
    print("YES")
elif A < B :
    if a < b:
        print("NO")
    else:
        print("YES")
# Original solution
A,V=list(map(int, input().split()))
B,W=list(map(int, input().split()))
T = int(eval(input()))
k = abs(A-B)
d = V-W
if d <= 0:
  print("NO")
else:
  for i in range(T):
    k -= d
    if k <= 0:
      print("YES")
      break
  else:
    print("NO")


# Optimized solution
A,V=list(map(int, input().split()))
B,W=list(map(int, input().split()))
T = int(eval(input()))
k = abs(A-B)
d = V-W
if d <= 0:
  print("NO")
else:
  if (k / d) > T:
    print("NO")
  else:
    print("YES")
# Original solution
a,v,b,w,t=list(map(int,open(0).read().split()))
print((['NO','YES'][abs(b-a)<=(v-w)*t]))

# Optimized solution
a,v,b,w,t=list(map(int,open(0).read().split()))
print(('YNEOS'[abs(b-a)>(v-w)*t::2]))
# Original solution
A,V=list(map(int,input().split()))
B,W=list(map(int,input().split()))
T=int(eval(input()))
if W>=V:
  print("NO")
else:
  if abs(A-B)/(V-W)<=T:
    print("YES")
  else:
    print("NO")

# Optimized solution
A,V=list(map(int,input().split()))
B,W=list(map(int,input().split()))
T=int(eval(input()))
if W>=V:
  print("NO")
else:
  if abs(A-B)<=(V-W)*T:
    print("YES")
  else:
    print("NO")
# Original solution
def onigokko():
    A,V = list(map(int, input().split()))
    B,W = list(map(int, input().split()))
    T = int(eval(input()))
    
    if B < A:
        swap = A
        A = B
        B = swap
    
    for i in range(T):
        # Aから一番遠い所へ移動
        B += W

        # Aを動かす
        # 一番遠い所へ移動
        A += V

        # もし、A>=Bなら鬼の勝ち
        if A >= B:
            print('YES')
            return
    print('NO')

onigokko()

# Optimized solution
def onigokko():
    A,V = list(map(int, input().split()))
    B,W = list(map(int, input().split()))
    T = int(eval(input()))
    
    if B < A:
        swap = A
        A = B
        B = swap
    
    tikaduku = V - W
    
    # 遠ざかったらアウト
    if tikaduku < 1:
        return 'NO'
    
    kyori = B - A
    
    if kyori <= tikaduku * T:
        return 'YES'
    
    return 'NO'

print((onigokko()))
# Original solution
a, v = list(map(int, input().split()))
b, w = list(map(int, input().split()))
t = int(eval(input()))
if v <= w:
    print('NO')
else:
    if 1 <= (abs(b - a) / (v - w)) <= t:
        print('YES')
    else:
        print('NO')

# Optimized solution
a, v = list(map(int, input().split()))
b, w = list(map(int, input().split()))
t = int(eval(input()))
if v <= w:
    print('NO')
else:
    if -1 < ((b - a) / (v - w)) < 1:
        print('NO')
    elif 1 <= (abs(b - a) / (v - w)) <= t:
        print('YES')
    else:
        print('NO')
# Original solution
a, v = list(map(int, input().split()))
b, w = list(map(int, input().split()))
t = int(eval(input()))
if v <= w:
    print('NO')
else:
    if -1 < ((b - a) / (v - w)) < 1:
        print('NO')
    elif 1 <= (abs(b - a) / (v - w)) <= t:
        print('YES')
    else:
        print('NO')

# Optimized solution
# ac
a, v = list(map(int, input().split()))
b, w = list(map(int, input().split()))
t = int(eval(input()))
if v <= w:
    print('NO')
else:
    if 1 <= (abs(b - a) / (v - w)) <= t:
        print('YES')
    else:
        print('NO')
# Original solution
a,v = list(map(int,input().split()))
b,w = list(map(int,input().split()))
t = int(eval(input()))
flg = 0

for _ in range(t):
    if a < b:
        if v <= w:
            break
        if a+v >= b+w:
            flg = 1
            break
        a = a+v
        b= b+w
    else:
        if v <= w:
            break
        if a-v <= b-w:
            flg = 1
            break
        a = a-v
        b=b-w
        
if flg == 0:
    print("NO")
else:
    print("YES")

# Optimized solution
import sys
a,v = list(map(int,input().split()))
b,w = list(map(int,input().split()))
t = int(eval(input()))

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

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")
# Original solution
a,v=list(map(int,input().split()))
b,w=list(map(int,input().split()))
t=int(eval(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")

# Optimized solution
a,v=list(map(int,input().split()))
b,w=list(map(int,input().split()))
t=int(eval(input()))
k=abs(a-b)
if 0<=k<=(v-w)*t and v!=w:
    print("YES")
else:
    print("NO")
# Original solution
# -*- coding: utf-8 -*-


def main():
    import sys
    input = sys.stdin.readline

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

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

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


if __name__ == '__main__':
    main()


# Optimized solution
# -*- coding: utf-8 -*-


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

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

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


if __name__ == '__main__':
    main()
# Original solution
import sys

readline = sys.stdin.buffer.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


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

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

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


if __name__ == '__main__':
    main()


# Optimized solution
a, v = list(map(int, input().split()))
b, w = list(map(int, input().split()))
t = int(eval(input()))

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

if r_vel * t >= dist:
    print("YES")
else:
    print("NO")
# Original solution
if __name__ == '__main__':
    a, v = list(map(int, input().split()))
    b, w = list(map(int, input().split()))
    t = int(eval(input()))

    if w>= v:
        print("NO")
    else:
        flag = False
        if a == b:
            flag = True

        for i in range(t):
            if b>a:
                a+=v
                b+=w
            else:
                a-=v
                b-=w
            if a==b:
                flag=True
        if flag:
            print("YES")
        else:
            print("NO")



# Optimized solution
if __name__ == '__main__':
    a, v = list(map(int, input().split()))
    b, w = list(map(int, input().split()))
    t = int(eval(input()))
    l =abs(a - b)
    s=abs(v - w)

    if w >= v or l / s > t:
        print("NO")
    else:
        print("YES")
# Original solution
# tokiomarine2020_b.py
A,V = list(map(int,input().split()))
B,W = list(map(int,input().split()))
T = int(eval(input()))
if V<=W:
    print('NO')
    exit()

if A<B:
    for i in range(T):
        A += V
        B += W
        if A>=B:
            print('YES')
            exit()
else:
    for i in range(T):
        A -= V
        B -= W
        if A<=B:
            print('YES')
            exit()
print("NO")


# Optimized solution
# tokiomarine2020_b.py
A,V = list(map(int,input().split()))
B,W = list(map(int,input().split()))
T = int(eval(input()))
if V<=W:
    print('NO')
    exit()

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

# Optimized solution
a,v = list(map(int,input().split()))
b,w = list(map(int,input().split()))
t = int(eval(input()))
if (v-w)*t>=abs(b-a):print("YES")
else:print("NO")
# Original solution
a,v = list(map(int,input().split()))
b,w = list(map(int,input().split()))
t = int(eval(input()))
# print(a,v)
# print(b,w)
# print(t)

dl = abs(a-b)
dv = v-w # 鬼のほうが速い？＋
# print(dl,dv)
if dl == 0:
    print('YES')
else:
    if dv > 0:
        # print(dl//dv)
        if (dl+dv-1)//abs(dv) <= t:
        # if dl//dv <= t:
            print('YES')
        else:
            print('NO')
    else:
        print('NO')


# Optimized solution
a, v = list(map(int, input().split()))
b, w = list(map(int, input().split()))
t = int(eval(input()))
dl = abs(a - b)
dv = v - w
if dv > 0 and (dl+dv-1) // abs(dv) <= t: print('YES')
else: print('NO')
# Original solution
def main():
    A, V = list(map(int, input().split()))
    B, W = list(map(int, input().split()))
    T = int(eval(input()))

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

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

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


if __name__ == '__main__':
    main()

# import sys
# input = sys.stdin.readline
#
# sys.setrecursionlimit(10 ** 7)
#
# (int(x)-1 for x in input().split())
# rstrip()
#
# def binary_search(*, ok, ng, func):
#     while abs(ok - ng) > 1:
#         mid = (ok + ng) // 2
#         if func(mid):
#             ok = mid
#         else:
#             ng = mid
#     return ok


# Optimized solution
def main():
    A, V = list(map(int, input().split()))
    B, W = list(map(int, input().split()))
    T = int(eval(input()))

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


if __name__ == '__main__':
    main()
# Original solution
a, v = list(map(int, input().split()))
b, w = list(map(int, input().split()))
t = int(eval(input()))
ans = 'NO'
for i in range(t):
    if a < b:
        a += v
        b += w
    else:
        a -= v
        b -= w
    if a == b:
        ans = 'YES'
        break
print(ans)


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