qyliang/CodeNanoFix huggingface dataset:
Buggy code:
a,b = map(int,input().split())
if a/0.08 == a//0.08:
    emin = a//0.08
else:
    emin = a//0.08+1
if (a+1)/0.08 == (a+1)//0.08:
    emax = (a+1)//0.08-1
else:
    emax = (a+1)//0.08
tmin = b/0.1
tmax = (b+1)/0.1-1
if tmax > emax:
    if tmin <= emax:
        print(tmin)
    else:
        print(-1)
else:
    if emin <= tmax:
        print(emin)
    else:
        print(-1)

Fixed code:
a,b = map(int,input().split())
if a/0.08 == a//0.08:
    emin = a//0.08
else:
    emin = a//0.08+1
if (a+1)/0.08 == (a+1)//0.08:
    emax = (a+1)//0.08-1
else:
    emax = (a+1)//0.08
tmin = b/0.1
tmax = (b+1)/0.1-1
if tmax >= emax:
    if tmin <= emax:
        print(int(tmin))
    else:
        print(-1)
else:
    if emin <= tmax:
        print(int(emin))
    else:
        print(-1)
Buggy code:
a,b=map(int,input().split())
for i in range(1,100001):
    #print(int(25*0.08),int(25*0.1))
    if int(i*0.08)==a and int(i*0.1)==b:
        print(i)
        break
    

Fixed code:
a,b=map(int,input().split())
f=0
for i in range(1,100001):
    #print(int(25*0.08),int(25*0.1))
    if int(i*0.08)==a and int(i*0.1)==b:
        print(i)
        f=1
        break
if f==0:
    print(-1)
Buggy code:
import math
a, b = map(int, input().split(' '))

ans = min(math.ceil(a*12.5), b*10)
if int(ans*0.1) != b:
    print('-1')
    exit()
if int(ans*0.08) != a:
    print('-1')
    exit()

print(ans)

# for i in range(1100):
#     if int(i*0.08) == a and int(i*0.1) == b:
#         print(i)
#         exit()

# print('-1')


Fixed code:
# import math
a, b = map(int, input().split(' '))

# ans = math.ceil(a*12.5)
# if int(ans*0.1) != b:
#     print('-1')
#     exit()

# print(ans)

for i in range(1100):
    if int(i*0.08) == a and int(i*0.1) == b:
        print(i)
        exit()

print('-1')
Buggy code:
a, b = map(int, input().split())

upper = 1300

price = -1
for i in range(1, upper):
  tax8 = int(i*0.08)
  tax10 = int(i*0.1)
  if a == tax8 ans b == tax10:
    price = i
    break
    
print(price)

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

upper = 1300

price = -1
for i in range(1, upper):
    tax8 = int(i * 0.08)
    tax10 = int(i * 0.1)
    if a == tax8 and b == tax10:
        price = i
        break

print(price)
Buggy code:
A,B = [int(i) for i in input().split()]

for n in range(1,101):
  print(n)
  if int(n*0.08) == A and int(n*0.1) == B:
    print(n)
    exit()
print("-1")

Fixed code:
A,B = [int(i) for i in input().split()]

for n in range(1,1200):
  if int(n*0.08) == A and int(n*0.1) == B:
    print(n)
    exit()
print("-1")
Buggy code:
import math as m
a,b=map(int,input().split())
flag=True
for i in range(1,101):
    if m.floor(i*(0.08))==a and m.floor(i*(0.08))==b:
        flag=False
        print(i)
        break
if flag:
    print(-1)
    

Fixed code:
import math as m
a,b=map(int,input().split())
flag=True
for i in range(1,100000):
    if m.floor(i*0.08)==a and m.floor(i*0.10)==b:
        flag=False
        print(i)
        break
if flag:
    print(-1)
Buggy code:
import math
a,b = map(int, input().split())
for i in range(1 , 1e5):
    a2 = math.floor(i*0.08)
    b2 = math.floor(i*0.1)
    if a2 == a and b2 == b:
        exit(print(i))
    print(-1)

