Harryxun/stf_run huggingface dataset:
n,k=map(int,input().split())
lists=list(map(int,input().split()))
Chlist=[0]*n
countlist=[0]*40
for s in range(n):
    Chlist[s]=format(lists[s],’0%ib’%40)
    for i in range(40):
        if Chlist[s][i]=="1":
            countlist[39-i]+=1

#countlistのi桁めが2**(i-1)の数である
power=0
for i in range(40):
    if 2**i<=k<2**(i+1):
        power=i

ans1=0
for j in range(power):
    ans1+=(2**j)*max(countlist[j],n-countlist[j])
ans1+=(2**power)*(countlist[power])


uselist=[0]*(k-2**power+1)
for some in range(k-2**power+1):
    c=format(some,’0%ib’%40)
    uselist[some]=c


### FIXED CODE ###

n,k=map(int,input().split())
k2=format(k+1,"0%ib"%40)
lists=list(map(int,input().split()))
countlist=[0]*40
for j in lists:
    c=format(j,"0%ib"%40)
    for i in range(40):
        if c[i]=="1":
            countlist[i]+=1

emptylist=[]
for i in range(40):
    if k2[i]=="1":
        emptylist.append(i)
if k>=1:
    ans=0
    for i in emptylist:
        subing=0
        for j in range(40):
            if j<i:
                if k2[j]=="1":
                    subing+=(2**(39-j))*(n-countlist[j])
                elif k2[j]=="0":
                    subing+=(2**(39-j))*countlist[j]
            if j==i:
                subing+=(2**(39-i))*countlist[i]
            
            if j>i:
                subing+=(2**(39-j))*max(countlist[j],n-countlist[j])
        ans=max(ans,subing)
    print(ans)
elif k==0:
    ans=0
    for i in range(40):
        ans+=(2**(39-i))*countlist[i]
    print(ans)
mado = input()
ka-ten = input()

n = mado - (ka-ten*2)

if n >= 0:
  print(n)
else:
  print(0)

### FIXED CODE ###

MK = input()
mado = int(MK.split(" ")[0])
katen = int(MK.split(" ")[1])
 
n = mado - (katen*2)
 
if n >= 0:
  print(n)
else:
  print(0)
# -*- coding: utf-8 -*-
import numpy as np
import math

A, B = input().split()
A = int(A)
B_float = float(B)
B_int = int(B[0]+B[2:])
if B_float < 1:
    B_float = B_float*100
    C = A*B_float/100
    #C_str = str(C)
    print("{}".format(int(C)))
else:
    C = A*B_int
    C_str = str(C)
    iti = C_str.find('.')
    print("{}".format(int(C_str[:-2])))


### FIXED CODE ###

# -*- coding: utf-8 -*-
import numpy as np
import math

A, B = input().split()
A = int(A)
B_float = float(B)
B_int = int(B[0]+B[2:])
if B_float < 1:
    B_float = B_float*100
    C = A*B_float/100
    #C_str = str(C)
    print("{}".format(int(C)))
elif not A==0:
    C = A*B_int
    C_str = str(C)
    #iti = C_str.find('.')
    print("{}".format(int(C_str[:-2])))
elif A==0:
    print("{}".format(0))
from collections import Counter


def main():
    N = int(input())
    A = list(map(int, input().split()))

    A_set = set(A)
    A_dict = Counter(A)
    A_dict.sort()

    for key, count in A_dict.items():
        if count > 1:
            A_set.discard(key)
            continue

        k = key * 2

        if key in A_set:
            while k <= max(A):
                A_set.discard(k)
                k += key

    print(len(A_set))


if __name__ == '__main__':
    main()


### FIXED CODE ###


def main():
    N = int(input())
    A = list(map(int, input().split()))

    m = max(A) + 1
    dp = [0] * m

    for a in sorted(A):
        if dp[a] != 0:
            dp[a] = 2
            continue
        for i in range(a, m, a):
            dp[i] += 1

    print(sum(dp[i] == 1 for i in A))


if __name__ == '__main__':
    main()
n = int(input())
s = input
if (len(s) <= n):
  print(s)
else:
  for i in range (n):
    print(s[i], end = '')
  print()

### FIXED CODE ###

