peterverebics/CodeNet_Python_118 huggingface dataset:
n = int(input())
li = list(map(int,input().split()))
temp = 0
min = 100000000000000000000000000
for i in range(li[0], li[-1]+1):
    for k in li:
        temp += (k - i)**2
    if temp < min:
        min = temp
    temp = 0
print(str(min))
n=int(input())
x=list(map(int,input().split()))
ans=sum(x)//n+1
print(ans)
v=0
for i in x:
    v+=(i-ans)**2
print(v)
N = int(input())
X = list(map(int, input().split()))

sowa=0
ans=[]
for p in range(0,max(X)):
    for i,x in enumerate(X):
        tairyoku=(x-p)**2
        sowa+=tairyoku
    ans.append(sowa)
    # print(sowa)
    sowa=0
print(min(ans))
n = int(input())
x = list(map(int, input().split()))
x.sort()
res = 10**7
for i in range(x[0],x[-1]):
  tmp = 0
  for j in x:
    tmp += (j-i)**2
  res = min(tmp,res)
print(res)
from statistics import mean
import math
N = (map(int, input().split()))
X = list(map(int, input().split()))
A = mean(X)
A = math.ceil(A)
list =[]
for i in range(0, len(X)):
    B = X[i] - A
    B =pow(B,2)
    list.append(B)
Sum = sum(list)
print(Sum)
N=int(input())
list = list(map(int, input().split()))

c=max(list)
l=len(list)
m=100000000
j=1

while(j<c):
  r=0
  i=0
  while(i<l):
    r+=(list[i]-j) ** 2
    i+=1
  if(r<m):
    m=r
  j+=1

print(m)
import numpy
n = int(input())
l = numpy.array(list(map(int,input().split())))
av = round(numpy.average(l))
square_list = numpy.square(l - av)

print(numpy.sum(square_list))
N = 7
X = [14,14,2,13,56,2,7]
sum = 0
for a in X:
    sum = sum + a
C = sum/N
ans = 0
for b in X:
    ans = ans + (b-C)**2
print(int(ans))
import numpy as np
N = int(input())
X = [int(_) for _ in input().split()]
b = np.polyfit([0 for _ in range(N)], X, 0) #切片だけ
# y = ax + b
P = round(b[0])
res = [(x-P)*(x-P) for x in X]
print(sum(res))
n = int(input())
x = list(map(int, input().split()))

dist_min = 9999
for i in range(min(x),max(x)):
    dist_sum = 0
    for j in range(n):
        dist_sum += (x[j] - i)**2
    if dist_sum < dist_min:
        dist_min = dist_sum

print(dist_min)
n = int(input())
x = list(map(int,input().split()))
y = x
y.sort()
mini = 10000000000000
for i in range(y[-1]):
    tmp = 0
    for j in x:
        tmp += (j - i)**2
    if mini > tmp:
        mini = tmp
print(mini)
N=int(input())
x=list(map(int, input().split()))
M=max(x)

dmin=M**2
for p in range(1,M+1):
  d=0
  for i in range(N):
    d+=(p-x[i])**2
  if d<=dmin:
    dmin=d
print(dmin)
N = int(input())
X = list(map(int, input().split()))

