peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Wrong Answer
import math
import itertools

def mathFactorial(a,b):
	return math.factorial(a) // (math.factorial(b) * math.factorial(a-b))

N,K = map(int, input().split())
print(N,K)

myListA =[]
myList =[]

for i in range(0,N+1):
	myListA.append(i)

i = 0
l = 0
while K < N+2:
	for x in itertools.combinations(myListA,K):
		myList.append(sum(x))
	K = K + 1
	i = i + 1
	l = l + len(set(myList))
	myList =[]

print(l % (10^9 +7))
# Judge status: Accepted
K, X = list(map(int, input().split()))
if K * 500 >= X:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
n = int(input())
d = dict()
for i in range(n):
    s = list(input())
    s.sort()
    s = "".join(s)
    if s not in d.keys():
        d[s] = 1
    else:
        d[s] += 1
count = 0
for i in d.values():
    count += i * (i-1) // 2
print(count)
# Judge status: Wrong Answer
x, y = map(int, input().split())
if y <= x:
    print(1)
else:
    cnt = 1
    total = x
    while True:
        total += (x - 1)
        cnt += 1
        if total >= y:
            break
    print(cnt)
# Judge status: Accepted
from collections import Counter
import sys
MOD = 998244353


def main():
    n, *d =  map(int, sys.stdin.buffer.read().split())
    D = Counter(d)
    if D[0] != 1:
        print(0)
    else:
        ans = 1
        for i in d[1:]:
            ans = ans*D[i-1]%MOD
        print(ans % MOD)


if __name__ == '__main__':
    main()
# Judge status: Accepted
s = input()
a = int(s[:2])
b = int(s[2:])

if a <= 12 and b <= 12:
    if a==0 and b!=0:
        print("YYMM")
    elif b==0 and a!=0:
        print("MMYY")
    elif a==0 and b==0:
        print("NA")
    else:
        print("AMBIGUOUS")
elif a<=12 and b>12:
    if a==0:
        print("NA")
    else:
        print("MMYY")
elif a>12 and b<=12:
    if b==0:
        print("NA")
    else:
        print("YYMM")
else:
    print("NA")
# Judge status: Accepted
import sys
from itertools import combinations
import math


def I(): return int(sys.stdin.readline().rstrip())


def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))


def S(): return sys.stdin.readline().rstrip()


def LS(): return list(sys.stdin.readline().rstrip().split())


S = S()

while 1:
    for flag in ("erase", "eraser", "dream", "dreamer"):
        if S.endswith(flag):
            S = S[:-len(flag)]
            break
    else:
        print('NO')
        break
    if not S:
        print('YES')
        break
# Judge status: Wrong Answer
S_list = list(map(int,input().split()))

if  S_list[1] - S_list[0] >= 0 and S_list[2]- S_list[0] >=0 and S_list[2] - S_list[2] >=0:
    result = "Yes"
else:
    result = "No"
print(result)
# Judge status: Accepted
N, Y = map(int, input().split())

for i in range(0, N+1, 1):
  isFinish = False
  for j in range(0, N+1-i, 1):
    sen = 1000 * i
    gosen = 5000 * j
    man = 10000 * (N - i - j)
    
    if sen + gosen + man == Y:
      print(N - i - j, j, i)
      isFinish = True
      break
  
  if isFinish:
    break
else:
  print(-1, -1, -1)
# Judge status: Wrong Answer
x, y = map(int, input().split())
if x >= 0:
    if y >= 0:
        if x <= y:
            ans = y - x
        else:
            ans = x - y + 2
    else:
        ans = abs(x + y) + 1
else:
    if y < 0:
        if x <= y:
            ans = y - x
        else:
            ans = x - y + 2
    else:
        ans = abs(x + y) + 1

print(ans)
# Judge status: Accepted
# coding: utf-8
lst = set(map(int, input().split()))
print(len(lst))
# Judge status: Wrong Answer
n, m = map(int, input().split())
N = [1]*n
P = [True] + [False]*(n-1)
for i in range(m):
    x, y = list(map(lambda tmp: tmp-1, map(int, input().split())))
    P[y] = True if P[x]==True else False
    N[x] -= 1; N[y] += 1
    P[x] = False if N[x]==0 else P[x]
