Harryxun/stf_run huggingface dataset:
S=lambda:input()
I=lambda:int(input())
L=lambda:list(map(int,input().split()))
LS=lambda:list(map(str,input().split()))

def main():
    import sys
    input = sys.stdin.readline
    n,k=L()
    a=L()
    visited=[0]*n
    tmp=0
    now=0
    visited[0]=1
    for i in range(k):
        now=a[i]-1
        #print(tmp,now+1)
        if visited[now]==0:
            visited[now]=1
        else:
            tmp=i
            break
    #print(tmp,now)
    tmp2=k%tmp
    dist=a[now]
    #print(now+1,end=" ")
    for i in range(tmp2):
        now=a[now]-1
        dist=now+1
        #print(now+1,end=" ")
    #print()
    print(dist)
    
    
if __name__ == '__main__':
    main()

### FIXED CODE ###

S=lambda:input()
I=lambda:int(input())
L=lambda:list(map(int,input().split()))
LS=lambda:list(map(str,input().split()))

def main():
    import sys
    input = sys.stdin.readline
    n,k=L()
    a=L()
    visited=[0]*(n+1)
    tmp=0
    now=0
    visited[0]=1
    loopat=-1
    for i in range(k):
        #print(visited,end="")
        tmp=i+2
        now=a[now]-1
        #print(now)
        #print(tmp,now+1)
        if visited[now]==0:
            visited[now]=i+2
        else:
            loopat=now
            break
    #print(visited)
    #print(loopat,visited[loopat],tmp)
    #print(tmp,now)
    if loopat==-1:
        print(now+1)
        exit()
    elif tmp-visited[loopat]==0:
        tmp2=k
        dist=1
        now=0
    else:
        tmp2=(k-(visited[loopat]-1))%(tmp-visited[loopat])
        dist=loopat+1
    #print(tmp2)
    
    #print(now,dist)
    #print(now+1,end=" ")
    for i in range(tmp2):
        now=a[now]-1
        dist=now+1
        #print(now,dist)
    #print()
    print(dist)
    
    
if __name__ == '__main__':
    main()
import itertools
N = int(input())
V = list(map(int, input().split()))
C = list(map(int, input().split()))

M = [[V[i], C[i]]for i in range(N)]
print(M)

com_M = list(itertools.combinations(M, 2))
m_M = []
for i in range(N):
    X = com_M[i][0][0] + com_M[i][1][0]
    Y = com_M[i][0][1] + com_M[i][1][1]
    #print(X)
    #print(Y)
    m_M.append(X - Y)

print(max(m_M))


### FIXED CODE ###

import itertools
N = int(input())
V = list(map(int, input().split()))
C = list(map(int, input().split()))

M = [[V[i], C[i]]for i in range(N)]
#print(M)


tx = 0
R = 0
for i in range(N):
    tx = V[i] - C[i]
    if (tx > 0):
        R += tx

print(R)
a = int(input())
print("%.6f %,6f"%(a*a*3.1415926535, 2*a*3.1415946535))


### FIXED CODE ###

import math
x = float(input())
print("%.6f %.6f"%(x*x*math.pi, x*2*math.pi))
int i = 0
while 1:
   int x = raw_input()
   i = i +1
   if x == 0: 
     break
   print ("Case %d: %d") % (i,x)
  

### FIXED CODE ###

i = 0
while 1:
   x = int(raw_input())
   i = i + 1
   if x == 0:
      break
   print 'Case %s: %s' %(i, x)
import math
n = int(input())
c = []
s = []
f = []
for i in range(n-1):
  x,y,z = map(int, input().split())
  c += [x]
  s += [y]
  f += [z]
  
