peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Accepted
import numpy as np
n = int(input())
argList = [input() for _ in range(n)]
keys = list('abcdefghijklmnopqrstuvwxyz')
nMat = []
for s in argList:
    nList = [0]*26
    for i, k in enumerate(keys):
        nList[i] = s.count(k)
    nMat.append(nList)
nMat = np.array(nMat)
minLst = nMat.min(axis=0)
ret = ''
for i,num in enumerate(minLst):
    for j in range(num):
        ret += keys[i]
print(ret)
# Judge status: Accepted
#第2問　ABC081A
number = list(map(int,input()))
a = 0
for i in number:
    if i == 1:
        a = a+1
print(a)
# Judge status: Accepted
x,y = map(int,input().split())
n = 0
mod = 10**9+7
ans = 0
if not (x+y)%3:
  n = (x+y)//3
  x-=n
  y-=n
  if not x<0 or y<0:
    ans = 1
    for i in range(x):
      ans = ans*(n-i)*pow(i+1,mod-2,mod)%mod
print(ans)
# Judge status: Accepted
n = int(input())
s = []
t = []
for i in range(n):
    xa,la = map(int,input().split())
    s.append(xa-la)
    t.append(xa+la)
#print(s)
#print(t)

itv = []
for i in range(n):
    itv.append([t[i],s[i]])
itv.sort()

#print(itv)
ass = 0
tt = -1000000000
for i in range(n):
    if tt <= itv[i][1]:
        ass += 1
        tt = itv[i][0]
print(ass)
# Judge status: Accepted
def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]

n=n0()
a=n1()

def comb(n):
    if n<=1:
        return 0
    if n==2:
        return 1
    return (n*(n-1))//2

from collections import Counter
c=Counter(a)
# print(c)
d={i:comb(j) for i,j in c.items()}
# print(d)
s=sum(d.values())
# print(s)

for i in a:
    print(s-d[i]+comb(c[i]-1))
# Judge status: Accepted
n=int(input())
a=list(map(int,input().split()))

import fractions as math

l=[0]
r=[0]
for i in range(n-1):
  li=math.gcd(l[i],a[i])
  l.append(li)
  ri=math.gcd(r[i],a[n-i-1])
  r.append(ri)
m=[]
for i in range(n):
  mi=math.gcd(l[i],r[n-i-1])
  m.append(mi)

print(max(m))
# Judge status: Accepted
import sys

sys.setrecursionlimit(500005)
stdin = sys.stdin

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

n = ni()
a = na()

x = 0
for v in a:
    x ^= v
b = []
for i in range(n):
    b.append(a[i]^x)
print(" ".join(map(str, b)))
# Judge status: Accepted
a, b, c = map(int, input().split())

M = max(a, b, c)

if (a+b+c)%2 != (M* 3) % 2:
    M += 1