xpos = -(-sum(X)//N)
Xe = map(lambda x:abs(x-xpos)**2, X)
print(sum(Xe))
def solve():
    N = int(input())
    A = list(map(int, input().split()))
    A.sort()
    
    ans = 10 ** 9
    for i in range(A[0], A[-1]):
        c = 0
        for a in A:
            c += (abs(a-i)) ** 2
        ans = min(ans, c)
        
    return ans

print(solve())
N = int(input())
X = list(map(int,input().split()))
tmp = 0
tmp2 = 0
ans = 10 ** 10
for i in range(1,101):
  for a in range(N):
    tmp = abs(X[a] - i) ** 2
    tmp2 = tmp
  ans = min(ans,tmp2)
print(str(ans))
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

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

x.sort()
ave = sum(x) / len(x)
squared = sum([i*i for i in x])

print(Decimal(str(squared - n*(ave)*ave)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
import math
#入力二つ
# n, k = map(int,input().split())

n = int(input())
n_list = list(map(int,input().split(" ")))

min_num = 100000000000000

for p in range(n_list[0], n_list[-1]+1):
    sum = 0
    for j in n_list:
        sum += (j-p)**2

    if sum<min_num:
        min_num = sum

print(min_num)
import numpy as np
n = int(input())
a = list(map(int, input().split()))
t = 0
for i in a:
    t += i
wp = int(t//n + np.sign(t/n))
ans = 0
for i in a:
    ans += (i -wp) **2
print(int(ans))
n=int(input())
a=list(map(int,input().split()))
b=[i**2 for i in a]
#sum_=sum(b)-2*p*sum(a)+n*p**2
c=sum(a)
def tai(p):
    return n*p**2-2*p*c
d=[]
for i in range(min(a),max(a)+1):
    d.append(tai(i+1))
print(min(d)+sum(b))
N = int(input())
X = list(map(int, input().split()))

ans = []
count = 0

for i in range(1,N+1):
    number = 0
    count = 0
    for j in X:
        number = number + ((j-i)**2)
        count = count + 1
        if N == count:
            ans.append(number)

print(min(ans))
N=int(input())
X=list(map(int,input().split()))
c=0
d=sum(X)/N
for i in X:
   c+=(i-d)**2
print(c)
n=int(input())
x=list(map(int,input().split()))
x.sort()
min = 10**15
su=0
for j in range(x[0],x[n-1]):
    for i in x:
        su=(i-j)**2+su  
    if min>su:
        min=su
    su = 0
print(min)
N = int(input())
X = list(map(int, input().split()))

m = min(X)
M = max(X)

cost = [100*100 for _ in range(101)]
for p in range(1,101):
    c = 0
    for x in X:
        c += (x-p)**2
    cost[p] = c

print(min(cost))
# -*- coding: utf-8 -*-
n = int(input())
x = [int(i) for i in input().split()]

ans = 100 * 100
tmp = 0
for i in range(0, 101): #iは集会を開く場所
    for j in range(n):
        tmp += pow(x[j] - i, 2)
    if ans > tmp:
        ans = tmp
    tmp = 0
print(ans)
n=int(input())
x=list(map(int,input().split()))
ans=10**5
for i in range(1,101):
  cnt=0
  for j in range(n):
    cnt+=(i-x[j])**2
  if cnt<ans:
    ans=cnt
print(ans)
n = int(input())
list_x = list(map(int, input().split()))

def cost_calc(list_x, p):
  cost = 0
  for x in list_x:
    cost += (x - p)**2
  return cost

cost = 10**20
for _ in range(min(list_x),max(list_x)):
  tmp = cost_calc(list_x, _)
  if tmp < cost:
    cost = tmp
print(cost)
N = int(input())
X = list(map(int, input().split()))
ans = 100000
for i in range(0,101):
    s = 0
    for j in range(N):
        s+=(X[j]-i)**2
    ans = min(ans,s)
print(ans)
import numpy as np
import collections
from sys import stdin


def get_result(data):
    N, X = data[0][0], data[1:][0]
    X = np.array(X)
    max_X = max(X)
    tmp = np.zeros(max_X)
    for i in range(max_X):
        tmp[i] = np.sum((X - i) ** 2)
    return min(tmp)

if __name__ == '__main__':
    raw_data = [val.rstrip('\n') for val in stdin.readlines()]
    data = [list(map(int, val.split(' '))) for val in raw_data]
    result = get_result(data)
    print(result)
import numpy as np

def main():
    N = int(input())
    A = sorted(map(int, input().split()))
    mean = int(np.mean(A))
    x = np.array(A) - mean
    print(np.dot(x, x))

main()
import math
n = int(input())
x = list(map(int, input().split()))

p = sum(x)/n

h = 0
for i in x:
  h += abs(i - p)**2
print(math.ceil(h))
n = int(input())
x = list(map(int, input().split()))

y = sum(x) / n
ans = 0
for i in x:
  ans += (i-y)**2
print(int(ans)+1)
N = int(input())
X = sorted(list(map(int, input().split(" "))))
min = -1
for i in range(X[0], X[-1]):
  s = sum((x - i) ** 2for x in X)
  if min == -1:
    min = s
  if s < min:
    min = s
print(min)
import math
X = int(input())
L = list(map(int,input().split()))
ans = []
tmp = sum(L)/len(L)
#tmp = int(tmp)
#print("tmp",tmp)
anser = map(lambda x:(x-tmp)**2,L)
print(math.ceil(sum(anser)))
import math
N = int(input())
X = list(map(int,input().split()))
P = math.ceil(sum(X)/N)

hp = 0

for x in X:
  hp_x = (P-x)**2
  hp = hp + hp_x
print(hp)
N = int(input())
X = list(map(int, input().split()))

A = []
for P in range(1,X[N-1]+1):
    for i in range(N):
        A.append((X[i]-P)**2)
    if sum(A[0:N]) < sum(A[N:2*N]) or len(A) == N:
        A = A[0:N]
    else:
        A = A[N:2*N]
print(sum(A))
n = int(input())
x = list(map(int,input().split()))
M = max(x)
s = [0]*(2*M)

for j in range(2*M):
	for i in range(n):
		s[j] += pow(x[i]-(j-M),2)
print(min(s))
n = int(input())
x = [int(i) for i in input().split()]
l, r = 0, 0
for i in x:
    l = min(l, i)
    r = max(l, i)
ans = 10e9
for i in range(l, r + 1):
    cost = 0
    for j in range(n):
        cost += (x[j] - i) * (x[j] - i)
        print(i, j)
    ans = min(ans, cost)
print(ans)
import math
#入力二つ
# n, k = map(int,input().split())

n = int(input())
n_list = list(map(int,input().split(" ")))

min_num = 100000

for i in range(n_list[-1]):
    sum = 0
    for j in n_list:
        sum += (j-i)**2

    if sum<min_num:
        min_num = sum

print(min_num)
import numpy as np

n = input()
x = np.array(list(map(int,input().split())))
# x = np.array(x)
r = np.full(100, 100)

for p in range(100):
    r[p] = np.sum((x - p + 1)**2)
print(np.min(r))
n=int(input())
x=list(map(int,input().split()))
x.sort()
min = 10**10
su=0
for j in range(x[0],x[n-1]):
    for i in x:
        su=(i-j)**2+su
    
    if min>su:
        min=su
    su = 0
print(min)
n = int(input())
a = list(map(int, input().split()))
ans = 100

for i in range(max(a)):
  x = 0
  for j in a:
    x += (i - j) ** 2
  ans = min(x, ans)

print(ans)
n=int(input())
x = list(map(int,input().split()))
ans=10**5
for i in range(1,101):
    d=0
    for j in range(n):
        d+=(i-x[j])**2
    ans=min(ans,d)
print(ans)
n = int(input())
x = list(map(int,input().split()))
m = sum(x) // len(x)+1
l = [] 
for i in x:
  s = (i-m)**2
  if s < 0:
    l.append(-s)
  else:
    l.append(s)
print(sum(l), l, m)
import numpy as np
n=int(input())
x=np.fromstring(input(),int,sep=' ')
print(x)
p=0
hoge=np.inf
for i in range(1,np.max(x)+1):
    sux=sum((x-i)**2)
    if sux<hoge:
        p=i
        hoge=sux
print(hoge)
N = int(input())
X = list(map(int, input().split()))

ans = 10000000

for i in range(1, X[N-1]+1):
    l = 0
    for j in range(N):
        l += (i - X[j]) ** 2
    ans = min(ans, l)

print(ans)
a = int(input())
li = input().split()
c = 0
n = 0
while n < a:
	b = (int(li[n]) - a) ** 2
	c += b
	n += 1
print(c)
n = int(input())
x = list(map(int, input().split()))

ans = 100 * 100
for i in range(100):
  temp = 0
  for j in x:
    temp += pow(j - i, 2)
  if temp < ans:
    ans = temp

print(ans)
import sys
stdin = sys.stdin
import numpy as np

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))

n = ni()
x = na()
m = np.mean(x)
print(int(np.ceil(np.sum(np.square(x - m)))))
n=int(input())
a=list(map(int,input().split()))
b=[0]*max(a)
for i in range(0,max(a)):
  sum=0
  for j in range(0,n):
    sum=sum+(i-a[j])**2
  b[i]=sum
print(min(b))
n = int(input())
x = list(map(int,input().split()))
a = max(x)
b = min(x)
y = 0
ans = 100000

for i in range (b,a+1): #住民がいる間で
  y = 0 #初期化
  for j in x: #体力の総和を計算
    y = y + (j-i)**2
  if y < ans:
    ans = y

print(ans)
import math
n = int(input())
xl = list(map(int, input().split()))
xl_cnt = len(xl)
xl_sum = sum(xl)
xl_avg = xl_sum / xl_cnt
xl_diff = map(lambda x: x - math.ceil(xl_avg), xl)
xl_double = map(lambda x: x * x, xl_diff)
print(sum(xl_double))
n = int(input())
x = list(map(int,input().split()))
anslist = []
for i in range(max(x)):
    ans = 0
    for j in range(len(x)):
        ans += (i-x[j])**2
    anslist.append(ans)
print(min(anslist))
a=int(input())
b=list(map(int,input().split()))
c=sum(b)//a
d=0
for i in b:
    d+=(i-c)**2
    
print(d)
n = int(input())

x = [0] * n

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

x.sort()
sum = 0
min_sum = 100 * 1000
for i in list(range(x[0], x[-1] + 1)):
    sum = 0
    for j in x:
        sum += (j - i) * (j - i)
    if sum < min_sum:
        min_sum = sum
    # else:
    #     break
print(min_sum)
def main():
    N = int(input())
    X = list(map(int, input().split()))
    r = min((x - p) ** 2 for x in X for p in range(1, 101))
    print(r)


main()
N = int(input())
X = map(int,input().split(" "))



S = []
for p in range(1,N+1):
    #pで開催する時の消費体力の総和
    sum_power = 0
    for x in X:
        sum_power += (x-p)**2
    S.append(sum_power)


print(min(S))
# -*- coding: utf-8 -*-
"""
Created on Sun Mar  1 14:34:07 2020

@author: Kanaru Sato
"""

import sys

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

address.sort

ans = 0
total = sys.maxsize

for place in list(range(address[0],address[n-1]+1)):
    tmp = 0
    for i in range(n):
        tmp += (address[i]-place)**2
    if tmp <= total:
        total = tmp

print(total)
n=int(input())
l=list(map(int,input().split()))
lmax=0
for i in range(n):
    if lmax<l[i]:
        lmax=l[i]
sumlist=[]
for i in range(lmax):
    sumlist.append(0)
total=0
for i in range(lmax):
    for j in range(n):
        t=(l[j]-i)*(l[j]-i)
        total+=t
    sumlist[i]=total
    total=0
min=10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
for i in range(lmax):
    if min>sumlist[i]:
        min=sumlist[i]
print(min)
n = int(input())
X = list(map(int, input().split()))
ans = 0

for i in range(1,101):
  tmp = 0
  for x in X:
    if i == 1:
      ans += (i - x)**2
    else:
      tmp += (i - x)**2
      if tmp < ans:
        ans = tmp
    
print(ans)
n=int(input())
x=list(map(int, input().split()))
p=0
t=0
for i in range(n):
  p+=x[i]
p=p//n
for i in range(n):
  t+=(x[i]-p)**2
print(t)
N=int(input())
X=list(map(int,input().split()))
ans=[]
for i in range(max(X)):
    goukei = 0
    for j in range(N):
        if i%1==0:
            goukei+=(X[j]-i)**2
    ans.append(goukei)
kotae=set(ans)
print(min(kotae))
from sys import stdin
import sys
import math
from functools import reduce
import itertools

n = int(stdin.readline().rstrip())
x = [int(x) for x in stdin.readline().rstrip().split()]

p = int(sum(x)/n)
q = p+1

a = sum([(i-p)**2 for i in x])
b = sum([(i-q)**2 for i in x])

print(p,q,a,b)

print(min([a,b]))
N = int(input())
x_list = list(map(int, input().split()))


sumDist = sum(x_list)
p = sumDist // N

ans = 0
for i in range(N):
    ans += (x_list[i] - p)**2
print(ans)
n = int(input())
x = list(map(int, input().split()))

mini = (100-1)**2
for p in range(1, 101):
    temp = 0
    for i in x:
        temp += (i-p)**2
    mini = min(mini, temp)

print(mini)
from sys import stdin
n = int(stdin.readline().rstrip())
s = stdin.readline().rstrip().split()
x = [None]*n
x = [int(s[i]) for i in range(0, n)]

ave = 0
for i in range(0, n):
   ave += x[i]
p = ave//n + 1

sum = 0
for i in range(0, n):
   sum += pow(x[i]-p, 2)
print(sum)
N = int(input())
X = list(map(int, input().split()))
sum = 0
min_sum = 100000000
P =1
if P <= 100:
  for n in X:
    sum = sum +(n-P)**2
  if sum <= min_sum:
    min_sum = sum
  P = P + 1
print(min_sum)
n=int(input())
L=list(map(int,input().split()))
x=int(sum(L)/n)
ans=0
for i in L:
    ans+=pow(i-x,2)
print(ans)
# -*- coding: utf-8 -*-
n = int(input())
x = [int(i) for i in input().split()]

ans = 100 * 100
tmp = 0
for i in range(-1000, 1001): #iは集会を開く場所
    for j in range(n):
        tmp += pow(x[j] - i, 2)
    if ans > tmp:
        ans = tmp
    tmp = 0
print(ans)
A,B,C=map(int,input().split())
answer= False
if A==B or A==C or B==C:
  answer=True
if A==B and A==C and B==C:
  answer=False
print('Yes' if answer else 'No')
a,b,c=map(int,input().split())
if a==b==c or b!=c and b!=a and c!=a:
  print('No')
else:
  print('Yes')
a,b,c = map(int, input().split())

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

def hantei(n1,n2,n3):
  ans="Yes"
  if n1==n2 and n2==n3:
    ans="No"
  if n1!=n2 and n2!=n3 and n3!=n1:
    ans="No"
  return ans

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

n=0

for i in range(0,2):
  if li[i+1] - li[i] ==0:
    n+=1
if li[2] - li[0] ==0:
  n+=1

if n==1:
  print("Yes")
else:
  print("No")
A, B, C = map(int, input().split())

if (A == B and B == C) or (A != B and B != C and C != A):
    print('No')
else:
    print('Yes')
l=list(map(int,input().split()))
if(l[0]==l[1]==l[2]):
  print("No")
elif l[0]==l[1] or l[0]==l[2] or l[1]==l[2]:
  print("Yes")
else:
  print("No")
numbers = map(int, input().split())
print("Yes") if len(set(numbers)) == 2 else print("No")
a,b,c =map(int, input().split())


if a == b and b == c:
    print('No')
elif a == b or b == c or c == a:
    print('Yes')
else:
    print('No')
A, B, C = list(map(int, input().split()))
if (A==B or B==C or C==A) and not (A==B==C):
  print('Yes')
else:
  print('No')
A = [int(_) for _ in input().split()]

if len(set(A)) == 2:
    print('Yes')
else:
    print('No')
# -*- coding: utf-8 -*-

from fractions import gcd
from math import ceil,floor
import collections

# n=int(input())
# A,B,C,D=map(int, input().split())
# string = input()
# list = list(map(int, input().split()))


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

ans = "No"


if A==B and A!=C:
    ans = "Yes"
if A==C and A!=B:
    ans = "Yes"
if B==C and A!=B:
    ans = "Yes"

print(ans)
A = list(map(int, input().split()))
if len(set(A)) == 2:
  print('Yes')
else: print('No')
abc = [int(i) for i in input().split()]
if len(set(abc)) == 2:
    print("Yes")
else:
    print("No")
A, B, C = map(int, input().split())

if len(set([A, B, C])) == 2:
    print('Yes')
else:
    print('No')
lst = list(map(int, input().split()))
print('Yes' if len(set(lst)) == 2 else 'No')
def main():

    A, B, C = map(int, input().split())
    if len(set([A, B, C])) == 2:
        return "Yes"
    return "No"

if __name__ == '__main__':
    print(main())
a,b,c=map(int, input().split())
if a==b or b==c or a==c:
  if a==b==c:
    print('No')
  else:
    print('Yes')
else:
  print('No')
str = input()
ipt = list(map(lambda x: int(x), str.split()))
ipt.sort()
if ipt[0]==ipt[1] and ipt[1]==ipt[2]:
  print('No')
elif ipt[0]==ipt[1] or ipt[1]==ipt[2]:
  print('Yes')
else:
  print('No')
a,b,c = input().split(None, 3)
A = int(a)
B = int(b)
C = int(c)
if A == B and B == C:
    print("No")
elif A != B and A != C and B != C:
    print("No")
else:
    print("Yes")
A,B,C = map(int,input().split(" "))
if A == B and A != C and B!=C:
    print("Yes")
elif  A== C and A != B and B!=C:
    print("Yes")
elif  B== C and A != B and A!=C:
    print("Yes")
else:
    print("No")
A = list(map(int, input().split()))
if len(set(A)) == 2:
    print("Yes")
else:
    print("No")
def solve():
    A, B, C = map(int, input().split())
    if A == B and A != C:
        print('Yes')
    elif A == C and A != B:
        print('Yes')
    elif B == C and A != B:
        print('Yes')
    else:
        print('No')


if __name__ == '__main__':
    solve()
A,B,C=map(int,input().split())
x = (1 if A==B else 0) + (1 if B==C else 0) + (1 if C==A else 0)
print("Yes" if x==1 else "No")
a,b,c = map(int,input().split())
s = set()
s.add(a)
s.add(b)
s.add(c)
if len(s) == 2:
    print('Yes')
else:
    print('No')
import sys
read = sys.stdin.readline
import time
import math
import itertools as it
def inp():
    return int(input())
def inpl():
    return list(map(int, input().split()))
start_time = time.perf_counter()
# ------------------------------

A = inpl()
A.sort()
if A[0]!=A[2]:
    if A[0]==A[1]:
        print('Yes')
        sys.exit()
    if A[1]==A[2]:
        print('Yes')
        sys.exit()
print('No')


# -----------------------------
end_time = time.perf_counter()
print('time:', end_time-start_time, file=sys.stderr)
a, b, c = map(int, input().split())

if len(set([a, b, c])) == 2:
    print('Yes')
else:
    print('No')
A = list(map(int, input().split()))
A = sorted(A)

if A[0] == A[1] and A[1] != A[2]:
    print("Yes")
elif A[0] != A[1] and A[1] == A[2]:
    print("Yes")
else:
    print("No")
a = list(map(int, input().split()))
if len(set(a)) == 2:
    print("Yes")
else:
    print("No")
a, b, c = map(int, input().split())
if a == b and a != c:
    print("Yes")
elif a == c and a != b:
    print("Yes")
elif b == c and b != a:
    print("Yes")
else:
    print("No")
a, b, c= input().split()
a, b, c= int(a), int(b), int(c)

if (a==b and c==b) or (a!=b and b!=c and c!=a):
	print('No')
else:
	print('Yes')
def inpl():
    return list(map(int, input().split()))


A = inpl()
A.sort()
print("Yes" if A[0] != A[2] and (A[0] == A[1] or A[1] == A[2]) else "No")
abc=input().split()

print("Yes"  if len(set(abc)) == 2 else "No" )
A, B, C = [int(i) for i in input().split()]

if A == B and A != C:
    print("Yes")
elif B == C and B != A:
    print("Yes")
elif A == C and A != B:
    print("Yes")
else:
    print("No")
x,y,z = input().split()
if x == y and x == z:
    print("No")
elif x == y or y == z or x == z:
    print("Yes")
else:
    print("No")
a,b,c=map(int,input().split())
if a==b and a!=c:
    print("Yes")
elif a==c and a!=b:
    print("Yes")
elif b==c and b!=a:
    print("Yes")
else:
    print("No")
number = input().split(" ")
ans = set(number)
if len(ans) == 2:
	print("Yes")
else:
	print("No")
if len(set(map(int, input().split()))) == 2:
    print('Yes')
else:
    print('No')
if __name__ == "__main__":
    a, b, c = list(map(int, input().split()))

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

if A==B and B==C and C==A:
    print("No")
elif A!=B and B!=C and C!=A:
    print("No")
else:
    print("Yes")
a, b, c = map(int, input().split())

if a == b == c or (a != b and b != c and a != c):
    print('No')
else:
    print('Yes')
nums = [i for i in input().split()]
nums = list(set(nums))
print('Yes' if len(nums) == 2 else 'No')
A, B, C = map(int, input().split())
if A == B and A != C:
    print('Yes')
elif A == C and A != B:
    print('Yes')
elif B == C and B != A:
    print('Yes')
else:
    print('No')
a,b,c=map(int,input().split())
A=[a,b,c]
B=len(set(A))
if B==2:
  print('Yes')
else:
  print('No')
A, B, C = map(int, input().split())

x = set([A, B, C])

if len(x) == 2:
    print('Yes')
else:
    print('No')
s = set(map(int, input().split()))
if len(s) == 2:
    print("Yes")
else:
    print("No")
print("Yes" if 2 == len(set(list(map(int, input().split())))) else "No")
from collections import Counter
abc = Counter(input().split())
if len(abc) == 2:
    print('Yes')
else:
    print('No')
A,B,C = map(int,input().split())
count = 0
if A == B:
    count += 1
if A == C:
    count += 1
if B == C:
    count += 1
if count == 1:
    print("Yes")
else:
    print("No")
A = list(map(int, input().split()))
B = set(A)
if len(B) == 2:
  print('Yes')
else:
  print('No')
a,b,c=map(int,input().split())
if (a!=b and b!=c and c!=a) or (a==b and b==c):
  print('No')
else:
  print('Yes')
a,b,c = [int(x) for x in input().split()]

if (a==b and c!= a) or (a==c and a!=b) or (b == c and a!=b):print('Yes')
else:print('No')
A,B,C=map(int,input().split())

if(A==B and (B==C and A==C)):
    print("No")

elif(A!=B and (B!=C and A!=C)):
    print("No")
else:
    print("Yes")
# A - Poor
def main():
    A, B, C = map(int, input().split())
    is_poor = (A == B and A != C) or (A == C and A != B) or (B == C and A != B)
    print("Yes" if is_poor else "No")


if __name__ == "__main__":
    main()
print('Yes' if len(set(input().split()))==2 else 'No')
A, B, C = map(int, input().split())
if A == B and B ==C:
  print('No')
elif A != B and B != C and C != A:
  print('No')
else:
  print('Yes')
a,b,c=map(int,input().split())

tmp=set([a,b,c])
if len(tmp)==1:
  print('No')
elif len(tmp)==2:
  print('Yes')
else:
  print('No')
a, b, c = map(int, input().split(" "))

if (a - b) * (b - c) * (c - a) == 0 and not ((a == b) and (a == c)):
  print("Yes")
else:
  print("No")
li = list(map(int,input().split()))
a=list(set(li))
if len(a)==2:
  print("Yes")
else:
  print("No")
X = list(map(int,input().split()))
for i in [0,1]:
    if X.count(X[i]) == 2:
        print('Yes')
        exit()

print('No')
a,b,c=map(int,input().split())
if a==b and a==c:
  print('No')
elif a!=b and a!=c and b!=c:
  print('No')
else:
  print('Yes')
A, B, C = map(int,input().split())
li = [A, B, C]
li.sort()

ans = "No"

if li[0] == li[1] and li[1] != li[2] :
  ans = "Yes"

elif li[0] != li[1] and li[1] == li[1] == li[2]:
  ans = "Yes"

print(ans)
import sys #sys.stdin.readline()
import heapq #heap
from collections import defaultdict
fastinp = lambda: sys.stdin.readline().split(' ')
inp = lambda: input().split(' ')
ml = lambda x, y=int: list(map(y, x))
debug = lambda *args: print(*args, sep=' | ')
a, b, c = ml(inp())
if a == b and a != c:
    print('Yes')
elif b == c and a != b:
    print('Yes')
elif a == c and b != a:
    print('Yes')
else:
    print('No')
a = list(map(int, input().split()))
a_set = len(set(a))

if a_set == 2:
    print("Yes")
else:
    print("No")
a,b,c = map(int, input().split())
if a==b==c:
  print('No')
elif a==b or b==c or a==c:
  print('Yes')
else:
  print('No')
arr = list(map(int, input().split()))
arr.sort()
if (arr[0] == arr[1]) and (arr[2] != arr[1]):
	print("Yes")
elif (arr[1] == arr[2]) and (arr[0] != arr[1]):
	print("Yes")
else:
	print("No")