print(sum(P))
# Judge status: Accepted
n = int(input())
a_list = [int(x) for x in input().split()]
print(*(a_list[::-2] + a_list[n&1::2]))
# Judge status: Accepted
s = input()
odd = ["R", "U", "D"]
even = ["L", "U", "D"]
for i in list(s[::2]):
    if i not in odd: 
        print("No")
        exit()
for i in list(s[1::2]):
    if i not in even: 
        print("No")
        exit()
print("Yes")
# Judge status: Accepted
N, M = map(int, input().split())

s = {1}
cnt = [1] * (N + 1)
for i in range(M):
    x, y = map(int, input().split())
    cnt[x] -= 1
    cnt[y] += 1
    if x in s:
        s.add(y)
        if cnt[x] == 0:
            s.discard(x)

print(len(s))
# Judge status: Accepted
a,b,c = map(int,input().split())
ans = 0

if a%2 == 0 or b%2==0 or c%2==0:
  pass
  
else:
  ans += min(a*b,a*c,b*c)
print(ans)
# Judge status: Accepted
n,h=map(int,input().split())
a=[]
b=[]
for _ in range(n):
    a_i,b_i=map(int,input().split())
    a.append(a_i)
    b.append(b_i)

import bisect,math


b=sorted(b)
index = bisect.bisect_left(b,max(a))

cnt=0
for i in range(n-1,-1,-1):
    if i>=index:
        h-=b[i]
        cnt+=1
    else:
        break
    
    if h<=0:
        h=0
        break

ans=math.ceil(h/max(a))+cnt

print(ans)
# Judge status: Accepted
x,y=map(int, input().split())
ans=0
if x!=0 and x==-y:
    ans+=1
elif x*y<0:
    ans+=abs(x+y)+1
else:
    if x>y:
        ans+=1+(x!=0 and y!=0)
        x,y=-x,-y
    ans+=y-x
print(ans)
# Judge status: Accepted
N=int(input())
P=list(map(int, input().split()))
ido=[]

for i in range(N):
	if P[i]!=i+1:
		ido.append(P[i])

if len(ido)==2 or len(ido)==0:
	print("YES")
else:
	print("NO")
# Judge status: Accepted
S = input()
ok = True
for i in range(0, len(S), 2):
    try:
        if not (S[i] == "h" and S[i + 1] == "i"):
            ok = False
            break
    except IndexError:
        ok = False
        break
print("Yes" if ok else "No")
# Judge status: Accepted
import math
N=int(input())
print(math.factorial(N)%(10**9+7))
# Judge status: Wrong Answer
n, m = map(int, input().split())
students = [list(map(int, input().split())) for i in range(n)]

targets = [list(map(int, input().split())) for i in range(m)]
x = 0
snumber = [(0, x)] * n
  
def md(s, t):
  d = abs(s[0] - t[0]) + abs(s[1] - t[1])
  return d

for i in range(n):
  x = 2 * 10 ** 8
  for j in range(m):    
    if x > md(students[i], targets[j]):
      x = md(students[i], targets[j])
      snumber[i] = (j+1, md(students[i], targets[j]))
 
for i in range(n):      
  print(snumber[i][0])
# Judge status: Accepted
from bisect import bisect_left, bisect_right

n, m, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
for i in range(n-1): a[i+1] = a[i] + a[i+1]
for i in range(m-1): b[i+1] = b[i] + b[i+1]
a = [0] + a; b = [0] + b

c = bisect_right(a, k)-1
ans = 0

for i in range(c+1)[::-1]:
    r = k-a[i]
    j = bisect_right(b, r)-1
    ans = max(ans, i+j)

print(ans)
# Judge status: Accepted
n = int(input())
while n >= 0:
    if n % 4 == 0:
        print("Yes")
        exit()
    else:
        n -= 7
print("No")
# Judge status: Accepted
n = int(input())
l_list = [2, 1]
if n < 2 :
    print(l_list[n])
else :
    for i in range(2,n+1) :
        new = l_list[i-1] + l_list[i-2]
        l_list.append(new)
    print(l_list[n])
