Harryxun/stf_run huggingface dataset:
def main():
    n = int(input())
    c = []
    state = [0 for i in range(n+1)]
    dp = [0 for i in range(n+1)]
    dp[0] = 1
    for i in range(n):
        c_i = int(input())

        if state[c_i] >= 1 and state[c_i] != i:
            dp[i+1] += dp[state[c_i]] + dp[i]
        else:
            dp[i+1] = dp[i]

        state[c_i] = i + 1

    print(dp[-1])

main()

### FIXED CODE ###

def main():
    n = int(input())
    c = []
    mod = 10 ** 9 + 7
    state = [0 for i in range(n+200000)]
    dp = [0 for i in range(n+1)]
    dp[0] = 1
    for i in range(n):
        c_i = int(input())

        if state[c_i] >= 1 and state[c_i] != i:
            dp[i+1] = (dp[state[c_i]] + dp[i]) % mod
        else:
            dp[i+1] = dp[i] % mod

        state[c_i] = i + 1
    print(dp[-1] % mod)

main()
n,q = map(int,input().split())
s = input()
for i in range(q):
    l,r = map(int,input().split())
    print(s[l-1:r].count("AC"))

### FIXED CODE ###

b = str(input())

if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "G":
    print("C")
elif b == "C":
    print("G")
from collections import defaultdict
from itertools import combinations


def p_e():
    N = int(input())
    S = input()

    S_idx = defaultdict(list)

    for i in range(N):
        S_idx[S[i]].append(i)

    ans = []

    for c in S_idx.keys():
        if len(S_idx[c]) <= 1:
            continue

        comb_list = list(combinations(S_idx[c], 2))
        i = 1

        f = True
        while f:
            i += 1
            f = False
            for comb in comb_list:
                a = comb[0]
                b = comb[1]
                if S[a: a + i] == S[b: b + i]:
                    f = True

        ans.append(i - 1)

    print(max(ans))


if __name__ == '__main__':
    p_e()


### FIXED CODE ###

def p_e():
    N = int(input())
    S = input()

    l, r, ans = 0, 0, 0

    while r < N:
        if S[l:r] in S[r:N]:
            ans = max(ans, r - l)
            r += 1
        else:
            l += 1

    print(ans)


if __name__ == '__main__':
    p_e()
import math
import sys
sys.setrecursionlimit(100000)

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

br = [list(map(int, input().split())) for _ in range(m)]

ans = []

def ncr(n, r):
    if n<r:
        return 0
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

subg = {i+1:i+1 for i in range(n)}

nodes = {i+1:1 for i in range(n)}

res = []
r = ncr(n, 2)

def fetch(i):
    if i == subg[i]:
        return i
    j = fetch(subg[i])
    subg[i] = j
    return j

for a, b in reversed(br):
    # print(subg, nodes)

    if len(nodes.keys()) == 1:
        res.append(0)
        continue
    else:
        res.append(r)

    mi, ma = min(a,b), max(a,b)
    v, w = max(fetch(mi), fetch(ma)), min(fetch(mi), fetch(ma))
    
    x = nodes[v] 
    y = nodes[w]

    r += ncr(x, 2) + ncr(y, 2)
    r -= ncr(x+y, 2)

    nodes[w] += nodes[v]
    del nodes[v]
    subg[mi] = w
    subg[ma] = w

for i in reversed(res):
    print(i)



### FIXED CODE ###


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

br = [list(map(int, input().split())) for _ in range(m)]

ans = []

def nc2(n):
    if n<2:
        return 0
    return n * (n-1) // 2


class UnionFind:

    def __init__(self, size):
        self.table = [-1 for _ in range(size+1)]
        self.size = [1 for _ in range(size+1)]

    def find(self, x):
        while self.table[x] >= 0:
            x = self.table[x]
        return x

    def union(self, x, y):
        s1 = self.find(x)
        s2 = self.find(y)
        if s1 != s2:
            if self.table[s1] != self.table[s2]:
                if self.table[s1] < self.table[s2]:
                    self.table[s2] = s1
                    self.size[s1] += self.size[s2]
                    self.size[s2] = 0
                else:
                    self.table[s1] = s2
                    self.size[s2] += self.size[s1]
                    self.size[s1] = 0
            else:
                self.table[s1] += -1
                self.table[s2] = s1
                self.size[s1] += self.size[s2]
                self.size[s2] = 0

    def get_size(self, x):
        s1 = self.find(x)
        return self.size[s1]

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

