ZhenlongDai/ACPR huggingface dataset:
Problem: p02831
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
a, b= map(int,input().split())
d= math.gcd(a,b)
print(a*b/d)

Failing test case input:
110100 99999

Expected output:
3669963300


Actual output:
3669963300.0


Fixed submission (verdict: Accepted):
import math
a, b= map(int,input().split())
d= math.gcd(a,b)
print(a*b

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,S = map(int, input().split())
tmp = 1
a = 2
while (True):
  if N % a == 0 and S % a == 0:
    N,S = int(N / a), int(S / a)
    tmp *= a
    a = 2
  a += 1
  if N <= a or S <= a:
    break
print(tmp * S * N)

Failing test case input:
010100 8

Expected output:
20200


Actual output:
40400


Fixed submission (verdict: Accepted):
N,S = map(int, input().split())
tmp = 1
a = 1
while True:
  if N 
    break
  if N % a == 0 and S % a == 0:
    N,S = N 
    tmp *= a
    a = 1
  a += 1

print(tmp * S * N)

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=sorted(map(int,input().split()))

def gcd(a,b):
    if b==0:
        return a
    
    else:
        return (gcd(b,a%b))
print(a*b/gcd(a,b))


Failing test case input:
001000 19

Expected output:
19000


Actual output:
19000.0


Fixed submission (verdict: Accepted):
a,b=sorted(map(int,input().split()))

def gcd(a,b):
    if b==0:
        return a
    
    else:
        return (gcd(b,a%b))
print(int(a*b/gcd(a,b)))

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = map(int,input().split())
def gcd(a,b):
    if a < b:
        temp = b
        b = a 
        a = temp
    remainder = a % b
    if remainder == 0:
        return b
    else:
        return gcd(remainder,b)

def gys(a,b):
    remainder = gcd(a,b)
    print(a*b/remainder)
gys(a,b)


Failing test case input:
010111 1

Expected output:
10111


Actual output:
10111.0


Fixed submission (verdict: Accepted):
a,b = map(int,input().split())
def gcd(a,b):
    if a < b:
        temp = b
        b = a 
        a = temp
    remainder = a % b
    if remainder == 0:
        return b
    else:
        return gcd(remainder,b)
 
def gys(a,b):
    remainder = gcd(a,b)
    print(int(a*b/remainder))
gys(a,b)

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys
a, b = input().split()

A = int(a)
B = int(b)

Adiv = A
Bdiv = B
k = 0




for i in reversed(range(min([A, B]))):
    j = i+1
    if Adiv % j == 0 and Bdiv % j == 0:
        k = j


if k == 0:
    k = 1


res = A * B / k
if k == min([A, B]):
    res = max([A, B])
print(int(res))


Failing test case input:
100000 52132

Expected output:
1303300000


Actual output:
5213200000


Fixed submission (verdict: Accepted):
import sys
a, b = input().split()

A = int(a)
B = int(b)

Adiv = A
Bdiv = B
k = 0




for i in reversed(range(min([A, B]))):
    j = i+1
    if Adiv % j == 0 and Bdiv % j == 0:
        k = j
        break


if k == 0:
    k = 1


res = A * B / k

print(int(res))
Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):


def saidaikouyakusu(a,b):
    if a%b==0:
        return b
    else:
        return saidaikouyakusu(b,a%b)

a,b=[int(x) for x in input().split()]

if a<b:
    tmp=a
    a=b
    b=tmp

print(a,b)

ans=int(a*b/saidaikouyakusu(a,b))

print(ans)

Failing test case input:
100000 52132

Expected output:
1303300000


Actual output:
100000 52132
1303300000


Fixed submission (verdict: Accepted):


def saidaikouyakusu(a,b):
    if a%b==0:
        return b
    else:
        return saidaikouyakusu(b,a%b)

a,b=[int(x) for x in input().split()]

if a<b:
    tmp=a
    a=b
    b=tmp

ans=int(a*b/saidaikouyakusu(a,b))

print(ans)

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B = map(int, input().split())

for i in range(1, 10 ** 5 + 1):
    if i % A == 0 and i % B == 0:
         print(i)
         break

Failing test case input:
110000 22

Expected output:
110000


Actual output:

Fixed submission (verdict: Accepted):
A, B = map(int, input().split())
C = A * B
      
    
for i in range(1, 10**5):
    if (A * i) % B == 0:
        print(A * i)
        break

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = input().split()
complete = int(a) * int(b);
tmp = complete
for i in range(2, min(int(a), int(b)) + 1):
    tmp = complete / i
    if tmp % int(b) == 0 and tmp % int(a) == 0:
        complete = tmp
        break
print(int(complete))


Failing test case input:
011100 8

Expected output:
22200


Actual output:
44400


Fixed submission (verdict: Accepted):
a, b = input().split()
product = int(a) * int(b);
complete = product
tmp = product
for i in range(2, min(int(a), int(b)) + 1):
    tmp = product / i
    if tmp % int(b) == 0 and tmp % int(a) == 0:
        complete = tmp
print(int(complete))
Problem: p02831
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
import sys
from functools import reduce
import copy
import math
from pprint import pprint
import collections
import bisect
import itertools
import heapq


sys.setrecursionlimit(4100000)


def inputs(num_of_input):
    ins = [input() for i in range(num_of_input)]
    return ins


def int_inputs(num_of_input):
    ins = [int(input()) for i in range(num_of_input)]
    return ins


def solve(input):
    [A, B] = string_to_int(input)
    return A*B


def string_to_int(string):
    return list(map(lambda x: int(x), string.split()))


if __name__ == "__main__":
    ret = solve(input())
    print(ret)


Failing test case input:
110000 52132

Expected output:
1433630000


Actual output:
5734520000