# Judge status: Accepted
S = input()
T = input()

print('Yes' if T.startswith(S) else 'No')
# Judge status: Wrong Answer
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())

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

if b+w*t > a+v*t:
    print("NO")
else:
    print("YES")
# Judge status: Wrong Answer

import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

from collections import Counter

N = int(input())
S = [''.join(map(str,(sorted(str(input()))))) for i in range(N)]
print(S)
counter = Counter(S)
print(counter)

answer = sum(x*(x-1)//2 for x in counter.values())
print(answer)
# Judge status: Accepted
N,x=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
happy=0
for i in range(N-1):
    if a[i]<=x:
        x-=a[i]
        happy+=1
    else:
        break
if a[N-1]==x:
    happy+=1
print(happy)
# Judge status: Accepted
n = int(input())
st = ["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"]
s = input()
for i in range(len(s)):
    a = (st.index(s[i]) + n) % 26
    print(st[a],end="")
# Judge status: Accepted
n=int(input())
c=input()
a=[]
for i in range(n):
    if(c[i]=='R'):
        a.append(0)
    else:
        a.append(1)

zero=0
one=0
for i in range(n):
    if(a[i]==0):
        zero+=1

ans=[zero]
for i in range(n):
    if(a[i]==0):
        zero-=1
    else:
        one+=1
    #print(zero,one)
    ans.append(max(zero,one))

print(min(ans))
# Judge status: Accepted
c = str(input())

if c == 'a':
	print('vowel')
elif c == 'i':
	print('vowel')
elif c == 'u':
	print('vowel')
elif c == 'e' :
	print('vowel')
elif c == 'o':
	print('vowel')
else:
	print('consonant')
# Judge status: Accepted
import sys
input = sys.stdin.readline
N = int(input())
a = list(map(int, input().split()))
cs = [0] * (N + 1)
for i in range(N): cs[i + 1] = cs[i] + a[i]
res = float("inf")
for i in range(1, N):
  res = min(res, abs(cs[i] - (cs[-1] - cs[i])))
print(res)
# Judge status: Accepted
n=int(input())
print(1000-((n-1)%1000)-1)
# Judge status: Wrong Answer
a = input()
t = 0
ans = 0
f = a[0]
if f == '>':ans+=1
elif f == '<':t = 0
for i in a[1:]:
    # print(f,i)
    if f == '>' and i == '<':
        t = 0
    elif f == '<' and i == '>':
        t += 1
        ans +=t
        if t != 1 : t = 0
    else:
        t += 1
        ans+=t
    f = i
    # print(t,ans)
if f == '>':t=1
print(ans+(f == '<'))
# Judge status: Accepted
def collatz(n):
  if n % 2 == 0:
    return int(n/2)
  else:
    return 3 * n + 1

A = [int(input())]
i = 1
while True:
  x = collatz(A[-1])
  if x in A:
    print(i + 1)
    break
  else:
    A.append(x)
    i += 1
# Judge status: Accepted
n = int(input())
a = list(map(int,input().split()))
MOD = 10**9+7

array_sum = 0
for i in range(n):
  array_sum += a[i]
  array_sum %= MOD

ans = 0
for i in range(n):
  array_sum -= a[i]
  ans += array_sum * a[i]
  ans %= MOD
  
print(ans)
# Judge status: Wrong Answer
N=int(input())
X=list(map(int,input().split()))
s=0
sum=0
for i in X:
    sum+=i

sum=round(sum/len(X),0)
print(sum)
for i in X:
    tmp=(i-sum)**2
    s=s+tmp
print(s)
# Judge status: Wrong Answer
N = int(input())
A = list(map(int,input().split()))
X = [0,0,0]

for i in range(len(A)):
  if A[i]%4 == 0:
    X[2] += 1
  elif A[i]%2 == 0:
    X[1] += 1
  else:
    X[0] += 1

if 2*X[2] + X[1] >= N:
  print("Yes")
else:
  print("No")
# Judge status: Accepted
n=list(map(int,input().split()))
p=sum(n)
f=15
ans=(f-p)
print(ans)
# Judge status: Accepted
a, b = map(int, input().split())

ans = 0
tap = 1
while tap < b:
    tap += a - 1
    ans += 1

print(ans)
# Judge status: Wrong Answer
A, B=input().split()
B=float(B)
B="%.2f" % round(B, 2)
re=int(A)*float(B)
print (int(re//1))
# Judge status: Accepted
import sys
import bisect
input = sys.stdin.readline

N = int(input())
L = sorted(list(map(int, input().split())))
ans = 0
for i in range(N - 2):
    for j in range(i + 1, N - 1):
        index = bisect.bisect_left(L, L[i] + L[j])
        n = index - j - 1
        ans += n

print(ans)
# Judge status: Accepted
#import sys
#import numpy as np
import math
#from fractions import Fraction
import itertools
from collections import deque
from collections import Counter
import heapq
from fractions  import gcd
#input=sys.stdin.readline
#import bisect
n,m=map(int,input().split())
if n>=m//2:
    print(m//2)
else:
    ans=n+(m-2*n)//4
    print(ans)
# Judge status: Accepted
X = int(input())
year = 0
deposit = 100
while deposit < X:
    deposit = deposit*101//100
    year += 1
print(year)
# Judge status: Accepted
import bisect
x, n = map(int, input().split())
pN = list(map(int, input().split()))

pN.sort()

diff = 0

if n == 0:
    print(x)
else:
    while(1):
        if x-diff not in pN:
            print(x-diff)
            exit()
        elif x+diff not in pN:
            print(x+diff)
            exit()
        diff+=1
# Judge status: Accepted
a, b = map(int, input().split())
def Base_10_to_n(X, n):
    if (int(X/n)):
        return Base_10_to_n(int(X/n), n)+str(X%n)
    return str(X%n)

print(len(Base_10_to_n(a, b)))
# Judge status: Accepted
from collections import deque
n=int(input())
a=list(map(int,input().split()))
head=False
d = deque()
for i in range(n):
    if head==True:
        d.appendleft(a[i])
    else:
        d.append(a[i])
    head = not head
if head==True:
    d=list(d)
    print(*d[::-1])
else:
    print(*d)
# Judge status: Accepted
def fact(n):
  ret=1
  for i in range(2,n+1):
    ret=ret*i
  return ret

n=int(input())
arr1=list(map(int,input().split()))
arr2=list(map(int,input().split()))
cnt1=0
cnt2=0
checked1=[0]*(n+1)
checked2=[0]*(n+1)
for i in range(n):
  checked1[arr1[i]]=1
  checked2[arr2[i]]=1
  cnt1+=(arr1[i]-1-sum(checked1[:arr1[i]]))*fact(n-i-1)
  cnt2+=(arr2[i]-1-sum(checked2[:arr2[i]]))*fact(n-i-1)
print(abs(cnt1-cnt2))
# Judge status: Wrong Answer
S = int(input())
from math import sqrt
rtS = sqrt(S)
u = 10 ** 9
ans = [0 for _ in range(6)]
ans[2] = u
ans[3] = 1
ans[4] = -S%u
ans[5] = S//u
print(*ans)
# Judge status: Wrong Answer
n = int(input())

ab = []
for _ in range(n):
    a,b = map(int,input().split())
    ab.append([a,b])

ab.sort(key=lambda x:x[1])

wrk = ab[0][0]
for i in range(n):
    if wrk > ab[i][1]:
        print('No')
        exit()
    wrk += ab[i][0]

print('Yes')
# Judge status: Accepted
import sys
import numpy as np

ri = lambda: int(sys.stdin.readline())
rl = lambda: list(map(int, sys.stdin.readline().split()))

D = ri()
c = np.array(rl())
s = np.array([np.array(rl()) for _ in range(D)])
for lis in s:
  tmp_list = lis ** 2 / c**0.01
  max_idx = np.argmax(tmp_list)
  print(max_idx + 1)
# Judge status: Accepted
a,b,x=map(int,input().split())
a1=a//x
if a%x==0:
  a1-=1
b1=b//x
print(b1-a1)
# Judge status: Accepted
import itertools

n = int(input())
pos = []
for _ in range(n):
	x, y = map(int, input().split())
	pos.append([x, y])

def dist(lst):
	d = 0
	for i in range(n-1):
		lst1 = lst[i]
		lst2 = lst[i+1]
		d += ((lst1[0]-lst2[0])**2 + (lst1[1]-lst2[1])**2)**0.5
	return d

d = 0
p_lst = list(itertools.permutations(pos, n))

for v in p_lst:
	d += dist(v)
    
print(d / len(p_lst))
# Judge status: Accepted
import itertools
def main():
    n,m,k=map(int, input().split())
    a=[int(i) for i in input().split()]
    b=[int(i) for i in input().split()]
    a = [0]+list(itertools.accumulate(a))
    b = [0]+list(itertools.accumulate(b))
    res = 0
    j = m
    best=0
    for i in range(n+1):
        if(a[i]>k):
            break
        while(b[j] > k-a[i]):
            j-=1
        res = max(res,i+j)
    print(res)


if __name__ == '__main__':
    main()
# Judge status: Accepted
import sys
input = sys.stdin.readline

a = input()

if a.isupper():
    print("A")
else:
    print("a")
# Judge status: Wrong Answer
n = int(input())
a,b=[],[]

for i in range(n):
    x,y = map(int,input().split())
    a.append(x)
    b.append(y)
print(a,b)

a=list(reversed(a))
b=list(reversed(b))
print(a,b)

OK=0
for i in range(n):
    A=a[i]+OK
    if A<b[i]:
        ok=b[i]-A
    elif A==b[i]:
        continue
    else:
        ok=-(-A//b[i])*b[i]-A
    OK+=ok

print(OK)
# Judge status: Accepted
h , n = map(int, input().split())
a = [int(i) for i in input().split()]
if sum(a) >= h:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
n = int(input())

count = 0
for a in range(1,1000001):
  b = a
  while a*b < n:
    if a == b:
      count += 1
      b += 1
    else:
      count += 2
      b += 1
print(count)
# Judge status: Accepted
a,b,c = map(int,input().split())
if a+b+c>=22:
    print("bust")
else:
    print("win")
# Judge status: Accepted
import math

s = int(input())

x1 = math.ceil(math.sqrt(s))
y1 = 1
x2 = x1**2 - s
y2 = x1
x3 = 0
y3 = 0

print(x1, y1, x2, y2, x3, y3)
# Judge status: Wrong Answer
def main():
  import sys
  from  operator import itemgetter
  input=sys.stdin.readline
  n,m=map(int,input().split())
  works=[list(map(int,input().split())) for i in range(n)]
  
  works.sort(key=itemgetter(1,0),reverse=True)
  j,money=0,0
  for i in range(m):
    while j<n and works[j][0]>m-i:
      j+=1
    if j!=n:
      money+=works[j][1]
      j+=1
    else:
      break
  print(money)

if __name__=='__main__':
  main()
# Judge status: Wrong Answer
import math
a = int(input())
print(int((a * a * math.pi) / math.pi))
# Judge status: Accepted
S = input()
C = [S.count('a'),S.count('b'),S.count('c')]
if len(S) == 1:
  print('YES')
elif len(set(S)) == 1 or max(C)-min(C) > 1:
  print('NO')
else:
  print('YES')
# Judge status: Wrong Answer
N = int(input())
A = list(map(int, input().split()))

#%%
ans = 1
up = False
down = False
for n in range(N-1):
    if A[n] < A[n+1]:
        up = True
    elif A[n] > A[n+1]:
        down = True
    if up == True and down == True:
        ans += 1
        up = False
        down = False
# Judge status: Wrong Answer
A, B, C, K = map(int, input().split())
print(A-B if K % 2 == 1 else B-A)
# Judge status: Accepted
N = int(input())
S = []
for i in range(N):
    s = input()
    S.append(s)
print(len(set(S)))
# Judge status: Accepted
A, B = map(int, input().split())

ans = 0
for i in range(A, B+1):
    a = str(i)
    if all([a[i] == a[-i-1] for i in range(len(a))]):
        ans += 1
print(ans)
# Judge status: Accepted
import sys

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


def solve():
    a, b = map(int, input().split())
    if a < b:
        ans = str(a) * b
    else:
        ans = str(b) * a
    print(ans)


if __name__ == '__main__':
    solve()
# Judge status: Accepted
n,m=[int(i) for i in input().split()]

ab_list=[]
for i in range(n):
    a,b=[int(i) for i in input().split()]
    ab_list.append([a,b])
    
cd_list=[]
for i in range(m):
    c,d=[int(i) for i in input().split()]
    cd_list.append([c,d])
    
    
for i in range(n):
    len_list=[]
    for j in range(m):
        len=abs(ab_list[i][0]-cd_list[j][0])+abs(ab_list[i][1]-cd_list[j][1])
        len_list.append(len)
    print(len_list.index(min(len_list))+1)
# Judge status: Accepted
N, K = map(int, input().split())
A = list(map(int, input().split()))

ans = 0
for i, j in zip(range(N - 1), range(1, N)):
    Asum = A[i] + A[j]
    if Asum <= K:
        continue
    eat = Asum - K
    d = min(eat, A[j])
    A[j] -= d
    eat -= d
    ans += d
    d = min(eat, A[i])
    A[i] -= d
    ans += d

print(ans)
# Judge status: Accepted
N, M = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
B = []
for i in range(M):
  b, c = map(int, input().split())
  B.append([c, b])
B.sort(reverse=True)
i = 0
f = 0
for j in range(M):
  while B[j][1]:
    if A[i] < B[j][0]:
      A[i] = B[j][0]
      B[j][1] -= 1
      i += 1
      if i >= N:
        f = 1
        break
    else:
      f = 1
      break
  if f == 1:
    break
print(sum(A))
# Judge status: Wrong Answer
n,m = map(int, input().split())
if n == m:
    print('AC')
else:
    print('WA')
# Judge status: Accepted
n=int(input())
a=n-(n//2)
print(a/n)
# Judge status: Wrong Answer
N = int(input())

L = [2, 1]

if N <= 2:
   print(L[N-1])
else:
   for i in range(N-1):
      L.append(L[-1] + L[-2])

print(L[-1])
# Judge status: Wrong Answer
import math
a, b = map(int, input().split())
for i in range(1, 101):
  aa = math.floor(i*1.08)
  bb = math.floor(i*1.1)
  if aa - i == a and bb - i == b:
    print(i)
    exit()
print(-1)
# Judge status: Wrong Answer
import heapq
n,m = map(int,input().split())
ls = list(map(int,input().split()))
ls = list(map(lambda x:x*(-1),ls))
di = [list(map(int,input().split())) for _ in range(m)]
heapq.heapify(ls)
for i,j in di:
    for k in range(i):
        heapq.heappush(ls,j*(-1))
ls = list(ls)[n*(-1):]
print(sum(ls))
# Judge status: Accepted
n = int(input())
a = int(input())

n = n % 500

if n % 500 == 0:
    print('Yes')
else:
    n = n % 500
    if (n <= a):
        print('Yes')
    else:
        print('No')
# Judge status: Wrong Answer
A, B, C = map(int, input().split())
print('Yes' if A+B*2 >= C else 'No')
# Judge status: Wrong Answer
k =int(input())
a, b =map(int, input().split())

if a <= b/k*k:
  print('OK')
else:
  print('NG')
# Judge status: Accepted
import sys

readline = sys.stdin.readline

def main():
    N = int(readline())
    A = []
    for _ in range(N):
        A.append(int(readline())-1)
    check = [0]*N
    check[0] = 1
    nxt = 0
    ans = 1
    while True:
        nxt = A[nxt]
        if check[nxt] == 1:
            ans = -1
            break
        if nxt == 1:
            break
        check[nxt] = 1
        ans += 1
    print(ans)

if __name__ == "__main__":
    main()
# Judge status: Wrong Answer
W, H, x, y = map(int, input().split())
print(W*H/2, end=' ')
print(1 if x == y and W ==H else 0)
# Judge status: Accepted
import math
N = int(input())
for i in range(1,50001):
    if math.floor(i*1.08) == N:
        print(i)
        break
else:
    print(":(")
# Judge status: Accepted
n = int(input())

print((int((int(n) / 2))) + (int((int(n) % 2))))
# Judge status: Accepted
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
B = []
a = sum(A)
for i in A:
    if i >= a/(4*M):
        B.append(i)
if len(B) >= M:
    print('Yes')
else:
    print('No')
# Judge status: Wrong Answer
X,Y,Z=map(int,input().split())
print(int((X-Z*(Y+1))/Y))
# Judge status: Accepted
import math

a, b, x = map(int, input().split())
if a * a * b <= 2 * x:
    ans = math.degrees(math.atan((2 * (b - (x / (a * a))) / a)))
    print('{:.10f}'.format(ans))
else:
    ans = math.degrees(math.atan((a * b * b) / (2 * x)))
    print('{:.10f}'.format(ans))
# Judge status: Accepted
n=int(input())
ans=1
for i in range(1,n+1):
    ans=(ans*i)%(10**9+7)
print(ans)
# Judge status: Accepted
n=int(input())
h=list(map(int, input().split()))
dp=[0]*n
dp[1]=abs(h[1]-h[0])
for i in range(2,n):
  dp[i]=min(dp[i-1]+abs(h[i]-h[i-1]), dp[i-2]+abs(h[i]-h[i-2]))
print(dp[-1])
# Judge status: Accepted
n = int(input())
t, a = map(int, input().split())
h = list(map(int, input().split()))

def htemp(h):
    return abs(a - ((t * 1000) - (h * 6)) / 1000)

ans = list(map(htemp, h))
ans1 = ans.index(min(ans)) + 1

print(ans1)
# Judge status: Accepted
S = input()

tap_flag = True
for i in range(len(S)):
    if (i+1) % 2 == 0:
        if S[i] == "R":
            tap_flag = False
            break
    elif (i+1) % 2 == 1:
        if S[i] == "L":
            tap_flag = False
            break

if tap_flag == True:
    print("Yes")
else:
    print("No")
# Judge status: Wrong Answer
n = int(input())
s = sorted([int(input()) for _ in range(n)])
ans = sum(s)
for v in s:
  if ans%10!=0:
    print(ans)
    break
  if v%10==0:
    continue
  ans -= v
else:
  print(ans)
# Judge status: Accepted
import sys
input = sys.stdin.readline

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    mod=10**9+7
    a=[1,3,5,7,8,10,12]
    b=[4,6,9,11]
    x,y=MI()
    if (x in a and y in a) or (x in b and y in b):
        print("Yes")
    else:
        print("No")

main()
# Judge status: Accepted
a,b =map(int,input().split())

if (a<10) and (b<10):
    print(a*b)
else:
    print(-1)
# Judge status: Wrong Answer
N = input()
ans = 'Yes'
if N.isdecimal():
    ans = 'No'
    N = int(N)

    A = N % 4
    B = N % 7
    C = N % 11

    if A == 0:
        ans = 'Yes'
    elif B == 0:
        ans = 'Yes'
    elif C == 0:
        ans = 'Yes'
    elif C == 4:
        ans = 'Yes'
    elif C == 7:
        ans = 'Yes'
    elif C == 8:
        ans = 'Yes'
print(ans)
# Judge status: Accepted
A, B = map(int, input().split())
cnt = 0
for num in range(A, B+1):
    num = list(str(num))
    for i in range(len(num)//2):
        if num[i] != num[len(num)-i-1]:
            break
    else:
        cnt += 1
print(cnt)
# Judge status: Accepted
x=list(input())
ans=5000
for i in range(len(x)-2):
  ans=min(ans,int(abs(753-int(x[i]+x[i+1]+x[i+2]))))
print(ans)
# Judge status: Accepted
s = list(input())
lis = []

for i in s:
  if i == 'B':
    if len(lis) != 0:
      lis.pop()
  elif i == '0':
    lis.append('0')
  elif i == '1':
    lis.append('1')
    
print(''.join(lis))
# Judge status: Accepted
a,b,c = map(int,input().split())
if a+b >= c:
    print("Yes")
else:
    print("No")