res = []
r = nc2(n)

uf = UnionFind(n)

for a, b in reversed(br):

    res.append(r)

    if not uf.check_same(a,b):
        r -= uf.get_size(a)*uf.get_size(b)

    uf.union(a,b)

for i in reversed(res):
    print(i)
from collections import deque

n, m = map(int, input().split())
E = [[] for i in range(m)]

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

INF = 2 * m

dists = [INF for i in range(n)]

def bfs(cur, pre, dist):
    stack = deque([[cur, pre, dist]])
    while stack:
        cur, pre, dist = stack.popleft()
        if dist < dists[cur]:
            dists[cur] = dist
            for e in E[cur]:
                if e != pre:
                    stack.append([e, cur, dist + 1])
bfs(0, -1, 0)

print('Yes')

# for i in range(1,n):
#     di = dists[i]
#     for e in E[i]:
#         if di - 1 == dists[e]:
#             print(e+1)
#             break


### FIXED CODE ###

from collections import deque

n, m = map(int, input().split())
E = [[] for i in range(n)]

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

INF = 2 * m

dists = [INF for i in range(n)]

def bfs(cur, pre, dist):
    stack = deque([[cur, pre, dist]])
    while stack:
        cur, pre, dist = stack.popleft()
        if dist < dists[cur]:
            dists[cur] = dist
            for e in E[cur]:
                if e != pre:
                    stack.append([e, cur, dist + 1])
bfs(0, -1, 0)

print('Yes')

for i in range(1,n):
    di = dists[i]
    for e in E[i]:
        if di - 1 == dists[e]:
            print(e+1)
            break
スコード 

Copy
Copy
N, R = map(int, input().split())
 
if N > 10:
  print(R)
else:
  ans = R - (100*(10-R))
  print(ans)

### FIXED CODE ###

N, R = map(int, input().split())
 
if N > 10:
  print(R)
else:
  ans = R + (100*(10-N))
  print(ans)
N, M, K = map(int, input().split())

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

i = 0
a = 0
b = 0
time = 0
while True:
    i += 1
    if len(A) == 0:
        time += B[b]
        b += 1
    elif len(B) == 0:
        time += A[a]
        a += 1
    else:
        if A[a] <= B[b]:
            time += A[a]
            a += 1
        elif A[a] > B[b]:
            time += B[b]
            b += 1
    if K < time:
        print(i - 1)
        exit()
    elif len(A) == 0 and len(B) == 0:
        print(i)
        exit()


### FIXED CODE ###

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(len(a)):
    A.append(A[i] + a[i])
for i in range(len(b)):
    B.append(B[i] + b[i])

ans = 0
j = len(B) - 1
for i in range(len(A)):
    if A[i] > K:
        break
    while A[i] + B[j] > K:
        j -= 1
    ans = max(ans, i + j)
print(ans)
a = int(input())
b = int(input())
t = int(input())

x = (t+0.5)%a
return b*x

### FIXED CODE ###

a, b, t = map(int, input().split())

