qyliang/CodeNanoFix huggingface dataset:
Buggy code:
n,k=map(int,input().split())
mod=10**9+7
k=min(k,n)
ans=1
g=1
h=1
for i in range(k):
    g*=(n-i)*pow(k+i,mod-2,mod)
    g%=mod
    h*=(n-1-i)*pow(k+i,mod-2,mod)
    h%=mod
    ans+=g*h%mod
    ans%=mod
print(ans)

Fixed code:
n,k=map(int,input().split())
mod=10**9+7
k=min(k,n-1)
ans=1
g=1
h=1
for i in range(k):
    g*=(n-i)*pow(i+1,mod-2,mod)
    g%=mod
    h*=(n-1-i)*pow(i+1,mod-2,mod)
    h%=mod
    ans+=g*h%mod
    ans%=mod
print(ans)
Buggy code:
from collections import *
from itertools import *
from bisect import *
import copy

n,k=map(int,input().split())
mod=10**9+7
fac=[0,1]
for i in range(2,2*n+1):
    fac.append(fac[i-1]*i%mod)
ifac=[pow(i,mod-2,mod) for i in fac]

def comb(a,b):
    if a==0 and b==0:return(1)
    if a<b or a<0:return(0)

    return((fac[a]*ifac[a-b]*ifac[b])%mod)

count=1
for m in range(0,min(k+1,n)):

    count=(count+comb(n,m)*comb((n-m)+m-1,n-m-1))%mod
print(count)


Fixed code:
from collections import *
from itertools import *
from bisect import *
import copy

n,k=map(int,input().split())
mod=10**9+7
fac=[0,1]
for i in range(2,2*n+1):
    fac.append(fac[i-1]*i%mod)
ifac=[pow(i,mod-2,mod) for i in fac]

def comb(a,b):
    if a>=0 and b==0:return(1)
    if a<b or a<0:return(0)

    return((fac[a]*ifac[a-b]*ifac[b])%mod)

count=1
for m in range(1,min(k+1,n)):

    count=(count+comb(n,m)*comb(n-1,n-m-1))%mod
print(count)
Buggy code:
n,k = map(int, input().split())
mod = 10**9 + 7

ans = 0
lim = 2*(10**5) + 5
mothers = [1] * lim
mothers_inv = [1] * lim
for i in range(1, lim):
    mothers[i] = mothers[i-1] * i % mod
    mothers_inv[i] = pow(mothers[i], mod-2, mod)


def calc(n,k):
    child = mothers[n] * mothers_inv[n-k] % mod
    mother_inv = mothers_inv[k]
    return((child * mother_inv)%mod)

if( n <= k+1):
    ans = calc(2*n-1, n-1)
    print(ans)
    exit()

ans = calc(2*n-1, n-1)

tmp = 0
for i in range(1,n-k):
    if(i ==1):
        c1 = 1
    else:
        c1 = calc(n-1, i-1) 

    c2 = calc(n, i) 
    ans = (ans - c1 * c2)%mod


print(ans)

Fixed code:
n,k = map(int, input().split())
mod = 10**9 + 7

ans = 0
lim = 2*(10**5) + 5
mothers = [1] * lim
mothers_inv = [1] * lim
for i in range(1, lim):
    mothers[i] = mothers[i-1] * i % mod
    mothers_inv[i] = pow(mothers[i], mod-2, mod)


def calc(n,k):
    child = mothers[n] * mothers_inv[n-k] % mod
    mother_inv = mothers_inv[k]
    return((child * mother_inv)%mod)

def calc2(n,k):
    child = 1
    for i in range(n, n-k, -1):
        child = child * i % mod
    mother_inv = mothers_inv[k]
    return((child * mother_inv)%mod)

if( n <= k+1):
    ans = calc2(2*n-1, n-1)
    print(ans)
    exit()

ans = calc2(2*n-1, n-1)

for i in range(1,n-k):
    if(i ==1):
        c1 = 1
    else:
        c1 = calc(n-1, i-1)

    c2 = calc(n, i)
    ans = (ans - c1 * c2)%mod