n = int(input())
s = input()
x = len(s)
if (x <= n):
  print(s)
else:
  for i in range (n):
    print(s[i], end = '')
  print("...")
N = map(int, raw_input().split())
a = []
for i in range(N):
    a.append(map(int, raw_input().split()))


for i in range(N):
    v = a[i]
    j = i-1
    while j>=0 and a[j]>v:
        a[j+1] = a[j]
        j = j-1
        a[j+1] = v
    print(a)


### FIXED CODE ###

N = int(input())
a = input().split()
b = [int(n) for n in a]


for i in range(N):
    v = b[i]
    j = i-1
    while j>=0 and b[j]>v:
        b[j+1] = b[j]
        j = j-1
        b[j+1] = v
    print(" ".join([str(n) for n in b]))
import math

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

print(A * B // math.gcd(A, B))


### FIXED CODE ###

import fractions

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

print(A * B // fractions.gcd(A, B))
a = map(int,input().split())
print(sum(a) - max(a))

### FIXED CODE ###

a = list(map(int,input().split()))
print(sum(a) - max(a))
import numpy as np
N = int(input())
n = N % 2
if n == 1:
  ans = 0
else:
  AB = list(range(N, 1, -2))
  AB = [len(str(ab)) - 1 for ab in AB if ab % 10 ==0]
  ans = np.sum(AB)
print(ans)

### FIXED CODE ###

import numpy as np
N = int(input())
n2 = N % 2
if n2 != 0:
  ans = 0
elif N <= 2:
  ans =0
else:
  a = int(np.log(N) // np.log(5))
  A = [N // (2 * (5 ** (i + 1))) for i in range(a)]
  ans = np.sum(A)
print(ans)
half_ring=raw_input()
ring=s*2
target=raw_input()
f=0

for i in range(len(s)):
	if ring[i:i+len(target)]==target:
		f=1
		break
if f==1:
	print "Yes"
else:
	print "No"

### FIXED CODE ###

s=raw_input()
target=raw_input()
ring=s*2

ans="No"
for i in range(len(s)):
	if ring[i:i+len(target)]==target:
		ans="Yes"
		break
print ans
def main():
  from heapq import *
  import sys
  input=sys.stdin.readline
  N,M=map(int,input().split())
  G=[set() for i in range(N)]
  for i in range(M):
      u,v=map(int,input().split())
      u,v=u-1,v-1
      G[u].add(v)
  S,T=map(int,input().split())
  A=[set() for i in range(N)]
  for i in range(N):
      for v in G[i]:
          A[i]=A[i] | G[v]
  B=[set() for i in range(N)]
  for i in range(N):
      for v in G[i]:
          B[i]=B[i] | A[v]
  C=[[] for i in range(N)]
  for i in range(N):
      for j in B[i]:
          C[i].append([j,1])
  INF=10**9+7
  def dijkstra(G,s):

    d=[INF]*N
    d[s]=0
    visited={s}
    que=[(0,s)]
    while(que):
      p=heappop(que)
      v=p[1]
      visited.add(v)
      for node,cost in G[v]:
        if (node not in visited) and d[node]>d[v]+cost:
          d[node]=d[v]+cost
          heappush(que,(d[node],node))
    return d
  d=dijkstra(C,S-1)
  if d[T-1]==INF:
    print(-1)
  else:
    print(d[T-1])
if __name__=='__main__':#おまじない
  main()


### FIXED CODE ###

from heapq import *
import sys
input=sys.stdin.readline
N,M=map(int,input().split())
G=[[] for i in range(3*N)]
for i in range(M):
    u,v=map(int,input().split())
    u,v=u-1,v-1
    G[3*u+0].append([3*v+1,0])
    G[3*u+1].append([3*v+2,0])
    G[3*u+2].append([3*v+0,1])
S,T=map(int,input().split())
INF=10**9+7
def dijkstra(G,s):

  d=[INF]*(3*N)
  d[s]=0
  visited={s}
  que=[(0,s)]
  while(que):
    p=heappop(que)
    v=p[1]
    visited.add(v)
    for node,cost in G[v]:
      if (node not in visited) and d[node]>d[v]+cost:
        d[node]=d[v]+cost
        heappush(que,(d[node],node))
  return d
d=dijkstra(G,(S-1)*3)
if d[(T-1)*3]==INF:
  print(-1)
else:
  print(d[(T-1)*3])
arr = list(map(int, input().split()))
au = sum(i for in range(arr[0]) if arr[1] <= sum(map(int, str(i))) <= arr[2])
print(au)

### FIXED CODE ###

n,a,b=map(int,input().split())
print(sum(i for i in range(n+1) if a<=sum(map(int,str(i)))<=b))
S = input().strip()
T = input().strip()


dp = [[0] * (len(T)+1) for _ in range(len(S))]

for i, s in enumerate(S):
  for j, t in enumerate(T):
    if s == t:
      dp[i][j] = dp[i-1][j-1] + 1
    else:
      dp[i][j] = max(dp[i][j-1], dp[i-1][j])
ans = []
s = (len(S)-1, len(T)-1)
while True:
  x, y = s
  if x < 0 or y < 0:
    assert x == y
    break
  if S[x] == T[y]:
    ans.append(S[x])
    s = (x-1, y-1)
  else:
    if dp[x-1][y] > dp[x][y-1]:
      s = (x-1, y)
    else:
      s = (x, y-1)

    
print(''.join(reversed(ans)))

### FIXED CODE ###

S = input().strip()
T = input().strip()


dp = [[0] * (len(T)+1) for _ in range(len(S)+1)]

for i, s in enumerate(S):
  for j, t in enumerate(T):
    if s == t:
      dp[i][j] = dp[i-1][j-1] + 1
    else:
      dp[i][j] = max(dp[i][j-1], dp[i-1][j])
ans = []
s = (len(S)-1, len(T)-1)
while True:
  x, y = s
  if x < 0 or y < 0:
    break
  if S[x] == T[y]:
    ans.append(S[x])
    s = (x-1, y-1)
  else:
    if dp[x-1][y] > dp[x][y-1]:
      s = (x-1, y)
    else:
      s = (x, y-1)

    
print(''.join(reversed(ans)))
costs = [2,5,5,4,5,6,3,7,6]

N, M = map(int, input().split())
A = list(map(int, input().split()))
neginf = -1 * 1e20
D = [neginf]*(N+1)

def dp(n_match):
    D[0] = 0
    for n in range(1,n_match+1):
        arr = [D[n-costs[a-1]] if n-costs[a-1]>=0 else neginf for a in A]
        if max(arr) < 0:
            continue
        D[n] = max(arr)+1
    # exit(0)

def main():
    dp(N)
    # print(D)
    # exit(0)
    n = N
    ans = ''
    while n>0:
        arr = [ a for a in A if D[n-costs[a-1]]==D[n]-1 ]
        if len(arr)>0:
            a = max(arr)
            ans += str(a)
            n -= costs[a-1]
        else:
            break
    print(ans)

main()



### FIXED CODE ###

N,M = map(int, input().split())
cost = [0,2,5,5,4,5,6,3,7,6]
A = list(map(int, input().split()))

costp = sorted([ (cost[a] ,a) for a in A], key=lambda x:x[1], reverse=True)
costX = [ z[0] for z in costp]
A = [ z[1] for z in costp]
# print(A,costX)

dp = [-1] * (N+1)
dp[N] = 0

for i in range(N, 1, -1):
    if (dp[i]) == -1:
        continue

    for c,a in zip(costX,A):
        if i-c >= 0:
            dp[i-c] = dp[i] + 1


ans = ""

i = 0
while i<N:
    # print(i)
    for c,a in zip(costX,A):
        # print(c,a,i)
        # if i+c <= N:
        #     print("i: {}, dp[i]=".format(i), dp[i], ", dp[i+c]: ", dp[i+c], "c=",c, "a=",a)
        # else: print("i: {}, dp[i]=".format(i), dp[i], ",c=",c, "a=",a)
        
        if i+c <= N:
            if dp[i]-1 == dp[i+c]:
                ans += str(a)
                i = i+c
                break

print(ans)
# print(dp)
from copy import copy
import numpy as np

N, K = map(int, input().split())
P = list(map(int, input().split()))
C = list(map(int, input().split()))

score = 0
if K > N:
    sho = K // N
    yo = K % N
    K = yo
    if sum(C) > 0:
        score += sho * sum(C)

score_list = np.zeros((N, K), dtype='int64')
for n in range(N):
    now = copy(n)
    s = copy(score)
    for k in range(K):
        now = P[now] - 1
        s += C[now]
        score_list[n, k] = s

print(score_list.max())

### FIXED CODE ###

N, K = map(int, input().split())
P = list(map(int, input().split()))
C = list(map(int, input().split()))

for i in range(N):
    P[i] -= 1

ans = -10 ** 18
for si in range(N):
    x = si
    c = []
    tot = 0
    while True:
        x = P[x]
        c.append(C[x])
        tot += C[x]
        if x == si:
            break

    s = 0
    for k in range(len(c)):
        if k + 1 > K:
            break
        s += c[k]
        ss = s
        if tot > 0:
            ss += tot * int((K - (k + 1)) // len(c))
        ans = max(ss, ans)

print(ans)
import statistics

n = int(input())
d = list(map(int, input().split()))

if n % 2 == 1:
  print(0)
  exit()
cnt = 0
index = 0
for _, num in enumerate(d):
  item = [j for j in d if j >= num]
  if len(item) == (len(d) / 2):
    cnt = num
    index = _

d = list(set(sorted(d)))
ans = cnt - d[d.index(cnt) - 1]
print(ans)

### FIXED CODE ###

n = int(input())
d = list(map(int, input().split()))
 
if n % 2 == 1:
  print(0)
  exit()

d = sorted(d)
print(d[int(n/2)] - d[int(n/2) - 1])
X,T = map.(int, input().split(' '))

input(T/X)

### FIXED CODE ###

T,X = map(int, input().split())

print(T/X+0.000001)
str = input()
week_whether = {'Sunny':0, 'Cloudy':1, 'Rainy':2}
weel_labels = {0:'Sunny',1:'Cloudy', 2: 'Rainy'}
print(weel_labels[week_whether[str] + 1])

### FIXED CODE ###

str = input()
week_whether = {'Sunny':0, 'Cloudy':1, 'Rainy':2}
weel_labels = {0:'Sunny',1:'Cloudy', 2: 'Rainy'}
print(weel_labels[(week_whether[str] + 1)%3])
def calc(value):
    tmp = 1
    for i in range(1, value+1):
        tmp *= i
    return tmp//2


n = int(input())
array = [int(x) for x in input().split()]

tmp_sum = 0
sum_array = []

for i in array:
    tmp_sum += i
    sum_array.append(tmp_sum)

sum_dict = {x:sum_array.count(x) for x in set(sum_array)}

minus = 0
if sum_array.count(0) == 1:
    sum_dict[0] += 1
else:
    minus = sum_dict[0]

res = 0
for key, value in sum_dict.items():
    if value >= 2:
        res += calc(value)

print(res-minus)



### FIXED CODE ###

n=int(input())
a=list(map(int,input().split()))
ans=0
b=[]
sum=0
for i in range(n):
    sum+=a[i]
    b.append(sum)
b=sorted(b)
b.append(float("inf"))
k=0
for i in range(n):
    if b[i]==b[i+1]:
        k+=1
    else:
        if not k==0:
            ans+=k*(k+1)//2
        k=0
for i in range(n):
    if b[i]==0:
        ans+=1
print(ans)
import numpy as np

def koch_divide(p,q):
    v = q-p
    r = np.array([[np.sqrt(3)/2, 0.5],[-0.5, np.sqrt(3)/2]])
    s = p + v/3
    t = q - v/3
    u = p + np.dot(v,r)/np.sqrt(3)
    return [s,u,t,q]

def koch_curve(previous):
    vertices = [previous[0]]
    for p,q in zip(previous[:-1], previous[1:]):
        vertices.extend(koch_divide(p,q))
    return vertices

if __name__=='__main__':
    p_q = np.array([[0.0, 0.0], [100.0, 0.0]])
    n = int(input())
    for _ in range(n):
        p_q = koch_curve(p_q)
    for vertex in p_q:
        print(" ".join(map(str, vertex)))

### FIXED CODE ###

def koch_divide(p,q):
    v = [q[0]-p[0], q[1]-p[1]]
    s = [p[0]+v[0]/3, p[1]+v[1]/3]
    t = [q[0]-v[0]/3, q[1]-v[1]/3]
    u = [p[0]+v[0]*0.5-v[1]*0.288675, p[1]+v[0]*0.288675+v[1]*0.5]
    return [s,u,t,q]

def koch_curve(previous):
    vertices = [previous[0]]
    for p,q in zip(previous[:-1], previous[1:]):
        vertices.extend(koch_divide(p,q))
    return vertices

if __name__=='__main__':
    p_q = [[0.0, 0.0], [100.0, 0.0]]
    n = int(input())
    for _ in range(n):
        p_q = koch_curve(p_q)
    for vertex in p_q:
        print(" ".join(['{:.8f}'.format(x) for x in vertex]))
a,b,n = map(int,input().split())

x = list()
if n<=b:
  for i in range(n+1):
    y = int(a*i/b) - a*int(i/b)
    x.append(y)
else:
  for i in range(b):
    y = int(a*i/b) - a*int(i/b)
    x.append(y)
x = sort(x)
print(x[-1])


### FIXED CODE ###

a,b,n=map(int,input().split())
x=min(b-1,n)
print((a*x)//b-a*(x//b))
nm = list(map(int,input().split()))
n = nm[0]
m = nm[1]
a = []
b = []
for i in range(0, m):
    ab = list(map(int,input().split()))
    a.append(ab[0])
    b.append(ab[1])
signs = [0]*(n+1)
signs[1]=-1
now = [1]
nexx = []
while True:
    for i in now:
        for j in range(0,m):
            if a[j] == i:
                if signs[b[j]] == 0:
                    signs[b[j]] = i
                    nexx.append(b[j])
            elif b[j] == i:
                if signs[a[j]] == 0:
                    signs[a[j]] = i
                    print("signs=",signs)
                    nexx.append(a[j])
    now=nexx.copy()
    if len(nexx)==0:
        break
    nexx = []
flag = 0
for i in range(2, n+1):
    if signs[i]==0:
        print("No")
        flag = 1
        break
if flag == 0:
    print("Yes")
    for k in range(2,n+1):
        print(signs[k])



### FIXED CODE ###

n = int(input())
rem = n%10
if rem == 3:
  print("bon")
elif rem == 0 or rem == 1 or rem == 6 or rem == 8:
  print("pon")
else:
  print("hon")
s = int(input())
import sys
p = 10**9+7
dp = [0]*100#2003
dp[2]=1
if s<=3:
    print(dp[s-1])
    sys.exit()
for i in range(3,s):
    dp[i] = (dp[i-1]%p+dp[i-3]%p)%p


print(dp[s-1])

### FIXED CODE ###

s = int(input())
import sys
p = 10**9+7
dp = [0]*2003
dp[2]=1
if s<=3:
    print(dp[s-1])
    sys.exit()
for i in range(3,s):
    dp[i] = (dp[i-1]%p+dp[i-3]%p)%p


print(dp[s-1])
S = input()
print(S - "FESTIVAL")

### FIXED CODE ###

S = input()
print(S[:-8])
a,b,c = map(int,input(),split())
print(a*b/2)

### FIXED CODE ###

a,b,c = map(int,input().split())
print(int(a*b/2))
from collections import defaultdict

def DFS(u,G,H,A,visited,P):
    visited[u]=True
    for v in G[u]:
        if not (min(u,v),max(u,v)) in P:
            if H[u-1]>H[v-1]:
                    A[u]+=1
            elif H[v-1]>H[u-1]:
                    A[v]+=1
            P.add((min(u,v),max(u,v)))
        if not visited[v]:
            DFS(v,G,H,A,visited,P)

def DFSUtil(G,H,N):
    visited=[False]*(N+1)
    A=[0]*(N+1)
    P=set()
    for u in G:
        if (not visited[u]):
            DFS(u,G,H,A,visited,P)
    return A
N,M=map(int,input().strip().split())
H=list(map(int,input().strip().split()))
G=defaultdict(list)

for i in range(M):
    u,v=map(int,input().strip().split())
    G[u].append(v)
    G[v].append(u)
A=DFSUtil(G,H,N)
cnt=0
for i in range(1,N+1):
    neighbours=len(list(set(G[i])))
    if neighbours==A[i]:
        cnt+=1
print(cnt)

### FIXED CODE ###

from collections import defaultdict
import sys
sys.setrecursionlimit(100000000)
def DFS(u,G,H,A,visited,P):
    visited[u]=True
    for v in G[u]:
        if not (min(u,v),max(u,v)) in P:
            if H[u-1]>H[v-1]:
                    A[u]+=1
            elif H[v-1]>H[u-1]:
                    A[v]+=1
            P.add((min(u,v),max(u,v)))
        if not visited[v]:
            DFS(v,G,H,A,visited,P)

def DFSUtil(G,H,N):
    visited=[False]*(N+1)
    A=[0]*(N+1)
    P=set()
    for u in G:
        if (not visited[u]):
            DFS(u,G,H,A,visited,P)
    return A
N,M=map(int,input().strip().split())
H=list(map(int,input().strip().split()))
G=defaultdict(list)

for i in range(M):
    u,v=map(int,input().strip().split())
    G[u].append(v)
    G[v].append(u)
A=DFSUtil(G,H,N)
cnt=0
for i in range(1,N+1):
    neighbours=len(list(set(G[i])))
    if neighbours==A[i]:
        cnt+=1
print(cnt)
n = int(input())
s = input()

num = len(s)
ans = 0
for i in range(num):
    a = set(s[i])
    for j in range(i+1, num):
        if s[j] in a:
            continue
        a.add(s[j])
        for k in range(j+1, num):
            if s[k] in a or j-i == k-j:
                continue
            ans += 1
        a.remove()

print(ans)


### FIXED CODE ###

n = int(input())
s = input()

num = len(s)
ans = s.count('R')*s.count('G')*s.count('B')

for i in range(num):
    for j in range(i+1, num):
        if 0 <= 2*j-i < num:
            if s[i] != s[j] and s[j] != s[2*j-i] and s[2*j-i] != s[i]:
                ans -= 1
print(ans)
N,M = map(int,input().split())
a = [int(input()) for _ in range(M)]

MOD = 1000000007

d = [0] * (N+1)
NG = [FALSE]*N
d[0] = 1
if(1 in a):
    d[1] = 0
else:
    d[1] = 1

for i in range(M):
    NG[i] = True


for i in range(2,N+1):
    if(NG[i-1] == False):
        d[i] = d[i-1] + d[i-2]
        d[i] %= MOD
    '''
    if(i in a):
        d[i] = 0
    else:
        d[i] = d[i-1] + d[i-2]
    d[i] %= MOD
    '''

print(d[-1])

### FIXED CODE ###

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

MOD = 1000000007

d = [0] * (N+1)
OK = [True]*(N+1)
d[0] = 1

for i in range(M):
    OK[a[i]] = False

#print(OK)

if(OK[1]):
    d[1] = 1
else:
    d[1] = 0

for i in range(2,N+1):
    if(OK[i-1]):
        d[i] += d[i-1]
    if(OK[i-2]):
        d[i] += d[i-2]
    d[i] %= MOD
    '''
    if(i in a):
        d[i] = 0
    else:
        d[i] = d[i-1] + d[i-2]
    d[i] %= MOD
    '''

print(d[-1])
from collections import deque
k=int(input())
deq=deque([1,2,3,4,5,6,7,8,9])
for in in range(k):
  a=deq.popleft()
  if not a%10==0:
    deq.append(a*10+a%10-1)
  deq.append(a*10+a%10)
  if a%10==9:
    deq.append(a*10+a%10+1)
print(a)
    
  

### FIXED CODE ###

from collections import deque
K=int(input())
que=deque([1,2,3,4,5,6,7,8,9])
for i in range(K):
    a=que.popleft()
    if not a%10==0:
        que.append(a*10+a%10-1)
    que.append(a*10+a%10)
    if not a%10==9:
        que.append(a*10+a%10+1)
print(a)
class Dice :
        same_dice_index = ('123456' , '135246' , '142536' , '154326' ,
                       '214365' , '231645' , '246135' , '263415',
                       '312564' , '326154' , '351624' , '365214',
                       '415263' , '421653' , '456123' , '462513',
                       '513462' , '536142' , '541632' , '564312',
                       '624351' , '632541' , '645231' , '653421')

def __init__ ( self , num_list ) :
            self.faces = num_list

 
    

def is_same ( self , dice ) :
            for i in Dice.same_dice_index :
                    example_faces = [ ]

            for j in i :
                    example_faces.append ( self.faces [ int ( j ) - 1 ] )
            if example_faces == dice.faces :
                    return 'Yes'
        return 'No'
 
num_list1 = list ( map ( int , input ( ).split ( ) ) )
num_list2 = list ( map ( int , input ( ).split ( ) ) )
 
dice1 = Dice ( num_list1 )
dice2 = Dice ( num_list2 )
 
ans = dice1.is_same ( dice2 )
 
print ( ans )



### FIXED CODE ###

import random


def dice ( a , b , c , d , e , f , l ) :
    if l == "N" :
        return [ b , f , c , d , a , e ]
    if l == "S" :
        return [ e , a , c , d , f , b ]
    if l == "E" :
        return [ d , b , a , f , e , c ]
    if l == "W" :
        return [ c , b , f , a , e , d ]
d = list ( map ( int , input ( ).split ( ) ) )
s = [ "W" , "N" , "E" , "S" ]
a , b , c , g , e , f = map ( int , input ( ).split ( ) )
j = 0
while j <= 10000 :
    k = random.randrange ( 4 )
    d = dice ( d [ 0 ] , d [ 1 ] , d [ 2 ] , d [ 3 ] , d [ 4 ] , d [ 5 ] , s [ k ] )
    if d [ 0 ] == a and d [ 1 ] == b and d [ 2 ] == c and d [ 3 ] == g and d [ 4 ] == e and d [ 5 ] == f :
        print ( "Yes" )
        break
    if j == 10000 :
        print ( "No" )
    j += 1
from collections import deque
n,x,y = map(int,input().split())
next = [[] for i in range(n)]
next[0].append(1)
next[n-1].append(n-2)
next[x-1].append(y-1)
next[y-1].append(x-1)
for i in range(1,n-1):
  next[i].append(i-1)
  next[i].append(i+1)

ans = [0] *(n-1)

for j in range(n):
  mark = ['inf']*(n)
  que = deque([j])
  mark[j] = 0
 
  while que:
    q = que.popleft()
    for k in next[q]:
      if mark[k] == 'inf':
        mark[k] = mark[q] + 1
        que.append(k)
  
  for l in range(0,n):
    if mark[l] != 0:
      ans[mark[l]-1] += 1

import numpy as np    
arr = np.array(ans) //2
for x in arr:
  print(x)
      


### FIXED CODE ###

from collections import deque
n,x,y = map(int,input().split())
next = [[] for i in range(n)]
next[0].append(1)
next[n-1].append(n-2)
next[x-1].append(y-1)
next[y-1].append(x-1)
for i in range(1,n-1):
  next[i].append(i-1)
  next[i].append(i+1)

ans = [0] *(n-1)

for j in range(n):
  mark = ['inf']*(n)
  que = deque([j])
  mark[j] = 0
 
  while que:
    q = que.popleft()
    for k in next[q]:
      if mark[k] == 'inf':
        mark[k] = mark[q] + 1
        que.append(k)
  
  for l in range(0,n):
    if mark[l] != 0:
      ans[mark[l]-1] += 1

for x in ans:
  print(x//2)
N = int(input())
A = list(map(int, input().split()))
x = [0]**(2*10**5)
for i in range(N):
  x[A[i]] += 1

for i in range(N):
  print(x[i])

### FIXED CODE ###

N = int(input())
A = list(map(int, input().split()))
x = [0]*(2*10**5+1)
for i in range(N-1):
    x[A[i]] += 1
for i in range(1,N+1):
    print(x[i])
import numpy as np
k,x = map(int,input().split())

result = np.linspace(x-k+1,x+k-1,k*2-1,dtype = 'int')

for i in range(k*2-1):
    print(result[i],end = " ")

### FIXED CODE ###

import numpy as np
k,x = map(int,input().split())

result = np.arange(x-k+1,x+k,1,dtype = 'int')

for i in range(len(result)):
    print(result[i],end = " ")