Fixed submission (verdict: Accepted):
import sys
from functools import reduce
import copy
import math
from pprint import pprint
import collections
import bisect
import itertools
import heapq


sys.setrecursionlimit(4100000)


def inputs(num_of_input):
    ins = [input() for i in range(num_of_input)]
    return ins


def int_inputs(num_of_input):
    ins = [int(input()) for i in range(num_of_input)]
    return ins


def solve(input):
    nums = string_to_int(input)

    def euclid(large, small):
        if small == 0:
            return large
        l = large % small
        return euclid(small, l)

    nums.sort(reverse=True)
    eee = euclid(nums[0], nums[1])
    return int((nums[0] * nums[1]) / eee)


def string_to_int(string):
    return list(map(lambda x: int(x), string.split()))


if __name__ == "__main__":
    ret = solve(input())
    print(ret)

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,m =map(int,input().split())
n2=max(n,m)
m2=min(n,m)
while m2!=0:
    tmp=n2
    n2=m2
    m2=tmp%m2
print(n2,m2)
print(int(n*m/n2))


Failing test case input:
111000 84

Expected output:
777000


Actual output:
12 0
777000


Fixed submission (verdict: Accepted):
n,m =map(int,input().split())
n2=max(n,m)
m2=min(n,m)
while m2!=0:
    tmp=n2
    n2=m2
    m2=tmp%m2
print(int(n*m/n2))

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())
li = []
for i in range(1, 10**5+1):
  if a%i==0 and b%i==0:
    li.append(i)
print((a*b)/li[-1])

Failing test case input:
001000 32

Expected output:
4000


Actual output:
4000.0


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
li = []
for i in range(1, 10**5+1):
  if a%i==0 and b%i==0:
    li.append(i)
print(int((a*b)/li[-1]))

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=input().split()
a=int(a)
b=int(b)
x = a * b

if (a<b):
  tmp = a
  a = b;
  b = tmp

r = a % b
while(r!=0):
  a = b
  b = r
  r = a % b

print(x/b)

Failing test case input:
110001 2

Expected output:
220002


Actual output:
220002.0


Fixed submission (verdict: Accepted):
a,b=input().split()
a=int(a)
b=int(b)
x = a * b

if (a<b):
  tmp = a
  a = b;
  b = tmp

r = a % b
while(r!=0):
  a = b
  b = r
  r = a % b

print(int(x/b))
Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x,y = input().split()
x = int(x)
y = int(y)
if x < y:
  a = y
  b = x
else:
  a = x
  b = y

while b:
  a, b = b, a % b

print(x*y/a)


Failing test case input:
000011 2

Expected output:
22


Actual output:
22.0


Fixed submission (verdict: Accepted):
x,y = input().split()
x = int(x)
y = int(y)
if x < y:
  a = y
  b = x
else:
  a = x
  b = y
 
while b:
  a, b = b, a % b
 
print(x * y

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())
ans = 0
if a > b:
  for i in range(b, a + 1):
    if b * i % a == 0:
      ans = b * i
      break
else:
  for i in range(a, b + 1):
    if a * i % b == 0:
      ans = a * i
      break
print(ans)


Failing test case input:
50 30

Expected output:
150


Actual output:
900


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
ans = 0
if a > b:
  for i in range(1, a + 1):
    if b * i % a == 0:
      ans = b * i
      break
else:
  for i in range(1, b + 1):
    if a * i % b == 0:
      ans = a * i
      break
print(ans)

Problem: p02831
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
def gcd(a, b):
    if a < b:
        return gcd(b, a)
    while b > 0:
        a, b = b, a % b
    return a
a, b = map(int, input().split())
print(gcd(a, b))

Failing test case input:
111000 43

Expected output:
4773000


Actual output:
1


Fixed submission (verdict: Accepted):
def gcd(a, b):
    if a < b:
        return gcd(b, a)
    while b > 0:
        a, b = b, a % b
    return a