Fixed code:
import math
a,b = map(int, input().split())
for i in range(1 , 100000):
    a2 = math.floor(i*0.08)
    b2 = math.floor(i*0.1)
    if a2 == a and b2 == b:
        exit(print(i))
print(-1)
Buggy code:
a,b=map(int,input().split())
for i in range(10000):
    if int(i*0.08) == A and int(i*0.1) == B:
        print(i)
        break
else:
    print(-1)


Fixed code:
A, B = map(int, input().split())
 
for i in range(10000):
    if int(i * 0.08) == A and int(i * 0.1) == B:
        print(i)
        break
else:
    print(-1)
Buggy code:
def main():
    a, b = map(int, input().split())
    eight = [i for i in range(0, 10001) if a == int(i * 0.08)]
    ten = [i for i in range(0, 10001) if b == int(i * 0.1)]
    print(eight)
    print(ten)
    for i in eight:
        for j in ten:
            if i == j:
                print(i)
                return
    print(-1)


if __name__ == '__main__':
    main()


Fixed code:
def main():
    a, b = map(int, input().split())
    eight = [i for i in range(0, 2000) if a == int(i * 0.08)]
    ten = [i for i in range(0, 2000) if b == int(i * 0.1)]
    for i in eight:
        for j in ten:
            if i == j:
                print(i)
                return
    print(-1)


if __name__ == '__main__':
    main()
Buggy code:
import math
a, b = map(int, input().split())

for i in range(1010):
    tax8 = math.floor(a * 0.08)
    tax10 = math.floor(a * 0.1)

    if a == tax8 and b == tax10:
        print(i)
        exit()

print(-1)

Fixed code:
a, b = map(int, input().split())
for i in range(1010):
    tax8 = int(i * 0.08)
    tax10 = int(i * 0.1)

    if a == tax8 and b == tax10:
        print(i)
        exit()

print(-1)
Buggy code:
import math
A, B = map(int,(input().split()))

list1 = []
list2 = []

border1 = math.ceil(A/0.08)
border2 = math.ceil((A+1)/0.08-1)
border3 = math.ceil(A/0.1)
border4 = math.ceil((A+1)/0.1-1)

for i in range(border1,border2+1,1):
    list1.append(i)
for j in range(border3,border4+1,1):
    list2.append(j)
    
list3 = list(set(list1) & set(list2))

if bool(list3)==True:
    print(min(list3))
else:
    print('-1')

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

list1 = []
list2 = []

border1 = math.ceil(A/0.08)
border2 = math.ceil((A+1)/0.08-1)
border3 = math.ceil(B/0.1)
border4 = math.ceil((B+1)/0.1-1)

for i in range(border1,border2+1,1):
    list1.append(i)
for j in range(border3,border4+1,1):
    list2.append(j)
    
list3 = list(set(list1) & set(list2))

if bool(list3)==True:
    print(min(list3))
else:
    print('-1')
Buggy code:
a = list(map(float,input().split()))
 
for i in range(0, 1251):
  if a[0]/0.08 >= i and (a[0]-1.0)/0.08 < i and a[1]/0.1 >= i and (a[1]-1.0)/0.1 < i:
    print(i)
    return
print(-1)

Fixed code:
def f():
  a = list(map(float,input().split()))

  for i in range(0, 1251):
    if i >= a[0]/0.08 and i < (a[0]+1)/0.08 and i >= a[1]/0.1 and i < (a[1]+1)/0.1:
      print(i)
      return

  print(-1)

f()
Buggy code:
a,b = map(int, input().split())
for i in range(1, 1001):
    if int(i**0.08)==a and int(i*0.1)==b:
        print(i)
        exit()
print(-1)

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

for i in range(1, 1001):
  if int(i * 0.08) == a and int(i * 0.1) == b:
    print(i)
    exit()
print(-1)
Buggy code:
import math
tax_eight, tax_ten = map(int, input().split())
min_eight_price = math.ceil(tax_eight / 0.08)
max_eight_price = math.floor((tax_eight + 1) / 0.08 - 1)
min_ten_price = tax_ten / 0.1 
max_ten_price = (tax_ten + 1) / 0.1 - 1
print(min_eight_price, max_eight_price)
print(min_ten_price, max_ten_price)
min_price = max(min_eight_price, min_ten_price)
max_price = min(max_eight_price, max_ten_price)
if max_price < min_price:
    print(-1)