x =int((t+0.5)//a)*b

print(x)
a,b=input().split()
a=int(a)
b=int(b)

if a>8 and b>8
	print(":)")
else:
	print("Yay")

### FIXED CODE ###

a,b=input().split()
a=int(a)
b=int(b)

if a>8 or b>8:
	print(":(")
else:
	print("Yay!")
N = int(input())

P = int(input())

out_range = 10**18

for i in range(N-1):
    tmp = int(input())
    if  P > out_range or tmp > out_range:
        print(-1)
    P = tmp * P

print(P)


### FIXED CODE ###

N = int(input())

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

out_range = 10**18

ans=1
if  0 in P:
    print(0)
    exit()

for i in range(N):
    tmp = P[i]
    ans *= tmp
    if  ans > out_range:
        print(-1)
        exit()

print(ans)
a = int(input())

if a % 2 ==0:
  print(n)
else:
  print(n*2)

### FIXED CODE ###

a = int(input())

if a % 2 ==0:
    print(a)
else:
    print(a*2)
N=input()
sum=0
for i in range(1,N+1):
    if i % 3 != 0 and i % 5 != 0:
        #print(i)
        sum += i
print(sum)


### FIXED CODE ###

N=input()
sum=0
for i in range(1,int(N)+1):
    if i % 3 != 0 and i % 5 != 0:
        #print(i)
        sum += i
print(sum)
alpha2num = lambda c: ord(c) - ord('a') 

s = list(input())
alpha = [[] for i in range(26)]
a = 'abcdefghijklmnopqrstuvwxyz'

for i in range(len(s)):
    alpha[alpha2num(s[i])].append(i)

#print(alpha)

t = list(input())
l = [0] * 26
ans = 0


s_unique = list(set(s))
t_unique = list(set(t))
check = 0

for i in t_unique:
    if i in s_unique:
        pass
    else:
        check = 1

if check == 0:

    for i in range(len(t)):
        if i == 0:
            last = alpha[alpha2num(t[i])][l[alpha2num(t[i])]]
        else:
            if l[alpha2num(t[i])] >= len(alpha[alpha2num(t[i])]):
                l = [0] * 26
                last = tmp
                ans += 1
            else:
                tmp = alpha[alpha2num(t[i])][l[alpha2num(t[i])]]
                l[alpha2num(t[i])] += 1
    #            print(tmp)
                if tmp < last:
                    l = [0] * 26
                    last = tmp
                    ans += 1
                else:
                    last = tmp

#    print(ans)
    print(max(ans * len(s) + tmp + 1, len(s)))

else:
    print(-1)



### FIXED CODE ###

#%%

#%%
import bisect
s = list(input())
t = list(input())
alpha2num = lambda c: ord(c) - ord('a')
count = [0] * 26
count_t = [0] * 26
ind = [[] for _ in range(26)]
for i in range(len(s)):
    count[alpha2num(s[i])] += 1
    ind[alpha2num(s[i])].append(i)
for i in range(len(t)):
    count_t[alpha2num(t[i])] += 1

flag = True
for i in range(26):
    if count_t[i] >= 1 and count[i] == 0:
        flag = False

if flag:
    ans = 0
    tmp = -1
    i = 0
    while True:
        a = bisect.bisect_right(ind[alpha2num(t[i])], tmp)
        #print(i, tmp, a)
        if 0 <= a < count[alpha2num(t[i])]:
            tmp = ind[alpha2num(t[i])][a]
            i += 1
        else:
            tmp = -1
            ans += 1
        if i >= len(t):
            break
    ans = ans * len(s) + tmp + 1
    print(ans)
else:
    print(-1)
s_sum = input()
h = s_sum / 3600
m = (s_sum - 3600*h) / 60
s = s_sum - 3600*h - 60*m

print h + ':' + m + ':' + s

### FIXED CODE ###

s_sum = input()
h = s_sum / 3600
m = (s_sum - 3600*h) / 60
s = s_sum - 3600*h - 60*m

print '%d:%d:%d' % (h,m,s)
グリコ森永事件【完全永久保存版】

### FIXED CODE ###

vowel=['a','i','u','e','o']
print('vowel' if input() in vowel else 'consonant')
n, k, x, y = int(input().split()) for _ in range(4)
t = 0
if n - k > 0:
  t = (n  - k) * y
print(n * x + t)

### FIXED CODE ###

n,k,x,y=(int(input()) for i in range(4))
if n - k > 0:
  ans = k * x + (n - k) * y
else:
  ans = n * x
print(ans)
o, e = input().split()

i = 0
res = []
while True:
    if o[i]:
        res.append(o[i])
    else:
        break
    if e[i]:
        res.append(e[i])
        i += 1
    else:
        break

print(''.join(res))

### FIXED CODE ###

o = input()
e = input()

lo = len(o)
le = len(e)
i = 0
res = []
while True:
    if i == len(o):
        break
    else:
        res.append(o[i])
    if i == len(e):
        break
    else:
        res.append(e[i])
        i += 1

print(''.join(res))
n, m = map(int, input().split())
x = [0] * n

exist = True

if n == 1:
    sc_list = []
    for i in range(m):
        sc_list.append(list(map(int, input().split())))
    for i in range(m-1):
        if sc_list[i][1] != sc_list[i+1][1]:
            exist = False
    if exist:
        x = [sc_list[0][1]]

elif n >= 2:
    for i in range(m):
        s, c = map(int, input().split())
        if s == 1:
            if c == 0:
                exist = False
            else:
                if x[0] != 0 and x[0] != c:
                    exist = False
                else:
                    x[0] = c
        else:
            if x[s-1] != 0 and x[s-1] != c:
                exist = False
            else:
                x[s-1] = c

if n >= 2 and x[0] == 0:
    exist = False
            
if exist:
    print("".join(map(str,x)))
else:
    print(-1)


### FIXED CODE ###

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

exist = True

if n == 1:
    sc_list = []
    for i in range(m):
        sc_list.append(list(map(int, input().split())))
    
    if m >= 2:
        for j in range(m-1):
            if sc_list[j][1] != sc_list[j+1][1]:
                exist = False
    
    if exist:
        if m >= 1:
            x = str(sc_list[0][1])
        elif m == 0:
            x = '0'

elif n >= 2:
    x = [-1] * n

    for i in range(m):
        s, c = map(int, input().split())
        if s == 1:
            if c == 0:
                exist = False
            else:
                if x[0] != -1 and x[0] != c:
                    exist = False
                else:
                    x[0] = c
        else:
            if x[s-1] != -1 and x[s-1] != c:
                exist = False
            else:
                x[s-1] = c

    if x[0] == -1 :
        x[0] = 1
    if exist:
        x = [0 if j == -1 else j for j in x]
        x = "".join(map(str,x))
            
if exist:
    print(x)
else:
    print('-1')
from operator import itemgetter
from scipy.sparse.csgraph import minimum_spanning_tree
from scipy.sparse import csr_matrix

n = int(input())
xy = [list(map(int, input().split())) for _ in range(n)]

xyi = [[x, y, i] for i, (x, y) in enumerate(xy)]
row = []
col = []
cost = []

xyi.sort()
for (x1, y1, i1), (x2, y2, i2) in zip(xyi, xyi[1:]):
    row.append(i1)
    col.append(i2)
    cost.append(min(abs(x1 - x2), abs(y1 - y2)))

xyi.sort(key=itemgetter(1))
for (x1, y1, i1), (x2, y2, i2) in zip(xyi, xyi[1:]):
    row.append(i1)
    col.append(i2)
    cost.append(min(abs(x1 - x2), abs(y1 - y2)))

graph = csr_matrix((cost, (row, col)))
mst = minimum_spanning_tree(graph)
ans = mst.sum().astype(int)
print(ans)


### FIXED CODE ###

from scipy.sparse.csgraph import minimum_spanning_tree
from scipy.sparse import csr_matrix
from operator import itemgetter

n = int(input())
xy = [list(map(int, input().split())) + [i] for i in range(n)]

edge = set()
for key in (itemgetter(0), itemgetter(1)):
    xy.sort(key=key)
    for (x1, y1, i1), (x2, y2, i2) in zip(xy, xy[1:]):
        d = min(abs(x1 - x2), abs(y1 - y2))
        edge.add((i1, i2, d))

u, v, c = zip(*edge)

graph = csr_matrix((c, (u, v)), shape=(n, n), dtype=int)
mst = minimum_spanning_tree(graph, overwrite=True).astype(int)
ans = mst.sum()
print(ans)
n = int(raw_input())
if not n%2:
  print 0.500000000
else:
  print((n/2)/n)

### FIXED CODE ###

n = int(raw_input())
if n ==1:
	print 1
else:
	if not n%2:
	  print(0.500000000)
	else:
	  print((int(n/2)+1)/float(n))
X,N=map(int, input().split())
p=list(map(int,input().split()))   
if N==0:
    print(X)
else:
    for k in range(0,51):
        if not X-k in p:
            print(X-k)
            break 
        elif not X+k in p_list:
            print(X+k)
            break

### FIXED CODE ###

X, N = map(int, input().split())
p_list = list(map(int, input().split()))

if N == 0: 
   print(X)
else:
   for i in range(0,100):
       if not X-i in p_list:
           print(X-i)
           break
       elif not X+i in p_list:
           print(X+i)
           break
x, a = map(int, input())
if (x < a):
    print(0)
else:
    print(10)

### FIXED CODE ###

x, a = map(int, input().split())
if (x < a):
    print(0)
else:
    print(10)
N,M=map(int,input().split(" "))
A=list(sorted(map(int,input().split(" "))))
L=sorted([A[s]-A[s+1] for s in range(M-1)])
print(abs(sum(L[N-1:])))

### FIXED CODE ###

A,B=map(int,input().split(" "))
print('{:.10f}'.format(A/B))
N, Q = map(int, input().split())
count = [0] * (N + 1)
g = [[] for _ in range(N+1)]
for _ in range(N - 1):
    a, b = map(int, input().split())
    g[a].append(b)
    g[b].append(a)
for _ in range(Q):
    v, val = map(int, input().split())
    count[v] += val
q = collections.deque()
q.append(1)
check = [0] * (N + 1)
while q:
    v = q.pop()
    check[v] = 1
    for u in g[v]:
        if check[u] == 1:
            continue
        count[u] += count[v]
        q.append(u)
print(*count[1:])

### FIXED CODE ###

import collections
N, Q = map(int, input().split())
count = [0] * (N + 1)
g = [[] for _ in range(N+1)]
for _ in range(N - 1):
    a, b = map(int, input().split())
    g[a].append(b)
    g[b].append(a)
for _ in range(Q):
    v, val = map(int, input().split())
    count[v] += val
q = collections.deque()
q.append(1)
check = [0] * (N + 1)
while q:
    v = q.pop()
    check[v] = 1
    for u in g[v]:
        if check[u] == 1:
            continue
        count[u] += count[v]
        q.append(u)
print(*count[1:])
import sys
import math
N = int(input())
array = list(map(int,input().split()))
set_array = set(array)

if not ( 3 <= N <= 10**5 and N % 2 == 1 ): sys.exit()
if len(array) == len(list(set_array)): print(0);sys.exit()

print(len(list(set_array))) if len(list(set_array)) % 2 == 1 else print(len(list(set_array) - 1))

### FIXED CODE ###

import sys
import math
N = int(input())
array = list(map(int,input().split()))
set_array = set(array)

if not ( 3 <= N <= 10**5 and N % 2 == 1 ): sys.exit()

print(len(list(set_array))) if len(list(set_array)) % 2 == 1 else print(len(list(set_array)) - 1)
f=0
while 1:
  a,　b = map(int, raw_input().split())
  if a==b==0: break
  x = [i for i in range(a, b+1) if (i%4　==　0 and (i%100　!= 0 or i%400 == 0))]
  if x==[]: x=["NA"]

  if f: print
  for e in x: print e
  f=1

### FIXED CODE ###

f=0
while 1:
  a, b = map(int, raw_input().split())
  if a==b==0: break
  x=[i for i in range(a,b+1) if (i%4==0 and (i%100!=0 or i%400==0))]
  if x==[]: x=["NA"]

  if f: print
  for e in x: print e
  f=1
data_list = [
    1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51
]
k = int(input())
print(data_list[k])


### FIXED CODE ###

data_list = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
k = int(input())
print(data_list[k - 1])
import sys
from itertools import permutations

def main():
	while True:
		n = input()
		k = input()
		if n == k == 0:
			sys.exit(0)
		for i in xrange(n):
			input()
#		nums = [raw_input().strip() for i in xrange(n)]
#		result = set(["".join(p) for p in permutations(nums, k)])
#		print (len(result))

if __name__ == '__main__':
	sys.exit(main())

### FIXED CODE ###

import sys
from itertools import permutations
 
def main():
	while True:
		line = raw_input()
		if line == "0 0": break
		n = int(line)
		k = input()
		nums = [raw_input().strip() for i in xrange(n)]
		result = set(["".join(p) for p in permutations(nums, k)])
		print (len(result))

if __name__ == '__main__':
	sys.exit(main())
N = int(input())
H = [int, input().split(' ')]

counter = -1
last_h = float('inf')
_max = 0
for h in H:
    if h <= last_h:
        counter += 1
    else:
        if _max < counter:
            _max = counter
        counter = 0
    last_h = h
if _max < counter:
    _max = counter
print(_max)


### FIXED CODE ###

N = int(input())
numbers = [int(n) for n in input().split(' ')]
distances = []
if N == 1:
    print(0)
else:
    counter = 0
    for i in range(0, len(numbers)):
        if i == len(numbers) - 1:
            distances.append(counter)
            break
        if numbers[i] >= numbers[i + 1]:
            counter += 1
        else:
            distances.append(counter)
            counter = 0

    print(max(distances))
n, q = list(map(int, input().split(' ')))
inf = [[] for _ in range(n+1)]
p_list = [0 for _ in range(n+1)]

for i in range(n-1):
    a, b = list(map(int, input().split(' ')))
    inf[a].append(b)

def add_p(num, point):
    if len(inf[num]) == 0:
        p_list[num] += point
        return 0
    p_list[num] += point
    for next_num in inf[num]:
        print(next_num, point)
        add_p(next_num, point)
    return 0
for i in range(q):
    p, x = list(map(int, input().split(' ')))
    add_p(p, x)
result = p_list[1:]
result = list(map(str, result))
print(' '.join(result))

### FIXED CODE ###

def main():
    n, q = map(int, input().split(' '))
    import sys
    from collections import deque
    sys.setrecursionlimit(10**7)

    visit = [True for _ in range(n)]
    point = [0 for _ in range(n)]
    dic = [[] for _ in range(n)]
    for _ in range(n-1):
        a, b = map(int, input().split(' '))
        dic[a-1].append(b-1)
        dic[b-1].append(a-1)
    for _ in range(q):
        p, x = map(int, input().split(' '))
        point[p-1] += x
    next_visit = deque()
    next_visit.append(0)
    visit[0] = False
    counter = 1
    while counter < n:
        t = next_visit.pop()
        for s in dic[t]:
            if visit[s]:
                point[s] += point[t]
                visit[s] = False
                counter += 1
                next_visit.append(s)
    print(*point)
if __name__ == '__main__':
    main()
import sys
import collections
input = lambda: sys.stdin.readline().rstrip("\r\n")

## taken from GFG

class Graph:
    
	def __init__(self,V): 
		self.V = V 
		self.adj = [[] for i in range(V)] 

	def DFSUtil(self, temp, v, visited): 
		visited[v] = True
		temp.append(v) 
		for i in self.adj[v]: 
			if visited[i] == False: 
				temp = self.DFSUtil(temp, i, visited) 
		return temp
        
	def addEdge(self, v, w): 
		self.adj[v].append(w) 
		self.adj[w].append(v) 

	def connectedComponents(self): 
		visited = [] 
		cc = [] 
		for i in range(self.V): 
			visited.append(False) 
		for v in range(self.V): 
			if visited[v] == False: 
				temp = [] 
				cc.append(self.DFSUtil(temp, v, visited)) 
		return cc 

def solve():
    n, m = map(int, input().split())
    g = Graph(n)
    if m:
        for _ in range(m):
            u, v = map(int, input().split())
            g.addEdge(u - 1, v - 1)
        ans = g.connectedComponents()
        res = - 10 ** 10
        for i in ans:
            res = max(res, len(i))
        print(res)
    else:
        print(1)

if __name__=="__main__": 
	solve()

### FIXED CODE ###

import sys
input = lambda: sys.stdin.readline().rstrip('\r\n')

class DSU(object):
    
    def __init__(self, n):
        self.parent = [i for i in range(n)]
        self.rank = [1] * n
        self.cycle = False

    def find(self, key):
        if self.parent[key] != key:
            self.parent[key] = self.find(self.parent[key])
        return self.parent[key]

    def union(self, a, b):
        s1, s2 = self.find(a), self.find(b)
        if s1 != s2:
            if self.rank[s1] < self.rank[s2]:
                self.parent[s1] = s2
                self.rank[s2] += self.rank[s1]
            else:
                self.parent[s2] = s1
                self.rank[s1] += self.rank[s2]
        else:
            self.cycle = True
        
    def has_cycle(self):
        return self.cycle
    
    def show_parent(self):
        return self.parent

    def show_rank(self):
        return self.rank

def solve():
    n, m = map(int, input().split())
    d = DSU(n + 1)
    if m > 0:
        for _ in range(m):
            a, b = map(int, input().split())
            d.union(a, b)
        # print(d.show_parent())
        print(max(d.show_rank()))
    else:
        print(1)

solve()
h,n = map(int,input.split())
a = list(map,input().split())

if sum(a) >= h:
    print('Yes')
else:
    print('No')


### FIXED CODE ###

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

if sum(a) >= h:
    print('Yes')
else:
    print('No')
a = int(input())
if a =< 1000:
    b = a//1000
else:
    b = a//1000 + 1
print(b*1000 - a)

### FIXED CODE ###

a = int(input())
if a == 1000:
    b = 1
elif a %1000 == 0:
    b = a//1000
else:
    b = a//1000 + 1
print(b*1000 - a)
n = int(input())
H = [int(i) for i in input().split()]

mi = -1
for i in range(n):
    if mi < H[i]:
        mi = H[i] - 1
    elif mi > H[i]:
        print('No')
        sys.exit()
print('Yes')

### FIXED CODE ###

n = int(input())
H = [int(i) for i in input().split()]

mi = -1
rs = 'Yes'
for i in range(n):
    if mi < H[i]:
        mi = H[i] - 1
    elif mi > H[i]:
        rs = 'No'
        break
print(rs)
a, b = input().split()
ai = int(a)
bf = froat(b)
print(int(ai*bf))

### FIXED CODE ###

a, b = map(int, input().replace(".", "").split())
print(a*b//100)