diff = 3 * M - a - b - c
print(diff // 2)
# Judge status: Wrong Answer
X = int(input())

if X < 4:
    print(1)
    exit()

ans = 1
for x in range(2,X-1):
    for p in range(2,X-1):
        if(x**p > X): break
        ans = x**p

print(ans)
# Judge status: Accepted
x=int(input())
while True:
    r = int(x ** .5)
    for i in range(2,r+1):
        if x%i == 0:
            break
    else:
        break
    x+=1
print(x)
# Judge status: Accepted
n = int(input())
l = list(map(int,input().split(' ')))

l = sorted(l)

ans = 0
for i in range (0,n-2):
	for j in range (i + 1,n-1):
		for k in range (j + 1,n):
			if l[i] != l[j] and l[j] != l[k] and l[i] != l[k] and l[i] + l[j] > l[k]:
				ans += 1

print(ans)
# Judge status: Accepted
from collections import deque
n, k = list(map(int, input().split()))
a = [0, ] + list(map(int, input().split()))
stack = deque([1, ])
visited = [0] * (n + 1)
hist = []
open = []
loop = []
while stack:
    now = stack.popleft()
    if visited[now] == 1:
        b = hist.index(now)
        open = hist[:b]
        loop = hist[b:]
        break
    next = a[now]
    visited[now] = 1
    hist.append(now)
    stack.append(next)
if k < len(open):
    print(open[k])
else:
    print(loop[(k - len(open)) % len(loop)])
# Judge status: Accepted
x = int(input())

n=1

while 1:
    angle_n = 360*n
    if angle_n % x == 0:
        ans = angle_n // x
        break
    else:
        n += 1

print(ans)
# Judge status: Accepted
x = int(input())
ans = 1
for i in range(2,x+1):
    j = 2
    while i **j <= x:
        ans = max(ans, i**j)
        j+=1
print(ans)
# Judge status: Wrong Answer
N, X = map(int, input().split())
x = list(map(int, input().split()))

x.append(X)
from math import gcd
g = x[1] - x[0]
for i in range(N-1):
    g = gcd(g, (x[i+1] - x[i]))

print(abs(g))
# Judge status: Wrong Answer
import math
x = math.pi
a=input()
n = int(a)
print(n*x)
# Judge status: Accepted
# AtCoder Beginner Contest 122 B - ATCoder
import sys

S = str(input())
target = ['A', 'C', 'G', 'T']

ans = 0
temp_ans = 0
for s in S:
    if s in target:
        temp_ans += 1
    else:
        temp_ans = 0
    ans = max(ans, temp_ans)

print(ans)
# Judge status: Accepted
def main():
    T = input()
    
    T = T.replace('?', 'D')

    # cnt = 0

    # cnt_pd = t.count('PD')
    # cnt_d = t.count('D')
            
    # cnt = cnt_d + cnt_pd
    print(T)
main()
# Judge status: Accepted
a,b = map(int,input().split())
if a + b >= 24:
    print(a+b-24)
else:
    print(a+b)
# Judge status: Accepted
print("ABC" if int(input()) <= 999 else "ABD")
# Judge status: Accepted
import fractions
from functools import reduce
def lcm_base(x, y):
    return (x * y) // fractions.gcd(x, y)

def lcm(*numbers):
    return reduce(lcm_base, numbers, 1)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)
N=int(input())
T=[]
for i in range(N):
    Ti=int(input())
    T.append(Ti)
print(lcm_list(T))
# Judge status: Accepted
n = int(input())
action = []
for i in range(n):
    action.append([int(i) for i in input().split()])
dp = [[0 for _ in range(3)] for _ in range(n+1)]

for i in range(n):
    for j in range(3):
        for k in range(3):
            if j == k:
                continue
            dp[i+1][k] = max(dp[i+1][k], dp[i][j] + action[i][k])
print(max(dp[n]))
# Judge status: Accepted
N,M = map(int, input().split())

a = [int(input()) for i in range(M)]

#初期化
dp=[-1]*N
dp[0]=1

for i in a:
    dp[i-1] = 0

for i in range(1,N):
    if dp[i]==0:
        continue
    elif i==1:
        dp[i]=dp[i-1] + 1
    else:
        dp[i]=dp[i-1]+dp[i-2]

print(dp[N-1]%1000000007)
# Judge status: Accepted
S = list(input())

if len(S) == len(set(S)):
    print("yes")
else:
    print("no")
# Judge status: Wrong Answer
s = input()
k = int(input())
slen = len(s)
new_s = ""

for i in range(slen):
  val = ord("z") + 1 - ord(s[i])
  if k >= val:
    k -= val
    new_s += "a"
  else:
    new_s += s[i]
    
if k > 0:
  tmp_val = ord(new_s[slen-1]) + k % 26
  if tmp_val > ord("z"):
    tmp_val -= 26
  new_s = new_s[:-1] + chr(tmp_val)

print(new_s)
# Judge status: Accepted
N=input()
for i in range(2**(len(N)-1)):
    OP=["-","-","-"]
    for j in range(len(N)-1):
        if ((i>>j)&1):
            OP[3-j-1]="+"
    formula=""
    for n,op in zip(N,OP+[""]):
        formula+=n+op
    if eval(formula)==7:
        print(formula+"=7")
        break
# Judge status: Accepted
#設定
import sys
input = sys.stdin.buffer.readline

#ライブラリインポート
from collections import defaultdict

#入力受け取り
def getlist():
	return list(map(int, input().split()))

