Harryxun/stf_run huggingface dataset:
# 2020-05-22
from collections import deque


def main():
    n, m, k = [int(x) for x in input().split()]
    friends = [set() for _ in range(n)]
    blocks = [set() for _ in range(n)]
    for _ in range(m):
        a, b = [int(x) - 1 for x in input().split()]
        friends[a].add(b)
        friends[b].add(a)
    for _ in range(k):
        a, b = [int(x) - 1 for x in input().split()]
        blocks[a].add(b)
        blocks[b].add(a)

    networks = {}  # The dict of networks as sets. Keys are leaders.
    net_leaders = [-1] * n  # The leaders of the networks that the ones joined.
    visited = [False] * n
    for person in range(n):
        if visited[person]:
            continue
        networks[person] = set()
        stack = deque([person])
        while stack:
            new = stack.pop()
            for adj in friends[new]:
                if visited[adj]:
                    continue
                stack.append(adj)
                networks[person].add(adj)
                visited[adj] = True
                net_leaders[adj] = person

    answers = []
    for person in range(n):
        net = networks[net_leaders[person]]
        ans = len(net) - len(friends[person]) - 1
        bb = len(net & blocks[person])
        answers.append(ans - bb)

    print(*answers)
    return


if __name__ == '__main__':
    main()


### FIXED CODE ###

# 2020-05-22
def main():
    n, m, k = [int(x) for x in input().split()]
    friends = [set() for _ in range(n)]
    blocks = [set() for _ in range(n)]
    for _ in range(m):
        a, b = [int(x) - 1 for x in input().split()]
        friends[a].add(b)
        friends[b].add(a)
    for _ in range(k):
        a, b = [int(x) - 1 for x in input().split()]
        blocks[a].add(b)
        blocks[b].add(a)

    networks = {}  # The dict of networks as sets. Keys are leaders.
    net_leaders = [-1] * n  # The leaders of the networks that the ones joined.
    visited = [False] * n
    for person in range(n):
        if visited[person]:
            continue
        network = set()
        network_add = network.add
        stack = [person]
        stack_append = stack.append
        stack_pop = stack.pop
        while stack:
            new = stack_pop()
            visited[new] = True
            net_leaders[new] = person
            network_add(new)
            for adj in friends[new]:
                if visited[adj]:
                    continue
                stack_append(adj)
        networks[person] = network

    answers = []
    answers_append = answers.append
    for person in range(n):
        net = networks[net_leaders[person]]
        ans = len(net) - len(friends[person]) - 1
        for block in blocks[person]:
            if block in net:
                ans -= 1
        answers_append(ans)

    print(*answers)
    return


if __name__ == '__main__':
    main()
print("YNeos"["9"not in input()::2])
print("Yes"if"9"in input()else"No")

### FIXED CODE ###

print("Yes" if input().count("9") > 0 else "No")
N = int(input())
count = 0
a = []
b = input()
c = b.split()
for i in range(N):
    a.append(int(c[i]))

for i in range(1,N):
    if a[i] == a[i-1]:
        a[i] = a[i+1] + 1
        count = count + 1

print(count)

### FIXED CODE ###

N = int(input())
a = list(map(int,input().split()))
count = 0

if N != 2:
    for i in range(1,N-1):
        if a[i] == a[i-1]:
            a[i] = a[i+1] + 1
            count = count + 1
else:
    if a[0] == a[1]:
        a[0] = a[1]+1
        count = count + 1

if a[N-2] == a[N-1]:
    count = count + 1

print(count)
input(a,b)

c = a * b
if c % 2 == 0:
  print("Even")
  else:
    print("Odd")
    

### FIXED CODE ###

a,b=map(int,input().split())
print("Even" if a*b%2==0 else "Odd")
N = int(input())
A = list(map(int, input.split()))

O = A.copy()

for i in A:
    for j in A:
        if i != j:
            if (i%j == 0):
                if i in O:
                    O.remove(i)

ans = len(O)

print(ans)

### FIXED CODE ###

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