else:
    print(int(min_price))


Fixed code:
import math
tax_eight, tax_ten = map(int, input().split())
min_eight_price = math.ceil(tax_eight / 0.08)
max_eight_price = math.floor((tax_eight + 1) / 0.08 - 1)
min_ten_price = tax_ten / 0.1 
max_ten_price = (tax_ten + 1) / 0.1 - 1
min_price = max(min_eight_price, min_ten_price)
max_price = min(max_eight_price, max_ten_price)
if max_price < min_price:
    print(-1)
else:
    print(int(min_price))
Buggy code:
import sys
input = sys.stdin.readline

A, B = [int(x) for x in input().split()]

for i in range(10 ** 6):
    if i * 1.08 == A and i * 1.1 == B:
        print(i)
        sys.exit()
print(-1)

Fixed code:
import sys
input = sys.stdin.readline
import math

A, B = [int(x) for x in input().split()]

for i in range(10 ** 6):
    if math.floor(i * 0.08) == A and math.floor(i * 0.1) == B:
        print(i)
        sys.exit()
print(-1)
Buggy code:
A, B = map(int, input().split())
ans = -1
for candidate in range(max(A, B), 1001):
    print(candidate)
    if (int(candidate * 0.08) == A) and (int(candidate * 0.1) == B):
        ans = candidate
        break
print(ans)


Fixed code:
A, B = map(int, input().split())
ans = -1
for candidate in range(max(A, B), 1009):
    if (int(candidate * 0.08) == A) and (int(candidate * 0.1) == B):
        ans = candidate
        break
print(ans)
Buggy code:
import math
A ,B = list(map(int,input().split()))

def problem_koganemaru(A,B):  
  for price in range(10000):
    if math.ceil(price*0.08) == A and math.ceil(price*0.1) == B:
      return price
  return -1

print(problem_koganemru(A,B))

Fixed code:
import math
A ,B = list(map(int,input().split()))
 
def problem_koganemaru(A,B):  
  for price in range(10000):
    if math.floor(price*0.08) == A and math.floor(price*0.1) == B:
      return price
  return -1
 
print(problem_koganemaru(A,B))
Buggy code:
a,b=map(int,input().split())

eightper = 0.08
tenper = 0.1
ans = -1
for i in range(1,100*(1+tenper)+1):
    if int(i*eightper)==a:
        if int(i*tenper)==b:
            ans=i
            break
print(ans)

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

eightper = 0.08
tenper = 0.1
ans = -1
for i in range(1,1000+1):
    if int(i*eightper)==a:
        if int(i*tenper)==b:
            ans=i
            break
print(ans)
Buggy code:
import sys
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

A, B = rl()

import math
for i in range(math.floor(B * 100 / 10), math.ceil(A * 100 / 8)+1):
    if math.floor(i*10/100) == B and math.floor(i*8/100) == A:
        print(i)
print(-1)

Fixed code:
import sys
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

A, B = rl()

import math
for i in range(1, 2000):
    if math.floor(i*8/100) == A and math.floor(i*10/100) == B:
        print(i)
        exit()
print(-1)
Buggy code:
# coding: utf-8

a, b = map(int, input().split())
# print(a,b)
# x=-1
# y=-1

# xr=[]
# yr=[]
# for i in range(1,101):
#     if i*0.08//1==a:
#         # print("x:{}".format(i))
#         x=i
#         xr.append(x)
# for i in range(1,101):
#     if i *0.1//1==b:
#         # print("y:{}".format(i))
#         y=i
#         yr.append(y)
# flag=False
#
# result=[]
# for i in xr:
#     for j in yr:
#         if i==j:
#             result.append(i)
#
# if len(result)>0:
#     print(result[0])
# else:
#     print('-1')
flag =False
for i in range(1,1010):
    if 1009*0.08//1==a and 1009*0.1//1==b:
        print(i)
        flag=True
        break

