peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Accepted
import numpy as np

N, M = map(int, input().split())

ab = []
for i in range(N):
    tmp = list(map(int, input().split()))
    ab.append(tmp)

ab = np.array(ab)
dist = np.full([N, M], np.inf)

for m in range(M):
    tmp = np.array(list(map(int, input().split())))
    for n in range(N):
        dist[n, m] = np.abs(ab[n] - tmp).sum()

dist = dist.astype("int")

for d in dist:
    print(d.argmin()+1)
# Judge status: Accepted
n = int(input())
q, r = divmod(n, 11)
if r == 0:
  print(q*2)
elif r <= 6:
  print(q*2 + 1)
else:
  print(q*2 + 2)
# Judge status: Accepted
def solve():
    X = int(input())
    ans = 1
    for b in range(1, X):
        for p in range(2, X):
            if b ** p <= X:
                ans = max(ans, b ** p)
            else:
                break
    print(ans)


if __name__ == "__main__":
    solve()
# Judge status: Accepted
n=int(input())
ln=[1,2,3,4,5,6,7,8,9]
ls=[]
for i in ln:
  for j in ln:
    ls.append(i*j)

if n in ls:
  print("Yes")
else:
  print("No")
# Judge status: Accepted
from itertools import combinations
from collections import Counter

N, X, Y = map(int, input().split())

C = Counter(min(abs(i - j), abs(X - i) + abs(Y - j) + 1, abs(X - j) + abs(Y - i) + 1) for i, j in combinations(range(1, N + 1), 2))

print("\n".join(str(C[k]) for k in range(1, N)))
# Judge status: Accepted
n,h=map(int,input().split())
x=[]
for i in range(n):
  a,b=map(int,input().split())
  x.append([a,0])
  x.append([b,1])
x.sort(reverse=1)
i=ans=0
while h>0:
  if x[i][1]:
    h-=x[i][0]
    ans+=1
  else:
    ans+=0--h//x[i][0]
    h=0
  i+=1
print(ans)
# Judge status: Wrong Answer
N = int(input())
A = list(map(int, input().split()))
import math
ans=0
for i in range(N, 0, -1):
    if A[i]>2**(i):
        ans=-1
        break
    if i!=0:
        q=math.ceil(A[i]/2)
        if q==0:
            q=1
        print(A[i]+q)
        ans=ans+A[i]+q
print(ans)
# Judge status: Accepted
n, a, b = map(int, input().split())