mx = max(A)
x = [0] * (mx + 1) # len(x)
for i in A:
    x[i] += 1
for i in range(1, mx + 1):
    if x[i] != 0:
        for j in range(2 * i, mx + 1, i):
            x[j] = 0
    if x[i] > 1:
        x[i] = 0
print(sum(x))
D, T, S = input() 


if T-D/S >= 0
	print("Yes")
  
  else print("No")
  
  

### FIXED CODE ###

D,T,S = map(int, input().split())

if T-D/S >= 0:
    print("Yes")
else:
    print("No")
n=int(input())

p=n[0]*n[1]
if p%2==0:
  print('Even')
else:
  print('Odd')

### FIXED CODE ###

a,b=map(int,input().split())
p=a*b
if p%2==0:
  print('Even')
else:
  print('Odd')
S = input()

num = len(S)
S1 = S[:(num-1)/2]
S2 = S[(num+3)/2:]

if S == S[::-1] and S1 == [::-1] and S2 == [::-1]:
  print('Yes')
else:
  print('No')

### FIXED CODE ###

S = input()

num = len(S)
S1 = S[:(num-1)//2]
S2 = S[(num+1)//2:]

if S == S[::-1] and S1 == S1[::-1] and S2 == S2[::-1]:
  print('Yes')
else:
  print('No')
#!/usr/bin/env python3

from copy import copy
from math import gcd

def all_gcd(numbers):
    result = numbers[0]
    for v in numbers:
        result = gcd(result, v)
    return result

def main():
    n = int(input())
    a = list(map(int, input().split()))
    max_gcd = 0
    for i in range(n):
        b = copy(a)
        del b[i]
        bgcd = all_gcd(b)
        if max_gcd < bgcd:
            max_gcd = bgcd
    print(max_gcd)




if __name__ == '__main__':
    main()


### FIXED CODE ###

#!/usr/bin/env python3
 
from fractions import gcd
 
def all_gcd(numbers):
    result = numbers[0]
    for v in numbers:
        result = gcd(result, v)
    return result
 
def main():
    n = int(input())
    a = list(map(int, input().split()))
    # x[i] = gcd 0 to i
    x = []
    for i in range(n):
        prev = 0 if i == 0 else x[i - 1]
        x.append(gcd(a[i], prev))
    # y[i] = gcd i to n
    y = [0] * n
    y[n-1] = a[n-1]
    for i in range(2, n + 1):
        y[n-i] = gcd(y[n-i+1], a[n-i])

    max_gcd = 0
    for i in range(n):
        if i == 0:
            now_gcd = y[1]
        elif i == n-1:
            now_gcd = x[n-2]
        else:
            now_gcd = gcd(x[i-1], y[i+1])
        if now_gcd > max_gcd:
            max_gcd = now_gcd
    print(max_gcd)
 
if __name__ == '__main__':
    main()
N, Q = map(int, input().split())
    S = input()

    for i in range(Q):
        left, right = map(int, input().split())
        print(len(S[left-1:right].split("AC"))-1)


### FIXED CODE ###

import collections

N, Q = map(int, input().split())
S = input()

new_S = S.replace("AC", "12")


count_one_list = [0] * len(S)
for i in range(len(S)-1):
    if new_S[i] == '1' and i == 0:
        count_one_list[i+1] += 1
    elif new_S[i] == '1':
        count_one_list[i+1] = count_one_list[i] + 1
    else:
        count_one_list[i+1] = count_one_list[i]
# count_one_list = [new_S[:i].count('1') for i in range(len(S))]
# print(count_one_list)

for i in range(Q):
    left, right = map(int, input().split())
    count_one = count_one_list[right-1] - count_one_list[left-1]
    print(count_one)
d,n = map(int,input().split())

if d == 0:
    if n == 100:
        print(101)
    else:
        if n == 100:
        print(n)
else:
    if n == 100:
        print(100**d * 101)
    else:
        print(100**d * n)

### FIXED CODE ###

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

if d == 0:
    if n == 100:
        print(101)
    else:
        print(n)
else:
    if n == 100:
        print(100**d * 101)
    else:
        print(100**d * n)
N,M=map(int,input().split())


A=[int(i) for i in (input().split(" "))]

A.sort()

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

BC.sort(key=lambda x:x[1],reverse=True)

for b,c in BC:
    A.expend([c]*b)
    if len(A)>2*N:
        break

A.sort(reverse=True)
suma=0
#for i in A:
#    suma+=i

print(sum(A[:N]))

### FIXED CODE ###


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


A=[int(i) for i in (input().split(" "))]

A.sort()

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

BC.sort(key=lambda x:x[1],reverse=True)

for b,c in BC:
    A.extend([c]*b)
    if len(A)>2*N:
        break

A.sort(reverse=True)
suma=0
#for i in A:
#    suma+=i

print(sum(A[:N]))
N = int(input())
arr = input()

mother = 0
for i in arr:
  if i != " ":
  	mother = mother + 1 / int(i) 

print(1/mother)

### FIXED CODE ###

N = int(input())
arr = input()

hoge = arr.split(" ")

mother = 0
for i in hoge:
  mother = mother + 1 / int(i) 

print(1/mother)
d = ["-","SAT","FRI","THU","WED","TUR","MON","SUN"]
input()
for n,s in enumerate(d):
    if s == S:
        print(n)


### FIXED CODE ###

d = ["-","SAT","FRI","THU","WED","TUE","MON","SUN"]
S = input()
for n,s in enumerate(d):
    if s == S:
        print(n)
O=[]
O= input().split()
LO=int(len(O))
E= input().split()
LE=len(E)

flist=[]

for i in range(LO):
    if i>LE:
        a=O[i]
        flist.append(a)
    else:
        a=O[i]+E[i]
        flist.append(a)
b=join.flist
print(b)

### FIXED CODE ###

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

if (a-b==b-c):
    print("YES")
else:
    print("NO")
Q = int(input())
query = [list(map(int, input().split())) for _ in range(Q)]

def is_prime(n):
  if n <= 1:
    return False
  if n == 2:
    return True
  i = 2
  while i * i <= n:
    if n % i == 0:
      return False
    i += 1
  return True

prime = []
ans = [0]*10001
sum_a = [0]*10001
for n in range(3, 10000):
  if is_prime(n) and is_prime((n+1)//2):
    prime.append(n)
    ans[n] = 1
  sum_a[n] = sum_a[n-1] + ans[n]

for l, r in query:
  print(sum_a[r] - sum_a[l-1])

### FIXED CODE ###

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

def is_prime(n):
  if n <= 1:
    return False
  if n == 2:
    return True
  i = 2
  while i * i <= n:
    if n % i == 0:
      return False
    i += 1
  return True

prime = []
ans = [0]*100001
sum_a = [0]*100001
for n in range(1, 100000+1):
  if is_prime(n) and is_prime((n+1)//2):
    if n != 2:
      prime.append(n)
      ans[n] = 1
  sum_a[n] = sum_a[n-1] + ans[n]

for l, r in query:
  print(sum_a[r] - sum_a[l-1])
n=int(input())
import math
a=2
def lcm(a,n):
    return (a*n)//math.gcd(a,n)
print(lcm(a,n))

### FIXED CODE ###

a=int(input())
b=2
def gcd(a,b):
    while b!=0:
        a,b=b,a%b
    return a
def lcm(a,b):
    return a*b//gcd(a,b)
print(lcm(a,b))
import math
a,b=map(int, input().split())
print(math.gcd(a,b))

### FIXED CODE ###

a,b=map(int, input().split())
a=a%b
if a==0:
    print(0)
else:
    arr=[]
    arr.append(a)
    while True:
        a=abs(a-b)
        if sum(x == a for x in arr)==1:
            break
        else:
            arr.append(a)

    print(min(arr))
import math
mod=1000000007
n=int(input())
iwashi_group={}

#傾きを第1象限(True)と第4象限(False)の座標で管理する
for i in range(n):
    a,b=map(int,input().split())
    
    if a*b>0:
        GCD=math.gcd(abs(a),abs(b))
        iwashi=(abs(a)//GCD,abs(b)//GCD)
        flag=True
    
    elif a*b<0:
        GCD=math.gcd(abs(a),abs(b))
        iwashi=(abs(b)//GCD,abs(a)//GCD)
        flag=False

    elif a==0 and b==0:
        Flag=True
        continue

    elif a==0:
        iwashi=(0,1)
        flag=True
    
    elif b==0:
        iwashi=(0,1)
        flag=False
  
    if iwashi in iwashi_group:
        if flag:
            iwashi_group[iwashi][0]+=1
        else:
            iwashi_group[iwashi][1]+=1
    else:
        if flag:
            iwashi_group[iwashi]=[1,0]
        else:
            iwashi_group[iwashi]=[0,1]

ans=1
for a,b in iwashi_group.values():
    ans=ans*(2**a+2**b-1)%mod
if Flag:
    print(ans)
else:
    print(ans-1)

### FIXED CODE ###

import math
mod=1000000007
n=int(input())
iwashi_group={}
count=0

#傾きを第1象限(True)と第4象限(False)の座標で管理する
for i in range(n):
    a,b=map(int,input().split())
    
    if a*b>0:
        GCD=math.gcd(abs(a),abs(b))
        iwashi=(abs(a)//GCD,abs(b)//GCD)
        flag=True
    
    elif a*b<0:
        GCD=math.gcd(abs(a),abs(b))
        iwashi=(abs(b)//GCD,abs(a)//GCD)
        flag=False

    elif a==0 and b==0:
        count+=1
        continue

    elif a==0:
        iwashi=(0,1)
        flag=True
    
    elif b==0:
        iwashi=(0,1)
        flag=False
  
    if iwashi in iwashi_group:
        if flag:
            iwashi_group[iwashi][0]+=1
        else:
            iwashi_group[iwashi][1]+=1
    else:
        if flag:
            iwashi_group[iwashi]=[1,0]
        else:
            iwashi_group[iwashi]=[0,1]

ans=1
for a,b in iwashi_group.values():
    ans=ans*(2**a+2**b-1)%mod

print((ans+count-1)%mod)
import math
A, B, N = list(map(int, input().split(" ")))
if B > N:
    print(math.floor(A*i/B) - A * math.floor(i/B))
else:
    print(math.floor(A*(B-1)/B))

### FIXED CODE ###

import math
A, B, N = list(map(int, input().split(" ")))
if B > N:
    print(math.floor(A*N/B) - A * math.floor(N/B))
else:
    print(math.floor(A*(B-1)/B))
a,b = map(int,input().split())
print a*b + ' ' + (a*b)*2

### FIXED CODE ###

foo,bar = map(int,raw_input().split())
print '%d %d' % (foo*bar,(foo+bar)*2)
s=map(int,input().split());print(["No","Yes"[s in[1,3,5,7,8,10,12]or s in[4,6,9,11]])

### FIXED CODE ###

s=[int(i)for i in input().split()];f=lambda x,l:not(set(x[:])-set(l));print(["No","Yes"][f(s,[1,3,5,7,8,10,12])or f(s,[4,6,9,11])or f(s,[2])])
K=int(input())
n=0
c=0
while 1:
  j=True
    if len(n_str) > 1 and abs(int(n_str[0]) - int(n_str[1])) > 1:
    n = (int(str(int(n_str[0])+1)+str(int(n_str[0]))))*(10**(len(n_str)-2))
  else:
    n+=1
  n_str=str(n)
  for i in range(len(n_str)-1):
    if abs(int(n_str[i]) - int(n_str[i+1])) > 1:
      j=False
  if j:
    c+=1
  if c==K:
    print(n)
    break


### FIXED CODE ###

from collections import deque
K=int(input())
Q=deque(list(range(1,10)))
for _ in range(K):
  x=Q.popleft()
  if x%10 != 0:
    Q.append(10*x+x%10-1)
  Q.append(10*x+x%10)
  if x%10 != 9:
    Q.append(10*x+x%10+1)
print(x)
n=int(input())
a=list(map(float,input().split()))
s=1

for i in range(n):
  s *= a[i]

b=s/a

### FIXED CODE ###

import numpy as np

n=int(input())
a=list(map(float,input().split()))
s=1

for i in range(n):
  s *= a[i]

b=[s/a[j] for j in range(n)]

print(s/np.sum(b))
from fractions import gcd

N, M = list(map(int, input().split()))
S = input()
T = input()

# L = (N * M) // gcd(N, M)
# L = int((N * M) / gcd(N, M))
g = gcd(N, M)
nm = N * M
L = g // nm
# L = 10 ** 5 + 10

L1 = [1]
L2 = [1]
for i in range(1, N):
    t = i * (L // N) + 1
    L1.append(t)

for i in range(1, M):
    t = i * (L // M) + 1
    L2.append(t)

LS = [None] * L
for i, li in enumerate(L1):
    ind = li-1
    LS[ind] = S[i]

ans = True
for i, li in enumerate(L2):
    ind = li-1
    if LS[ind] is not None:
        if LS[ind] != T[i]:
            ans = False

if ans:
    print(L)
else:
    print(-1)


# print(L1)
# print(L2)
# print(LS)

### FIXED CODE ###

from fractions import gcd

N, M = list(map(int, input().split()))
S = input()
T = input()

L = (N * M) // gcd(N, M)

L1 = [0]
L2 = [0]

from collections import Counter
c = Counter()

for i in range(1, N):
    t = i * (L // N) + 1
    L1.append(t-1)

for i in range(1, M):
    t = i * (L // M) + 1
    L2.append(t-1)


d = {}
for i, li in enumerate(L1):
    d[li] = S[i]

# print(d)

ans = True

for i, li in enumerate(L2):
    if not d.get(li):
        continue
    if d[li] != T[i]:
        ans = False

# print(L1)
# print(L2)
# print(common)
# print(dic)

if ans:
    print(L)
else:
    print(-1)
n = int(input())
h = list(map(int, input().split()))
count = [0]
ans = []

for i in range(n-1):
  if h[i] < h[i+1]:
    count.append(i+1)
  if i == n - 2:
    if h[n-2] >= h[n-1]:
      count.append(n)

for i in range(len(count) - 1):
  ans.append(count[i+1] - count[i] - 1)

print(max(ans))


### FIXED CODE ###

n = int(input())
h = list(map(int, input().split()))
count = [0]
ans = []

for i in range(n-1):
  if h[i] < h[i+1]:
    count.append(i+1)
  if i == n - 2:
    if h[n-2] >= h[n-1]:
      count.append(n)

for i in range(len(count) - 1):
  ans.append(count[i+1] - count[i] - 1)

if n == 1:
  print(0)
else:
  print(max(ans))
n = int(input())
graph = [[float('inf') for _ in range(n)] for _ in range(n)]
graph1 = {i:[] for i in range(n)}
for _ in range(n-1):
  u,v,w = map(int,input().slpit())
  graph[u-1][v-1] = w
  graph[v-1][u-1] = w
  graph1[u].append(v)
  graph1[v].append(u)
  
  
color = [-1 for i in range(n)] 
def dfs(i,j):#(child, parent)
  if color[i] != -1:
    return
  if graph[i][j] %2:
    color[i] = 1 -color[j]
  else:
    color[i] = color[j]
  for k in graph1[i]:
    if k ==j:
      continue
    dfs(k,i)
dsf(0,-1)

for i in range(n):
  print(color[i])

### FIXED CODE ###

import sys
input = sys.stdin.readline
n = int(input())
d = {}
graph = {i:[] for i in range(n)}
for _ in range(n-1):
  u,v,w = map(int,input().split())
  d[(u-1,v-1)] = w
  graph[u-1].append(v-1)
  graph[v-1].append(u-1)
  
  
color = [-1 for i in range(n)] 
color[0] = 0
from collections import deque
queue =deque([0])

while queue:
  p = queue.popleft()
  color_p = color[p]
  for i in graph[p]:
    if color[i] != -1:
      continue
    else:
      if d[(min(i,p),max(i,p))] %2:
        color[i] = 1 - color_p
      else:
        color[i] = color_p
      queue.append(i)

for i in range(n):
  print(color[i])
X, Y, Z = list(map(int, input().split(" ")))

import numpy as np

ABC = []

for i in range(X+Y+Z):
    ABC.append(list(map(int, input().split(" "))))

ABC = sorted(ABC, key=lambda row: row[0]-row[1])    

ans = 0

ABC_bk = ABC_np[:Y]
ABC_ak = ABC_np[Y:]

for k in range(Y, Y+Z):
    
    ABC_bk = ABC_bk + ABC_ak[0]
    ABC_ak = ABC_ak.pop(0)
    
    
    before_k = np.asarray(sorted(ABC_bk.tolist(), key=lambda row: row[1]-row[2]))
    after_k = np.asarray(sorted(ABC_ak.tolist(), key=lambda row: row[0]-row[2]) )      
    
    bk_sum = before_k[-Y:].sum(axis=0)[1] + before_k[:-Y].sum(axis=0)[2]
    ak_sum = after_k[-X:].sum(axis=0)[0] + after_k[:-X].sum(axis=0)[2]
    
    tmp = ak_sum + bk_sum
                          
    if ans < tmp:
        ans = tmp
    
print (ans)

### FIXED CODE ###

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

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

ans = False

A = sorted(A)

key = 99999999999999
    
if A[-1] < K:
    ans = False

else:
    for i in range(2, A[0]+1):
        key_flag = True
        for a in A:
            if a % i !=0:
                key_flag = False
                break
                
        if key_flag == True:
            key = i
            break

    if key_flag == False:
        ans = True
#         print(1)
    elif K % key == 0:
        ans = True
#         print(2)
    else:
#         print(3)
        ans = False           
    
if ans == True:
    print("POSSIBLE")
else:
    print("IMPOSSIBLE")
import math

r = imput()

print("%f %f" % (math.pi * r ** 2, 2 * math.pi * r))

### FIXED CODE ###

import math

r = input()

print("%f %f" % (math.pi * r ** 2, 2 * math.pi * r))
a,b,c = input().split(,)
print(a,b,c)

### FIXED CODE ###

a,b,c = input().split(',')
print(a,b,c)
x,y=map(int,input().split())
printint((x+y/2))

### FIXED CODE ###

x,y=map(int,input().split())
print(int(x+y/2))
n = int(input())

sum_a_rev = 0

for i in range(n):
    val = int(input())
    sum_a_rev = sum_a_rev + 1/val

res = 1/sum_a_rev

print("{}".format(res))



### FIXED CODE ###

n = int(input())

a = input().split()

sum_a_rev = 0

for i in range(n):
    sum_a_rev = sum_a_rev + 1/int(a[i])

res = 1/sum_a_rev

print("{}".format(res))
w = input()

f = True
for s in w:
  a = w.count(s)
  if a%2 != 0:
    f = Flase
    break
 
if f:
  print("Yes")
else:
  print("No")

### FIXED CODE ###

w = input()
 
f = True
for s in w:
	a = w.count(s)
	if a%2 != 0:
		f = False
		break
 
if f:
  print("Yes")
else:
  print("No")
import numpy as np

MOD = 10**9+7

D,T,E = input().split()
n= int(D)

arr = np.zeros((n+1,n+1),dtype=np.int16)
for i in np.arange(3,n+1):
    arr[0,i] = 1

for i in np.arange(1,n+1):
    sum_ = 0
    for j in np.arange(3*i,n+1):
        sum_ += arr[i-1,j]
        sum_ %= MOD
        if j+3 >= n + 1:
            break
        arr[i,j+3] = sum_

ans = 0
for i in range(n+1):
    ans += arr[i,n]
    ans %= MOD
print(ans)










### FIXED CODE ###

D,T,S = [int(i) for i in input().split()]
out = 'Yes' if D <= T * S else 'No'
print(out)
a, b, c = [int(x) for x in in input().split()]

if sorted([a, b, c]) == [5, 5, 7]: print("YES")
else: print("NO")

### FIXED CODE ###

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

if sorted([a, b, c]) == [5, 5, 7]: print('YES')
else: print('NO')
n, k, x, y = [map(int(input()), for i in range(4))]
print(x*n - (x - y)*max(0, n-k))


### FIXED CODE ###

n,k,x,y=[int(input()) for i in range(4)]
print(n*x-(x-y)*max(n-k,0))
andy = list(map(int, input().split()))

S = sorted(candy, reverse = True)
if S[0] == S[1] + S[2]:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

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

S = sorted(candy, reverse = True)
if S[0] == S[1] + S[2]:
    print("Yes")
else:
    print("No")
n = int(input())
P = [int(x) for x in input().split()]

counter = 1
for i in range(1,n):
    if any( x< P[i] for x in  P[0:i] ):
            break
    else:
        counter +=1

print(counter)

### FIXED CODE ###

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

if n==m :
    print('Yes')
else:
    print('No')
import math
A,B,C,D = map(int,input().split())
cnt = 0
# print(B//C)
# print(A//C)
# print(B//D)
# print(A//D)
# print()
cnt += ((B // C) - ((A-1) // C))
# print(cnt)
cnt += ((B // D) - ((A-1) // D))
# print(cnt)

# print()
# print(B-A+1-cnt)

# かぶっているのを足し戻す
tmp = 0
def lcm(x,y):
    return (x * y) // math.gcd(x,y)
# print(lcm(C,D))

# print(B//lcm(C,D))
# print(A//lcm(C,D))
tmp = ((B//lcm(C,D)) - (A//lcm(C,D)))

print(B-A+1-cnt+tmp)


### FIXED CODE ###

from fractions import gcd

def lcm(a, b):
    return a // gcd(a, b) * b

A,B,C,D = list(map(int,input().split()))
C1 = B//C
C2 = (A-1)//C
C3 = B//D
C4 = (A-1)//D
C5 = B//lcm(C,D)
C6 = (A-1)//lcm(C,D)
print((B-(A-1))-((C1-C2)+(C3-C4)-(C5-C6)))
import math

N = int(input())

def enum(N,A):
	if(N % A == 0):
		B = N // A
		return (A,B)
	else:
		return 'NULL'

def F(tupleX):
	t = max(tupleX)
	return int(math.log10(t) + 1)

X = []  # 候補
for n in range(1,N):
	X.append(enum(N,n))

Y = [] 
for x in X:
    if (x == 'NULL'):
        continue
    else:
	    y = F(x)
	    Y.append(y)
	
print(min(Y))

### FIXED CODE ###

import math

N = int(input())

def enum(N,A):
    if(N % A == 0):
        B = N // A
        return (A,B)
    else:
        return 'NULL'

def F(tupleX):
    t = max(tupleX)
    return int(math.log10(t) + 1)

X = []
hu = int(math.sqrt(N)) + 1
for n in range(1,hu):
    X.append(enum(N,n))

Y = []
for x in X:
    if (x == 'NULL'):
        continue
    else:
        y = F(x)
        Y.append(y)

print(min(Y))
n=int(input())  #数値入力 「N」だけの入力のとき

S = []
for _ in range(n):
    S.append(set(input()).sort)
print(n-len(set(S))+1)

### FIXED CODE ###

import collections
N=int(input())
S=[''.join(sorted(input())) for _ in range(N)]
C=collections.Counter(S)
ans=0
for si in set(S):
  n=C[si]
  ans+=n*(n-1)//2
print(ans)