qyliang/CodeNanoFix huggingface dataset:
Buggy code:
a,b=map(int,input())
if (a+b)%2==0:
  print (a+b)/2
else:
  print('IMPOSSIBLE')


Fixed code:
a,b=map(int,input().split())
if (a+b)%2==0:
    print ((a+b)//2)
else:
    print('IMPOSSIBLE')
Buggy code:
a, b = map(int,input.split())
s = (a + b) //2
if s % 2 == 0:
  print(s)
else:
  print('IMPOSSIBLE')

Fixed code:
a,b=map(int,input().split())
k=a+b
if k%2==0:
        print(k//2)
else:
        print("IMPOSSIBLE")
Buggy code:
#--Harmony

a, b = map(int, input().split())
N = a + b

if (N % 2 == 0):
  print(N/2)
else:
  print("IMPOSSIBLE")
  

Fixed code:
#--Harmony

a, b = map(int, input().split())
N = a + b

if (N % 2 == 0):
  print(int(N/2))
else:
  print("IMPOSSIBLE")
Buggy code:
a,b = map(int,input().split())
if (b-a)%2 == 1:
    print('IMPOSSIBLE')

else:
    print((b-a)/2)


Fixed code:
a,b = map(int,input().split())
if (b-a)%2 == 1:
    print('IMPOSSIBLE')

else:
    print(int((b-a)/2 + a))
Buggy code:
a, b = map(int,input().split())
if a%2 == b%2:
  print((a+b)/2)
else:
  print("IMPOSSIBLE")
    

Fixed code:
a,b = map(int,input().split())
if (a+b) % 2 != 0:
    print("IMPOSSIBLE")
else:
    print(int(((a+b)/2)))
Buggy code:
a,b = map(int,input().split())
if (b-a)%2 == 1:
    print('IMPOSSIBLE')

else:
    print((b-a)/2 + a)


Fixed code:
a, b = map(int,input().split())
if a%2 == b%2:
  print(int((a+b)/2))
else:
  print("IMPOSSIBLE")
Buggy code:
a, b = map(int,input().split())
kk =  (a - b) / 2
if ((a - kk) == (b - kk)) or ((a - kk) == (b + kk)) :
    print(a - kk)
else :
    print('IMPOSSIBLE')


Fixed code:
a, b = map(int,input().split())
kk =  (a - b) // 2
if ((a - kk) == (b - kk)) or ((a - kk) == (b + kk)) :
    print(a - kk)
else :
    print('IMPOSSIBLE')
Buggy code:
a, b = map(int, input().split())

if a % 2 == b % 2:
  print((a + b) / 2)
else:
  print("IMPOSSIBLE")

Fixed code:
a, b = map(int, input().split())
 
if a % 2 == b % 2:
  print((a + b) // 2)
else:
  print("IMPOSSIBLE")
Buggy code:
def main():
    a, b = map(int, input().split(' '))
    s = a + b
    ans = s // 2 if s % 2 == 0 else 'IMPOSSIBE'
    print(ans)

if __name__ == '__main__':
    main()


Fixed code:
def main():
    a, b = map(int, input().split(' '))
    s = a + b
    ans = s // 2 if s % 2 == 0 else 'IMPOSSIBLE'
    print(ans)

if __name__ == '__main__':
    main()
Buggy code:
a,b = map(int,input().split())
s=a+b
if s%2 != 0:
	print("IMPOSSIBLE")
else:
	print(s/2)
	


Fixed code:
a,b = map(int,input().split(" "))
if a%2 != b%2:
  print('IMPOSSIBLE')
else:
  print((a+b)//2)
Buggy code:
a,b=map(int,input().split())
if (a-b)%2==1:
  print('IMPOSSIBLE')
else:
  print(abs(a-b)//2)

Fixed code:
a,b=map(int,input().split())
if (a-b)%2==1:
  print('IMPOSSIBLE')
else:
  print(min(a,b)+abs(a-b)//2)
Buggy code:
q, r = divmod(sum(map(int, input().split())), 2)
print(q if r else 'IMPOSSIBLE')

Fixed code:
q, r = divmod(sum(map(int, input().split())), 2)
print('IMPOSSIBLE' if r else q)
Buggy code:
a, b = map(int, input().split())
if (a + b) % 2:
    print('IMPOSIIBLE')
else:
    print((a + b) // 2)

Fixed code:
a, b = map(int, input().split())
if (a + b) % 2:
    print('IMPOSSIBLE')
else:
    print((a + b) // 2)
Buggy code:
a, b = map(int, input().split())
if (a + b) % 2 == 0:
  n = (a + b) / 2
else:
  n = 'IMPOSSIBLE'
print(n)

Fixed code:
a, b = map(int, input().split())
if (a + b) % 2 == 0:
  print((a + b) // 2)
else:
  print('IMPOSSIBLE')
Buggy code:
N,K = list(map(lambda x: int(x),input().split()))
if (N+K)%2==0:
    print((N+K)/2)
else:
    print("IMPOSSIBLE")


Fixed code:
N,K = list(map(lambda x: int(x),input().split()))
if (N+K)%2==0:
    print(int((N+K)/2))
else:
    print("IMPOSSIBLE")
Buggy code:
A,B=map(int,input().split())

if (A+B)%2==0:
    print((A+B)//2)
else:
    print("INPOSSIBLE")

Fixed code:
A,B = map(int,input().split())
if (A+B)%2==0:
    print((A+B)//2)
else:
    print('IMPOSSIBLE')
Buggy code:
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a,b=INTM()
    if (a+b)%2==!:
        print('IMPOSSIBLE')
    else:
        print((a+B)//2)
if __name__ == '__main__':
    do()

Fixed code:
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a,b=INTM()
    if (a+b)%2==1:
        print('IMPOSSIBLE')
    else:
        print((a+b)//2)
if __name__ == '__main__':
    do()
Buggy code:
a,b = map(int,input().split())
if a+b % 2 == 0:
    print((a+b) /2)
else:
    print("IMPOSSIBLE")

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

if (a + b) % 2 == 0:
    print(int((a+b)/2))
else:
    print("IMPOSSIBLE")
Buggy code:
num = [int(e) for e in input().split()]

a = num[0]
b = num[1]

K =(a+b)/2

if (a-b)%2 != 0:
    print("IMPOSSIBLE")
else:
    print(K)

Fixed code:
num = [int(e) for e in input().split()]

a = num[0]
b = num[1]

K =int((a+b)/2)


if (a-b)%2 != 0:
    print("IMPOSSIBLE")
else:
    print(K)
Buggy code:
#A-Harmony
X=map(int, input().split())
K=(X[0]+X[1])/2
if (X[0]+X[1])%2==0:
    print(K)
else:
    print("IMPOSSIBLE")

Fixed code:
#A-Harmony
X=list(map(int, input().split()))
K=(X[0]+X[1])/2
if (X[0]+X[1])%2==0:
    print(int(K))
else:
    print("IMPOSSIBLE")
Buggy code:
a,b=map(int,input().split())
print((a+b)//2 if (a+b)%2=0 else "IMPOSSIBLE")

Fixed code:
a,b=map(int,input().split())
c=a+b
if(c%2==0):
  print(int(c/2))
else:
  print("IMPOSSIBLE")
Buggy code:
a,b=map(int,input().split());print((a+b)/2 if (a+b)%2==0 else "IMPOSSIBLE")

Fixed code:
a,b=map(int,input().split())
print(int((a+b)/2) if (a+b)/2%1==0 else 'IMPOSSIBLE')
Buggy code:
num = input().split()
if int(num[0])+int(num[1])%2!=0:
  print('IMPOSSIBLE')
else:
  print(int(num[0])+int(num[1])//2)

Fixed code:
num = input().split()
a = int(num[0])%2
b = int(num[1])%2
if a!=b: print('IMPOSSIBLE')
else: print((int(num[0])+int(num[1]))//2)
Buggy code:
a,b = list(map(int,input().split()))
if abs(a-b)%2 == 0:
    print(abs(a-b)%2+min(a,b))
else:
    print("IMPOSSIBLE")

Fixed code:
a,b = list(map(int,input().split()))
if abs(a-b)%2 == 0:
    print(abs(a-b)//2+min(a,b))
else:
    print("IMPOSSIBLE")
Buggy code:
A,B = map(int,input().split())
p = A + B
if p % 2 == 0:
    print(p/2)
else:
    print("IMPOSSIBLE")

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

if (A+B) % 2 == 0:
    print((A+B)//2)
else:
    print("IMPOSSIBLE")
Buggy code:
a,b=map(int,input().split())

if (a+b)%2==0:
  print((a+2)/2)
else:
  print("IMPOSSIBLE")

Fixed code:
a,b = map(int,input().split())
if (a+b)%2:
    print('IMPOSSIBLE')
else:
    print((a+b)//2)
Buggy code:
#!/usr/bin/env python3
# N = int(input())
# S = input()
A, B = map(int, input().split())
# A = list(map(int, input().split()))
if (A + B) % 2 == 0:
    print((A + B)) // 2)
else:
    print("IMPOSSIBLE")

Fixed code:
#!/usr/bin/env python3
# N = int(input())
# S = input()
A, B = map(int, input().split())
# A = list(map(int, input().split()))
if (A + B) % 2 == 0:
    print((A + B) // 2)
else:
    print("IMPOSSIBLE")
Buggy code:
a,b=map(int,input().split())

if (a+b)%2 == 0:
    print((a+b)/2)
else:
    print('IMPOSSIBLE')


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

if (a + b) % 2 == 0:
    print((a + b) // 2)
else:
    print('IMPOSSIBLE')
Buggy code:
a, b = map(int,input().split())
if (a+b)%2 == 0:
  print((a+b)/2)
else:
  print("IMPOSSIBLE")

Fixed code:
a,b = map(int,input().split())
if (a%2) != (b%2):
    print("IMPOSSIBLE")
else:
    print(int(((a+b)/2)))
Buggy code:
a,b = [int(x) for x in input().split()] 
c=(a+b)//2
k=(a+b)/2
if(c==k):
    print(k)
else:
    print("IMPOSSIBLE")


Fixed code:
a,b=[int(x) for x in input().split()] 
c=(a+b)/2
k=(a+b)//2
if(k==c):
  if(abs(a-k)==abs(b-k)):
     print(k)
else:
     print("IMPOSSIBLE")
Buggy code:
a, b = map(int, input().split())
if a + b % 2 == 0:
    print(a + b // 2)
else:
    print("IMPOSSIBLE")


Fixed code:
a,b = map(int,input().split())
if (a+b)%2 == 1:
  print('IMPOSSIBLE')
else:
  print(int((a+b)/2))
Buggy code:
a,b=map(int,input().split())
k=(a+b)/2
if (a+b)%2==0:
    print(k)
else:
    print('IMPOSSIBLE')
    

Fixed code:
a, b = map(int, input().split())
sum = a + b
if sum%2 == 0:
    print(sum//2)
else:
    print("IMPOSSIBLE")
Buggy code:
a,b = map(int,input().split())
ans = (a+b)/2

if ans == int(ans):
  print(ans)
else:
  print('IMPOSSIBLE')

Fixed code:
a,b = map(int,input().split())
ans = (a+b)/2
 
if ans == int(ans):
  print(int(ans))
else:
  print('IMPOSSIBLE')
Buggy code:
A,B=map(int,input().split())
K = (A+B)/2
if K % 2 == 0:
    print(int(K))
else:
    print("IMPOSSIBLE")

Fixed code:
A,B=map(int,input().split())
K = (A+B)/2
if (A+B) % 2 == 0:
    print(int(K))
else:
    print("IMPOSSIBLE")
Buggy code:
def harmony(a, b):

    return "IMPOSSIBLE" if abs(a-b)%2 != 0 else int(abs(a-b)//2)
def main():
    a, b = map(int, input().split())
    print(harmony(a, b))

if __name__ == '__main__':
    main()


Fixed code:
def harmony(a, b):

    return "IMPOSSIBLE" if abs(a-b)%2 != 0 else int(abs(a-b)//2)+min(a,b)
def main():
    a, b = map(int, input().split())
    print(harmony(a, b))

if __name__ == '__main__':
    main()
Buggy code:
A, B= map(int, input().split())
diff_ba = B-A
if diff_ba % 2 == 0:
  print(A + diff_ba)
else:
  print("IMPOSSIBLE")

Fixed code:
A, B= map(int, input().split())
diff_ba = B-A
if diff_ba % 2 == 0:
  print(A + diff_ba//2)
else:
  print("IMPOSSIBLE")
Buggy code:
a, b = tuple(map(int, input().split(' ')))
if (a + b) % 2 == 1:
  print('IMPOSSIBLE')
print((a + b) // 2)

Fixed code:
a, b = tuple(map(int, input().split(' ')))
if (a + b) % 2 == 1:
  print('IMPOSSIBLE')
else:
  print((a + b) // 2)
Buggy code:

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

if ((a+b)/2) % 1 == 0:
    print((a+b)/2)
else:
    "IMPOSSIBLE"


Fixed code:
a,b = map(int,input().split(" "))
mes =""
if (a+b)%2==0:
  mes = int((a+b)/2)
else:
  mes = "IMPOSSIBLE"
print(mes)
Buggy code:
A,B = map(int, input().split())
# R = int(input())
# B = int(input())
# C = int(input())
# b = input()
print((A + B) / 2 if (A + B) % 2 == 0 else "IMPOSSIBLE")

Fixed code:
A,B = map(int, input().split())
# R = int(input())
# B = int(input())
# C = int(input())
# b = input()
print((A + B) // 2 if (A + B) % 2 == 0 else "IMPOSSIBLE")
Buggy code:
A,B = map(int,input().split())
if A >= B:
  K = B + abs(A-B)/2
else:
  K = A +  abs(A-B)/2
if float.is_integer(K) == True:
  print(K)
else:
  print('IMPOSSIBLE')

Fixed code:
A,B = map(int,input().split())
if A >= B:
  K = B + abs(A-B)/2
else:
  K = A +  abs(A-B)/2
if float.is_integer(K) == True:
  print(int(K))
else:
  print('IMPOSSIBLE')
Buggy code:
a, b = map(int, input().split())

if (a+b)%2 != 0:
  print("IMPOSSIBLE")
else:
  print((a+b)/2)


Fixed code:
a,b = map(int,input().split())
if a>b:
    a,b=b,a
if (b+a)%2 != 0:
    print("IMPOSSIBLE")
else:
    print((a+b)//2)
Buggy code:
A,B=map(int(input.split()))

if (A+B)%2==1:
  print("IMPOSSIBLE")
  
else:
  print((A+B)/2)

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

if (A+B)%2==0:
    print((A+B)//2)
else:
    print('IMPOSSIBLE')
Buggy code:
a,b = list(map(int, input().split()))
if (a+b) % 2 == 0:
  print((a+b)/2)
else:
  print("IMPOSSIBLE")

Fixed code:
a,b = list(map(int, input().split()))
if (a+b) % 2 == 0:
  print(int((a+b)/2))
else:
  print("IMPOSSIBLE")
Buggy code:
a,b = map(int,input().split())

if (a+b) % 2 == 0:
  print((a+b)/2)
else:
  print("IMPOSSIBLE")

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

if (a+b) % 2 == 0:
  print(int((a+b)/2))
else:
  print("IMPOSSIBLE")
Buggy code:
a,b=map(int,input().split())
print(("IMPOSSIBLE",(a+b)/2)[(a+b)%2==0])

Fixed code:
a,b=map(int,input().split())
print(("IMPOSSIBLE",(a+b)//2)[(a+b)%2==0])
Buggy code:
a, b = map(int,input().split())

x = abs(a-b)

print(x)

if x % 2 != 0:
    print("IMPOSSIBLE")
    exit()

if a < b:
    print(a + (x // 2))
else:
    print(b + (x // 2))

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

x = abs(a-b)

if x % 2 != 0:
    print("IMPOSSIBLE")
    exit()

if a < b:
    print(a + (x // 2))
else:
    print(b + (x // 2))
Buggy code:
s = list(map(int, input.split()))
A = s[0]
B = s[1]
result = (A + B)
if result % 2 ==0:
    print(result/2)
else:
    print('IMPOSSIBLE')
    

Fixed code:
s = list(map(int, input().split()))
A = s[0]
B = s[1]
result = abs(A - B)
if result % 2 ==0:
    print(int(min(A,B) + result/2))
else:
    print('IMPOSSIBLE')
Buggy code:
a ,b =map(int, input().split())

x = (a + b)/2

if  (a + b)%2 == 0 and abs(a - x) == abs(b - x):
    print(x)

else:
    print("IMPOSSIBLE")

Fixed code:

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

x = (a + b)/2

if (a + b)%2 == 0 and abs(a - x) == abs(b - x):
    print(int(x))

else:
    print("IMPOSSIBLE")
Buggy code:
a,b = map(int,input().split())
if a+b % 2 == 1:
    print('IMPOSSIBLE')
else:
    kotae = (a+b)/2
    print(kotae)


Fixed code:
a,b = map(int,input().split())
if (a+b) % 2 == 0:
    kotae = (a+b) // 2
    print(kotae)
else:
    print('IMPOSSIBLE')
Buggy code:
A, B = map(int, input().split())

if not abs(A - B) % 2 == 0:
    print("impossible")
else:
    print((A + B) // 2)


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

if not abs(A - B) % 2 == 0:
    print("IMPOSSIBLE")
else:
    print((A + B) // 2)
Buggy code:
a, b = (int(i) for i in input().split())
if a+b % 2 == 0:
  print((a+b)//2)
else:
  print('IMPOSSIBLE')

Fixed code:
a, b = (int(i) for i in input().split())
if (a+b) % 2 == 0:
  print((a+b)//2)
else:
  print('IMPOSSIBLE')
Buggy code:
a, b = map(int, input().split())

if a % 2 != b % 2:
    print('IMPOSSIBLE')
else:
    i = (a + b)/2
    print(i)

Fixed code:
a, b = map(int, input().split())
 
if a % 2 != b % 2:
    print('IMPOSSIBLE')
else:
    i = (a + b)//2
    print(i)
Buggy code:
a,b = map(int,input().split())

if ((a+b) / 2) % 2 == 0:
    print((a+b)//2)
else:
    print('IMPOSSIBLE')

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

if (a+b)%2 == 0:
  print((a+b)//2)
else:
  print('IMPOSSIBLE')
Buggy code:
a=list(map(int,input().split()))
if (a[0]+a[1])%2==0:
  	print((a[0]+a[1])/2)
else:
  	print("IMPOSSIBLE")

Fixed code:
a=list(map(int,input().split()))
if (a[0]+a[1])%2==0:
  	print(int((a[0]+a[1])/2))
else:
  	print("IMPOSSIBLE")
Buggy code:
AB = int(input().split())

A = AB[0]
B = AB[1]

if A%2 == 0 and B%2 == 0:
  print((A+B)/2)
  
elif A%2 == 1 and B%2 ==1:
  print((A+B)/1)
  
else:
  print("IMPOSSIBLE")

Fixed code:
AB=input()
AB=AB.split(" ")
A=int(AB[0])
B=int(AB[1])

if((A+B)%2 == 0):
  print(int((A+B)/2))
else:
  print("IMPOSSIBLE")
Buggy code:
a, b = map(int, input().split())

if ((a - b) / 2 ) % 2 == 0:
    print((a + b) / 2 )
else:
    print("IMPOSSIBLE")

Fixed code:
a, b = map(int, input().split(" "))
print((a + b) // 2) if (a + b) % 2 == 0 else print("IMPOSSIBLE")
Buggy code:
AB = list(map(int, input().split()))
 
A = int(AB[0])
B = int(AB[1])
 
if A%2 == 0 and B%2 == 0:
    print((A+B)/2)
elif A%2 == 1 and B%2 == 1:
    print((A+B)/1)
else:
    print("IMPOSSIBLE")

Fixed code:
AB = list(map(int, input().split()))
 
A = int(AB[0])
B = int(AB[1])
 
if A%2 == 0 and B%2 == 0:
    print(int((A+B)/2))
elif A%2 == 1 and B%2 == 1:
    print(int((A+B)/2))
else:
    print("IMPOSSIBLE")
Buggy code:
A,B = map(int,input().split())
if (abs(A-B)/2) % 1 != 0:
	print('IMPOSSIBLE')
else:
	print(int(abs(A-B)/2))

Fixed code:
A,B = map(int,input().split())
if (abs(A-B)/2) % 1 != 0:
	print('IMPOSSIBLE')
else:
	print(int(min(A,B)+abs(A-B)/2))
Buggy code:
a, b = map(int, input().split())

if ((a - b) / 2 ) % 2 == 0:
    print((a - b) / 2 )
else:
    print("IMPOSSIBLE")

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

if (a+b) % 2 == 0:
    print((a+b)//2)
else:
    print("IMPOSSIBLE")
Buggy code:
A, B = map(int,input().split())
if (A+B) % 2 == 0:
    K = (A+B)/2
    print(K)
else:
    print('IMPOSSIBLE')

Fixed code:
A, B = map(int, input().split())
if (A + B) % 2:
    print("IMPOSSIBLE")
else:
    print((A + B) // 2)
Buggy code:
a,b = map(int,input().split())

if (a+b%2) == 0:
  print(int(a+b/2))
else:
  print("IMPOSSIBLE")

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

if (a+b)%2==1:
    print('IMPOSSIBLE')
else:
    print((a+b)//2)
Buggy code:
lis=list(map(int,input().split())
a=lis[0]+lis[1]
if a%2==0:
    print(int(a/2))
else:
    print("IMPOSSIBLE")


Fixed code:
lis=list(map(int,input().split()))
a=lis[0]+lis[1]
if a%2==0:
    print(int(a/2))
else:
    print("IMPOSSIBLE")
Buggy code:
a, b = map(int, input().split())

if a > b:
    c = b
    b = a
    a = c
    
if (b - a) % 2 == 1:
    print(IMPOSSIBLE)
else:
    print((b + a) // 2)

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

if a > b:
    c = b
    b = a
    a = c
    
if (b - a) % 2 == 1:
    print('IMPOSSIBLE')
else:
    print((b + a) // 2)
Buggy code:
A, B = map(int, input().split())
K = (A + B) / 2
if K % 2 == 0:
  print(K)
else:
  print("IMPOSSIBLE")

Fixed code:
A, B = map(int, input().split())
K = A + B
if K % 2 == 0:
  print(K // 2)
else:
  print("IMPOSSIBLE")
Buggy code:
a, b = map(int, raw_input().split())
if (a + b) % 2 == 0:
	print((a + b) // 2)
else:
	print("IMPOSSIBLE") 

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

if (a + b) % 2 == 0:
    print((a+b)//2) 
else:
    print('IMPOSSIBLE')
Buggy code:
A, B = (int(x) for x in input().split())
K = 0
K = (A+B)/2
if K == int(K):
  print((A+B)//2)
else:
  print(IMPOSSIBLE)

Fixed code:
A, B = (int(x) for x in input().split())
K = 0
K = (A+B)/2
if K == int(K):
  print((A+B)//2)
else:
  print("IMPOSSIBLE")
Buggy code:
a,b=map(int,input().split())

if (a+b) % 2 == 0:
  print((a + b)/2)
  
else:
  print("IMPOSSIBLE")

Fixed code:
a,b=map(int,input().split())
s = int((a+b)/2)
u = (a+b)%2

if u == 0:
  print(s)
  
else: 
  print("IMPOSSIBLE")
Buggy code:
A, B = map(int, input().split())
print((A+B)//2 if (A+B)% == 0 else "IMPOSSIBLE")

Fixed code:
A, B = map(int, input().split())
if((A+B) % 2 != 0):
    print('IMPOSSIBLE')
else:
    print((A+B)//2)
Buggy code:
# -*- coding: utf-8 -*-

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

ans = ((B-A/2)+A)
if isinstance(int, ans):
    print(ans)
else:
    print("IMPOSSIBLE")

Fixed code:
# -*- coding: utf-8 -*-

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

ans = (((B-A)/2)+A)
if ans.is_integer():
    print(int(ans))
else:
    print("IMPOSSIBLE")
Buggy code:
a,b = map(int,input().split())
m = a - b
if m % 2 == 1:
  print('IMPOSSIBLE')
else:
  print(abs(m//2))

Fixed code:
a,b=map(int,input().split())
if abs(b-a)%2==1:
  print('IMPOSSIBLE')
else:
  print((b+a)//2)
Buggy code:
a, b = map(int, input().split())
v = (a + b) // 2
if abs(a - v) == abs(b - v)
    print(v)
else:
    print('IMPOSSIBLE')


Fixed code:
a, b = map(int, input().split())
v = (a + b) // 2
if abs(a - v) == abs(b - v):
    print(v)
else:
    print('IMPOSSIBLE')
Buggy code:
A,B = map(int, input().split())

if (A+B)%0 :
	print((A+B)/2)
else :
	print('IMPOSSIBLE')

Fixed code:
A,B = map(int, input().split())
ans = int(A + B) / 2
if ((A + B) % 2 == 0):
    print(int((A + B) / 2))
else:
    print('IMPOSSIBLE')
Buggy code:
a, b = [int(e) for e in input().split()]
if (a+b)%2==0:
    return int((a+b)/2)
else:
    return 'IMPOSSIBLE'

Fixed code:
a, b = [int(e) for e in input().split()]
if (a+b)%2==0:
    print(int((a+b)/2))
else:
    print('IMPOSSIBLE')
Buggy code:
A,B = map(int,input().split())
c = B**2-A**2
if c % 2== 1:
  print('IMPOSSIBLE')
else:
  print(c/(2*(B-A)))

Fixed code:
A,B = map(int,input().split())
c = B**2-A**2
if c % 2== 1:
  print('IMPOSSIBLE')
else:
  print(int(c/(2*(B-A))))
Buggy code:
a, b = map(int,input().split())
x = a + b
if x % 2 == 0:
    print(s / 2)
else:
    print('IMPOSSIBLE')

Fixed code:
a, b = map(int,input().split())
if (a + b) % 2 == 0:
    print((a+b)//2)
else:
    print("IMPOSSIBLE")
Buggy code:
A, B = map(int, input().split())
print((A+B)/2 if (A+B)%2 == 0 else 'IMPOSSIBLE')

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

print((A + B) // 2 if (A + B) % 2 == 0 else 'IMPOSSIBLE')
Buggy code:
a=input().split(" ")
A=int(a[0])
B=int(a[1])
answer=(A+B)/2
if (A+B)%2==0 :
    print(answer)
else:
    print("IMPOSSIBLE")


Fixed code:
a=input().split(" ")
A=int(a[0])
B=int(a[1])
answer=int((A+B)/2)
if (A+B)%2==0 :
    print(answer)
else:
    print("IMPOSSIBLE")
Buggy code:
a, b = map(int, input().split())
c = abs(a - b)
if c % 2 == 0:
    print(c // 2)
else:
    print("IMPOSSIBLE")


Fixed code:
a, b = map(int, input().split())
c = abs(a - b)
if c % 2 == 0:
    print(c // 2 + min((a, b)))
else:
    print("IMPOSSIBLE")
Buggy code:
A,B=map(int,input().split())
K=(A+B)/2
if (A+B)%2==0:
    print(K)
else: print("IMPOSSIBLE")
    

Fixed code:
A, B = map(int, input().split())
if (A + B)%2 == 0:
    print((A + B) // 2)
else:
    print("IMPOSSIBLE")
Buggy code:
A, B = (int(x) for x in input().split())
K = (A + B) / 2
if A == B:
  print(0)
else:
  if isinstance(K, int):
    print(K)
  else:
    print('IMPOSSIBLE')

Fixed code:
A, B = (int(x) for x in input().split())
K = (A + B) / 2
if A == B:
  print(0)
else:
  if K.is_integer():
    print(int(K))
  else:
    print('IMPOSSIBLE')
Buggy code:
A, B = map(int, input().split())
K = (A + B) / 2
if K / 2 == K // 2:
  print(K)
else:
  print('IMPOSSIBLE')

Fixed code:
A, B = map(int, input().split())
K = (A + B) / 2
L = (A + B) // 2
if K.is_integer():
  print(L)
else:
  print('IMPOSSIBLE')
Buggy code:
a, b = map(int, input().split())

if (a+b) % 2 != 0:
  print('IMPOSSIBLE')
else:
  print((a+b)/2)


Fixed code:
a, b = map(int, input().split())
if (a + b) % 2 == 0:
  print(int((a + b) / 2))
else:
  print('IMPOSSIBLE')
Buggy code:
A , B = map( int , input() . split() )

w = ( A + B )

if w % 2 == 0:
    print( w / 2 )
else:
    print('IMPOSSIBLE')

Fixed code:
A,B = map(int,input().split())
k =int((A+B)/2) 
if  (A+B) % 2 == 0:
    print(k)
else:
    print("IMPOSSIBLE")
Buggy code:
"""
author : halo2halo
date : 10, Jan, 2020
"""

import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buf"""
author : halo2halo
date : 11, Jan, 2020
"""

import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

N, M = map(int, read().split())
S = N + M

print(S // 2 if S % 2 == 0 else 'IMPOSSIBLE')
fer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

N, M = map(int, read().split())
S = N + M

print(S // 2 if S % 2 == 0 else 'IMPOSSIBLE')


Fixed code:
"""
author : halo2halo
date : 10, Jan, 2020
"""

import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

N, M = map(int, read().split())
S = N + M

print(S // 2 if S % 2 == 0 else 'IMPOSSIBLE')
Buggy code:
a,b=map(int, input().split())


if (a + b) % 2 === 0:
  print((a + b) // 2)
else:
  print("IMPOSSIBLE")

Fixed code:
a,b = map(int,input().split())
if (a-b) % 2 == 0:
    print((a+b)//2)
else:
    print("IMPOSSIBLE")
Buggy code:
a,b=map(int, input().split())

c = a + b

if c % 2 == 0:
  print(c)
else:
  print('IMPOSSIBLE')
  

Fixed code:
a,b=map(int,input().split())
if (a+b)%2==0:
  print(int((a+b)/2))
else:
  print('IMPOSSIBLE')
Buggy code:
A,B=map(int,input().split())

if (A+B)%2==0:
    print((A+B)/2)
else:
    print('IMPOSSIBLE')

Fixed code:
A, B = map(int,input().split())
if (A+B) % 2 == 0:
    print((A+B)//2)
else:
    print('IMPOSSIBLE')
Buggy code:
a, b = sorted(map(int, input().split()))

if (b-a)%2==0:
    print(int((b-a)/2))
else:
    print('IMPOSSIBLE')

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

if (b-a)%2==0:
    print(int((b+a)/2))
else:
    print('IMPOSSIBLE')
Buggy code:
A, B = map(int, input())
K = int((A+B)//2)
if abs(A-K) == abs(B-K):
  print(K)
else:
  print('IMPOSSIBLE')

Fixed code:
A, B = map(int, input().split())
K = int((A+B)//2)
if abs(A-K) == abs(B-K):
  print(K)
else:
  print('IMPOSSIBLE')
Buggy code:
input1 = input()

num = input1.split(' ')

num1 = int(num[0])
num2 = int(num[1])

total = num1 + num2

if total%2 == 0:
	print('IMPOSSIBLE')
else:
	print(total/2)

Fixed code:
input1 = input()
 
num = input1.split()
 
num1 = int(num[0])
num2 = int(num[1])
 
total = num1 + num2
 
if total%2 != 0:
	print('IMPOSSIBLE')
else:
	print(int(total/2))