for i in range(n-1):
  ans = s[i]+c[i]
  for j in range(i+1, n-1):
    ans = (ans//f[j]) * math.ceil(ans/f[j]) + c[j]
  print(ans)
print(0)

### FIXED CODE ###

import math

n = int(input())
c = []
s = []
f = []
for i in range(n - 1):
    x, y, z = map(int, input().split())
    c += [x]
    s += [y]
    f += [z]

for i in range(n - 1):
    ans = s[i] + c[i]
    for j in range(i + 1, n-1):
        if ans < s[j]:
            ans = s[j] + c[j]
        else:
            ans = f[j] * math.ceil(ans / f[j]) + c[j]
    print(ans)
print(0)
import sys

sys.setrecursionlimit(10**6)
input = sys.stdin.readline

def main():
    order_F = []
    order_F = input().rstrip().split('T')
    x, y = map(int, input().split())
    distance = [len(order_F[i]) for i in range(len(order_F))]
    dp_len = max(distance) + 1
    vert_DP = [False] * (dp_len + 1)
    side_DP = [False] * (dp_len + 1)
    vert_DP[0] = True
    side_DP[0] = True
    vert_sum = 0
    side_sum = 0
    x -= distance[0]
    for i in range(1, len(order_F)):
        if i % 2 == 0:
            side_sum += distance[i]
            for j in reversed(range(dp_len + 1 - distance[i])):
                if side_DP[j]:
                    side_DP[j + distance[i]] = True
        else:
            vert_sum += distance[i]
            for j in reversed(range(dp_len + 1 - distance[i])):
                if vert_DP[j]:
                    vert_DP[j + distance[i]] = True
    if side_sum < x or vert_sum < y:
        print("No")
    elif (side_sum - x) % 2 == 1 or (vert_sum - y) % 2 == 1:
        print("No")
    else:
        if side_DP[(side_sum - x)//2] and vert_DP[(vert_sum - y)//2]:
            print("Yes")
        else:
            print("No")

if __name__ == "__main__":
    main()

### FIXED CODE ###

import sys

sys.setrecursionlimit(10**6)
input = sys.stdin.readline

def main():
    order_F = []
    order_F = input().rstrip().split('T')
    x, y = map(int, input().split())
    vert_DP = [False] * 8001
    side_DP = [False] * 8001
    vert_DP[0] = True
    side_DP[0] = True
    vert_sum = 0
    side_sum = 0
    distance = [len(order_F[i]) for i in range(len(order_F))]
    order_len = len(order_F)
    x -= len(order_F[0])
    vert_last = 0
    side_last = 0
    for i in range(1, order_len):
        if i % 2 == 0:
            side_sum += distance[i]
            for j in reversed(range(side_last+1)):
                if side_DP[j]:
                    side_DP[j + distance[i]] = True
            side_last += distance[i]
        else:
            vert_sum += distance[i]
            for j in reversed(range(vert_last+1)):
                if vert_DP[j]:
                    vert_DP[j + distance[i]] = True
            vert_last += distance[i]
    if side_sum < x or vert_sum < y:
        print("No")
    elif (side_sum - x) % 2 == 1 or (vert_sum - y) % 2 == 1:
        print("No")
    else:
        if side_DP[(side_sum - x)//2] and vert_DP[(vert_sum - y)//2]:
            print("Yes")
        else:
            print("No")

if __name__ == "__main__":
    main()
rt = int(inut())

if rt >= 30:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

rt = int(input())

if rt >=30:
    print("Yes")
else:
    print("No")
n = int(input())
d = list(map(int, input().split()))
count = 0
for i in range(len(d)):
    for j in range(i+1, len(d)):
        count += d[i] * d[j]
print(count)

### FIXED CODE ###

x, y = map(int, input().split())
output =  0 if x <= 2 * y else x - 2 * y
print(output)
import sys
input=sys.stdin.readline

def longest_path(s):
    global dp
    if dp[s-1]<1:
        if edge[s]:
            dp[s-1]=max((longest_path(t)+1)for t in edge[s])
        else:
            dp[s-1]=0
    return dp[s-1]

N,M=map(int,input().split())
edge={}
for i in range(1,N+1):
    edge.setdefault(i,[])
for _ in range(M):
    x,y=map(int,input().split())
    edge[x].append(y)
dp=[0]*N
for i in range(1,N+1):
    if dp[i-1]==0:
        longest_path(i)

print(max(dp))

### FIXED CODE ###

import sys
input=sys.stdin.readline
sys.setrecursionlimit(10**6)

def longest_path(s):
    global dp
    if dp[s-1]<1:
        if edge[s]:
            dp[s-1]=max((longest_path(t)+1)for t in edge[s])
        else:
            dp[s-1]=0
    return dp[s-1]

N,M=map(int,input().split())
edge={}
for i in range(1,N+1):
    edge.setdefault(i,[])
for _ in range(M):
    x,y=map(int,input().split())
    edge[x].append(y)
dp=[0]*N
for i in range(1,N+1):
    if dp[i-1]==0:
        longest_path(i)

print(max(dp))
s = input()
ss = s.replase('/','')

if ss>20190430:
    print("TBD")
else:
    print("Heisei")

### FIXED CODE ###

Y, M, D = map(str, input().split("/"))
s = ''.join([Y,M,D])

if int(s)>20190430:
    print("TBD")
else:
    print("Heisei")
_=input()
print(1/sum[1/r for r in list(map(int,input().split()))])

### FIXED CODE ###

N = int(input())
A = list(map(int,input().split()))
R = 0.0
for i in range(N):
  R += A[i]**(-1)
print(1/R)
S = list(input())

Odd = S[0::2]
Even = S[1::2]

for i in range(len(Odd)):
    if 'L' == Odd[i]:
        l = 0
        break
    else:
        l = 1

for j in range(len(Even)):
    if 'R' == Even[j]:
        r = 0
        break
    else:
        r = 1

if l+r == 2:
    print('Yes')
else:
    print('No')

### FIXED CODE ###

S = list(input())

Odd = S[0::2]
Even = S[1::2]

for i in range(len(Odd)):
    if 'L' == Odd[i]:
        l = 0
        break
    else:
        l = 1

r = 1
for j in range(len(Even)):
    if 'R' == Even[j]:
        r = 0
        break
    else:
        r = 1

if l+r == 2:
    print('Yes')
else:
    print('No')
X=[input() for i in range(2)]
A,P=X[0],X[1]

print(int(A*3+P)/2)


### FIXED CODE ###

X=input()
X=X.split()
A,P=int(X[0]),int(X[1])

print(int((A*3+P)/2))
import sys
def check(here, count):
	return ((abs(here[0]-s[count][0]))**2 + (abs(here[1]-s[count][1]))**2 <= 2)
		
def dfs(here, count):
	if count == 10:
		result = True
	else:
		result = False
		for dx, dy in delta:
			next = (here[0]+dx,here[1]+dy)
			if lb[0] <= next[0] <= ub[0] and lb[1] <= next[1] <= ub[1] and check(next, count):
				result |= dfs(next, count+1)
	return result
delta = ((2, 0), (2, 1), (2, -1), (0, 2), (1, 2), (-1, 2), 
	(-2, 0), (-2, 1), (-2, -1), (0, -2), (1, -2), (-1, -2)) 

sys.setrecursionlimit = 1000000
lb = (0,0)
ub = (9,9)
while 1:
	here = map(int,raw_input().split(" "))
	if here == [0,0]:
		break
	n = int(raw_input())
	s = map(int,raw_input().split(" "))
	s = [(s[i*2],s[i*2+1]) for i in range(n)]
	if dfs(here, 0):
		print "OK"
	else:
		print "NA"

### FIXED CODE ###

import sys
def check(here, count):
	return ((abs(here[0]-s[count][0]))**2 + (abs(here[1]-s[count][1]))**2 <= 2)
		
def dfs(here, count):
	if count == n:
		result = True
	else:
		result = False
		for dx, dy in delta:
			next = (here[0]+dx,here[1]+dy)
			if lb[0] <= next[0] <= ub[0] and lb[1] <= next[1] <= ub[1] and check(next, count):
				result |= dfs(next, count+1)
	return result
delta = ((2, 0), (2, 1), (2, -1), (0, 2), (1, 2), (-1, 2), 
	(-2, 0), (-2, 1), (-2, -1), (0, -2), (1, -2), (-1, -2)) 

sys.setrecursionlimit = 1000000
lb = (0,0)
ub = (9,9)
while 1:
	here = map(int,raw_input().split(" "))
	if here == [0,0]:
		break
	n = int(raw_input())
	s = map(int,raw_input().split(" "))
	s = [(s[i*2],s[i*2+1]) for i in range(n)]
	if dfs(here, 0):
		print "OK"
	else:
		print "NA"
a,b = map(str,input().split())

c = int(a + b)

import math

if math.sprt(c).isdigit() == True:
  print("Yes")
  
else:
  print("No")




### FIXED CODE ###

import sys
a,b = map(str,input().split())
c = int(a + b)

for i in range(1,400):
    if c == i**2:
        print('Yes')
        sys.exit()
print('No')
n,m,k = map(int,input().split())

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

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

c = [0]
d = 0
for i in range(n):
    d += a[i]
    c.append(d)

e = [0]
f = 0
for i in range(n):
    f += b[i]
    e.append(f)


ans = 0
j = q-1
for i in range(n):
    if c[i] > k:
        break
    else:
        while c[i] + e[j] > k:
            j -= 1
    ans = max(i + j,ans)

print(ans)

### FIXED CODE ###

n,m,k = map(int,input().split())

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

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


c = [0]
d = 0
for i in range(n):
    d += a[i]
    c.append(d)

e = [0]
f = 0
for i in range(m):
    f += b[i]
    e.append(f)


ans = 0
j = m
for i in range(n+1):
    if c[i] > k:
        break
    else:
        while c[i] + e[j] > k:
            j -= 1
    ans = max(i + j,ans)

print(ans)
from sys import stdin
input = stdin

n = int(input())
aa = list(map(int, input().split()))
if 0 in aa:
  print(0)
  exit()
ans = 1
for a in aa:
  ans *= a
  if ans > 10**18:
    print(-1)
    exit()
print(ans)


### FIXED CODE ###

from sys import stdin
input = stdin.readline

n = int(input())
aa = list(map(int, input().split()))
if 0 in aa:
  print(0)
  exit()
ans = 1
for a in aa:
  ans *= a
  if ans > 10**18:
    print(-1)
    exit()
print(ans)
A, B = map(int, input().split())


_beki = [None] * 50
def ni_beki(n):
    return 2 ** n


# １-nのそれぞれの2進数で下からn桁目(n=0,1,...)の中の1の個数を返す関数
def f(x, n):
     a, b = divmod(x, ni_beki(n+1))
     p = ni_beki(n)
     return a * p + max(b - (p - 1), 0)

# 2進数での桁数を求める
def g(n):
    c = 0
    while True:
        if ni_beki(c) >= n + 1:
            return c
        c += 1

keta = g(B)
# 下から数えていく
d = []
for i in range(keta):
    p = f(B, i)
    q = f(A-1, i)
    d.append(p - q)

# 表示順に
d.reverse()

# 01文字に
e = list(map(lambda x: str(x % 2), d))

# 文字列に
e = ''.join(e)

print(int(e, 2))

### FIXED CODE ###

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


_beki = [None] * 50
def ni_beki(n):
    return 2 ** n


# １-nのそれぞれの2進数で下からn桁目(n=0,1,...)の中の1の個数を返す関数
def f(x, n):
     a, b = divmod(x, ni_beki(n+1))
     p = ni_beki(n)
     return a * p + max(b - (p - 1), 0)

# 2進数での桁数を求める
def g(n):
    c = 0
    while True:
        if ni_beki(c) >= n + 1:
            return c
        c += 1

keta = g(B)
# 下から数えていく
d = []
for i in range(keta):
    p = f(B, i)
    q = f(A-1, i)
    d.append(p - q)

# 表示順に
d.reverse()

# 01文字に
e = list(map(lambda x: str(x % 2), d))

# 文字列に
e = ''.join(e)

if e == '':
    e = "0"
print(int(e, 2))
X, N = map(int,input().split())
if N == 0:
    print(X)
    exit()

p = list(map(int,input().split()))
if p.count(X) == 0:
    print(X)
    exit()


l = list(range(0,102)) #ここの範囲設定が一番難しい部分だと思う
flist = []
for i in range(len(l)):
    if p.count(l[i]) == 0:
        flist.append(l[i])


flist.append(X)
anslist = sorted(flist)
t = anslist.index(X)

dist1 = anslist[t] - anslist[t-1] #Xと1つ前の数字との距離
dist2 = anslist[t+1] - anslist[t]) #Xと1つ後ろの数字との距離
    if dist1 <= dist2:
        print(anslist[t-1])
    else:
        print(anslist[t+1])

### FIXED CODE ###

X,N=map(int,input().split())
if N==0:
    print(X)
    exit()

P_ori=list(map(int,input().split()))
if P_ori.count(X)==0:
    print(X)
    exit()


P1=sorted(P_ori)
N=list(range(0,102))
PZ=[]
for i in range(len(N)):
    if P1.count(N[i])==0:
        PZ.append(N[i])

PZ.append(X)
P2=sorted(PZ)
t=P2.index(X)
if P2[t]==P2[0]:
    print(P2[1])
    exit()
elif P2[t]==P2[-1]:
    print(P2[-2])
    exit()
else:
    dist1=abs(P2[t-1]-P2[t])
    dist2=abs(P2[t]-P2[t+1])
    if dist1<=dist2:
        print(P2[t-1])
        exit()
    else:
        print(P2[t+1])
        exit()
print(0)
from functools import reduce
import fractions
import sys
sys.setrecursionlimit(20000)

def lcm_base(a, b):
    return a * b / fractions.gcd(a, b)


def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

N = int(input())
A = sorted(list(map(int, input().split())))
B = [0 for _ in range(N)]
mod = 10**9+7

ll = lcm_list(A)
ans = 0
for i in range(A):
    ans += ll // i
print(int(ans%mod))


### FIXED CODE ###

from fractions import gcd

def lcm(c,d):
    return c//gcd(c,d)*d
mod=10**9+7
n=int(input())
a=[int(i) for i in input().split()]
l=a[0]
for i in range(1,n):
    l=lcm(l,a[i])
ans=0
for i in range(n):
    ans+=l//a[i]
    #ans%=mod
print(ans%mod)
# 標準入力
range = int(input())
input = list(map(int, input().split()))

count = 0
for i in range(range):
    if (i+1) % 2 == 1 and list[i] % 2 == 1:
        count += 1
print(count)

### FIXED CODE ###

# 標準入力
n = int(input())
input = list(map(int, input().split()))
count = 0
for i in range(n):
    if (i+1) % 2 == 1 and input[i] % 2 == 1:
        count += 1
print(count)
a,b,c =  list(map(int, input().split()))

for i in range(b):
	if (i+1)*a%(b) == c:
		print('YES')
		sys.exit()

print('NO')

### FIXED CODE ###

import sys
a,b,c =  list(map(int, input().split()))

for i in range(b):
	if (i+1)*a%b == c:
		print('YES')
		sys.exit()

print('NO')
from collections import Counter
import sys
N = int(input())
A = [int(_) for _ in input().split()]

key_val_lis = []
for key, value in Counter(A).items():
    if value >= 2:
        key_val_lis.append((key, value))

ans_lis = sorted(key_val_lis, key=lambda x: -x[0])

if len(ans_lis) == 1 and ans_lis[0][0] < 4:
    print(0)
    sys.exit()

area_1 = ans_lis[0][0] * ans_lis[1][0]
area_2 = ans_lis[0][0] ** 2
print(max(area_1, area_2))


### FIXED CODE ###

from collections import Counter
import sys
N = int(input())
A = [int(_) for _ in input().split()]

key_val_lis = []
for key, value in Counter(A).items():
    if value >= 2:
        key_val_lis.append((key, value))

ans_lis = sorted(key_val_lis, key=lambda x: -x[0])

if len(ans_lis) <= 1 or ans_lis[0][1] is None:
        print(0)
        sys.exit()

area_1 = ans_lis[0][0] * ans_lis[1][0]
area_2 = 0
if ans_lis[0][1] >= 4:
    area_2 = ans_lis[0][0] ** 2
print(max(area_1, area_2))
import math
from sys import stdin
N,P=[int(x) for x in stdin.readline().rstrip().split()]
po=math.pow(P,(1/N))
for i in reversed(range(round(po,0)+1)):
    tmp=math.pow(i,N)
    if P==1:
        ans=1
        break
    if N==1:
        ans=P
        break
    if P%tmp==0:
        ans=i
        break
print(ans)

### FIXED CODE ###

import math
from sys import stdin
N,P=[int(x) for x in stdin.readline().rstrip().split()]
for i in reversed(range(round(math.pow(P,(1/N)))+1)):
    tmp=math.pow(i,N)
    if P==1:
        ans=1
        break
    if N==1:
        ans=P
        break
    if P%tmp==0:
        ans=i
        break
print(ans)
import math
c  = raw_input();
for var in range(0, int(c)) :
	n1 = raw_input();
	n2 = raw_input();
	sum = int(n1) + int(n2)
	if int(math.log10(sum)) + 1 > 80 :
		print("overflow")
	else :
		print(sum)
exit(0)

### FIXED CODE ###

for _ in range(int(input())) :
    n = int(input()) + int(input())
    if (n >= 10 ** 80) :
        print("overflow")
    else :
        print(n)
s = input()
a = [str(c) for c in s]
t = input()
b = [str(c) for c in s]

c = 0

for i in range(n):
  if a[i] == b[i]:
    c +=1

print(n-c)

### FIXED CODE ###

s = input()
a = [str(c) for c in s]
t = input()
b = [str(c) for c in t]

c = 0
n = len(a)
for i in range(n):
  if a[i] == b[i]:
    c +=1

print(n-c)
from itertools import combinations as cc
l = []
n,k = map(int, input().split())
xs,ys = set(),set()
t = 10**24
for _ in range(n):
  x,y = map(int, input().split())
  xs.add(x)
  ys.add(y)
  l.append((x,y))
xs = sorted(list(xs))
ys = sorted(list(ys))
for xl,xr in cc(xs,2):
  foe yl,yr in cc(ys,2):
    cnt = 0
    for x,y in l:
      if xl<=x<=xr and yl<=y<=yr:
        cnt += 1
      if cnt >= k:
        s = (xr-xl)*(yr-yl)
        if t > s:
          t = s
print(t)

### FIXED CODE ###

from itertools import combinations as cc
l = []
n,k = map(int, input().split())
xs,ys = set(),set()
t = 10**24
for _ in range(n):
  x,y = map(int, input().split())
  xs.add(x)
  ys.add(y)
  l.append((x,y))
xs = sorted(list(xs))
ys = sorted(list(ys))
for xl,xr in cc(xs,2):
  for yl,yr in cc(ys,2):
    cnt = 0
    for x,y in l:
      if xl<=x<=xr and yl<=y<=yr:
        cnt += 1
      if cnt >= k:
        s = (xr-xl)*(yr-yl)
        if t > s:
          t = s
print(t)
N = int(input())
K = list(map(int, input().split()))
n = [0] * N

for i in range(N):
  n[K[i]-1] = i + 1

for i in n:
  print(i, end=" ")

### FIXED CODE ###

a = int(input())
if a % 2 == 0:
  print(float(1 / 2))
else:
  print(float((a - (a - 1) / 2) / a))
N, P = [int(i) for i in input().strip().split()]
dic={}

for i in range(2,int(P**(1/2))+1):
    num = 0
    while P%i == 0:
        num = num +1
        P = P/i
    dic[i] = num
    
ans = 1
for i in dic:
    if dic[i] != 0:
        ans = ans*(i**(dic[i]//N))
if N = 1:
    ans = P
print(ans)

### FIXED CODE ###

N, P = [int(i) for i in input().strip().split()]
dic={}
ans = 1

if N == 1:
    print(P)
    quit()
elif P == 1:
    print(1)
    quit()
    
for i in range(2,int(P**(1/2))+1):
    num = 0
    while P%i == 0:
        num = num +1
        P = int(P/i)
    dic[i] = num//N
    ans = ans*(i**(dic[i]))

print(ans)
N = input()
coordinate = list(map(int, input().split()))
result = 0
resultl = 0

for j in range(N):
    result += (1-coordinate[j])**2

for i in range(1,101):
    for k in range(N):
        resultl += (i-coordinate[k])**2

    if resultl < result:
        result = resultl
    resultl = 0

print(result)

### FIXED CODE ###

N = int(input())
coordinate = list(map(int, input().split()))
result = 0
resultl = 0
 
for j in range(N):
    result += (1-coordinate[j])**2
    
for i in range(1,101):
    for k in range(N):
        resultl += (i-coordinate[k])**2
 
    if resultl < result:
        result = resultl
    resultl = 0
    
print(result)
n=int(input())
p=[]
for i in range(n):
    p.append(int(input())

print(sum(p)-(max(p)//2))

### FIXED CODE ###

n=int(input())
p=[int(input()) for i in range(n)]

print(sum(p)-(max(p)//2))
import collections

n,m,k = map(int,raw_input().split(' '))

friendships = [map(int, raw_input().split(' ')) for _ in range(m)]
disses = [map(int, raw_input().split(' ')) for _ in range(k)]
parent = {i:i for i in range(1, n+1)}
sizes = {i:1 for i in range(1, n+1)}
counts = {i:0 for i in range(1, n+1)}
howmanydisses = {i:0 for i in range(1, n+1)}
adj = collections.defaultdict(set)
def f(parent, a):
	if parent[a] != a:
		parent[a] = f(parent, parent[a])
	return parent[a]

for a,b in friendships:
	pa,pb = f(parent, a), f(parent, b)
	counts[a] +=1
	counts[b] +=1
	adj[a].add(b)
	adj[b].add(a)
	if pa != pb:
		parent[pb] = pa
		sizes[pa] += sizes[pb]

for a,b in disses:
	pa,pb = f(parent, a), f(parent, b)
	if pa == pb:
		if b not in adj[a]:
			howmanydisses[a] += 1
			howmanydisses[b] += 1

print ' '.join([str(sizes[f(parent,a)] - counts[a] - howmanydisses[a] - 1)  for a in range(1, n+1)])

### FIXED CODE ###

import collections

n,m,k = map(int,raw_input().split(' '))

friendships = [map(int, raw_input().split(' ')) for _ in range(m)]
disses = [map(int, raw_input().split(' ')) for _ in range(k)]

parent = {i:i for i in range(0, n+1)}
sizes = {i:1 for i in range(0, n+1)}

hd = collections.Counter()

adj = collections.defaultdict(set)

def f(parent, u):
	if parent[u] != u: 
		parent[u] = f(parent, parent[u])
	return parent[u]

for a,b in friendships:
	if a == b: continue

	pa,pb = f(parent, a), f(parent, b)
	
	adj[a].add(b)
	adj[b].add(a)

	if pa != pb:
		if sizes[pa] >= sizes[pb]:
			parent[pb] = pa
			sizes[pa] += sizes[pb]
		else:
			parent[pa] = pb
			sizes[pb] += sizes[pa]

for c,d in disses:
	pc,pd = f(parent, c), f(parent, d)
	if (pc == pd):
		hd[c] += 1
		hd[d] += 1
"""
hd[u] = k
u has k disses in its connected component
"""

print ' '.join([str(sizes[f(parent,u)] - len(adj[u]) - hd[u] - 1)  for u in range(1, n+1)])
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>

using namespace std;
typedef long long ll;

int main()
{
  ll x,y,z,K;
  cin >> x >> y >> z >> K;

  vector<ll>a(x);
  vector<ll>b(y);
  vector<ll>c(z);  
  
  for( int i=0;i<x;++i)
    cin >> a[i];
  for( int i=0;i<y;++i)
    cin >> b[i];
  for( int i=0;i<z;++i)
    cin >> c[i];

  sort(a.begin(), a.end(), greater<ll>());
  sort(b.begin(), b.end(), greater<ll>());
  sort(c.begin(), c.end(), greater<ll>());

  int i,j,k;
  cout << a[i]+b[j]+c[k] << endl;
  for( int v=1;v<K;++v )
    {
      if( i<x-1 && j<y-1 && k<z-1 )
	{
	  ll s = a[i]+b[j]+c[k+1];
	  ll t = a[i]+b[j+1]+c[k];
	  ll u = a[i+1]+b[j]+c[k];       
	  if( s>t && s>u )
	    k++;
	  else if ( t>s && t>u )
	    j++;
	  else
	    i++;
	}
      else if( i<x-1 && j<y-1 )
	{
	  ll t = a[i+1]+b[j]+c[k];
	  ll u = a[i]+b[j+1]+c[k];       
	  if( t>u )
	    i++;
	  else
	    j++;
	}
      else if( i<x-1 && k<z-1 )
	{
	  ll s = a[i+1]+b[j]+c[k];
	  ll t = a[i]+b[j]+c[k+1];
	  if( s>t )
	    i++;
	  else
	    k++;
	}
      else if( j<y-1 && k<z-1 )
	{
	  ll s = a[i]+b[j+1]+c[k];
	  ll t = a[i]+b[j]+c[k+1];
	  if( s>t )
	    j++;
	  else
	    k++;
	}
      else if( i<x-1 )
	i++;
      else if( j<y-1 )
	j++;
      else
	k++;
      
      cout << a[i]+b[j]+c[k] << endl;	 
    }
  return 0;
}


### FIXED CODE ###

import heapq

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

a = list(map(int,input().split()))
b = list(map(int,input().split()))
c = list(map(int,input().split()))

a.sort()
a.reverse()
b.sort()
b.reverse()
c.sort()
c.reverse()


memo = {}
i = j = k = 0

h = []
heapq.heappush(h, (-(a[i]+b[j]+c[k]), i,j,k))
for _ in range(K):
    cost, i, j, k = heapq.heappop(h)
    print(-cost)
    for dx, dy, dz in ((1,0,0), (0,1,0), (0,0,1)):
        if (i+dx, j+dy, k+dz) in memo:
            continue
        if i+dx<x and j+dy<y and k+dz<z:
            heapq.heappush(h, (-(a[i+dx]+b[j+dy]+c[k+dz]), i+dx, j+dy, k+dz))
            memo[(i+dx,j+dy,k+dz)] = 1
n, m = map(int, input().split())
if n == m:
  print('Yes')
else:
  print(('No")
  

### FIXED CODE ###

n, m = map(int, input().split())
if n == m:
  print('Yes')
else:
  print('No')