if not flag:
    print(-1)


Fixed code:
# coding: utf-8

a, b = map(int, input().split())
# print(a,b)
# x=-1
# y=-1

# xr=[]
# yr=[]
# for i in range(1,101):
#     if i*0.08//1==a:
#         # print("x:{}".format(i))
#         x=i
#         xr.append(x)
# for i in range(1,101):
#     if i *0.1//1==b:
#         # print("y:{}".format(i))
#         y=i
#         yr.append(y)
# flag=False
#
# result=[]
# for i in xr:
#     for j in yr:
#         if i==j:
#             result.append(i)
#
# if len(result)>0:
#     print(result[0])
# else:
#     print('-1')
flag =False
for i in range(1,1010):
    if i*0.08//1==a and i*0.1//1==b:
        print(i)
        flag=True
        break

if not flag:
    print(-1)
Buggy code:
a,b = list(map(int,input().split()))
to = 0

while 1:
  to += 100
  c = int(to * 0.08)
  d = int(to * 0.1)
  if c >= a and d >= b:
    
    while 1:
      to -= 1
      c = int(to * 0.08)
      d = int(to * 0.1)
      if c == a and d == b:
        print(to)
        exit()
      elif to % 100 == 0:
        print(-1)
        exit()

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

while 1:
  to += 100
  c = int(to * 0.08)
  d = int(to * 0.1)
  if c >= a and d >= b:
    to -= 100
    while 1:
      to += 1
      c = int(to * 0.08)
      d = int(to * 0.1)
      if c == a and d == b:
        print(to)
        exit()
      elif to % 100 == 0:
        print(-1)
        exit()
Buggy code:
A,B=map(int,input().split())
for i in range(1,10010):
	if i*0.08==A and i*0.1==B:
		print(i)
		exit()
print(-1)

Fixed code:
A,B=map(int,input().split())
for i in range(1,10010):
	if int(i*0.08)==A and int(i*0.1)==B:
		print(i)
		exit()
print(-1)
Buggy code:
A,B = map(int,input().split())
i = -1

for i in range (10100):
  if int(i*0.08) == A and int(i*0.1) == B:
    print(i)
    break

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

for i in range (10100):
  if int(i*0.08) == A and int(i*0.1) == B:
    print(i)
    exit()
    
print(-1)
Buggy code:
a, b = list(map(int,input().split()))

for p in range(1000):
  if int((p + 1) * 0.08) == a and int((p + 1) * 0.1) == b:
    print(p)
    break
  if p == 999:
    print('-1')

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

for p in range(1000):
  if int((p + 1) * 0.08) == a and int((p + 1) * 0.1) == b:
    print(p + 1)
    break
  if p == 999:
    print('-1')
Buggy code:
a = [i for i in range(int((A-1)*100/8 ), int((A+1)*100/8 ))]
b = [i for i in range(int((B-1)*100/10), int((B+1)*100/10))]

a = [i for i in a if int(i*0.08) == A]
b = [i for i in b if int(i*0.10) == B]

ans = list(set(a) & set(b))
if ans and min(ans) > 0:
    print(min(ans))
else:
    print(-1)


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

a = [i for i in range(int((A-1)*100/8 ), int((A+1)*100/8 ))]
b = [i for i in range(int((B-1)*100/10), int((B+1)*100/10))]

a = [i for i in a if int(i*0.08) == A]
b = [i for i in b if int(i*0.10) == B]

ans = list(set(a) & set(b))
if ans and min(ans) > 0:
    print(min(ans))
else:
    print(-1)
Buggy code:
import math
A, B = map(int, input().split())
for i in range(10000):
    if math.floor(i*0.08) == A and math.floor(i*0.1) == B:
        print(i)
        break

Fixed code:
import math
A, B = map(int, input().split())
for i in range(10001):
    if math.floor(i*0.08) == A and math.floor(i*0.1) == B:
        print(i)
        break
    if i == 10000:
        print(-1)
Buggy code:
a, b = map(int, input().split(' '))