result = 0
result += (n // (a+b))*a
result += min(a, n%(a+b))
print(result)
# Judge status: Accepted
N = int(input())


for i in range(1, 8):
	if 2**i > N:
		print(2**(i-1))
		exit()
# Judge status: Accepted
S, W = map(int, input().split())

if W >= S:
    print('unsafe')
else:
    print('safe')
# Judge status: Wrong Answer
N = int(input())
cnt = []
for i in range(N):
    a, b = map(int, input().split())
    if a == b:
        cnt.append(1)
    else:
        cnt.append(0)

from itertools import groupby
for key, group in groupby(cnt):
    if  len(list(group)) >= 3:
        print('Yes')
        exit()
print('No')
# Judge status: Accepted
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7

d, n = MAP()
m = 100 ** d * n
if n == 100:
    m = 100 ** d * 101
print(m)
# Judge status: Accepted
import math


N,M = map(int,input().split())

ans_N=0
ans_M=0
if N != 0:
	ans_N=(N*(N-1))//2
if M != 0:
	ans_M=(M*(M-1))//2

print(ans_N+ans_M)
# Judge status: Wrong Answer
N, A, B = map(int, input().split())
ans = 0
for i in range(1, 1+N):
    s = str(i)
    if A <= sum(map(int, s)) <= B:
        ans += 1

print(ans)
# Judge status: Wrong Answer
N = int(input())
X=10**12
Y=10**12
flag = 0
for i in range(2,int(N**0.5)):
  if N%i==0:
    flag = 1
    temp = N//i
    if X+Y > temp+i:
      X = i
      Y = temp
      
if flag==0:
  X = N
  Y = 1
print(X+Y-2)
# Judge status: Accepted
'''
Created on 2020/08/20

@author: harurun
'''
def main():
  import sys
  pin=sys.stdin.readline
  pout=sys.stdout.write
  perr=sys.stderr.write
  
  X,Y=map(int,pin().split())
  if X%Y==0:
    print(-1)
    return 
  print(X)
  return 

main()
# Judge status: Accepted
a, b, k = map(int, input().split())
if k<=a:
    print(a-k, b)
elif a<k and k<=(a+b):
    print(0, b-(k-a))
else:
    print(0, 0)
# Judge status: Accepted
from collections import defaultdict

n,k=map(int,input().split())
l=list(map(int,input().split()))
a=defaultdict(int)
for i in l:
	a[i] += 1
a=list(a.items())
if len(a) <= k:
	print(0)
else:
	ans = 0
	a.sort(key = lambda x: x[1])
	for i in range(len(a) - k):
		ans += a[i][1]
	print(ans)
# Judge status: Accepted
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

N = int(input())
XY = [list(mapint()) for _ in range(N)]
XY.sort(key=lambda x:x[0]+x[1])
ans_1 = abs(XY[0][0]-XY[-1][0])+abs(XY[0][1]-XY[-1][1])
XY.sort(key=lambda x:x[0]-x[1])
ans_2 = abs(XY[0][0]-XY[-1][0])+abs(XY[0][1]-XY[-1][1])
print(max(ans_1, ans_2))
# Judge status: Accepted
import math
n=int(input(""))
mk=n//3
s=0
kaizyou=1
for i in range(1,mk+1):
    t=1
    
    a=math.factorial(i-1)
    for k in range(i-1):
        t*=(n-2*i-1-k)
        t%=a*(10**9+7)
        
            
    t/=a
    t%=(10**9+7)
    
    s+=t
    s%=(10**9+7)
print(int(s))
# Judge status: Wrong Answer
n, m = map(int, input().split())

m += n * 2

print(m // 4)
# Judge status: Accepted
k = int(input())
a, b = map(int, input().split())

f = False
for i in range(1, 1001):
  t = i * k
  if a <= t and t <= b:
    f = True
    break
  if t > b:
    break

if f:
  print('OK')
else:
  print('NG')
# Judge status: Accepted
a,b,n = map(int,input().split())
if n >= b-1: x = b-1
else: x = n
ans = (a * x) // b - a * (x // b)
print(ans)
# Judge status: Accepted
H1,M1,H2,M2,K=map(int, input().split())

min=(H2-H1)*60+M2-M1

print(min-K)
# Judge status: Accepted
N=int(input())
correct = True
words = set({})

W = input()
words.add(W)
last_letter = W[len(W)-1]

for i in range(1,N):
    W = input()
    if  not W in words and W[0] == last_letter:
        words.add(W)
        last_letter = W[len(W)-1]
    else:
        correct = False
        break

if correct:
    print('Yes')
else:
    print('No')
# Judge status: Wrong Answer
a,b = map(int, input().split())
print((a+b)/2) if (a+b)%2 == 0 else print("IMPOSSIBLE")
# Judge status: Accepted
n,h=map(int,input().split())
a=[0]*n
b=[0]*n
for i in range(n):
  a[i],b[i]=map(int,input().split())
ab=sorted(a+b)[::-1]
ans=0
for i in ab[:ab.index(max(a))]:
  h-=i
  ans+=1
  if h<=0:
    print(ans)
    exit()
ans+=(h+max(a)-1)//max(a)
print(ans)
# Judge status: Wrong Answer
s,t = map(str,input().split())
a,b = map(int,input().split())
u=input()

if s==u:
    print(a-1)

else:
    print(b-1)
# Judge status: Wrong Answer
x = int(input())

a = x//11
b = x%11
if b > 6: print(2*a+2)
else: print(2*a+1)
# Judge status: Accepted
a = [int(x) for x in input().split()]
a.sort(reverse=True)
print(a[0]*10+a[1]+a[2])
# Judge status: Wrong Answer
s = str(sorted(input()))
t = str(sorted(input()))[::-1]
print('Yes' if s < t else 'No')
# Judge status: Accepted
st = input()

list = (st.split())

print(list[1]+list[0])
# Judge status: Wrong Answer
a,b = map(int, input().split())
res = 0
c = 1
while c < b:
  c += a - 1
  res += 1
  print(res)
# Judge status: Wrong Answer
from math import sqrt,factorial
n = int(input())
l = []
for i in range(n):
  d = list(map(int,input().split()))
  l.append(d)
x = 2//n
ans = 0
for i in range(n-1):
  for j in range(i+1,n):
    ans += x*sqrt(((l[i][0]-l[j][0])**2 + (l[i][1]-l[j][1])**2))
print(ans)
# Judge status: Wrong Answer
a = str(input())
boin = ["a","e","i","o","u"]
if a in boin:
    print("voewl")
else:
    print("consonant")
# Judge status: Accepted
x, a, b = map(int, input().split())
if -a+b <= 0:
    print('delicious')
elif 0 < -a+b <= x:
    print('safe')
else:
    print('dangerous')
# Judge status: Accepted
n, m = map(int, input().split())
a = []
b = []
for _ in range(n):
  a.append(input())
for _ in range(m):
  b.append(input())

def detect(i, j):
  flag = True
  for k in range(len(b)):
    for l in range(len(b)):
      if i+k >= n or j+l >= n or a[i+k][j+l] != b[k][l]:
        flag = False
        break
    if not flag:
      break
  return flag
  
ans = "No"
for i in range(len(a)):
  for j in range(len(a)):
    if detect(i, j):
      ans = "Yes"
      break
  if ans == "Yes":
    break
print(ans)
# Judge status: Wrong Answer
n,k = map(int,input().split())
p = list(map(int,input().split()))
p.sort()
print(sum(p[:3]))
# Judge status: Wrong Answer
x = int(input())

ans = 0
for i in range(x + 1):
    if i * i > x: break
    ans = i * i
print(ans)
# Judge status: Wrong Answer

N=int(input())

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

A.sort()
B.sort()

if N%2==0:
    sca=scb=N//2-1
    lca=lcb=N//2
    x=A[lca]+A[sca]
    y=B[lcb]+B[lcb]
    print(x-y+1)
    
    
else:
    ca=cb=N//2
    ans=B[cb]-A[ca]+1
    print(ans)
# Judge status: Accepted
n = int(input())

print(800 * n - 200 * int(n / 15))
# Judge status: Wrong Answer
a, b, c = map(int, input().split())
max_num = max(a, b, c)
if max_num % 2 == 0:
    max_num += 1
print(int((max_num * 3 - (a + b + c)) / 2))
# Judge status: Wrong Answer
X = int(input())

for A in range(10**18):
    diff = X - A**5
    if diff < 0:
        minus_flg = False
        diff = abs(diff)
    else:
        minus_flg = True
    B = pow(diff, 0.2)
    if (isinstance(B, float)) and B.is_integer():
        break
if minus_flg:
    B = int(B)*-1
print(A, int(B))
# Judge status: Wrong Answer
n = int(input()); s = input()
a = [0]*26; b = 1
for i in range(n): a[ord(s[i])-97] += 1
for i in range(26): b *= a[i]+1
print(b-1)
# Judge status: Accepted
n = int(input())
k = int(input())
x = int(input())
y = int(input())
print(min(n, k) * x + max(n - k, 0) * y)
# Judge status: Accepted
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 = 0
j = m
for i in range(0, n+1):
    if a[i] > k:
        break
    while b[j] > k - a[i]:
        j -= 1
    ans = max(ans, i+j)

print(ans)
# Judge status: Wrong Answer
n, m = map(int, input().split())
d = []
for _ in range(n):
    a, b = map(int, input().split())
    d.append((b, a))
d.sort(reverse=True)

cnt = m
ans = 0
i = 0
while i < min(n, m):
    if d[i][1] <= cnt:
        ans += d[i][0]
        i += 1
        cnt -= 1
    else:
        i += 1
print(ans)
# Judge status: Accepted
H, N = map(int, input().split())
attacks = list(map(int, input().split()))
if sum(attacks) >= H:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
a = int(input())
b = int(input())

if a != 3 and b != 3:
    print(3)
elif a != 2 and b != 2:
    print(2)
else:
    print(1)
# Judge status: Accepted
k = int(input())
lis = [1,2,3,4,5,6,7,8,9]
i=0
while len(lis) < k:
	m = lis[i]%10
	if m != 0:
		lis.append(int(str(lis[i])+str(m-1)))
	lis.append(int(str(lis[i])+str(m)))
	if m!= 9:
		lis.append(int(str(lis[i])+str(m+1)))
	i+=1
print(lis[k-1])
# Judge status: Accepted
s=list(input())
t=list(input())

u=sorted(s)
v=sorted(t,reverse=True)

print("Yes" if u<v else "No")
# Judge status: Accepted
s, t = map(str, input().split())
print(t+s)
# Judge status: Accepted
n = int(input())
l = [2, 1]
for i in range(2, n+1):
    l.append(l[i-2]+l[i-1])
print(l[-1])
# Judge status: Wrong Answer
S=input()
SET=set(list(S))

if ("h" in SET) and ("i" in SET) and len(SET)==2:
  print("Yes")
else:
  print("No")
# Judge status: Wrong Answer
N=int(input())

a=N/1080
if int(a*1080)==N:
    print(a)
else:
    print(':(')
# Judge status: Accepted
import math
n = int(input())
a = list(map(int,input().split()))
r ,l = [0] * (n),[0] * (n)
l[0] = 0
r[n-1] = 0
for i in range(1,n):
    l[i] = math.gcd(l[i-1],a[i-1])
    r[n-i-1] = math.gcd(r[n-i],a[n-i])
m = [0] * n
for i in range(n):
    m[i] = math.gcd(l[i],r[i])
print(max(m))
# Judge status: Accepted
n, k = list(map(int, input().split()))
h = list(map(int, input().split()))

h.sort()
h.reverse()

if k == 0:
  print(sum(h))
else:
  print(sum(h[k:]))
# Judge status: Accepted
a,b = map(int,input().split())
if a <= b:
  print(a)
else:
  print(a-1)
# Judge status: Accepted
n, r = map(int, input().split())
if n >= 10:
    print(r)
else:
    print(r + 100 * (10 - n))
# Judge status: Accepted
x = int(input())
n = x//11
k = x%11
if k==0:
    print(2*n)
elif 1<=k<=6:
    print(2*n+1)
else:
    print(2*(n+1))
# Judge status: Accepted
n=int(input()[-1])
if n==3:
    res="bon"
elif n in [0,1,6,8]:
    res="pon"
else:
    res="hon"
print(res)
# Judge status: Accepted
N=int(input())
for i in range(-200,200):
    for j in range(-200,200):
        if i**5-j**5==N:
            a=i
            b=j
print(a,b)
# Judge status: Wrong Answer
N, M = map(int, input().split())
A = sorted(list(map(int, input().split())), reverse = True)

for _ in range(0, M, 1):
	A[0] >>= 1
	for i in range(1, len(A), 1):
		if A[i] < A[i - 1]:
			A[i], A[i - 1] = A[i - 1], A[i]
		else:
			break

print(sum(A))
# Judge status: Wrong Answer
import math

def search_divide_minimum_number(n, check_list):
    num = n
    for i in range(2, int(math.sqrt(n))+1):
        if (n%i == 0)&(not i in check_list):
            num = i
            break
    return num

if __name__ == "__main__":
    N = int(input())
    check_list = []
    while(N != 1):
        factor = search_divide_minimum_number(N, check_list)
        if not factor in check_list:
            check_list.append(factor)
        N //= factor
    
    print(len(check_list))
# Judge status: Wrong Answer
##A
s = input()
if s[2] == s[3] and s[4] == s[5]:
    print("yes")
else:
    print("No")
# Judge status: Accepted
k, toayen, fromayen = map(int, input().split())
ans1 = k + 1
k -= (toayen - 1)
d, m = divmod(k, 2)
ans2 = (fromayen - toayen) * d + toayen + m
print(max(ans1, ans2))
# Judge status: Accepted
N = int(input())
S = list(input())
ans = 0
for i in range(N):
  A = S[:i]
  B = S[i:]
  C = list(set(A) & set(B))
  #print(C)
  c = len(C)
  if c > ans:
    ans += 1

print(ans)
# Judge status: Wrong Answer
N, A, B = map(int,input().split())

a = 0

for i in range(1,N+1):
    c = i//1000 + (i%1000)//100 + (i%100)//10 +i%10
    if (A<= c) and (c <= B):
        a +=i

print(a)
# Judge status: Accepted
n = int(input())
list_a = []
list_b = []
for i in range(n):
    a,b = (int(x) for x in input().split())
    list_a.append(a)
    list_b.append(b)
list_a.sort()
list_b.sort()

if n%2==0:
    mi = (list_a[int(n/2)]+list_a[int(n/2)-1])/2
    ma = (list_b[int(n/2)]+list_b[int(n/2)-1])/2
    print(int((ma-mi)*2+1))
else:
    mi = list_a[int((n-1)/2)]
    ma = list_b[int((n-1)/2)]
    print(int(ma-mi+1))
# Judge status: Wrong Answer
A, B, C = map(int, input().split())

if A == B == C:
    print(-1)
else:
    ans = 0
    while A%2 == B%2 == C%2 == 0:
        A, B, C = (B+C)//2, (C+A)//2, (A+B)//2
        ans += 1
    print(ans)
# Judge status: Accepted
n = int(input())
s = input()
mod = 10**9 + 7

ans = 0
cnt = [1] * 26
for i,ch in enumerate(s):
    tmp = 1
    for j in range(26):
        if(j==(ord(ch) - 97)):
            continue
        tmp *= cnt[j]
        tmp %= mod
    ans += tmp
    ans %= mod
    cnt[ord(ch) - 97] += 1

print(ans)
# Judge status: Wrong Answer
x,y,z = map(int,input().split())
y %= 4
if y == 0:
    if z % 4 ==0:
        print("YES")
        exit()
if y == 1:
    if z % 4 == 2:
        print("Yes")
        exit()
if y == 2:
    if z % 4 == 0:
        print("Yes")
        exit()
if y == 3:
    if z % 4 == 2:
        print("Yes")
        exit()
print("No")
# Judge status: Accepted
from fractions import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import accumulate, product, permutations, combinations

def main():
    A, s, C = input().split()

    print(A[0] + s[0] + C[0])

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

if a > 0:
    print("Positive")
elif a == 0:
    print("Zero")
else:
    if b >= 0:
        print("Zero")
    else:
        if (b - a) % 2 != 0:
            print("Positive")
        else:
            print("Negative")
# Judge status: Accepted
N, W = map(int, input().split())
wt, vt = [], []
for _ in range(N):
    w, v = map(int, input().split())
    wt.append(w)
    vt.append(v)

dp = [[0] * (W + 5) for _ in range(105)]

for i in range(N):
    for j in range(W + 1):
        dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
        if 0 <= j - wt[i]:
            dp[i + 1][j] = max(dp[i + 1][j], dp[i][j - wt[i]] + vt[i])
# print(dp)
print(dp[N][W])
# Judge status: Accepted
import sys
sample = sys.stdin.read().splitlines()
N = int(sample[0])
points = [list(map(int, sample[current_day].split())) for current_day in range(1, N+1)]
dp = points[0]
ans = max(dp)
for point in points[1:]:
	for idx, num in enumerate(point):
		point[idx] = point[idx]+max(dp[(idx+1)%len(point)], dp[(idx+2)%len(point)])
	dp = point
	ans = max(ans, max(point))
print(ans)
# Judge status: Accepted
N, M = map(int, input().split())
list_a = [int(x) for x in input().split()]

import fractions

def insu2(a) :
    insu = 0
    while a%2 == 0 :
        insu += 1
        a /= 2
    return insu

check = True

for i in list_a :
    if insu2(i) != insu2(list_a[0]) :
        print(0)
        exit()

ans_0 = list_a[0]
for i in range(1,N) :
    ans_0 = ans_0 * list_a[i] // fractions.gcd(ans_0, list_a[i])

ans_0 //= 2
ans = M//ans_0 - M//(ans_0*2)

print(ans)
# Judge status: Accepted
n = int(input())
t,a = map(int,input().split())
h = list(map(int,input().split()))
dif = 10**10
ans = 0
for i in range(n):
    z = t-h[i]*0.006
    if dif>abs(a-z):
        dif = abs(a-z)
        ans = i+1
print(ans)
# Judge status: Accepted
N=input()
ans=0
for i in N:
    ans+=int(i)
if ans%9==0:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
s = input()
a = [int(c) for c in s]
b = 0
for i in a:
  if i == 1:
    b += 1
 
print(b)
# Judge status: Wrong Answer
n=int(input())
print(-n+n*(n+1)/2)
# Judge status: Accepted
def func(n, a):
    mx = max(a)
    x = [0] * (mx + 1) # len(x)
    for i in a:
        x[i] += 1
    for i in range(1, mx + 1):
        if x[i] != 0:
            for j in range(2 * i, mx + 1, i):
                x[j] = 0
        if x[i] > 1:
            x[i] = 0
    print(sum(x)) # 31401

n = int(input())
a = list(map(int, input().split()))
func(n, a)
# Judge status: Accepted
n=int(input())
a=list(map(int,input().split()))
ans=[0]*9
for i in range(n):
  if a[i]<400:
    ans[0]=1
  elif a[i]<800:
    ans[1]=1
  elif a[i]<1200:
    ans[2]=1
  elif a[i]<1600:
    ans[3]=1
  elif a[i]<2000:
    ans[4]=1
  elif a[i]<2400:
    ans[5]=1
  elif a[i]<2800:
    ans[6]=1
  elif a[i]<3200:
    ans[7]=1
  else:
    ans[8]+=1
print(max(sum(ans[:8]),1),sum(ans))
# Judge status: Accepted
A, B, C = map(int, input().split())
if A+B < C:
    print("No")
else:
    print("Yes")
# Judge status: Wrong Answer
a, b, c = map(int, input().split())

if a<=c:
  if c>=c:
    print('Yes')
else:
  print('No')
# Judge status: Accepted
from sys import stdin
import fractions

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

n,m = [int(x) for x in stdin.readline().rstrip().split()]

if lcm(n,m) == n:
    print(-1)
else:
    print(n)
# Judge status: Accepted
n=int(input())
p=list(map(int,input().split()))
ans=0
for i in range(1,n-1):
    if p[i-1]<p[i]<p[i+1] or p[i+1]<p[i]<p[i-1]:
        ans+=1
print(ans)
# Judge status: Accepted
a,b,c=map(int,input().split())
d=max(a,b,c)
if d==a:
  if d==b+c:
    print('Yes')
  else:
    print('No')
elif d==b:
  if d==a+c:
    print('Yes')
  else:
    print('No')
elif d==c:
  if d==a+b:
    print('Yes')
  else :
    print('No')
# Judge status: Wrong Answer
from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(10 ** 7)

n = int(stdin.readline().rstrip())
s = [stdin.readline().rstrip() for _ in range(n)]
li = list(s[0])
for i in s:
    for j in li:
        if j not in i:
            li.remove(j)
li.sort()
print("".join(li))
# Judge status: Wrong Answer
N = int(input())
a = list(map(int, input().split()))

cnt = 0
for i in range(N):
    if i % 2 == 1 and a[i] % 2 == 1:
        cnt += 1

print(cnt)
# Judge status: Accepted
a, b = map(int, input().split())
if (a*b)%2 ==0:
    print('Even')
else:
    print('Odd')
# Judge status: Accepted
S = input()
N = len(S)
A = [0] * (N + 1)
for i in range(N):
    if S[i] == '<':
        A[i + 1] = A[i] + 1
for i in range(N - 1, -1, -1):
    a = A[i + 1] + 1
    if S[i] == '>' and a > A[i]:
        A[i] = a
print(sum(A))
# Judge status: Accepted
N = int(input())
ans = 0

for i in range(1, N + 1):
  if len(str(i)) % 2 == 1:
    ans += 1

print(ans)
# Judge status: Accepted
n = int(input())
s = list(input())
t = list(input())
cnt = 0
for i in range(min(len(s), len(t))):
    c = 0
    for j in range(i + 1):
        if s[len(s) - 1 - i + j] == t[j]:
            c += 1
    cnt = max(cnt, c)
ans = len(s) + len(t) - cnt
if ans < n:
    ans = n
print(ans)
# Judge status: Accepted
s=input()

if s[2] == s[3] and s[4] == s[5]:
  print("Yes")
else:
  print("No")
# Judge status: Wrong Answer
#入力例は合うがWAになる

S = str(input())
T = str(input())

if S[0]==T[2] and S[1]==T[1] and S[2]==T[0]:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
# https://atcoder.jp/contests/arc099/tasks/arc099_a
n, k = map(int, input().split())
nums = [int(i) for i in input().split()]

ans = (len(nums) - 1) // (k - 1)
if (len(nums) - 1) % (k - 1) != 0:
    ans += 1
print(ans)
# Judge status: Wrong Answer
# coding: utf-8
s1 = input()
s2 = input()
s2 = s2[-1]

if s1 == s2:
    print("Yes")
else:
    print("No")
# Judge status: Wrong Answer
x = int(input())
ans = 1
for i in range(35):
    for j in range(15):
        if i**j > x:
            break
        else:
            ans = max(i**j,ans)
print(ans)
# Judge status: Accepted
n = int(input())
a = list(map(int,input().split()))

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

l = [0] * (n + 1)
r = [0] * (n + 1)
for i in range(n):
    l[i + 1] = gcd(l[i], a[i])

for i in reversed(range(n)):
    r[i] = gcd(r[i + 1], a[i])

ans = 0
for i in range(n):
    ans = max(ans, gcd(l[i], r[i + 1]))

print(ans)
# Judge status: Accepted
c = (input())
list =['a','i','u','e','o']
if c in list:
    print('vowel')
else:
    print('consonant')
# Judge status: Wrong Answer
N = int(input())

A = list(map(int, input().split()))

for i in range(len(A)-1):
  before = A[i] + A[i+1]
  after = -1*A[i] + (-1)*A[i+1]

  if A[i] >= 0:
    continue

  if A[i] < 0 and i != len(A)-1:
    A[i] *= -1
    A[i+1] *= -1 
    continue

  if after >= before:
    A[i] *= -1
    A[i+1] *= -1

print(sum(A))
# Judge status: Accepted
k = int(input())
print(int((k/2)**2))
# Judge status: Accepted
n, k, q = map(int, input().split())
sc = [k - q] * n

for i in range(q):
    sc[int(input()) - 1] += 1

for j in sc:
    print('Yes' if j > 0 else 'No')
# Judge status: Wrong Answer
A, B = map(int, input().split())
for i in range(1, 101):
    if (i * 0.08) // 1 == A and (i * 0.1) // 1 == B:
        print(i)
        exit(0)

print(-1)
# Judge status: Accepted
a,b,h=[int(input()) for i in range(3)]
print((a+b)*h//2)
# Judge status: Accepted
H = int(input())

def attackNum(H):
    if H == 1:
        return 1
    else:
        return 2 * attackNum(H // 2) + 1

print(attackNum(H))
# Judge status: Accepted
S = input()
prev = True
ans = 0
cnt = 0
for i in range(3):
  if S[i] == 'R':
    if prev:
      cnt += 1
    else:
      prev = True
      cnt = 1
  else:
    ans = max(ans, cnt)
    cnt = 0
    prev = False
print(max(ans, cnt))
# Judge status: Wrong Answer
s=list(map(int,input().split()))
print('Yes' if sum(s)%2==0 else 'No')