a, b = map(int, input().split())
print(a*b

Problem: p02831
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
A,B = map(int,input().split())
seki = A*B

if B>A:
    C = A
    A = B
    B = C

while A%B != 0:
    a = A
    b = B
    A = a
    B = a%b
    
print(int(seki/B))

Failing test case input:
110000 549

Expected output:
60390000


Actual output:
301950


Fixed submission (verdict: Accepted):
A,B = map(int,input().split())
seki = A*B

if B>A:
    C = A
    A = B
    B = C

while B != 0:
    a = A
    b = B
    A = B
    B = a%b
    
print(int(seki/A))

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B = list(map(int, input().split()))

large = A if A > B else B
small = A if A < B else B

multi = small

r = large % small
while r != 0:
    multi = r
    r = small % r

print(int(large/multi*small))


Failing test case input:
011101 8

Expected output:
88808


Actual output:
44404


Fixed submission (verdict: Accepted):
A, B = list(map(int, input().split()))

large = A if A > B else B
small = A if A < B else B

def gcd(large, small):
    r = large % small
    while r != 0:
        large = small
        small = r
        r = large % small
    return small

print(large*small
Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B = list(map(int, input().split()))
N = 1
i = 1
if A <= B:
  while (N % A) != 0:
    N = B * i
    i += 1
else:
  while (N % B) != 0:
    N = A * i
    i += 1
print(N)

Failing test case input:
010110 1

Expected output:
10110


Actual output:
1


Fixed submission (verdict: Accepted):
A, B = list(map(int, input().split()))
i = 1
if A <= B:
  N = B
  while (N % A) != 0:
    i += 1
    N = B * i
else:
  N = A
  while (N % B) != 0:
    i += 1
    N = A * i
print(N)

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int,input().split())
big = max(a, b)
small = min(a, b)
for i in range(1, 10000):
  if big*i % small == 0:
    print(big*i)
    exit()

Failing test case input:
100000 52132

Expected output:
1303300000


Actual output:

Fixed submission (verdict: Accepted):
a, b = map(int,input().split())
big = max(a, b)
small = min(a, b)
for i in range(1, 100000):
  if big*i % small == 0:
    print(big*i)
    exit()

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = input().split()
A = int(S[0])
B = int(S[1])
C = 0



for i in range(1,1000000000,1):
  if A > B:
  	C = A * i
  else:
    C = B *i
    
  if C % B == 0:
    print(C)
    break

Failing test case input:
123 456

Expected output:
18696

Actual output:
456


Fixed submission (verdict: Accepted):
S = input().split()
A = int(S[0])
B = int(S[1])
C = 0
D = 0



for i in range(1,100000,1):
  if A > B:
  	C = A * i
  else:
    C = B *i
  
  if A > B:
  	D = B
  else:
    D = A
    
  if C % D == 0:
    print(C)
    break

Problem: p02831
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from math import gcd
a,b=map(int,input().split())
print(a*b/gcd(a,b))

Failing test case input:
001000 22

Expected output:
11000


Actual output:
11000.0


Fixed submission (verdict: Accepted):
from math import gcd
a,b=map(int,input().split())
print((a*b)

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def gcd(a, b):
    if a < b :
        a, b = b, a
    while True:
        a, b = b, a % b
        if b == 0:
            return a

a, b = map(int, input().split())
int(a * b / gcd(a, b))

Failing test case input:
101000 43

Expected output:
4343000


Actual output:

Fixed submission (verdict: Accepted):
def gcd(a, b):
    if a < b :
        a, b = b, a
    while True:
        a, b = b, a % b
        if b == 0:
            return a

a, b = map(int, input().split())
print(int(a * b / gcd(a, b)))
Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import math

d = input().split(" ")
a = int(d[0])
b = int(d[1])
ans = 1
p = math.sqrt(a)
q = math.sqrt(b)
if q <= p:
	p = q
m = int(p)
for i in range(2, m+1):
	while(a % i == 0 and b % i == 0):
		ans *= i
		a = int(a/i)
		b = int(b/i)
ans = ans * a * b
print(ans)

Failing test case input:
011100 10

Expected output:
11100


Actual output:
55500


Fixed submission (verdict: Accepted):
import math

d = input().split(" ")
a = int(d[0])
b = int(d[1])
ans = 1
p = a
if b <= p:
	p = b
for i in range(2, p+1):
	while(a % i == 0 and b % i == 0):
		ans *= i
		a = int(a/i)
		b = int(b/i)
ans = ans * a * b
print(ans)

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=(int(x) for x in input().split())
gcc=1

for i in range(1,max(a,b)):
    if (a%i==0 and b%i==0):
        gcc*=i
        a/=i
        b/=i

print(int(a*b/gcc))


Failing test case input:
010010 77

Expected output:
10010


Actual output:
1


Fixed submission (verdict: Accepted):
a,b=(int(x) for x in input().split())
gcc=1
i=2
while True:
    if(a<i or b<i):
        break
    elif (a%i==0 and b%i==0):
        gcc*=i
        a/=i
        b/=i
        i=2
    else:
        i+=1

print(int(a*b*gcc))

Problem: p02831
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
A, B = map(int, input().split())
i = max(A, B)
A = max(A, B)
B = min(A, B)
while i <= A*B:
    if i%B == 0:
        print(i)
        exit()
    i += A

Failing test case input:
110000 138162

Expected output:
7598910000


Actual output:
138162


Fixed submission (verdict: Accepted):
A, B = map(int, input().split())
i = max(A, B)
B = min(A, B)
A = i
while i <= A*B:
    if i%B == 0:
        print(i)
        exit()
    i += A

Problem: p02831
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
def main():
    a, b = map(int, input().split())
    import math

    print(math.gcd(a,b))
    


if __name__ == "__main__":
    main()


Failing test case input:
100000 99999

Expected output:
9999900000

Actual output:
1


Fixed submission (verdict: Accepted):
def main():
    a, b = map(int, input().split())
    import math

    print(int(a*b/math.gcd(a,b)))
    


if __name__ == "__main__":
    main()

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = list(map(int, input().split()))
a = A[0]
b = A[1]

def gcd(a,b):
  while b!=0:
    a,b=b,a%b
  return a

ans = a*b/gcd(a,b)
print(ans)

Failing test case input:
110000 19750

Expected output:
8690000


Actual output:
8690000.0


Fixed submission (verdict: Accepted):
A = list(map(int, input().split()))
a = A[0]
b = A[1]
 
def gcd(a,b):
  while b!=0:
    a,b=b,a%b
  return a
 
ans = a*b/gcd(a,b)
ans = int(ans)
print(ans)
Problem: p02831
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b=input().split()
a=int(a)
b=int(b)
c=1
d=0
if a>b:
  for i in range(1,a):
    if a%(a-i)==0 and b%(b-i)==0:
      a=a/(a-i)
      b=b/(a-i)
      c=c*(a-i)
  print(int(a*b*c))
if a<b:
  for i in range(1,b):
    if a%(b-i)==0 and b%(b-i)==0:
      a=a/(b-i)
      b=b/(b-i)
      c=c*(b-i)
  print(int(a*b*c))

Failing test case input:
101000 2

Expected output:
101000


Actual output:
202000


Fixed submission (verdict: Accepted):
a,b=input().split()
a=int(a)
b=int(b)
e=a
d=b
c=1
if a>b:
  for i in range(1,e):
    if a%(e-i)==0 and b%(e-i)==0:
      a=a/(e-i)
      b=b/(e-i)
      c=c*(e-i)
  print(int(a*b*c))
if a<b:
  for i in range(1,d):
    if a%(d-i)==0 and b%(d-i)==0:
      a=a/(d-i)
      b=b/(d-i)
      c=c*(d-i)
  print(int(a*b*c))

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B=input().split()
a=int(A)
b=int(B)
 
c=min(a,b)
 
def sosu(x):
    sum=0
    for i in range(x):
        if x%(i+1)==0:
            sum+=1
    if sum==2:
        return True
    else:
        return False

j=2  
kobai=[]
while j<=c:
  if a%j==0 and b%j==0 and sosu(j):
    c=int(c/j)
    kobai.append(j)
    print(j)
    j=2
   
  else:
    j+=1
print(kobai) 
answer=a*b
for i in range(len(kobai)):
  answer=int(answer/kobai[i])

print(answer)


Failing test case input:
011100 7

Expected output:
77700


Actual output:
[]
77700


Fixed submission (verdict: Accepted):
A,B=input().split()
a=int(A)
b=int(B)
 
c=min(a,b)
 
def sosu(x):
    sum=0
    for i in range(x):
        if x%(i+1)==0:
            sum+=1
    if sum==2:
        return True
    else:
        return False

j=2  
kobai=[]
while j<=c:
  if a%j==0 and b%j==0 and sosu(j):
    c=int(c/j)
    kobai.append(j)
    
    a=int(a/j)
    b=int(b/j)
    j=2
   
  else:
    j+=1

answer=int(A)*int(B)
for i in range(len(kobai)):
  answer=int(answer/kobai[i])

print(answer)

Problem: p02831
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
def gcd(a, b):
  if a == 0: return b
  if b == 0: return a
  if a == b: return a
  if a > b: return gcd(b, a%b)
  return gcd(a, b%a)
def lcm(a, b):
  if a == b == 0:
  	return abs(a*b)/gcd(a, b)
  return 0
a, b = map(int, input().split())
print(lcm(a, b))

Failing test case input:
001000 43

Expected output:
43000


Actual output:
0


Fixed submission (verdict: Accepted):
def gcd(a, b):
    if a == 0: return b
    if b == 0: return a
    if a == b: return a
    if a > b: return gcd(b, a%b)
    return gcd(a, b%a)
def lcm(a, b):
    if a == b == 0:
        return 0
    return abs(a*b)/gcd(a, b)
a, b = map(int, input().split())
print(int(lcm(a, b)))
Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B=map(int,input().split())
x=min(A,B)
y=max(A,B)
check=1


if y%x==0:
    print(y)

else:
    root=round((x**(1/2)))
    for i in range(2,root+1):
        if x%i==0 and y%i==0:
            x/=i
            y/=i
            check*=i 
            i=2
            root=round((x**(1/2)))
    print(int(check*x*y))

      


Failing test case input:
111000 84

Expected output:
777000


Actual output:
1554000


Fixed submission (verdict: Accepted):
A,B=map(int,input().split())
x=min(A,B)
y=max(A,B)
check=1


if y%x==0:
    print(y)

else:
    
    while True:
        through=0
        for i in range(2,int(x)):
            if x%i==0 and y%i==0:
                x/=i
                y/=i
                check*=i 
                through=1
                break
        if through==0:
            break
    print(int(check*x*y))

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=sorted(map(int,input().split()))

def gcd(a,b):
    if b==0:
        return a
    else:
        return (gcd(b,a%b))
        

print(gcd(a,b)*a*b)


Failing test case input:
101000 32

Expected output:
404000


Actual output:
25856000


Fixed submission (verdict: Accepted):
a,b=sorted(map(int,input().split()))

def gcd(a,b):
    if b==0:
        return a
    
    else:
        return (gcd(b,a%b))
print(int(a*b/gcd(a,b)))

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
num = [int(s) for s in input().split()]

com = 1
tes = 2
if max(num)%min(num) == 0:
  print(max(num))
else:
  while tes < min(num)**0.5:
    if min(num)%tes == 0 and max(num)%tes == 0:
      com *= tes
      num = [int(n/tes) for n in num]
    else:
      tes += 1

print(com*min(num)*max(num))

Failing test case input:
101010 2

Expected output:
101010


Actual output:
101010
202020


Fixed submission (verdict: Accepted):
num = [int(s) for s in input().split()]

com = 1
tes = 2
if max(num)%min(num) == 0:
  print(max(num))
else:
  while tes < min(num)/2 +1:
    if min(num)%tes == 0 and max(num)%tes == 0:
      com *= tes
      num = [int(n/tes) for n in num]
    else:
      tes += 1
  print(com*min(num)*max(num))

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B = map(int, input().split())
for i in range(A, A*B+1, A):
    if i % B == 0:
        print(i)


Failing test case input:
110001 99999

Expected output:
3666663333


Actual output:
3666663333
7333326666
10999989999


Fixed submission (verdict: Accepted):
A, B = map(int, input().split())
for i in range(A, A*B+1, A):
    if i % B == 0:
        print(i)
        break

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B = map(int, input().split())
a , c = 0, 0

if B > A:
  c = B
  B = A
  A = c
 
for i in range(1, B):
  a = A * i
  if a % B == 0:
    print(a)
    break

Failing test case input:
50 243

Expected output:
12150


Actual output:

Fixed submission (verdict: Accepted):
A, B = map(int, input().split())
a , c = 0, 0
ans = 0

if B > A:
  c = B
  B = A
  A = c
 
for i in range(1, B+1):
  a = A * i
  if ans != 0:
    break
  if a % B == 0:
    ans = a
    break
print(ans)
Problem: p02831
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
a, b = list(map(int, input().split()))
c = math.gcd(a, b)
d = a * b / c
d = d 
print(d)

Failing test case input:
011100 10

Expected output:
11100


Actual output:
11100.0


Fixed submission (verdict: Accepted):
import math
a, b = list(map(int, input().split()))
c = math.gcd(a, b)
d = a * b / c
d = math.floor(d)
print(d)

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B = map(int, input().split())
AA = A
BB = B
lcm = 1
cont = 1

while cont == 1:
  if A % B == 0 or B % A == 0:
    lcm = min(A, B)
    break
  
  if A < B:
    B = B % A
  elif A > B:
    A = A % B

ans = AA * BB / lcm
print(ans)


Failing test case input:
110000 549

Expected output:
60390000


Actual output:
60390000.0


Fixed submission (verdict: Accepted):
A, B = map(int, input().split())
AA = A
BB = B
lcm = 1
cont = 1

while cont == 1:
  if A % B == 0 or B % A == 0:
    lcm = min(A, B)
    break
  
  if A < B:
    B = B % A
  elif A > B:
    A = A % B

ans = int(AA * BB / lcm)
print(ans)

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
ab = list(map(int, input().split()))
a = max(ab)
b = min(ab)
r = a%b
while r!=0:
    a = r
    b = a
    r = a%b
print(int(max(ab) * min(ab)/a))

Failing test case input:
010010 549

Expected output:
5495490


Actual output:
42933


Fixed submission (verdict: Accepted):
ab = list(map(int, input().split()))
a = max(ab)
b = min(ab)
r = a%b
while r!=0:
    a = b
    b = r
    r = a%b
print(int(max(ab) * min(ab)/b))

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = input().split()
complete = int(a) * int(b);
tmp = complete
for i in range(2, min(int(a), int(b)) + 1):
    tmp = complete / i
    if tmp % int(b) == 0 and tmp % int(a) == 0:
        complete = tmp

print(int(complete))


Failing test case input:
111000 84

Expected output:
777000


Actual output:
1554000


Fixed submission (verdict: Accepted):
a, b = input().split()
product = int(a) * int(b);
complete = product
tmp = product
for i in range(2, min(int(a), int(b)) + 1):
    tmp = product / i
    if tmp % int(b) == 0 and tmp % int(a) == 0:
        complete = tmp
print(int(complete))

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = input().split()
complete = int(a) * int(b);
tmp = complete
for i in range(1, min(int(a), int(b)) + 1):
    tmp = complete / i
    if tmp % int(b) == 0 and tmp % int(a) == 0:
        complete = tmp

print(complete)


Failing test case input:
1 16

Expected output:
16


Actual output:
16.0


Fixed submission (verdict: Accepted):
a, b = input().split()
product = int(a) * int(b);
complete = product
tmp = product
for i in range(2, min(int(a), int(b)) + 1):
    tmp = product / i
    if tmp % int(b) == 0 and tmp % int(a) == 0:
        complete = tmp
print(int(complete))
Problem: p02831
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
import math
a,b=map(int,input().split())
print(math.gcd(a,b))

Failing test case input:
010110 8

Expected output:
40440


Actual output:
2


Fixed submission (verdict: Accepted):
import math
a,b=map(int,input().split())
print((a*b)

Problem: p02831
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
import math as mt
a,b=map(int,input().split())
tem=max(a,b)
c=1
if a==b:
    print(a)
elif min(a,b)==1:
    print(max(a,b))
else:
        
    while 1:
        c+=1
        if (tem*c)%a==0 and (tem*c)%b==0:
            print(tem*c)
            break
        

Failing test case input:
2 54

Expected output:
54


Actual output:
108


Fixed submission (verdict: Accepted):
import math as mt
a,b=map(int,input().split())
tem=max(a,b)
c=1
if a==b:
    print(a)
elif min(a,b)==1:
    print(max(a,b))
elif a%b==0 or b%a==0:
    print(max(a,b))
else:
        
    while 1:
        c+=1
        if (tem*c)%a==0 and (tem*c)%b==0:
            print(tem*c)
            break

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000)

A, B = map(int, input().split())
tmp_a, tmp_b = A, B
print(tmp_a, tmp_b)
while tmp_a % tmp_b != 0:
    tmp_a, tmp_b = tmp_b, tmp_a % tmp_b
    
    
    


print(int(A * B / tmp_b))

Failing test case input:
110000 549

Expected output:
60390000


Actual output:
110000 549
60390000


Fixed submission (verdict: Accepted):

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000)

A, B = map(int, input().split())
tmp_a, tmp_b = A, B
while tmp_a % tmp_b != 0:
    tmp_a, tmp_b = tmp_b, tmp_a % tmp_b

print(int(A * B / tmp_b))

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B=input().split()
a=int(A)
b=int(B)
 
c=min(a,b)
 
def sosu(x):
    sum=0
    for i in range(x):
        if x%(i+1)==0:
            sum+=1
    if sum==2:
        return True
    else:
        return False

j=2  
kobai=[]
while j<=c:
  if a%j==0 and b%j==0 and sosu(j):
    c=int(c/j)
    kobai.append(j)
    
    j=2
   
  else:
    j+=1

answer=a*b
for i in range(len(kobai)):
  answer=int(answer/kobai[i])

print(answer)


Failing test case input:
50 306

Expected output:
7650


Actual output:
478


Fixed submission (verdict: Accepted):
A,B=input().split()
a=int(A)
b=int(B)
 
c=min(a,b)
 
def sosu(x):
    sum=0
    for i in range(x):
        if x%(i+1)==0:
            sum+=1
    if sum==2:
        return True
    else:
        return False

j=2  
kobai=[]
while j<=c:
  if a%j==0 and b%j==0 and sosu(j):
    c=int(c/j)
    kobai.append(j)
    
    a=int(a/j)
    b=int(b/j)
    j=2
   
  else:
    j+=1

answer=int(A)*int(B)
for i in range(len(kobai)):
  answer=int(answer/kobai[i])

print(answer)
Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def gcd(a,b):
    if (a % b) == 0:
        return b
    else:
        return gcd(b, a%b)


def lcm(a, b):
    y = gcd(a,b)
    print(y)
    if (y == 0):
        return a*b

    else:
        return a*b/y


A, B = map(int,input().split())
if A < B:
    t = A
    A = B
    B = t


x  = int(lcm(A,B))
print(x)



Failing test case input:
101000 2

Expected output:
101000


Actual output:
2
101000


Fixed submission (verdict: Accepted):
def gcd(a,b):
    if (a % b) == 0:
        return b
    else:
        return gcd(b, a%b)


def lcm(a, b):
    y = gcd(a,b)
    if (y == 0):
        return a*b

    else:
        return a*b/y


A, B = map(int,input().split())
if A < B:
    t = A
    A = B
    B = t


x  = int(lcm(A,B))
print(x)

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,S = map(int, input().split())
tmp = 1
a = 2
while (True):
  if N % a == 0 and S % a == 0:
    N,S = int(N / a), int(S / a)
    tmp *= a
    a = 1
  a += 1
  if N / 2 <= a or S / 2 <= a:
    break
print(tmp * S * N)

Failing test case input:
110000 22

Expected output:
110000


Actual output:
1210000


Fixed submission (verdict: Accepted):
N,S = map(int, input().split())
tmp = 1
a = 1
while True:
  if N 
    break
  if N % a == 0 and S % a == 0:
    N,S = N 
    tmp *= a
    a = 1
  a += 1

print(tmp * S * N)

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B = map(int, input().split())
for i in range(B):
    if A * i % B == 0:
        print(A * i)
        exit(0)


Failing test case input:
100010 6

Expected output:
300030


Actual output:
0


Fixed submission (verdict: Accepted):
A, B = map(int, input().split())
i = 1
while True:
    if (A * i) % B == 0:
        print(A * i)
        exit(0)
    i += 1

Problem: p02831
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A,B=map(int,input().split())
if B > A:
    A,B = B,A

for i in range(1, int(10**5 / A)):
    if (A * i) % B == 0:
        print(A * i)
        break 

Failing test case input:
010010 87

Expected output:
870870


Actual output:

Fixed submission (verdict: Accepted):
A,B=map(int,input().split())
if B > A:
    A,B = B,A

for i in range(1, B+1):
    if (A * i) % B == 0:
        print(A * i)
        break

Problem: p02831
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A,B=map(int,input().split())
num=1
for i in range(1,max(A,B)+1):
    if A%i==0 and B%i==0:
        num*=i
print(int(A*B/num))

Failing test case input:
110000 19750

Expected output:
8690000


Actual output:
0


Fixed submission (verdict: Accepted):
A,B=map(int,input().split())
num=1
for i in range(1,max(A,B)):
    if A%i==0 and B%i==0:
        num=i
print(int(A*B/num))
Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

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

if A<B:
    A=B
    B=swapA

Anext=A
Bnext=B
amari=1

while amari!=0:
    amari=Anext%Bnext
    if amari==0:
        Bnext=Bnext
    else:
        Anext=Bnext
        Bnext=amari

A=A/Bnext
B=B/Bnext

print(int(A*B))
    

Failing test case input:
110010 549

Expected output:
20131830


Actual output:
6710610


Fixed submission (verdict: Accepted):

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

if A<B:
    A=B
    B=swapA

Anext=A
Bnext=B
amari=1

while amari!=0:
    amari=Anext%Bnext
    if amari==0:
        Bnext=Bnext
    else:
        Anext=Bnext
        Bnext=amari

A=A
B=B/Bnext

print(int(A*B))

Problem: p02831
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
def lcm(a,b):
  m=max(a,b)
  n=min(a,b)
  kk=0
  for j in range(m,a*b,n):
    if j%a==0 and j%b==0:
      kk=j
      break
  return kk
a,b=map(int,input().split())
c=lcm(a,b)
print(c)

Failing test case input:
011100 7

Expected output:
77700


Actual output:
0


Fixed submission (verdict: Accepted):
def lcm(a,b):
  m=max(a,b)
  n=min(a,b)
  kk=0
  for j in range(n,a*b+1,n):
 

    if j%a==0 and j%b==0:
      kk=j
      break
  return kk
a,b=map(int,input().split())
c=lcm(a,b)
print(c)

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import math
A, B = map(int, input().split())
gcd = 1
for i in range(2,min(A,B)):
  if A%i==0 and B%i==0:
    gcd = i
print(int(A*B/gcd))

Failing test case input:
101010 2

Expected output:
101010


Actual output:
202020


Fixed submission (verdict: Accepted):
import math
A, B = map(int, input().split())
gcd = 1
for i in range(2,min(A,B)+1):
  if A%i==0 and B%i==0:
    gcd = i
print(int(A*B/gcd))

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B = [int(v) for v in input().split()]

minV = min(A, B)
maxV = max(A, B)

if maxV % minV == 0:
  print(maxV)

if maxV == minV + 1:
  print(maxV * minV)

v = maxV * 2

for i in range(2, minV + 1):
  if v % minV != 0:
    v += maxV
    continue
  print(v)
  exit()


Failing test case input:
100000 99999

Expected output:
9999900000

Actual output:
9999900000
9999900000


Fixed submission (verdict: Accepted):
A, B = [int(v) for v in input().split()]

minV = min(A, B)
maxV = max(A, B)

if maxV % minV == 0:
  print(maxV)
  exit()

if maxV == minV + 1:
  print(maxV * minV)
  exit()

v = maxV * 2

for i in range(2, minV + 1):
  if v % minV != 0:
    v += maxV
    continue
  print(v)
  exit()

Problem: p02831
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b=map(int,input().split());print(a*b)

Failing test case input:
2 54

Expected output:
54


Actual output:
108


Fixed submission (verdict: Accepted):
import math as mp
a,b=map(int,input().split())
print(a*b
Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = input().split()
complete = int(a) * int(b);
tmp = complete
for i in range(2, min(int(a), int(b)) + 1):
    tmp = complete / i
    if tmp % int(b) == 0 and tmp % int(a) == 0:
        if tmp / int(b) > complete / int(b) and tmp / int(a) > complete / int(a):
            complete = tmp
print(int(complete))


Failing test case input:
001000 22

Expected output:
11000


Actual output:
22000


Fixed submission (verdict: Accepted):
a, b = input().split()
product = int(a) * int(b);
complete = product
tmp = product
for i in range(2, min(int(a), int(b)) + 1):
    tmp = product / i
    if tmp % int(b) == 0 and tmp % int(a) == 0:
        complete = tmp
print(int(complete))

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
Ar =list(map(int,input().split()))

if Ar[0]>=Ar[1]:
  A=Ar[0]
  B=Ar[1]
else:
  A=Ar[1]
  B=Ar[0]
print(A,B)

r=None
while r!=0:
  r = (A%B)
  A = B
  B = r

Ans=int(Ar[0]*Ar[1]/A)
print(Ans)

Failing test case input:
010010 549

Expected output:
5495490


Actual output:
10010 549
5495490


Fixed submission (verdict: Accepted):
Ar =list(map(int,input().split()))

if Ar[0]>=Ar[1]:
  A=Ar[0]
  B=Ar[1]
else:
  A=Ar[1]
  B=Ar[0]

r=None
while r!=0:
  r = (A%B)
  A = B
  B = r

Ans=int(Ar[0]*Ar[1]/A)
print(Ans)

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
strings = input().split(' ')
A = int(strings[0])
B = int(strings[1])

i = 1
while i < 1e6:
    if i % A ==0 and i % B == 0:
        print(i)
        break
    else:
        i = i + 1

    

Failing test case input:
110000 87

Expected output:
9570000


Actual output:

Fixed submission (verdict: Accepted):
strings = input().split(' ')
A = int(strings[0])
B = int(strings[1])

i = min(A,B)
m = max(A,B)
n = min(A,B)
while 1:
    mt = n
    n = m % n
    m = mt
    if n == 0:
        break
if m != 0:
    print(A*B
else:
    print(A*B)

Problem: p02831
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = input().split()
complete = int(a) * int(b);
tmp = complete
for i in range(1, min(int(a), int(b)) + 1):
    tmp = complete / i
    if tmp % int(b) == 0 and tmp % int(a) == 0:
        complete = tmp

print(int(complete))


Failing test case input:
111000 84

Expected output:
777000


Actual output:
1554000


Fixed submission (verdict: Accepted):
a, b = input().split()
product = int(a) * int(b);
complete = product
tmp = product
for i in range(2, min(int(a), int(b)) + 1):
    tmp = product / i
    if tmp % int(b) == 0 and tmp % int(a) == 0:
        complete = tmp
print(int(complete))
Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
c = list(map(int, input().split()))

if(int(len(set(c)) == 1)):
    print("No")
elif(len(c) != len(set(c))):
    print("YES")
else:
    print("No")

Failing test case input:
4 3 4

Expected output:
Yes


Actual output:
YES


Fixed submission (verdict: Accepted):
c = list(map(int, input().split()))

if(int(len(set(c)) == 3)):
    print("No")
elif(int(len(set(c)) == 2)):
    print("Yes")
else:
    print("No")

Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=map(int,input().split())

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

Failing test case input:
14 3 2

Expected output:
No


Actual output:

Fixed submission (verdict: Accepted):
a,b,c=map(int,input().split())

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

Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int,input().split())
if a == b:
    if a == c:
        print("No")
    else:
        print("Yes")
elif a == c:
    print("Yes") 
else:
    print("No")

Failing test case input:
1 -2 -2

Expected output:
Yes


Actual output:
No


Fixed submission (verdict: Accepted):
a, b, c = map(int,input().split())
if a == b:
    if a == c:
        print("No")
    else:
        print("Yes")
elif a == c:
    print("Yes") 
elif b == c:
    print("Yes")
else:
    print("No")

Problem: p02771
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a,b,c  = map(int,input().split())

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


Failing test case input:
6 5 6

Expected output:
Yes


Actual output:
No


Fixed submission (verdict: Accepted):
a,b,c  = map(int,input().split())

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

Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, C = [int(x) for x in input().split()]

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

Failing test case input:
14 1 1

Expected output:
Yes


Actual output:
No


Fixed submission (verdict: Accepted):
A, B, C = [int(x) for x in input().split()]

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

Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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 B!=A: ans='YES'

print(ans)

Failing test case input:
24 3 2

Expected output:
No


Actual output:
NO


Fixed submission (verdict: Accepted):
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 B!=A: ans='Yes'

print(ans)
Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c = map(int,input().split())

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

Failing test case input:
3 3 -2

Expected output:
Yes


Actual output:
No


Fixed submission (verdict: Accepted):
a,b,c = map(int,input().split())

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

Problem: p02771
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
lst = list(map(int,input().split()))
ans = False
lst.sort()
if lst[0] == lst[1]:
    if lst[0] != lst[2]:
        ans = True
else:
    if lst[0] == lst[2]:
        ans = True

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

Failing test case input:
3 3 -2

Expected output:
Yes


Actual output:
No


Fixed submission (verdict: Accepted):
import sys
lst = list(map(int,input().split()))
lst1 = list(set(lst))
ans = False
if len(lst1) == 1:
    print('No')
    sys.exit()
if lst.count(lst1[0]) == 1:
    if lst.count(lst1[1]) == 2:
        ans = True
else:
    if lst.count(lst1[1]) == 1:
        ans = True

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

Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def solve():
    A, B, C = list(input().split())
    if A == B == C:
        print("Yes")
        exit()
    else:
        print("No")


if __name__ == '__main__':
    solve()


Failing test case input:
1 1 17

Expected output:
Yes


Actual output:
No


Fixed submission (verdict: Accepted):
def solve():
    a, b, c= list(input().split())
    if a == b == c:
        print("No")
    elif a == b or a == c or b == c:
        print("Yes")
    else:
        print("No")


if __name__ == '__main__':
    solve()

Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, C = map(int, input().split())

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

Failing test case input:
4 3 4

Expected output:
Yes


Actual output:
No


Fixed submission (verdict: Accepted):
A, B, C = map(int, input().split())

if (A == B and B != C) or (A == C and C != B) or (B == C and A != C):
    print("Yes")

else:
    print("No")

Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
li = list(map(int, input().split()))
if (len(li)) == 2:
    print("Yes")
else:
    print("No")


Failing test case input:
4 3 4

Expected output:
Yes


Actual output:
No


Fixed submission (verdict: Accepted):
li = list(map(int, input().split()))
if (len(set(li))) == 2:
    print("Yes")
else:
    print("No")

Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=(int(x) for x in input().split())

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

Failing test case input:
6 5 6

Expected output:
Yes


Actual output:
No


Fixed submission (verdict: Accepted):
a,b,c=(int(x) for x in input().split())

if a==b==c :
    print("No")

elif a!=b and b!=c and a!=c:
    print("No")
    
else:
    print("Yes")
Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s=list(input())

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

Failing test case input:
1 -2 -2

Expected output:
Yes


Actual output:
No


Fixed submission (verdict: Accepted):
s=list(map(int,input().split()))

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

Problem: p02771
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a,b,c=list(map(int,input().split()))
print('No' if a==b==c else 'Yes')

Failing test case input:
18 2 5

Expected output:
No


Actual output:
Yes


Fixed submission (verdict: Accepted):
num=list(map(int,input().split()))
print('Yes' if len(num) == len(set(num))+1 else 'No')

Problem: p02771
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a, b, c = map(int, input().split())
 
count = 1
if a==b:
  count+=1
elif a==c:
  count+=1
elif b==c:
  count+=1
 
if count == 1:
  print('Yes')
else:
  print('No')

Failing test case input:
1 4 26

Expected output:
No


Actual output:
Yes


Fixed submission (verdict: Accepted):
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')

Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

data = input().split( )

if (data[0] == data[1] or data[1] == data[2] or
   data[2] ==data[0]) and data[1]!= data[2]!=data[0] :
    print("Yes")

else:
    print("No")

Failing test case input:
18 3 3

Expected output:
Yes


Actual output:
No


Fixed submission (verdict: Accepted):

data = input().split( )

if (data[0] == data[1] or data[1] == data[2] or
   data[2] ==data[0]) and not data[1]== data[2]==data[0] :
    print("Yes")

else:
    print("No")

Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int, input().split())
if a== b and b == c:
    print('No')
else:
    print('Yes')

Failing test case input:
0 -2 1

Expected output:
No


Actual output:
Yes


Fixed submission (verdict: Accepted):
l= list(map(int, input().split()))
l = set(l)
if len(l) == 2:
    print('Yes')
else:
    print('No')

Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = list(map(int,input().split()))
a.sort()
if a[0] == a[1]:
	if a[1] == a[2]:
		print("NO")
	else:
		print("YES")
else:
	if a[1] == a[2]:
		print("YES")
	else:
		print("NO")

Failing test case input:
1 4 17

Expected output:
No


Actual output:
NO


Fixed submission (verdict: Accepted):
a = list(map(int,input().split()))
a.sort()
if a[0] == a[1]:
	if a[1] == a[2]:
		print("No")
	else:
		print("Yes")
else:
	if a[1] == a[2]:
		print("Yes")
	else:
		print("No")
Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, C = input().split(' ')
if (A == B == C) or (A!= B != C):
  print('No')
else:
  print('Yes')


Failing test case input:
6 5 6

Expected output:
Yes


Actual output:
No


Fixed submission (verdict: Accepted):
A, B, C = input().split(' ')
if (A == B == C) or (A!= B != C != A):
  print('No')
else:
  print('Yes')

Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c = map(int, input().split(' '))
if a == b == c or (a != b and b!=c):
    print('Yes')
else:
    print('No')

Failing test case input:
3 3 -1

Expected output:
Yes


Actual output:
No


Fixed submission (verdict: Accepted):
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')

Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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')


Failing test case input:
4 4 12

Expected output:
Yes


Actual output:
yes


Fixed submission (verdict: Accepted):
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')

Problem: p02771
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
A, B, C = map(int, input().split())

if (len(set({A, B, C})) == 2):
    print("YES")
else:
    print("NO")

Failing test case input:
5 5 6

Expected output:
Yes


Actual output:
YES


Fixed submission (verdict: Accepted):
A, B, C = map(int, input().split())

if (len(set({A, B, C})) == 2):
    print("Yes")
else:
    print("No")

Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,C=map(int,input().split())
if A==B and B==C:
  print("No")
else:
  print("Yes")

Failing test case input:
3 5 6

Expected output:
No


Actual output:
Yes


Fixed submission (verdict: Accepted):
A,B,C=map(int,input().split())
if (A==B or B==C or C==A) and not(A==B and B==C and C==A):
  print("Yes")
else:
  print("No")

Problem: p02771
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c = map(int,input().split())

if a == b:
  if b != c:
    print('YES')
  else:
    print('NO')
else:
  if b != c and a != c:
    print('NO')
  else:
    print('YES')

Failing test case input:
3 3 -2

Expected output:
Yes


Actual output:
YES


Fixed submission (verdict: Accepted):
a,b,c = map(int,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')