#処理内容
def main():
	N = int(input())
	L = [[0] * 10 for i in range(10)]
	for i in range(1, N + 1):
		A = str(i)
		x = int(A[0])
		y = int(A[-1])
		L[x][y] += 1
	
	ans = 0
	for i in range(1, 10):
		for j in range(1, 10):
			ans += L[i][j] * L[j][i]

	print(ans)


if __name__ == '__main__':
	main()
# Judge status: Wrong Answer
n, a, b = map(int, input().split())
if a > b:
    print(0)
if n == 1 and a != b:
    print(0)
else:
    min_num = a * (n - 2)
    max_num = b * (n - 2)
    print(max_num - min_num + 1)
# Judge status: Accepted
a,b,c = map(int,input().split())

d = a - b
if c - d <= 0:
  print(0)
else:
  print(c - d)
# Judge status: Accepted
n,m=map(int,input().split())
cnt=[n for _ in range(m)]
for i in range(n):
	k = list(map(int,input().split()))
	for i in range(1, k[0]+1):
		cnt[k[i]-1] -= 1
ans = 0
for i in range(m):
	if cnt[i] == 0:
		ans += 1
print(ans)
# Judge status: Accepted
n = int(input())
if n>=1000:
  print('ABD')
else:
  print('ABC')
# Judge status: Accepted
s,t=[input() for i in range(2)]
for _ in range(len(s)):
  s=s[-1]+s[:-1]
  if s==t:
    print("Yes")
    break

else:
  print("No")
# Judge status: Accepted
n,a,b = map(int, input().split())

if a>b:
    print(0)
    exit()
if n==1:
    if b-a>0:
        print(0)
    else:
        print(1)
    exit()
if n==2:
    print(1)
    exit()

res = (a+b*(n-1)) - (a*(n-1)+b) + 1
print(res)
# Judge status: Accepted
n = int(input())
t = 0
f = False
for i in range(n):
    a,b = map(int, input().split())
    if a == b:
        t += 1
    else:
        t = 0
    if t>= 3:
        f = True
        # break

if f:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
s = str(input())
if len(set(s)) == 1:
    print('No')
elif (s[0] == s[1]) and (s[2] == s[3]):
    print('Yes')
elif (s[0] == s[2]) and (s[1] == s[3]):
    print('Yes')
elif (s[0] == s[3]) and (s[1] == s[2]):
    print('Yes')
else:
    print('No')
# Judge status: Accepted
n = int(input())
A = [int(input()) for _ in range(n)]

B = []
import bisect
for i, a in enumerate(A):
    if len(B) == 0:
        B.append(-a)
    else:
        j = bisect.bisect_right(B, -a)
        #print(j)
        if j == len(B):
            B.append(-a)
        elif j == 0:
            B[0] = -a
        else:
            B[j] = -a
    #print(B)
#print(B)
print(len(B))
# Judge status: Accepted
A, B, M = map(int, input().split())
list_A = list(map(int, input().split()))
list_B = list(map(int, input().split()))
ans = min(list_A) + min(list_B)


for i in range(M):
    tmp_list = list(map(int, input().split()))
    tmp_cost = list_A[tmp_list[0]-1] + list_B[tmp_list[1]-1] - tmp_list[2]
    ans = min(tmp_cost, ans)

print(ans)
# Judge status: Accepted
n = int(input())
a = list(map(int,input().split()))
l,r = {},{}
for i in range(n):
  xl = i+a[i]
  if xl in l:
    l[xl] += 1
  else:
    l[xl] = 1
  
  xr = i-a[i]
  if xr in r:
    r[xr] += 1
  else:
    r[xr] = 1

ans = 0
for x in l:
  if x in r:
    ans += l[x] * r[x]
print(ans)
# Judge status: Wrong Answer
n = int(input())
p = list(map(int, input().split()))
count = 0
for i in range(len(p)-1):
    if (p[i] > p[i-1] and p[i] < p[i+1]) or (p[i] < p[i-1] and p[i] > p[i+1]):
        count += 1
print(count)
# Judge status: Accepted
N = int(input())
A_leaf = list(map(int, input().split()))
if N == 0:
    print(1 if A_leaf[0] == 1 else -1)
    exit()