b_l = list(range(int(b/0.1), int((b+0.99)//0.1+1)))
for b_ in b_l:
  s = int(b_*0.08//1)
  if s==a:
    print(str(b_))
    exit(0)
prin('-1')

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

b_l = list(range(int(b/0.1), int((b+0.99)//0.1+1)))
for b_ in b_l:
  s = int(b_*0.08//1)
  if s==a:
    print(str(b_))
    exit(0)
print('-1')
Buggy code:
def main():
    a, b = map(int, input().split())
    ans = -1
    for i in range(10000, 1, -1):
        tax1 = int(i*0.08)
        tax2 = int(i*0.08)
        if tax1 == a and tax2 == b:
            ans = i
    print(ans)


if __name__ == "__main__":
    main()


Fixed code:
def main():
    a, b = map(int, input().split())
    ans = -1
    for i in range(10000, -1, -1):
        tax1 = int(i*0.08)
        tax2 = int(i*0.10)
        if tax1 == a and tax2 == b:
            ans = i
    print(ans)


if __name__ == "__main__":
    main()
Buggy code:
a, b = map(int, input().split())
for i in range(1, 10**5):
    if (i*8) // 100 == a and i // 10 == b:
        print(n)
        exit()
print(-1)

Fixed code:
a, b = map(int, input().split())
for i in range(1, 10**5):
    if (i*8) // 100 == a and i // 10 == b:
        print(i)
        exit()
print(-1)
Buggy code:
import math
A, B = map(int,input().split())
A, B = 19, 99

UE_8 = (A+1)/0.08
SHITA_8 = A/0.08
UE_10 = (B+1)/0.10
SHITA_10 = B/0.10

if UE_8 < SHITA_10 or UE_10 < SHITA_8:
    print(-1)
else:
    i = math.ceil(SHITA_8)
    j = math.floor(UE_8)
    for n in range(j-i+1,start=i):
        if i < UE_10 and i >= SHITA_10:
            print(i)
        i+=1
        

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

UE_8 = math.ceil((A+1)/0.08)-1
SHITA_8 = A/0.08
UE_10 = math.ceil((B+1)/0.10)-1
SHITA_10 = B/0.10

if UE_8 < math.ceil(SHITA_10) or UE_10 < math.ceil(SHITA_8):
    print(-1)
else:
    i = math.ceil(SHITA_8)
    j = math.floor(UE_8)
    for n in range(int(i),int(j+1),1):
        if i < UE_10 and i >= SHITA_10:
            print(i)
            break
        i+=1
Buggy code:
A, B = list(map(int, input().split()))
ans = -1
for i in range(1, 1009):
    if int(i*0.08) == A and int(i*0.10) == B:
        ans = i
print(ans)

Fixed code:
A, B = list(map(int, input().split()))
ans = -1
for i in range(1, 1009):
    if int(i*0.08) == A and int(i*0.10) == B:
        ans = i
        break
print(ans)
Buggy code:
A,B=map(int,input().split())
cal,cal2=0,0
ans=[]

for i in range(1200):
    cal=math.floor(i*0.08)
    cal2=math.floor(i*0.1)

    if cal==A and cal2==B:
        ans.append(i)


if len(ans)>0:
    print(min(ans))
else :
    print(-1)


Fixed code:
import math
A,B=map(int,input().split())
cal,cal2=0,0
ans=[]

for i in range(1200):
    cal=math.floor(i*0.08)
    cal2=math.floor(i*0.1)

    if cal==A and cal2==B:
        ans.append(i)


if len(ans)>0:
    print(min(ans))
else :
    print(-1)
Buggy code:
import math

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

#x=A/0.08
#y=B/0.10

ans=1251
#max_y=( int(y) + 10 )%100
for i in range(1,1251):
  v_08 = math.floor(i * 0.08)
  v_10 = math.floor(i * 0.1)
  
  if v_08==A and v_10==B:
    ans=min(ans,i)

print(ans)


Fixed code:
import math

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

#x=A/0.08
#y=B/0.10

ans=9999
#max_y=( int(y) + 10 )%100
for i in range(1,1251):
  v_08 = math.floor(i * 0.08)
  v_10 = math.floor(i * 0.1)
  
  if v_08==A and v_10==B:
    ans=min(ans,i)

print(ans if ans != 9999 else -1)
Buggy code:
a_s=a/1.08
a_t=(a+1)/1.08
b_s=b/1.1
b_t=(b+1)/1.1

a0=int(a_s)
a1=int(a_t)
b0=int(b_s)
b1=int(b_t)


if (a_s-a0)>0:
  a0+=1
if (a_t-a1)<=0:
  a1-=1
if (b_s-b0)>0:
  b0+=1
if (b_t-b1)<=0:
  b1-=1

lista=[i for i in range(a0,a1+1)]
listb=[i for i in range(b0,b1+1)]

ansl=[]
for j in range(len(lista)):
  if lista[j] in listb:
    ansl.append(lista[j])

if not ansl==[]:
  ans=ansl[0]
  print(ans)
else:
  print(-1)

Fixed code:
a,b=map(int,input().split())
a_s=a/0.08
a_t=(a+1)/0.08
b_s=b/0.1
b_t=(b+1)/0.1

a0=int(a_s)
a1=int(a_t)
b0=int(b_s)
b1=int(b_t)


if (a_s-a0)>0:
  a0+=1
if (a_t-a1)<=0:
  a1-=1
if (b_s-b0)>0:
  b0+=1
if (b_t-b1)<=0:
  b1-=1

lista=[i for i in range(a0,a1+1)]
listb=[i for i in range(b0,b1+1)]

ansl=[]
for j in range(len(lista)):
  if lista[j] in listb:
    ansl.append(lista[j])

if not ansl==[]:
  ans=ansl[0]
  print(ans)
else:
  print(-1)
Buggy code:
a, b = map(int, input().split())
for i in range(909,1009):
    if int(i*0.08) == a and int(i*0.1) == b:
        print(int(i))
print("-1")

Fixed code:
a, b = map(int, input().split())
for i in range(1,1009):
    if int(i*0.08) == a and int(i*0.1) == b:
        print(int(i))
        exit()
print("-1")
Buggy code:
import math
A, B = map(float, input().split())
lowerA = math.ceil(A/0.08)
upperA = math.floor((A+1)/0.08)      
lowerB = math.ceil(B/0.1)
upperB = math.floor((B+1)/0.1)
answer = 0
for i in range(lowerA, upperA):
  if (lowerB <= i) and (i <= upperB):
    answer = i
    break
print(answer)
      

Fixed code:
import math
A, B = map(float, input().split())
lowerA = math.ceil(A/0.08)
upperA = math.floor((A+1)/0.08)      
lowerB = math.ceil(B/0.1)
upperB = math.floor((B+1)/0.1)
answer = -1
for i in range(lowerA, upperA):
  if (lowerB <= i) and (i < upperB):
    answer = i
    break
print(answer)
Buggy code:
A,B=map(int,input().split())

for i in range(1009):
    answer_A=i*0.08
    answer_B=i*0.1
    if answer_A==A and answer_B==B:
        answer=i
        break
    else:
        answer=-1

print(answer)

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

for i in range(1009):
    answer_A=int(i*0.08)
    answer_B=int(i*0.1)
    if answer_A==A and answer_B==B:
        answer=i
        break
    else:
        answer=-1

print(answer)
Buggy code:
A,B=map(int,input().split())

for i in range(0,1009):
    ans_a=int(i*0.08)
    ans_b=int(i*0.1)
    if A==ans_a&B==ans_b:
        ans=i
        break
    ans=-1

print(ans)

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

for i in range(0,1009):
    ans_a=int(i*0.08)
    ans_b=int(i*0.1)
    if A==ans_a and B==ans_b:
        ans=i
        break
    ans=-1

print(ans)
Buggy code:
import sys
A,B=map(int,input().split())
for i in range(1,10000):
  if i*0.1==B and i*0.08==A:
    print(i)
    sys.exit()
print(-1)

Fixed code:
import sys
A,B=map(int,input().split())
for i in range(1010):
  if int(i*0.1)==B and int(i*0.08)==A:
    print(i)
    sys.exit()
print(-1)
Buggy code:
import numpy as np

s = np.array(input().split()).astype(int)
# =============================================================================
# if s.find("A") >= 0 and s.find("B") >= 0:
#     print("Yes")
# else:
#     print("No")
# =============================================================================

# =============================================================================
# N,A,B = s
# 
# print(N//(A+B)*A + np.array([N%(A+B),A]).min())
# =============================================================================

A,B = s

eight =  100/8
ten = 100/10
x1 = A*eight
x2 = A*ten
ans = []
ans2 = []
if x1 == x2:
    ans.append(x1)
else:
    for i in range(0,np.array([x1,x2]).max().astype(int)):
        if int(i * 1/eight) == A and int(i * 1/ten) == B:
            ans.append(i)
        ans2.append(i)
if (int)(A * 10/8) != B:
    print(-1)
else:
    print(np.array(ans).min().astype(int))


Fixed code:
import numpy as np

s = np.array(input().split()).astype(int)
# =============================================================================
# if s.find("A") >= 0 and s.find("B") >= 0:
#     print("Yes")
# else:
#     print("No")
# =============================================================================

# =============================================================================
# N,A,B = s
# 
# print(N//(A+B)*A + np.array([N%(A+B),A]).min())
# =============================================================================

A,B = s

eight =  100/8
ten = 100/10
x1 = A*eight
x2 = A*ten
ans = []

for i in np.arange(0,np.array([x1,x2]).max().astype(int) + 100):
    if int(i * 1/eight) == A and int(i * 1/ten) == B:
        ans.append(i)
if len(ans) == 0:
    print(-1)
else:
    print(np.array(ans).min().astype(int))
Buggy code:

import math
import itertools
import statistics
#import numpy as np
import collections
a, b = list(map(int, input().split()))
#print(a/0.08)
price = a//0.08
while math.floor(price*0.08)==a:
    if b==price*0.1//1:
        ans = int(price//1)
        print(ans)
        exit() 
    price += 1

print("-1")


# print(a/0.08*0.1//1)
#print(b/0.1)



Fixed code:
import math
import itertools
import statistics
#import numpy as np
import collections
a, b = list(map(int, input().split()))
#print(a/0.08)
price = math.ceil(a/0.08)
if b==price*0.1//1:
    ans = int(price//1)
    print(ans)
else:
    price += 1
    while math.floor(price*0.08)==a:
        if b==price*0.1//1:
            ans = int(price//1)
            print(ans)
            exit()
        price += 1

    print("-1")


# print(a/0.08*0.1//1)
#print(b/0.1)
Buggy code:
A,B = map(int, input().split())

ans = 0

for i in range(1900):
    if i * 0.08 == A and i* 0.1 == B:
        ans = i
        break
    else:
        ans = -1

print(ans)




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

ans = 0

for i in range(1900):
    if int(i * 0.08) == A and int(i* 0.1) == B:
        ans = i
        break
    else:
        ans = -1

print(ans)
Buggy code:
a, b = map(int, input().split())
num = -1

for i in range(100000):
    if a == math.floor(i*0.08):
        if b == math.floor(i*0.1):
            num = i
            break
print(num)

Fixed code:
a, b = map(int, input().split())
import math
num = -1

for i in range(100000):
    if a == math.floor(i*0.08):
        if b == math.floor(i*0.1):
            num = i
            break
print(int(num))
Buggy code:
import math
a,b=map(int,input().split())
n=math.ceil((a*100)/8)
m=int((a*100)/10)
result=[]
for i in range(m-100,n+100):
    print(i)
    if math.floor(i*0.08)==a and math.floor(i*0.1)==b:
        result.append(i)
if result==[]:
    print(-1)
    exit()
print(min(result))


Fixed code:
import math
a,b=map(int,input().split())
n=math.ceil((a*100)/8)
m=int((a*100)/10)
result=[]
for i in range(m-100,n+100):
    if math.floor(i*0.08)==a and math.floor(i*0.1)==b:
        result.append(i)
if result==[]:
    print(-1)
    exit()
print(min(result))