print(ans)
Buggy code:
n, k = map(int, input().split())
class factorial:
  def __init__(self, n, p=10**9 + 7):
    self.__p  = p
    self.__fac  = [0] * (n+1)
    self.__inv  = [0] * (n+1)
    self.__finv = [0] * (n+1)

    self.__fac[0] = self.__fac[1] = 1
    self.__inv[1] = 1
    self.__finv[0] = self.__finv[1] = 1

    for i in range(2, n+1):
      self.__fac[i] = self.__fac[i-1] * i % p
      self.__inv[i] = p - self.__inv[p%i] * (p // i) % p
      self.__finv[i] = self.__finv[i-1] * self.__inv[i] % p
  
  def fact(self, n):
    return self.__fac[n]
  
  def perm(self, n, k):
    return self.__fac[n] * self.__finv[n-k] % self.__p
  
  def comb(self, n, k):
    return self.perm(n, k) * self.__finv[k] % self.__p

f = factorial(n)
p = 10**9 + 7
ans = 0
for i in range(n, 0, -2):
  ans = (ans + f.comb(n, i) ** 2) % p
print(ans)

Fixed code:
n, k = map(int, input().split())
class factorial:
  def __init__(self, n, p=10**9 + 7):
    self.__p  = p
    self.__fac  = [0] * (n+1)
    self.__inv  = [0] * (n+1)
    self.__finv = [0] * (n+1)

    self.__fac[0] = self.__fac[1] = 1
    self.__inv[1] = 1
    self.__finv[0] = self.__finv[1] = 1

    for i in range(2, n+1):
      self.__fac[i] = self.__fac[i-1] * i % p
      self.__inv[i] = p - self.__inv[p%i] * (p // i) % p
      self.__finv[i] = self.__finv[i-1] * self.__inv[i] % p
  
  def fact(self, n):
    return self.__fac[n]
  
  def perm(self, n, k):
    return self.__fac[n] * self.__finv[n-k] % self.__p
  
  def comb(self, n, k):
    return self.perm(n, k) * self.__finv[k] % self.__p

f = factorial(n)
p = 10**9 + 7
ans = 0
for i in range(min(k+1, n)):
  ans = (ans + f.comb(n, i) * f.comb(n-1, n-i-1)) % p
print(ans)
Buggy code:
MOD = 10**9 + 7
inpl = lambda: list(map(int,input().split()))
def inv_mod(a, p=10**9+7):
    p = abs(p)
    a %= p
    stack = []
    p0 = p
    while a > 1:
        d, a, p = p//a, p%a, a
        stack.append(d)
    x, y = 1, 0
    while stack:
        d = stack.pop()
        x, y = y-d*x, x
    return x % p0
n, k = inpl()
if k >= n:
    k = n-1
ans = 1
t = 1
print(k)
for i in range(k):
    t *= (n-1-i)*(n-i)
    t %= MOD
    j = inv_mod(i+1)
    t *= j*j % MOD
    ans += t
    ans %= MOD
print(ans)

Fixed code:
MOD = 10**9 + 7
inpl = lambda: list(map(int,input().split()))
def inv_mod(a, p=10**9+7):
    p = abs(p)
    a %= p
    stack = []
    p0 = p
    while a > 1:
        d, a, p = p//a, p%a, a
        stack.append(d)
    x, y = 1, 0
    while stack:
        d = stack.pop()
        x, y = y-d*x, x
    return x % p0
n, k = inpl()
if k >= n:
    k = n-1
ans = 1
t = 1
for i in range(k):
    t *= (n-1-i)*(n-i)
    t %= MOD
    j = inv_mod(i+1)
    t *= j*j % MOD
    ans += t
    ans %= MOD
print(ans)
Buggy code:
def modinv(a,m):
    return pow(a,m-2,m)


n,k = map(int,input().split())
P = 10**9+7

if n-1 <= k:

    ans = 1
    for i in range(1,n):
        ans = ans*(N+1-i)*modinv(i,P)%P

else:
    ans = 0
    nCl = 1
    n1Cl = 1
    for l in range(1,k+1):
        nCl = nCl*(n+1-l)*modinv(l,P)%P
        n1Cl = n1Cl*(n-l)*modinv(l,P)%P
        ans = (ans+nCl*n1Cl)%P

print((ans+1)%P)



Fixed code:
def modinv(a,m):
    return pow(a,m-2,m)


n,k = map(int,input().split())
P = 10**9+7



if n-1 <= k:
    N = n + min(n-1,k)
    ans = 1
    for i in range(1,n):
        ans = ans*(N+1-i)*modinv(i,P)%P

else:
    ans = 1
    nCl = 1
    n1Cl = 1
    for l in range(1,k+1):
        nCl = nCl*(n+1-l)*modinv(l,P)%P
        n1Cl = n1Cl*(n-l)*modinv(l,P)%P
        ans = (ans+nCl*n1Cl)%P

print(ans)
Buggy code:
n, k = map(int, input().split())
mod = 10**9+7

k = min([k, n-1])


ans = 0
key = 1

for i in range(k):
    ans += key
    ans %= mod
    key = (((key*(n-i)%mod)*(n-i-1)%mod)*pow(pow(i+1, mod-2, mod), 2, mod))%mod
print(ans)

Fixed code:
n,k = map(int, input().split())
mod = 10 ** 9 + 7

comb0 = [1] * (n)

for i in range(n-1):
    comb0[i + 1] = comb0[i] * (n - i) * pow(i + 1,mod - 2, mod) % mod

comb1 = [1] * (n)

for i in range(n-1):
    comb1[i + 1] = comb1[i] * (n - 1 - i) * pow(i + 1,mod - 2, mod) % mod

ans = 0

for i in range(min(n - 1, k) + 1):
    ans += comb0[i] * comb1[i]
    ans %= mod

print(ans)
Buggy code:
li = list(map(int, input().split()))
if (len(li) == 2:
    print("Yes")
else:
    print("No")


Fixed code:
li = list(map(int, input().split()))
if (len(set(li))) == 2:
    print("Yes")
else:
    print("No")
Buggy code:
A,B,C = map(int,input().split())
if A==B and B==C:
    print("No")
else:
print("Yes")


Fixed code:
A,B,C = map(int,input().split())
if (A==B and B==C and A==C) or (A!=B and B!=C and A!=C):
    print("No")
else:
    print("Yes")
Buggy code:
li = list(map(int, input().split()))
if (set(len(li))) == 2:
    print("Yes")
else:
    print("No")


Fixed code:
n = list(map(int,input().split()))
if len(set(n)) == 2:
  print('Yes')
else:
  print('No')
Buggy code:
num=input().split()

tmp=sorted(num)

if num[0] == num [1] and num[1] != num[2] :
    print("Yes")
elif num[1] == num[2] and num[0] != num[1] :
    print("Yes")
else:
    print("No")    

Fixed code:
num=input().split()

tmp=sorted(num)

if tmp[0] == tmp [1] and tmp[1] != tmp[2] :
    print("Yes")
elif tmp[1] == tmp[2] and tmp[0] != tmp[1] :
    print("Yes")
else:
    print("No")
Buggy code:
a,b,c = map(str, input().split())
if a==b and a!=c:
    print("Yes")
if a==c and a!=b:
    print("Yes")
if b==c	and b!=a:
    print("Yes")
else:
    print("No")

Fixed code:
a,b,c = map(str, 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")
Buggy code:
A, B, C = map(int, input('').split(' '))
if(A == B and B == C):
    print('No')
else:
    print('Yes')

Fixed code:
A, B, C = map(int, input('').split(' '))
if((A != B and B != C and C != A) or (A == B and B == C and C == A)):
    print('No')
else:
    print('Yes')
Buggy code:
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#l = list(map(int, input().split()))


l = list(map(int, input().split()))
l.sort

if (l[1] != l[2]):
    print("Yes")
else:
    print("No")


Fixed code:
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#l = list(map(int, input().split()))


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

if (l[0] == l[1] != l[2]):
    print("Yes")
elif (l[0] == l[2] != l[1]):
    print("Yes")
elif (l[0] != l[1] == l[2]):
    print("Yes")
else:
    print("No")
Buggy code:
a,b,c = map(int,input().split())

if a == b == c:
    print("No")
elif a != b != c:
#elif a != b and b != c and a != c:
    print("No")
else:
    print("Yes")

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

if a == b == c:
    print("No")
#elif a != b != c:
elif a != b and b != c and a != c:
    print("No")
else:
    print("Yes")
Buggy code:
a, b, c = map(int, input().split())
ans = 'No'
if a == b or b == c or c == a:
    ans = 'Yes'
print(ans)

Fixed code:
a, b, c = map(int, input().split())
ans = 'No'
if (a == b and b != c) or (b == c and c != a) or (c == a and a != b):
    ans = 'Yes'
print(ans)
Buggy code:
num = [x for x in input()]
ans = 0
if num[0] == num[1]:
  ans = ans + 1
if num[0] == num[2]:
  ans = ans + 1
if num[1] == num[2]:
  ans = ans + 1

if ans == 1:
  print('Yes')
else:
  print('No')

Fixed code:
num = [x for x in input().split()]
ans = 0
if num[0] == num[1]:
  ans = ans + 1
if num[0] == num[2]:
  ans = ans + 1
if num[1] == num[2]:
  ans = ans + 1

if ans == 1:
  print('Yes')
else:
  print('No')
Buggy code:
a,b,c = map(int,input().split)
if a==b!=c or a==c!=b or b==c!=a:
    print('Yes')
else:
    print('No')

Fixed code:
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')
Buggy code:
A,B,C=map(int,input().split())
if A==B==C or A!=B!=C:
  print('No')
else:
  print('Yes')

Fixed code:
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')
Buggy code:
a, b, c = map(int, input().split(" "))

if a == b == c:
    print("No")
elif a == b & a == c & b == c:
    print("Yes")
else:
    print("No")

Fixed code:
a, b, c = map(int, input().split(" "))

if a == b == c:
    print("No")
elif a == b or a == c or b == c:
    print("Yes")
else:
    print("No")
Buggy code:
a,b,c=map(int,input().split())
if((a == b == c ) or (a != b != c )):
            print("No")
else:       
            print("Yes")
    

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

if int(A) == int(B) == int(C):
  print("Yes")
else:
  print("No")

Fixed code:
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")
Buggy code:
A,B,C=map(int,input().split())
if (A==B or B==C or A==C) and A!=B!=C:
  print("Yes")
else:
  print("No")
  

Fixed code:
A, B, C = map(int, input().split())
if A == B and B == C:
  print("No")
elif A != B and A != C and B != C:
  print("No")
else:
  print("Yes")
Buggy code:

def main():
    s = input().split()
    if len(s) == set(s) or len(set(s)) == 1:
        print("No")
    else:
        print("Yes")


main()

Fixed code:

def main():
    s = input().split()
    if len(s) == len(set(s)) or len(set(s)) == 1:
        print("No")
    else:
        print("Yes")


main()
Buggy code:
a, b, c = map(int, input().split())

if a==b or a==c or b==c:
  print("No")
else:
  print("Yes")

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

if (a==b and a!=c) or (a==c and a!=b) or (b==c and b!=a):
    print('Yes')

else:
    print('No')
Buggy code:
a, b, c = list(map(int, input().split()))

if a==b or a==c or b==c:
    print("Yes")
else:
    print("No")

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

if (a == b or a == c or b == c) and not a == b == c:
    print("Yes")
else:
    print("No")
Buggy code:
A = map(int, input().split())
print("Yes" if set(A) == 2 else "No")

Fixed code:
A = map(int, input().split())
print("Yes" if len(set(A)) == 2 else "No")
Buggy code:
def main():
    A, B, C = input().split(' ')

    if A == B:
        print('Yes')
    elif B == C:
        print('Yes')
    elif A == C:
        print('Yes')
    else:
        print('No')

if __name__ == '__main__':
    main()

Fixed code:
def main():
    A, B, C = input().split(' ')

    if A == B and B == C:
        print('No')
    elif A == B:
        print('Yes')
    elif B == C:
        print('Yes')
    elif A == C:
        print('Yes')
    else:
        print('No')

if __name__ == '__main__':
    main()
Buggy code:
array = map(int,input().split())
array.sort()
if array[0] != array[2] and (array[0] == array[1] or array[1] == array[2]):
  print('Yes')
else:
  print('No')

Fixed code:
array = list(map(int,input().split()))
array.sort()
if array[0] != array[2] and (array[0] == array[1] or array[1] == array[2]):
  print('Yes')
else:
  print('No')
Buggy code:
s,t,u = input().split()

if s == t == u:
    print("No")
elif s != t != u:
	print("No")    
else:
    print("Yes")

Fixed code:
s,t,u = input().split()

if s == t == u:
    print("No")
elif (s != t)and(t != u)and(s != u):
	print("No")    
else:
    print("Yes")
Buggy code:
A=list(map(int,input().split()))
if A[0]==A[1]:
    print('Yes')
elif A[0]==A[2]:
    print('Yes')
elif A[1]==A[2]:
    print('Yes')
else:
    print('No')

Fixed code:
A=list(map(int,input().split()))
if A[0]==A[1]==A[2]:
    print('No')
elif A[0]==A[1]:
    print('Yes')
elif A[0]==A[2]:
    print('Yes')
elif A[1]==A[2]:
    print('Yes')
else:
    print('No')
Buggy code:
a, b, c = map(int, input().split(" "))

if ((a == b) and (b != c)) or
   ((b == c) and (c != a)) or
   ((c == a) and (a != b)):
  print("Yes")
else:
  print("No")

Fixed code:
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')
Buggy code:
input_line = input().split(' ')

arr = set(input_line)
if(len(arr) === 2):
  print('Yes')
else:
  print('No')

Fixed code:
input_line = input().split(' ')
 
arr = set(input_line)
if(len(arr) == 2):
  print('Yes')
else:
  print('No')
Buggy code:
def main():
    a, b, c = map(int, input().split())
    if a == b == c:
        print('No')
    elif a != b != c:
        print('No')
    else:
        print('Yes')
        
if __name__ == '__main__':
    main()

Fixed code:
def main():
    a, b, c = map(int, input().split())
    if a == b == c:
        print('No')
    elif a != b and b != c and c != a:
        print('No')
    else:
        print('Yes')
        
if __name__ == '__main__':
    main()
Buggy code:
if len(set([int(x) for x in input().split("")])) = 2:
  print("yes")
else:
  print("No")

Fixed code:
if len(set([int(x) for x in input().split(" ")])) == 2:
  print("Yes")
else:
  print("No")
Buggy code:
A,B,C = input().split(' ')

if A== B:
    if B =!C:
        print('Yes')
    else:
        print('No')
else:
    if B == C or A ==C:
        print('Yes')
    else:
        print('No')

Fixed code:
A,B,C = input().split(' ')

if A== B:
    if B != C:
        print('Yes')
    else:
        print('No')
else:
    if B == C or A ==C:
        print('Yes')
    else:
        print('No')
Buggy code:
List= list(int,input().split())
List=set(List)
if len(List)==2:
    print('Yes')
else:
    print('No') 

Fixed code:
List= list(map(int,input().split()))
List=set(List)
if len(List)==2:
    print('Yes')
else:
    print('No')
Buggy code:
a,b,c=map(int,input().split())
if a=b=c or a!=b!=c:
  print('No')
else:
  print('Yes')


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

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


if (A == B or B == C or A == C):
  if A == B and B == C and C == A:
    print('No')
  else:
    print('Yes')


Fixed code:
A, B, C = list(map(int, input().split()))


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


Fixed code:
a,b,c=map(int,input().split())
if (a==b!=c) or (a!=b==c) or (a==c!=b):
    print("Yes")
else:
    print("No")
Buggy code:
a,b,c=map(int,input().split())

if a==b and a!=c:
    print("Yes")
elif a==b and a!=c:
    print("Yes")
elif a==b and a!=c:
    print("Yes")
else:
    print("No")

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

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

if A == B and B != C:
    print('yes')
elif B == C and C != A:
    print('Yes')
elif A == C and C != B:
    print("Yes")
else:
    print('No')


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

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

if (a == b and b==c) or (a != b and b != c) :
  print("No")
else :
  print("Yes")

Fixed code:
a,b,c = map(int,input().split())
print("No" if (a == b and a == c and b == c) or (a != b and b != c and c != a) else "Yes")
Buggy code:
from sys import stdin
a, b, c = map(int, stdin.readline().rstrip().split())
if a == b == c:
    print("No")
else:
    print("Yes")

Fixed code:
from sys import stdin
a, b, c = map(int, stdin.readline().rstrip().split())
if a == b == c:
    print("No")
elif a == b or a == c or b == c:
    print("Yes")
else:
    print("No")
Buggy code:
A, B, C = map(int, input().split())
if A == B == C:
    print('No')
else:
    print('Yes')

Fixed code:
A,B,C = map(int,input().split())
if A==B==C:
    print('No')
elif A==B or B==C or C==A:
    print('Yes')
else:
    print('No')
Buggy code:
a,b,c=map(int,input().split())
if a==b==c:
    print("No")
else:
    print("Yes")

Fixed code:
a,b,c=map(int,input().split())
if a==b==c:
  print("No")
elif a==b or b==c or c==a:
  print("Yes")
else:
  print("No")
Buggy code:
A, B, C = map(int, input().split())

if A == B and B == C:
    print('No')
else:
    print('Yes')


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

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


Fixed code:
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')
Buggy code:
a,b,c = map(int, input().split())

if a!=b!=c:
  print('No')
elif a==b==c:
  print('No')
else:
  print('Yes')

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

if a==b and b!=c:
    print('Yes')

elif a==c and b!=c:
    print('Yes')

elif b==c and a!=c:
    print('Yes')

else:
    print('No')
Buggy code:
A,B,C=[int(i) for i in input().split()]
if A == B == C:
    print("No")
elif A != B != C:
    print("No")
else:
    print("Yes")


Fixed code:
A,B,C=[int(i) for i in input().split()]
if A == B and A == C:
    print("No")
elif A != B and B != C and A != C:
    print("No")
else:
    print("Yes")
Buggy code:
vA, B, C = map(int, input().split())

if A == B and B != C:
    print("Yes")
elif B == C and A != B:
    print("Yes")
elif A == C and A != B:
    print("Yes")
else:
    pirnt("No")

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

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

if A == B and A == C and B != C:
  print("Yes")
elif A == B and A != C and B == C:
  print("Yes")
elif A != B and A == C and B == C:
  print("Yes")
else:
  print("No")

Fixed code:
A,B,C = map(int,input().split())
if (A == B and A != C) or (B == C  and C != A) or (C == A and A != B):
    print('Yes')
else:
    print('No')
Buggy code:
a = list(map(int, input().split()))
if (a[0]==a[1] and a[0] != a[2]) or (a[1]==a[2] and a[1] != a[0]) or (a[0]==a[2] and a[0] != a[1]):
print('Yes')
else:
print('No')

Fixed code:
a = list(map(int,input().split()))
a.sort()
if (a[0] == a[1] and a[0] != a[2]) or (a[1] == a[2] and a[0] != a[2]):
    print('Yes')
else:
    print('No')
Buggy code:
A = input().split()

a = A.count(A[0])
b = A.count(A[1])
c = A.count(A[2])

if a == 1 or b == 1 or c == 1:
    print("Yes")
else:
    print("No")


Fixed code:
A = input().split()

a = A.count(A[0])
b = A.count(A[1])
c = A.count(A[2])

if a == 2 or b == 2 or c == 2:
    print("Yes")
else:
    print("No")
Buggy code:
k=list(map(int,input().split())))
from collections import Counter
l=Counter(k)
if len(l)==2:
  print("Yes")
else:
  print("No")
  
  

Fixed code:
k=list(map(int,input().split()))
from collections import Counter
l=Counter(k)
if len(l)==2:
  print("Yes")
else:
  print("No")
Buggy code:
a, b, c = map(int, input().split())

if a == b and b == c:
  print('Yes')
else:
  print('No')

Fixed code:
a, b, c = map(int, input().split())
if a == b == c or (a != b and b != c and c !=a):
    print("No")
else:
    print("Yes")
Buggy code:
a,b,c = int(input().split())

if a == b == c:
  print('No')
elif a != b and b != c and a != c:
  print('No')
elif 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')

Fixed code:
a,b,c = input().split()

if a == b == c:
  print('No')
elif a != b and b != c and a != c:
  print('No')
elif 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')
Buggy code:
line = input()
a, b, c = line.split(" ")
if a == b and b == c:
    print("No")
else:
    print("Yes")

Fixed code:
line = input()
a, b, c = line.split(" ")
if a == b and b == c:
    print("No")
elif a != b and a != c and b != c:
    print("No")
else:
    print("Yes")
Buggy code:
a,b,c = map(int,input().split())
if a == b and a == c:
    print("No")
else:
    print("Yes")

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

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


if (a==b) and (b==c):
    print("No")
else:
    print("Yes")

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


if (a==b) and (b!=c):
    print("Yes")
elif(a==c) and (b!=c):
    print("Yes")
elif(c==b) and (a!=c):
    print("Yes")
else:
    print("No")
Buggy code:
A,B,C = input().strip().split()
if A == B or B == C or C == A:
    print('Yes')
else:
    print('No')

Fixed code:
A,B,C = input().strip().split()
if (A == B or B == C or C == A) and not(A == B == C) :
    print('Yes')
else:
    print('No')
Buggy code:
nums= input().split()


for i in range(len(nums)):
    nums[i] = int(nums[i])
    
nums.sort()


if nums[1] == nums[2] and nums[0]<nums[1]:
    print(Yes)
elif nums[1] == nums[0] and nums[1]<nums[2]:
    print(Yes)
else:
    print(No)

Fixed code:
nums= input().split()


for i in range(len(nums)):
    nums[i] = int(nums[i])
    
nums.sort()


if nums[1] == nums[2] and nums[0]<nums[1]:
    print("Yes")
elif nums[1] == nums[0] and nums[1]<nums[2]:
    print("Yes")
else:
    print("No")