s = [0]*(N+2)
for i in range(1, N+2):
    s[i] = s[i-1] + A_leaf[i-1]
node = [1]*(N+1)
for i in range(1, N+1):
    node[i] = min((node[i-1] - A_leaf[i-1])*2, s[N+1]-s[i])
    if node[i] < A_leaf[i]:
        print(-1)
        exit()
else:
    print(sum(node))
# Judge status: Wrong Answer
n = int(input())

s = input()

if len(s) == n:
    print(s)
else:
    print(s[:n] + '...')
# Judge status: Wrong Answer
import sys
n=int(input())
h=list(map(int,input().split()))

for i in range(1,n-1):
    if h[i-1]<=h[i]<=h[i+1]:
        pass
    else:
        h[i]-=1
        if h[i-1]<=h[i]<=h[i+1]:
            pass
        else:
            print("No")
            sys.exit()
print("Yes")
# Judge status: Accepted
si = lambda: input().strip()
ii = lambda: int(input())
mii = lambda: map(int, input().split())
lmii = lambda: list(map(int, input().split()))
lmsi = lambda: list(map(str, input().split()))
smii = lambda: sorted(map(int, input().split()))

# ----------

x = ii()

d, m = divmod(x, 11)

ans = 2 * d
if m > 0:
    ans += 1
    if m > 6:
        ans += 1

print(ans)
# Judge status: Accepted
import itertools
n = int(input())
xy = [[int(i) for i in input().split()] for _ in [0]*n]
it = list(itertools.permutations(xy, n))
ans = 0
for i in it:
    for j in range(len(list(i))-1):
        ans += ((i[j][0] - i[j+1][0])**2 + (i[j][1] - i[j+1][1])**2)**0.5
print(ans/len(it))
# Judge status: Accepted
N,K = map(int,input().split())
S = list(input())
tmp = []
tmp.append(S[0])
for i in  range(1,N):
    if(S[i] != S[i-1]):
        tmp.append(S[i])
G = len(tmp)
G -= 2*K
G = max(G-1,0)

print(N-G-1)
# Judge status: Accepted
from fractions import gcd


N, X = map(int, input().split())
X = [X] + list(map(int, input().split()))
ans = 0
for i in range(N):
    ans = gcd(ans, abs(X[i + 1] - X[i]))
print(ans)
# Judge status: Accepted
N = int(input())
AC = 0
WA = 0
TLE = 0
RE = 0
for i in range(N):
    temp = input()
    if temp == "AC":
        AC = AC + 1
    if temp == "WA":
        WA = WA + 1
    if temp == "TLE":
        TLE = TLE + 1
    if temp == "RE":
        RE = RE + 1
print("AC x " + str(AC))
print("WA x " + str(WA))
print("TLE x " + str(TLE))
print("RE x " + str(RE))
# Judge status: Accepted
import sys
input = sys.stdin.readline


def main():
    N = int(input())

    L = [0] * 87
    L[0] = 2
    L[1] = 1
    for i in range(2, 87):
        L[i] = L[i-1] + L[i-2]
    print(L[N])


if __name__ == "__main__":
    main()
