Harryxun/stf_run huggingface dataset:
bfr = [[[0 for _ in range(10)] for _ in range(3)] for _ in range(4)]

n = int(input())
for _ in range(n):
    b, f, r, v = map(int, input().split())
    bfr[b-1][f-1][r-1] += v
for b in range(4):
    for f in range(3):
        print(' ' + ' '.join(map(str, bfr[b][f])))
    if b != 3:
        print('#'*20)


### FIXED CODE ###

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

for i in range(n):
    s = 0
    for j in range(m):
        s += a[i][j] * b[j]
    print(s)
n = int(input())
    li = [sorted(list(input())) for i in range(n)]
     
    li2 = []
    for i in range(len(li)):
        li2.append(li.count(li[i]))
     
    li3 = list(set(li2))
        
    num = 0   
    if len(li3) <=1:
      print(0)
    for i in range(len(li3)):
        if li3[i] >= 2:
            num += li3[i]*(li3[i]-1)//2        
     
    print(num)

### FIXED CODE ###

n = int(input())
from collections import Counter
li = []
for i in range (n):
    li.append(sorted(input()))
li.sort()
for i in range(n):
    li[i]="".join(li[i])

d = Counter(li)
L = list(d.values())

cnt = 0
for i in range(len(L)):
    cnt += L[i]*(L[i]-1)//2
print(cnt)
K = int(input())
score = input().split()
if int(score[0] < K):
	if int(int(score[0])/K) < int(int(score[1])/K):
		print('OK')
	else:
		if int(score[0]) % K == int(score[1]) % K:
			print('OK')
		else:
			print('NG')

### FIXED CODE ###

K = int(input())
score = input().split()
s1 = int(score[0])
s2 = int(score[1])
if ( s1 % K ) == 0:
		print('OK')
elif ( s2 % K ) == 0:
		print('OK')