# Judge status: Accepted
s=input()
print(len([True for i in range(len(s)//2) if s[i]!=s[-1-i]]))
# Judge status: Accepted
from itertools import combinations
import sys

x = [input() for _ in range(5)]
k = int(input())

for i in combinations(x,2):
    tmp = abs(int(i[0])-int(i[1]))
    if(tmp > k):
        print(':(')
        sys.exit()
print('Yay!')
# Judge status: Accepted
N=int(input())
i=0
s=2
ans=1
while 1:
  ans = s**i
  if ans>N:
    print(s**(i-1))
    exit()
  i+=1
# Judge status: Accepted
from collections import Counter
n = int(input())
dum = [0]*n
a_li = list(map(int,input().split()))
a_counter = Counter(a_li)
a_most = a_counter.most_common()
count = 0
for i,j in a_most:
    if j >= 2:
        dum[count] = i
    count += 1
dum.sort(reverse=1)
if a_counter[dum[0]] >= 4:
    print(dum[0]**2)
else:
    print(dum[0]*dum[1])
# Judge status: Wrong Answer
n = int(input())
total = 0
for i in range(n):
    if i % 3 != 0 and i % 5 != 0:
        total += i
print(total)
# Judge status: Accepted
import sys

input = sys.stdin.readline


def main():
    N, M = [int(x) for x in input().split()]

    if M < N * 2:
        print(M // 2)
    else:
        ans = N
        M = M - N * 2
        ans += M // 4
        print(ans)
        

if __name__ == '__main__':
    main()
# Judge status: Accepted
def main():
    T = input()
    print(T.replace('?', 'D'))


if __name__ == "__main__":
    main()
# Judge status: Wrong Answer
s = input()
cnt = 0
for i in s:
    if s.count(i) % 2 == 0:
        cnt += 1
    
    else:
        print("No")
if cnt == len(s):
    print("Yes")
else:
    print("No")
# Judge status: Wrong Answer
import math
line = input()
a, b, n = line.split(" ")
a, b, n = int(a), int(b), int(n)
# ans = 0


# for i in range(n+1):
#     ans = math.floor((a*i)/b) - math.floor(i/b)
# print(ans)

ans1 = math.floor((a*n)/b) - math.floor(n/b)
ans2 = math.floor((a*n-1)/b) - math.floor(n-1/b)
print(max(ans1, ans2))
# Judge status: Wrong Answer
n = int(input())
t = [int(input()) for _ in range(n)]

def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a%b)

l = t[0]
for i in range(1, n):
    g = gcd(l, t[i])
    l = t[i-1]*t[i] // g
    
print(l)
# Judge status: Wrong Answer
def main():
    N, M = map(int, input().split())
    if N > M:
        N, M = M, N

    if N == 1:
        print(M-2)
    elif N == 2:
        print(0)
    else:
        print((N-2) * (M-2))


if __name__ == '__main__':
    main()
# Judge status: Accepted
s=input()
if 'RRR' in s:
    print(3)
elif 'RR' in s:
    print(2)
elif 'R' in s:
    print(1)
else:
    print(0)
# Judge status: Wrong Answer



def main():
    input_str = input()

    a,b,c = input_str.split(' ')
    a = int(a)
    b = int(b)
    c = int(c)
    flag = False

    for i in [a,b,c,'fin']:
        if i == 'fin':
            if a+b+c== 15:
                flag = True
        elif not i in [5,7]:
            break

    if flag:
        print('YES')
    else:
        print('NO')


if __name__=='__main__':
    main()
# Judge status: Wrong Answer
N = int(input())

if N == 1:
    print(1/float(1))
elif N%2==0:
    print((N//2)/float(N))
else:
    print((N//2)/float(N))
# Judge status: Accepted
a = int(input())

print(a + a*a + a*a*a)
# Judge status: Accepted
N = int(input())
A = list(map(int,input().split()))
ans = [0]*(10**6+1)
mul = set()
for i in range(N):
	if ans[A[i]] == 0:
		ans[A[i]] = 1
		p = A[i]*2
		while p <= 10**6:
			ans[p] = -1
			p += A[i]
	elif ans[A[i]] == 1:
		ans[A[i]] = 2

q = 0	
for i in range(10**6+1):
	if ans[i] == 1:
		q += 1
print(q)
# Judge status: Wrong Answer
from sys import exit

w = input()

w_set = list(set(w))

for i in range(len(w_set)):
  if w.count(w_set[i]) % 2 != 0:
    print("No")
    exit()
  else:
    print("Yes")
    exit()
# Judge status: Accepted
a,b,c = map(int, input().split())

if a==b==c: ans = 1
elif a != b and b != c and a != c: ans = 3
else: ans = 2

print(ans)
# Judge status: Accepted
from collections import Counter
MOD = 10**9 + 7
n = int(input())
c = Counter(input())
ans = 1
for k,v in c.items():
  ans = (ans*(v+1)) % MOD
  
print(ans-1)
# Judge status: Wrong Answer
s = input()
n_s = s[::-1]
print(sum(s != n_s for i,j in zip(s, n_s)))
# Judge status: Accepted
n,m = map(int, input().split())
AC = [False]*n
WA = [0]*n

for i in range(m):
    p,s = input().split()
    p = int(p)-1

    if AC[p] == False:
        if s == 'WA':
            WA[p] += 1
        else:
            AC[p] = True

wa = 0

for i in range(n):
    if AC[i]:
        wa += WA[i]
        

print(AC.count(True),wa)
# Judge status: Accepted
N = int(input())
if N % 2 == 0:
    print(N//2)
else:
    print(N//2+1)
# Judge status: Wrong Answer
a,b = map(int,input().split())

print("Even" if (a * b) % 2 else "Odd" )
# Judge status: Wrong Answer
import itertools
import fractions
from functools import reduce
N,M=map(int,input().split())
A=list(map(int,input().split()))
def lcm_base(x, y):
    return (x * y) // fractions.gcd(x, y)
def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)
tmp=lcm_list(A)
if M>tmp:
    print((M-tmp//2)//tmp+1)
else:
  print(0)
# Judge status: Wrong Answer
import sys
read = lambda: sys.stdin.readline().rstrip()

def counting_tree(N, D):
    tot = 1
    cnt = [0]*N
    # cnt = collections.Counter(D)
    for i in D:
        cnt[i]+=1
        print(cnt)

    for i in D[1:]:
        tot = tot * cnt[i-1]%998244353
        print(tot)

    return tot if D[0]==0 else 0

def main():
    
    N0 = int(read())
    D0 = tuple(map(int, read().split()))

    res = counting_tree(N0, D0)

    print(res)

if __name__ == "__main__":
    main()
# Judge status: Wrong Answer
num = input()
sum = 0
for x in num:
    sum = sum + (int(x) - 48)
    
if (sum % 9 == 0):
    if (sum != 0):
        print("YES")
    else:
        print("NO")
else:
    print("NO")
# Judge status: Accepted
n = int(input())
A = [list(map(int, input().split())) for _ in range(n)]

dp = [[ 0 for _ in range(3)]for _ in range(n+10)]

for i in range(3):
    dp[0][i] = A[0][i]

for i in range(1, n):
    for j in range(3):
        for k in range(3):
            if j != k:
                dp[i][k] = max(dp[i][k], dp[i-1][j]+A[i][k])

print(max(dp[n-1]))
# Judge status: Wrong Answer
import itertools

N = int(input())
X = [list(map(int, input().split())) for i in range(N)]
x = list(itertools.permutations(range(N), N))
res = 0
for a in x:
    for i in range(N - 1):
        print(res)
        res += ((X[a[i]][0] - X[a[i + 1]][0]) ** 2 + (X[a[i]][1] - X[a[i + 1]][1]) ** 2) ** 0.5
print(res / len(x))
# Judge status: Accepted
n=int(input())
s=[]
for i in range(n):
    s.append(input())
s.sort()
ans=n
for i in range(n-1):
    if s[i]==s[i+1]:
        ans-=1
print(ans)
# Judge status: Accepted
s = input()
for i in range(len(s) - 1):
    if s[i] in s[i+1:]:
        print('no')
        exit()
print('yes')
# Judge status: Accepted
n,k,s = map(int,input().split())
ans = []
for i in range(k):
  ans.append(str(s))
  
for j in range(n-k):
  if s != 1:
    ans.append(str(s-1))
  else:
    ans.append(str(s+1))
print(' '.join(ans))
# Judge status: Wrong Answer
N = int(input())
a = list(map(int, input().split()))
n = sum(a) // N - 1

ans = 0
for i in range(N):
  if a[i] == n or a[i] - 1 == n or a[i] + 1 == n:
    ans += 1
print(ans)
# Judge status: Accepted
a,b = map(int,input().split())
if a <= b:
    print(a)
else:
    print(a-1)
# Judge status: Accepted
a, b, c = map(int, input().split())

if c >= a and c <= b:
  print('Yes')
else:
  print('No')
# Judge status: Accepted
ABC = input().split()
print("YES" if ABC.count("5") == 2 and ABC.count("7") == 1 else "NO")
# Judge status: Accepted
n = int(input())

l = 10**9 + 7
power = 1

for i in range(1,n+1):
    power = (power * i)%l

print(power)
# Judge status: Wrong Answer
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())

if a+v*t >= b+w*t >= 0:
    print('YES')
else:
    print('NO')
# Judge status: Accepted
def main():
    a, b, c = map(int, input().split())
    k = int(input())

    count = 0
    while True:
        if a < b:
            if b < c:
                break
            else:
                c *= 2
                count += 1
        else:
            b *= 2
            count += 1
    print('Yes' if count <= k else 'No')


if __name__ == '__main__':
    main()
# Judge status: Wrong Answer
n=int(input())
a=int(input())
if n//500<=a:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
N = int(input())
A = list(map(int, input().split()))

min_div = 10 ** 9 
for a in A:
    div_count = 0
    while a % 2 == 0:
        a /= 2
        div_count += 1
    min_div = min(min_div, div_count)

print(min_div)
# Judge status: Accepted
from collections import defaultdict
N = int(input())
d = defaultdict(int)
for _ in range(N):
    d[''.join(sorted(input()))] += 1

def tousa(n):
    return n*(n-1)//2

ans = 0
for i in d.values():
    ans += tousa(i)
print(ans)
# Judge status: Accepted
import itertools
N,M,Q = map(int,input().split())
x = [list(map(int,input().split()))  for _ in range(Q)]
d=0
ans=0
B=[]

#Aの場合の数を全列挙
ele = [k for k in range(1,M+1)]

for i in itertools.combinations_with_replacement(ele,N):
  A = list(i)
  d=0
  for j in range(Q):
    if A[x[j][1]-1] - A[x[j][0]-1] == x[j][2]:
      d += x[j][3]
      
  else:
    if d>ans:
      ans = d
     
print(ans)
# Judge status: Accepted
S = input()
if S[0]=="A" and S[2:-1].count("C") == 1 and S[1:].replace("C","c").islower():
    print("AC")
else:
    print("WA")
# Judge status: Accepted
N=int(input())
A=list(map(int,input().split()))
B=set(A)
if N==len(B):
  print('YES')
else:
  print('NO')
# Judge status: Wrong Answer
import sys
S = input()
K = int(input())
for i in S:
  if i != 1:
    print(i)
    sys.exit()
print(1)
# Judge status: Wrong Answer
k=int(input())
s=input()
l=len(s)
if(l<=k):
  print(s)
else:
  s=s[k:]
  print(s)
# Judge status: Wrong Answer
n, x, t = map(int, input().split())
times = (n + x - 1) / x
ans = times * t
print(ans)
# Judge status: Wrong Answer
n = int(input())
txy = [list(map(int, input().split())) for i in range(n)]
t = 0
dx = 0
dy = 0
z = 'Yes'
for i,h,j in txy:
    if (dx != h or dy != j) and abs(dx-h)+abs(dy-j) <= i-t:
        dx = h
        dy = j
        t = i
    else:
        z = 'No'
print(z)
# Judge status: Accepted
a,b,c,d = map(int,input().split())
if abs(a-b)<=d and abs(b-c)<=d:
    print("Yes")
elif abs(a-c)<=d:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
import itertools

n, k = map(int, input().split())
dices = map(int, input().split())
dices_EV = list(map(lambda x:(x+1)/2, dices))
dices_EV_accumulate = list(itertools.accumulate(dices_EV))
dices_EV_sums = [dices_EV_accumulate[i+k] - dices_EV_accumulate[i] for i in range(n-k)]
dices_EV_sums.append(dices_EV_accumulate[k-1])
print(max(dices_EV_sums))
# Judge status: Accepted
s = input()

if s[2]==s[3] and s[4]==s[5]:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
n, k = map(int, input().split())

d = []
a = []

for i in range(k):
    d.append(int(input()))
    a.append(list(map(int,input().split())))


okashi = [0] * n


for i in a:
    for j in i:
        okashi[j-1] = 1

ans = n - sum(okashi)

print(ans)
# Judge status: Wrong Answer
h,n=map(int,input().split())
A=[list(map(int,input().split())) for i in range(n)]
ma=max(a for a,b in A)
dp=[0]*(h+ma)
for i in range(h+ma):
  dp[i]=min(dp[i-a]+b for a,b in A)
print(min(dp[h:]))