elif ( s1 // K ) < ( s2 // K ):
		print('OK')
else:
		print('NG')
x = input()
y = x**3
print(y)


### FIXED CODE ###

x=int(input())
print(x*x*x)
import sys
import math

line = input()
N = line.split(' ')[0]
D = line.split(' ')[1]

count = 0

for i in range(1,int(D)):
  inputs = input()
  X = int(inputs.split(' ')[0])
  Y = int(inputs.split(' ')[1])
  if(math.sqrt(pow(X,2) + pow(Y,2)) <= int(D) ):
    count = count + 1

print(count)

### FIXED CODE ###

import sys
import math

line = input()
N = line.split(' ')[0]
D = line.split(' ')[1]

count = 0

for i in range(int(N)):
  inputs = input()
  X = int(inputs.split(' ')[0])
  Y = int(inputs.split(' ')[1])
  if(math.sqrt(pow(X,2) + pow(Y,2)) <= int(D) ):
    count = count + 1

print(count)
a=input()
b=input()
print a*b
print a*2+b*2

### FIXED CODE ###

a,b=map(int,raw_input().split())
print a*b,a*2+b*2
n,k=map(int, input().split())
a=map(int, input().split())
print(N-K+1)

### FIXED CODE ###

n, k = map(int, input().split())
a = list(map(int, input().split()))
ans = 0
for i in range(1, n, k - 1):
    ans += 1
print(ans)
import sys
import math

readline = sys.stdin.readline
readall = sys.stdin.read
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prl = lambda x: print(*x ,sep='\n')

a,b = input().split(' ')
a = int(a)
b = float(b)
t = str(b).replace('.','')
res = 0
for i in range(3):
    res += int(str(t)[i]) * a // (10 ** i)
print(int(res))

### FIXED CODE ###

import sys
import math

readline = sys.stdin.readline
readall = sys.stdin.read
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prl = lambda x: print(*x ,sep='\n')

a,b = input().split(' ')
ash_1 = int(a[-1])
ash_2 = int(a[-2:])
bsh_1 = int(b[-2])
bsh_2 = int(b[-1])
bsh_0 = int(b[0])
kuri = (ash_1*bsh_1*10 + ash_2*bsh_2) //100
if len(a) == 1:
    res = int(a)*bsh_0 + kuri
elif len(a) == 2:
    a1 = a[:-1]
    res = int(a)*bsh_0 + int(a1)*bsh_1 + kuri
else:
    a1 = a[:-1]
    a2 = a[:-2]
    res = int(a)*bsh_0 + int(a1)*bsh_1 + int(a2)*bsh_2 + kuri
print(res)
import itertools


X = int(input())
ans_A = 0
ans_B = 0
for i, j in itertools.combinations(range(0, 1000), 2):
    j *= -1
    if i**5 - j**5 == X:
        ans_A = i
        ans_B = j
        break
if ans_A == 0 and ans_B == 0:
    for i, j in itertools.combinations(range(0, 1000), 2):
        if i**5 - j**5 == X:
            ans_A = i
            ans_B = j
            break
print(ans_A, ans_B)


### FIXED CODE ###

S = input()
if S == 'ABC':
    print('ARC')
else:
    print('ABC')
A=?????¨?????¨??????????????? = int(input())
B=??????????????? = int(input())
C=?????£????????????????????????????????????????????? = int(input())
D=?????£??????????§£?????????????????????????????? = int(input())
E=?????£?????????????????????????????????????????????????????? = int(input())

if A>0:
	print((B-A)*E)
else:
	print(C*abs(A)+D+E*B)

### FIXED CODE ###

A,B,C,D,E=[int(input())for i in range(5)]
if A>0:print((B-A)*E)
else:print(C*abs(A)+D+E*B)
A,B,K = map(int,input().split())
hoge=[]

for i in range(1,101):
  if (A%i == 0 and B%i ==0):
    hoge.append(i)

print(hoge[K-1])


### FIXED CODE ###

A,B,C = map(int,input().split())

if B - A*C >= 0:
  print(C)
else:
  print(B//A)
# -*- coding: utf-8 -*-

n, m = map(int, input().split())
friend_list = []
friend_list2 = []
for i in range(m):
  a, b = map(int, input().split())
  friend_list.append([a, b])
while friend_list:
  friend = friend_list.pop()
  if not friend_list2:
    friend_list2.append(friend)
  else:
    temp_list = friend_list2.copy()
    for i in temp_list:
      if friend[0] in i:
        i.append(friend[1])
        break
      elif friend[1] in i:
        i.append(friend[0])
        break
      else:
        friend_list2.append(friend)
friend_list3 = []
for i in friend_list2:
  friend_list3.append(set(i))
friend_list2 = []
for i in friend_list3:
  friend_list2.append(len(i))
print(max(friend_list2))

### FIXED CODE ###

# -*- coding: utf-8 -*-
import numpy
class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

n, m = map(int, input().split())
uf = UnionFind(n)
for i in range(m):
    a, b = map(int, input().split())
    uf.union(a-1, b-1)
answer = []
for i in range(n):
    answer.append(uf.size(i))
print(max(answer))
map={'A':'T','C':'G','G':'C','T':'A'}
inp=input()
return map[inp]

### FIXED CODE ###

map={'A':'T','C':'G','G':'C','T':'A'}
inp=input()
print(map[inp])
N, K = [int(i) for i in input().split()]
print(K*((K-1)**(N-1)))

### FIXED CODE ###

s=set(input().split())
print(len(s))
def fib(x):
  if x=0:
    return 0
  elif x=1 or x=2
  	return 1
  else
  	return fib(x-2)+fib(x-1)

N,M=(int(x) for xin input().split())
a=[int(input()) for i in range(M)]
x=1
for i in range(1,M):
  x*=fib(a[i]-a[i-1])

print (a%((10e+9)+7))

### FIXED CODE ###

N,M=(int(x) for x in input().split())
a=[int(input()) for i in range(M)]

x=[0]*(N+1)
j=0
if N!=0:
    x[0]=1
if N>1 and M!= 0 and a[0]==1:
    j+=1
else:
    x[1]=1

for i in range(2,N+1): 
    if j==M or i!=a[j]:
        x[i]=x[i-1]+x[i-2]
    else:
        x[i]=0
        j+=1
print(int(x[N]%(1000000007)))
N,M = map(int,input().split())
order = {}
if N==1 and M==0:
  print(0)
else:
  for i in range(M):
    s,c = map(int,input().split())
    if order.get(s,x)==x:
        order[s]=c
    elif order.get(s,x)!=x and order[s]!=c:
        print(-1)
        break
  else:
    moji = [1]+[0]*(N-1)
    for k in order.keys():
        moji[k-1]=order[k]
    if N!=1 and moji[0]==0:
      print(-1)
    else:
      print(''.join([str(a) for a in moji]))


### FIXED CODE ###

N,M = map(int,input().split())
order = {}
if N==1 and M==0:
  print(0)
else:
  for i in range(M):
    s,c = map(int,input().split())
    if order.get(s,57)==57:
        order[s]=c
    elif order.get(s,57)!=57 and order[s]!=c:
        print(-1)
        break
  else:
    moji = [1]+[0]*(N-1)
    for k in order.keys():
        moji[k-1]=str(order[k])
    if N!=1 and moji[0]=='0':
      print(-1)
    else:
      ans = [str(a) for a in moji]
      print(''.join(ans))
m=[list(map(int,input().split()))for i in range(3)]
ans=1
if m[0][0]-m[1][0]!=m[0][1]-m[1][1]:
  ans=0
if m[0][0]-m[1][0]!=m[0][2]-m[1][2]:
  ans=0
if m[0][0]-m[2][0]!=m[0][1]-m[2][1]:
  ans=0
if m[0][0]-m[2][0]!=m[0][2]-m[2][2]:
  ans=0
if m[0][0]-m[0][1]!=m[1][0]-m[1][1]:
  ans=0
if m[0][0]-m[0][1]!=m[2][0]-m[2][1]:
  ans=0
if m[0][0]-m[0][2]!=m[1][0]-m[1][2]:
  ans=0
if m[0][0]-m[0][2]!=m[2][0]-m[2][2]:
  ans=0
print("YNeos"[and::2])

### FIXED CODE ###

m=[list(map(int,input().split()))for i in range(3)]
ans=0
if m[0][0]-m[1][0]!=m[0][1]-m[1][1]:
  ans=1
if m[0][0]-m[1][0]!=m[0][2]-m[1][2]:
  ans=1
if m[0][0]-m[2][0]!=m[0][1]-m[2][1]:
  ans=1
if m[0][0]-m[2][0]!=m[0][2]-m[2][2]:
  ans=1
if m[0][0]-m[0][1]!=m[1][0]-m[1][1]:
  ans=1
if m[0][0]-m[0][1]!=m[2][0]-m[2][1]:
  ans=1
if m[0][0]-m[0][2]!=m[1][0]-m[1][2]:
  ans=1
if m[0][0]-m[0][2]!=m[2][0]-m[2][2]:
  ans=1
print("YNeos"[ans::2])
N, M = map(int, input().strip().split(" "))


p = []
s = []
ans = [0]*N
c_wa = [0]*N
c_sum = 0

for i in range(M):
    temp1, temp2 = input().strip().split(" ")
    p.append(int(temp1))
    s.append(str(temp2))
  

for j in range(M):
    
    if s[j] == "WA":
        if ans[p[j]-1] == 0:
            c_wa[p[j]-1] += 1
        elif ans[p[j]-1] == 1:
            pass
        
                
            
    elif s[j] == "AC":
        if ans[p[j]-1] == 0:
            ans[p[j]-1] += 1
        elif ans[p[j]-1] == 1:
            pass
    
for j in range(N):
    if ans[p[j]-1] == 1:
        c_sum += c_wa[p[j]-1]
        
            
print(sum(ans), c_sum)

### FIXED CODE ###



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


p = []
s = []
ans = [0]*N
c_wa = [0]*N
pena = 0

for i in range(M):
    temp1, temp2 = input().strip().split(" ")
    p.append(int(temp1))
    s.append(str(temp2))
  

for j in range(M):
    
    if s[j] == "WA":
        if ans[p[j]-1] == 0:
            c_wa[p[j]-1] += 1
        elif ans[p[j]-1] == 1:
            pass
        
                
            
    elif s[j] == "AC":
        if ans[p[j]-1] == 0:
            ans[p[j]-1] += 1
        elif ans[p[j]-1] == 1:
            pass
        
for k in range(N):
    if ans[k] == 1:
        pena += c_wa[k]
    

            
print(sum(ans), pena)
for _ in[0]*int(input()):
 a,b,c,d,e,f=map(int,input().split())
 x=((a*a+b*b)*(d-f)+(c*c+d*d)*(f-b)+(e*e+f*f)*(b-d))/2/(a*(d-f)+c*(f-b)+e*(b-d))
 y=((a*a+b*b)*(c-d)+(c*c+d*d)*(e-a)+(e*e+f*f)*(a-c))/2/(b*(c-e)+d*(e-a)+f*(a-c))
 print(f"{x:.4} {y:.4} {(x*x+y*y)**.5:.4}")


### FIXED CODE ###

for _ in[0]*int(input()):
 a,b,c,d,e,f=map(float,input().split())
 s,t,u=a*a+b*b,c*c+d*d,e*e+f*f
 x=(s*(d-f)+t*(f-b)+u*(b-d))/2/(a*(d-f)+c*(f-b)+e*(b-d))
 y=(s*(c-e)+t*(e-a)+u*(a-c))/2/(b*(c-e)+d*(e-a)+f*(a-c))
 print(f'{x:.3f} {y:.3f} {((x-a)**2+(y-b)**2)**.5:.3f}')
import sys
input = sys.stdin.buffer.readline

#sys.setrecursionlimit(10**9)
#from functools import lru_cache

def RD(): return input().rstrip().decode()
def II(): return int(input())
def FI(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode()

from collections import deque

def main():
	h,w,m=MI()
	A=[0]*(h+1)
	B=[0]*(w+1)
	C=[[] for _ in range(h+1)]

	for _ in range(m):
		hh,ww=MI()
		A[hh]+=1
		B[ww]+=1
		C[hh].append(ww)


	for i in range(h+1):
		C[i].sort()

	AA=max(A)
	BB=max(B)

	x=[]
	y=[]

	for i,v in enumerate(A):
		if v==AA:
			x.append(i)

	for i,v in enumerate(B):
		if v==BB:
			y.append(i)

	#print(x,y,AA,BB)
	ans=0

	for i in x:
		#print("a")
		#print(C[i])
		#print(y)
		a=0
		for j in y:
			while True:
				if j==C[i][a]:
					a+=1
					break
				elif j<C[i][a]:
					print(AA+BB)
					exit()
				else:
					break

	print(AA+BB-1)
















if __name__ == "__main__":
	main()


### FIXED CODE ###

import sys
input = sys.stdin.buffer.readline

#sys.setrecursionlimit(10**9)
#from functools import lru_cache

def RD(): return input().rstrip().decode()
def II(): return int(input())
def FI(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode()

from collections import deque

def main():
	h,w,m=MI()
	A=[0]*(h+1)
	B=[0]*(w+1)
	C=[[] for _ in range(h+1)]

	for _ in range(m):
		hh,ww=MI()
		A[hh]+=1
		B[ww]+=1
		C[hh].append(ww)


	for i in range(h+1):
		C[i].sort()

	AA=max(A)
	BB=max(B)

	x=[]
	y=[]

	for i,v in enumerate(A):
		if v==AA:
			x.append(i)

	for i,v in enumerate(B):
		if v==BB:
			y.append(i)

	#print(x,y,AA,BB)
	#print(C)
	ans=0

	for i in x:
		C[i].append(10**7)
		#print("a")
		#print(C[i])
		#print(y)
		a=0
		for j in y:
			while a<len(C[i]):
				if j==C[i][a]:
					a+=1
					break
				elif j<C[i][a]:
					print(AA+BB)
					exit()
				else:
					a+=1

	print(AA+BB-1)
















if __name__ == "__main__":
	main()
x, y = int(input().split())

max_num = 4 * x
min_num = 2 * x

if y % 2 == 1:
    print('No')
elif (min_num <= y) and (max_num >= y):
    print('Yes')
else:
    print('No')

### FIXED CODE ###

x, y =  map(int, input().split())

max_num = 4 * x
min_num = 2 * x

if y % 2 == 1:
    print('No')
elif (min_num <= y) and (max_num >= y):
    print('Yes')
else:
    print('No')
N = int(input())
alist = []
for _ in range(N):
    alist.append(int(input()))
i = 1
for n in range(N):
    i = alist[i - 1]
    if i == 2:
        print(len(n + 1))
        break
else:
    print(-1)

### FIXED CODE ###

N = int(input())
alist = []
for _ in range(N):
    alist.append(int(input()))
i = 1
for n in range(N):
    i = alist[i - 1]
    if i == 2:
        print(n + 1)
        break
else:
    print(-1)
# -*- coding: utf-8 -*-

import functools
import fractions

N = int(input())
numbers = list(map(int, input().split()))

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

max_under_lcm = functools.reduce(lambda x, y: int((x * y) / fractions.gcd(x,y)), numbers) - 1
sum = 0
for n in numbers:
    sum += max_under_lcm % n
answer = sum

print(answer)
~             

### FIXED CODE ###

import functools
import fractions

N = int(input())
numbers = list(map(int, input().split()))
answer = sum([n - 1 for n in numbers])

print(answer)
a, b, c = map(int, input().split())
if a == b && a != c:
  print('Yes')
elif a == c && a != b:
  print('Yes')
elif b == c && a != c:
  print('Yes')
else:
  print('No')

### FIXED CODE ###

a, b, c = map(int, input().split())
if a == b and a != c:
  print('Yes')
elif a == c and a != b:
  print('Yes')
elif b == c and a != c:
  print('Yes')
else:
  print('No')
N, M = map(int, input().split())

G = [[] for i in range(N)]
for i in range(M):
    a, b = map(int, input().split())
    G[a-1].append(b-1)
    G[b-1].append(a-1)

def dfs(v, u, depth):

    depth_min[v] = depth
    memo[v] = u

    for next_v in G[v]:
        if next_v == 0:
            continue
        if depth_min[next_v] > depth+1:
            dfs(next_v, v, depth+1)

depth_min = [float("inf")] * N
memo = [-1] * N
dfs(0, 0, 0)
if -1 in memo:
    print("No")
else:
    print("Yes")
    for i in range(1, N):
        print(memo[i]+1)

### FIXED CODE ###

from collections import deque

N, M = map(int, input().split())
g = [[int(i) for i in input().split()] for j in range(M)]

G = [[] for i in range(N)]
for i in range(M):
    a, b = g[i]
    G[a-1].append(b-1)
    G[b-1].append(a-1)

marks = [-1 for i in range(N)]
node = deque([[0, 0]])
while len(node) > 0:
    v = node.popleft()
    if marks[v[0]] == -1:
        marks[v[0]] = v[1]
        for i in G[v[0]]:
            if marks[i] == -1:
                node.append([i, v[0]])

if -1 not in marks:
    print("Yes")
    for i in range(1, N):
        print(marks[i]+1)
else:
    print("No")
b = input().strip()
if b == 'A':
  pirnt('T')
if b == 'T':
  print('A')
if b == 'G':
  print('C')
if b == 'C':
  print('G')

### FIXED CODE ###

b = input().strip()
if b == 'A':
  print('T')
if b == 'T':
  print('A')
if b == 'G':
  print('C')
if b == 'C':
  print('G')
import sys
input = sys.stdin.readline


def plus_score(tree, index, point):
    tree[index][0] += point
    if len(tree[index][1]) == 0:
        return
    for t in tree[index][1]:
        plus_score(tree, t, point)


def main():
    N, Q = [int(x) for x in input().strip().split()]
    data = []
    for _ in range(N-1):
        data.append([int(x) for x in input().strip().split()])
    operate = []
    for _ in range(Q):
        operate.append([int(x) for x in input().strip().split()])

    tree = [ [0,[]] for _ in range(N+1)]
    for d in data:
        tree[d[0]][1].append(d[1])

    for op in operate:
        plus_score(tree, op[0], op[1])

    ans = [x[0] for x in tree]
    print(*ans[1:])


if __name__ == "__main__":
    main()


### FIXED CODE ###

import sys
from collections import deque
input = sys.stdin.readline


def main():
    N, Q = [int(x) for x in input().strip().split()]
    data = []
    for _ in range(N-1):
        data.append([int(x) for x in input().strip().split()])

    operate = [0] * (N+1)
    for _ in range(Q):
        node, point = [int(x) for x in input().strip().split()]
        operate[node] += point

    tree = [[] for _ in range(N+1)]
    for d in data:
        tree[d[0]].append(d[1])
        tree[d[1]].append(d[0])

    stack = deque()
    stack.append((0,1))  # スタートノード
    while len(stack) > 0:
        parent_node, proc_node = stack.popleft()
        operate[proc_node] += operate[parent_node]
        for child_node in tree[proc_node]:
            if child_node == parent_node:
                continue
            stack.append((proc_node, child_node))

    print(*operate[1:])


if __name__ == "__main__":
    main()
n, m = map(int, input().split())
a = list(map(int, input.split()))
s = sum(a)
if n < s:
  print(-1)
else:
  print(n - a)

### FIXED CODE ###

n, m = map(int, input().split())
a = list(map(int, input().split()))
s = sum(a)
if n < s:
  print(-1)
else:
  print(n - s)
s=input()
s[3]='8'
print(s)

### FIXED CODE ###

s=input()
print(s[:3]+'8'+s[4:])
n=int(input())
ans=0
for i in range(1,n+1):
    if not len(i)%2==0:
        ans+=1
print(ans)

### FIXED CODE ###

n=int(input())
ans=0
for i in range(1,n+1):
    if not len(str(i))%2==0:
        ans+=1
print(ans)
H,W,M=map(int, input().split())
sumh=[0]*H
sumw=[0]*W
bomb=[]
for i in range(M):
  h,w=map(int, input().split())
  sumh[h-1]+=1
  sumw[w-1]+=1
  bomb.append((h,w))
 
maxh=max(sumh)
maxw=max(sumw)

cnt=0
for h,w in bomb:
  if sumh[h-1]==maxh and sumw[w-1]==maxw:
    cnt+=1

if cnt==len(qh)*len(qw):
  print(maxh+maxw-1)
else:
  print(maxh+maxw)

### FIXED CODE ###

H,W,M=map(int, input().split())
sumh=[0]*H
sumw=[0]*W
bomb=[]
for i in range(M):
  h,w=map(int, input().split())
  sumh[h-1]+=1
  sumw[w-1]+=1
  bomb.append((h,w))

maxh=max(sumh)
maxw=max(sumw)
ch=sumh.count(maxh)
cw=sumw.count(maxw)

cnt=0
for h,w in bomb:
  if sumh[h-1]==maxh and sumw[w-1]==maxw:
    cnt+=1

if cnt==ch*cw:
  print(maxh+maxw-1)
else:
  print(maxh+maxw)
x = input()
s = set(list(x))
f = 0
for i in s:
  x.count(i) % 2 == 1:
    f = 1
    break
  
if f == 1:
  print("No")
else:
  print("Yes")





### FIXED CODE ###

x = input()
s = set(list(x))
f = 0
for i in s:
  if x.count(i) % 2 == 1:
    f = 1
    break
  
if f == 1:
  print("No")
else:
  print("Yes")
def main():
    n=int(input())
    a=list(map(int,input().split()))
    a.sort()
    max=a[-1]
    check=[0 for i in range(max+10)]
    sum=0
    tmp=a[1]
    for i in range(n):
        if tmp==a[i]:
            continue
        tmp=a[i]
        if check[a[i]]==0:
            sum+=1
            j=1
            x=a[i]*j
            while x<max+1:
                x=a[i]*j
                check[x]=1
                j+=1
        else:
            continue
    print(sum)
        
    
    
if __name__=="__main__":
    main()

### FIXED CODE ###

def main():
    n=int(input())
    a=list(map(int,input().split()))
    a.sort()
    max=a[-1]
    check=[0 for i in range(max+10)]
    sum=0
    #print(a)
    if len(a)==1:
        print(1)
        exit()
    if a[0]==1:
        if a[1]==1:
            print(0)
        else:
            print(1)
        exit()
    for i in range(n):
        if check[a[i]]==0:
            sum+=1
            j=1
            x=a[i]*j
            while x<max+1:
                check[x]=1
                j+=1
                x=a[i]*j
            if i<n-1 and a[i+1]==a[i]:
                sum-=1
        else:
            continue
    print(sum)
        
    
    
if __name__=="__main__":
    main()
import numpy as np
n, m = map(int, input().split())
num = list(map(int, input().split()))
for i in range(m):
  num.sort()
  cnt, changeNum = map(int, input().split())
  for j in range(cnt):
    if num[j] >= changeNum:
      break
    else:
      num[j] = changeNum
print(sum(num))

### FIXED CODE ###

import sys
from heapq import heappush, heappop

input = sys.stdin.readline
n, m = map(int, input().split())
heap = []

for i in map(int, input().split()):
  heappush(heap, i)

bc = [list(map(int, input().split())) for _ in range(m)]
bc.sort(key = lambda x: -x[1])#cが大きいものから順に操作を加える

for b,c in bc:
  for j in range(b):
    a = heappop(heap)
    if a < c:
      heappush(heap, c)
    else:
      heappush(heap, a)
      break
print(sum(heap))
n, a, b = map(int, input().split())
print(min(m * a, b))

### FIXED CODE ###

n, a, b = map(int, input().split())
print(min(n * a, b))
W,H,x,y,r=map(int, input().split())
if r=<x=<(W-r) and r=<y=<(H-r):
	print("Yes")
else:
	print("No")


### FIXED CODE ###

W,H,x,y,r=map(int,input().split())
if r<=x<=(W-r) and r<=y<=(H-r):
	print("Yes")
else:
	print("No")
s = input()
p = input()
s = s + s[0:len(p)]
if s.find(p):
    print('Yes')
else:
    print('No')

### FIXED CODE ###

s = input()
p = input()
s = s + s[:len(p)]
if p in s:
    print('Yes')
else:
    print('No')
n = int(input)
s, t= map(str,input().split())

l = ' '

for i in range(n)
  l += s[i]
  l += t[i]

  print(l)


### FIXED CODE ###

n = int(input())
s,t = input().split()
l = ''
for i in range(n):
    l += s[i]
    l += t[i]
print(l)